private static async Task AddSyndicationItemEntry(AtomEntry <SyndicationItem <Municipality> > entry, SyndicationContext context, CancellationToken ct)
{
var municipalityItem = await context
.MunicipalityBosaItems
.FindAsync(entry.Content.Object.Id);
if (municipalityItem == null)
{
municipalityItem = new MunicipalityBosaItem
{
MunicipalityId = entry.Content.Object.Id,
NisCode = entry.Content.Object.Identificator?.ObjectId,
Version = entry.Content.Object.Identificator?.Versie,
Position = long.Parse(entry.FeedEntry.Id),
PrimaryLanguage = entry.Content.Object.OfficialLanguages.FirstOrDefault(),
IsFlemishRegion = RegionFilter.IsFlemishRegion(entry.Content.Object.Identificator?.ObjectId)
};
UpdateNamesByGemeentenamen(municipalityItem, entry.Content.Object.MunicipalityNames);
await context
.MunicipalityBosaItems
.AddAsync(municipalityItem, ct);
}
else
{
municipalityItem.NisCode = entry.Content.Object.Identificator?.ObjectId;
municipalityItem.Version = entry.Content.Object.Identificator?.Versie;
municipalityItem.Position = long.Parse(entry.FeedEntry.Id);
municipalityItem.PrimaryLanguage = entry.Content.Object.OfficialLanguages.FirstOrDefault();
municipalityItem.IsFlemishRegion = RegionFilter.IsFlemishRegion(entry.Content.Object.Identificator?.ObjectId);
UpdateNamesByGemeentenamen(municipalityItem, entry.Content.Object.MunicipalityNames);
}
}
protected override bool OnBackButtonPressed()
{
if (!RegionFilter.Equals(regionFilterBackup))
RegionFilter = CloneRegionFilter(regionFilterBackup);
if (!ProductFilter.Equals(productFilterBackup))
ProductFilter = CloneProductFilter(productFilterBackup);
return base.OnBackButtonPressed();
}
private async void OnCancelClicked(object sender, EventArgs e)
{
if (!RegionFilter.Equals(regionFilterBackup))
RegionFilter = CloneRegionFilter(regionFilterBackup);
if (!ProductFilter.Equals(productFilterBackup))
ProductFilter = CloneProductFilter(productFilterBackup);
await Navigation.PopModalAsync();
}
public PlantInfoFilters()
{
ZoneFilter = new ZoneFilter();
RegionFilter = new RegionFilter();
HeightFilter = new HeightFilter();
SpreadFilter = new SpreadFilter();
LightFilter = new LightFilter();
WaterFilter = new WaterFilter();
BloomFilter = new BloomFilter();
NativeFilter = new NativeFilter();
}
public FileResult Export(RegionFilter filter)
{
var response = _regionService.Filter(filter);
var csv = new CsvExport();
csv.ConcatRow(0, "REGIÓN,ESTADO");
csv.ConcatRows(0, "Name,Status", response.Regions);
var stream = csv.RetrieveFile();
return(new StreamFactory().Csv(stream, "Regiones"));
}
public StreetNameNameProjectionsV2()
{
When <Envelope <StreetNameWasProposedV2> >(async(context, message, ct) =>
{
var streetNameNameV2 = new StreetNameNameV2
{
PersistentLocalId = message.Message.PersistentLocalId,
MunicipalityId = message.Message.MunicipalityId,
NisCode = message.Message.NisCode,
VersionTimestamp = message.Message.Provenance.Timestamp,
IsFlemishRegion = RegionFilter.IsFlemishRegion(message.Message.NisCode),
Status = StreetNameStatus.Proposed,
Removed = false
};
UpdateNameByLanguage(streetNameNameV2, message.Message.StreetNameNames);
await context
.StreetNameNamesV2
.AddAsync(streetNameNameV2, ct);
});
When <Envelope <MunicipalityNisCodeWasChanged> >(async(context, message, ct) =>
{
var streetNames = context
.StreetNameNamesV2
.Local
.Where(s => s.MunicipalityId == message.Message.MunicipalityId)
.Union(context.StreetNameNamesV2.Where(s => s.MunicipalityId == message.Message.MunicipalityId));
foreach (var streetName in streetNames)
{
streetName.NisCode = message.Message.NisCode;
}
});
}
public IActionResult Regions([FromQuery] RegionFilter filter)
=> Ok(dbContext.Regions
.Include(i => i.Territories)
.ApplyFilter(filter));
public StreetNameNameProjections()
{
When <Envelope <StreetNameWasRegistered> >(async(context, message, ct) =>
{
await context
.StreetNameNames
.AddAsync(new StreetNameName
{
StreetNameId = message.Message.StreetNameId,
NisCode = message.Message.NisCode,
VersionTimestamp = message.Message.Provenance.Timestamp,
IsFlemishRegion = RegionFilter.IsFlemishRegion(message.Message.NisCode),
Complete = false,
Removed = false
}, ct);
});
When <Envelope <StreetNameWasNamed> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
UpdateNameByLanguage(streetNameNameItem, message.Message.Language, message.Message.Name);
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameNameWasCorrected> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
UpdateNameByLanguage(streetNameNameItem, message.Message.Language, message.Message.Name);
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameNameWasCleared> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
UpdateNameByLanguage(streetNameNameItem, message.Message.Language, null);
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameNameWasCorrectedToCleared> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
UpdateNameByLanguage(streetNameNameItem, message.Message.Language, null);
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameBecameComplete> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.Complete = true;
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameBecameIncomplete> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.Complete = false;
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameWasRemoved> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.Removed = true;
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameBecameCurrent> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.Status = StreetNameStatus.Current;
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameWasProposed> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.Status = StreetNameStatus.Proposed;
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameWasRetired> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.Status = StreetNameStatus.Retired;
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameWasCorrectedToCurrent> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.Status = StreetNameStatus.Current;
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameWasCorrectedToProposed> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.Status = StreetNameStatus.Proposed;
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameWasCorrectedToRetired> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.Status = StreetNameStatus.Retired;
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameStatusWasRemoved> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.Status = null;
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameStatusWasCorrectedToRemoved> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.Status = null;
UpdateVersionTimestamp(streetNameNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNamePersistentLocalIdWasAssigned> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameName(
message.Message.StreetNameId,
streetNameNameItem =>
{
streetNameNameItem.PersistentLocalId = message.Message.PersistentLocalId;
},
ct);
});
When <Envelope <StreetNameHomonymAdditionWasCleared> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNameHomonymAdditionWasCorrected> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNameHomonymAdditionWasCorrectedToCleared> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNameHomonymAdditionWasDefined> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNamePrimaryLanguageWasCleared> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNamePrimaryLanguageWasCorrected> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNamePrimaryLanguageWasCorrectedToCleared> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNamePrimaryLanguageWasDefined> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNameSecondaryLanguageWasCleared> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNameSecondaryLanguageWasCorrected> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNameSecondaryLanguageWasCorrectedToCleared> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNameSecondaryLanguageWasDefined> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNameWasImportedFromCrab> >(async(context, message, ct) => DoNothing());
When <Envelope <StreetNameStatusWasImportedFromCrab> >(async(context, message, ct) => DoNothing());
}
public JsonResult Filter(RegionFilter filter)
{
var response = _regionService.Filter(filter);
return(new JsonFactory().Success(response.Regions, response.TotalRecords));
}
public MunicipalityNameProjections()
{
When <Envelope <MunicipalityWasRegistered> >(async(context, message, ct) =>
{
await context
.MunicipalityName
.AddAsync(
new MunicipalityName
{
MunicipalityId = message.Message.MunicipalityId,
NisCode = message.Message.NisCode,
IsFlemishRegion = RegionFilter.IsFlemishRegion(message.Message.NisCode),
VersionTimestamp = message.Message.Provenance.Timestamp
}, ct);
});
When <Envelope <MunicipalityNisCodeWasDefined> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityName(
message.Message.MunicipalityId,
municipalityNameItem =>
{
municipalityNameItem.NisCode = message.Message.NisCode;
municipalityNameItem.IsFlemishRegion = RegionFilter.IsFlemishRegion(message.Message.NisCode);
UpdateVersionTimestamp(municipalityNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityNisCodeWasCorrected> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityName(
message.Message.MunicipalityId,
municipalityNameItem =>
{
municipalityNameItem.NisCode = message.Message.NisCode;
municipalityNameItem.IsFlemishRegion = RegionFilter.IsFlemishRegion(message.Message.NisCode);
UpdateVersionTimestamp(municipalityNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityWasNamed> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityName(
message.Message.MunicipalityId,
municipalityNameItem =>
{
UpdateNameByLanguage(municipalityNameItem, message.Message.Language, message.Message.Name);
UpdateVersionTimestamp(municipalityNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityNameWasCorrected> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityName(
message.Message.MunicipalityId,
municipalityNameItem =>
{
UpdateNameByLanguage(municipalityNameItem, message.Message.Language, message.Message.Name);
UpdateVersionTimestamp(municipalityNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityNameWasCleared> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityName(
message.Message.MunicipalityId,
municipalityNameItem =>
{
UpdateNameByLanguage(municipalityNameItem, message.Message.Language, null);
UpdateVersionTimestamp(municipalityNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityNameWasCorrectedToCleared> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityName(
message.Message.MunicipalityId,
municipalityNameItem =>
{
UpdateNameByLanguage(municipalityNameItem, message.Message.Language, null);
UpdateVersionTimestamp(municipalityNameItem, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityBecameCurrent> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityWasRetired> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityWasCorrectedToRetired> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityWasCorrectedToCurrent> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityOfficialLanguageWasAdded> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityOfficialLanguageWasRemoved> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityFacilityLanguageWasAdded> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityFacilitiesLanguageWasRemoved> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityGeometryWasCleared> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityGeometryWasCorrected> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityGeometryWasCorrectedToCleared> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityWasDrawn> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityNameWasImportedFromCrab> >(async(context, message, ct) => DoNothing());
When <Envelope <MunicipalityWasImportedFromCrab> >(async(context, message, ct) => DoNothing());
}
public CrayonApiClientResult <ApiCollection <Region> > Get(string token, RegionFilter filter = null)
{
var uri = "/api/v1/regions/".Append(filter);
return(_client.Get <ApiCollection <Region> >(token, uri));
}
public static RegionListRequestBuilder List(RegionFilter filter)
{
return(new RegionListRequestBuilder(filter));
}
public RegionListRequestBuilder(RegionFilter filter)
: this()
{
this.Filter = filter;
}
