pastk/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

[editor] Ways upload support/use C++ exceptions in OSM API.

Browse source 
Also fixed some bugs in Android auth impl and potential unhandled exceptions from libcppoauth.
This commit is contained in:
Alex Zolotarev 2016-01-31 15:02:11 +03:00 • committed by Sergey Yershov
parent 0120cb4a24
commit 5e503e8de8
17 changed files with 660 additions and 590 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

67
android/jni/com/mapswithme/maps/editor/OsmOAuth.cpp
View file

@ -18,12 +18,13 @@ jobjectArray ToStringArray(JNIEnv * env, TKeySecret const & secret)
return resultArray;
}
jobjectArray ToStringArray(JNIEnv * env, string const & secret, string const & token, string const & url)
// @returns [url, key, secret]
jobjectArray ToStringArray(JNIEnv * env, OsmOAuth::TUrlRequestToken const & uks)
{
jobjectArray resultArray = env->NewObjectArray(3, GetStringClass(env), nullptr);
env->SetObjectArrayElement(resultArray, 0, ToJavaString(env, secret));
env->SetObjectArrayElement(resultArray, 1, ToJavaString(env, token));
env->SetObjectArrayElement(resultArray, 2, ToJavaString(env, url));
env->SetObjectArrayElement(resultArray, 0, ToJavaString(env, uks.first));
env->SetObjectArrayElement(resultArray, 1, ToJavaString(env, uks.second.first));
env->SetObjectArrayElement(resultArray, 2, ToJavaString(env, uks.second.second));
return resultArray;
}
} // namespace
@ -36,36 +37,64 @@ Java_com_mapswithme_maps_editor_OsmOAuth_nativeAuthWithPassword(JNIEnv * env, jc
jstring login, jstring password)
{
OsmOAuth auth = OsmOAuth::ServerAuth();
auto authResult = auth.AuthorizePassword(ToNativeString(env, login), ToNativeString(env, password));
return authResult == OsmOAuth::AuthResult::OK ? ToStringArray(env, auth.GetToken())
: nullptr;
try
{
if (auth.AuthorizePassword(ToNativeString(env, login), ToNativeString(env, password)))
return ToStringArray(env, auth.GetKeySecret());
LOG(LWARNING, ("nativeAuthWithPassword: invalid login or password."));
}
catch (exception const & ex)
{
LOG(LWARNING, ("nativeAuthWithPassword error ", ex.what()));
}
return nullptr;
}
JNIEXPORT jobjectArray JNICALL
Java_com_mapswithme_maps_editor_OsmOAuth_nativeAuthWithWebviewToken(JNIEnv * env, jclass clazz,
jstring secret, jstring token, jstring verifier)
jstring key, jstring secret, jstring verifier)
{
OsmOAuth auth = OsmOAuth::ServerAuth();
TKeySecret outKeySecret;
TKeySecret inKeySecret(ToNativeString(env, secret), ToNativeString(env, token));
auto authResult = auth.FinishAuthorization(inKeySecret, ToNativeString(env, verifier), outKeySecret);
if (authResult != OsmOAuth::AuthResult::OK)
try
{
TRequestToken const rt = { ToNativeString(env, key), ToNativeString(env, secret) };
OsmOAuth auth = OsmOAuth::ServerAuth();
TKeySecret const ks = auth.FinishAuthorization(rt, ToNativeString(env, verifier));
return ToStringArray(env, ks);
}
catch (exception const & ex)
{
LOG(LWARNING, ("nativeAuthWithWebviewToken error ", ex.what()));
return nullptr;
auth.FinishAuthorization(inKeySecret, ToNativeString(env, token), outKeySecret);
return ToStringArray(env, outKeySecret);
}
}
JNIEXPORT jobjectArray JNICALL
Java_com_mapswithme_maps_editor_OsmOAuth_nativeGetFacebookAuthUrl(JNIEnv * env, jclass clazz)
{
OsmOAuth::TUrlKeySecret keySecret = OsmOAuth::ServerAuth().GetFacebookOAuthURL();
return ToStringArray(env, keySecret.first, keySecret.second.first, keySecret.second.second);
try
{
OsmOAuth::TUrlRequestToken const uks = OsmOAuth::ServerAuth().GetFacebookOAuthURL();
return ToStringArray(env, uks);
}
catch (exception const & ex)
{
LOG(LWARNING, ("nativeGetFacebookAuthUrl error ", ex.what()));
return nullptr;
}
}
JNIEXPORT jobjectArray JNICALL
Java_com_mapswithme_maps_editor_OsmOAuth_nativeGetGoogleAuthUrl(JNIEnv * env, jclass clazz)
{
OsmOAuth::TUrlKeySecret keySecret = OsmOAuth::ServerAuth().GetGoogleOAuthURL();
return ToStringArray(env, keySecret.first, keySecret.second.first, keySecret.second.second);
try
{
OsmOAuth::TUrlRequestToken const uks = OsmOAuth::ServerAuth().GetGoogleOAuthURL();
return ToStringArray(env, uks);
}
catch (exception const & ex)
{
LOG(LWARNING, ("nativeGetGoogleAuthUrl error ", ex.what()));
return nullptr;
}
}
} // extern "C"

7
android/src/com/mapswithme/maps/editor/AuthFragment.java
View file

@ -152,6 +152,9 @@ public class AuthFragment extends BaseMwmToolbarFragment implements View.OnClick
@Override
public void run()
{
// TODO(@yunikkk): auth can be nullptr in case of errors.
// Need to handle it in UI.
// [url, key, secret]
final String[] auth = facebook ? OsmOAuth.nativeGetFacebookAuthUrl()
: OsmOAuth.nativeGetGoogleAuthUrl();
@ -199,13 +202,13 @@ public class AuthFragment extends BaseMwmToolbarFragment implements View.OnClick
webview.loadUrl(authUrl);
}
private void finishWebviewAuth(final String token, final String secret, final String verifier)
private void finishWebviewAuth(final String key, final String secret, final String verifier)
{
ThreadPool.getWorker().execute(new Runnable() {
@Override
public void run()
{
final String[] auth = OsmOAuth.nativeAuthWithWebviewToken(token, secret, verifier);
final String[] auth = OsmOAuth.nativeAuthWithWebviewToken(key, secret, verifier);
UiThread.run(new Runnable() {
@Override
public void run()

38
editor/changeset_wrapper.cpp
View file

@ -5,7 +5,6 @@
#include "geometry/mercator.hpp"
#include "base/assert.hpp"
#include "base/logging.hpp"
#include "std/algorithm.hpp"
@ -26,25 +25,31 @@ namespace osm
{
ChangesetWrapper::ChangesetWrapper(TKeySecret const & keySecret,
ServerApi06::TKeyValueTags const & comments)
: m_changesetComments(comments),
m_api(OsmOAuth::ServerAuth().SetToken(keySecret))
ServerApi06::TKeyValueTags const & comments) noexcept
: m_changesetComments(comments), m_api(OsmOAuth::ServerAuth(keySecret))
{
}
ChangesetWrapper::~ChangesetWrapper()
{
if (m_changesetId)
m_api.CloseChangeSet(m_changesetId);
{
try
{
m_api.CloseChangeSet(m_changesetId);
}
catch (std::exception const & ex)
{
LOG(LWARNING, (ex.what()));
}
}
}
void ChangesetWrapper::LoadXmlFromOSM(ms::LatLon const & ll, pugi::xml_document & doc)
{
auto const response = m_api.GetXmlFeaturesAtLatLon(ll.lat, ll.lon);
if (response.first == OsmOAuth::ResponseCode::NetworkError)
MYTHROW(NetworkErrorException, ("NetworkError with GetXmlFeaturesAtLatLon request."));
if (response.first != OsmOAuth::ResponseCode::OK)
MYTHROW(HttpErrorException, ("HTTP error", response.first, "with GetXmlFeaturesAtLatLon", ll));
if (response.first != OsmOAuth::HTTP::OK)
MYTHROW(HttpErrorException, ("HTTP error", response, "with GetXmlFeaturesAtLatLon", ll));
if (pugi::status_ok != doc.load(response.second.c_str()).status)
MYTHROW(OsmXmlParseException, ("Can't parse OSM server response for GetXmlFeaturesAtLatLon request", response.second));
@ -93,21 +98,14 @@ XMLFeature ChangesetWrapper::GetMatchingAreaFeatureFromOSM(vector<m2::PointD> co
MYTHROW(OsmObjectWasDeletedException, ("OSM does not have any matching way for feature"));
}
void ChangesetWrapper::ModifyNode(XMLFeature node)
void ChangesetWrapper::Modify(XMLFeature node)
{
// TODO(AlexZ): ServerApi can be much better with exceptions.
if (m_changesetId == kInvalidChangesetId && !m_api.CreateChangeSet(m_changesetComments, m_changesetId))
MYTHROW(CreateChangeSetFailedException, ("CreateChangeSetFailedException"));
uint64_t nodeId;
if (!strings::to_uint64(node.GetAttribute("id"), nodeId))
MYTHROW(CreateChangeSetFailedException, ("CreateChangeSetFailedException"));
if (m_changesetId == kInvalidChangesetId)
m_changesetId = m_api.CreateChangeSet(m_changesetComments);
// Changeset id should be updated for every OSM server commit.
node.SetAttribute("changeset", strings::to_string(m_changesetId));
if (!m_api.ModifyNode(node.ToOSMString(), nodeId))
MYTHROW(ModifyNodeFailedException, ("ModifyNodeFailedException"));
m_api.ModifyElement(node);
}
} // namespace osm

5
editor/changeset_wrapper.hpp
View file

@ -29,7 +29,7 @@ public:
DECLARE_EXCEPTION(ModifyNodeFailedException, ChangesetWrapperException);
DECLARE_EXCEPTION(LinearFeaturesAreNotSupportedException, ChangesetWrapperException);
ChangesetWrapper(TKeySecret const & keySecret, ServerApi06::TKeyValueTags const & comments);
ChangesetWrapper(TKeySecret const & keySecret, ServerApi06::TKeyValueTags const & comments) noexcept;
~ChangesetWrapper();
/// Throws many exceptions from above list, plus including XMLNode's parsing ones.
@ -38,7 +38,8 @@ public:
editor::XMLFeature GetMatchingAreaFeatureFromOSM(vector<m2::PointD> const & geomerty);
/// Throws exceptions from above list.
void ModifyNode(editor::XMLFeature node);
/// Node should have correct OSM "id" attribute set.
void Modify(editor::XMLFeature node);
private:
/// Unfortunately, pugi can't return xml_documents from methods.

35
editor/editor_tests/osm_auth_test.cpp
View file

@ -3,6 +3,7 @@
#include "editor/osm_auth.hpp"
using osm::OsmOAuth;
using osm::TKeySecret;
namespace
{
@ -17,34 +18,37 @@ constexpr char const * kFacebookToken = "CAAYYoGXMFUcBAHZBpDFyFPFQroYRMtzdCzXVFi
UNIT_TEST(OSM_Auth_InvalidLogin)
{
OsmOAuth auth = OsmOAuth::IZServerAuth();
auto const result = auth.AuthorizePassword(kIZTestUser, kIZInvalidPassword);
TEST_EQUAL(result, OsmOAuth::AuthResult::FailLogin, ("invalid password"));
bool result;
TEST_NO_THROW(result = auth.AuthorizePassword(kIZTestUser, kIZInvalidPassword), ());
TEST_EQUAL(result, false, ("invalid password"));
TEST(!auth.IsAuthorized(), ("Should not be authorized."));
}
UNIT_TEST(OSM_Auth_Login)
{
OsmOAuth auth = OsmOAuth::IZServerAuth();
auto const result = auth.AuthorizePassword(kIZTestUser, kIZTestPassword);
TEST_EQUAL(result, OsmOAuth::AuthResult::OK, ("login to test server"));
bool result;
TEST_NO_THROW(result = auth.AuthorizePassword(kIZTestUser, kIZTestPassword), ());
TEST_EQUAL(result, true, ("login to test server"));
TEST(auth.IsAuthorized(), ("Should be authorized."));
OsmOAuth::Response const perm = auth.Request("/permissions");
TEST_EQUAL(perm.first, OsmOAuth::ResponseCode::OK, ("permission request ok"));
TEST(perm.second.find("write_api") != string::npos, ("can write to api"));
TEST_EQUAL(perm.first, OsmOAuth::HTTP::OK, ("permission request ok"));
TEST_NOT_EQUAL(perm.second.find("write_api"), string::npos, ("can write to api"));
}
UNIT_TEST(OSM_Auth_Facebook)
{
OsmOAuth auth = OsmOAuth::IZServerAuth();
auto const result = auth.AuthorizeFacebook(kFacebookToken);
TEST_EQUAL(result, OsmOAuth::AuthResult::OK, ("login via facebook"));
bool result;
TEST_NO_THROW(result = auth.AuthorizeFacebook(kFacebookToken), ());
TEST_EQUAL(result, true, ("login via facebook"));
TEST(auth.IsAuthorized(), ("Should be authorized."));
OsmOAuth::Response const perm = auth.Request("/permissions");
TEST_EQUAL(perm.first, OsmOAuth::ResponseCode::OK, ("permission with stored token request ok"));
TEST(perm.second.find("write_api") != string::npos, ("can write to api"));
TEST_EQUAL(perm.first, OsmOAuth::HTTP::OK, ("permission with stored token request ok"));
TEST_NOT_EQUAL(perm.second.find("write_api"), string::npos, ("can write to api"));
}
// TODO(@Zverik): Fix Google auth and uncomment test.
/*UNIT_TEST(OSM_Auth_Google)
{
OsmOAuth auth(kConsumerKey, kConsumerSecret, kTestServer, kTestServer);
@ -59,8 +63,9 @@ UNIT_TEST(OSM_Auth_Facebook)
UNIT_TEST(OSM_Auth_ForgotPassword)
{
OsmOAuth auth = OsmOAuth::IZServerAuth();
auto result = auth.ResetPassword(kIZForgotPasswordEmail);
TEST_EQUAL(result, OsmOAuth::AuthResult::OK, ("Correct email"));
result = auth.ResetPassword("not@registered.email");
TEST_EQUAL(result, OsmOAuth::AuthResult::NoEmail, ("Incorrect email"));
bool result;
TEST_NO_THROW(result = auth.ResetPassword(kIZForgotPasswordEmail), ());
TEST_EQUAL(result, true, ("Correct email"));
TEST_NO_THROW(result = auth.ResetPassword("not@registered.email"), ());
TEST_EQUAL(result, false, ("Incorrect email"));
}

149
editor/editor_tests/server_api_test.cpp
View file

@ -4,6 +4,8 @@
#include "geometry/mercator.hpp"
#include "base/scope_guard.hpp"
#include "std/cstring.hpp"
#include "3party/pugixml/src/pugixml.hpp"
@ -19,8 +21,8 @@ constexpr char const * kValidOsmPassword = "12345678";
UNIT_TEST(OSM_ServerAPI_TestUserExists)
{
ServerApi06 api(OsmOAuth::DevServerAuth());
TEST_EQUAL(OsmOAuth::ResponseCode::OK, api.TestUserExists(kValidOsmUser), ());
TEST_EQUAL(OsmOAuth::ResponseCode::NotFound, api.TestUserExists(kInvalidOsmUser), ());
TEST(api.TestOSMUser(kValidOsmUser), ());
TEST(!api.TestOSMUser(kInvalidOsmUser), ());
}
namespace
@ -28,80 +30,25 @@ namespace
ServerApi06 CreateAPI()
{
OsmOAuth auth = OsmOAuth::DevServerAuth();
OsmOAuth::AuthResult const result = auth.AuthorizePassword(kValidOsmUser, kValidOsmPassword);
TEST_EQUAL(result, OsmOAuth::AuthResult::OK, ());
bool result;
TEST_NO_THROW(result = auth.AuthorizePassword(kValidOsmUser, kValidOsmPassword), ());
TEST_EQUAL(result, true, ("Invalid login or password?"));
TEST(auth.IsAuthorized(), ("OSM authorization"));
ServerApi06 api(auth);
// Test user preferences reading along the way.
osm::UserPreferences prefs;
OsmOAuth::ResponseCode const code = api.GetUserPreferences(prefs);
TEST_EQUAL(code, OsmOAuth::ResponseCode::OK, ("Request user preferences"));
TEST_NO_THROW(prefs = api.GetUserPreferences(), ());
TEST_EQUAL(prefs.m_displayName, kValidOsmUser, ("User display name"));
TEST_EQUAL(prefs.m_id, 3500, ("User id"));
return api;
}
// id attribute is set to -1.
// version attribute is set to 1.
void GenerateNodeXml(ms::LatLon const & ll, ServerApi06::TKeyValueTags const & tags, xml_document & outNode)
{
outNode.reset();
xml_node node = outNode.append_child("osm").append_child("node");
node.append_attribute("id") = -1;
node.append_attribute("version") = 1;
node.append_attribute("lat") = ll.lat;
node.append_attribute("lon") = ll.lon;
for (auto const & kv : tags)
{
xml_node tag = node.append_child("tag");
tag.append_attribute("k").set_value(kv.first.c_str());
tag.append_attribute("v").set_value(kv.second.c_str());
}
}
string XmlToString(xml_node const & node)
{
ostringstream stream;
node.print(stream);
return stream.str();
}
// Replaces attribute for <node> tag (creates attribute if it's not present).
template <class TNewValue>
bool SetAttributeForOsmNode(xml_document & doc, char const * attribute, TNewValue const & v)
{
xml_node node = doc.find_node([](xml_node const & n)
{
return 0 == strncmp(n.name(), "node", sizeof("node"));
});
if (node.empty())
return false;
if (node.attribute(attribute).empty())
node.append_attribute(attribute) = v;
else
node.attribute(attribute) = v;
return true;
}
} // namespace
UNIT_TEST(SetAttributeForOsmNode)
{
xml_document doc;
doc.append_child("osm").append_child("node");
TEST(SetAttributeForOsmNode(doc, "Test", 123), ());
TEST_EQUAL(123, doc.child("osm").child("node").attribute("Test").as_int(), ());
TEST(SetAttributeForOsmNode(doc, "Test", 321), ());
TEST_EQUAL(321, doc.child("osm").child("node").attribute("Test").as_int(), ());
}
void DeleteOSMNodeIfExists(ServerApi06 const & api, uint64_t changeSetId, ms::LatLon const & ll)
{
// Delete all test nodes left on the server (if any).
auto const response = api.GetXmlFeaturesAtLatLon(ll);
TEST_EQUAL(response.first, OsmOAuth::ResponseCode::OK, ());
TEST_EQUAL(response.first, OsmOAuth::HTTP::OK, ());
xml_document reply;
reply.load_string(response.second.c_str());
// Response can be empty, and it's ok.
@ -109,52 +56,60 @@ void DeleteOSMNodeIfExists(ServerApi06 const & api, uint64_t changeSetId, ms::La
{
node.attribute("changeset") = changeSetId;
node.remove_child("tag");
TEST(ServerApi06::DeleteResult::ESuccessfullyDeleted == api.DeleteNode(
"<osm>\n" + XmlToString(node) + "</osm>", node.attribute("id").as_ullong()), ());
TEST(api.DeleteElement(editor::XMLFeature(node)), ());
}
}
UNIT_TEST(OSM_ServerAPI_ChangesetActions)
UNIT_TEST(OSM_ServerAPI_ChangesetAndNode)
{
ms::LatLon const kOriginalLocation(11.11, 12.12);
ms::LatLon const kModifiedLocation(10.10, 12.12);
using editor::XMLFeature;
XMLFeature node(XMLFeature::Type::Node);
ServerApi06 const api = CreateAPI();
uint64_t changeSetId = api.CreateChangeSet({{"created_by", "MAPS.ME Unit Test"},
{"comment", "For test purposes only."}});
auto const changesetCloser = [&]() { api.CloseChangeSet(changeSetId); };
{
MY_SCOPE_GUARD(guard, changesetCloser);
uint64_t changeSetId;
TEST(api.CreateChangeSet({{"created_by", "MAPS.ME Unit Test"}, {"comment", "For test purposes only."}}, changeSetId), ());
// Sometimes network can unexpectedly fail (or test exception can be raised), so do some cleanup before unit tests.
DeleteOSMNodeIfExists(api, changeSetId, kOriginalLocation);
DeleteOSMNodeIfExists(api, changeSetId, kModifiedLocation);
ms::LatLon const originalLocation(11.11, 12.12);
// Sometimes network can unexpectedly fail (or test exception can be raised), so do some cleanup before unit tests.
DeleteOSMNodeIfExists(api, changeSetId, originalLocation);
ms::LatLon const modifiedLocation(10.10, 12.12);
DeleteOSMNodeIfExists(api, changeSetId, modifiedLocation);
node.SetCenter(kOriginalLocation);
node.SetAttribute("changeset", strings::to_string(changeSetId));
node.SetAttribute("version", "1");
node.SetTagValue("testkey", "firstnode");
xml_document node;
GenerateNodeXml(originalLocation, {{"testkey", "firstnode"}}, node);
TEST(SetAttributeForOsmNode(node, "changeset", changeSetId), ());
// Pushes node to OSM server and automatically sets node id.
api.CreateElementAndSetAttributes(node);
TEST(!node.GetAttribute("id").empty(), ());
uint64_t nodeId;
TEST(api.CreateNode(XmlToString(node), nodeId), ());
TEST(SetAttributeForOsmNode(node, "id", nodeId), ());
// Change node's coordinates and tags.
node.SetCenter(kModifiedLocation);
node.SetTagValue("testkey", "secondnode");
api.ModifyElementAndSetVersion(node);
// After modification, node version increases in ModifyElement.
TEST_EQUAL(node.GetAttribute("version"), "2", ());
TEST(SetAttributeForOsmNode(node, "lat", modifiedLocation.lat), ());
TEST(api.ModifyNode(XmlToString(node), nodeId), ());
// After modification, node version has increased.
TEST(SetAttributeForOsmNode(node, "version", 2), ());
// To retrieve created node, changeset should be closed first.
// It is done here via Scope Guard.
}
// To retrieve created node, changeset should be closed first.
TEST(api.CloseChangeSet(changeSetId), ());
auto const response = api.GetXmlFeaturesAtLatLon(kModifiedLocation);
TEST_EQUAL(response.first, OsmOAuth::HTTP::OK, ());
auto const features = XMLFeature::FromOSM(response.second);
TEST_EQUAL(1, features.size(), ());
TEST_EQUAL(node.GetAttribute("id"), features[0].GetAttribute("id"), ());
TEST(api.CreateChangeSet({{"created_by", "MAPS.ME Unit Test"}, {"comment", "For test purposes only."}}, changeSetId), ());
// Cleanup - delete unit test node from the server.
changeSetId = api.CreateChangeSet({{"created_by", "MAPS.ME Unit Test"},
{"comment", "For test purposes only."}});
MY_SCOPE_GUARD(guard, changesetCloser);
// New changeset has new id.
TEST(SetAttributeForOsmNode(node, "changeset", changeSetId), ());
auto const response = api.GetXmlFeaturesAtLatLon(node.child("osm").child("node").attribute("lat").as_double(),
node.child("osm").child("node").attribute("lon").as_double());
TEST_EQUAL(response.first, OsmOAuth::ResponseCode::OK, ());
xml_document reply;
reply.load_string(response.second.c_str());
TEST_EQUAL(nodeId, reply.child("osm").child("node").attribute("id").as_ullong(), ());
TEST(ServerApi06::DeleteResult::ESuccessfullyDeleted == api.DeleteNode(XmlToString(node), nodeId), ());
TEST(api.CloseChangeSet(changeSetId), ());
node.SetAttribute("changeset", strings::to_string(changeSetId));
TEST(api.DeleteElement(node), ());
}

50
editor/editor_tests/xml_feature_test.cpp
View file

@ -187,21 +187,22 @@ UNIT_TEST(XMLFeature_ForEachName)
());
}
auto const kTestNodeWay = R"(<?xml version="1.0"?>
<osm>
<node id="4" lat="55.7978998" lon="37.474528" timestamp="2015-11-27T21:13:32Z"/>
<node id="5" lat="55.7977777" lon="37.474528" timestamp="2015-11-27T21:13:33Z"/>
<way id="3" timestamp="2015-11-27T21:13:34Z">
<nd ref="4"/>
<nd ref="5"/>
<tag k="hi" v="test"/>
</way>
</osm>
)";
UNIT_TEST(XMLFeature_FromOSM)
{
auto const kTestNodeWay = R"(<?xml version="1.0"?>
<osm>
<node id="4" lat="55.7978998" lon="37.474528" timestamp="2015-11-27T21:13:32Z">
<tag k="test" v="value"/>
</node>
<node id="5" lat="55.7977777" lon="37.474528" timestamp="2015-11-27T21:13:33Z"/>
<way id="3" timestamp="2015-11-27T21:13:34Z">
<nd ref="4"/>
<nd ref="5"/>
<tag k="hi" v="test"/>
</way>
</osm>
)";
TEST_ANY_THROW(XMLFeature::FromOSM(""), ());
TEST_ANY_THROW(XMLFeature::FromOSM("This is not XML"), ());
TEST_ANY_THROW(XMLFeature::FromOSM("<?xml version=\"1.0\"?>"), ());
@ -210,5 +211,28 @@ UNIT_TEST(XMLFeature_FromOSM)
vector<XMLFeature> features;
TEST_NO_THROW(features = XMLFeature::FromOSM(kTestNodeWay), ());
TEST_EQUAL(3, features.size(), ());
XMLFeature const & node = features[0];
TEST_EQUAL(node.GetAttribute("id"), "4", ());
TEST_EQUAL(node.GetTagValue("test"), "value", ());
TEST_EQUAL(features[2].GetTagValue("hi"), "test", ());
}
UNIT_TEST(XMLFeature_FromXmlNode)
{
auto const kTestNode = R"(<?xml version="1.0"?>
<osm>
<node id="4" lat="55.7978998" lon="37.474528" timestamp="2015-11-27T21:13:32Z">
<tag k="amenity" v="fountain"/>
</node>
</osm>
)";
pugi::xml_document doc;
doc.load_string(kTestNode);
XMLFeature const feature(doc.child("osm").child("node"));
TEST_EQUAL(feature.GetAttribute("id"), "4", ());
TEST_EQUAL(feature.GetTagValue("amenity"), "fountain", ());
XMLFeature copy(feature);
TEST_EQUAL(copy.GetAttribute("id"), "4", ());
TEST_EQUAL(copy.GetTagValue("amenity"), "fountain", ());
}

434
editor/osm_auth.cpp
View file

@ -4,6 +4,7 @@
#include "base/assert.hpp"
#include "base/logging.hpp"
#include "base/string_utils.hpp"
#include "std/iostream.hpp"
#include "std/map.hpp"
@ -25,10 +26,6 @@ constexpr char const * kGoogleOAuthPart = "/auth/google?referer=%2Foauth%2Fautho
namespace
{
inline bool IsKeySecretValid(TKeySecret const & t)
{
return !(t.first.empty() || t.second.empty());
}
string FindAuthenticityToken(string const & body)
{
@ -61,269 +58,306 @@ bool IsLoggedIn(string const & contents)
{
return contents.find("<form id=\"login_form\"") == string::npos;
}
// TODO(AlexZ): DebugPrint doesn't detect this overload. Fix it.
string DP(alohalytics::HTTPClientPlatformWrapper const & request)
{
string str = "HTTP " + strings::to_string(request.error_code()) + " url [" + request.url_requested() + "]";
if (request.was_redirected())
str += " was redirected to [" + request.url_received() + "]";
if (!request.server_response().empty())
str += " response: " + request.server_response();
return str;
}
} // namespace
OsmOAuth::OsmOAuth(string const & consumerKey, string const & consumerSecret, string const & baseUrl, string const & apiUrl)
// static
bool OsmOAuth::IsValid(TKeySecret const & ks) noexcept
{
return !(ks.first.empty() || ks.second.empty());
}
// static
bool OsmOAuth::IsValid(TUrlRequestToken const & urt) noexcept
{
return !(urt.first.empty() || urt.second.first.empty() || urt.second.second.empty());
}
OsmOAuth::OsmOAuth(string const & consumerKey, string const & consumerSecret,
string const & baseUrl, string const & apiUrl) noexcept
: m_consumerKeySecret(consumerKey, consumerSecret), m_baseUrl(baseUrl), m_apiUrl(apiUrl)
{
}
OsmOAuth OsmOAuth::IZServerAuth()
// static
OsmOAuth OsmOAuth::ServerAuth() noexcept
{
// TODO(AlexZ): Replace with ProductionServerAuth before release.
return IZServerAuth();
}
// static
OsmOAuth OsmOAuth::ServerAuth(TKeySecret const & userKeySecret) noexcept
{
OsmOAuth auth = ServerAuth();
auth.SetKeySecret(userKeySecret);
return auth;
}
// static
OsmOAuth OsmOAuth::IZServerAuth() noexcept
{
constexpr char const * kIZTestServer = "http://188.166.112.124:3000";
constexpr char const * kIZConsumerKey = "QqwiALkYZ4Jd19lo1dtoPhcwGQUqMCMeVGIQ8Ahb";
constexpr char const * kIZConsumerSecret = "wi9HZKFoNYS06Yad5s4J0bfFo2hClMlH7pXaXWS3";
return OsmOAuth(kIZConsumerKey, kIZConsumerSecret, kIZTestServer, kIZTestServer);
}
OsmOAuth OsmOAuth::DevServerAuth()
// static
OsmOAuth OsmOAuth::DevServerAuth() noexcept
{
constexpr char const * kOsmDevServer = "http://master.apis.dev.openstreetmap.org";
constexpr char const * kOsmDevConsumerKey = "eRtN6yKZZf34oVyBnyaVbsWtHIIeptLArQKdTwN3";
constexpr char const * kOsmDevConsumerSecret = "lC124mtm2VqvKJjSh35qBpKfrkeIjpKuGe38Hd1H";
return OsmOAuth(kOsmDevConsumerKey, kOsmDevConsumerSecret, kOsmDevServer, kOsmDevServer);
}
OsmOAuth OsmOAuth::ProductionServerAuth()
// static
OsmOAuth OsmOAuth::ProductionServerAuth() noexcept
{
constexpr char const * kOsmMainSiteURL = "https://www.openstreetmap.org";
constexpr char const * kOsmApiURL = "https://api.openstreetmap.org";
return OsmOAuth(OSM_CONSUMER_KEY, OSM_CONSUMER_SECRET, kOsmMainSiteURL, kOsmApiURL);
}
OsmOAuth OsmOAuth::ServerAuth()
{
// TODO(AlexZ): Replace with ProductionServerAuth before release.
return IZServerAuth();
}
void OsmOAuth::SetKeySecret(TKeySecret const & keySecret) noexcept { m_tokenKeySecret = keySecret; }
TKeySecret const & OsmOAuth::GetKeySecret() const noexcept { return m_tokenKeySecret; }
bool OsmOAuth::IsAuthorized() const noexcept{ return IsValid(m_tokenKeySecret); }
// Opens a login page and extract a cookie and a secret token.
OsmOAuth::AuthResult OsmOAuth::FetchSessionId(OsmOAuth::SessionID & sid, string const & subUrl) const
OsmOAuth::SessionID OsmOAuth::FetchSessionId(string const & subUrl) const
{
HTTPClientPlatformWrapper request(m_baseUrl + subUrl + "?cookie_test=true");
string const url = m_baseUrl + subUrl + "?cookie_test=true";
HTTPClientPlatformWrapper request(url);
if (!request.RunHTTPRequest())
return AuthResult::NetworkError;
if (request.error_code() != 200)
return AuthResult::ServerError;
sid.m_cookies = request.combined_cookies();
sid.m_token = FindAuthenticityToken(request.server_response());
return !sid.m_cookies.empty() && !sid.m_token.empty() ? AuthResult::OK : AuthResult::FailCookie;
MYTHROW(NetworkError, ("FetchSessionId Network error while connecting to", url));
if (request.was_redirected())
MYTHROW(UnexpectedRedirect, ("Redirected to", request.url_received(), "from", url));
if (request.error_code() != HTTP::OK)
MYTHROW(FetchSessionIdError, (DP(request)));
SessionID const sid = { request.combined_cookies(), FindAuthenticityToken(request.server_response()) };
if (sid.m_cookies.empty() || sid.m_token.empty())
MYTHROW(FetchSessionIdError, ("Cookies and/or token are empty for request", DP(request)));
return sid;
}
// Log a user out.
OsmOAuth::AuthResult OsmOAuth::LogoutUser(SessionID const & sid) const
void OsmOAuth::LogoutUser(SessionID const & sid) const
{
HTTPClientPlatformWrapper request(m_baseUrl + "/logout");
request.set_cookies(sid.m_cookies);
if (!request.RunHTTPRequest())
return AuthResult::NetworkError;
if (request.error_code() != 200)
return AuthResult::ServerError;
return AuthResult::OK;
MYTHROW(NetworkError, ("LogoutUser Network error while connecting to", request.url_requested()));
if (request.error_code() != HTTP::OK)
MYTHROW(LogoutUserError, (DP(request)));
}
// Signs a user id using login and password.
OsmOAuth::AuthResult OsmOAuth::LoginUserPassword(string const & login, string const & password, SessionID const & sid) const
bool OsmOAuth::LoginUserPassword(string const & login, string const & password, SessionID const & sid) const
{
map<string, string> params;
params["username"] = login;
params["password"] = password;
params["referer"] = "/";
params["commit"] = "Login";
params["authenticity_token"] = sid.m_token;
map<string, string> const params =
{
{"username", login},
{"password", password},
{"referer", "/"},
{"commit", "Login"},
{"authenticity_token", sid.m_token}
};
HTTPClientPlatformWrapper request(m_baseUrl + "/login");
request.set_body_data(BuildPostRequest(params), "application/x-www-form-urlencoded");
request.set_cookies(sid.m_cookies);
if (!request.RunHTTPRequest())
return AuthResult::NetworkError;
if (request.error_code() != 200)
return AuthResult::ServerError;
MYTHROW(NetworkError, ("LoginUserPassword Network error while connecting to", request.url_requested()));
if (request.error_code() != HTTP::OK)
MYTHROW(LoginUserPasswordServerError, (DP(request)));
// Not redirected page is a 100% signal that login and/or password are invalid.
if (!request.was_redirected())
return AuthResult::FailLogin;
// Since we don't know whether the request was redirected or not, we need to check page contents.
return IsLoggedIn(request.server_response()) ? AuthResult::OK : AuthResult::FailLogin;
return false;
// Parse redirected page contents to make sure that it's not some router in-between.
return IsLoggedIn(request.server_response());
}
// Signs a user in using a facebook token.
OsmOAuth::AuthResult OsmOAuth::LoginSocial(string const & callbackPart, string const & socialToken, SessionID const & sid) const
bool OsmOAuth::LoginSocial(string const & callbackPart, string const & socialToken, SessionID const & sid) const
{
string const url = m_baseUrl + callbackPart + socialToken;
HTTPClientPlatformWrapper request(url);
request.set_cookies(sid.m_cookies);
if (!request.RunHTTPRequest())
return AuthResult::NetworkError;
if (request.error_code() != 200)
return AuthResult::ServerError;
MYTHROW(NetworkError, ("LoginSocial Network error while connecting to", request.url_requested()));
if (request.error_code() != HTTP::OK)
MYTHROW(LoginSocialServerError, (DP(request)));
// Not redirected page is a 100% signal that social login has failed.
if (!request.was_redirected())
return AuthResult::FailLogin;
return IsLoggedIn(request.server_response()) ? AuthResult::OK : AuthResult::FailLogin;
return false;
// Parse redirected page contents to make sure that it's not some router in-between.
return IsLoggedIn(request.server_response());
}
// Fakes a buttons press, so a user accepts requested permissions.
// Fakes a buttons press to automatically accept requested permissions.
string OsmOAuth::SendAuthRequest(string const & requestTokenKey, SessionID const & sid) const
{
map<string, string> params;
params["oauth_token"] = requestTokenKey;
params["oauth_callback"] = "";
params["authenticity_token"] = sid.m_token;
params["allow_read_prefs"] = "yes";
params["allow_write_api"] = "yes";
params["allow_write_gpx"] = "yes";
params["allow_write_notes"] = "yes";
params["commit"] = "Save changes";
map<string, string> const params =
{
{"oauth_token", requestTokenKey},
{"oauth_callback", ""},
{"authenticity_token", sid.m_token},
{"allow_read_prefs", "yes"},
{"allow_write_api", "yes"},
{"allow_write_gpx", "yes"},
{"allow_write_notes", "yes"},
{"commit", "Save changes"}
};
HTTPClientPlatformWrapper request(m_baseUrl + "/oauth/authorize");
request.set_body_data(BuildPostRequest(params), "application/x-www-form-urlencoded");
request.set_cookies(sid.m_cookies);
if (!request.RunHTTPRequest())
return string();
MYTHROW(NetworkError, ("SendAuthRequest Network error while connecting to", request.url_requested()));
string const callbackURL = request.url_received();
string const vKey = "oauth_verifier=";
auto const pos = callbackURL.find(vKey);
if (pos == string::npos)
return string();
MYTHROW(SendAuthRequestError, ("oauth_verifier is not found", DP(request)));
auto const end = callbackURL.find("&", pos);
return callbackURL.substr(pos + vKey.length(), end == string::npos ? end : end - pos - vKey.length());
}
TKeySecret OsmOAuth::FetchRequestToken() const
TRequestToken OsmOAuth::FetchRequestToken() const
{
OAuth::Consumer const consumer(m_consumerKeySecret.first, m_consumerKeySecret.second);
OAuth::Client oauth(&consumer);
string const requestTokenUrl = m_baseUrl + "/oauth/request_token";
string const requestTokenQuery = oauth.getURLQueryString(OAuth::Http::Get, requestTokenUrl + "?oauth_callback=oob");
HTTPClientPlatformWrapper request(requestTokenUrl + "?" + requestTokenQuery);
if (!(request.RunHTTPRequest() && request.error_code() == 200 && !request.was_redirected()))
return TKeySecret(string(), string());
OAuth::Token reqToken = OAuth::Token::extract(request.server_response());
return TKeySecret(reqToken.key(), reqToken.secret());
if (!request.RunHTTPRequest())
MYTHROW(NetworkError, ("FetchRequestToken Network error while connecting to", request.url_requested()));
if (request.error_code() != HTTP::OK)
MYTHROW(FetchRequestTokenServerError, (DP(request)));
if (request.was_redirected())
MYTHROW(UnexpectedRedirect, ("Redirected to", request.url_received(), "from", request.url_requested()));
// Throws std::runtime_error.
OAuth::Token const reqToken = OAuth::Token::extract(request.server_response());
return { reqToken.key(), reqToken.secret() };
}
OsmOAuth::AuthResult OsmOAuth::FinishAuthorization(TKeySecret const & requestToken, string const & verifier, TKeySecret & outKeySecret) const
TKeySecret OsmOAuth::FinishAuthorization(TRequestToken const & requestToken, string const & verifier) const
{
OAuth::Consumer const consumer(m_consumerKeySecret.first, m_consumerKeySecret.second);
OAuth::Token const reqToken(requestToken.first, requestToken.second, verifier);
OAuth::Client oauth(&consumer, &reqToken);
string const accessTokenUrl = m_baseUrl + "/oauth/access_token";
string const queryString = oauth.getURLQueryString(OAuth::Http::Get, accessTokenUrl, "", true);
HTTPClientPlatformWrapper request2(accessTokenUrl + "?" + queryString);
if (!(request2.RunHTTPRequest() && request2.error_code() == 200 && !request2.was_redirected()))
return AuthResult::NoAccess;
OAuth::KeyValuePairs responseData = OAuth::ParseKeyValuePairs(request2.server_response());
OAuth::Token accessToken = OAuth::Token::extract(responseData);
HTTPClientPlatformWrapper request(accessTokenUrl + "?" + queryString);
if (!request.RunHTTPRequest())
MYTHROW(NetworkError, ("FinishAuthorization Network error while connecting to", request.url_requested()));
if (request.error_code() != HTTP::OK)
MYTHROW(FinishAuthorizationServerError, (DP(request)));
if (request.was_redirected())
MYTHROW(UnexpectedRedirect, ("Redirected to", request.url_received(), "from", request.url_requested()));
outKeySecret.first = accessToken.key();
outKeySecret.second = accessToken.secret();
return AuthResult::OK;
OAuth::KeyValuePairs const responseData = OAuth::ParseKeyValuePairs(request.server_response());
// Throws std::runtime_error.
OAuth::Token const accessToken = OAuth::Token::extract(responseData);
return { accessToken.key(), accessToken.secret() };
}
// Given a web session id, fetches an OAuth access token.
OsmOAuth::AuthResult OsmOAuth::FetchAccessToken(SessionID const & sid, TKeySecret & outKeySecret) const
TKeySecret OsmOAuth::FetchAccessToken(SessionID const & sid) const
{
// Aquire a request token.
TKeySecret const requestToken = FetchRequestToken();
if (requestToken.first.empty())
return AuthResult::NoOAuth;
TRequestToken const requestToken = FetchRequestToken();
// Faking a button press for access rights.
string const pin = SendAuthRequest(requestToken.first, sid);
if (pin.empty())
return AuthResult::FailAuth;
LogoutUser(sid);
// Got pin, exchange it for the access token.
return FinishAuthorization(requestToken, pin, outKeySecret);
return FinishAuthorization(requestToken, pin);
}
OsmOAuth::AuthResult OsmOAuth::AuthorizePassword(string const & login, string const & password, TKeySecret & outKeySecret) const
bool OsmOAuth::AuthorizePassword(string const & login, string const & password)
{
SessionID sid;
AuthResult result = FetchSessionId(sid);
if (result != AuthResult::OK)
return result;
result = LoginUserPassword(login, password, sid);
if (result != AuthResult::OK)
return result;
return FetchAccessToken(sid, outKeySecret);
SessionID const sid = FetchSessionId();
if (!LoginUserPassword(login, password, sid))
return false;
m_tokenKeySecret = FetchAccessToken(sid);
return true;
}
OsmOAuth::AuthResult OsmOAuth::AuthorizeFacebook(string const & facebookToken, TKeySecret & outKeySecret) const
bool OsmOAuth::AuthorizeFacebook(string const & facebookToken)
{
SessionID sid;
AuthResult result = FetchSessionId(sid);
if (result != AuthResult::OK)
return result;
result = LoginSocial(kFacebookCallbackPart, facebookToken, sid);
if (result != AuthResult::OK)
return result;
return FetchAccessToken(sid, outKeySecret);
SessionID const sid = FetchSessionId();
if (!LoginSocial(kFacebookCallbackPart, facebookToken, sid))
return false;
m_tokenKeySecret = FetchAccessToken(sid);
return true;
}
OsmOAuth::AuthResult OsmOAuth::AuthorizeGoogle(string const & googleToken, TKeySecret & outKeySecret) const
bool OsmOAuth::AuthorizeGoogle(string const & googleToken)
{
SessionID sid;
AuthResult result = FetchSessionId(sid);
if (result != AuthResult::OK)
return result;
result = LoginSocial(kGoogleCallbackPart, googleToken, sid);
if (result != AuthResult::OK)
return result;
return FetchAccessToken(sid, outKeySecret);
SessionID const sid = FetchSessionId();
if (!LoginSocial(kGoogleCallbackPart, googleToken, sid))
return false;
m_tokenKeySecret = FetchAccessToken(sid);
return true;
}
OsmOAuth::TUrlKeySecret OsmOAuth::GetFacebookOAuthURL() const
OsmOAuth::TUrlRequestToken OsmOAuth::GetFacebookOAuthURL() const
{
TKeySecret const requestToken = FetchRequestToken();
if (requestToken.first.empty())
return TUrlKeySecret(string(), requestToken);
TRequestToken const requestToken = FetchRequestToken();
string const url = m_baseUrl + kFacebookOAuthPart + requestToken.first;
return TUrlKeySecret(url, requestToken);
return TUrlRequestToken(url, requestToken);
}
OsmOAuth::TUrlKeySecret OsmOAuth::GetGoogleOAuthURL() const
OsmOAuth::TUrlRequestToken OsmOAuth::GetGoogleOAuthURL() const
{
TKeySecret const requestToken = FetchRequestToken();
if (requestToken.first.empty())
return TUrlKeySecret(string(), requestToken);
TRequestToken const requestToken = FetchRequestToken();
string const url = m_baseUrl + kGoogleOAuthPart + requestToken.first;
return TUrlKeySecret(url, requestToken);
return TUrlRequestToken(url, requestToken);
}
OsmOAuth::AuthResult OsmOAuth::ResetPassword(string const & email) const
bool OsmOAuth::ResetPassword(string const & email) const
{
string const kForgotPasswordUrlPart = "/user/forgot-password";
SessionID sid;
AuthResult result = FetchSessionId(sid, kForgotPasswordUrlPart);
if (result != AuthResult::OK)
return result;
map<string, string> params;
params["user[email]"] = email;
params["authenticity_token"] = sid.m_token;
params["commit"] = "Reset password";
SessionID const sid = FetchSessionId(kForgotPasswordUrlPart);
map<string, string> const params =
{
{"user[email]", email},
{"authenticity_token", sid.m_token},
{"commit", "Reset password"}
};
HTTPClientPlatformWrapper request(m_baseUrl + kForgotPasswordUrlPart);
request.set_body_data(BuildPostRequest(params), "application/x-www-form-urlencoded");
request.set_cookies(sid.m_cookies);
if (!request.RunHTTPRequest())
return AuthResult::NetworkError;
MYTHROW(NetworkError, ("ResetPassword Network error while connecting to", request.url_requested()));
if (request.error_code() != HTTP::OK)
MYTHROW(ResetPasswordServerError, (DP(request)));
return request.was_redirected() && request.url_received().find(m_baseUrl) != string::npos ? AuthResult::OK : AuthResult::NoEmail;
if (request.was_redirected() && request.url_received().find(m_baseUrl) != string::npos)
return true;
return false;
}
OsmOAuth::Response OsmOAuth::Request(TKeySecret const & keySecret, string const & method, string const & httpMethod, string const & body) const
OsmOAuth::Response OsmOAuth::Request(string const & method, string const & httpMethod, string const & body) const
{
CHECK(IsKeySecretValid(keySecret), ("Empty request token"));
if (!IsValid(m_tokenKeySecret))
MYTHROW(InvalidKeySecret, ("User token (key and secret) are empty."));
OAuth::Consumer const consumer(m_consumerKeySecret.first, m_consumerKeySecret.second);
OAuth::Token const oatoken(keySecret.first, keySecret.second);
OAuth::Token const oatoken(m_tokenKeySecret.first, m_tokenKeySecret.second);
OAuth::Client oauth(&consumer, &oatoken);
OAuth::Http::RequestType reqType;
@ -336,10 +370,7 @@ OsmOAuth::Response OsmOAuth::Request(TKeySecret const & keySecret, string const
else if (httpMethod == "DELETE")
reqType = OAuth::Http::Delete;
else
{
ASSERT(false, ("Unsupported OSM API request method", httpMethod));
return Response(ResponseCode::NetworkError, string());
}
MYTHROW(UnsupportedApiRequestMethod, ("Unsupported OSM API request method", httpMethod));
string const url = m_apiUrl + kApiVersion + method;
string const query = oauth.getURLQueryString(reqType, url);
@ -347,9 +378,12 @@ OsmOAuth::Response OsmOAuth::Request(TKeySecret const & keySecret, string const
HTTPClientPlatformWrapper request(url + "?" + query);
if (httpMethod != "GET")
request.set_body_data(body, "application/xml", httpMethod);
if (!request.RunHTTPRequest() || request.was_redirected())
return Response(ResponseCode::NetworkError, string());
return Response(static_cast<ResponseCode>(request.error_code()), request.server_response());
if (!request.RunHTTPRequest())
MYTHROW(NetworkError, ("Request Network error while connecting to", url));
if (request.was_redirected())
MYTHROW(UnexpectedRedirect, ("Redirected to", request.url_received(), "from", url));
return Response(request.error_code(), request.server_response());
}
OsmOAuth::Response OsmOAuth::DirectRequest(string const & method, bool api) const
@ -357,86 +391,36 @@ OsmOAuth::Response OsmOAuth::DirectRequest(string const & method, bool api) cons
string const url = api ? m_apiUrl + kApiVersion + method : m_baseUrl + method;
HTTPClientPlatformWrapper request(url);
if (!request.RunHTTPRequest())
return Response(ResponseCode::NetworkError, string());
// TODO(AlexZ): Static cast causes big problems if doesn't match ResponseCode enum.
return Response(static_cast<ResponseCode>(request.error_code()), request.server_response());
MYTHROW(NetworkError, ("DirectRequest Network error while connecting to", url));
if (request.was_redirected())
MYTHROW(UnexpectedRedirect, ("Redirected to", request.url_received(), "from", url));
return Response(request.error_code(), request.server_response());
}
OsmOAuth & OsmOAuth::SetToken(TKeySecret const & keySecret)
string DebugPrint(OsmOAuth::Response const & code)
{
m_tokenKeySecret = keySecret;
return *this;
}
TKeySecret const & OsmOAuth::GetToken() const { return m_tokenKeySecret; }
bool OsmOAuth::IsAuthorized() const { return IsKeySecretValid(m_tokenKeySecret); }
OsmOAuth::AuthResult OsmOAuth::FetchAccessToken(SessionID const & sid)
{
return FetchAccessToken(sid, m_tokenKeySecret);
}
OsmOAuth::AuthResult OsmOAuth::FinishAuthorization(TKeySecret const & requestToken, string const & verifier)
{
return FinishAuthorization(requestToken, verifier, m_tokenKeySecret);
}
OsmOAuth::AuthResult OsmOAuth::AuthorizePassword(string const & login, string const & password)
{
return AuthorizePassword(login, password, m_tokenKeySecret);
}
OsmOAuth::AuthResult OsmOAuth::AuthorizeFacebook(string const & facebookToken)
{
return AuthorizeFacebook(facebookToken, m_tokenKeySecret);
}
OsmOAuth::AuthResult OsmOAuth::AuthorizeGoogle(string const & googleToken)
{
return AuthorizeGoogle(googleToken, m_tokenKeySecret);
}
OsmOAuth::Response OsmOAuth::Request(string const & method, string const & httpMethod, string const & body) const
{
return Request(m_tokenKeySecret, method, httpMethod, body);
}
string DebugPrint(OsmOAuth::AuthResult const res)
{
switch (res)
string r;
switch (code.first)
{
case OsmOAuth::AuthResult::OK: return "OK";
case OsmOAuth::AuthResult::FailCookie: return "FailCookie";
case OsmOAuth::AuthResult::FailLogin: return "FailLogin";
case OsmOAuth::AuthResult::NoOAuth: return "NoOAuth";
case OsmOAuth::AuthResult::FailAuth: return "FailAuth";
case OsmOAuth::AuthResult::NoAccess: return "NoAccess";
case OsmOAuth::AuthResult::NetworkError: return "NetworkError";
case OsmOAuth::AuthResult::ServerError: return "ServerError";
case OsmOAuth::AuthResult::NoEmail: return "NoEmail";
case OsmOAuth::HTTP::OK: r = "OK"; break;
case OsmOAuth::HTTP::BadXML: r = "BadXML"; break;
case OsmOAuth::HTTP::BadAuth: r = "BadAuth"; break;
case OsmOAuth::HTTP::Redacted: r = "Redacted"; break;
case OsmOAuth::HTTP::NotFound: r = "NotFound"; break;
case OsmOAuth::HTTP::WrongMethod: r = "WrongMethod"; break;
case OsmOAuth::HTTP::Conflict: r = "Conflict"; break;
case OsmOAuth::HTTP::Gone: r = "Gone"; break;
case OsmOAuth::HTTP::PreconditionFailed: r = "PreconditionFailed"; break;
case OsmOAuth::HTTP::URITooLong: r = "URITooLong"; break;
case OsmOAuth::HTTP::TooMuchData: r = "TooMuchData"; break;
default:
// No data from server in case of NetworkError.
if (code.first < 0)
return "NetworkError " + strings::to_string(code.first);
r = "HTTP " + strings::to_string(code.first);
}
return "Unknown";
}
string DebugPrint(OsmOAuth::ResponseCode const code)
{
switch (code)
{
case OsmOAuth::ResponseCode::NetworkError: return "NetworkError";
case OsmOAuth::ResponseCode::OK: return "OK";
case OsmOAuth::ResponseCode::BadXML: return "BadXML";
case OsmOAuth::ResponseCode::BadAuth: return "BadAuth";
case OsmOAuth::ResponseCode::Redacted: return "Redacted";
case OsmOAuth::ResponseCode::NotFound: return "NotFound";
case OsmOAuth::ResponseCode::WrongMethod: return "WrongMethod";
case OsmOAuth::ResponseCode::Conflict: return "Conflict";
case OsmOAuth::ResponseCode::Gone: return "Gone";
case OsmOAuth::ResponseCode::RefError: return "RefError";
case OsmOAuth::ResponseCode::URITooLong: return "URITooLong";
case OsmOAuth::ResponseCode::TooMuchData: return "TooMuchData";
}
return "Unknown";
return r + ": " + code.second;
}
} // namespace osm

148
editor/osm_auth.hpp
View file

@ -1,5 +1,7 @@
#pragma once
#include "base/exception.hpp"
#include "std/string.hpp"
#include "std/utility.hpp"
@ -7,29 +9,15 @@ namespace osm
{
using TKeySecret = pair<string /*key*/, string /*secret*/>;
using TRequestToken = TKeySecret;
/// All methods that interact with the OSM server are blocking and not asynchronous.
class OsmOAuth
{
public:
/// A result of authentication. OK if everything is good.
enum class AuthResult
/// Do not use enum class here for easier matching with error_code().
enum HTTP : int
{
OK,
FailCookie,
FailLogin,
NoOAuth,
FailAuth,
NoAccess,
NetworkError,
ServerError,
NoEmail
};
/// A result of a request. Has readable values for all OSM API return codes.
enum class ResponseCode
{
NetworkError = -1,
OK = 200,
BadXML = 400,
BadAuth = 401,
@ -38,65 +26,81 @@ public:
WrongMethod = 405,
Conflict = 409,
Gone = 410,
RefError = 412,
// Most often it means bad reference to another object.
PreconditionFailed = 412,
URITooLong = 414,
TooMuchData = 509
};
/// A pair of <error code, response contents>.
using Response = std::pair<ResponseCode, string>;
/// A pair of <http error code, response contents>.
using Response = std::pair<int, string>;
/// A pair of <url, key-secret>.
using TUrlKeySecret = std::pair<string, TKeySecret>;
using TUrlRequestToken = std::pair<string, TRequestToken>;
DECLARE_EXCEPTION(OsmOAuthException, RootException);
DECLARE_EXCEPTION(NetworkError, OsmOAuthException);
DECLARE_EXCEPTION(UnexpectedRedirect, OsmOAuthException);
DECLARE_EXCEPTION(UnsupportedApiRequestMethod, OsmOAuthException);
DECLARE_EXCEPTION(InvalidKeySecret, OsmOAuthException);
DECLARE_EXCEPTION(FetchSessionIdError, OsmOAuthException);
DECLARE_EXCEPTION(LogoutUserError, OsmOAuthException);
DECLARE_EXCEPTION(LoginUserPasswordServerError, OsmOAuthException);
DECLARE_EXCEPTION(LoginUserPasswordFailed, OsmOAuthException);
DECLARE_EXCEPTION(LoginSocialServerError, OsmOAuthException);
DECLARE_EXCEPTION(LoginSocialFailed, OsmOAuthException);
DECLARE_EXCEPTION(SendAuthRequestError, OsmOAuthException);
DECLARE_EXCEPTION(FetchRequestTokenServerError, OsmOAuthException);
DECLARE_EXCEPTION(FinishAuthorizationServerError, OsmOAuthException);
DECLARE_EXCEPTION(ResetPasswordServerError, OsmOAuthException);
static bool IsValid(TKeySecret const & ks) noexcept;
static bool IsValid(TUrlRequestToken const & urt) noexcept;
/// The constructor. Simply stores a lot of strings in fields.
/// @param[apiUrl] The OSM API URL defaults to baseUrl, or kDefaultApiURL if not specified.
OsmOAuth(string const & consumerKey, string const & consumerSecret, string const & baseUrl, string const & apiUrl);
OsmOAuth(string const & consumerKey, string const & consumerSecret,
string const & baseUrl, string const & apiUrl) noexcept;
/// Should be used everywhere in production code instead of servers below.
static OsmOAuth ServerAuth() noexcept;
static OsmOAuth ServerAuth(TKeySecret const & userKeySecret) noexcept;
/// Ilya Zverev's test server.
static OsmOAuth IZServerAuth();
static OsmOAuth IZServerAuth() noexcept;
/// master.apis.dev.openstreetmap.org
static OsmOAuth DevServerAuth();
static OsmOAuth DevServerAuth() noexcept;
/// api.openstreetmap.org
static OsmOAuth ProductionServerAuth();
/// Should be used everywhere in production code.
static OsmOAuth ServerAuth();
static OsmOAuth ProductionServerAuth() noexcept;
/// @name Stateless methods.
//@{
AuthResult AuthorizePassword(string const & login, string const & password, TKeySecret & outKeySecret) const;
AuthResult AuthorizeFacebook(string const & facebookToken, TKeySecret & outKeySecret) const;
AuthResult AuthorizeGoogle(string const & googleToken, TKeySecret & outKeySecret) const;
AuthResult ResetPassword(string const & email) const;
/// @param[method] The API method, must start with a forward slash.
Response Request(TKeySecret const & keySecret, string const & method, string const & httpMethod = "GET", string const & body = "") const;
//@}
void SetKeySecret(TKeySecret const & keySecret) noexcept;
TKeySecret const & GetKeySecret() const noexcept;
bool IsAuthorized() const noexcept;
/// @name Methods for using a token stored in this class. Obviously not thread-safe.
//@{
OsmOAuth & SetToken(TKeySecret const & keySecret);
TKeySecret const & GetToken() const;
bool IsAuthorized() const;
AuthResult AuthorizePassword(string const & login, string const & password);
AuthResult AuthorizeFacebook(string const & facebookToken);
AuthResult AuthorizeGoogle(string const & googleToken);
/// @returns false if login and/or password are invalid.
bool AuthorizePassword(string const & login, string const & password);
/// @returns false if Facebook credentials are invalid.
bool AuthorizeFacebook(string const & facebookToken);
/// @returns false if Google credentials are invalid.
bool AuthorizeGoogle(string const & googleToken);
/// @returns false if email has not been registered on a server.
bool ResetPassword(string const & email) const;
/// Throws in case of network errors.
/// @param[method] The API method, must start with a forward slash.
Response Request(string const & method, string const & httpMethod = "GET", string const & body = "") const;
//@}
/// @name Methods for WebView-based authentication.
//@{
TUrlKeySecret GetFacebookOAuthURL() const;
TUrlKeySecret GetGoogleOAuthURL() const;
AuthResult FinishAuthorization(TKeySecret const & requestToken, string const & verifier, TKeySecret & outKeySecret) const;
AuthResult FinishAuthorization(TKeySecret const & requestToken, string const & verifier);
string GetRegistrationURL() const { return m_baseUrl + "/user/new"; }
string GetResetPasswordURL() const { return m_baseUrl + "/user/forgot-password"; }
//@}
/// Tokenless GET request, for convenience.
/// @param[api] If false, request is made to m_baseUrl.
Response DirectRequest(string const & method, bool api = true) const;
/// @name Methods for WebView-based authentication.
//@{
TUrlRequestToken GetFacebookOAuthURL() const;
TUrlRequestToken GetGoogleOAuthURL() const;
TKeySecret FinishAuthorization(TRequestToken const & requestToken, string const & verifier) const;
//AuthResult FinishAuthorization(TKeySecret const & requestToken, string const & verifier);
string GetRegistrationURL() const noexcept { return m_baseUrl + "/user/new"; }
string GetResetPasswordURL() const noexcept { return m_baseUrl + "/user/forgot-password"; }
//@}
private:
struct SessionID
{
@ -105,23 +109,29 @@ private:
};
/// Key and secret for application.
TKeySecret m_consumerKeySecret;
string m_baseUrl;
string m_apiUrl;
TKeySecret const m_consumerKeySecret;
string const m_baseUrl;
string const m_apiUrl;
/// Key and secret to sign every OAuth request.
TKeySecret m_tokenKeySecret;
AuthResult FetchSessionId(SessionID & sid, string const & subUrl = "/login") const;
AuthResult LogoutUser(SessionID const & sid) const;
AuthResult LoginUserPassword(string const & login, string const & password, SessionID const & sid) const;
AuthResult LoginSocial(string const & callbackPart, string const & socialToken, SessionID const & sid) const;
SessionID FetchSessionId(string const & subUrl = "/login") const;
/// Log a user out.
void LogoutUser(SessionID const & sid) const;
/// Signs a user id using login and password.
/// @returns false if login or password are invalid.
bool LoginUserPassword(string const & login, string const & password, SessionID const & sid) const;
/// Signs a user in using Facebook token.
/// @returns false if the social token is invalid.
bool LoginSocial(string const & callbackPart, string const & socialToken, SessionID const & sid) const;
/// @returns non-empty string with oauth_verifier value.
string SendAuthRequest(string const & requestTokenKey, SessionID const & sid) const;
TKeySecret FetchRequestToken() const;
AuthResult FetchAccessToken(SessionID const & sid, TKeySecret & outKeySecret) const;
AuthResult FetchAccessToken(SessionID const & sid);
/// @returns valid key and secret or throws otherwise.
TRequestToken FetchRequestToken() const;
TKeySecret FetchAccessToken(SessionID const & sid) const;
//AuthResult FetchAccessToken(SessionID const & sid);
};
string DebugPrint(OsmOAuth::AuthResult const res);
string DebugPrint(OsmOAuth::ResponseCode const code);
string DebugPrint(OsmOAuth::Response const & code);
} // namespace osm

2
editor/osm_feature_matcher.cpp
View file

@ -89,7 +89,7 @@ pugi::xml_node GetBestOsmNode(pugi::xml_document const & osmResponse, ms::LatLon
bestMatchNode = xNode.node();
}
}
catch (editor::XMLFeatureNoLatLonError const & ex)
catch (editor::NoLatLon const & ex)
{
LOG(LWARNING, ("No lat/lon attribute in osm response node.", ex.Msg()));
continue;

128
editor/server_api.cpp
View file

@ -6,6 +6,7 @@
#include "base/logging.hpp"
#include "base/string_utils.hpp"
#include "base/timer.hpp"
#include "std/sstream.hpp"
@ -19,13 +20,10 @@ ServerApi06::ServerApi06(OsmOAuth const & auth)
{
}
bool ServerApi06::CreateChangeSet(TKeyValueTags const & kvTags, uint64_t & outChangeSetId) const
uint64_t ServerApi06::CreateChangeSet(TKeyValueTags const & kvTags) const
{
if (!m_auth.IsAuthorized())
{
LOG(LWARNING, ("Not authorized"));
return false;
}
MYTHROW(NotAuthorized, ("Not authorized."));
ostringstream stream;
stream << "<osm>\n"
@ -36,91 +34,101 @@ bool ServerApi06::CreateChangeSet(TKeyValueTags const & kvTags, uint64_t & outCh
"</osm>\n";
OsmOAuth::Response const response = m_auth.Request("/changeset/create", "PUT", stream.str());
if (response.first == OsmOAuth::ResponseCode::OK)
{
if (strings::to_uint64(response.second, outChangeSetId))
return true;
LOG(LWARNING, ("Can't parse changeset ID from server response."));
}
else
LOG(LWARNING, ("CreateChangeSet request has failed:", response.first));
if (response.first != OsmOAuth::HTTP::OK)
MYTHROW(CreateChangeSetHasFailed, ("CreateChangeSet request has failed:", response));
return false;
uint64_t id;
if (!strings::to_uint64(response.second, id))
MYTHROW(CantParseServerResponse, ("Can't parse changeset ID from server response."));
return id;
}
bool ServerApi06::CreateNode(string const & nodeXml, uint64_t & outCreatedNodeId) const
uint64_t ServerApi06::CreateElement(editor::XMLFeature const & element) const
{
OsmOAuth::Response const response = m_auth.Request("/node/create", "PUT", nodeXml);
if (response.first == OsmOAuth::ResponseCode::OK)
{
if (strings::to_uint64(response.second, outCreatedNodeId))
return true;
LOG(LWARNING, ("Can't parse created node ID from server response."));
}
else
LOG(LWARNING, ("CreateNode request has failed:", response.first));
return false;
OsmOAuth::Response const response = m_auth.Request("/" + element.GetTypeString() + "/create",
"PUT", element.ToOSMString());
if (response.first != OsmOAuth::HTTP::OK)
MYTHROW(CreateElementHasFailed, ("CreateElement request has failed:", response, "for", element));
uint64_t id;
if (!strings::to_uint64(response.second, id))
MYTHROW(CantParseServerResponse, ("Can't parse created node ID from server response."));
return id;
}
bool ServerApi06::ModifyNode(string const & nodeXml, uint64_t nodeId) const
void ServerApi06::CreateElementAndSetAttributes(editor::XMLFeature & element) const
{
OsmOAuth::Response const response = m_auth.Request("/node/" + strings::to_string(nodeId), "PUT", nodeXml);
if (response.first == OsmOAuth::ResponseCode::OK)
return true;
LOG(LWARNING, ("ModifyNode request has failed:", response.first, response.second));
return false;
uint64_t const id = CreateElement(element);
element.SetAttribute("id", strings::to_string(id));
element.SetAttribute("version", "1");
}
ServerApi06::DeleteResult ServerApi06::DeleteNode(string const & nodeXml, uint64_t nodeId) const
uint64_t ServerApi06::ModifyElement(editor::XMLFeature const & element) const
{
OsmOAuth::Response const response = m_auth.Request("/node/" + strings::to_string(nodeId), "DELETE", nodeXml);
if (response.first == OsmOAuth::ResponseCode::OK)
return DeleteResult::ESuccessfullyDeleted;
else if (static_cast<int>(response.first) >= 400)
{
LOG(LWARNING, ("Server can't delete node, replied:", response.second));
// Tons of reasons, see http://wiki.openstreetmap.org/wiki/API_v0.6#Error_codes_16
return DeleteResult::ECanNotBeDeleted;
}
string const id = element.GetAttribute("id");
if (id.empty())
MYTHROW(ModifiedElementHasNoIdAttribute, ("Please set id attribute for", element));
LOG(LWARNING, ("DeleteNode request has failed:", response.first));
return DeleteResult::EFailed;
OsmOAuth::Response const response = m_auth.Request("/" + element.GetTypeString() + "/" + id,
"PUT", element.ToOSMString());
if (response.first != OsmOAuth::HTTP::OK)
MYTHROW(ModifyElementHasFailed, ("ModifyElement request has failed:", response, "for", element));
uint64_t version;
if (!strings::to_uint64(response.second, version))
MYTHROW(CantParseServerResponse, ("Can't parse element version from server response."));
return version;
}
bool ServerApi06::CloseChangeSet(uint64_t changesetId) const
void ServerApi06::ModifyElementAndSetVersion(editor::XMLFeature & element) const
{
uint64_t const version = ModifyElement(element);
element.SetAttribute("version", strings::to_string(version));
}
bool ServerApi06::DeleteElement(editor::XMLFeature const & element) const
{
string const id = element.GetAttribute("id");
if (id.empty())
MYTHROW(DeletedElementHasNoIdAttribute, ("Please set id attribute for", element));
OsmOAuth::Response const response = m_auth.Request("/" + element.GetTypeString() + "/" + id,
"DELETE", element.ToOSMString());
return (response.first == OsmOAuth::HTTP::OK || response.first == OsmOAuth::HTTP::Gone);
}
void ServerApi06::CloseChangeSet(uint64_t changesetId) const
{
OsmOAuth::Response const response = m_auth.Request("/changeset/" + strings::to_string(changesetId) + "/close", "PUT");
if (response.first == OsmOAuth::ResponseCode::OK)
return true;
LOG(LWARNING, ("CloseChangeSet request has failed:", response.first));
return false;
if (response.first != OsmOAuth::HTTP::OK)
MYTHROW(ErrorClosingChangeSet, ("CloseChangeSet request has failed:", response));
}
OsmOAuth::ResponseCode ServerApi06::TestUserExists(string const & userName)
bool ServerApi06::TestOSMUser(string const & userName)
{
string const method = "/user/" + UrlEncode(userName);
return m_auth.DirectRequest(method, false).first;
return m_auth.DirectRequest(method, false).first == OsmOAuth::HTTP::OK;
}
OsmOAuth::ResponseCode ServerApi06::GetUserPreferences(UserPreferences & pref) const
UserPreferences ServerApi06::GetUserPreferences() const
{
OsmOAuth::Response const response = m_auth.Request("/user/details");
if (response.first != OsmOAuth::ResponseCode::OK)
return response.first;
if (response.first != OsmOAuth::HTTP::OK)
MYTHROW(CantGetUserPreferences, (response));
pugi::xml_document details;
if (!details.load_string(response.second.c_str()))
return OsmOAuth::ResponseCode::NotFound;
pugi::xml_node user = details.child("osm").child("user");
MYTHROW(CantParseUserPreferences, (response));
pugi::xml_node const user = details.child("osm").child("user");
if (!user || !user.attribute("id"))
return OsmOAuth::ResponseCode::BadXML;
MYTHROW(CantParseUserPreferences, ("No <user> or 'id' attribute", response));
UserPreferences pref;
pref.m_id = user.attribute("id").as_ullong();
pref.m_displayName = user.attribute("display_name").as_string();
pref.m_accountCreated = my::StringToTimestamp(user.attribute("account_created").as_string());
pref.m_imageUrl = user.child("img").attribute("href").as_string();
pref.m_changesets = user.child("changesets").attribute("count").as_uint();
return OsmOAuth::ResponseCode::OK;
return pref;
}
OsmOAuth::Response ServerApi06::GetXmlFeaturesInRect(m2::RectD const & latLonRect) const

60
editor/server_api.hpp
View file

@ -1,10 +1,13 @@
#pragma once
#include "editor/osm_auth.hpp"
#include "editor/xml_feature.hpp"
#include "geometry/latlon.hpp"
#include "geometry/rect2d.hpp"
#include "base/exception.hpp"
#include "std/map.hpp"
#include "std/string.hpp"
@ -14,41 +17,58 @@ struct UserPreferences
{
uint64_t m_id;
string m_displayName;
time_t m_accountCreated;
string m_imageUrl;
uint32_t m_changesets;
};
/// All methods here are synchronous and need wrappers for async usage.
/// TODO(AlexZ): Rewrite ServerAPI interface to accept XMLFeature.
/// Exceptions are used for error handling.
class ServerApi06
{
public:
// k= and v= tags used in OSM.
using TKeyValueTags = map<string, string>;
/// Some nodes can't be deleted if they are used in ways or relations.
enum class DeleteResult
{
ESuccessfullyDeleted,
EFailed,
ECanNotBeDeleted
};
DECLARE_EXCEPTION(ServerApi06Exception, RootException);
DECLARE_EXCEPTION(NotAuthorized, ServerApi06Exception);
DECLARE_EXCEPTION(CantParseServerResponse, ServerApi06Exception);
DECLARE_EXCEPTION(CreateChangeSetHasFailed, ServerApi06Exception);
DECLARE_EXCEPTION(CreateElementHasFailed, ServerApi06Exception);
DECLARE_EXCEPTION(ModifiedElementHasNoIdAttribute, ServerApi06Exception);
DECLARE_EXCEPTION(ModifyElementHasFailed, ServerApi06Exception);
DECLARE_EXCEPTION(ErrorClosingChangeSet, ServerApi06Exception);
DECLARE_EXCEPTION(DeletedElementHasNoIdAttribute, ServerApi06Exception);
DECLARE_EXCEPTION(CantGetUserPreferences, ServerApi06Exception);
DECLARE_EXCEPTION(CantParseUserPreferences, ServerApi06Exception);
ServerApi06(OsmOAuth const & auth);
/// This function can be used to check if user did not confirm email validation link after registration.
/// @returns OK if user exists, NotFound if it is not, and ServerError if there is no connection.
OsmOAuth::ResponseCode TestUserExists(string const & userName);
/// A convenience method for UI
OsmOAuth::ResponseCode GetUserPreferences(UserPreferences & pref) const;
/// Throws if there is no connection.
/// @returns true if user have registered/signed up even if his email address was not confirmed yet.
bool TestOSMUser(string const & userName);
/// Get OSM user preferences in a convenient struct.
/// Throws in case of any error.
UserPreferences GetUserPreferences() const;
/// Please use at least created_by=* and comment=* tags.
bool CreateChangeSet(TKeyValueTags const & kvTags, uint64_t & outChangeSetId) const;
/// nodeXml should be wrapped into <osm> ... </osm> tags.
bool CreateNode(string const & nodeXml, uint64_t & outCreatedNodeId) const;
/// nodeXml should be wrapped into <osm> ... </osm> tags.
bool ModifyNode(string const & nodeXml, uint64_t nodeId) const;
/// nodeXml should be wrapped into <osm> ... </osm> tags.
DeleteResult DeleteNode(string const & nodeXml, uint64_t nodeId) const;
bool CloseChangeSet(uint64_t changesetId) const;
/// @returns created changeset ID.
uint64_t CreateChangeSet(TKeyValueTags const & kvTags) const;
/// <node>, <way> or <relation> are supported.
/// Only one element per call is supported.
/// @returns id of created element.
uint64_t CreateElement(editor::XMLFeature const & element) const;
/// The same as const version but also updates id and version for passed element.
void CreateElementAndSetAttributes(editor::XMLFeature & element) const;
/// @param element should already have all attributes set, including "id", "version", "changeset".
/// @returns new version of modified element.
uint64_t ModifyElement(editor::XMLFeature const & element) const;
/// Sets element's version.
void ModifyElementAndSetVersion(editor::XMLFeature & element) const;
/// Some nodes can't be deleted if they are used in ways or relations.
/// @param element should already have all attributes set, including "id", "version", "changeset".
/// @returns true if element was successfully deleted (or was already deleted).
bool DeleteElement(editor::XMLFeature const & element) const;
void CloseChangeSet(uint64_t changesetId) const;
/// @returns OSM xml string with features in the bounding box or empty string on error.
OsmOAuth::Response GetXmlFeaturesInRect(m2::RectD const & latLonRect) const;

8
indexer/osm_editor.cpp
View file

@ -743,10 +743,6 @@ void Editor::UploadChanges(string const & key, string const & secret, TChangeset
continue;
XMLFeature feature = fti.m_feature.ToXML();
// TODO(AlexZ): Add areas(ways) upload support.
if (feature.GetType() != XMLFeature::Type::Node)
continue;
if (!fti.m_street.empty())
feature.SetTagValue(kAddrStreetTag, fti.m_street);
try
@ -758,12 +754,12 @@ void Editor::UploadChanges(string const & key, string const & secret, TChangeset
// Check to avoid duplicates.
if (osmFeature == osmFeatureCopy)
{
LOG(LWARNING, ("Local changes are equal to OSM, feature was not uploaded, local changes were deleted.", feature));
LOG(LWARNING, ("Local changes are equal to OSM, feature was not uploaded, local changes were deleted.", osmFeatureCopy));
// TODO(AlexZ): Delete local change.
continue;
}
LOG(LDEBUG, ("Uploading patched feature", osmFeature));
changeset.ModifyNode(osmFeature);
changeset.Modify(osmFeature);
fti.m_uploadStatus = kUploaded;
fti.m_uploadAttemptTimestamp = time(nullptr);
fti.m_uploadError.clear();

24
iphone/Maps/Classes/CustomViews/Login/MWMAuthorizationLoginViewController.mm
View file

@ -105,17 +105,23 @@ using namespace osm;
{
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^
{
OsmOAuth auth = OsmOAuth::ServerAuth();
auth.SetToken(MWMAuthorizationGetCredentials());
ServerApi06 api(auth);
UserPreferences prefs;
if (api.GetUserPreferences(prefs) != OsmOAuth::ResponseCode::OK)
return;
dispatch_async(dispatch_get_main_queue(), ^
ServerApi06 const api(OsmOAuth::ServerAuth(MWMAuthorizationGetCredentials()));
try
{
self.title = @(prefs.m_displayName.c_str());
});
UserPreferences const prefs = api.GetUserPreferences();
dispatch_async(dispatch_get_main_queue(), ^
{
self.title = @(prefs.m_displayName.c_str());
});
}
catch (exception const & ex)
{
// TODO(@igrechuhin): Should we display some error here?
LOG(LWARNING, ("Can't load user preferences from OSM server:", ex.what()));
}
});
// TODO(@igrechuhin): Cache user name and other info to display while offline.
// Note that this cache should be reset if user logs out.
self.title = @"";
self.message.hidden = YES;
self.loginGoogleButton.hidden = YES;

14
iphone/Maps/Classes/CustomViews/Login/MWMAuthorizationOSMLoginViewController.mm
View file

@ -7,6 +7,7 @@
#include "private.h"
#include "editor/server_api.hpp"
#include "platform/platform.hpp"
#include "base/logging.hpp"
typedef NS_OPTIONS(NSUInteger, MWMFieldCorrect)
{
@ -137,13 +138,20 @@ using namespace osm;
string const username = self.loginTextField.text.UTF8String;
string const password = self.passwordTextField.text.UTF8String;
OsmOAuth auth = OsmOAuth::ServerAuth();
OsmOAuth::AuthResult const result = auth.AuthorizePassword(username, password);
try
{
auth.AuthorizePassword(username, password);
}
catch (exception const & ex)
{
LOG(LWARNING, ("Error login", ex.what()));
}
dispatch_async(dispatch_get_main_queue(), ^
{
[self stopSpinner];
if (result == OsmOAuth::AuthResult::OK)
if (auth.IsAuthorized())
{
MWMAuthorizationStoreCredentials(auth.GetToken());
MWMAuthorizationStoreCredentials(auth.GetKeySecret());
[self dismissViewControllerAnimated:YES completion:nil];
}
else

54
iphone/Maps/Classes/CustomViews/Login/MWMAuthorizationWebViewLoginViewController.mm
View file

@ -2,6 +2,7 @@
#import "MWMAuthorizationWebViewLoginViewController.h"
#import "MWMCircularProgress.h"
#include "base/logging.hpp"
#include "editor/osm_auth.hpp"
using namespace osm;
@ -48,7 +49,7 @@ NSString * getVerifier(NSString * urlString)
@implementation MWMAuthorizationWebViewLoginViewController
{
TKeySecret m_keySecret;
TRequestToken m_requestToken;
}
- (void)viewDidLoad
@ -75,28 +76,35 @@ NSString * getVerifier(NSString * urlString)
[self startSpinner];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^
{
// TODO(AlexZ): Change to production.
OsmOAuth const auth = OsmOAuth::ServerAuth();
OsmOAuth::TUrlKeySecret urlKey;
switch (self.authType)
try
{
OsmOAuth::TUrlRequestToken urt;
switch (self.authType)
{
case MWMWebViewAuthorizationTypeGoogle:
urlKey = auth.GetGoogleOAuthURL();
urt = auth.GetGoogleOAuthURL();
break;
case MWMWebViewAuthorizationTypeFacebook:
urlKey = auth.GetFacebookOAuthURL();
urt = auth.GetFacebookOAuthURL();
break;
}
self->m_requestToken = urt.second;
NSURL * url = [NSURL URLWithString:@(urt.first.c_str())];
NSURLRequest * request = [NSURLRequest requestWithURL:url];
dispatch_async(dispatch_get_main_queue(), ^
{
[self stopSpinner];
self.webView.hidden = NO;
[self.webView loadRequest:request];
});
}
self->m_keySecret = urlKey.second;
NSURL * url = [NSURL URLWithString:@(urlKey.first.c_str())];
NSURLRequest * request = [NSURLRequest requestWithURL:url];
dispatch_async(dispatch_get_main_queue(), ^
catch (exception const & ex)
{
[self stopSpinner];
self.webView.hidden = NO;
[self.webView loadRequest:request];
});
// TODO(@igrechuhin): What should we do in the error case?
// Stop spinner? Show some dialog?
LOG(LWARNING, ("Can't loadAuthorizationPage", ex.what()));
}
});
}
@ -122,16 +130,22 @@ NSString * getVerifier(NSString * urlString)
[self startSpinner];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^
{
TKeySecret outKeySecret;
// TODO(AlexZ): Change to production.
OsmOAuth const auth = OsmOAuth::ServerAuth();
OsmOAuth::AuthResult const result = auth.FinishAuthorization(self->m_keySecret, verifier.UTF8String, outKeySecret);
TKeySecret ks;
try
{
ks = auth.FinishAuthorization(self->m_requestToken, verifier.UTF8String);
}
catch (exception const & ex)
{
LOG(LWARNING, ("checkAuthorization error", ex.what()));
}
dispatch_async(dispatch_get_main_queue(), ^
{
[self stopSpinner];
if (result == OsmOAuth::AuthResult::OK)
if (OsmOAuth::IsValid(ks))
{
MWMAuthorizationStoreCredentials(outKeySecret);
MWMAuthorizationStoreCredentials(ks);
[self dismissViewControllerAnimated:NO completion:nil];
}
else

27
qt/osm_auth_dialog.cpp
View file

@ -103,18 +103,27 @@ void OsmAuthDialog::OnAction()
}
OsmOAuth auth = osm::OsmOAuth::ServerAuth();
OsmOAuth::AuthResult const res = auth.AuthorizePassword(login, password);
if (res != OsmOAuth::AuthResult::OK)
try
{
setWindowTitle(("Auth failed: " + DebugPrint(res)).c_str());
if (auth.AuthorizePassword(login, password))
{
auto const token = auth.GetKeySecret();
Settings::Set(kTokenKeySetting, token.first);
Settings::Set(kTokenSecretSetting, token.second);
SwitchToLogout(this);
}
else
{
setWindowTitle("Auth failed: invalid login or password");
return;
}
}
catch (exception const & ex)
{
setWindowTitle((string("Auth failed: ") + ex.what()).c_str());
return;
}
auto const token = auth.GetToken();
Settings::Set(kTokenKeySetting, token.first);
Settings::Set(kTokenSecretSetting, token.second);
SwitchToLogout(this);
}
else
{