public InjectionTestCase(Guid applyingContactId,
Guid organisationId, string endPointAssessorOrganisationId, int standardCode, DateTime effectiveFrom, string deliveryAreas,
bool isOrganisationStandardTaken, string epaoStandardId, string warningMessage)
{
var warningMessages = new List <string>();
if (!string.IsNullOrEmpty(warningMessage))
{
warningMessages.Add(warningMessage);
}
IsOrganisationStandardTaken = isOrganisationStandardTaken;
var response = new CreateOrganisationStandardFromApplyResponse
{
WarningMessages = warningMessages,
EpaoStandardId = epaoStandardId
};
Command = new CreateOrganisationStandardCommand
{
OrganisationId = organisationId,
EndPointAssessorOrganisationId = endPointAssessorOrganisationId,
StandardCode = standardCode,
EffectiveFrom = DateTime.Parse(effectiveFrom.ToString()),
DeliveryAreas = deliveryAreas?.Split(",").ToList(),
ApplyingContactId = applyingContactId,
};
ExpectedResponse = response;
}
private async Task <List <int> > MapCommandToDeliveryAreas(CreateOrganisationStandardCommand command)
{
if (command.DeliveryAreas != null)
{
var areas = await _apiClient.GetDeliveryAreas();
return(areas.Where(a => command.DeliveryAreas.Contains(a.Area)).Select(a => a.Id).ToList());
}
return(new List <int>());
}
public void WhenGatheringAnswersForAnOrganisationStandard(StandardCommandTest commandTestSetup)
{
var expectedCommand = new CreateOrganisationStandardCommand
{
OrganisationId = commandTestSetup.OrganisationId,
EndPointAssessorOrganisationId = commandTestSetup.OrganisationName,
StandardCode = commandTestSetup.StandardCode,
EffectiveFrom = commandTestSetup.EffectiveFrom,
DeliveryAreas = commandTestSetup.DeliveryAreas,
ApplyingContactId = commandTestSetup.CreatedBy,
};
var applicationData = new Dictionary <string, object>
{
["effective_from"] = commandTestSetup.EffectiveFrom,
["delivery_areas"] = commandTestSetup.DeliveryAreasString
};
var applicationOrganisation = new Organisation
{
Id = commandTestSetup.OrganisationId,
EndPointAssessorName = commandTestSetup.OrganisationName,
EndPointAssessorOrganisationId = commandTestSetup.OrganisationName
};
var application = new ApplicationResponse
{
Id = _applicationId,
ApplicationId = _applicationId,
CreatedBy = commandTestSetup.CreatedBy.ToString(),
OrganisationId = applicationOrganisation.Id,
StandardCode = commandTestSetup.StandardCode
};
var applicationContact = new Contact {
Id = commandTestSetup.CreatedBy, SignInId = Guid.Empty, FamilyName = "", GivenNames = "", Email = ""
};
_mockApplicationApiClient.Setup(x => x.GetApplication(application.Id)).ReturnsAsync(application);
_mockQnaApiClient.Setup(x => x.GetApplicationDataDictionary(application.ApplicationId)).ReturnsAsync(applicationData);
_mockApiClient.Setup(x => x.GetOrganisation(application.OrganisationId)).ReturnsAsync(applicationOrganisation);
_mockApiClient.Setup(x => x.GetOrganisationContacts(application.OrganisationId)).ReturnsAsync(new List <Contact> {
applicationContact
});
var actualCommand = _answerService.GatherAnswersForOrganisationStandardForApplication(_applicationId).Result;
Assert.AreEqual(JsonConvert.SerializeObject(expectedCommand), JsonConvert.SerializeObject(actualCommand));
}
public async Task <CreateOrganisationStandardCommand> GatherAnswersForOrganisationStandardForApplication(Guid applicationId)
{
var application = await _applyApiClient.GetApplication(applicationId);
var applicationData = await _qnaApiClient.GetApplicationDataDictionary(application?.ApplicationId ?? Guid.Empty);
var organisation = await _apiApiClient.GetOrganisation(application?.OrganisationId ?? Guid.Empty);
var organisationContacts = await _apiApiClient.GetOrganisationContacts(organisation?.Id ?? Guid.Empty);
var applyingContact = organisationContacts?.FirstOrDefault(c => c.Id.ToString().Equals(application?.CreatedBy, StringComparison.InvariantCultureIgnoreCase));
if (application is null || applicationData is null || organisation is null || applyingContact is null)
{
return(new CreateOrganisationStandardCommand());
}
var effectiveFrom = DateTime.UtcNow.Date;
if (DateTime.TryParse(GetAnswer(applicationData, "effective_from"), out var effectiveFromDate))
{
effectiveFrom = effectiveFromDate.Date;
}
var deliveryAreas = GetAnswer(applicationData, "delivery_areas");
var command = new CreateOrganisationStandardCommand
(
organisation.Id,
organisation.EndPointAssessorOrganisationId,
application.StandardCode ?? 0,
application.ApplyData?.Apply?.StandardReference,
application.ApplyData?.Apply?.Versions,
effectiveFrom,
deliveryAreas?.Split(',').ToList(),
applyingContact.Id,
application.StandardApplicationType);
return(command);
}
private async Task <CreateEpaOrganisationStandardRequest> MapCommandToOrganisationStandardRequest(CreateOrganisationStandardCommand command)
{
var organisationId = _cleanser.CleanseStringForSpecialCharacters(command.EndPointAssessorOrganisationId);
return(new CreateEpaOrganisationStandardRequest
{
OrganisationId = organisationId,
StandardCode = command.StandardCode,
StandardReference = command.StandardReference,
StandardVersions = command.StandardVersions,
DateStandardApprovedOnRegister = command.DateStandardApprovedOnRegister,
EffectiveFrom = command.EffectiveFrom,
ContactId = command.ApplyingContactId.ToString(),
DeliveryAreas = await MapCommandToDeliveryAreas(command),
DeliveryAreasComments = string.Empty,
StandardApplicationType = command.StandardApplicationType
});
}
public async Task <CreateOrganisationStandardFromApplyResponse> InjectApplyOrganisationStandardDetailsIntoRegister(CreateOrganisationStandardCommand command)
{
var response = new CreateOrganisationStandardFromApplyResponse {
WarningMessages = new List <string>()
};
var warningMessages = new List <string>();
// Organisation checks ////////////////////////////////
RaiseWarningIfNoEpaoId(command.EndPointAssessorOrganisationId, warningMessages);
RaiseWarningIfEpaoIdIsInvalid(command.EndPointAssessorOrganisationId, warningMessages);
// Standard checks ///////////////////////////////////
RaiseWarningIfStandardCodeIsInvalid(command.StandardCode, warningMessages);
var standard = await MapCommandToOrganisationStandardRequest(command);
// If we passed basic pre-checks; then validate fully
if (warningMessages.Count == 0)
{
var validationResponse = await _assessorValidationService.ValidateNewOrganisationStandardRequest(standard);
if (!validationResponse.IsValid)
{
var validationResponseErrors = validationResponse.Errors.Select(err => err.ErrorMessage);
warningMessages.AddRange(validationResponseErrors);
_logger.LogInformation($"Inject standard failed on Validation Service. OrganisationId: {command.OrganisationId} - Warnings: {string.Join(",", validationResponseErrors)}");
}
}
else
{
_logger.LogInformation($"Inject standard failed at pre-check. OrganisationId: {command.OrganisationId} - Warnings: {string.Join(",", warningMessages)}");
}
// If everything has checked out; approve the standard
if (warningMessages.Count == 0)
{
_logger.LogInformation("Injecting new standard into register");
response.EpaoStandardId = await _apiClient.CreateEpaOrganisationStandard(standard);
}
else
{
_logger.LogWarning($"Cannot inject standard details into register at this time. OrganisationId: {command.OrganisationId} - Warnings: {string.Join(", ", warningMessages)}");
}
response.WarningMessages = warningMessages;
return(response);
}
