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
160
161
162
163
164
165
166
167
168
|
#pragma once
#include "search/city_finder.hpp"
#include "map/discovery/discovery_client_params.hpp"
#include "map/discovery/discovery_search_params.hpp"
#include "map/search_api.hpp"
#include "partners_api/booking_api.hpp"
#include "partners_api/locals_api.hpp"
#include "partners_api/viator_api.hpp"
#include "platform/marketing_service.hpp"
#include "platform/platform.hpp"
#include "geometry/point2d.hpp"
#include "geometry/rect2d.hpp"
#include "base/thread_checker.hpp"
#include <functional>
#include <string>
#include <utility>
#include <vector>
class DataSourceBase;
namespace discovery
{
class Manager final
{
public:
struct APIs
{
APIs(SearchAPI & search, viator::Api const & viator, locals::Api & locals)
: m_search(search), m_viator(viator), m_locals(locals)
{
}
SearchAPI & m_search;
viator::Api const & m_viator;
locals::Api & m_locals;
};
struct Params
{
std::string m_curency;
std::string m_lang;
size_t m_itemsCount = 0;
m2::PointD m_viewportCenter;
m2::RectD m_viewport;
ItemTypes m_itemTypes;
};
using ErrorCalback = std::function<void(uint32_t const requestId, ItemType const type)>;
Manager(DataSourceBase const & dataSource, search::CityFinder & cityFinder, APIs const & apis);
template <typename ResultCallback>
uint32_t Discover(Params && params, ResultCallback const & onResult, ErrorCalback const & onError)
{
GetPlatform().GetMarketingService().SendPushWooshTag(marketing::kDiscoveryButtonDiscovered);
uint32_t const requestId = ++m_requestCounter;
CHECK_THREAD_CHECKER(m_threadChecker, ());
auto const & types = params.m_itemTypes;
ASSERT(!types.empty(), ("Types must contain at least one element."));
for (auto const type : types)
{
switch (type)
{
case ItemType::Viator:
{
std::string const sponsoredId = GetCityViatorId(params.m_viewportCenter);
if (sponsoredId.empty())
{
GetPlatform().RunTask(Platform::Thread::Gui,
[requestId, onResult] {
onResult(requestId, std::vector<viator::Product>());
});
break;
}
if (m_cachedViator.first == sponsoredId)
{
GetPlatform().RunTask(Platform::Thread::Gui, [this, requestId, onResult] {
onResult(requestId, m_cachedViator.second);
});
break;
}
m_viatorApi.GetTop5Products(
sponsoredId, params.m_curency,
[this, requestId, sponsoredId, onResult, onError](std::string const & destId,
std::vector<viator::Product> const & products) {
CHECK_THREAD_CHECKER(m_threadChecker, ());
if (destId == sponsoredId)
{
if (products.empty())
{
onError(requestId, ItemType::Viator);
return;
}
m_cachedViator = std::make_pair(sponsoredId, products);
onResult(requestId, products);
}
});
break;
}
case ItemType::Attractions: // fallthrough
case ItemType::Cafes:
case ItemType::Hotels:
{
auto p = GetSearchParams(params, type);
auto const viewportCenter = params.m_viewportCenter;
p.m_onResults = [requestId, onResult, type, viewportCenter](search::Results const & results) {
GetPlatform().RunTask(Platform::Thread::Gui,
[requestId, onResult, type, results, viewportCenter] {
onResult(requestId, results, type, viewportCenter);
});
};
m_searchApi.SearchForDiscovery(p);
break;
}
case ItemType::LocalExperts:
{
auto const latLon = MercatorBounds::ToLatLon(params.m_viewportCenter);
auto constexpr pageNumber = 1;
m_localsApi.GetLocals(
latLon.lat, latLon.lon, params.m_lang, params.m_itemsCount, pageNumber,
[this, requestId, onResult](uint64_t id, std::vector<locals::LocalExpert> const & locals,
size_t /* pageNumber */, size_t /* countPerPage */,
bool /* hasPreviousPage */, bool /* hasNextPage */) {
CHECK_THREAD_CHECKER(m_threadChecker, ());
onResult(requestId, locals);
},
[this, requestId, onError, type](uint64_t id, int errorCode, std::string const & errorMessage) {
CHECK_THREAD_CHECKER(m_threadChecker, ());
onError(requestId, type);
});
break;
}
}
}
return requestId;
}
std::string GetViatorUrl(m2::PointD const & point) const;
std::string GetLocalExpertsUrl(m2::PointD const & point) const;
private:
static search::DiscoverySearchParams GetSearchParams(Manager::Params const & params, ItemType const type);
std::string GetCityViatorId(m2::PointD const & point) const;
DataSourceBase const & m_dataSource;
search::CityFinder & m_cityFinder;
SearchAPI & m_searchApi;
viator::Api const & m_viatorApi;
locals::Api & m_localsApi;
uint32_t m_requestCounter = 0;
ThreadChecker m_threadChecker;
// We save last succeed viator result for the nearest city and rewrite it when the nearest city
// was changed.
std::pair<std::string, std::vector<viator::Product>> m_cachedViator;
};
} // namespace discovery
|
