1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
#include "partners_api/locals_api.hpp"
#include "platform/http_client.hpp"
#include "platform/platform.hpp"
#include "platform/preferred_languages.hpp"
#include "coding/string_utf8_multilang.hpp"
#include "base/logging.hpp"
#include "base/string_utils.hpp"
#include "defines.hpp"
#include "3party/jansson/myjansson.hpp"
#include "private.h"
namespace
{
using namespace locals;
void ParseError(std::string const & src, int & errorCode, std::string & message)
{
message.clear();
errorCode = 0;
base::Json root(src.c_str());
FromJSONObject(root.get(), "code", errorCode);
FromJSONObject(root.get(), "message", message);
}
void ParseLocals(std::string const & src, std::vector<LocalExpert> & locals,
bool & hasPrevious, bool & hasNext)
{
locals.clear();
base::Json root(src.c_str());
auto previousField = base::GetJSONOptionalField(root.get(), "previous");
auto nextField = base::GetJSONOptionalField(root.get(), "next");
hasPrevious = json_is_number(previousField);
hasNext = json_is_number(nextField);
auto const results = json_object_get(root.get(), "results");
auto const dataSize = json_array_size(results);
for (size_t i = 0; i < dataSize; ++i)
{
LocalExpert local;
auto const item = json_array_get(results, i);
FromJSONObject(item, "id", local.m_id);
FromJSONObject(item, "motto", local.m_motto);
FromJSONObject(item, "link", local.m_pageUrl);
FromJSONObject(item, "photo", local.m_photoUrl);
FromJSONObject(item, "name", local.m_name);
FromJSONObject(item, "country", local.m_country);
FromJSONObject(item, "city", local.m_city);
FromJSONObject(item, "rating", local.m_rating);
FromJSONObject(item, "reviews", local.m_reviewCount);
FromJSONObject(item, "price_per_hour", local.m_pricePerHour);
FromJSONObject(item, "currency", local.m_currency);
FromJSONObject(item, "about_me", local.m_aboutExpert);
FromJSONObject(item, "i_will_show_you", local.m_offerDescription);
// Rescale rating to (0.0; 10.0] range. Rating 0.0 is invalid.
if (local.m_rating != kInvalidRatingValue)
local.m_rating *= 2.0;
locals.push_back(std::move(local));
}
}
} // namespace
namespace locals
{
bool RawApi::Get(double lat, double lon, std::string const & lang, size_t resultsOnPage, size_t pageNumber,
std::string & result)
{
result.clear();
std::ostringstream ostream;
ostream << LOCALS_API_URL << "/search?api_key=" << LOCALS_API_KEY
<< "&lat=" << lat << "&lon=" << lon
<< "&limit=" << resultsOnPage << "&page=" << pageNumber;
if (!lang.empty())
ostream << "&lang=" << lang;
platform::HttpClient request(ostream.str());
request.SetHttpMethod("GET");
request.SetRawHeader("User-Agent", GetPlatform().GetAppUserAgent());
if (request.RunHttpRequest())
{
result = request.ServerResponse();
if (request.ErrorCode() == 200)
return true;
}
return false;
}
std::string Api::GetLocalsPageUrl()
{
return LOCALS_PAGE_URL;
}
uint64_t Api::GetLocals(double lat, double lon, std::string const & lang,
size_t resultsOnPage, size_t pageNumber,
LocalsSuccessCallback const & successFn,
LocalsErrorCallback const & errorFn)
{
uint64_t id = ++m_requestId;
GetPlatform().RunTask(Platform::Thread::Network,
[id, lat, lon, lang, resultsOnPage, pageNumber, successFn, errorFn]()
{
std::string result;
if (!RawApi::Get(lat, lon, lang, resultsOnPage, pageNumber, result))
{
try
{
int errorCode;
std::string errorMessage;
ParseError(result, errorCode, errorMessage);
LOG(LWARNING, ("Locals request failed:", errorCode, errorMessage));
return errorFn(id, errorCode, errorMessage);
}
catch (base::Json::Exception const & e)
{
LOG(LWARNING, ("Unknown error:", e.Msg(), ", response:", result));
return errorFn(id, kUnknownErrorCode, "Unknown error: " + e.Msg());
}
}
std::vector<LocalExpert> locals;
bool hasPreviousPage = false;
bool hasNextPage = false;
try
{
ParseLocals(result, locals, hasPreviousPage, hasNextPage);
}
catch (base::Json::Exception const & e)
{
LOG(LWARNING, ("Locals response parsing failed:", e.Msg(), ", response:", result));
errorFn(id, kUnknownErrorCode, "Response parsing failed: " + e.Msg());
}
successFn(id, locals, pageNumber, resultsOnPage, hasPreviousPage, hasNextPage);
});
return id;
}
std::string DebugPrint(LocalExpert const & localExpert)
{
std::ostringstream out;
out << "id: " << localExpert.m_id << std::endl
<< "name: " << localExpert.m_name << std::endl
<< "about: " << localExpert.m_aboutExpert << std::endl
<< "city: " << localExpert.m_city << std::endl
<< "country: " << localExpert.m_country << std::endl
<< "currency: " << localExpert.m_currency << std::endl
<< "pageUrl: " << localExpert.m_pageUrl << std::endl
<< "photoUrl: " << localExpert.m_photoUrl << std::endl
<< "description: " << localExpert.m_offerDescription << std::endl
<< "motto: " << localExpert.m_motto << std::endl;
return out.str();
}
} // namespace locals
|
