From d38f2a554e342b93d24df743295b28e974ce4aaa Mon Sep 17 00:00:00 2001 From: Arsentiy Milchakov Date: Thu, 13 Sep 2018 19:19:39 +0300 Subject: [PATCH] [partners_api] rutaxi --- data/taxi_places/maxim.json | 44 +- data/taxi_places/osm_to_rutaxi.json | 532 ++++++++++++++++++ data/taxi_places/rutaxi.json | 122 ++++ data/taxi_places/uber.json | 6 - data/taxi_places/yandex.json | 472 ++++++++++++---- partners_api/CMakeLists.txt | 3 + partners_api/maxim_api.cpp | 6 +- .../partners_api_tests/CMakeLists.txt | 1 + .../partners_api_tests/rutaxi_tests.cpp | 125 ++++ .../partners_api_tests/taxi_engine_tests.cpp | 99 +++- partners_api/rutaxi_api.cpp | 282 ++++++++++ partners_api/rutaxi_api.hpp | 81 +++ partners_api/taxi_delegate.hpp | 20 + partners_api/taxi_engine.cpp | 19 +- partners_api/taxi_engine.hpp | 15 +- partners_api/taxi_places_loader.cpp | 1 + partners_api/taxi_provider.hpp | 2 + .../partners_api.xcodeproj/project.pbxproj | 12 + 18 files changed, 1677 insertions(+), 165 deletions(-) create mode 100644 data/taxi_places/osm_to_rutaxi.json create mode 100644 data/taxi_places/rutaxi.json create mode 100644 partners_api/partners_api_tests/rutaxi_tests.cpp create mode 100644 partners_api/rutaxi_api.cpp create mode 100644 partners_api/rutaxi_api.hpp create mode 100644 partners_api/taxi_delegate.hpp diff --git a/data/taxi_places/maxim.json b/data/taxi_places/maxim.json index 5792029925..88acbbc3de 100644 --- a/data/taxi_places/maxim.json +++ b/data/taxi_places/maxim.json @@ -3,34 +3,50 @@ "countries": [ { "id": "Azerbaijan Region", - "cities": [ "Baku" ] + "cities": [ "Baku", "Ganja", "Mingachevir", "Sumgayit" ] }, { "id": "Belarus", - "cities": [ "Baranovichi", "Mahilyow" ] + "cities": [ "Baranovichi", "Mahilyow", "Brest", "Vitebsk", "Hrodna" ] }, { "id": "Bulgaria", - "cities": [ "Varna", "Plovdiv", "Sofia" ] + "cities": [ "Sofia" ] }, { "id": "Georgia Region", - "cities": [ "Batumi", "Gori", "Zugdidi", "Kutaisi", "Poti" ] + "cities": [ "Batumi", "Gori", "Zugdidi", "Kutaisi", "Poti", "Rustavi", "Tbilisi" ] + }, + { + "id": "Chile", + "cities": [ "Concepcion", "Santiago" ] + }, + { + "id": "Indonesia", + "cities": [ "Denpasar", "Jakarta" ] + }, + { + "id": "Italy", + "cities": [ "Milan" ] }, { "id": "Kazakhstan", - "cities": [ "Kokshetau", "Semey", "Temirtau", "Oskemen" ] + "cities": [ "Aktobe", "Kostanay", "Semipalatinsk", "Temirtau", "Oskemen", "Oral" ] + }, + { + "id": "Malaysia", + "cities": [ "Kuala Lumpur" ] + }, + { + "id": "Tajikistan", + "cities": [ "Dushanbe", "Khujand" ] + }, + { + "id": "Ukraine", + "cities": [ "Zhytomyr", "Kremenchuk", "Mariupol", "Poltava", "Sumy", "Kharkiv", "Cherkasy", "Chernihiv" ] } ], - "mwms": [ - "Belarus_Brest Region", - "Belarus_Vitebsk Region", - "Ukraine_Poltava Oblast", - "Ukraine_Donetsk Oblast", - "Ukraine_Sumy Oblast", - "Ukraine_Cherkasy Oblast", - "Ukraine_Chernihiv Oblast" - ] + "mwms": [] }, "disabled": { "countries": [], diff --git a/data/taxi_places/osm_to_rutaxi.json b/data/taxi_places/osm_to_rutaxi.json new file mode 100644 index 0000000000..815758abb4 --- /dev/null +++ b/data/taxi_places/osm_to_rutaxi.json @@ -0,0 +1,532 @@ +[ + { + "osm": "Abakan", + "rutaxi": "abakan", + "currency": "RUB" + }, + { + "osm": "Aleksin", + "rutaxi": "aleksin", + "currency": "RUB" + }, + { + "osm": "Almaty", + "rutaxi": "almaty", + "currency": "KZT" + }, + { + "osm": "Angarsk", + "rutaxi": "angarsk", + "currency": "RUB" + }, + { + "osm": "Astana", + "rutaxi": "astana", + "currency": "KZT" + }, + { + "osm": "Astrakhan", + "rutaxi": "astrakhan", + "currency": "RUB" + }, + { + "osm": "Barnaul", + "rutaxi": "barnaul", + "currency": "RUB" + }, + { + "osm": "Berezniki", + "rutaxi": "berezniki", + "currency": "RUB" + }, + { + "osm": "Blagoveshchensk", + "rutaxi": "blagoveshchensk", + "currency": "RUB" + }, + { + "osm": "Bryansk", + "rutaxi": "bryansk", + "currency": "RUB" + }, + { + "osm": "Veliky Novgorod", + "rutaxi": "vnovgorod", + "currency": "RUB" + }, + { + "osm": "Vladivostok", + "rutaxi": "vladivostok", + "currency": "RUB" + }, + { + "osm": "Vladimir", + "rutaxi": "vladimir", + "currency": "RUB" + }, + { + "osm": "Volgograd", + "rutaxi": "volgograd", + "currency": "RUB" + }, + { + "osm": "Volzhsky", + "rutaxi": "volzhskiy", + "currency": "RUB" + }, + { + "osm": "Vologda", + "rutaxi": "vologda", + "currency": "RUB" + }, + { + "osm": "Voronezh", + "rutaxi": "voronezh", + "currency": "RUB" + }, + { + "osm": "Votkinsk", + "rutaxi": "votkinsk", + "currency": "RUB" + }, + { + "osm": "Gatchina", + "rutaxi": "gatchina", + "currency": "RUB" + }, + { + "osm": "Dzerzhinsk", + "rutaxi": "dzerjinsk", + "currency": "RUB" + }, + { + "osm": "Dimitrovgrad", + "rutaxi": "dmgrad", + "currency": "RUB" + }, + { + "osm": "Donskoj", + "rutaxi": "domodedovo", + "currency": "RUB" + }, + { + "osm": "Yekaterinburg", + "rutaxi": "ekt", + "currency": "RUB" + }, + { + "osm": "Zhigulyovsk", + "rutaxi": "zhigulevsk", + "currency": "RUB" + }, + { + "osm": "Zlatoust", + "rutaxi": "zlatoust", + "currency": "RUB" + }, + { + "osm": "Ivanovo", + "rutaxi": "ivanovo", + "currency": "RUB" + }, + { + "osm": "Izhevsk", + "rutaxi": "izhevsk", + "currency": "RUB" + }, + { + "osm": "Irkutsk", + "rutaxi": "irkutsk", + "currency": "RUB" + }, + { + "osm": "Yoshkar-Ola", + "rutaxi": "yoshkarola", + "currency": "RUB" + }, + { + "osm": "Kazan", + "rutaxi": "kazan", + "currency": "RUB" + }, + { + "osm": "Kaliningrad", + "rutaxi": "kaliningrad", + "currency": "RUB" + }, + { + "osm": "Kaluga", + "rutaxi": "kaluga", + "currency": "RUB" + }, + { + "osm": "Karaganda", + "rutaxi": "karaganda", + "currency": "KZT" + }, + { + "osm": "Kemerovo", + "rutaxi": "kemerovo", + "currency": "RUB" + }, + { + "osm": "Kirov", + "rutaxi": "kirov", + "currency": "RUB" + }, + { + "osm": "Kozelsk", + "rutaxi": "kozelsk", + "currency": "RUB" + }, + { + "osm": "Kondrovo", + "rutaxi": "kondrovo", + "currency": "RUB" + }, + { + "osm": "Kostroma", + "rutaxi": "kostroma", + "currency": "RUB" + }, + { + "osm": "Krasnodar", + "rutaxi": "krasnodar", + "currency": "RUB" + }, + { + "osm": "Krasnoyarsk", + "rutaxi": "krasnoyarsk", + "currency": "RUB" + }, + { + "osm": "Kungur", + "rutaxi": "kungur", + "currency": "RUB" + }, + { + "osm": "Kyzyl", + "rutaxi": "kyzyl", + "currency": "RUB" + }, + { + "osm": "Lipetsk", + "rutaxi": "lipeck", + "currency": "RUB" + }, + { + "osm": "Lysva", + "rutaxi": "lisva", + "currency": "RUB" + }, + { + "osm": "Lyudinovo", + "rutaxi": "lyudinovo", + "currency": "RUB" + }, + { + "osm": "Magnitogorsk", + "rutaxi": "magnitogorsk", + "currency": "RUB" + }, + { + "osm": "Miass", + "rutaxi": "miass", + "currency": "RUB" + }, + { + "osm": "Minusinsk", + "rutaxi": "minus", + "currency": "RUB" + }, + { + "osm": "Moscow", + "rutaxi": "moscow", + "currency": "RUB" + }, + { + "osm": "Murmansk", + "rutaxi": "murmansk", + "currency": "RUB" + }, + { + "osm": "Naberezhnye Chelny", + "rutaxi": "nabchelny", + "currency": "RUB" + }, + { + "osm": "Nizhny Novgorod", + "rutaxi": "nnovgorod", + "currency": "RUB" + }, + { + "osm": "Nizhny Tagil", + "rutaxi": "ntagil", + "currency": "RUB" + }, + { + "osm": "Novoaltaysk", + "rutaxi": "novoaltaisk", + "currency": "RUB" + }, + { + "osm": "Novokuznetsk", + "rutaxi": "novokuznetsk", + "currency": "RUB" + }, + { + "osm": "Novokuybyshevsk", + "rutaxi": "novokuib", + "currency": "RUB" + }, + { + "osm": "Novomoskovsk", + "rutaxi": "novomoskovsk", + "currency": "RUB" + }, + { + "osm": "Novorossiysk", + "rutaxi": "novoross", + "currency": "RUB" + }, + { + "osm": "Novosibirsk", + "rutaxi": "novosibirsk", + "currency": "RUB" + }, + { + "osm": "Novocherkassk", + "rutaxi": "novochek", + "currency": "RUB" + }, + { + "osm": "Obninsk", + "rutaxi": "obninsk", + "currency": "RUB" + }, + { + "osm": "Oktyabrskiy", + "rutaxi": "oktiabrsky", + "currency": "RUB" + }, + { + "osm": "Omsk", + "rutaxi": "omsk", + "currency": "RUB" + }, + { + "osm": "Orenburg", + "rutaxi": "orenburg", + "currency": "RUB" + }, + { + "osm": "Orsk", + "rutaxi": "orsk", + "currency": "RUB" + }, + { + "osm": "Penza", + "rutaxi": "penza", + "currency": "RUB" + }, + { + "osm": "Pervouralsk", + "rutaxi": "pervouralsk", + "currency": "RUB" + }, + { + "osm": "Perm", + "rutaxi": "perm", + "currency": "RUB" + }, + { + "osm": "Petrozavodsk", + "rutaxi": "ptz", + "currency": "RUB" + }, + { + "osm": "Pskov", + "rutaxi": "pskov", + "currency": "RUB" + }, + { + "osm": "Rostov-on-Don", + "rutaxi": "rostov", + "currency": "RUB" + }, + { + "osm": "Ryazan", + "rutaxi": "ryazan", + "currency": "RUB" + }, + { + "osm": "Salavat", + "rutaxi": "salavat", + "currency": "RUB" + }, + { + "osm": "Samara", + "rutaxi": "samara", + "currency": "RUB" + }, + { + "osm": "Saint Petersburg", + "rutaxi": "spb", + "currency": "RUB" + }, + { + "osm": "Saransk", + "rutaxi": "saransk", + "currency": "RUB" + }, + { + "osm": "Saratov", + "rutaxi": "saratov", + "currency": "RUB" + }, + { + "osm": "Sayanogorsk", + "rutaxi": "sayan", + "currency": "RUB" + }, + { + "osm": "Serpukhov", + "rutaxi": "serpuhov", + "currency": "RUB" + }, + { + "osm": "Smolensk", + "rutaxi": "smolensk", + "currency": "RUB" + }, + { + "osm": "Solikamsk", + "rutaxi": "solikamsk", + "currency": "RUB" + }, + { + "osm": "Sochi", + "rutaxi": "sochi", + "currency": "RUB" + }, + { + "osm": "Sterlitamak", + "rutaxi": "sterl", + "currency": "RUB" + }, + { + "osm": "Syzran", + "rutaxi": "syzran", + "currency": "RUB" + }, + { + "osm": "Syktyvkar", + "rutaxi": "syktyvkar", + "currency": "RUB" + }, + { + "osm": "Taganrog", + "rutaxi": "taganrog", + "currency": "RUB" + }, + { + "osm": "Tambov", + "rutaxi": "tambov", + "currency": "RUB" + }, + { + "osm": "Tver", + "rutaxi": "tver", + "currency": "RUB" + }, + { + "osm": "Togliatti", + "rutaxi": "tolyatti", + "currency": "RUB" + }, + { + "osm": "Tomsk", + "rutaxi": "tomsk", + "currency": "RUB" + }, + { + "osm": "Tyumen", + "rutaxi": "tyumen", + "currency": "RUB" + }, + { + "osm": "Ulan-Ude", + "rutaxi": "ulan-ude", + "currency": "RUB" + }, + { + "osm": "Ulyanovsk", + "rutaxi": "ulyanovsk", + "currency": "RUB" + }, + { + "osm": "Ufa", + "rutaxi": "ufa", + "currency": "RUB" + }, + { + "osm": "Khabarovsk", + "rutaxi": "habarovsk", + "currency": "RUB" + }, + { + "osm": "Chaikovsky", + "rutaxi": "chaykovskiy", + "currency": "RUB" + }, + { + "osm": "Chapaevsk", + "rutaxi": "chapaevsk", + "currency": "RUB" + }, + { + "osm": "Cheboksary", + "rutaxi": "cheboksary", + "currency": "RUB" + }, + { + "osm": "Chelyabinsk", + "rutaxi": "chel", + "currency": "RUB" + }, + { + "osm": "Cherepovets", + "rutaxi": "cherepovec", + "currency": "RUB" + }, + { + "osm": "Chernogorsk", + "rutaxi": "chernogorsk", + "currency": "RUB" + }, + { + "osm": "Chita", + "rutaxi": "chita", + "currency": "RUB" + }, + { + "osm": "Chusovoy", + "rutaxi": "chus", + "currency": "RUB" + }, + { + "osm": "Shakhty", + "rutaxi": "shakhty", + "currency": "RUB" + }, + { + "osm": "Engels", + "rutaxi": "engels", + "currency": "RUB" + }, + { + "osm": "Yaroslavl", + "rutaxi": "yaroslavl", + "currency": "RUB" + } +] \ No newline at end of file diff --git a/data/taxi_places/rutaxi.json b/data/taxi_places/rutaxi.json new file mode 100644 index 0000000000..ecd0fdd8d9 --- /dev/null +++ b/data/taxi_places/rutaxi.json @@ -0,0 +1,122 @@ +{ + "enabled": { + "countries": [ + { + "id": "Russian Federation", + "cities": [ + "Abakan", + "Aleksin", + "Almaty", + "Angarsk", + "Astana", + "Astrakhan", + "Barnaul", + "Berezniki", + "Blagoveshchensk", + "Bryansk", + "Veliky Novgorod", + "Vladivostok", + "Vladimir", + "Volgograd", + "Volzhsky", + "Vologda", + "Voronezh", + "Votkinsk", + "Gatchina", + "Dzerzhinsk", + "Dimitrovgrad", + "Donskoj", + "Yekaterinburg", + "Zhigulyovsk", + "Zlatoust", + "Ivanovo", + "Izhevsk", + "Irkutsk", + "Yoshkar-Ola", + "Kazan", + "Kaliningrad", + "Kaluga", + "Karaganda", + "Kemerovo", + "Kirov", + "Kirov", + "Kozelsk", + "Kondrovo", + "Kostroma", + "Krasnodar", + "Krasnoyarsk", + "Kungur", + "Kyzyl", + "Lipetsk", + "Lysva", + "Lyudinovo", + "Magnitogorsk", + "Miass", + "Minusinsk", + "Moscow", + "Murmansk", + "Naberezhnye Chelny", + "Nizhny Novgorod", + "Nizhny Tagil", + "Novoaltaysk", + "Novokuznetsk", + "Novokuybyshevsk", + "Novomoskovsk", + "Novorossiysk", + "Novosibirsk", + "Novocherkassk", + "Obninsk", + "Oktyabrskiy", + "Omsk", + "Orenburg", + "Orsk", + "Penza", + "Pervouralsk", + "Perm", + "Petrozavodsk", + "Pskov", + "Rostov-on-Don", + "Ryazan", + "Salavat", + "Samara", + "Saint Petersburg", + "Saransk", + "Saratov", + "Sayanogorsk", + "Serpukhov", + "Smolensk", + "Solikamsk", + "Sochi", + "Sterlitamak", + "Syzran", + "Syktyvkar", + "Taganrog", + "Tambov", + "Tver", + "Togliatti", + "Tomsk", + "Tyumen", + "Ulan-Ude", + "Ulyanovsk", + "Ufa", + "Khabarovsk", + "Chaikovsky", + "Chapaevsk", + "Cheboksary", + "Chelyabinsk", + "Cherepovets", + "Chernogorsk", + "Chita", + "Chusovoy", + "Shakhty", + "Engels" + ] + } + ], + "mwms": [] + }, + "disabled": { + "countries": [], + "mwms": [] + } +} \ No newline at end of file diff --git a/data/taxi_places/uber.json b/data/taxi_places/uber.json index eb24a70edb..c5f9f20e06 100644 --- a/data/taxi_places/uber.json +++ b/data/taxi_places/uber.json @@ -11,7 +11,6 @@ {"id": "Brazil","cities": []}, {"id": "Cambodia","cities": []}, {"id": "Canada","cities": []}, - {"id": "Chile","cities": []}, {"id": "People's Republic of China","cities": []}, {"id": "Colombia","cities": []}, {"id": "Costa Rica","cities": []}, @@ -22,7 +21,6 @@ {"id": "Ecuador","cities": []}, {"id": "Egypt","cities": []}, {"id": "El Salvador","cities": []}, - {"id": "Estonia","cities": []}, {"id": "Finland","cities": []}, {"id": "France","cities": []}, {"id": "Germany","cities": []}, @@ -31,17 +29,13 @@ {"id": "Guatemala","cities": []}, {"id": "Hungary","cities": []}, {"id": "India","cities": []}, - {"id": "Indonesia","cities": []}, {"id": "Ireland","cities": []}, {"id": "Israel Region","cities": []}, - {"id": "Italy","cities": []}, {"id": "Japan","cities": []}, {"id": "Jordan","cities": []}, {"id": "Kenya","cities": []}, {"id": "South Korea","cities": []}, {"id": "Lebanon","cities": []}, - {"id": "Lithuania","cities": []}, - {"id": "Malaysia","cities": []}, {"id": "Mexico","cities": []}, {"id": "Morocco","cities": []}, {"id": "Myanmar","cities": []}, diff --git a/data/taxi_places/yandex.json b/data/taxi_places/yandex.json index 43c0769195..e6305491fd 100644 --- a/data/taxi_places/yandex.json +++ b/data/taxi_places/yandex.json @@ -2,130 +2,382 @@ "enabled": { "countries": [ { - "id": "Georgia Region", + "id": "Armenia", "cities": [ - "Rustavi", - "Tbilisi" + "Artashat", + "Vanadzor", + "Goris", + "Gyumri", + "Yerevan", + "Kapan", + "Hrazdan" + ] + }, + { + "id": "Belarus", + "cities": [ + "Homel", + "Minsk", + "Rechytsa" ] }, { "id": "Kazakhstan", "cities": [ "Aktau", - "Aktobe", - "Almaty", - "Astana", "Atyrau", - "Karaganda", - "Kostanay", + "Zhezkazgan", + "Kokshetau", "Kyzylorda", "Pavlodar", - "Petropavlovsk", + "Taldykorgan", "Taraz", - "Turkestan", - "Oral", - "Ust-Kamenogorsk", - "Shymkent" + "Shymkent", + "Ekibastuz" + ] + }, + { + "id": "Kyrgyzstan", + "cities": [ + "Bishkek", + "Osh" + ] + }, + { + "id": "Latvia", + "cities": [ + "Riga" + ] + }, + { + "id": "Lithuania", + "cities": [ + "Vilnius" + ] + }, + { + "id": "Moldova", + "cities": [ + "Kishinev" + ] + }, + { + "id": "Ukraine", + "cities": [ + "Kyiv", + "Odessa" + ] + }, + { + "id": "Serbia", + "cities": [ + "Belgrade" + ] + }, + { + "id": "Uzbekistan", + "cities": [ + "Tashkent" + ] + }, + { + "id": "Estonia", + "cities": [ + "Tallinn" + ] + }, + { + "id": "Russian Federation", + "cities": [ + "Adler", + "Adygeysk", + "Aznakayevo", + "Azov", + "Akademgorodok", + "Alapaevsk", + "Alatyr", + "Alekseevka", + "Almetyevsk", + "Anapa", + "Andzhero-Sudzhensk", + "Arzamas", + "Armavir", + "Artyom", + "Arkhangelsk", + "Asbest", + "Achinsk", + "Baksan", + "Balabanovo", + "Balakovo", + "Balashov", + "Belgorod", + "Belebei", + "Belogorsk", + "Belokurikha", + "Beloozyorsky", + "Belorechensk", + "Berdsk", + "Biysk", + "Birobidzhan", + "Birsk", + "Bologoe", + "Borisoglebsk", + "Borovichi", + "Bratsk", + "Bronnitsy", + "Bryukhovetskaya", + "Bugulma", + "Budyonnovsk", + "Buzuluk", + "Buturlinovka", + "Valuyki", + "Verkhneyarkeevo", + "Verkhnyaya Salda", + "Vladikavkaz", + "Volgodonsk", + "Volzhsk", + "Volsk", + "Voskresensk", + "Vsevolozhsk", + "Vyborg", + "Vyksa", + "Vyazniki", + "Vyazma", + "Vyatskiye Polyany", + "Gagarin", + "Gelendzhik", + "Georgiyevsk", + "Glazov", + "Gorno-Altaysk", + "Goryachiy Klyuch", + "Grozny", + "Gusev", + "Gus-Khrustalny", + "Derbent", + "Dinskaya", + "Dmitrov", + "Dobryanka", + "Dolgoderevenskoye", + "Dubna", + "Dyurtyuli", + "Yegoryevsk", + "Yeysk", + "Yelabuga", + "Yelets", + "Ershov", + "Yessentuki", + "Yefremov", + "Zheleznogorsk", + "Zavitinsk", + "Zaraysk", + "Zvenigorod", + "Zelenogorsk", + "Zelenogradsk", + "Zelenodolsk", + "Zelenokumsk", + "Iskitim", + "Istra", + "Ishimbay", + "Kamenka", + "Kamensk-Uralsky", + "Kamensk-Shakhtinsky", + "Kamyshin", + "Kanash", + "Karasuk", + "Kasimov", + "Kaspiysk", + "Katchkanar", + "Kashira", + "Kizilyurt", + "Kingisepp", + "Kineshma", + "Kirovo-Chepetsk", + "Kirovsk", + "Kislovodsk", + "Klin", + "Klintsy", + "Kovrov", + "Kogalym", + "Kolomna", + "Kolpino", + "Kolchugino", + "Komsomolsk-on-Amur", + "Korenovsk", + "Korsakov", + "Kotlas", + "Krasnyy Sulin", + "Krestzy", + "Kronstadt", + "Kropotkin", + "Krymsk", + "Kubinka", + "Kudymkar", + "Kuznetsk", + "Kumertau", + "Kurgan", + "Kurganinsk", + "Kurovskoye", + "Kurortny District", + "Kursk", + "Kurchatov", + "Kushchovskaya", + "Labinsk", + "Leninogorsk", + "Livny", + "Likino-Dulyovo", + "Liski", + "Lomonosov", + "Losino-Petrovsky", + "Luga", + "Lukhovitsy", + "Lyantor", + "Magadan", + "Magas", + "Maykop", + "Maloyaroslavets", + "Matveyev Kurgan", + "Makhachkala", + "Mednogorsk", + "Meleuz", + "Mineralnye Vody", + "Mitchurinsk", + "Mozhaisk", + "Mozhga", + "Mozdok", + "Monino", + "Murom", + "Nadym", + "Nalchik", + "Naro-Fominsk", + "Nartkala", + "Nakhodka", + "Nevinnomyssk", + "Neftegorsk", + "Neftekamsk", + "Neftekumsk", + "Nefteyugansk", + "Nizhnevartovsk", + "Nizhnekamsk", + "Nikolskoye", + "Novovoronezh", + "Novozybkov", + "Novotroitsk", + "Novouralsk", + "Novy Urengoy", + "Noginsk", + "Norilsk", + "Noyabrsk", + "Nurlat", + "Ozersk", + "Ozyory", + "Oktyabrsk", + "Oryol", + "Orekhovo-Zuyevo", + "Osa", + "Ostrogozhsk", + "Otradnoe", + "Pavlovsk", + "Pavlovsky Posad", + "Peterhof", + "Petropavlovsk-Kamchatsky", + "Podporozhye", + "Pokhvistnevo", + "Pravdinskiy", + "Prokopyevsk", + "Protvino", + "Prokhladny", + "Pushkin", + "Pyatigorsk", + "Rasskazovo", + "Revda", + "Roslavl", + "Rossosh", + "Rubtsovsk", + "Ruzaevka", + "Rybinsk", + "Saraktash", + "Sarapul", + "Sarov", + "Sasovo", + "Satka", + "Svetlograd", + "Severodvinsk", + "Seversk", + "Semikarakorsk", + "Sergiyev Posad", + "Serdobsk", + "Sertolovo", + "Sestroretsk", + "Sibay", + "Slavgorod", + "Slavyansk-na-Kubani", + "Slobodskoy", + "Sovetskiy", + "Solnechnogorsk", + "Solnechnodolsk", + "Sosnoviy Bor", + "Sofrino", + "Stavropol", + "Stary Oskol", + "Strezhevoi", + "Stupino", + "Sudzha", + "Suzdal", + "Surgut", + "Tara", + "Teykovo", + "Temryuk", + "Timashewsk", + "Tikhvin", + "Tikhoretsk", + "Tobolsk", + "Toksova", + "Tosno", + "Troitsk", + "Trubchevsk", + "Tuapse", + "Tuymazy", + "Tula", + "Tuchkovo", + "Tynda", + "Uglich", + "Ussurijsk", + "Ust-Labinsk", + "Ukhta", + "Khanty-Mansiysk", + "Khasavyurt", + "Khorol", + "Khotkovo", + "Tsyvilsk", + "Chebarkul", + "Chegem", + "Cheremkhovo", + "Cherkessk", + "Chernogolovka", + "Chernushka", + "Chernyakhovsk", + "Chekhov", + "Chistopol", + "Shadrinsk", + "Sharya", + "Shatura", + "Shumerlya", + "Elektrogorsk", + "Elektrostal", + "Elista", + "Yugorsk", + "Yuzhno-Sakhalinsk", + "Yuzhnouralsk", + "Yurga", + "Yakutsk", + "Yarovoe", + "Yaroslavl", + "Yartsevo", + "Yakhroma" ] } ], - "mwms": [ - "Armenia", - "Belarus_Homiel Region", - "Belarus_Minsk Region", - "Kyrgyzstan", - "Latvia", - "Moldova", - "Russia_Altai Krai", - "Russia_Amur Oblast", - "Russia_Arkhangelsk Oblast_Central", - "Russia_Arkhangelsk Oblast_North", - "Russia_Astrakhan Oblast", - "Russia_Bashkortostan", - "Russia_Belgorod Oblast", - "Russia_Bryansk Oblast", - "Russia_Buryatia", - "Russia_Vladimir Oblast", - "Russia_Volgograd Oblast", - "Russia_Vologda Oblast", - "Russia_Voronezh Oblast", - "Russia_Republic of Dagestan", - "Russia_Zabaykalsky Krai", - "Russia_Ivanovo Oblast", - "Russia_Irkutsk Oblast", - "Russia_Kabardino-Balkaria", - "Russia_Kaliningrad Oblast", - "Russia_Kaluga Oblast", - "Russia_Karachay-Cherkessia", - "Russia_Republic of Karelia_North", - "Russia_Republic of Karelia_South", - "Russia_Kemerov Oblast", - "Russia_Kirov Oblast", - "Russia_Komi Republic", - "Russia_Kostroma Oblast", - "Russia_Krasnodar Krai", - "Russia_Krasnoyarsk Krai_North", - "Russia_Krasnoyarsk Krai_South", - "Russia_Kurgan Oblast", - "Russia_Kursk Oblast", - "Russia_Leningradskaya Oblast_Karelsky", - "Russia_Leningradskaya Oblast_Southeast", - "Russia_Lipetsk Oblast", - "Russia_Magadan Oblast", - "Russia_Mari El", - "Russia_Republic of Mordovia", - "Russia_Moscow", - "Russia_Moscow Oblast_East", - "Russia_Moscow Oblast_West", - "Russia_Murmansk Oblast", - "Russia_Nizhny Novgorod Oblast", - "Russia_Novgorod Oblast", - "Russia_Novosibirsk Oblast", - "Russia_Omsk Oblast", - "Russia_Orenburg Oblast", - "Russia_Oryol Oblast", - "Russia_Penza Oblast", - "Russia_Perm Krai_North", - "Russia_Perm Krai_South", - "Russia_Primorsky Krai", - "Russia_Pskov Oblast", - "Russia_Krasnodar Krai_Adygeya", - "Russia_Ingushetia", - "Russia_Republic of Kalmykia", - "Russia_Tuva", - "Russia_Khakassia", - "Russia_Rostov Oblast", - "Russia_Ryazan Oblast", - "Russia_Samara Oblast", - "Russia_Saint Petersburg", - "Russia_Saratov Oblast", - "Russia_Sakha Republic", - "Russia_Sakhalin Oblast", - "Russia_Sverdlovsk Oblast_Ekaterinburg", - "Russia_Sverdlovsk Oblast_North", - "Russia_North Ossetia-Alania", - "Russia_Smolensk Oblast", - "Russia_Stavropol Krai", - "Russia_Tambov Oblast", - "Russia_Tatarstan", - "Russia_Tver Oblast", - "Russia_Tomsk Oblast", - "Russia_Tula Oblast", - "Russia_Tyumen Oblast", - "Russia_Udmurt Republic", - "Russia_Ulyanovsk Oblast", - "Russia_Khabarovsk Krai", - "Russia_Yugra_Khanty", - "Russia_Chelyabinsk Oblast", - "Russia_Chuvashia", - "Russia_Yamalo-Nenets Autonomous Okrug", - "Russia_Yaroslavl Oblast", - "Ukraine_Dnipropetrovsk Oblast", - "Ukraine_Kyiv Oblast", - "Ukraine_Lviv Oblast", - "Ukraine_Odessa Oblast", - "Ukraine_Kharkiv Oblast" - ] + "mwms": [] }, "disabled": { "countries": [], diff --git a/partners_api/CMakeLists.txt b/partners_api/CMakeLists.txt index d7f0e3f53a..35bbc0e901 100644 --- a/partners_api/CMakeLists.txt +++ b/partners_api/CMakeLists.txt @@ -34,8 +34,11 @@ set( partners.hpp rb_ads.cpp rb_ads.hpp + rutaxi_api.cpp + rutaxi_api.hpp taxi_base.cpp taxi_base.hpp + taxi_delegate.hpp taxi_engine.cpp taxi_engine.hpp taxi_places.cpp diff --git a/partners_api/maxim_api.cpp b/partners_api/maxim_api.cpp index dc9c426d13..ec7e05f2c1 100644 --- a/partners_api/maxim_api.cpp +++ b/partners_api/maxim_api.cpp @@ -104,11 +104,9 @@ RideRequestLinks Api::GetRideRequestLinks(std::string const & productId, ms::Lat << "&endLongitude=" << to.lon; #if defined(OMIM_OS_IPHONE) - installLink << "https://itunes.apple.com/app/apple-store/id579985456?pt=119057982" - << "&ct=maps_me&mt=8"; + installLink << "https://app.appsflyer.com/id579985456?pid=maps_me"; #elif defined(OMIM_OS_ANDROID) - installLink << "https://play.google.com/store/apps/details?id=com.taxsee.taxsee" - << "&referrer=utm_source%3Dmaps_me"; + installLink << "https://app.appsflyer.com/com.taxsee.taxsee?pid=maps_me"; #endif return {"maximzakaz://" + orderLink.str(), installLink.str()}; diff --git a/partners_api/partners_api_tests/CMakeLists.txt b/partners_api/partners_api_tests/CMakeLists.txt index caea8e4f7d..ce96642991 100644 --- a/partners_api/partners_api_tests/CMakeLists.txt +++ b/partners_api/partners_api_tests/CMakeLists.txt @@ -12,6 +12,7 @@ set( megafon_countries_tests.cpp mopub_tests.cpp rb_tests.cpp + rutaxi_tests.cpp taxi_engine_tests.cpp taxi_places_tests.cpp uber_tests.cpp diff --git a/partners_api/partners_api_tests/rutaxi_tests.cpp b/partners_api/partners_api_tests/rutaxi_tests.cpp new file mode 100644 index 0000000000..3a7dcdc8ad --- /dev/null +++ b/partners_api/partners_api_tests/rutaxi_tests.cpp @@ -0,0 +1,125 @@ +#include "testing/testing.hpp" + +#include "partners_api/rutaxi_api.hpp" + +#include "platform/platform.hpp" + +#include "geometry/latlon.hpp" + +#include + +namespace +{ +class DelegateForTesting : public taxi::Delegate +{ +public: + storage::TCountriesVec GetCountryIds(m2::PointD const & point) override { return {""}; } + std::string GetCityName(m2::PointD const & point) override { return ""; } + storage::TCountryId GetMwmId(m2::PointD const & point) override { return ""; } +}; + +using Runner = Platform::ThreadRunner; + +auto const kNearObject = R"( +{ + "success": true, + "time": "2018-09-07 16:20:52", + "data": { + "objects": [ + { + "id": "467", + "house": "6ст3", + "name": "Булатниковский проезд", + "metatype": 0 + } + ], + "status": 220 + } +})"; + +UNIT_TEST(RuTaxi_GetNearObject) +{ + ms::LatLon pos(55.592522, 37.653501); + std::string result; + taxi::rutaxi::RawApi::GetNearObject(pos, "moscow", result); + TEST(!result.empty(), ()); + LOG(LINFO, (result)); + + my::Json root(result.c_str()); + + TEST(json_is_object(root.get()), ()); + + bool success = false; + FromJSONObject(root.get(), "success", success); + + TEST(success, ()); +} + +UNIT_TEST(RuTaxi_GetCost) +{ + taxi::rutaxi::Object from = {"3440", "2"}; + taxi::rutaxi::Object to = {"467", "6ст3"}; + std::string result; + taxi::rutaxi::RawApi::GetCost(from, to, "moscow", result); + TEST(!result.empty(), ()); + LOG(LINFO, (result)); + + my::Json root(result.c_str()); + + TEST(json_is_object(root.get()), ()); + + bool success = false; + FromJSONObject(root.get(), "success", success); + + TEST(success, ()); +} + +UNIT_TEST(RuTaxi_MakeNearObject) +{ + taxi::rutaxi::Object dst; + taxi::rutaxi::MakeNearObject(kNearObject, dst); + TEST_EQUAL(dst.m_id, "467", ()); + TEST_EQUAL(dst.m_house, "6ст3", ()); +} + +UNIT_TEST(RuTaxi_MakeProducts) +{ + auto const src = R"( + { + "success": true, + "time": "2018-09-07 16:20:53", + "data": { + "cost": "1005", + "status": 220 + } + })"; + + taxi::rutaxi::Object from; + taxi::rutaxi::MakeNearObject(kNearObject, from); + taxi::rutaxi::Object to; + taxi::rutaxi::MakeNearObject(kNearObject, to); + taxi::rutaxi::City city = {"moscow", "RUB"}; + + std::vector dst; + taxi::rutaxi::MakeProducts(src, from, to, city, dst); + TEST_EQUAL(dst.size(), 1, ()); + TEST_EQUAL(dst[0].m_price, "1005", ()); + TEST_EQUAL(dst[0].m_currency, "RUB", ()); + + TEST(!dst[0].m_productId.empty(), ()); + TEST(!dst[0].m_time.empty(), ()); + TEST(dst[0].m_name.empty(), ()); +} + +UNIT_TEST(RuTaxi_LoadCityMapping) +{ + auto const mapping = taxi::rutaxi::LoadCityMapping(); + TEST(!mapping.empty(), ()); + + for (auto const & item : mapping) + { + TEST(!item.second.m_id.empty(), ()); + TEST(!item.second.m_currency.empty(), ()); + } +} +} // namespace \ No newline at end of file diff --git a/partners_api/partners_api_tests/taxi_engine_tests.cpp b/partners_api/partners_api_tests/taxi_engine_tests.cpp index 3e3f1ba884..a704423b5e 100644 --- a/partners_api/partners_api_tests/taxi_engine_tests.cpp +++ b/partners_api/partners_api_tests/taxi_engine_tests.cpp @@ -1,6 +1,7 @@ #include "testing/testing.hpp" #include "partners_api/maxim_api.hpp" +#include "partners_api/rutaxi_api.hpp" #include "partners_api/taxi_engine.hpp" #include "partners_api/uber_api.hpp" #include "partners_api/yandex_api.hpp" @@ -10,6 +11,7 @@ #include "platform/gui_thread.hpp" #include "geometry/latlon.hpp" +#include "geometry/mercator.hpp" #include "base/scope_guard.hpp" #include "base/worker_thread.hpp" @@ -86,6 +88,18 @@ public: storage::TCountryId GetMwmId(m2::PointD const & point) override { return {}; } }; +class RussiaSochiDelegate : public taxi::Delegate +{ +public: + storage::TCountriesVec GetCountryIds(m2::PointD const & point) override + { + return {"Russian Federation"}; + } + + std::string GetCityName(m2::PointD const & point) override { return "Sochi"; } + storage::TCountryId GetMwmId(m2::PointD const & point) override { return {}; } +}; + std::vector GetUberSynchronous(ms::LatLon const & from, ms::LatLon const & to, std::string const & url) { @@ -135,9 +149,32 @@ std::vector GetMaximSynchronous(ms::LatLon const & from, ms::LatL return maximProducts; } +std::vector GetRutaxiSynchronous(ms::LatLon const & from, ms::LatLon const & to, + taxi::Delegate & delegate, std::string const & url) +{ + auto const city = delegate.GetCityName(MercatorBounds::FromLatLon(from)); + + std::string fromHttpResult; + TEST(taxi::rutaxi::RawApi::GetNearObject(from, city, fromHttpResult, url), ()); + taxi::rutaxi::Object fromObj; + taxi::rutaxi::MakeNearObject(fromHttpResult, fromObj); + + std::string toHttpResult; + TEST(taxi::rutaxi::RawApi::GetNearObject(to, city, toHttpResult, url), ()); + taxi::rutaxi::Object toObj; + taxi::rutaxi::MakeNearObject(toHttpResult, toObj); + + std::string costHttpResult; + TEST(taxi::rutaxi::RawApi::GetCost(fromObj, toObj, city, costHttpResult, url), ()); + std::vector rutaxiProducts; + taxi::rutaxi::MakeProducts(costHttpResult, fromObj, toObj, {city, "UFO"}, rutaxiProducts); + + return rutaxiProducts; +} + taxi::ProvidersContainer GetProvidersSynchronous(taxi::Engine const & engine, ms::LatLon const & from, ms::LatLon const & to, - std::string const & url) + taxi::Delegate & delegate, std::string const & url) { taxi::ProvidersContainer providers; @@ -154,6 +191,10 @@ taxi::ProvidersContainer GetProvidersSynchronous(taxi::Engine const & engine, case taxi::Provider::Type::Maxim: providers.emplace_back(taxi::Provider::Type::Maxim, GetMaximSynchronous(from, to, url)); break; + case taxi::Provider::Type::Rutaxi: + providers.emplace_back(taxi::Provider::Type::Rutaxi, + GetRutaxiSynchronous(from, to, delegate, url)); + break; case taxi::Provider::Type::Count: LOG(LERROR, ()); break; @@ -247,8 +288,8 @@ UNIT_CLASS_TEST(AsyncGuiThread, TaxiEngine_ResultMaker) TEST(false, ("errorNotPossibleCallback", requestId, errors)); }; - // Try to image what products1, products2 and products3 are lists of products for different taxi - // providers. Only product id is important for us, all other fields are empty. + // Try to image what products1, products2, products3 and products4 are lists of products for + // different taxi providers. Only product id is important for us, all other fields are empty. std::vector products1 = { {"1", "", "", "", ""}, @@ -268,27 +309,35 @@ UNIT_CLASS_TEST(AsyncGuiThread, TaxiEngine_ResultMaker) {"7", "", "", "", ""}, }; - maker.Reset(reqId, 3, successCallback, errorNotPossibleCallback); - maker.ProcessProducts(reqId, taxi::Provider::Type::Uber, products1); - maker.ProcessProducts(reqId, taxi::Provider::Type::Yandex, products2); - maker.ProcessProducts(reqId, taxi::Provider::Type::Maxim, products3); - - TEST(providers.empty(), ()); - TEST(errors.empty(), ()); + std::vector products4 = + { + {"8", "", "", "", ""}, + }; maker.Reset(reqId, 4, successCallback, errorNotPossibleCallback); maker.ProcessProducts(reqId, taxi::Provider::Type::Uber, products1); maker.ProcessProducts(reqId, taxi::Provider::Type::Yandex, products2); maker.ProcessProducts(reqId, taxi::Provider::Type::Maxim, products3); + maker.ProcessProducts(reqId, taxi::Provider::Type::Rutaxi, products3); + + TEST(providers.empty(), ()); + TEST(errors.empty(), ()); + + maker.Reset(reqId, 5, successCallback, errorNotPossibleCallback); + maker.ProcessProducts(reqId, taxi::Provider::Type::Uber, products1); + maker.ProcessProducts(reqId, taxi::Provider::Type::Yandex, products2); + maker.ProcessProducts(reqId, taxi::Provider::Type::Maxim, products3); + maker.ProcessProducts(reqId, taxi::Provider::Type::Rutaxi, products4); maker.DecrementRequestCount(reqId); maker.MakeResult(reqId); testing::Wait(); - TEST_EQUAL(providers.size(), 3, ()); + TEST_EQUAL(providers.size(), 4, ()); TEST_EQUAL(providers[0].GetType(), taxi::Provider::Type::Uber, ()); TEST_EQUAL(providers[1].GetType(), taxi::Provider::Type::Yandex, ()); TEST_EQUAL(providers[2].GetType(), taxi::Provider::Type::Maxim, ()); + TEST_EQUAL(providers[3].GetType(), taxi::Provider::Type::Rutaxi, ()); TEST_EQUAL(providers[0][0].m_productId, "1", ()); TEST_EQUAL(providers[0][1].m_productId, "2", ()); TEST_EQUAL(providers[0][2].m_productId, "3", ()); @@ -296,11 +345,13 @@ UNIT_CLASS_TEST(AsyncGuiThread, TaxiEngine_ResultMaker) TEST_EQUAL(providers[1][1].m_productId, "5", ()); TEST_EQUAL(providers[1][2].m_productId, "6", ()); TEST_EQUAL(providers[2][0].m_productId, "7", ()); + TEST_EQUAL(providers[3][0].m_productId, "8", ()); - maker.Reset(reqId, 3, successCallback, errorNotPossibleCallback); + maker.Reset(reqId, 4, successCallback, errorNotPossibleCallback); maker.ProcessError(reqId, taxi::Provider::Type::Uber, taxi::ErrorCode::NoProducts); maker.ProcessProducts(reqId, taxi::Provider::Type::Yandex, products2); maker.ProcessProducts(reqId, taxi::Provider::Type::Maxim, products3); + maker.ProcessError(reqId, taxi::Provider::Type::Rutaxi, taxi::ErrorCode::NoProducts); maker.MakeResult(reqId); testing::Wait(); @@ -313,37 +364,42 @@ UNIT_CLASS_TEST(AsyncGuiThread, TaxiEngine_ResultMaker) TEST_EQUAL(providers[0][2].m_productId, "6", ()); TEST_EQUAL(providers[1][0].m_productId, "7", ()); - maker.Reset(reqId, 3, successCallback, errorNotPossibleCallback); + maker.Reset(reqId, 4, successCallback, errorNotPossibleCallback); maker.ProcessProducts(reqId, taxi::Provider::Type::Uber, products1); maker.ProcessError(reqId, taxi::Provider::Type::Yandex, taxi::ErrorCode::NoProducts); maker.ProcessProducts(reqId, taxi::Provider::Type::Maxim, products3); + maker.ProcessProducts(reqId, taxi::Provider::Type::Rutaxi, products4); maker.MakeResult(reqId); testing::Wait(); - TEST_EQUAL(providers.size(), 2, ()); + TEST_EQUAL(providers.size(), 3, ()); TEST_EQUAL(providers[0].GetType(), taxi::Provider::Type::Uber, ()); TEST_EQUAL(providers[1].GetType(), taxi::Provider::Type::Maxim, ()); TEST_EQUAL(providers[0][0].m_productId, "1", ()); TEST_EQUAL(providers[0][1].m_productId, "2", ()); TEST_EQUAL(providers[0][2].m_productId, "3", ()); TEST_EQUAL(providers[1][0].m_productId, "7", ()); + TEST_EQUAL(providers[2][0].m_productId, "8", ()); - maker.Reset(reqId, 3, successNotPossibleCallback, errorCallback); + maker.Reset(reqId, 4, successNotPossibleCallback, errorCallback); maker.ProcessError(reqId, taxi::Provider::Type::Uber, taxi::ErrorCode::NoProducts); maker.ProcessError(reqId, taxi::Provider::Type::Yandex, taxi::ErrorCode::RemoteError); maker.ProcessError(reqId, taxi::Provider::Type::Maxim, taxi::ErrorCode::NoProducts); + maker.ProcessError(reqId, taxi::Provider::Type::Rutaxi, taxi::ErrorCode::RemoteError); maker.MakeResult(reqId); testing::Wait(); - TEST_EQUAL(errors.size(), 3, ()); + TEST_EQUAL(errors.size(), 4, ()); TEST_EQUAL(errors[0].m_type, taxi::Provider::Type::Uber, ()); TEST_EQUAL(errors[0].m_code, taxi::ErrorCode::NoProducts, ()); TEST_EQUAL(errors[1].m_type, taxi::Provider::Type::Yandex, ()); TEST_EQUAL(errors[1].m_code, taxi::ErrorCode::RemoteError, ()); TEST_EQUAL(errors[2].m_type, taxi::Provider::Type::Maxim, ()); TEST_EQUAL(errors[2].m_code, taxi::ErrorCode::NoProducts, ()); + TEST_EQUAL(errors[3].m_type, taxi::Provider::Type::Rutaxi, ()); + TEST_EQUAL(errors[3].m_code, taxi::ErrorCode::RemoteError, ()); maker.Reset(reqId, 3, successCallback, errorNotPossibleCallback); maker.DecrementRequestCount(reqId); @@ -391,12 +447,14 @@ UNIT_CLASS_TEST(AsyncGuiThread, TaxiEngine_Smoke) taxi::Engine engine({{taxi::Provider::Type::Uber, kTesturl}, {taxi::Provider::Type::Yandex, kTesturl}, - {taxi::Provider::Type::Maxim, kTesturl}}); + {taxi::Provider::Type::Maxim, kTesturl}, + {taxi::Provider::Type::Rutaxi, kTesturl}}); engine.SetDelegate(std::make_unique()); + BelarusMinskDelegate delegate; taxi::ProvidersContainer const synchronousProviders = - GetProvidersSynchronous(engine, from, to, kTesturl); + GetProvidersSynchronous(engine, from, to, delegate, kTesturl); TEST(!synchronousProviders.empty(), ()); @@ -463,6 +521,11 @@ UNIT_TEST(TaxiEngine_GetProvidersAtPos) TEST_EQUAL(providers.size(), 1, ()); TEST_EQUAL(providers[0], taxi::Provider::Type::Uber, ()); + engine.SetDelegate(std::make_unique()); + providers = engine.GetProvidersAtPos(latlon); + TEST_EQUAL(providers.size(), 1, ()); + TEST_EQUAL(providers[0], taxi::Provider::Type::Rutaxi, ()); + engine.SetDelegate(std::make_unique()); providers = engine.GetProvidersAtPos(latlon); TEST(providers.empty(), (providers)); diff --git a/partners_api/rutaxi_api.cpp b/partners_api/rutaxi_api.cpp new file mode 100644 index 0000000000..275f9c0d0f --- /dev/null +++ b/partners_api/rutaxi_api.cpp @@ -0,0 +1,282 @@ +#include "partners_api/rutaxi_api.hpp" + +#include "platform/http_client.hpp" +#include "platform/platform.hpp" + +#include "geometry/latlon.hpp" +#include "geometry/mercator.hpp" + +#include "coding/url_encode.hpp" + +#include "base/logging.hpp" +#include "base/string_utils.hpp" + +#include "std/target_os.hpp" + +#include +#include +#include +#include + +#include "3party/jansson/myjansson.hpp" + +#include "private.h" + +namespace +{ +std::string const kMappingFilepath = "taxi_places/osm_to_rutaxi.json"; +std::string const kArrivalTimeSeconds = "300"; + +bool RunSimpleHttpRequest(std::string const & url, std::string const & data, std::string & result) +{ + platform::HttpClient request(url); + + request.SetTimeout(10.0); + + if (!data.empty()) + request.SetBodyData(data, "application/json"); + + request.SetRawHeader("Accept", "application/json"); + request.SetRawHeader("X-Parse-Application-Id", std::string("App ") + RUTAXI_APP_TOKEN); + + return request.RunHttpRequest(result); +} +} // namespace + +namespace taxi +{ +namespace rutaxi +{ +std::string const kTaxiInfoUrl = "https://api.rutaxi.ru/api/1.0.0/"; + +// static +bool RawApi::GetNearObject(ms::LatLon const & pos, std::string const & city, std::string & result, + std::string const & baseUrl /* = kTaxiInfoUrl */) +{ + std::ostringstream data; + data << R"({"latitude": )" << pos.lat << R"(, "longitude": )" << pos.lon << R"(, "city": ")" + << city << R"("})"; + + return RunSimpleHttpRequest(baseUrl + "near/", data.str(), result); +} + +// static +bool RawApi::GetCost(Object const & from, Object const & to, std::string const & city, + std::string & result, std::string const & baseUrl /* = kTaxiInfoUrl */) +{ + std::ostringstream data; + data << R"({"city": ")" << city << R"(", "Order": {"points": [{"object_id": )" << from.m_id + << R"(, "house": ")" << from.m_house << R"("}, {"object_id": )" << to.m_id + << R"(, "house": ")" << to.m_house << R"("}]}})"; + + return RunSimpleHttpRequest(baseUrl + "cost/", data.str(), result); +} + +Api::Api(std::string const & baseUrl /* = kTaxiInfoUrl */) + : ApiBase(baseUrl) + , m_cityMapping(LoadCityMapping()) +{ +} + +void Api::SetDelegate(Delegate * delegate) +{ + m_delegate = delegate; +} + +void Api::GetAvailableProducts(ms::LatLon const & from, ms::LatLon const & to, + ProductsCallback const & successFn, + ErrorProviderCallback const & errorFn) +{ + ASSERT(successFn, ()); + ASSERT(errorFn, ()); + ASSERT(m_delegate, ()); + + auto const fromCity = m_delegate->GetCityName(MercatorBounds::FromLatLon(from)); + auto const toCity = m_delegate->GetCityName(MercatorBounds::FromLatLon(to)); + auto const cityIdIt = m_cityMapping.find(toCity); + + // TODO(a): Add ErrorCode::FarDistance and provide this error code. + if (fromCity != toCity || cityIdIt == m_cityMapping.cend() || !IsDistanceSupported(from, to)) + { + errorFn(ErrorCode::NoProducts); + return; + } + + auto const baseUrl = m_baseUrl; + auto const & city = cityIdIt->second; + + using ObjectPtr = std::shared_ptr; + + ObjectPtr fromObj = std::make_shared(); + ObjectPtr toObj = std::make_shared(); + auto errorOnPreviousStep = std::make_shared(false); + + auto const getNearObject = + [city, baseUrl, errorOnPreviousStep, errorFn](ms::LatLon const & pos, ObjectPtr & dst) + { + if (*errorOnPreviousStep) + return; + + std::string httpResult; + if (!RawApi::GetNearObject(pos, city.m_id, httpResult, baseUrl)) + { + errorFn(ErrorCode::RemoteError); + *errorOnPreviousStep = true; + return; + } + + Object result; + try + { + MakeNearObject(httpResult, result); + } + catch (my::Json::Exception const & e) + { + errorFn(ErrorCode::NoProducts); + *errorOnPreviousStep = true; + LOG(LERROR, (e.what(), httpResult)); + return; + } + + *dst = result; + }; + + GetPlatform().RunTask(Platform::Thread::Network, [getNearObject, from, fromObj]() mutable + { + getNearObject(from, fromObj); + }); + + GetPlatform().RunTask(Platform::Thread::Network, [getNearObject, to, toObj]() mutable + { + getNearObject(to, toObj); + }); + + GetPlatform().RunTask(Platform::Thread::Network, + [fromObj, toObj, city, baseUrl, errorOnPreviousStep, successFn, errorFn]() + { + if (*errorOnPreviousStep) + return; + + std::string result; + if (!RawApi::GetCost(*fromObj, *toObj, city.m_id, result, baseUrl)) + { + errorFn(ErrorCode::RemoteError); + return; + } + + std::vector products; + try + { + MakeProducts(result, *fromObj, *toObj, city, products); + } + catch (my::Json::Exception const & e) + { + LOG(LERROR, (e.what(), result)); + products.clear(); + } + + if (products.empty()) + errorFn(ErrorCode::NoProducts); + else + successFn(products); + }); +} + +/// Returns link which allows you to launch the RuTaxi app. +RideRequestLinks Api::GetRideRequestLinks(std::string const & productId, ms::LatLon const & from, + ms::LatLon const & to) const +{ + return {"rto://order.rutaxi.ru/a.php?" + productId, "https://go.onelink.me/2944814706/mapsme1"}; +} + +void MakeNearObject(std::string const & src, Object & dst) +{ + my::Json root(src.c_str()); + + auto const data = json_object_get(root.get(), "data"); + auto const objects = json_object_get(data, "objects"); + auto const item = json_array_get(objects, 0); + + FromJSONObject(item, "id", dst.m_id); + FromJSONObject(item, "house", dst.m_house); + FromJSONObject(item, "name", dst.m_title); +} + +void MakeProducts(std::string const & src, Object const & from, Object const & to, + City const & city, std::vector & products) +{ + products.clear(); + + my::Json root(src.c_str()); + + std::ostringstream productStream; + productStream << "city=" << city.m_id << "&title1=" << UrlEncode(from.m_title) + << "&ob1=" << from.m_id << "&h1=" << UrlEncode(from.m_house) + << "&title2=" << UrlEncode(to.m_title) << "&ob2=" << to.m_id + << "&h2=" << UrlEncode(to.m_house); + + taxi::Product product; + product.m_productId = productStream.str(); + product.m_currency = city.m_currency; + product.m_time = kArrivalTimeSeconds; + + auto const data = json_object_get(root.get(), "data"); + + FromJSONObject(data, "cost", product.m_price); + + products.emplace_back(std::move(product)); +} + +CityMapping LoadCityMapping() +{ + std::string fileData; + try + { + auto const fileReader = GetPlatform().GetReader(kMappingFilepath); + fileReader->ReadAsString(fileData); + } + catch (FileAbsentException const & ex) + { + LOG(LERROR, ("Exception while get reader for file:", kMappingFilepath, "reason:", ex.what())); + return {}; + } + catch (FileReader::Exception const & ex) + { + LOG(LERROR, ("Exception while reading file:", kMappingFilepath, "reason:", ex.what())); + return {}; + } + + ASSERT(!fileData.empty(), ()); + + CityMapping result; + + try + { + my::Json root(fileData.c_str()); + + auto const count = json_array_size(root.get()); + std::string osmName; + City city; + + for (size_t i = 0; i < count; ++i) + { + auto const item = json_array_get(root.get(), i); + + FromJSONObject(item, "osm", osmName); + FromJSONObject(item, "rutaxi", city.m_id); + FromJSONObject(item, "currency", city.m_currency); + + result.emplace(osmName, city); + } + } + catch (my::Json::Exception const & ex) + { + LOG(LWARNING, ("Exception while parsing file:", kMappingFilepath, "reason:", ex.what(), + "json:", fileData)); + return {}; + } + + return result; +} +} // namespace rutaxi +} // namespace taxi diff --git a/partners_api/rutaxi_api.hpp b/partners_api/rutaxi_api.hpp new file mode 100644 index 0000000000..96f619d640 --- /dev/null +++ b/partners_api/rutaxi_api.hpp @@ -0,0 +1,81 @@ +#pragma once + +#include "partners_api/taxi_base.hpp" +#include "partners_api/taxi_delegate.hpp" + +#include "base/visitor.hpp" + +#include +#include + +namespace ms +{ +class LatLon; +} + +namespace taxi +{ +namespace rutaxi +{ +struct City +{ + std::string m_id; + std::string m_currency; +}; + +using CityMapping = std::unordered_map; + +struct Object +{ + std::string m_id; + std::string m_house; + std::string m_title; +}; + +struct OsmToId +{ + std::string m_osmName; + std::string m_id; +}; + +extern std::string const kTaxiInfoUrl; +/// RuTaxi api wrapper is based on synchronous http requests. +class RawApi +{ +public: + static bool GetNearObject(ms::LatLon const & pos, std::string const & city, std::string & result, + std::string const & baseUrl = kTaxiInfoUrl); + + static bool GetCost(Object const & from, Object const & to, std::string const & city, + std::string & result, std::string const & baseUrl = kTaxiInfoUrl); +}; + +/// Class which is used for making products from http requests results. +class Api : public ApiBase +{ +public: + explicit Api(std::string const & baseUrl = kTaxiInfoUrl); + + void SetDelegate(Delegate * delegate); + // ApiBase overrides: + /// Requests list of available products from RuTaxi. + void GetAvailableProducts(ms::LatLon const & from, ms::LatLon const & to, + ProductsCallback const & successFn, + ErrorProviderCallback const & errorFn) override; + + /// Returns link which allows you to launch the RuTaxi app. + RideRequestLinks GetRideRequestLinks(std::string const & productId, ms::LatLon const & from, + ms::LatLon const & to) const override; + +private: + // Non-owning delegate pointer + Delegate * m_delegate = nullptr; + CityMapping m_cityMapping; +}; + +void MakeNearObject(std::string const & src, Object & dst); +void MakeProducts(std::string const & src, Object const & from, Object const & to, + City const & city, std::vector & products); +CityMapping LoadCityMapping(); +} // namespace rutaxi +} // namespace taxi diff --git a/partners_api/taxi_delegate.hpp b/partners_api/taxi_delegate.hpp new file mode 100644 index 0000000000..5bbe7e6202 --- /dev/null +++ b/partners_api/taxi_delegate.hpp @@ -0,0 +1,20 @@ +#pragma once + +#include "storage/index.hpp" + +#include "geometry/point2d.hpp" + +#include + +namespace taxi +{ +class Delegate +{ +public: + virtual ~Delegate() = default; + + virtual storage::TCountriesVec GetCountryIds(m2::PointD const & point) = 0; + virtual std::string GetCityName(m2::PointD const & point) = 0; + virtual storage::TCountryId GetMwmId(m2::PointD const & point) = 0; +}; +} // namespace taxi diff --git a/partners_api/taxi_engine.cpp b/partners_api/taxi_engine.cpp index 286a4302fc..cc81485c6a 100644 --- a/partners_api/taxi_engine.cpp +++ b/partners_api/taxi_engine.cpp @@ -1,5 +1,6 @@ #include "partners_api/taxi_engine.hpp" #include "partners_api/maxim_api.hpp" +#include "partners_api/rutaxi_api.hpp" #include "partners_api/taxi_places_loader.hpp" #include "partners_api/uber_api.hpp" #include "partners_api/yandex_api.hpp" @@ -118,9 +119,25 @@ Engine::Engine(std::vector urls /* = {} */) AddApi(urls, Provider::Type::Yandex); AddApi(urls, Provider::Type::Uber); AddApi(urls, Provider::Type::Maxim); + AddApi(urls, Provider::Type::Rutaxi); } -void Engine::SetDelegate(std::unique_ptr delegate) { m_delegate = std::move(delegate); } +void Engine::SetDelegate(std::unique_ptr delegate) +{ + m_delegate = std::move(delegate); + + auto it = std::find_if(m_apis.begin(), m_apis.end(), [](ApiItem const & item) + { + return item.m_type == Provider::Type::Rutaxi; + }); + + if (it != m_apis.end()) + { + auto rutaxiPtr = dynamic_cast(it->m_api.get()); + CHECK(rutaxiPtr != nullptr, ()); + rutaxiPtr->SetDelegate(m_delegate.get()); + } +} /// Requests list of available products. Returns request identificator immediately. uint64_t Engine::GetAvailableProducts(ms::LatLon const & from, ms::LatLon const & to, diff --git a/partners_api/taxi_engine.hpp b/partners_api/taxi_engine.hpp index 1265ba94e4..bf486aeb2d 100644 --- a/partners_api/taxi_engine.hpp +++ b/partners_api/taxi_engine.hpp @@ -1,6 +1,7 @@ #pragma once #include "partners_api/taxi_base.hpp" +#include "partners_api/taxi_delegate.hpp" #include "platform/safe_callback.hpp" @@ -19,16 +20,6 @@ using SuccessCallback = using ErrorCallback = platform::SafeCallback; -class Delegate -{ -public: - virtual ~Delegate() = default; - - virtual storage::TCountriesVec GetCountryIds(m2::PointD const & point) = 0; - virtual std::string GetCityName(m2::PointD const & point) = 0; - virtual storage::TCountryId GetMwmId(m2::PointD const & point) = 0; -}; - /// This class is used to collect replies from all taxi apis and to call callback when all replies /// are collected. The methods are called in callbacks on different threads, so synchronization is /// required. @@ -93,6 +84,8 @@ private: template void AddApi(std::vector const & urls, Provider::Type type); + std::unique_ptr m_delegate; + std::vector m_apis; // Id for currently processed request. @@ -100,7 +93,5 @@ private: // Use single instance of maker for all requests, for this reason, // all outdated requests will be ignored. std::shared_ptr m_maker = std::make_shared(); - - std::unique_ptr m_delegate; }; } // namespace taxi diff --git a/partners_api/taxi_places_loader.cpp b/partners_api/taxi_places_loader.cpp index b430ff4529..07f40d5db0 100644 --- a/partners_api/taxi_places_loader.cpp +++ b/partners_api/taxi_places_loader.cpp @@ -51,6 +51,7 @@ std::string Loader::GetFileNameByProvider(Provider::Type const type) switch (type) { case Provider::Type::Maxim: return "taxi_places/maxim.json"; + case Provider::Type::Rutaxi: return "taxi_places/rutaxi.json"; case Provider::Type::Uber: return "taxi_places/uber.json"; case Provider::Type::Yandex: return "taxi_places/yandex.json"; case Provider::Type::Count: LOG(LERROR, ("Incorrect taxi provider")); return ""; diff --git a/partners_api/taxi_provider.hpp b/partners_api/taxi_provider.hpp index a5536d5c03..c2333ef4df 100644 --- a/partners_api/taxi_provider.hpp +++ b/partners_api/taxi_provider.hpp @@ -24,6 +24,7 @@ public: Uber, Yandex, Maxim, + Rutaxi, Count }; @@ -80,6 +81,7 @@ inline std::string DebugPrint(Provider::Type type) case Provider::Type::Uber: return "Uber"; case Provider::Type::Yandex: return "Yandex"; case Provider::Type::Maxim: return "Maxim"; + case Provider::Type::Rutaxi: return "Rutaxi"; case Provider::Type::Count: ASSERT(false, ()); return ""; } CHECK_SWITCH(); diff --git a/xcode/partners_api/partners_api.xcodeproj/project.pbxproj b/xcode/partners_api/partners_api.xcodeproj/project.pbxproj index a659429e2c..613b3ea6a5 100644 --- a/xcode/partners_api/partners_api.xcodeproj/project.pbxproj +++ b/xcode/partners_api/partners_api.xcodeproj/project.pbxproj @@ -29,6 +29,9 @@ 349FEC5A2010D54D00FE5CA3 /* liboauthcpp.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 349FEC5B2010D54D00FE5CA3 /* liboauthcpp.a */; }; 349FEC5C2010D56400FE5CA3 /* libprotobuf.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 349FEC5D2010D56400FE5CA3 /* libprotobuf.a */; }; 349FEC5E2010D67B00FE5CA3 /* libopening_hours.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 349FEC5F2010D67B00FE5CA3 /* libopening_hours.a */; }; + 3D15ACE6214AA1B000F725D5 /* taxi_delegate.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3D15ACE3214AA1AF00F725D5 /* taxi_delegate.hpp */; }; + 3D15ACE7214AA1B000F725D5 /* rutaxi_api.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3D15ACE4214AA1B000F725D5 /* rutaxi_api.hpp */; }; + 3D15ACE8214AA1B000F725D5 /* rutaxi_api.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3D15ACE5214AA1B000F725D5 /* rutaxi_api.cpp */; }; 3D452AEF1EE6D202009EAB9B /* google_tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3D452AED1EE6D202009EAB9B /* google_tests.cpp */; }; 3D452AF01EE6D202009EAB9B /* mopub_tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3D452AEE1EE6D202009EAB9B /* mopub_tests.cpp */; }; 3D452AF31EE6D20D009EAB9B /* google_ads.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3D452AF11EE6D20D009EAB9B /* google_ads.cpp */; }; @@ -110,6 +113,9 @@ 349FEC5B2010D54D00FE5CA3 /* liboauthcpp.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; path = liboauthcpp.a; sourceTree = BUILT_PRODUCTS_DIR; }; 349FEC5D2010D56400FE5CA3 /* libprotobuf.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; path = libprotobuf.a; sourceTree = BUILT_PRODUCTS_DIR; }; 349FEC5F2010D67B00FE5CA3 /* libopening_hours.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; path = libopening_hours.a; sourceTree = BUILT_PRODUCTS_DIR; }; + 3D15ACE3214AA1AF00F725D5 /* taxi_delegate.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = taxi_delegate.hpp; sourceTree = ""; }; + 3D15ACE4214AA1B000F725D5 /* rutaxi_api.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = rutaxi_api.hpp; sourceTree = ""; }; + 3D15ACE5214AA1B000F725D5 /* rutaxi_api.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = rutaxi_api.cpp; sourceTree = ""; }; 3D452AED1EE6D202009EAB9B /* google_tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = google_tests.cpp; sourceTree = ""; }; 3D452AEE1EE6D202009EAB9B /* mopub_tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = mopub_tests.cpp; sourceTree = ""; }; 3D452AF11EE6D20D009EAB9B /* google_ads.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = google_ads.cpp; sourceTree = ""; }; @@ -229,6 +235,9 @@ F6B5363B1DA520B20067EEA5 /* partners_api */ = { isa = PBXGroup; children = ( + 3D15ACE5214AA1B000F725D5 /* rutaxi_api.cpp */, + 3D15ACE4214AA1B000F725D5 /* rutaxi_api.hpp */, + 3D15ACE3214AA1AF00F725D5 /* taxi_delegate.hpp */, 3DCD415120DAB33700143533 /* booking_block_params.cpp */, 3DCD415220DAB33700143533 /* booking_block_params.hpp */, 346E888F1E9D087400D4CE9B /* ads_base.cpp */, @@ -349,9 +358,11 @@ F6B536411DA520E40067EEA5 /* booking_api.hpp in Headers */, 3430643D1E9FBCF500DC7665 /* mopub_ads.hpp in Headers */, 3D47B2B11F14FA14000828D2 /* utils.hpp in Headers */, + 3D15ACE7214AA1B000F725D5 /* rutaxi_api.hpp in Headers */, 45C380782094C5B400C18D81 /* partners.hpp in Headers */, 3DFEBF861EF82BEA00317D5C /* viator_api.hpp in Headers */, 346E889C1E9D087400D4CE9B /* rb_ads.hpp in Headers */, + 3D15ACE6214AA1B000F725D5 /* taxi_delegate.hpp in Headers */, 3DFEBF9A1EFBFC1500317D5C /* taxi_base.hpp in Headers */, 346E889A1E9D087400D4CE9B /* banner.hpp in Headers */, 3DFEBF9F1EFBFC1500317D5C /* yandex_api.hpp in Headers */, @@ -463,6 +474,7 @@ 3D452AEF1EE6D202009EAB9B /* google_tests.cpp in Sources */, 3D452AF01EE6D202009EAB9B /* mopub_tests.cpp in Sources */, 3D4E997F1FB439300025B48C /* utils.cpp in Sources */, + 3D15ACE8214AA1B000F725D5 /* rutaxi_api.cpp in Sources */, 3430643C1E9FBCF500DC7665 /* mopub_ads.cpp in Sources */, 45C380772094C5B400C18D81 /* partners.cpp in Sources */, 346E88961E9D087400D4CE9B /* ads_base.cpp in Sources */,