/// <summary>
/// Exports to ILR
/// </summary>
/// <param name="usingSource">using source.</param>
/// <param name="inContext">in context.</param>
/// <param name="forProvider">for provider.</param>
/// <returns>
/// the currently running task
/// </returns>
public async Task Export(IInputDataSource usingSource, IConnectionDetail inContext, int forProvider)
{
It.IsNull(usingSource)
.AsGuard <ArgumentNullException>(nameof(usingSource));
It.IsNull(inContext)
.AsGuard <ArgumentNullException>(nameof(inContext));
await Task.Run(async() =>
{
using (Timing.BeginScope($"Export file for {forProvider}"))
{
var schema = Schemas.GetSchema(usingSource.OperatingYear);
var schemaPath = Path.Combine(Location.OfAssets, schema.Message);
var templatePath = Path.Combine(Location.OfAssets, schema.BulkExport);
var candidate = await FileManager.Load(templatePath);
var batch = Batches.GetBatch(BatchProcessName.ExportSourceDataToILRFile, usingSource.OperatingYear);
candidate = candidate.Replace(Token.ForNamespace, schema.Namespace);
batch.Scripts
.ForEach(script => RunScript(script, inContext, forProvider, ref candidate));
var outputPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), "exportILR.xml");
await FileManager.Save(outputPath, candidate);
await StripEmptyTags(outputPath);
Emitter.Publish(Indentation.FirstLevel, CommonLocalised.Completed);
//(!await Validator.IsValid(outputPath, schemaPath))
// .AsGuard<OperationCanceledException, CommonLocalised>(CommonLocalised.SchemaValidationFailed);
}
});
}
/// <summary>
/// Exports (the currently selected input source to ILR file).
/// </summary>
/// <param name="fromThisSource">From this source.</param>
/// <param name="forProvider">For provider.</param>
/// <returns>
/// the current task
/// </returns>
public async Task Export(IInputDataSource fromThisSource, int forProvider)
{
await Handler.RunAsyncOperation <Localised>(async() =>
{
var context = Provider.ConnectionToSource(fromThisSource.Container, fromThisSource.DBName, fromThisSource.DBUser, fromThisSource.DBPassword);
await BulkExporter.Export(fromThisSource, context, forProvider);
});
}
/// <summary>
/// Runs (up) the providers.
/// </summary>
/// <param name="usingInputSource">using (the) input source.</param>
/// <returns></returns>
public async Task RunProviders(IInputDataSource usingInputSource)
{
It.IsNull(usingInputSource)
.AsGuard <ArgumentNullException>(nameof(usingInputSource));
using (State.BusyScope())
{
Emitter.Publish("Loading Providers..");
await Task.Run(async() =>
{
FilterUsing = string.Empty;
Providers = AddProviderDetailsUpdateCountHook(usingInputSource);
await ApplyFilter();
});
}
}
/// <summary>
/// Creates a context provider...
/// </summary>
/// <param name="onInstance">on instance.</param>
/// <param name="forDataSource">for data source.</param>
/// <param name="usingSourceForResults">if set to <c>true</c> [using source for results].</param>
/// <param name="depositArtefacts">if set to <c>true</c> [deposit artefacts].</param>
/// <param name="returnPeriod">The return period.</param>
/// <returns>
/// a connection context provider
/// </returns>
public IContainSessionContext Create(string onInstance, string thisUser, string thisPassword, IInputDataSource forDataSource, bool runMode, bool usingSourceForResults, bool depositArtefacts, ReturnPeriod returnPeriod)
{
var sourceLocation = CreateFor(onInstance, forDataSource.DBName, thisUser, thisPassword);
var provider = new SessionContextContainer
{
Year = forDataSource.OperatingYear,
//Master = CreateFor(onInstance, "master", thisUser, thisPassword),
SourceLocation = sourceLocation,
ProcessingLocation = CreateFor(onInstance, forDataSource.DBName, thisUser, thisPassword),
RunMode = runMode ? TypeOfRunMode.Lite : TypeOfRunMode.Full,
UsingSourceForResults = usingSourceForResults,
DepositRulebaseArtefacts = depositArtefacts,
ReturnPeriod = returnPeriod
};
provider.ResultsDestination = usingSourceForResults
? sourceLocation
: CreateFor(onInstance, forDataSource.DBName, thisUser, thisPassword);
return(provider);
}
/// <summary>
/// Creates a run configuration...
/// </summary>
/// <param name="withRulesToRun">with rules to run.</param>
/// <param name="andInputSource">and input source.</param>
/// <returns>
/// a session configuration
/// </returns>
public IContainSessionConfiguration Create(IReadOnlyCollection <IRulebaseConfiguration> withRulesToRun, IInputDataSource andInputSource)
{
return(new SessionConfiguration
{
RulesToRun = withRulesToRun.AsSafeReadOnlyList(),
InputDataSource = andInputSource
});
}
public Program(IInputDataSource source, ICombination algoritm, IOutputDataAccept dataAssept)
{
this.source = source;
this.algoritm = algoritm;
this.dataAssept = dataAssept;
}
/// <summary>
/// Adds the provider details update count hook.
/// </summary>
/// <param name="source">The source.</param>
public IReadOnlyCollection <LearningProviderWrapper> AddProviderDetailsUpdateCountHook(IInputDataSource source)
{
var context = Provider.ConnectionToSource(source.Container, source.DBName, source.DBUser, source.DBPassword);
var providerIDs = source.Providers.Select(x => x.ID).AsSafeReadOnlyList();
var details = ValidSources.GetProviderDetails(context, providerIDs);
return(source.Providers
.Select(x =>
{
var count = ValidSources.GetLearnerCount(context, x.ID);
var providerDetail = details?.FirstOrDefault(y => y.UKPRN == x.ID);
return new LearningProviderWrapper(x, count, providerDetail, UpdatePreparationDetails);
})
.AsParallel()
.AsSafeReadOnlyList());
}
