public PreValidationOrchestrationSfService(
IPopulationService preValidationPopulationService,
IErrorLookupPopulationService errorLookupPopulationService,
ILearnerPerActorProviderService learnerPerActorProviderService,
ILearnerDPPerActorProviderService learnerDPPerActorProviderService,
IJsonSerializationService jsonSerializationService,
IInternalDataCache internalDataCache,
IExternalDataCache externalDataCache,
IFileDataCache fileDataCache,
IValidationErrorCache <U> validationErrorCache,
IValidationOutputService validationOutputService,
IRuleSetOrchestrationService <IMessage, U> ruleSetOrchestrationService,
ILogger logger)
{
_preValidationPopulationService = preValidationPopulationService;
_errorLookupPopulationService = errorLookupPopulationService;
_learnerPerActorProviderService = learnerPerActorProviderService;
_learnerDPPerActorProviderService = learnerDPPerActorProviderService;
_jsonSerializationService = jsonSerializationService;
_internalDataCache = internalDataCache;
_externalDataCache = externalDataCache;
_fileDataCache = fileDataCache;
_validationErrorCache = validationErrorCache;
_validationOutputService = validationOutputService;
_ruleSetOrchestrationService = ruleSetOrchestrationService;
_logger = logger;
}
public PreValidationOrchestrationSfService(
IPopulationService preValidationPopulationService,
ICache <IMessage> messageCache,
ILearnerPerActorService learnerPerActorService,
IJsonSerializationService jsonSerializationService,
IInternalDataCache internalDataCache,
IExternalDataCache externalDataCache,
IFileDataCache fileDataCache,
IValidationErrorCache <U> validationErrorCache,
IValidationOutputService <U> validationOutputService,
IValidationItemProviderService <IEnumerable <IMessage> > validationItemProviderService,
IRuleSetOrchestrationService <IMessage, U> ruleSetOrchestrationService,
ILogger logger,
IValidateXMLSchemaService validateXMLSchemaService)
{
_preValidationPopulationService = preValidationPopulationService;
_learnerPerActorService = learnerPerActorService;
_messageCache = messageCache;
_jsonSerializationService = jsonSerializationService;
_internalDataCache = internalDataCache;
_externalDataCache = externalDataCache;
_fileDataCache = fileDataCache;
_validationErrorCache = validationErrorCache;
_validationOutputService = validationOutputService;
_validationItemProviderService = validationItemProviderService;
_ruleSetOrchestrationService = ruleSetOrchestrationService;
_logger = logger;
_validateXmlSchemaService = validateXMLSchemaService;
}
private PreValidationOrchestrationSfService NewService(
IPopulationService preValidationPopulationService,
IFileProvider <Message> messageProvider,
IFileProvider <ReferenceDataRoot> referenceDataRootProvider,
IFileProvider <LearnerReferenceData> learnerReferenceDataProvider,
IValidationErrorCache validationErrorCache,
IValidationOutputService validationOutputService,
IValidIlrFileOutputService validIlrFileOutputService,
IRuleSetOrchestrationService <IRule <IMessage>, IMessage> messageRuleSetOrchestrationService,
IRuleSetOrchestrationService <ICrossYearRule <ILearner>, ILearner> crossYearRuleSetOrchestrationService,
IValidationExecutionProvider validationExecutionProvider)
{
return(new PreValidationOrchestrationSfService(
preValidationPopulationService,
messageProvider,
referenceDataRootProvider,
learnerReferenceDataProvider,
validationErrorCache,
validationOutputService,
validIlrFileOutputService,
messageRuleSetOrchestrationService,
crossYearRuleSetOrchestrationService,
validationExecutionProvider,
Mock.Of <ILogger>()));
}
public PreValidationOrchestrationSfService(
IPopulationService preValidationPopulationService,
IFileProvider <Message> messageProvider,
IFileProvider <ReferenceDataRoot> referenceDataRootProvider,
IFileProvider <LearnerReferenceData> learnerReferenceDataProvider,
IValidationErrorCache validationErrorCache,
IValidationOutputService validationOutputService,
IValidIlrFileOutputService validIlrFileOutputService,
IRuleSetOrchestrationService <IRule <IMessage>, IMessage> messageRuleSetOrchestrationService,
IRuleSetOrchestrationService <ICrossYearRule <ILearner>, ILearner> crossYearRuleSetOrchestrationService,
IValidationExecutionProvider validationExecutionProvider,
ILogger logger)
{
_preValidationPopulationService = preValidationPopulationService;
_messageProvider = messageProvider;
_referenceDataRootProvider = referenceDataRootProvider;
_learnerReferenceDataProvider = learnerReferenceDataProvider;
_validationErrorCache = validationErrorCache;
_validationOutputService = validationOutputService;
_validIlrFileOutputService = validIlrFileOutputService;
_messageRuleSetOrchestrationService = messageRuleSetOrchestrationService;
_crossYearRuleSetOrchestrationService = crossYearRuleSetOrchestrationService;
_validationExecutionProvider = validationExecutionProvider;
_logger = logger;
}
public ValidationExecutionProvider(
IRuleSetOrchestrationService <IRule <ILearner>, ILearner> learnerRuleSetOrchestrationService,
IRuleSetOrchestrationService <IRule <ILearnerDestinationAndProgression>, ILearnerDestinationAndProgression> learnerDPRuleSetOrchestrationService,
ILogger logger)
{
_learneRuleSetOrchestrationService = learnerRuleSetOrchestrationService;
_learnerDPRuleSetOrchestrationService = learnerDPRuleSetOrchestrationService;
_logger = logger;
}
public ConsolePreValidationOrchestrationService(
IPopulationService preValidationPopulationService,
IRuleSetOrchestrationService <ILearner, U> learnerRuleSetOrchestrationService,
IRuleSetOrchestrationService <IMessage, U> messageRuleSetOrchestrationService,
IValidationOutputService validationOutputService,
IFileDataCache fileDataCache)
{
_preValidationPopulationService = preValidationPopulationService;
_learnerRuleSetOrchestrationService = learnerRuleSetOrchestrationService;
_messageRuleSetOrchestrationService = messageRuleSetOrchestrationService;
_validationOutputService = validationOutputService;
_fileDataCache = fileDataCache;
}
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 externalDataCache;
FileDataCache fileDataCache;
Message message;
ValidationContext validationContext;
IEnumerable <IValidationError> errors;
try
{
logger.LogDebug($"{nameof(ValidationActor)} {_actorId} {GC.GetGeneration(actorModel)} starting");
internalDataCache = _jsonSerializationService.Deserialize <InternalDataCache>(Encoding.UTF8.GetString(actorModel.InternalDataCache));
externalDataCache = _jsonSerializationService.Deserialize <ExternalDataCache>(Encoding.UTF8.GetString(actorModel.ExternalDataCache));
fileDataCache = _jsonSerializationService.Deserialize <FileDataCache>(Encoding.UTF8.GetString(actorModel.FileDataCache));
message = _jsonSerializationService.Deserialize <Message>(new MemoryStream(actorModel.Message));
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.Execute(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(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);
}
