public async Task ExecuteAsync(IPreValidationContext validationContext, CancellationToken cancellationToken)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
try
{
// get ILR data from file
await _errorLookupPopulationService.PopulateAsync(cancellationToken).ConfigureAwait(false);
_logger.LogDebug($"Error lookup service completed in: {stopWatch.ElapsedMilliseconds}");
if (_validationErrorCache.ValidationErrors.Any())
{
return;
}
cancellationToken.ThrowIfCancellationRequested();
await _preValidationPopulationService.PopulateAsync(cancellationToken).ConfigureAwait(false);
_logger.LogDebug($"Population service completed in: {stopWatch.ElapsedMilliseconds}");
// Set the filename
_fileDataCache.FileName = validationContext.Input;
// File Validation
await _ruleSetOrchestrationService.ExecuteAsync(validationContext.Tasks, cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
if (_validationErrorCache.ValidationErrors.Any(IsFail))
{
_logger.LogDebug(
$"File schema catastrophic error, so will not execute learner validation actors, error count: {_validationErrorCache.ValidationErrors.Count}");
return;
}
await ExecuteValidationActors(validationContext, cancellationToken).ConfigureAwait(false);
_logger.LogDebug(
$"Actors results collated {_validationErrorCache.ValidationErrors.Count} validation errors");
}
catch (Exception ex)
{
_logger.LogError("Validation Critical Error", ex);
throw;
}
finally
{
cancellationToken.ThrowIfCancellationRequested();
await _validationOutputService.ProcessAsync(cancellationToken).ConfigureAwait(false);
_logger.LogDebug($"Validation final results persisted in {stopWatch.ElapsedMilliseconds}");
}
}
public async Task ExecuteAsync(IValidationContext validationContext, CancellationToken cancellationToken)
{
// get the file name
_fileDataCache.FileName = validationContext.Filename;
// get ILR data from file
await _preValidationPopulationService.PopulateAsync(validationContext, cancellationToken);
await _messageRuleSetOrchestrationService.ExecuteAsync(validationContext, cancellationToken);
await _learnerRuleSetOrchestrationService.ExecuteAsync(validationContext, cancellationToken);
await _validationOutputService.ProcessAsync(validationContext, CancellationToken.None);
}
public async Task ExecuteAsync(IValidationContext validationContext, IMessage message, CancellationToken cancellationToken)
{
_logger.LogDebug("Starting Learner RuleSet Execution");
if (message?.Learners != null)
{
await _learneRuleSetOrchestrationService.ExecuteAsync(message.Learners, cancellationToken).ConfigureAwait(false);
}
_logger.LogDebug("Finished Learner RuleSet Execution");
_logger.LogDebug("Starting LearnerDP RuleSet Execution");
if (message?.LearnerDestinationAndProgressions != null)
{
await _learnerDPRuleSetOrchestrationService.ExecuteAsync(message.LearnerDestinationAndProgressions, cancellationToken).ConfigureAwait(false);
}
_logger.LogDebug("Finished LearnerDP RuleSet Execution");
}
private async Task <IEnumerable <IValidationError> > RunValidation(ValidationActorModel actorModel, CancellationToken cancellationToken)
{
if (_executionContext is ExecutionContext executionContextObj)
{
executionContextObj.JobId = "-1";
executionContextObj.TaskKey = _actorId.ToString();
}
ILogger logger = _parentLifeTimeScope.Resolve <ILogger>();
InternalDataCache internalDataCache;
ExternalDataCache externalDataCacheGet;
ExternalDataCache externalDataCache;
FileDataCache fileDataCache;
Message message;
IEnumerable <string> tasks;
ValidationContext validationContext;
IEnumerable <IValidationError> errors;
try
{
logger.LogDebug($"{nameof(ValidationActor)} {_actorId} {GC.GetGeneration(actorModel)} starting");
internalDataCache = _jsonSerializationService.Deserialize <InternalDataCache>(actorModel.InternalDataCache);
externalDataCacheGet = _jsonSerializationService.Deserialize <ExternalDataCache>(actorModel.ExternalDataCache);
fileDataCache = _jsonSerializationService.Deserialize <FileDataCache>(actorModel.FileDataCache);
message = _jsonSerializationService.Deserialize <Message>(actorModel.Message);
tasks = _jsonSerializationService.Deserialize <IEnumerable <string> >(actorModel.TaskList);
externalDataCache = new ExternalDataCache
{
LearningDeliveries = externalDataCacheGet.LearningDeliveries.ToCaseInsensitiveDictionary(),
EPAOrganisations = externalDataCacheGet.EPAOrganisations.ToCaseInsensitiveDictionary(),
ERNs = externalDataCacheGet.ERNs,
FCSContractAllocations = externalDataCacheGet.FCSContractAllocations,
Frameworks = externalDataCacheGet.Frameworks,
Organisations = externalDataCacheGet.Organisations,
Postcodes = externalDataCacheGet.Postcodes.ToCaseInsensitiveHashSet(),
ONSPostcodes = externalDataCacheGet.ONSPostcodes,
Standards = externalDataCacheGet.Standards,
StandardValidities = externalDataCacheGet.StandardValidities,
ULNs = externalDataCacheGet.ULNs,
ValidationErrors = externalDataCacheGet.ValidationErrors.ToCaseInsensitiveDictionary(),
CampusIdentifiers = externalDataCacheGet.CampusIdentifiers
};
validationContext = new ValidationContext
{
Input = message
};
logger.LogDebug($"{nameof(ValidationActor)} {_actorId} {GC.GetGeneration(actorModel)} finished getting input data");
cancellationToken.ThrowIfCancellationRequested();
}
catch (Exception ex)
{
ActorEventSource.Current.ActorMessage(this, "Exception-{0}", ex.ToString());
logger.LogError($"Error while processing {nameof(ValidationActor)}", ex);
throw;
}
using (var childLifeTimeScope = _parentLifeTimeScope.BeginLifetimeScope(c =>
{
c.RegisterInstance(validationContext).As <IValidationContext>();
c.RegisterInstance(new Cache <IMessage> {
Item = message
}).As <ICache <IMessage> >();
c.RegisterInstance(internalDataCache).As <IInternalDataCache>();
c.RegisterInstance(externalDataCache).As <IExternalDataCache>();
c.RegisterInstance(fileDataCache).As <IFileDataCache>();
}))
{
ExecutionContext executionContext = (ExecutionContext)childLifeTimeScope.Resolve <IExecutionContext>();
executionContext.JobId = actorModel.JobId;
executionContext.TaskKey = _actorId.ToString();
ILogger jobLogger = childLifeTimeScope.Resolve <ILogger>();
try
{
jobLogger.LogDebug($"{nameof(ValidationActor)} {_actorId} {GC.GetGeneration(actorModel)} {executionContext.TaskKey} started learners: {validationContext.Input.Learners.Count}");
IRuleSetOrchestrationService <ILearner, IValidationError> preValidationOrchestrationService = childLifeTimeScope
.Resolve <IRuleSetOrchestrationService <ILearner, IValidationError> >();
errors = await preValidationOrchestrationService.ExecuteAsync(tasks, cancellationToken);
jobLogger.LogDebug($"{nameof(ValidationActor)} {_actorId} {GC.GetGeneration(actorModel)} {executionContext.TaskKey} validation done");
}
catch (Exception ex)
{
ActorEventSource.Current.ActorMessage(this, "Exception-{0}", ex.ToString());
jobLogger.LogError($"Error while processing {nameof(ValidationActor)}", ex);
throw;
}
}
internalDataCache = null;
externalDataCache = null;
fileDataCache = null;
message = null;
validationContext = null;
return(errors);
}
private async Task <IEnumerable <IValidationError> > RunValidation(ValidationDPActorModel actorModel, CancellationToken cancellationToken)
{
if (_executionContext is ExecutionContext executionContextObj)
{
executionContextObj.JobId = "-1";
executionContextObj.TaskKey = _actorId.ToString();
}
ILogger logger = _parentLifeTimeScope.Resolve <ILogger>();
InternalDataCache internalDataCache;
ExternalDataCache externalDataCacheGet;
ExternalDataCache externalDataCache;
FileDataCache fileDataCache;
Message message;
IEnumerable <IValidationError> errors;
try
{
logger.LogDebug($"{nameof(ValidationDPActor)} {_actorId} {GC.GetGeneration(actorModel)} starting");
internalDataCache = _jsonSerializationService.Deserialize <InternalDataCache>(actorModel.InternalDataCache);
externalDataCacheGet = _jsonSerializationService.Deserialize <ExternalDataCache>(actorModel.ExternalDataCache);
fileDataCache = _jsonSerializationService.Deserialize <FileDataCache>(actorModel.FileDataCache);
message = _jsonSerializationService.Deserialize <Message>(actorModel.Message);
externalDataCache = new ExternalDataCache
{
ULNs = externalDataCacheGet.ULNs,
ValidationErrors = externalDataCacheGet.ValidationErrors.ToCaseInsensitiveDictionary(),
ValidationRules = externalDataCacheGet.ValidationRules,
ReturnPeriod = externalDataCacheGet.ReturnPeriod
};
logger.LogDebug($"{nameof(ValidationDPActor)} {_actorId} {GC.GetGeneration(actorModel)} finished getting input data");
cancellationToken.ThrowIfCancellationRequested();
}
catch (Exception ex)
{
ActorEventSource.Current.ActorMessage(this, "Exception-{0}", ex.ToString());
logger.LogError($"Error while processing {nameof(ValidationDPActor)}", ex);
throw;
}
using (var childLifeTimeScope = _parentLifeTimeScope.BeginLifetimeScope(c =>
{
c.RegisterInstance(new Cache <IMessage> {
Item = message
}).As <ICache <IMessage> >();
c.RegisterInstance(internalDataCache).As <IInternalDataCache>();
c.RegisterInstance(externalDataCache).As <IExternalDataCache>();
c.RegisterInstance(fileDataCache).As <IFileDataCache>();
}))
{
ExecutionContext executionContext = (ExecutionContext)childLifeTimeScope.Resolve <IExecutionContext>();
executionContext.JobId = actorModel.JobId;
executionContext.TaskKey = _actorId.ToString();
ILogger jobLogger = childLifeTimeScope.Resolve <ILogger>();
try
{
jobLogger.LogDebug($"{nameof(ValidationDPActor)} {_actorId} {GC.GetGeneration(actorModel)} {executionContext.TaskKey} started Destination and Progressions: {message.LearnerDestinationAndProgressions.Count}");
IRuleSetOrchestrationService <IRule <ILearnerDestinationAndProgression>, ILearnerDestinationAndProgression> preValidationOrchestrationService = childLifeTimeScope
.Resolve <IRuleSetOrchestrationService <IRule <ILearnerDestinationAndProgression>, ILearnerDestinationAndProgression> >();
errors = await preValidationOrchestrationService.ExecuteAsync(message.LearnerDestinationAndProgressions, cancellationToken);
jobLogger.LogDebug($"{nameof(ValidationDPActor)} {_actorId} {GC.GetGeneration(actorModel)} {executionContext.TaskKey} Destination and Progression validation done");
}
catch (Exception ex)
{
ActorEventSource.Current.ActorMessage(this, "Exception-{0}", ex.ToString());
jobLogger.LogError($"Error while processing {nameof(ValidationDPActor)}", ex);
throw;
}
}
internalDataCache = null;
externalDataCache = null;
fileDataCache = null;
message = null;
return(errors);
}
public async Task ExecuteAsync(IValidationContext validationContext, CancellationToken cancellationToken)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
try
{
if (_validationErrorCache.ValidationErrors.Any())
{
return;
}
cancellationToken.ThrowIfCancellationRequested();
var message = await _messageProvider.ProvideAsync(validationContext.Filename, validationContext.Container, cancellationToken);
var referenceDataRoot = await _referenceDataRootProvider.ProvideAsync(validationContext.IlrReferenceDataKey, validationContext.Container, cancellationToken);
var learnerReferenceData = await _learnerReferenceDataProvider.ProvideAsync(validationContext.LearnerReferenceDataKey, validationContext.Container, cancellationToken);
_preValidationPopulationService.Populate(validationContext, message, referenceDataRoot, learnerReferenceData);
_logger.LogDebug($"Population service completed in: {stopWatch.ElapsedMilliseconds}");
// Stateless Validation
var statelessValidationTasks = new List <Task>
{
_messageRuleSetOrchestrationService.ExecuteAsync(message, cancellationToken),
_crossYearRuleSetOrchestrationService.ExecuteAsync(message.Learners, cancellationToken)
};
await Task.WhenAll(statelessValidationTasks).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
if (_validationErrorCache.ValidationErrors.Any(IsFail))
{
_logger.LogDebug($"File schema catastrophic error, so will not execute learner validation actors, error count: {_validationErrorCache.ValidationErrors.Count}");
await _validationOutputService.ProcessAsync(validationContext, message, _validationErrorCache.ValidationErrors, cancellationToken).ConfigureAwait(false);
throw new ValidationSeverityFailException("File level errors (Severity F) caught. Handing back to Message Handler.");
}
await _validationExecutionProvider.ExecuteAsync(validationContext, message, cancellationToken).ConfigureAwait(false);
_logger.LogDebug($"Actors results collated {_validationErrorCache.ValidationErrors.Count} validation errors");
cancellationToken.ThrowIfCancellationRequested();
await _validationOutputService.ProcessAsync(validationContext, message, _validationErrorCache.ValidationErrors, cancellationToken).ConfigureAwait(false);
await _validIlrFileOutputService.ProcessAsync(validationContext, message, cancellationToken).ConfigureAwait(false);
_logger.LogDebug($"Validation final results persisted in {stopWatch.ElapsedMilliseconds}");
}
catch (Exception ex)
{
_logger.LogError("Validation Critical Error", ex);
throw;
}
}