private async Task Updatehighways(OsmChange changes)
{
var deleteTasks = new List <Task>();
foreach (var highwaysToRemove in changes.Delete.OfType <Way>())
{
var task = _elasticSearchGateway.DeleteHighwaysById(highwaysToRemove.Id.ToString());
deleteTasks.Add(task);
}
await Task.WhenAll(deleteTasks);
var updateTasks = new List <Task <CompleteWay> >();
foreach (var highwaysToUpdate in changes.Modify
.Concat(changes.Create)
.OfType <Way>()
.Where(w => w.Tags != null && w.Tags.ContainsKey("highway")))
{
var task = _osmGateway.GetCompleteWay(highwaysToUpdate.Id.ToString());
updateTasks.Add(task);
}
var updatedWays = await Task.WhenAll(updateTasks);
var geoJsonHighways = _osmGeoJsonPreprocessorExecutor.Preprocess(updatedWays.ToList());
await _elasticSearchGateway.UpdateHighwaysData(geoJsonHighways);
}
public void TestUpdate_OsmChangeFileWithDeletion_ShouldDeleteFromDatabase()
{
var changes = new OsmChange
{
Create = new OsmGeo[0],
Modify = new OsmGeo[0],
Delete = new OsmGeo[] {
new Way()
{
Id = 1, Tags = new TagsCollection {
{ "highway", "track" }
}
}
}
};
_geoJsonPreprocessorExecutor
.Preprocess(Arg.Is <Dictionary <string, List <ICompleteOsmGeo> > >(x => x.Values.Count == 0))
.Returns(new List <Feature>());
_geoJsonPreprocessorExecutor
.Preprocess(Arg.Is <List <CompleteWay> >(x => x.Count == 0))
.Returns(new List <Feature>());
_service.Update(changes).Wait();
_elasticSearchGateway.Received(1).DeleteHighwaysById("way_1");
_elasticSearchGateway.Received(1).DeleteOsmPointOfInterestById("way_1");
}
public void TestUpdate_OsmChangeFileWithModification_ShouldUpdateDatabase()
{
var way = new CompleteWay()
{
Id = 1,
Tags = new TagsCollection {
{ "highway", "track" }, { "route", "bicycle" }
},
Nodes = new Node[0]
};
var changes = new OsmChange
{
Create = new OsmGeo[0],
Modify = new OsmGeo[] { way.ToSimple() },
Delete = new OsmGeo[0]
};
var list = new List <Feature> {
new Feature(new LineString(new Coordinate[0]), new AttributesTable())
};
_geoJsonPreprocessorExecutor
.Preprocess(Arg.Is <Dictionary <string, List <ICompleteOsmGeo> > >(x => x.Values.Count == 1))
.Returns(list);
_geoJsonPreprocessorExecutor
.Preprocess(Arg.Is <List <CompleteWay> >(x => x.Count == 1))
.Returns(list);
_osmGateway.GetCompleteWay(1).Returns(way);
_service.Update(changes).Wait();
_elasticSearchGateway.Received(1).UpdatePointsOfInterestData(Arg.Is <List <Feature> >(x => x.Count == 1));
_elasticSearchGateway.Received(1).UpdateHighwaysData(Arg.Is <List <Feature> >(x => x.Count == 1));
}
/// <summary>
/// Applies the given changes.
/// </summary>
public void ApplyChangeset(OsmChange changeset)
{
if (changeset == null)
{
throw new ArgumentNullException("changeset");
}
if (changeset.Delete != null)
{
this.Delete(changeset.Delete.Select(x => new OsmGeoKey()
{
Id = x.Id.Value,
Type = x.Type
}));
}
if (changeset.Modify != null)
{
this.AddOrUpdate(changeset.Modify);
}
if (changeset.Create != null)
{
this.AddOrUpdate(changeset.Create);
}
}
private async Task UpdatePointsOfInterest(OsmChange changes)
{
var deleteTasks = new List <Task>();
var relevantTagsDictionary = _tagsHelper.GetAllTags();
foreach (var poiToRemove in changes.Delete)
{
var task = _elasticSearchGateway.DeletePointOfInterestById(poiToRemove.Id.ToString(), poiToRemove.Type.ToString().ToLower());
deleteTasks.Add(task);
}
await Task.WhenAll(deleteTasks);
var updateTasks = new List <Task <ICompleteOsmGeo> >();
foreach (var poiToUpdate in changes.Modify
.Concat(changes.Create)
.Where(o => IsRelevantPointOfInterest(o, relevantTagsDictionary)))
{
var task = _osmGateway.GetElement(poiToUpdate.Id.ToString(), poiToUpdate.Type.ToString().ToLower());
updateTasks.Add(task);
}
var allElemets = await Task.WhenAll(updateTasks);
var osmNamesDictionary = allElemets.GroupBy(e => e.Tags.GetName()).ToDictionary(g => g.Key, g => g.ToList());
var geoJsonNamesDictionary = _osmGeoJsonPreprocessorExecutor.Preprocess(osmNamesDictionary);
await _elasticSearchGateway.UpdatePointsOfInterestData(geoJsonNamesDictionary.Values.SelectMany(v => v).ToList());
}
/// <inheritdoc />
public async Task Update(OsmChange changes)
{
_logger.LogInformation("Staring updating from OSM change file");
await Updatehighways(changes);
await UpdatePointsOfInterest(changes);
_logger.LogInformation("Finished updating from OSM change file");
}
public void TestSerialize()
{
var osmChange = new OsmChange()
{
Version = 0.6,
Generator = "OsmSharp",
Create = new OsmGeo[]
{
new Node()
{
Id = 1
},
new Way()
{
Id = 10
},
new Relation()
{
Id = 100
}
},
Modify = new OsmGeo[]
{
new Node()
{
Id = 2
},
new Way()
{
Id = 20
},
new Relation()
{
Id = 200
}
},
Delete = new OsmGeo[]
{
new Node()
{
Id = 3
},
new Way()
{
Id = 30
},
new Relation()
{
Id = 300
}
}
};
var result = osmChange.SerializeToXml();
Assert.AreEqual("<osmChange generator=\"OsmSharp\" version=\"0.6\"><create><node id=\"1\" /><way id=\"10\" /><relation id=\"100\" /></create><modify><node id=\"2\" /><way id=\"20\" /><relation id=\"200\" /></modify><delete><node id=\"3\" /><way id=\"30\" /><relation id=\"300\" /></delete></osmChange>",
result);
}
public DiffResult Upload(OsmChange item)
{
// Won't need this cast after updating OsmApiClient
var changesetId = Client.CreateChangeset((TagsCollection)Tags).Result;
var diffResult = Client.UploadChangeset(changesetId, item).Result;
Client.CloseChangeset(changesetId).Wait();
return(diffResult);
}
public void TestSquashDeleteModifiedCreation()
{
var changeset1 = new OsmChange()
{
Create = new OsmGeo[]
{
new Node()
{
Id = 1,
Version = 1
}
},
Generator = "OsmSharp",
Version = 6
};
var changeset2 = new OsmChange()
{
Modify = new OsmGeo[]
{
new Node()
{
Id = 1,
Version = 3
}
},
Generator = "OsmSharp",
Version = 6
};
var changeset3 = new OsmChange()
{
Delete = new OsmGeo[]
{
new Node()
{
Id = 1,
Version = 3
}
},
Generator = "OsmSharp",
Version = 6
};
// doing the squashing, should undo the creation that was modified.
var squashed = new[] { changeset1, changeset2, changeset3 }.Squash();
Assert.IsNotNull(squashed.Create);
Assert.AreEqual(0, squashed.Create.Length);
Assert.IsNotNull(squashed.Delete);
Assert.AreEqual(0, squashed.Delete.Length);
Assert.IsNotNull(squashed.Modify);
Assert.AreEqual(0, squashed.Modify.Length);
Assert.AreEqual("OsmSharp", squashed.Generator);
Assert.AreEqual(6, squashed.Version);
}
/// <summary>
/// Adds changes.
/// </summary>
public void AddChanges(long id, OsmChange changes)
{
Tuple <Changeset, List <OsmChange> > existing;
if (!_changesets.TryGetValue(id, out existing) ||
existing.Item1.ClosedAt.HasValue)
{
throw new Exception("Cannot add changes to a non-existing or closed changetset.");
}
existing.Item2.Add(changes);
}
private async Task <Stream> CreateStream(OsmChange changes)
{
await Task.Delay(100);
Stream stream = new MemoryStream();
var serializer = new XmlSerializer(typeof(OsmChange));
serializer.Serialize(stream, changes);
stream.Seek(0, SeekOrigin.Begin);
return(stream);
}
public void PutUpdateData_Local_ShouldUpdate()
{
var changes = new OsmChange {
Create = new OsmGeo[] { new Node() }
};
_osmLatestFileFetcherExecutor.GetUpdates().Returns(CreateStream(changes));
SetupContext(IPAddress.Parse("1.2.3.4"), IPAddress.Loopback);
_controller.PutUpdateData().Wait();
_databasesUpdaterService.Received(1).Update(Arg.Is <OsmChange>(x => x.Create.Length == changes.Create.Length));
}
public static OsmChange[] GetChangesFromChangesets(params long[] changeIds)
{
var changes = new List <OsmChange>();
foreach (var changeId in changeIds)
{
OsmChange change = FileSerializer.ReadXmlCacheOrSource(@"CachesChanges\" + changeId + ".osc",
() => { Thread.Sleep(15000); return(OsmApiClient.GetChangesetDownload(changeId).Result); });
changes.Add(change);
}
return(changes.ToArray());
}
public static void FixImportedNames()
{
var nameIndex = OneOffs.GetAllChangeElements(e => e.Tags != null && e.Tags.ContainsKey("addr:unit"))
.GroupBy(e => e.Tags["addr:unit"])
.ToDictionary(g => g.Key, g => g.ToArray());
Console.Write(string.Join(Environment.NewLine,
nameIndex.OrderByDescending(kvp => kvp.Value.Length).Select(kvp => kvp.Value.Length + "x: " + kvp.Key + "\texample: " + kvp.Value.First().Type + " " + kvp.Value.First().Id)));
var nameDestinations = new Dictionary <string, string>
{
};
var toUpdate = new List <OsmGeo>();
var currentKeys = nameDestinations.Keys.SelectMany(n => nameIndex[n].Select(e => new OsmGeoKey(e))).Distinct().ToArray();
var allCurrents = GetCurrentVersionOfElements(currentKeys).ToDictionary(e => new OsmGeoKey(e));
var missing = currentKeys.Except(allCurrents.Keys).Select(k => k.Type + " " + k.Id).ToArray();
foreach (var name in nameDestinations)
{
var keys = nameIndex[name.Key].Select(e => new OsmGeoKey(e)).ToArray();
var currents = keys
.Where(k => allCurrents.ContainsKey(k))
.Select(k => allCurrents[k])
.Where(e => e.Visible == true && e.Tags != null && e.Tags.Contains("addr:unit", name.Key))
.ToArray();
foreach (var element in currents)
{
if (name.Value == null)
{
element.Tags.RemoveKey("addr:unit");
}
else
{
element.Tags.AddOrReplace("addr:unit", name.Value);
}
toUpdate.Add(element);
}
}
var fix = new OsmChange()
{
Modify = toUpdate.ToArray()
};
FileSerializer.WriteXml("temp change.osc", fix);
var changesetTags = GetCommitTags($"Fixing bad addr:unit previously imported.");
var fixIds = Subjects.UploadChange(fix, changesetTags, @"FIX Offices\Uploaded\").Result;
}
/// <summary>
/// Adds the given changeset.
/// </summary>
public void Add(Changeset meta, OsmChange changes)
{
if (meta == null)
{
throw new ArgumentNullException(nameof(meta));
}
if (changes == null)
{
throw new ArgumentNullException(nameof(changes));
}
_db.AddOrUpdate(meta);
_db.AddChanges(meta.Id.Value, changes);
}
public void PutUpdateData_FromTwoThreads_ShouldUpdateTwice()
{
var changes = new OsmChange {
Create = new OsmGeo[] { new Node() }
};
_osmLatestFileFetcherExecutor.GetUpdates().Returns(CreateStream(changes), CreateStream(changes));
SetupContext(IPAddress.Parse("1.2.3.4"), IPAddress.Loopback);
_controller.PutUpdateData().ContinueWith((t) => { });
_controller.PutUpdateData().Wait();
_elasticSearchUpdaterService.Received(2).Update(Arg.Is <OsmChange>(x => x.Create.Length == changes.Create.Length));
}
/// <inheritdoc />
public async Task <DiffResult> UploadChangeset(long changesetId, OsmChange osmChange)
{
var elements = new OsmGeo[][] { osmChange.Create, osmChange.Modify, osmChange.Delete }
.Where(c => c != null).SelectMany(c => c);
foreach (var osmGeo in elements)
{
osmGeo.ChangeSetId = changesetId;
}
var address = BaseAddress + $"0.6/changeset/{changesetId}/upload";
var request = new StringContent(osmChange.SerializeToXml());
return(await Post <DiffResult>(address, request));
}
private static async Task <long> UploadChangePart(this OsmChange part,
TagsCollection tags, BasicAuthClient client, string pathForFiles)
{
var changeSetId = await client.CreateChangeset(tags);
Log.LogDebug($"Creating ChangeSet {changeSetId}");
FileSerializer.WriteXml(Path.Combine(pathForFiles, $"{changeSetId}-Conflated.osc"), part);
var diffResult = await client.UploadChangeset(changeSetId, part);
FileSerializer.WriteXml(Path.Combine(pathForFiles, $"{changeSetId}-DiffResult.diff"), diffResult);
await client.CloseChangeset(changeSetId);
Log.LogDebug($"Closing ChangeSet {changeSetId}");
return(changeSetId);
}
private async Task UpdatePointsOfInterest(OsmChange changes)
{
var deleteTasks = new List <Task>();
var relevantTagsDictionary = _tagsHelper.GetAllTags();
foreach (var poiToRemove in changes.Delete)
{
var task = _elasticSearchGateway.DeleteOsmPointOfInterestById(poiToRemove.Type.ToString().ToLower() + "_" + poiToRemove.Id);
deleteTasks.Add(task);
}
await Task.WhenAll(deleteTasks);
var updateTasks = new List <Task <ICompleteOsmGeo> >();
foreach (var poiToUpdate in changes.Modify
.Concat(changes.Create)
.Where(o => IsRelevantPointOfInterest(o, relevantTagsDictionary)))
{
var task = _osmGateway.GetCompleteElement(poiToUpdate.Id.Value, poiToUpdate.Type);
updateTasks.Add(task);
}
var allElemets = await Task.WhenAll(updateTasks);
var osmNamesDictionary = allElemets.GroupBy(e => e.Tags.GetName()).ToDictionary(g => g.Key, g => g.ToList());
var features = _osmGeoJsonPreprocessorExecutor.Preprocess(osmNamesDictionary);
foreach (var poiToUpdate in changes.Modify
.Where(o => IsRelevantPointOfInterest(o, relevantTagsDictionary)))
{
var featureFromDb = await _elasticSearchGateway.GetPointOfInterestById(poiToUpdate.Type.ToString().ToLower() + "_" + poiToUpdate.Id, Sources.OSM);
if (featureFromDb == null)
{
continue;
}
var featureToUpdate = features.First(f => f.GetId().Equals(featureFromDb.GetId()));
foreach (var attributeKey in featureFromDb.Attributes.GetNames().Where(n => n.StartsWith(FeatureAttributes.POI_PREFIX)))
{
featureToUpdate.Attributes.AddOrUpdate(attributeKey, featureFromDb.Attributes[attributeKey]);
}
if (featureToUpdate.Geometry.OgcGeometryType == OgcGeometryType.Point &&
featureFromDb.Geometry.OgcGeometryType != OgcGeometryType.Point)
{
featureToUpdate.Geometry = featureFromDb.Geometry;
}
}
await _elasticSearchGateway.UpdatePointsOfInterestData(features);
}
public void TestSquashOneSet()
{
var changeset = new OsmChange()
{
Create = new OsmGeo[]
{
new Node()
{
Id = 1,
Version = 1
}
},
Delete = new OsmGeo[]
{
new Way()
{
Id = 1,
Version = 1
}
},
Modify = new OsmGeo[]
{
new Relation()
{
Id = 1,
Version = 2
}
},
Generator = "OsmSharp",
Version = 6
};
// doing the squashing, nothing should happen.
var squashed = new[] { changeset }.Squash();
Assert.IsNotNull(squashed.Create);
Assert.AreEqual(1, squashed.Create.Length);
Assert.AreEqual(OsmGeoType.Node, squashed.Create[0].Type);
Assert.IsNotNull(squashed.Delete);
Assert.AreEqual(1, squashed.Delete.Length);
Assert.AreEqual(OsmGeoType.Way, squashed.Delete[0].Type);
Assert.IsNotNull(squashed.Modify);
Assert.AreEqual(1, squashed.Modify.Length);
Assert.AreEqual(OsmGeoType.Relation, squashed.Modify[0].Type);
Assert.AreEqual("OsmSharp", squashed.Generator);
Assert.AreEqual(6, squashed.Version);
}
public static OsmGeo[] GetElementsFromChanges(params long[] changeIds)
{
var elements = new List <OsmGeo>();
int i = 0;
foreach (var changeId in changeIds)
{
Console.WriteLine(++i + "/" + changeIds.Length + ": " + changeId);
OsmChange fullChange = FileSerializer.ReadXmlCacheOrSource(@"CachesChanges\" + changeId + ".osc",
() => { Thread.Sleep(10000); return(OsmApiClient.GetChangesetDownload(changeId).Result); });
var newElements = fullChange.GetElements();
elements.AddRange(newElements);
}
return(elements.ToArray());
}
public void PutUpdateData_WhileRebuildIsRunning_ShouldNotUpdate()
{
var changes = new OsmChange {
Create = new OsmGeo[] { new Node() }
};
_osmLatestFileFetcherExecutor.Update().Returns(Task.Delay(100));
_osmLatestFileFetcherExecutor.GetUpdates().Returns(CreateStream(changes));
SetupContext(IPAddress.Parse("1.2.3.4"), IPAddress.Loopback);
_controller.PostUpdateData(new UpdateRequest()).ContinueWith((t) => { });
var results = _controller.PutUpdateData().Result as BadRequestObjectResult;
_databasesUpdaterService.DidNotReceive().Update(Arg.Is <OsmChange>(x => x.Create.Length == changes.Create.Length));
Assert.IsNotNull(results);
}
public void TestUpdate_OsmChangeFileWithModification_ShouldUpdateDatabaseUsingPoiPrefixFromDatabase()
{
var way = new CompleteWay()
{
Id = 1,
Tags = new TagsCollection {
{ "highway", "track" }, { "route", "bicycle" }
},
Nodes = new Node[0]
};
var changes = new OsmChange
{
Create = new OsmGeo[0],
Modify = new OsmGeo[] { way.ToSimple() },
Delete = new OsmGeo[0]
};
var wayFeature = new Feature(new LineString(new Coordinate[0]), new AttributesTable {
{ FeatureAttributes.ID, "1" },
{ FeatureAttributes.POI_SOURCE, Sources.OSM }
});
wayFeature.SetId();
var wayFeatureInDatabase = new Feature(new LineString(new Coordinate[0]), new AttributesTable {
{ FeatureAttributes.ID, "1" },
{ FeatureAttributes.POI_CATEGORY, Categories.HISTORIC },
{ FeatureAttributes.POI_SOURCE, Sources.OSM }
});
wayFeatureInDatabase.SetId();
var list = new List <Feature> {
wayFeature
};
_geoJsonPreprocessorExecutor
.Preprocess(Arg.Is <Dictionary <string, List <ICompleteOsmGeo> > >(x => x.Values.Count == 1))
.Returns(list);
_geoJsonPreprocessorExecutor
.Preprocess(Arg.Is <List <CompleteWay> >(x => x.Count == 1))
.Returns(list);
_osmGateway.GetCompleteWay(1).Returns(way);
_elasticSearchGateway.GetPointOfInterestById("way_1", Sources.OSM).Returns(wayFeatureInDatabase);
_service.Update(changes).Wait();
_elasticSearchGateway.Received(1).UpdatePointsOfInterestData(Arg.Is <List <Feature> >(x => x.Count == 1 && x.First().Attributes.Exists(FeatureAttributes.POI_CATEGORY)));
}
public void TestSquashModifyCreation()
{
var changeset1 = new OsmChange()
{
Create = new OsmGeo[]
{
new Node()
{
Id = 1,
Version = 1
}
},
Generator = "OsmSharp",
Version = 6
};
var changeset2 = new OsmChange()
{
Modify = new OsmGeo[]
{
new Node()
{
Id = 1,
Version = 3
}
},
Generator = "OsmSharp",
Version = 6
};
// doing the squashing, should modify the creation.
var squashed = new[] { changeset1, changeset2 }.Squash();
Assert.IsNotNull(squashed.Create);
Assert.AreEqual(1, squashed.Create.Length);
Assert.AreEqual(OsmGeoType.Node, squashed.Create[0].Type);
Assert.AreEqual(1, squashed.Create[0].Id);
Assert.AreEqual(3, squashed.Create[0].Version);
Assert.IsNotNull(squashed.Delete);
Assert.AreEqual(0, squashed.Delete.Length);
Assert.IsNotNull(squashed.Modify);
Assert.AreEqual(0, squashed.Modify.Length);
Assert.AreEqual("OsmSharp", squashed.Generator);
Assert.AreEqual(6, squashed.Version);
}
public void TestUpdate_EmptyOsmChangeFile_ShouldNotUpdateAnything()
{
var changes = new OsmChange {
Create = new OsmGeo[0], Modify = new OsmGeo[0], Delete = new OsmGeo[0]
};
_geoJsonPreprocessorExecutor
.Preprocess(Arg.Is <Dictionary <string, List <ICompleteOsmGeo> > >(x => x.Values.Count == 0))
.Returns(new List <Feature>());
_geoJsonPreprocessorExecutor
.Preprocess(Arg.Is <List <CompleteWay> >(x => x.Count == 0))
.Returns(new List <Feature>());
_service.Update(changes).Wait();
_elasticSearchGateway.Received(1).UpdatePointsOfInterestData(Arg.Is <List <Feature> >(x => x.Count == 0));
_elasticSearchGateway.Received(1).UpdateHighwaysData(Arg.Is <List <Feature> >(x => x.Count == 0));
}
public async Task <DiffResult> UploadChangeset(string changesetId, OsmChange osmChange)
{
using (var client = new HttpClient())
{
foreach (var osmGeo in osmChange.Create.Concat(osmChange.Modify).Concat(osmChange.Delete))
{
osmGeo.ChangeSetId = long.Parse(changesetId);
}
var address = _uploadChangesetAddress.Replace(":id", changesetId);
UpdateHeaders(client, address, "POST");
var response = await client.PostAsync(address, new StringContent(osmChange.SerializeToXml()));
if (response.StatusCode != HttpStatusCode.OK)
{
var message = await response.Content.ReadAsStringAsync();
throw new Exception($"Unable to upload changeset: {message}");
}
var serializer = new XmlSerializer(typeof(DiffResult));
return(serializer.Deserialize(await response.Content.ReadAsStreamAsync()) as DiffResult);
}
}
public static async Task <long[]> UploadChange(OsmChange change, TagsCollection changeTags, string pathForFiles)
{
Log.LogInformation("Uploading change to OSM");
var osmApiClient = new BasicAuthClient(Static.HttpClient,
Static.LogFactory.CreateLogger <BasicAuthClient>(), Static.Config["OsmApiUrl"],
Static.Config["OsmUsername"], Static.Config["OsmPassword"]);
var changeParts = change.SplitByCount().ToArray();
var result = new long[changeParts.Length];
int i = 0;
foreach (var part in changeParts)
{
if (changeParts.Length > 1)
{
changeTags.AddOrReplace("change-part", $"part {i + 1} of {changeParts.Length}");
}
result[i] = await UploadChangePart(part, changeTags, osmApiClient, pathForFiles);
i++;
}
return(result);
}
public static IEnumerable <OsmGeo> GetElements(this OsmChange change)
{
return(new OsmGeo[][] { change.Create, change.Modify, change.Delete }
.Where(a => a != null)
.SelectMany(a => a));
}
/// <summary>
/// Applies a changeset.
/// </summary>
public DiffResultResult ApplyChangeset(long id, OsmChange changeset)
{
if (changeset == null)
{
throw new ArgumentNullException("changeset");
}
var results = new List <OsmGeoResult>();
var nodeTransforms = new Dictionary <long, long>();
var wayTransforms = new Dictionary <long, long>();
var relationTransforms = new Dictionary <long, long>();
if (changeset.Create != null)
{
foreach (var create in changeset.Create)
{
var newId = this.GetNextId(create.Type);
switch (create.Type)
{
case OsmGeoType.Node:
nodeTransforms.Add(create.Id.Value, newId);
break;
case OsmGeoType.Way:
var way = create as Way;
for (var i = 0; i < way.Nodes.Length; i++)
{
long newNodeId;
if (nodeTransforms.TryGetValue(way.Nodes[i], out newNodeId))
{
way.Nodes[i] = newNodeId;
}
}
wayTransforms.Add(create.Id.Value, newId);
break;
case OsmGeoType.Relation:
var relation = create as Relation;
for (var i = 0; i < relation.Members.Length; i++)
{
long newMemberId;
var member = relation.Members[i];
switch (member.Type)
{
case OsmGeoType.Node:
if (nodeTransforms.TryGetValue(member.Id, out newMemberId))
{
member.Id = newMemberId;
}
break;
case OsmGeoType.Way:
if (wayTransforms.TryGetValue(member.Id, out newMemberId))
{
member.Id = newMemberId;
}
break;
case OsmGeoType.Relation:
if (relationTransforms.TryGetValue(member.Id, out newMemberId))
{
member.Id = newMemberId;
}
break;
}
relation.Members[i] = member;
}
relationTransforms.Add(create.Id.Value, newId);
break;
}
results.Add(OsmGeoResult.CreateCreation(
create, newId));
create.Id = newId;
create.Version = 1;
create.TimeStamp = DateTime.Now.ToUniversalTime();
create.Visible = true;
}
this.Add(changeset.Create);
}
if (changeset.Modify != null)
{
_db.Archive(changeset.Modify.Select(x =>
new OsmGeoKey()
{
Id = x.Id.Value,
Type = x.Type
}));
foreach (var modify in changeset.Modify)
{
results.Add(OsmGeoResult.CreateModification(
modify, modify.Version.Value + 1));
switch (modify.Type)
{
case OsmGeoType.Way:
var way = modify as Way;
for (var i = 0; i < way.Nodes.Length; i++)
{
long newNodeId;
if (nodeTransforms.TryGetValue(way.Nodes[i], out newNodeId))
{
way.Nodes[i] = newNodeId;
}
}
break;
case OsmGeoType.Relation:
var relation = modify as Relation;
for (var i = 0; i < relation.Members.Length; i++)
{
long newMemberId;
var member = relation.Members[i];
switch (member.Type)
{
case OsmGeoType.Node:
if (nodeTransforms.TryGetValue(member.Id, out newMemberId))
{
member.Id = newMemberId;
}
break;
case OsmGeoType.Way:
if (wayTransforms.TryGetValue(member.Id, out newMemberId))
{
member.Id = newMemberId;
}
break;
case OsmGeoType.Relation:
if (relationTransforms.TryGetValue(member.Id, out newMemberId))
{
member.Id = newMemberId;
}
break;
}
relation.Members[i] = member;
}
break;
}
modify.Version = modify.Version + 1;
modify.TimeStamp = DateTime.Now.ToUniversalTime();
modify.Visible = true;
}
_db.Add(changeset.Modify);
}
if (changeset.Delete != null)
{
foreach (var delete in changeset.Delete)
{
results.Add(OsmGeoResult.CreateDeletion(
delete));
}
_db.Archive(changeset.Delete.Select(x =>
new OsmGeoKey()
{
Id = x.Id.Value,
Type = x.Type
}));
}
return(new DiffResultResult(new DiffResult()
{
Results = results.ToArray(),
Generator = "OsmSharp",
Version = 0.6f
}, DiffResultStatus.BestEffortOK));
}
/// <summary>
/// Adds the given changeset.
/// </summary>
public void Add(Changeset meta, OsmChange changes)
{
_db.AddOrUpdate(meta);
_db.AddChanges(meta.Id.Value, changes);
}
