private bool Equals(PointShapeContent left, PointShapeContent right)
{
var sameContentLength = left.ContentLength.Equals(right.ContentLength);
var sameShapeType = left.ShapeType.Equals(right.ShapeType);
var sameShape = left.Shape.Equals(right.Shape);
return(sameContentLength && sameShapeType && sameShape);
}
public Task When_road_nodes_were_imported()
{
var data = _fixture
.CreateMany <ImportedRoadNode>(new Random().Next(1, 100))
.Select(@event =>
{
var point = GeometryTranslator.Translate(@event.Geometry);
var pointShapeContent = new PointShapeContent(
Be.Vlaanderen.Basisregisters.Shaperon.Geometries.GeometryTranslator.FromGeometryPoint(
new NetTopologySuite.Geometries.Point(point.X, point.Y)
)
);
var expectedRecord = new RoadNodeRecord
{
Id = @event.Id,
DbaseRecord = new RoadNodeDbaseRecord
{
WK_OIDN = { Value = @event.Id },
WK_UIDN = { Value = @event.Id + "_" + @event.Version },
TYPE = { Value = RoadNodeType.Parse(@event.Type).Translation.Identifier },
LBLTYPE =
{
Value = RoadNodeType.Parse(@event.Type).Translation.Name
},
BEGINTIJD = { Value = @event.Origin.Since },
BEGINORG = { Value = @event.Origin.OrganizationId },
LBLBGNORG = { Value = @event.Origin.Organization }
}.ToBytes(_services.MemoryStreamManager, Encoding.UTF8),
ShapeRecordContent = pointShapeContent.ToBytes(_services.MemoryStreamManager, Encoding.UTF8),
ShapeRecordContentLength = pointShapeContent.ContentLength.ToInt32(),
BoundingBox = RoadNodeBoundingBox.From(pointShapeContent.Shape)
};
return(new
{
ImportedRoadNode = @event,
ExpectedRecord = expectedRecord
});
}).ToList();
return(new RoadNodeRecordProjection(new RecyclableMemoryStreamManager(), Encoding.UTF8)
.Scenario()
.Given(data.Select(d => d.ImportedRoadNode))
.Expect(data.Select(d => d.ExpectedRecord)));
}
public RoadNodeRecordProjection(RecyclableMemoryStreamManager manager, Encoding encoding)
{
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
When <Envelope <ImportedRoadNode> >(async(context, envelope, token) =>
{
var typeTranslation = RoadNodeType.Parse(envelope.Message.Type).Translation;
var dbaseRecord = new RoadNodeDbaseRecord
{
WK_OIDN = { Value = envelope.Message.Id },
WK_UIDN = { Value = envelope.Message.Id + "_" + envelope.Message.Version },
TYPE = { Value = typeTranslation.Identifier },
LBLTYPE = { Value = typeTranslation.Name },
BEGINTIJD = { Value = envelope.Message.Origin.Since },
BEGINORG = { Value = envelope.Message.Origin.OrganizationId },
LBLBGNORG = { Value = envelope.Message.Origin.Organization }
};
var point = GeometryTranslator.FromGeometryPoint(BackOffice.Core.GeometryTranslator.Translate(envelope.Message.Geometry));
var pointShapeContent = new PointShapeContent(point);
await context.RoadNodes.AddAsync(new RoadNodeRecord
{
Id = envelope.Message.Id,
ShapeRecordContent = pointShapeContent.ToBytes(manager, encoding),
ShapeRecordContentLength = pointShapeContent.ContentLength.ToInt32(),
DbaseRecord = dbaseRecord.ToBytes(manager, encoding),
BoundingBox = RoadNodeBoundingBox.From(pointShapeContent.Shape)
}, token);
});
When <Envelope <RoadNetworkChangesBasedOnArchiveAccepted> >(async(context, envelope, token) =>
{
foreach (var message in envelope.Message.Changes.Flatten())
{
switch (message)
{
case RoadNodeAdded node:
var typeTranslation = RoadNodeType.Parse(node.Type).Translation;
var dbaseRecord = new RoadNodeDbaseRecord
{
WK_OIDN = { Value = node.Id },
WK_UIDN = { Value = node.Id + "_0" }, // 1?
TYPE = { Value = typeTranslation.Identifier },
LBLTYPE = { Value = typeTranslation.Name },
BEGINTIJD = { Value = LocalDateTimeTranslator.TranslateFromWhen(envelope.Message.When) },
BEGINORG = { Value = envelope.Message.OrganizationId },
LBLBGNORG = { Value = envelope.Message.Organization }
};
var point = GeometryTranslator.FromGeometryPoint(BackOffice.Core.GeometryTranslator.Translate(node.Geometry));
var pointShapeContent = new PointShapeContent(point);
await context.RoadNodes.AddAsync(new RoadNodeRecord
{
Id = node.Id,
ShapeRecordContent = pointShapeContent.ToBytes(manager, encoding),
ShapeRecordContentLength = pointShapeContent.ContentLength.ToInt32(),
DbaseRecord = dbaseRecord.ToBytes(manager, encoding),
BoundingBox = RoadNodeBoundingBox.From(pointShapeContent.Shape)
}, token);
break;
}
}
});
}
static void Main(string[] args)
{
Directory.CreateDirectory("output");
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
var node1Record = new RoadNodeChangeDbaseRecord();
node1Record.TYPE.Value = (short)RoadNodeType.EndNode.Translation.Identifier;
node1Record.RECORDTYPE.Value = (short)RecordType.Added.Translation.Identifier;
node1Record.WEGKNOOPID.Value = 1;
var node1Shape = new PointShapeContent(new Point(0.0, 0.0));
var node2Record = new RoadNodeChangeDbaseRecord();
node2Record.TYPE.Value = (short)RoadNodeType.EndNode.Translation.Identifier;
node2Record.RECORDTYPE.Value = (short)RecordType.Added.Translation.Identifier;
node2Record.WEGKNOOPID.Value = 2;
var node2Shape = new PointShapeContent(new Point(0.0, 1.0));
var segment1Record = new RoadSegmentChangeDbaseRecord();
segment1Record.WS_OIDN.Value = 1;
segment1Record.B_WK_OIDN.Value = 1;
segment1Record.E_WK_OIDN.Value = 2;
segment1Record.TGBEP.Value = (short)RoadSegmentAccessRestriction.PublicRoad.Translation.Identifier;
segment1Record.STATUS.Value = RoadSegmentStatus.InUse.Translation.Identifier;
segment1Record.WEGCAT.Value = RoadSegmentCategory.SecondaryRoad.Translation.Identifier;
segment1Record.METHODE.Value = (short)RoadSegmentGeometryDrawMethod.Measured.Translation.Identifier;
segment1Record.MORFOLOGIE.Value = (short)RoadSegmentMorphology.Motorway.Translation.Identifier;
segment1Record.LSTRNMID.Value = 123;
segment1Record.RSTRNMID.Value = 456;
segment1Record.BEHEERDER.Value = "-8";
segment1Record.RECORDTYPE.Value = (short)RecordType.Added.Translation.Identifier;
var segmentShape = new PolyLineMShapeContent(GeometryTranslator.FromGeometryMultiLineString(new NetTopologySuite.Geometries.MultiLineString(new NetTopologySuite.Geometries.LineString[]
{
new NetTopologySuite.Geometries.LineString(new NetTopologySuite.Geometries.Implementation.CoordinateArraySequence(new[]
{
new NetTopologySuite.Geometries.CoordinateM(0.0, 0.0, 0.0),
new NetTopologySuite.Geometries.CoordinateM(0.0, 1.0, 1.0)
}), GeometryConfiguration.GeometryFactory)
})));
var laneRecord = new RoadSegmentLaneChangeDbaseRecord();
laneRecord.RS_OIDN.Value = 1;
laneRecord.WS_OIDN.Value = 1;
laneRecord.RICHTING.Value = (short)RoadSegmentLaneDirection.Independent.Translation.Identifier;
laneRecord.AANTAL.Value = 2;
laneRecord.VANPOSITIE.Value = 0.0;
laneRecord.TOTPOSITIE.Value = 1.0;
laneRecord.RECORDTYPE.Value = (short)RecordType.Added.Translation.Identifier;
var surfaceRecord = new RoadSegmentSurfaceChangeDbaseRecord();
surfaceRecord.WV_OIDN.Value = 1;
surfaceRecord.WS_OIDN.Value = 1;
surfaceRecord.TYPE.Value = (short)RoadSegmentSurfaceType.SolidSurface.Translation.Identifier;
surfaceRecord.VANPOSITIE.Value = 0.0;
surfaceRecord.TOTPOSITIE.Value = 1.0;
surfaceRecord.RECORDTYPE.Value = (short)RecordType.Added.Translation.Identifier;
var widthRecord = new RoadSegmentWidthChangeDbaseRecord();
widthRecord.WB_OIDN.Value = 1;
widthRecord.WS_OIDN.Value = 1;
widthRecord.BREEDTE.Value = 1;
widthRecord.VANPOSITIE.Value = 0.0;
widthRecord.TOTPOSITIE.Value = 1.0;
widthRecord.RECORDTYPE.Value = (short)RecordType.Added.Translation.Identifier;
var nodeDbaseHeader = new DbaseFileHeader(
DateTime.Now,
DbaseCodePage.Western_European_ANSI,
new DbaseRecordCount(2),
new RoadNodeChangeDbaseSchema());
var nodeShapeHeader = new ShapeFileHeader(
ShapeFileHeader.Length.Plus(node1Shape.ContentLength).Plus(node2Shape.ContentLength),
ShapeType.Point,
BoundingBox3D
.FromGeometry(node1Shape.Shape)
.ExpandWith(
BoundingBox3D.FromGeometry(node2Shape.Shape)
)
);
// node
using (var nodeDbaseFile = new BinaryWriter(File.OpenWrite("output/WEGKNOOP_ALL.dbf")))
using (var nodeDbaseWriter = new DbaseBinaryWriter(nodeDbaseHeader, nodeDbaseFile))
{
nodeDbaseWriter.Write(node1Record);
nodeDbaseWriter.Write(node2Record);
}
using (var nodeShapeIndexFile = new BinaryWriter(File.OpenWrite("output/WEGKNOOP_ALL.shx")))
using (var nodeShapeFile = new BinaryWriter(File.OpenWrite("output/WEGKNOOP_ALL.shp")))
using (var nodeShapeWriter = new ShapeBinaryWriter(nodeShapeHeader, nodeShapeFile))
using (var nodeShapeIndexWriter =
new ShapeIndexBinaryWriter(nodeShapeHeader.ForIndex(new ShapeRecordCount(2)), nodeShapeIndexFile))
{
var node1ShapeRecord = node1Shape.RecordAs(RecordNumber.Initial);
nodeShapeWriter.Write(node1ShapeRecord);
var node2ShapeRecord = node2Shape.RecordAs(RecordNumber.Initial.Next());
nodeShapeWriter.Write(node2ShapeRecord);
var offset = ShapeIndexRecord.InitialOffset;
var node1ShapeIndexRecord = node1ShapeRecord.IndexAt(offset);
var node2ShapeIndexRecord = node2ShapeRecord.IndexAt(offset.Plus(node1ShapeRecord.Length));
nodeShapeIndexWriter.Write(node1ShapeIndexRecord);
nodeShapeIndexWriter.Write(node2ShapeIndexRecord);
}
// segment
var segmentDbaseHeader = new DbaseFileHeader(
DateTime.Now,
DbaseCodePage.Western_European_ANSI,
new DbaseRecordCount(1),
new RoadSegmentChangeDbaseSchema());
var segmentShapeHeader = new ShapeFileHeader(
ShapeFileHeader.Length.Plus(segmentShape.ContentLength),
ShapeType.PolyLineM,
BoundingBox3D
.FromGeometry(segmentShape.Shape)
);
using (var segmentDbaseFile = new BinaryWriter(File.OpenWrite("output/WEGSEGMENT_ALL.dbf")))
using (var segmentDbaseWriter = new DbaseBinaryWriter(segmentDbaseHeader, segmentDbaseFile))
{
segmentDbaseWriter.Write(segment1Record);
}
using (var segmentShapeIndexFile = new BinaryWriter(File.OpenWrite("output/WEGSEGMENT_ALL.shx")))
using (var segmentShapeFile = new BinaryWriter(File.OpenWrite("output/WEGSEGMENT_ALL.shp")))
using (var segmentShapeWriter = new ShapeBinaryWriter(segmentShapeHeader, segmentShapeFile))
using (var segmentShapeIndexWriter =
new ShapeIndexBinaryWriter(segmentShapeHeader.ForIndex(new ShapeRecordCount(2)), segmentShapeIndexFile))
{
var segment1ShapeRecord = segmentShape.RecordAs(RecordNumber.Initial);
segmentShapeWriter.Write(segment1ShapeRecord);
var offset = ShapeIndexRecord.InitialOffset;
var segment1ShapeIndexRecord = segment1ShapeRecord.IndexAt(offset);
segmentShapeIndexWriter.Write(segment1ShapeIndexRecord);
}
// lane
var laneDbaseHeader = new DbaseFileHeader(
DateTime.Now,
DbaseCodePage.Western_European_ANSI,
new DbaseRecordCount(1),
new RoadSegmentLaneChangeDbaseSchema());
using (var laneDbaseFile = new BinaryWriter(File.OpenWrite("output/ATTRIJSTROKEN_ALL.DBF")))
using (var laneDbaseWriter = new DbaseBinaryWriter(laneDbaseHeader, laneDbaseFile))
{
laneDbaseWriter.Write(laneRecord);
}
// width
var widthDbaseHeader = new DbaseFileHeader(
DateTime.Now,
DbaseCodePage.Western_European_ANSI,
new DbaseRecordCount(1),
new RoadSegmentWidthChangeDbaseSchema());
using (var widthDbaseFile = new BinaryWriter(File.OpenWrite("output/ATTWEGBREEDTE_ALL.DBF")))
using (var widthDbaseWriter = new DbaseBinaryWriter(widthDbaseHeader, widthDbaseFile))
{
widthDbaseWriter.Write(widthRecord);
}
// surface
var surfaceDbaseHeader = new DbaseFileHeader(
DateTime.Now,
DbaseCodePage.Western_European_ANSI,
new DbaseRecordCount(1),
new RoadSegmentSurfaceChangeDbaseSchema());
using (var surfaceDbaseFile = new BinaryWriter(File.OpenWrite("output/ATTWEGVERHARDING_ALL.DBF")))
using (var surfaceDbaseWriter = new DbaseBinaryWriter(surfaceDbaseHeader, surfaceDbaseFile))
{
surfaceDbaseWriter.Write(surfaceRecord);
}
// european road
var europeanRoadRecord = new EuropeanRoadChangeDbaseRecord();
europeanRoadRecord.EU_OIDN.Value = 1;
europeanRoadRecord.WS_OIDN.Value = 1;
europeanRoadRecord.EUNUMMER.Value = EuropeanRoadNumber.E40.ToString();
europeanRoadRecord.RECORDTYPE.Value = (short)RecordType.Added.Translation.Identifier;
var europeanDbaseHeader = new DbaseFileHeader(
DateTime.Now,
DbaseCodePage.Western_European_ANSI,
new DbaseRecordCount(1),
new EuropeanRoadChangeDbaseSchema());
using (var europeanDbaseFile = new BinaryWriter(File.OpenWrite("output/ATTEUROPWEG_ALL.DBF")))
using (var europeanDbaseWriter = new DbaseBinaryWriter(europeanDbaseHeader, europeanDbaseFile))
{
europeanDbaseWriter.Write(europeanRoadRecord);
}
// national road
var nationalRoadRecord = new NationalRoadChangeDbaseRecord();
nationalRoadRecord.NW_OIDN.Value = 1;
nationalRoadRecord.WS_OIDN.Value = 1;
nationalRoadRecord.IDENT2.Value = NationalRoadNumber.All[5].ToString();
nationalRoadRecord.RECORDTYPE.Value = (short)RecordType.Added.Translation.Identifier;
var nationalDbaseHeader = new DbaseFileHeader(
DateTime.Now,
DbaseCodePage.Western_European_ANSI,
new DbaseRecordCount(1),
new NationalRoadChangeDbaseSchema());
using (var nationalDbaseFile = new BinaryWriter(File.OpenWrite("output/ATTNATIONWEG_ALL.DBF")))
using (var nationalDbaseWriter = new DbaseBinaryWriter(nationalDbaseHeader, nationalDbaseFile))
{
nationalDbaseWriter.Write(nationalRoadRecord);
}
// numbered road
var numberedRoadRecord = new NumberedRoadChangeDbaseRecord();
numberedRoadRecord.GW_OIDN.Value = 1;
numberedRoadRecord.WS_OIDN.Value = 1;
numberedRoadRecord.IDENT8.Value = NumberedRoadNumber.Parse("A0001231").ToString();
numberedRoadRecord.RICHTING.Value = (short)RoadSegmentNumberedRoadDirection.Backward.Translation.Identifier;
numberedRoadRecord.VOLGNUMMER.Value = 1;
numberedRoadRecord.RECORDTYPE.Value = (short)RecordType.Added.Translation.Identifier;
var numberedDbaseHeader = new DbaseFileHeader(
DateTime.Now,
DbaseCodePage.Western_European_ANSI,
new DbaseRecordCount(1),
new NumberedRoadChangeDbaseSchema());
using (var numberedDbaseFile = new BinaryWriter(File.OpenWrite("output/ATTGENUMWEG_ALL.DBF")))
using (var numberedDbaseWriter = new DbaseBinaryWriter(numberedDbaseHeader, numberedDbaseFile))
{
numberedDbaseWriter.Write(numberedRoadRecord);
}
// grade separated junction
var gradeSeparatedJunctionRecord = new GradeSeparatedJunctionChangeDbaseRecord();
gradeSeparatedJunctionRecord.OK_OIDN.Value = 1;
gradeSeparatedJunctionRecord.BO_WS_OIDN.Value = 1;
gradeSeparatedJunctionRecord.ON_WS_OIDN.Value = 1;
gradeSeparatedJunctionRecord.TYPE.Value = (short)GradeSeparatedJunctionType.Unknown.Translation.Identifier;
gradeSeparatedJunctionRecord.RECORDTYPE.Value = (short)RecordType.Added.Translation.Identifier;
var gradeSeparatedJunctionDbaseHeader = new DbaseFileHeader(
DateTime.Now,
DbaseCodePage.Western_European_ANSI,
new DbaseRecordCount(1),
new GradeSeparatedJunctionChangeDbaseSchema());
using (var gradeSeparatedJunctionDbaseFile = new BinaryWriter(File.OpenWrite("output/RLTOGKRUISING_ALL.DBF")))
using (var gradeSeparatedJunctionDbaseWriter = new DbaseBinaryWriter(gradeSeparatedJunctionDbaseHeader, gradeSeparatedJunctionDbaseFile))
{
gradeSeparatedJunctionDbaseWriter.Write(gradeSeparatedJunctionRecord);
}
// transaction zone
var transactionZoneRecord = new TransactionZoneDbaseRecord();
transactionZoneRecord.ORG.Value = "11053";
transactionZoneRecord.OPERATOR.Value = "Yves Reynhout";
transactionZoneRecord.TYPE.Value = 1;
transactionZoneRecord.SOURCE_ID.Value = 1;
transactionZoneRecord.BESCHRIJV.Value = "Nieuwe wijk";
transactionZoneRecord.APPLICATIE.Value = "Wegenregister BLL";
var transactionZoneDbaseHeader = new DbaseFileHeader(
DateTime.Now,
DbaseCodePage.Western_European_ANSI,
new DbaseRecordCount(1),
TransactionZoneDbaseRecord.Schema);
using (var transactionZoneDbaseFile = new BinaryWriter(File.OpenWrite("output/TRANSACTIEZONE.DBF")))
using (var transactionZoneDbaseWriter = new DbaseBinaryWriter(transactionZoneDbaseHeader, transactionZoneDbaseFile))
{
transactionZoneDbaseWriter.Write(transactionZoneRecord);
}
var suffix =
DateTimeOffset.UtcNow.ToString("yyyyMMdd") + "-" +
Convert.ToInt32(DateTimeOffset.UtcNow.TimeOfDay.TotalSeconds);
using (var archiveStream = File.OpenWrite($"output/oplading-{suffix}.zip"))
using (var archive = new ZipArchive(archiveStream, ZipArchiveMode.Create))
{
foreach (var file in Directory.EnumerateFiles("output"))
{
if (file.ToLowerInvariant().EndsWith(".dbf") ||
file.ToLowerInvariant().EndsWith(".shp") ||
file.ToLowerInvariant().EndsWith(".shx"))
{
var entry = archive.CreateEntry(Path.GetFileName(file));
using (var fileStream = File.OpenRead(file))
using (var entryStream = entry.Open())
{
fileStream.CopyTo(entryStream);
}
}
}
}
}
public AddressExtractProjection(IOptions <ExtractConfig> extractConfig, Encoding encoding, WKBReader wkbReader)
{
_encoding = encoding ?? throw new ArgumentNullException(nameof(encoding));
When <Envelope <AddressWasRegistered> >(async(context, message, ct) =>
{
await context.AddressExtract.AddAsync(new AddressExtractItem
{
AddressId = message.Message.AddressId,
StreetNameId = message.Message.StreetNameId,
Complete = false,
DbaseRecord = new AddressDbaseRecord
{
huisnr = { Value = message.Message.HouseNumber },
versieid = { Value = message.Message.Provenance.Timestamp.ToBelgianDateTimeOffset().FromDateTimeOffset() }
}.ToBytes(_encoding),
}, cancellationToken: ct);
});
When <Envelope <AddressBecameComplete> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
item.Complete = true;
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressStreetNameWasChanged> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
item.StreetNameId = message.Message.StreetNameId;
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressStreetNameWasCorrected> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
item.StreetNameId = message.Message.StreetNameId;
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressBecameCurrent> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.status.Value = StatusCurrent);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressBecameIncomplete> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
if (item != null) // in rare cases were we might get this event after an AddressWasRemoved event, we can just ignore it
{
item.Complete = false;
UpdateVersie(item, message.Message.Provenance.Timestamp);
}
});
When <Envelope <AddressBecameNotOfficiallyAssigned> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.offtoegknd.Value = false);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressHouseNumberWasChanged> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.huisnr.Value = message.Message.HouseNumber);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressHouseNumberWasCorrected> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.huisnr.Value = message.Message.HouseNumber);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressOfficialAssignmentWasRemoved> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
if (item != null) // in rare cases were we might get this event after an AddressWasRemoved event, we can just ignore it
{
UpdateDbaseRecordField(item, record => record.offtoegknd.Value = null);
UpdateVersie(item, message.Message.Provenance.Timestamp);
}
});
When <Envelope <AddressPersistentLocalIdWasAssigned> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
if (item != null) // in rare cases were we might get this event after an AddressWasRemoved event, we can just ignore it
{
UpdateDbaseRecordField(item, record =>
{
record.id.Value = $"{extractConfig.Value.DataVlaanderenNamespace}/{message.Message.PersistentLocalId}";
record.adresid.Value = message.Message.PersistentLocalId;
});
}
});
When <Envelope <AddressPositionWasCorrected> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
if (item != null) // in rare cases were we might get this event after an AddressWasRemoved event, we can just ignore it
{
UpdateDbaseRecordField(item, record =>
{
record.posgeommet.Value = Map(message.Message.GeometryMethod);
record.posspec.Value = Map(message.Message.GeometrySpecification);
});
var coordinate = wkbReader.Read(message.Message.ExtendedWkbGeometry.ToByteArray()).Coordinate;
var pointShapeContent = new PointShapeContent(new Point(coordinate.X, coordinate.Y));
item.ShapeRecordContent = pointShapeContent.ToBytes();
item.ShapeRecordContentLength = pointShapeContent.ContentLength.ToInt32();
item.MinimumX = pointShapeContent.Shape.X;
item.MaximumX = pointShapeContent.Shape.X;
item.MinimumY = pointShapeContent.Shape.Y;
item.MaximumY = pointShapeContent.Shape.Y;
UpdateVersie(item, message.Message.Provenance.Timestamp);
}
});
When <Envelope <AddressPositionWasRemoved> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
if (item != null) // in rare cases were we might get this event after an AddressWasRemoved event, we can just ignore it
{
UpdateDbaseRecordField(item, record =>
{
record.posgeommet.Value = null;
record.posspec.Value = null;
});
item.ShapeRecordContent = null;
item.ShapeRecordContentLength = 0;
item.MaximumX = 0;
item.MinimumX = 0;
item.MaximumY = 0;
item.MinimumY = 0;
UpdateVersie(item, message.Message.Provenance.Timestamp);
}
});
When <Envelope <AddressPostalCodeWasChanged> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.postcode.Value = message.Message.PostalCode);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressPostalCodeWasCorrected> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
if (item != null)
{
UpdateDbaseRecordField(item, record => record.postcode.Value = message.Message.PostalCode);
UpdateVersie(item, message.Message.Provenance.Timestamp);
}
});
When <Envelope <AddressPostalCodeWasRemoved> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
if (item != null)
{
UpdateDbaseRecordField(item, record => record.postcode.Value = null);
UpdateVersie(item, message.Message.Provenance.Timestamp);
}
});
When <Envelope <AddressStatusWasCorrectedToRemoved> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.status.Value = null);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressStatusWasRemoved> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
if (item != null) // in rare cases were we might get this event after an AddressWasRemoved event, we can just ignore it
{
UpdateDbaseRecordField(item, record => record.status.Value = null);
UpdateVersie(item, message.Message.Provenance.Timestamp);
}
});
When <Envelope <AddressWasCorrectedToCurrent> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.status.Value = StatusCurrent);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressWasCorrectedToNotOfficiallyAssigned> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.offtoegknd.Value = false);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressWasCorrectedToOfficiallyAssigned> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.offtoegknd.Value = true);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressWasCorrectedToProposed> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.status.Value = StatusProposed);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressWasCorrectedToRetired> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.status.Value = StatusRetired);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressWasOfficiallyAssigned> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.offtoegknd.Value = true);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressWasPositioned> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
if (item != null) // in rare cases were we might get this event after an AddressWasRemoved event, we can just ignore it
{
UpdateDbaseRecordField(item, record =>
{
record.posgeommet.Value = Map(message.Message.GeometryMethod);
record.posspec.Value = Map(message.Message.GeometrySpecification);
});
var coordinate = wkbReader.Read(message.Message.ExtendedWkbGeometry.ToByteArray()).Coordinate;
var pointShapeContent = new PointShapeContent(new Point(coordinate.X, coordinate.Y));
item.ShapeRecordContent = pointShapeContent.ToBytes();
item.ShapeRecordContentLength = pointShapeContent.ContentLength.ToInt32();
item.MinimumX = pointShapeContent.Shape.X;
item.MaximumX = pointShapeContent.Shape.X;
item.MinimumY = pointShapeContent.Shape.Y;
item.MaximumY = pointShapeContent.Shape.Y;
UpdateVersie(item, message.Message.Provenance.Timestamp);
}
});
When <Envelope <AddressWasProposed> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.status.Value = StatusProposed);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressWasRemoved> >(async(context, message, ct) =>
{
var address = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
context.AddressExtract.Remove(address);
});
When <Envelope <AddressWasRetired> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.status.Value = StatusRetired);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressBoxNumberWasChanged> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.busnr.Value = message.Message.BoxNumber);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressBoxNumberWasCorrected> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.busnr.Value = message.Message.BoxNumber);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressBoxNumberWasRemoved> >(async(context, message, ct) =>
{
var item = await context.AddressExtract.FindAsync(message.Message.AddressId, cancellationToken: ct);
UpdateDbaseRecordField(item, record => record.busnr.Value = null);
UpdateVersie(item, message.Message.Provenance.Timestamp);
});
When <Envelope <AddressHouseNumberWasImportedFromCrab> >(async(context, message, ct) => DoNothing());
When <Envelope <AddressHouseNumberStatusWasImportedFromCrab> >(async(context, message, ct) => DoNothing());
When <Envelope <AddressHouseNumberPositionWasImportedFromCrab> >(async(context, message, ct) => DoNothing());
When <Envelope <AddressHouseNumberMailCantonWasImportedFromCrab> >(async(context, message, ct) => DoNothing());
When <Envelope <AddressSubaddressWasImportedFromCrab> >(async(context, message, ct) => DoNothing());
When <Envelope <AddressSubaddressPositionWasImportedFromCrab> >(async(context, message, ct) => DoNothing());
When <Envelope <AddressSubaddressStatusWasImportedFromCrab> >(async(context, message, ct) => DoNothing());
}
