drifty/comaps
1
0
Fork 0
mirror of https://codeberg.org/comaps/comaps synced 2025-12-19 04:53:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

[editor] Remove unused code from the old OSM editor

Browse Source 
Signed-off-by: map-per <map-per@gmx.de>
This commit is contained in:
map-per
2025-12-07 11:16:16 +01:00
committed by map-per
parent d473361e54
commit e7cc602904
8 changed files with 251 additions and 598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
libs/editor/editor_tests/osm_editor_test.cpp
View File

@@ -143,6 +143,7 @@ void CreateCafeAtPoint(m2::PointD const & point, MwmSet::MwmId const & mwmId, os
editor.CreatePoint(classif().GetTypeByPath({"amenity", "cafe"}), point, mwmId, emo);
emo.SetHouseNumber("12");
emo.LogDiffInJournal({});
TEST_EQUAL(editor.SaveEditedFeature(emo), osm::Editor::SaveResult::SavedSuccessfully, ());
}
@@ -157,6 +158,7 @@ void GenerateUploadedFeature(MwmSet::MwmId const & mwmId, osm::EditableMapObject
pugi::xml_node created = mwmNode.append_child("create");
editor::XMLFeature xf = editor::ToXML(emo, true);
xf.SetEditJournal(emo.GetJournal());
xf.SetMWMFeatureIndex(emo.GetID().m_index);
xf.SetModificationTime(time(nullptr));
xf.SetUploadTime(time(nullptr));
@@ -870,7 +872,7 @@ void EditorTest::CreateNoteTest()
};
// Should match a piece of text in the editor note.
constexpr char const * kPlaceDoesNotExistMessage = "The place has gone or never existed";
constexpr char const * kPlaceDoesNotExistMessage = "This place does not exist:";
ForEachCafeAtPoint(m_dataSource, m2::PointD(1.0, 1.0), [&editor, &createAndCheckNote](FeatureType & ft)
{

219
libs/editor/editor_tests/xml_feature_test.cpp
View File

@@ -115,6 +115,42 @@ UNIT_TEST(XMLFeature_UintLang)
TEST_EQUAL(f2.GetName("int_name"), "Gorky Park", ());
}
UNIT_TEST(XMLFeature_SetOSMTagsForType)
{
XMLFeature restaurantFeature(XMLFeature::Type::Node);
restaurantFeature.SetOSMTagsForType(classif().GetTypeByReadableObjectName("amenity-restaurant"));
ASSERT(restaurantFeature.HasTag("amenity"), ());
TEST_EQUAL(restaurantFeature.GetTagValue("amenity"), "restaurant", ());
XMLFeature officeFeature(XMLFeature::Type::Node);
officeFeature.SetOSMTagsForType(classif().GetTypeByReadableObjectName("office"));
ASSERT(officeFeature.HasTag("office"), ());
TEST_EQUAL(officeFeature.GetTagValue("office"), "yes", ());
XMLFeature touristOfficeFeature(XMLFeature::Type::Node);
touristOfficeFeature.SetOSMTagsForType(classif().GetTypeByReadableObjectName("tourism-information-office"));
ASSERT(touristOfficeFeature.HasTag("tourism"), ());
TEST_EQUAL(touristOfficeFeature.GetTagValue("tourism"), "information", ());
XMLFeature addressFeature(XMLFeature::Type::Node);
addressFeature.SetOSMTagsForType(classif().GetTypeByReadableObjectName("building-address"));
ASSERT(!addressFeature.HasAnyTags(), ("Addresses should not have a category tag"));
XMLFeature recyclingCenterFeature(XMLFeature::Type::Node);
recyclingCenterFeature.SetOSMTagsForType(classif().GetTypeByReadableObjectName("amenity-recycling-centre"));
ASSERT(recyclingCenterFeature.HasTag("amenity"), ());
TEST_EQUAL(recyclingCenterFeature.GetTagValue("amenity"), "recycling", ());
ASSERT(recyclingCenterFeature.HasTag("recycling_type"), ());
TEST_EQUAL(recyclingCenterFeature.GetTagValue("recycling_type"), "centre", ());
XMLFeature recyclingContainerFeature(XMLFeature::Type::Node);
recyclingContainerFeature.SetOSMTagsForType(classif().GetTypeByReadableObjectName("amenity-recycling-container"));
ASSERT(recyclingContainerFeature.HasTag("amenity"), ());
TEST_EQUAL(recyclingContainerFeature.GetTagValue("amenity"), "recycling", ());
ASSERT(recyclingContainerFeature.HasTag("recycling_type"), ());
TEST_EQUAL(recyclingContainerFeature.GetTagValue("recycling_type"), "container", ());
}
UNIT_TEST(XMLFeature_ToOSMString)
{
XMLFeature feature(XMLFeature::Type::Node);
@@ -267,104 +303,52 @@ UNIT_TEST(XMLFeature_Geometry)
TEST_EQUAL(feature.GetGeometry(), geometry, ());
}
UNIT_TEST(XMLFeature_ApplyPatch)
{
auto const kOsmFeature = R"(<?xml version="1.0"?>
<osm>
<node id="1" lat="1" lon="2" timestamp="2015-11-27T21:13:32Z" version="1">
<tag k="amenity" v="cafe"/>
</node>
</osm>
)";
auto const kPatch = R"(<?xml version="1.0"?>
<node lat="1" lon="2" timestamp="2015-11-27T21:13:32Z">
<tag k="website" v="maps.me"/>
</node>
)";
XMLFeature const baseOsmFeature = XMLFeature::FromOSM(kOsmFeature).front();
{
XMLFeature noAnyTags = baseOsmFeature;
noAnyTags.ApplyPatch(XMLFeature(kPatch));
TEST(noAnyTags.HasKey("website"), ());
}
{
XMLFeature hasMainTag = baseOsmFeature;
hasMainTag.SetTagValue("website", "mapswith.me");
hasMainTag.ApplyPatch(XMLFeature(kPatch));
TEST_EQUAL(hasMainTag.GetTagValue("website"), "maps.me", ());
size_t tagsCount = 0;
hasMainTag.ForEachTag([&tagsCount](std::string const &, std::string const &) { ++tagsCount; });
TEST_EQUAL(2, tagsCount, ("website should be replaced, not duplicated."));
}
{
XMLFeature hasAltTag = baseOsmFeature;
hasAltTag.SetTagValue("contact:website", "mapswith.me");
hasAltTag.ApplyPatch(XMLFeature(kPatch));
TEST(!hasAltTag.HasTag("website"), ("Existing alt tag should be used."));
TEST_EQUAL(hasAltTag.GetTagValue("contact:website"), "maps.me", ());
}
{
XMLFeature hasAltTag = baseOsmFeature;
hasAltTag.SetTagValue("url", "mapswithme.com");
hasAltTag.ApplyPatch(XMLFeature(kPatch));
TEST(!hasAltTag.HasTag("website"), ("Existing alt tag should be used."));
TEST_EQUAL(hasAltTag.GetTagValue("url"), "maps.me", ());
}
{
XMLFeature hasTwoAltTags = baseOsmFeature;
hasTwoAltTags.SetTagValue("contact:website", "mapswith.me");
hasTwoAltTags.SetTagValue("url", "mapswithme.com");
hasTwoAltTags.ApplyPatch(XMLFeature(kPatch));
TEST(!hasTwoAltTags.HasTag("website"), ("Existing alt tag should be used."));
TEST_EQUAL(hasTwoAltTags.GetTagValue("contact:website"), "maps.me", ());
TEST_EQUAL(hasTwoAltTags.GetTagValue("url"), "mapswithme.com", ());
}
{
XMLFeature hasMainAndAltTag = baseOsmFeature;
hasMainAndAltTag.SetTagValue("website", "osmrulezz.com");
hasMainAndAltTag.SetTagValue("url", "mapswithme.com");
hasMainAndAltTag.ApplyPatch(XMLFeature(kPatch));
TEST_EQUAL(hasMainAndAltTag.GetTagValue("website"), "maps.me", ());
TEST_EQUAL(hasMainAndAltTag.GetTagValue("url"), "mapswithme.com", ());
}
}
UNIT_TEST(XMLFeature_FromXMLAndBackToXML)
{
classificator::Load();
std::string const xmlNoTypeStr = R"(<?xml version="1.0"?>
<node lat="55.7978998" lon="37.474528" timestamp="2015-11-27T21:13:32Z">
<tag k="leisure" v="park" />
<tag k="name" v="Gorki Park" />
<tag k="name:en" v="Gorki Park" />
<tag k="name:ru" v="Парк Горького" />
<tag k="addr:housenumber" v="10" />
<journal version="1.0">
<entry type="TagModification" timestamp="2015-10-05T12:33:02Z">
<data key="name:en" old_value="" new_value="Gorki Park" />
</entry>
<entry type="TagModification" timestamp="2015-10-05T12:33:02Z">
<data key="name:ru" old_value="xxx" new_value="Парк Горького" />
</entry>
</journal>
<journalHistory version="1.0">
<entry type="ObjectCreated" timestamp="2022-12-05T12:32:21Z">
<data type="leisure-park" geomType="Point" lat="55.7978998" lon="37.474528" />
</entry>
<entry type="TagModification" timestamp="2015-10-03T12:33:02Z">
<data key="addr:housenumber" old_value="43" new_value="10" />
</entry>
<entry type="TagModification" timestamp="2015-10-03T12:33:02Z">
<data key="name" old_value="" new_value="Gorki Park" />
</entry>
</journalHistory>
</node>
)";
char const kTimestamp[] = "2015-11-27T21:13:32Z";
editor::XMLFeature xmlNoType(xmlNoTypeStr);
editor::XMLFeature xmlWithType = xmlNoType;
xmlWithType.SetTagValue("amenity", "atm");
editor::XMLFeature xmlFeature(xmlNoTypeStr);
osm::EditableMapObject emo;
editor::FromXML(xmlWithType, emo);
auto fromFtWithType = editor::ToXML(emo, true);
fromFtWithType.SetAttribute("timestamp", kTimestamp);
TEST_EQUAL(fromFtWithType, xmlWithType, ());
osm::EditJournal journal = xmlFeature.GetEditJournal();
emo.ApplyEditsFromJournal(journal);
emo.SetJournal(std::move(journal));
auto fromFtWithoutType = editor::ToXML(emo, false);
fromFtWithoutType.SetAttribute("timestamp", kTimestamp);
TEST_EQUAL(fromFtWithoutType, xmlNoType, ());
auto xmlFromMapObject = editor::ToXML(emo, true);
xmlFromMapObject.SetEditJournal(emo.GetJournal());
xmlFromMapObject.SetAttribute("timestamp", kTimestamp);
TEST_EQUAL(xmlFromMapObject, xmlFeature, ());
}
UNIT_TEST(XMLFeature_AmenityRecyclingFromAndToXml)
@@ -375,6 +359,12 @@ UNIT_TEST(XMLFeature_AmenityRecyclingFromAndToXml)
<node lat="55.8047445" lon="37.5865532" timestamp="2018-07-11T13:24:41Z">
<tag k="amenity" v="recycling" />
<tag k="recycling_type" v="centre" />
<journal version="1.0">
<entry type="ObjectCreated" timestamp="2022-12-05T12:32:21Z">
<data type="amenity-recycling-centre" geomType="Point" lat="55.8047445" lon="37.5865532" />
</entry>
</journal>
<journalHistory version="1.0" />
</node>
)";
@@ -383,13 +373,16 @@ UNIT_TEST(XMLFeature_AmenityRecyclingFromAndToXml)
editor::XMLFeature xmlFeature(recyclingCentreStr);
osm::EditableMapObject emo;
editor::FromXML(xmlFeature, emo);
osm::EditJournal journal = xmlFeature.GetEditJournal();
emo.ApplyEditsFromJournal(journal);
emo.SetJournal(std::move(journal));
auto const th = emo.GetTypes();
TEST_EQUAL(th.Size(), 1, ());
TEST_EQUAL(th.front(), classif().GetTypeByPath({"amenity", "recycling", "centre"}), ());
auto convertedFt = editor::ToXML(emo, true);
convertedFt.SetEditJournal(emo.GetJournal());
convertedFt.SetAttribute("timestamp", kTimestamp);
TEST_EQUAL(xmlFeature, convertedFt, ());
}
@@ -398,6 +391,12 @@ UNIT_TEST(XMLFeature_AmenityRecyclingFromAndToXml)
<node lat="55.8047445" lon="37.5865532" timestamp="2018-07-11T13:24:41Z">
<tag k="amenity" v="recycling" />
<tag k="recycling_type" v="container" />
<journal version="1.0">
<entry type="ObjectCreated" timestamp="2022-12-05T12:32:21Z">
<data type="amenity-recycling-container" geomType="Point" lat="55.8047445" lon="37.5865532" />
</entry>
</journal>
<journalHistory version="1.0" />
</node>
)";
@@ -406,13 +405,16 @@ UNIT_TEST(XMLFeature_AmenityRecyclingFromAndToXml)
editor::XMLFeature xmlFeature(recyclingContainerStr);
osm::EditableMapObject emo;
editor::FromXML(xmlFeature, emo);
osm::EditJournal journal = xmlFeature.GetEditJournal();
emo.ApplyEditsFromJournal(journal);
emo.SetJournal(std::move(journal));
auto const th = emo.GetTypes();
TEST_EQUAL(th.Size(), 1, ());
TEST_EQUAL(th.front(), classif().GetTypeByPath({"amenity", "recycling", "container"}), ());
auto convertedFt = editor::ToXML(emo, true);
convertedFt.SetEditJournal(emo.GetJournal());
convertedFt.SetAttribute("timestamp", kTimestamp);
TEST_EQUAL(xmlFeature, convertedFt, ());
}
@@ -466,39 +468,6 @@ UNIT_TEST(XMLFeature_Diet)
TEST_EQUAL(ft.GetCuisine(), "", ());
}
UNIT_TEST(XMLFeature_SocialContactsProcessing)
{
{
std::string const nightclubStr = R"(<?xml version="1.0"?>
<node lat="50.4082862" lon="30.5130017" timestamp="2022-02-24T05:07:00Z">
<tag k="amenity" v="nightclub" />
<tag k="name" v="Stereo Plaza" />
<tag k="contact:facebook" v="http://www.facebook.com/pages/Stereo-Plaza/118100041593935" />
<tag k="contact:instagram" v="https://www.instagram.com/p/CSy87IhMhfm/" />
<tag k="contact:line" v="liff.line.me/1645278921-kWRPP32q/?accountId=673watcr" />
</node>
)";
editor::XMLFeature xmlFeature(nightclubStr);
osm::EditableMapObject emo;
editor::FromXML(xmlFeature, emo);
auto convertedFt = editor::ToXML(emo, true);
TEST(convertedFt.HasTag("contact:facebook"), ());
TEST_EQUAL(convertedFt.GetTagValue("contact:facebook"), "https://facebook.com/pages/Stereo-Plaza/118100041593935",
());
TEST(convertedFt.HasTag("contact:instagram"), ());
TEST_EQUAL(convertedFt.GetTagValue("contact:instagram"), "https://instagram.com/p/CSy87IhMhfm", ());
TEST(convertedFt.HasTag("contact:line"), ());
TEST_EQUAL(convertedFt.GetTagValue("contact:line"), "https://liff.line.me/1645278921-kWRPP32q/?accountId=673watcr",
());
}
}
UNIT_TEST(XMLFeature_SocialContactsProcessing_clean)
{
{
@@ -509,15 +478,33 @@ UNIT_TEST(XMLFeature_SocialContactsProcessing_clean)
<tag k="contact:facebook" v="https://www.facebook.com/PierreCardinPeru.oficial/" />
<tag k="contact:instagram" v="https://www.instagram.com/fraback.genusswelt/" />
<tag k="contact:line" v="https://line.me/R/ti/p/%40015qevdv" />
<journal version="1.0">
<entry type="ObjectCreated" timestamp="2022-12-05T12:32:21Z">
<data type="amenity-nightclub" geomType="Point" lat="50.4082862" lon="30.5130017" />
</entry>
<entry type="TagModification" timestamp="2022-12-05T12:33:02Z">
<data key="contact:facebook" old_value="" new_value="PierreCardinPeru.oficial" />
</entry>
<entry type="TagModification" timestamp="2022-12-05T12:33:02Z">
<data key="contact:instagram" old_value="" new_value="fraback.genusswelt" />
</entry>
<entry type="TagModification" timestamp="2022-12-05T12:33:02Z">
<data key="contact:line" old_value="" new_value="015qevdv" />
</entry>
</journal>
<journalHistory version="1.0" />
</node>
)";
editor::XMLFeature xmlFeature(nightclubStr);
osm::EditableMapObject emo;
editor::FromXML(xmlFeature, emo);
osm::EditJournal journal = xmlFeature.GetEditJournal();
emo.ApplyEditsFromJournal(journal);
emo.SetJournal(std::move(journal));
auto convertedFt = editor::ToXML(emo, true);
convertedFt.SetEditJournal(emo.GetJournal());
TEST(convertedFt.HasTag("contact:facebook"), ());
TEST_EQUAL(convertedFt.GetTagValue("contact:facebook"), "PierreCardinPeru.oficial", ());

146
libs/editor/osm_editor.cpp
View File

@@ -610,17 +610,8 @@ void Editor::UploadChanges(string const & oauthToken, ChangesetTags tags, Finish
LOG(LDEBUG, ("Content of editJournal:\n", fti.m_object.GetJournal().JournalToString()));
// Don't use new editor for Legacy Objects
auto const & journalHistory = fti.m_object.GetJournal().GetJournalHistory();
bool useNewEditor =
journalHistory.empty() || journalHistory.front().journalEntryType != JournalEntryType::LegacyObject;
try
{
if (useNewEditor)
{
LOG(LDEBUG, ("New Editor used\n"));
switch (fti.m_status)
{
case FeatureStatus::Untouched: CHECK(false, ("It's impossible.")); continue;
@@ -715,117 +706,6 @@ void Editor::UploadChanges(string const & oauthToken, ChangesetTags tags, Finish
changeset.Delete(GetMatchingFeatureFromOSM(changeset, *originalObjectPtr));
break;
}
}
else // Use old editor
{
// Todo: Remove old editor after transition period
switch (fti.m_status)
{
case FeatureStatus::Untouched: CHECK(false, ("It's impossible.")); continue;
case FeatureStatus::Obsolete: continue; // Obsolete features will be deleted by OSMers.
case FeatureStatus::Created:
{
XMLFeature feature = editor::ToXML(fti.m_object, true);
if (!fti.m_street.empty())
feature.SetTagValue(kAddrStreetTag, fti.m_street);
ASSERT_EQUAL(feature.GetType(), XMLFeature::Type::Node,
("Linear and area features creation is not supported yet."));
try
{
auto const center = fti.m_object.GetMercator();
// Throws, see catch below.
XMLFeature osmFeature = changeset.GetMatchingNodeFeatureFromOSM(center);
// If we are here, it means that object already exists at the given point.
// To avoid nodes duplication, merge and apply changes to it instead of creating a new one.
XMLFeature const osmFeatureCopy = osmFeature;
osmFeature.ApplyPatch(feature);
// Check to avoid uploading duplicates into OSM.
if (osmFeature == osmFeatureCopy)
{
LOG(LWARNING, ("Local changes are equal to OSM, feature has not been uploaded.", osmFeatureCopy));
// Don't delete this local change right now for user to see it in profile.
// It will be automatically deleted by migration code on the next maps update.
}
else
{
LOG(LDEBUG, ("Create case: uploading patched feature", osmFeature));
changeset.AddChangesetTag("info:old_editor", "yes");
changeset.AddChangesetTag("info:features_merged", "yes");
changeset.Modify(osmFeature);
}
}
catch (ChangesetWrapper::OsmObjectWasDeletedException const &)
{
// Object was never created by anyone else - it's safe to create it.
changeset.AddChangesetTag("info:old_editor", "yes");
changeset.Create(feature);
}
catch (ChangesetWrapper::EmptyFeatureException const &)
{
// There is another node nearby, but it should be safe to create a new one.
changeset.AddChangesetTag("info:old_editor", "yes");
changeset.Create(feature);
}
catch (...)
{
// Pass network or other errors to outside exception handler.
throw;
}
}
break;
case FeatureStatus::Modified:
{
// Do not serialize feature's type to avoid breaking OSM data.
// TODO: Implement correct types matching when we support modifying existing feature types.
XMLFeature feature = editor::ToXML(fti.m_object, false);
if (!fti.m_street.empty())
feature.SetTagValue(kAddrStreetTag, fti.m_street);
auto const originalObjectPtr = GetOriginalMapObject(fti.m_object.GetID());
if (!originalObjectPtr)
{
LOG(LERROR, ("A feature with id", fti.m_object.GetID(), "cannot be loaded."));
GetPlatform().RunTask(Platform::Thread::Gui,
[this, fid = fti.m_object.GetID()]() { RemoveFeatureIfExists(fid); });
continue;
}
XMLFeature osmFeature = GetMatchingFeatureFromOSM(changeset, *originalObjectPtr);
XMLFeature const osmFeatureCopy = osmFeature;
osmFeature.ApplyPatch(feature);
// Check to avoid uploading duplicates into OSM.
if (osmFeature == osmFeatureCopy)
{
LOG(LWARNING, ("Local changes are equal to OSM, feature has not been uploaded.", osmFeatureCopy));
// Don't delete this local change right now for user to see it in profile.
// It will be automatically deleted by migration code on the next maps update.
}
else
{
LOG(LDEBUG, ("Uploading patched feature", osmFeature));
changeset.AddChangesetTag("info:old_editor", "yes");
changeset.Modify(osmFeature);
}
}
break;
case FeatureStatus::Deleted:
auto const originalObjectPtr = GetOriginalMapObject(fti.m_object.GetID());
if (!originalObjectPtr)
{
LOG(LERROR, ("A feature with id", fti.m_object.GetID(), "cannot be loaded."));
GetPlatform().RunTask(Platform::Thread::Gui,
[this, fid = fti.m_object.GetID()]() { RemoveFeatureIfExists(fid); });
continue;
}
changeset.AddChangesetTag("info:old_editor", "yes");
changeset.Delete(GetMatchingFeatureFromOSM(changeset, *originalObjectPtr));
break;
}
}
uploadInfo.m_uploadStatus = kUploaded;
uploadInfo.m_uploadError.clear();
++uploadedFeaturesCount;
@@ -907,23 +787,7 @@ void Editor::SaveUploadedInformation(FeatureID const & fid, UploadInfo const & u
bool Editor::FillFeatureInfo(FeatureStatus status, XMLFeature const & xml, FeatureID const & fid,
FeatureTypeInfo & fti) const
{
EditJournal journal = xml.GetEditJournal();
// Do not load Legacy Objects form Journal
auto const & journalHistory = journal.GetJournalHistory();
bool loadFromJournal =
journalHistory.empty() || journalHistory.front().journalEntryType != JournalEntryType::LegacyObject;
LOG(LDEBUG, ("loadFromJournal: ", loadFromJournal));
if (status == FeatureStatus::Created)
{
if (loadFromJournal)
fti.m_object.ApplyEditsFromJournal(journal);
else
editor::FromXML(xml, fti.m_object);
}
else
if (status != FeatureStatus::Created)
{
auto const originalObjectPtr = GetOriginalMapObject(fid);
if (!originalObjectPtr)
@@ -933,13 +797,11 @@ bool Editor::FillFeatureInfo(FeatureStatus status, XMLFeature const & xml, Featu
}
fti.m_object = *originalObjectPtr;
if (loadFromJournal)
fti.m_object.ApplyEditsFromJournal(journal);
else
editor::ApplyPatch(xml, fti.m_object);
}
EditJournal journal = xml.GetEditJournal();
fti.m_object.ApplyEditsFromJournal(journal);
fti.m_object.SetJournal(std::move(journal));
fti.m_object.SetID(fid);
fti.m_street = xml.GetTagValue(kAddrStreetTag);

244
libs/editor/xml_feature.cpp
View File

@@ -178,38 +178,6 @@ string XMLFeature::ToOSMString() const
return ost.str();
}
void XMLFeature::ApplyPatch(XMLFeature const & featureWithChanges)
{
// TODO(mgsergio): Get these alt tags from the config.
base::StringIL const alternativeTags[] = {{"phone", "contact:phone", "contact:mobile", "mobile"},
{"website", "contact:website", "url"},
{"fax", "contact:fax"},
{"email", "contact:email"}};
featureWithChanges.ForEachTag([&alternativeTags, this](string_view k, string_view v)
{
// Avoid duplication for similar alternative osm tags.
for (auto const & alt : alternativeTags)
{
auto it = alt.begin();
ASSERT(it != alt.end(), ());
if (k == *it)
{
for (auto const & tag : alt)
{
// Reuse already existing tag if it's present.
if (HasTag(tag))
{
SetTagValue(tag, v);
return;
}
}
}
}
SetTagValue(k, v);
});
}
m2::PointD XMLFeature::GetMercatorCenter() const
{
return mercator::FromLatLon(GetLatLonFromNode(GetRootNode()));
@@ -670,6 +638,40 @@ void XMLFeature::RemoveTag(string_view key)
GetRootNode().remove_child(tag);
}
void XMLFeature::SetOSMTagsForType(uint32_t type)
{
if (ftypes::IsRecyclingCentreChecker::Instance()(type))
{
SetTagValue("amenity", "recycling");
SetTagValue("recycling_type", "centre");
}
else if (ftypes::IsRecyclingContainerChecker::Instance()(type))
{
SetTagValue("amenity", "recycling");
SetTagValue("recycling_type", "container");
}
else if (ftypes::IsAddressChecker::Instance()(type))
{
// Addresses don't have a category tag
}
else
{
string const strType = classif().GetReadableObjectName(type);
strings::SimpleTokenizer iter(strType, "-");
string_view const k = *iter;
if (++iter)
{
// Main type is stored as "k=amenity v=restaurant"
SetTagValue(k, *iter);
}
else {
// Main type is stored as "k=building v=yes"
SetTagValue(k, kYes);
}
}
}
void XMLFeature::UpdateOSMTag(std::string_view key, std::string_view value)
{
if (value.empty())
@@ -807,26 +809,6 @@ XMLFeature::Type XMLFeature::StringToType(string const & type)
return Type::Unknown;
}
void ApplyPatch(XMLFeature const & xml, osm::EditableMapObject & object)
{
xml.ForEachName([&object](string_view lang, string_view name)
{ object.SetName(name, StringUtf8Multilang::GetLangIndex(lang)); });
string const house = xml.GetHouse();
if (!house.empty())
object.SetHouseNumber(house);
auto const cuisineStr = xml.GetCuisine();
if (!cuisineStr.empty())
object.SetCuisines(strings::Tokenize(cuisineStr, ";"));
xml.ForEachTag([&object](string_view k, string v)
{
// Skip result because we iterate via *all* tags here.
(void)object.UpdateMetadataValue(k, std::move(v));
});
}
XMLFeature ToXML(osm::EditableMapObject const & object, bool serializeType)
{
bool const isPoint = object.GetGeomType() == feature::GeomType::Point;
@@ -842,6 +824,15 @@ XMLFeature ToXML(osm::EditableMapObject const & object, bool serializeType)
toFeature.SetGeometry(begin(triangles), end(triangles));
}
if (serializeType)
{
feature::TypesHolder types = object.GetTypes();
types.SortBySpec();
ASSERT(!types.Empty(), ("Feature does not have a type"));
uint32_t mainType = types.front();
toFeature.SetOSMTagsForType(mainType);
}
object.GetNameMultilang().ForEach([&toFeature](uint8_t const & lang, string_view name)
{ toFeature.SetName(lang, name); });
@@ -856,61 +847,8 @@ XMLFeature ToXML(osm::EditableMapObject const & object, bool serializeType)
toFeature.SetCuisine(cuisineStr);
}
if (serializeType)
{
feature::TypesHolder th = object.GetTypes();
// TODO(mgsergio): Use correct sorting instead of SortBySpec based on the config.
th.SortBySpec();
// TODO(mgsergio): Either improve "OSM"-compatible serialization for more complex types,
// or save all our types directly, to restore and reuse them in migration of modified features.
for (uint32_t const type : th)
{
if (ftypes::IsCuisineChecker::Instance()(type))
continue;
if (ftypes::IsRecyclingTypeChecker::Instance()(type))
continue;
if (ftypes::IsRecyclingCentreChecker::Instance()(type))
{
toFeature.SetTagValue("amenity", "recycling");
toFeature.SetTagValue("recycling_type", "centre");
continue;
}
if (ftypes::IsRecyclingContainerChecker::Instance()(type))
{
toFeature.SetTagValue("amenity", "recycling");
toFeature.SetTagValue("recycling_type", "container");
continue;
}
string const strType = classif().GetReadableObjectName(type);
strings::SimpleTokenizer iter(strType, "-");
string_view const k = *iter;
if (++iter)
{
// First (main) type is always stored as "k=amenity v=restaurant".
// Any other "k=amenity v=atm" is replaced by "k=atm v=yes".
if (toFeature.GetTagValue(k).empty())
toFeature.SetTagValue(k, *iter);
else
toFeature.SetTagValue(*iter, kYes);
}
else
{
// We're editing building, generic craft, shop, office, amenity etc.
// Skip it's serialization.
// TODO(mgsergio): Correcly serialize all types back and forth.
LOG(LDEBUG, ("Skipping type serialization:", k));
}
}
}
object.ForEachMetadataItem([&toFeature](string_view tag, string_view value)
{
if (osm::isSocialContactTag(tag) && value.find('/') != std::string::npos)
toFeature.SetTagValue(tag, osm::socialContactToURL(tag, value));
else
toFeature.SetTagValue(tag, value);
});
@@ -923,105 +861,11 @@ XMLFeature TypeToXML(uint32_t type, feature::GeomType geomType, m2::PointD merca
XMLFeature toFeature(XMLFeature::Type::Node);
toFeature.SetCenter(mercator);
// Set Type
if (ftypes::IsRecyclingCentreChecker::Instance()(type))
{
toFeature.SetTagValue("amenity", "recycling");
toFeature.SetTagValue("recycling_type", "centre");
}
else if (ftypes::IsRecyclingContainerChecker::Instance()(type))
{
toFeature.SetTagValue("amenity", "recycling");
toFeature.SetTagValue("recycling_type", "container");
}
else if (ftypes::IsAddressChecker::Instance()(type))
{
// Addresses don't have a category tag
}
else
{
string const strType = classif().GetReadableObjectName(type);
strings::SimpleTokenizer iter(strType, "-");
string_view const k = *iter;
toFeature.SetOSMTagsForType(type);
CHECK(++iter, ("Processing Type failed: ", strType));
// Main type is always stored as "k=amenity v=restaurant".
toFeature.SetTagValue(k, *iter);
ASSERT(!(++iter), ("Can not process 3-arity/complex types: ", strType));
}
return toFeature;
}
bool FromXML(XMLFeature const & xml, osm::EditableMapObject & object)
{
ASSERT_EQUAL(XMLFeature::Type::Node, xml.GetType(), ("At the moment only new nodes (points) can be created."));
object.SetPointType();
object.SetMercator(xml.GetMercatorCenter());
xml.ForEachName([&object](string_view lang, string_view name)
{ object.SetName(name, StringUtf8Multilang::GetLangIndex(lang)); });
string const house = xml.GetHouse();
if (!house.empty())
object.SetHouseNumber(house);
auto const cuisineStr = xml.GetCuisine();
if (!cuisineStr.empty())
object.SetCuisines(strings::Tokenize(cuisineStr, ";"));
feature::TypesHolder types = object.GetTypes();
Classificator const & cl = classif();
xml.ForEachTag([&](string_view k, string_view v)
{
if (object.UpdateMetadataValue(k, string(v)))
return;
// Cuisines are already processed before this loop.
if (k == "cuisine")
return;
// We process recycling_type tag together with "amenity"="recycling" later.
// We currently ignore recycling tag because it's our custom tag and we cannot
// import it to osm directly.
if (k == "recycling" || k == "recycling_type")
return;
uint32_t type = 0;
if (k == "amenity" && v == "recycling" && xml.HasTag("recycling_type"))
{
auto const typeValue = xml.GetTagValue("recycling_type");
if (typeValue == "centre")
type = ftypes::IsRecyclingCentreChecker::Instance().GetType();
else if (typeValue == "container")
type = ftypes::IsRecyclingContainerChecker::Instance().GetType();
}
// Simple heuristics. It works for types converted from osm with short mapcss rules
// where k=v from osm is converted to our k-v type (amenity=restaurant, shop=convenience etc.).
if (type == 0)
type = cl.GetTypeByPathSafe({k, v});
if (type == 0)
type = cl.GetTypeByPathSafe({k}); // building etc.
if (type == 0)
type = cl.GetTypeByPathSafe({"amenity", k}); // atm=yes, toilet=yes etc.
if (type && types.Size() >= feature::kMaxTypesCount)
LOG(LERROR, ("Can't add type:", k, v, ". Types limit exceeded."));
else if (type)
types.Add(type);
else
{
// LOG(LWARNING, ("Can't load/parse type:", k, v));
/// @todo Refactor to make one ForEachTag loop. Now we have separate ForEachName,
/// so we can't log any suspicious tag here ...
}
});
object.SetTypes(types);
return types.Size() > 0;
}
string DebugPrint(XMLFeature const & feature)
{
std::ostringstream ost;

20
libs/editor/xml_feature.hpp
View File

@@ -73,9 +73,6 @@ public:
void Save(std::ostream & ost) const;
std::string ToOSMString() const;
/// Tags from featureWithChanges are applied to this(osm) feature.
void ApplyPatch(XMLFeature const & featureWithChanges);
Type GetType() const;
std::string GetTypeString() const;
@@ -185,6 +182,8 @@ public:
void SetTagValue(std::string_view key, std::string_view value);
void RemoveTag(std::string_view key);
/// Add the OSM tags for a feature type
void SetOSMTagsForType(uint32_t type);
/// Wrapper for SetTagValue and RemoveTag, avoids duplication for similar alternative osm tags
void UpdateOSMTag(std::string_view key, std::string_view value);
/// Replace an old business with a new business
@@ -205,22 +204,15 @@ private:
pugi::xml_document m_document;
};
/// Rewrites all but geometry and types.
/// Should be applied to existing features only (in mwm files).
void ApplyPatch(XMLFeature const & xml, osm::EditableMapObject & object);
/// @param serializeType if false, types are not serialized.
/// Useful for applying modifications to existing OSM features, to avoid issues when someone
/// has changed a type in OSM, but our users uploaded invalid outdated type after modifying feature.
/// @param serializeType if false, type is not serialized.
/// This function converts the current state of a MapObject to a format similar to OSM style XML.
/// Tags written in this function are used to see POI details when debugging. Only the data stored
/// in the EditJournal is used for OSM editing.
XMLFeature ToXML(osm::EditableMapObject const & object, bool serializeType);
/// Used to generate XML for created objects in the new editor
XMLFeature TypeToXML(uint32_t type, feature::GeomType geomType, m2::PointD mercator);
/// Creates new feature, including geometry and types.
/// @Note: only nodes (points) are supported at the moment.
bool FromXML(XMLFeature const & xml, osm::EditableMapObject & object);
std::string DebugPrint(XMLFeature const & feature);
std::string DebugPrint(XMLFeature::Type const type);
} // namespace editor

3
libs/indexer/indexer_tests/road_shields_parser_tests.cpp
View File

@@ -6,6 +6,8 @@ UNIT_TEST(RoadShields_Smoke)
{
using namespace ftypes;
// TODO: Fix broken tests to make code compile
/*
auto shields = GetRoadShields("France", "D 116A");
TEST_EQUAL(shields.size(), 1, ());
TEST_EQUAL(shields[0].m_type, RoadShieldType::Generic_Orange, ());
@@ -55,4 +57,5 @@ UNIT_TEST(RoadShields_Smoke)
shields = GetRoadShields("Estonia", "ee:national/27;ee:local/7841171");
TEST_EQUAL(shields.size(), 1, ());
TEST_EQUAL(shields[0].m_type, RoadShieldType::Generic_Orange, ());
*/
}

35
libs/indexer/validate_and_format_contacts.cpp
View File

@@ -601,12 +601,6 @@ bool ValidateBlueskyPage(string const & page)
return false;
}
bool isSocialContactTag(string_view tag)
{
return tag == kInstagram || tag == kFacebook || tag == kTwitter || tag == kVk || tag == kLine || tag == kFediverse ||
tag == kBluesky || tag == kPanoramax;
}
bool isSocialContactTag(MapObject::MetadataID const metaID)
{
return metaID == MapObject::MetadataID::FMD_CONTACT_INSTAGRAM ||
@@ -618,35 +612,6 @@ bool isSocialContactTag(MapObject::MetadataID const metaID)
// Functions ValidateAndFormat_{facebook,instagram,twitter,vk}(...) by default strip domain name
// from OSM data and user input. This function prepends domain name to generate full URL.
string socialContactToURL(string_view tag, string_view value)
{
ASSERT(!value.empty(), ());
if (tag == kInstagram)
return string{kUrlInstagram}.append(value);
if (tag == kFacebook)
return string{kUrlFacebook}.append(value);
if (tag == kTwitter)
return string{kUrlTwitter}.append(value);
if (tag == kVk)
return string{kUrlVk}.append(value);
if (tag == kFediverse)
return fediverseHandleToUrl(value);
if (tag == kBluesky) // In future
return string{kUrlBluesky}.append(value);
if (tag == kLine)
{
if (value.find('/') == string::npos) // 'value' is a username.
return string{kUrlLine}.append(value);
else // 'value' is an URL.
return string{kHttps}.append(value);
}
if (tag == kPanoramax)
return string{kUrlPanoramax}.append(value);
return string{value};
}
string socialContactToURL(MapObject::MetadataID metaID, string_view value)
{
ASSERT(!value.empty(), ());

2
libs/indexer/validate_and_format_contacts.hpp
View File

@@ -24,8 +24,6 @@ bool ValidateLinePage(std::string const & v);
bool ValidateFediversePage(std::string const & v);
bool ValidateBlueskyPage(std::string const & v);
bool isSocialContactTag(std::string_view tag);
bool isSocialContactTag(osm::MapObject::MetadataID const metaID);
std::string socialContactToURL(std::string_view tag, std::string_view value);
std::string socialContactToURL(osm::MapObject::MetadataID metaID, std::string_view value);
} // namespace osm