/// <summary>
/// Initializes a new instance of the <see cref="ExtractProcess"/> class.
/// </summary>
/// <param name="config">The configuration.</param>
public ExtractProcess(ExtractConfig config)
{
this.InitializeComponent();
App.Current.MainWindow.Title = "Extracting";
Config = config;
Worker = new BackgroundWorker();
//Worker.WorkerSupportsCancellation = true;
Worker.WorkerReportsProgress = true;
Worker.DoWork += delegate(object s, DoWorkEventArgs args)
{
args.Result = StartProcess();
};
Worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)
{
if (!(bool)args.Result)
{
MessageBox.Show(Application.Current.MainWindow,
"There was a problem in extracting the 5Ws. The input file does not contain any articles. \n\nKindly check the input file.",
"Extracting");
StatusTextBlock.Text = "process failed";
this.NavigationService.Navigate(new Home());
}
else
{
StatusTextBlock.Text = "process completed";
this.NavigationService.Navigate(new ViewList(Config.DestinationFilePath));
}
EndProcess();
};
Worker.ProgressChanged += delegate(object s, ProgressChangedEventArgs args)
{
int percentage = args.ProgressPercentage;
ProgressBar.Value = percentage;
StatusTextBlock.Text = StatusText;
};
}
/// <summary>
/// Handles the PreviewMouseLeftButtonDown event of the RecentFilesListView control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="MouseButtonEventArgs"/> instance containing the event data.</param>
private void RecentFilesListView_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
var item = ((FrameworkElement)e.OriginalSource).DataContext as RecentFile;
if (item != null)
{
if (item.OperationType == "/assets/images/extract.png")
{
ExtractConfig config = new ExtractConfig()
{
SourceFilePath = String.Format("{0}\\{1}.xml", item.SourceFilePath, item.Name),
DestinationFilePath = item.DestinationFilePath
};
if (Directory.Exists(System.IO.Path.GetDirectoryName(config.DestinationFilePath)) && File.Exists(config.SourceFilePath))
{
this.NavigationService.Navigate(new ExtractProcess(config));
}
else
{
MessageBox.Show(Application.Current.MainWindow,
"An error prohibited the loading of the files. Either the source file or the destination path does not exist. \n\nKindly check on your input file and destination path.",
"Selecting files");
}
}
else if (item.OperationType == "/assets/images/view.png")
{
string sourceFilePath = String.Format("{0}\\{1}.xml", item.SourceFilePath, item.Name);
if (File.Exists(sourceFilePath))
{
this.NavigationService.Navigate(new ViewList(sourceFilePath));
}
else
{
MessageBox.Show(Application.Current.MainWindow,
"An error prohibited the loading of the file. The source file does not exist. \n\nKindly check on your input file.",
"Selecting file");
}
}
}
}
public StreetNameExtractProjectionsV2(IOptions <ExtractConfig> extractConfig, Encoding encoding)
{
_extractConfig = extractConfig.Value;
_encoding = encoding ?? throw new ArgumentNullException(nameof(encoding));
When <Envelope <StreetNameWasProposedV2> >(async(context, message, ct) =>
{
var streetNameExtractItemV2 = new StreetNameExtractItemV2
{
StreetNamePersistentLocalId = message.Message.PersistentLocalId,
MunicipalityId = message.Message.MunicipalityId,
DbaseRecord = new StreetNameDbaseRecord
{
gemeenteid = { Value = message.Message.NisCode },
versieid = { Value = message.Message.Provenance.Timestamp.ToBelgianDateTimeOffset().FromDateTimeOffset() }
}.ToBytes(_encoding)
};
UpdateStraatnm(streetNameExtractItemV2, message.Message.StreetNameNames);
await context
.StreetNameExtractV2
.AddAsync(streetNameExtractItemV2, ct);
});
When <Envelope <MunicipalityNisCodeWasChanged> >(async(context, message, ct) =>
{
var streetNames = context
.StreetNameExtractV2
.Local
.Where(s => s.MunicipalityId == message.Message.MunicipalityId)
.Union(context.StreetNameExtractV2.Where(s => s.MunicipalityId == message.Message.MunicipalityId));
foreach (var streetName in streetNames)
{
UpdateRecord(streetName, i => i.gemeenteid.Value = message.Message.NisCode);
}
});
}
public StreetNameExtractProjections(IOptions <ExtractConfig> extractConfig, Encoding encoding)
{
_extractConfig = extractConfig.Value;
_encoding = encoding ?? throw new ArgumentNullException(nameof(encoding));
When <Envelope <StreetNameWasRegistered> >(async(context, message, ct) =>
{
await context
.StreetNameExtract
.AddAsync(new StreetNameExtractItem
{
StreetNameId = message.Message.StreetNameId,
DbaseRecord = new StreetNameDbaseRecord
{
gemeenteid = { Value = message.Message.NisCode },
versieid = { Value = message.Message.Provenance.Timestamp.ToBelgianDateTimeOffset().FromDateTimeOffset() }
}.ToBytes(_encoding)
}, ct);
});
When <Envelope <StreetNamePersistentLocalIdWasAssigned> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
var persistentLocalId = message.Message.PersistentLocalId;
streetName.StreetNamePersistentLocalId = persistentLocalId;
UpdateId(streetName, persistentLocalId);
},
ct);
});
When <Envelope <StreetNameWasNamed> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateStraatnm(streetName, message.Message.Language, message.Message.Name);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameNameWasCorrected> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateStraatnm(streetName, message.Message.Language, message.Message.Name);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameNameWasCleared> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateStraatnm(streetName, message.Message.Language, null);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameNameWasCorrectedToCleared> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateStraatnm(streetName, message.Message.Language, null);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameBecameCurrent> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateStatus(streetName, InUse);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameWasCorrectedToCurrent> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateStatus(streetName, InUse);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameWasRetired> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateStatus(streetName, Retired);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameWasRemoved> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
context.StreetNameExtract.Remove(streetName);
},
ct);
});
When <Envelope <StreetNameWasCorrectedToRetired> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateStatus(streetName, Retired);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameWasProposed> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateStatus(streetName, Proposed);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameWasCorrectedToProposed> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateStatus(streetName, Proposed);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameStatusWasRemoved> >(async(context, message, ct) =>
{
var streetName = await context.StreetNameExtract.FindAsync(message.Message.StreetNameId, cancellationToken: ct);
if (streetName != null) // it's possible that streetname is already removed
{
UpdateStatus(streetName, null);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
}
});
When <Envelope <StreetNameStatusWasCorrectedToRemoved> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateStatus(streetName, null);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameHomonymAdditionWasDefined> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateHomoniemtv(streetName, message.Message.Language, message.Message.HomonymAddition);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameHomonymAdditionWasCleared> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateHomoniemtv(streetName, message.Message.Language, null);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameHomonymAdditionWasCorrected> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateHomoniemtv(streetName, message.Message.Language, message.Message.HomonymAddition);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameHomonymAdditionWasCorrectedToCleared> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
UpdateHomoniemtv(streetName, message.Message.Language, null);
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameBecameComplete> >(async(context, message, ct) =>
{
await context.FindAndUpdateStreetNameExtract(
message.Message.StreetNameId,
streetName =>
{
streetName.Complete = true;
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <StreetNameBecameIncomplete> >(async(context, message, ct) =>
{
var streetName = await context.StreetNameExtract.FindAsync(message.Message.StreetNameId, cancellationToken: ct);
if (streetName != null) // it's possible that streetname is already removed
{
streetName.Complete = false;
UpdateVersie(streetName, message.Message.Provenance.Timestamp);
}
});
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 MunicipalityExtractProjections(IOptions <ExtractConfig> extractConfig, Encoding encoding)
{
_extractConfig = extractConfig.Value;
_encoding = encoding ?? throw new ArgumentNullException(nameof(encoding));
When <Envelope <MunicipalityWasRegistered> >(async(context, message, ct) =>
{
await context
.MunicipalityExtract
.AddAsync(new MunicipalityExtractItem
{
MunicipalityId = message.Message.MunicipalityId,
NisCode = message.Message.NisCode,
DbaseRecord = new MunicipalityDbaseRecord
{
gemeenteid = { Value = message.Message.NisCode },
id = { Value = $"{_extractConfig.DataVlaanderenNamespace}/{message.Message.NisCode}" },
versieid = { Value = message.Message.Provenance.Timestamp.ToBelgianDateTimeOffset().FromDateTimeOffset() }
}.ToBytes(_encoding)
}, ct);
});
When <Envelope <MunicipalityNisCodeWasDefined> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
UpdateId(municipality, message.Message.NisCode);
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityNisCodeWasCorrected> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
municipality.NisCode = message.Message.NisCode;
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityWasNamed> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
UpdateName(municipality, message.Message.Language, message.Message.Name);
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityNameWasCorrected> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
UpdateName(municipality, message.Message.Language, message.Message.Name);
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityNameWasCleared> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
UpdateName(municipality, message.Message.Language, null);
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityOfficialLanguageWasAdded> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
municipality.AddOfficialLanguage(message.Message.Language);
UpdateRecord(municipality, record => UpdateGemeentenm(municipality, record));
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityOfficialLanguageWasRemoved> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
municipality.RemoveOfficialLanguage(message.Message.Language);
UpdateRecord(municipality, record => UpdateGemeentenm(municipality, record));
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityNameWasCorrectedToCleared> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
UpdateName(municipality, message.Message.Language, null);
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityBecameCurrent> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
UpdateStatus(municipality, InUse);
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityWasCorrectedToCurrent> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
UpdateStatus(municipality, InUse);
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityWasRetired> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
UpdateStatus(municipality, Retired);
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
When <Envelope <MunicipalityWasCorrectedToRetired> >(async(context, message, ct) =>
{
await context.FindAndUpdateMunicipalityExtract(
message.Message.MunicipalityId,
municipality =>
{
UpdateStatus(municipality, Retired);
UpdateVersie(municipality, message.Message.Provenance.Timestamp);
},
ct);
});
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());
}
