/// <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()); }