public static IEnumerable <ExtractFile> CreateParcelFiles(ExtractContext context)
{
var extractItems = context
.ParcelExtract
.AsNoTracking();
var parcelProjectionState = context
.ProjectionStates
.AsNoTracking()
.Single(m => m.Name == typeof(ParcelExtractProjections).FullName);
var extractMetadata = new Dictionary <string, string>
{
{ ExtractMetadataKeys.LatestEventId, parcelProjectionState.Position.ToString() }
};
yield return(ExtractBuilder.CreateDbfFile <ParcelDbaseRecord>(
ExtractController.ZipName,
new ParcelDbaseSchema(),
extractItems.OrderBy(m => m.CaPaKey).Select(org => org.DbaseRecord),
extractItems.Count));
yield return(ExtractBuilder.CreateMetadataDbfFile(
ExtractController.ZipName,
extractMetadata));
}
public IActionResult Get(
[FromServices] ExtractContext context,
CancellationToken cancellationToken) =>
new IsolationExtractArchive($"{ZipName}-{DateTime.Now:yyyy-MM-dd}", context)
{
PostalRegistryExtractBuilder.CreatePostalFiles(context)
}
.CreateFileCallbackResult(cancellationToken);
public IActionResult Get(
[FromServices] ExtractContext context,
CancellationToken cancellationToken = default) =>
new ExtractArchive($"{ZipName}-{DateTime.Now:yyyy-MM-dd}")
{
ParcelRegistryExtractBuilder.CreateParcelFile(context)
}
.CreateFileCallbackResult(cancellationToken);
public static ExtractFile CreateStreetNameFile(ExtractContext context, SyndicationContext syndicationContext)
{
var extractItems = context
.StreetNameExtract
.AsNoTracking()
.Where(x => x.Complete)
.OrderBy(x => x.StreetNamePersistentLocalId);
var cachedMunicipalities = syndicationContext.MunicipalityLatestItems.AsNoTracking().ToList();
byte[] TransformRecord(StreetNameExtractItem r)
{
var item = new StreetNameDbaseRecord();
item.FromBytes(r.DbaseRecord, DbfFileWriter <StreetNameDbaseRecord> .Encoding);
var municipality = cachedMunicipalities.First(x => x.NisCode == item.gemeenteid.Value);
switch (municipality.PrimaryLanguage)
{
case null:
default:
item.straatnm.Value = r.NameUnknown;
item.homoniemtv.Value = r.HomonymUnknown ?? string.Empty;
break;
case Taal.NL:
item.straatnm.Value = r.NameDutch;
item.homoniemtv.Value = r.HomonymDutch ?? string.Empty;
break;
case Taal.FR:
item.straatnm.Value = r.NameFrench;
item.homoniemtv.Value = r.HomonymFrench ?? string.Empty;
break;
case Taal.DE:
item.straatnm.Value = r.NameGerman;
item.homoniemtv.Value = r.HomonymGerman ?? string.Empty;
break;
case Taal.EN:
item.straatnm.Value = r.NameEnglish;
item.homoniemtv.Value = r.HomonymEnglish ?? string.Empty;
break;
}
return(item.ToBytes(DbfFileWriter <StreetNameDbaseRecord> .Encoding));
}
return(ExtractBuilder.CreateDbfFile <StreetNameExtractItem, StreetNameDbaseRecord>(
ExtractController.ZipName,
new StreetNameDbaseSchema(),
extractItems,
extractItems.Count,
TransformRecord));
}
public IActionResult Get(
[FromServices] ExtractContext context,
[FromServices] SyndicationContext syndicationContext,
CancellationToken cancellationToken = default) =>
new ExtractArchive(ExtractFileNames.GetAddressZip())
{
AddressRegistryExtractBuilder.CreateAddressFiles(context, syndicationContext),
AddressCrabHouseNumberIdExtractBuilder.CreateAddressCrabHouseNumberIdFile(context),
AddressCrabSubaddressIdExtractBuilder.CreateAddressSubaddressIdFile(context)
}
.CreateFileCallbackResult(cancellationToken);
public static ExtractFile CreateParcelFile(ExtractContext context)
{
var extractItems = context
.ParcelExtract
.AsNoTracking();
return(ExtractBuilder.CreateDbfFile <ParcelDbaseRecord>(
ExtractController.ZipName,
new ParcelDbaseSchema(),
extractItems.OrderBy(m => m.CaPaKey).Select(org => org.DbaseRecord),
extractItems.Count));
}
public static ExtractFile CreatePostalFile(ExtractContext context)
{
var extractItems = context
.PostalInformationExtract
.AsNoTracking();
return(ExtractBuilder.CreateDbfFile <PostalDbaseRecord>(
ExtractController.ZipName,
new PostalDbaseSchema(),
extractItems.OrderBy(x => x.PostalCode).Select(org => org.DbaseRecord),
extractItems.Count));
}
public static ExtractFile CreateMunicipalityFile(ExtractContext context)
{
var extractItems = context
.MunicipalityExtract
.OrderBy(x => x.NisCode)
.AsNoTracking();
return(ExtractBuilder.CreateDbfFile <MunicipalityDbaseRecord>(
ExtractController.ZipName,
new MunicipalityDbaseSchema(),
extractItems.OrderBy(x => x.NisCode).Select(org => org.DbaseRecord),
extractItems.Count));
}
public static ExtractFile CreateAddressSubaddressIdFile(ExtractContext context)
{
var extractItems = context
.AddressCrabSubaddressIdExtract
.AsNoTracking()
.Where(m => m.CrabSubaddressId.HasValue && m.PersistentLocalId.HasValue)
.OrderBy(m => m.PersistentLocalId);
return(ExtractBuilder.CreateDbfFile <AddressCrabSubaddressIdDbaseRecord>(
ExtractFileNames.CrabSubadresId,
new AddressCrabSubaddressIdDbaseSchema(),
extractItems.Select(x => x.DbaseRecord),
extractItems.Count));
}
public static async Task <MunicipalityExtractItem> FindAndUpdateMunicipalityExtract(
this ExtractContext context,
Guid municipalityId,
Action <MunicipalityExtractItem> updateFunc,
CancellationToken ct)
{
var municipality = await context
.MunicipalityExtract
.FindAsync(municipalityId, cancellationToken : ct);
if (municipality == null)
{
throw DatabaseItemNotFound(municipalityId);
}
updateFunc(municipality);
return(municipality);
}
public static async Task <PostalInformationExtractItem> FindAndUpdatePostalInformationExtract(
this ExtractContext context,
string postalCode,
Action <PostalInformationExtractItem> updateFunc,
CancellationToken ct)
{
var postalInformation = await context
.PostalInformationExtract
.FindAsync(postalCode, cancellationToken : ct);
if (postalInformation == null)
{
throw DatabaseItemNotFound(postalCode);
}
updateFunc(postalInformation);
return(postalInformation);
}
public static async Task <ParcelExtractItem> FindAndUpdateParcelExtract(
this ExtractContext context,
Guid parcelId,
Action <ParcelExtractItem> updateFunc,
CancellationToken ct)
{
var parcel = await context
.ParcelExtract
.FindAsync(parcelId, cancellationToken : ct);
if (parcel == null)
{
throw DatabaseItemNotFound(parcelId);
}
updateFunc(parcel);
return(parcel);
}
public static async Task <StreetNameExtractItem> FindAndUpdateStreetNameExtract(
this ExtractContext context,
Guid streetNameId,
Action <StreetNameExtractItem> updateFunc,
CancellationToken ct)
{
var streetName = await context
.StreetNameExtract
.FindAsync(streetNameId, cancellationToken : ct);
if (streetName == null)
{
throw DatabaseItemNotFound(streetNameId);
}
updateFunc(streetName);
return(streetName);
}
public IActionResult Get(
[FromServices] ExtractContext context,
[FromServices] UseExtractV2Toggle useExtractV2Toggle,
[FromServices] SyndicationContext syndicationContext,
CancellationToken cancellationToken = default)
{
if (useExtractV2Toggle.FeatureEnabled)
{
return(new IsolationExtractArchive($"{ZipName}-{DateTime.Now:yyyy-MM-dd}", context)
{
StreetNameRegistryExtractBuilder.CreateStreetNameFilesV2(context, syndicationContext)
}
.CreateFileCallbackResult(cancellationToken));
}
return(new IsolationExtractArchive($"{ZipName}-{DateTime.Now:yyyy-MM-dd}", context)
{
StreetNameRegistryExtractBuilder.CreateStreetNameFiles(context, syndicationContext)
}
.CreateFileCallbackResult(cancellationToken));
}
// Only use in staging
public static IEnumerable <ExtractFile> CreateStreetNameFilesV2(ExtractContext context,
SyndicationContext syndicationContext)
{
var extractItems = context
.StreetNameExtractV2
.AsNoTracking()
.Where(x => x.Complete)
.OrderBy(x => x.StreetNamePersistentLocalId);
var streetNameProjectionState = context
.ProjectionStates
.AsNoTracking()
.Single(m => m.Name == typeof(StreetNameExtractProjectionsV2).FullName);
var extractMetadata = new Dictionary <string, string>
{
{ ExtractMetadataKeys.LatestEventId, streetNameProjectionState.Position.ToString() }
};
var cachedMunicipalities = syndicationContext.MunicipalityLatestItems.AsNoTracking().ToList();
byte[] TransformRecord(StreetNameExtractItemV2 r)
{
var item = new StreetNameDbaseRecord();
item.FromBytes(r.DbaseRecord, DbfFileWriter <StreetNameDbaseRecord> .Encoding);
var municipality = cachedMunicipalities.First(x => x.NisCode == item.gemeenteid.Value);
switch (municipality.PrimaryLanguage)
{
case Taal.NL:
item.straatnm.Value = r.NameDutch;
item.homoniemtv.Value = r.HomonymDutch ?? string.Empty;
break;
case Taal.FR:
item.straatnm.Value = r.NameFrench;
item.homoniemtv.Value = r.HomonymFrench ?? string.Empty;
break;
case Taal.DE:
item.straatnm.Value = r.NameGerman;
item.homoniemtv.Value = r.HomonymGerman ?? string.Empty;
break;
case Taal.EN:
item.straatnm.Value = r.NameEnglish;
item.homoniemtv.Value = r.HomonymEnglish ?? string.Empty;
break;
}
return(item.ToBytes(DbfFileWriter <StreetNameDbaseRecord> .Encoding));
}
yield return(ExtractBuilder.CreateDbfFile <StreetNameExtractItemV2, StreetNameDbaseRecord>(
ExtractController.ZipName,
new StreetNameDbaseSchema(),
extractItems,
extractItems.Count,
TransformRecord));
yield return(ExtractBuilder.CreateMetadataDbfFile(
ExtractController.ZipName,
extractMetadata));
}
public static IEnumerable <ExtractFile> CreateAddressFiles(ExtractContext context, SyndicationContext syndicationContext)
{
var extractItems = context
.AddressExtract
.AsNoTracking()
.Where(m => m.Complete)
.OrderBy(m => m.AddressPersistentLocalId);
var cachedMunicipalities = syndicationContext.MunicipalityLatestItems.AsNoTracking().ToList();
var cachedStreetNames = syndicationContext.StreetNameLatestItems.AsNoTracking().ToList();
byte[] TransformRecord(AddressExtractItem r)
{
var item = new AddressDbaseRecord();
item.FromBytes(r.DbaseRecord, DbfFileWriter <AddressDbaseRecord> .Encoding);
// update streetname, municipality
var streetName = cachedStreetNames.First(x => x.StreetNameId == r.StreetNameId);
var municipality = cachedMunicipalities.First(x => x.NisCode == streetName.NisCode);
item.straatnmid.Value = streetName.PersistentLocalId;
switch (municipality.PrimaryLanguage)
{
case null:
case Taal.NL:
default:
item.gemeentenm.Value = municipality.NameDutch;
item.straatnm.Value = streetName.NameDutch;
break;
case Taal.FR:
item.gemeentenm.Value = municipality.NameFrench;
item.straatnm.Value = streetName.NameFrench;
break;
case Taal.DE:
item.gemeentenm.Value = municipality.NameGerman;
item.straatnm.Value = streetName.NameGerman;
break;
case Taal.EN:
item.gemeentenm.Value = municipality.NameEnglish;
item.straatnm.Value = streetName.NameEnglish;
break;
}
return(item.ToBytes(DbfFileWriter <AddressDbaseRecord> .Encoding));
}
yield return(ExtractBuilder.CreateDbfFile <AddressExtractItem, AddressDbaseRecord>(
ExtractFileNames.Address,
new AddressDbaseSchema(),
extractItems,
extractItems.Count,
TransformRecord));
var boundingBox = new BoundingBox3D(
extractItems.Where(x => x.MinimumX > 0).Min(record => record.MinimumX),
extractItems.Where(x => x.MinimumY > 0).Min(record => record.MinimumY),
extractItems.Where(x => x.MaximumX > 0).Max(record => record.MaximumX),
extractItems.Where(x => x.MaximumY > 0).Max(record => record.MaximumY),
0,
0,
double.NegativeInfinity,
double.PositiveInfinity);
yield return(ExtractBuilder.CreateShapeFile <PointShapeContent>(
ExtractFileNames.Address,
ShapeType.Point,
extractItems.Select(x => x.ShapeRecordContent),
ShapeContent.Read,
extractItems.Select(x => x.ShapeRecordContentLength),
boundingBox));
yield return(ExtractBuilder.CreateShapeIndexFile(
ExtractFileNames.Address,
ShapeType.Point,
extractItems.Select(x => x.ShapeRecordContentLength),
extractItems.Count,
boundingBox));
yield return(ExtractBuilder.CreateProjectedCoordinateSystemFile(
ExtractFileNames.Address,
ProjectedCoordinateSystem.Belge_Lambert_1972));
}
public TransactionRepository(ExtractContext context)
: base(context)
{
}
public DataBankRepository(ExtractContext context)
: base(context)
{
}
public Repository(ExtractContext context)
{
Db = context;
DbSet = Db.Set <TEntity>();
}
public UnitOfWork(ExtractContext context)
{
_context = context;
}
