public void ProjectTrusts_ThreeTrusts_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectTrusts = new List <PostProjectsTrustsModel>
{
new PostProjectsTrustsModel
{
TrustId = Guid.Parse("a16e9020-9123-4420-8055-851d1b672fe1")
},
new PostProjectsTrustsModel
{
TrustId = Guid.Parse("a16e9020-9123-4420-8055-851d1b672ff2")
},
new PostProjectsTrustsModel
{
TrustId = Guid.Parse("a16e9020-9123-4420-8055-851d1b672fa9")
}
}
};
var result = _mapper.Map(request);
Assert.Equal("/accounts(a16e9020-9123-4420-8055-851d1b672fe1)", result.Trusts[0].TrustId);
Assert.Equal("/accounts(a16e9020-9123-4420-8055-851d1b672ff2)", result.Trusts[1].TrustId);
Assert.Equal("/accounts(a16e9020-9123-4420-8055-851d1b672fa9)", result.Trusts[2].TrustId);
}
public void RddOrRscInterventionReasons_ThreeAcademies_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
RddOrRscInterventionReasons = new List <RddOrRscInterventionReasonEnum>
{
RddOrRscInterventionReasonEnum.OfstedInadequateRating,
RddOrRscInterventionReasonEnum.RSCMindedToTerminateNotice,
RddOrRscInterventionReasonEnum.TerminationWarningNotice
}
},
new PostProjectsAcademiesModel
{
RddOrRscInterventionReasons = new List <RddOrRscInterventionReasonEnum>
{
RddOrRscInterventionReasonEnum.OfstedInadequateRating,
}
},
new PostProjectsAcademiesModel
{
RddOrRscInterventionReasons = new List <RddOrRscInterventionReasonEnum>()
}
}
};
var result = _mapper.Map(request);
Assert.Equal("596500002,596500001,596500000", result.Academies[0].RddOrRscInterventionReasons);
Assert.Equal("596500002", result.Academies[1].RddOrRscInterventionReasons);
Assert.Null(result.Academies[2].RddOrRscInterventionReasons);
}
public void ProjectTrust_Id_Required()
{
//No TrustId set raises error
var model = new PostProjectsRequestModel
{
ProjectTrusts = new List <PostProjectsTrustsModel>
{
new PostProjectsTrustsModel()
}
};
var result = _validator.Validate(model);
Assert.Contains(result.Errors, e => e.PropertyName == "ProjectTrusts[0].TrustId" && e.ErrorMessage == "Must not be empty");
//TrustId set doesn't raise error
model = new PostProjectsRequestModel
{
ProjectTrusts = new List <PostProjectsTrustsModel>
{
new PostProjectsTrustsModel {
TrustId = Guid.NewGuid()
}
}
};
result = _validator.Validate(model);
Assert.DoesNotContain(result.Errors, e => e.PropertyName == "ProjectTrusts[0].TrustId");
}
public void AcademiesTrusts_OneAcademy_ThreeTrusts_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel()
{
Trusts = new List <PostProjectsAcademiesTrustsModel>
{
new PostProjectsAcademiesTrustsModel
{
TrustId = Guid.Parse("81014326-5d51-e911-a82e-000d3a385a17")
},
new PostProjectsAcademiesTrustsModel
{
TrustId = Guid.Parse("a16e9020-9123-4420-8055-851d1b672fe1")
},
new PostProjectsAcademiesTrustsModel
{
TrustId = Guid.Parse("81014326-5e51-e911-a82e-000d3a385a17")
}
}
}
}
};
var result = _mapper.Map(request);
Assert.Equal("/accounts(81014326-5d51-e911-a82e-000d3a385a17)", result.Academies[0].Trusts[0].TrustId);
Assert.Equal("/accounts(a16e9020-9123-4420-8055-851d1b672fe1)", result.Academies[0].Trusts[1].TrustId);
Assert.Equal("/accounts(81014326-5e51-e911-a82e-000d3a385a17)", result.Academies[0].Trusts[2].TrustId);
}
public void AcademyId_ThreeAcademies_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
AcademyId = Guid.Parse("81014326-5d51-e911-a82e-000d3a385a17")
},
new PostProjectsAcademiesModel
{
AcademyId = Guid.Parse("a16e9020-9123-4420-8055-851d1b672fe1")
},
new PostProjectsAcademiesModel
{
AcademyId = Guid.Parse("9e644018-cbe7-4299-bd18-d30aa7bb13d6")
}
}
};
var result = _mapper.Map(request);
Assert.Equal("/accounts(81014326-5d51-e911-a82e-000d3a385a17)", result.Academies[0].AcademyId);
Assert.Equal("/accounts(a16e9020-9123-4420-8055-851d1b672fe1)", result.Academies[1].AcademyId);
Assert.Equal("/accounts(9e644018-cbe7-4299-bd18-d30aa7bb13d6)", result.Academies[2].AcademyId);
}
public void EsfaInterventionReasonsExplained_ThreeAcademies_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
EsfaInterventionReasonsExplained = "Some explanation"
},
new PostProjectsAcademiesModel
{
EsfaInterventionReasonsExplained = null
},
new PostProjectsAcademiesModel
{
EsfaInterventionReasonsExplained = "Another explanation"
}
}
};
var result = _mapper.Map(request);
Assert.Equal("Some explanation", result.Academies[0].EsfaInterventionReasonsExplained);
Assert.True(string.IsNullOrEmpty(result.Academies[1].EsfaInterventionReasonsExplained));
Assert.Equal("Another explanation", result.Academies[2].EsfaInterventionReasonsExplained);
}
public void EsfaInterventionReasons_MultipleAcademies_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
EsfaInterventionReasons = null
},
new PostProjectsAcademiesModel
{
EsfaInterventionReasons = new List <Models.Upstream.Enums.EsfaInterventionReasonEnum>
{
Models.Upstream.Enums.EsfaInterventionReasonEnum.FinanceConcerns,
}
},
new PostProjectsAcademiesModel
{
EsfaInterventionReasons = new List <Models.Upstream.Enums.EsfaInterventionReasonEnum>
{
Models.Upstream.Enums.EsfaInterventionReasonEnum.FinanceConcerns,
Models.Upstream.Enums.EsfaInterventionReasonEnum.IrregularityConcerns,
Models.Upstream.Enums.EsfaInterventionReasonEnum.SafeguardingConcerns
}
}
}
};
var result = _mapper.Map(request);
Assert.Null(result.Academies[0].EsfaInterventionReasons);
Assert.Equal("596500001", result.Academies[1].EsfaInterventionReasons);
Assert.Equal("596500001,596500002,596500003", result.Academies[2].EsfaInterventionReasons);
}
public void ProjectTrusts_NoTrusts_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectTrusts = null
};
var result = _mapper.Map(request);
Assert.Empty(result.Trusts);
}
public void ProjectStatus_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectStatus = Models.Upstream.Enums.ProjectStatusEnum.Completed
};
var result = _mapper.Map(request);
Assert.Equal(Models.D365.Enums.ProjectStatusEnum.Completed, result.ProjectStatus);
}
public void ProjectInitiator_Fields_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectInitiatorFullName = "Joe Bloggs",
ProjectInitiatorUid = "*****@*****.**"
};
var result = _mapper.Map(request);
Assert.Equal("Joe Bloggs", result.ProjectInitiatorFullName);
Assert.Equal("*****@*****.**", result.ProjectInitiatorUid);
}
public void AcademiesTrusts_OneAcademy_NoAcademyTrusts_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel()
}
};
var result = _mapper.Map(request);
Assert.Empty(result.Academies[0].Trusts);
}
public void RddOrRscInterventionReasonsExplained_Is_Not_Required()
{
var model = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel()
}
};
var result = _validator.Validate(model);
Assert.DoesNotContain(result.Errors, e => e.PropertyName == "ProjectAcademies[0].RddOrRscInterventionReasonsExplained");
}
public void RddOrRscInterventionReasonExplained_Must_Be_Shorter_Than_2000_Words()
{
//Explanation of 1999 words doesn't raise error
var underBoundaryText = new StringBuilder();
for (var i = 1; i < 2000; i++)
{
underBoundaryText.Append("word ");
}
var model = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
RddOrRscInterventionReasonsExplained = underBoundaryText.ToString()
}
}
};
var result = _validator.Validate(model);
Assert.DoesNotContain(result.Errors, e => e.PropertyName == "ProjectAcademies[0].RddOrRscInterventionReasonsExplained");
//Esplanation of 2000 words raises error
var overBoundaryText = new StringBuilder();
for (var i = 1; i <= 2000; i++)
{
overBoundaryText.Append("word ");
}
model = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
RddOrRscInterventionReasonsExplained = overBoundaryText.ToString()
}
}
};
result = _validator.Validate(model);
Assert.Contains(result.Errors, e => e.PropertyName == "ProjectAcademies[0].RddOrRscInterventionReasonsExplained" && e.ErrorMessage == "Must be shorter than 2000 words");
}
public void EsfaInterventionReasons_OneAcademy_Empty_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
EsfaInterventionReasons = null
}
}
};
var result = _mapper.Map(request);
Assert.True(string.IsNullOrEmpty(result.Academies[0].EsfaInterventionReasons));
}
public void EsfaInterventionReasonsExplained_OneAcademy_ValueSet_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
EsfaInterventionReasonsExplained = "Some explanation"
}
}
};
var result = _mapper.Map(request);
Assert.Equal("Some explanation", result.Academies[0].EsfaInterventionReasonsExplained);
}
public void AcademyId_OneAcademy_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
AcademyId = Guid.Parse("81014326-5d51-e911-a82e-000d3a385a17")
}
}
};
var result = _mapper.Map(request);
Assert.Equal("/accounts(81014326-5d51-e911-a82e-000d3a385a17)", result.Academies[0].AcademyId);
}
public async Task <RepositoryResult <Guid?> > InsertProject(PostProjectsRequestModel project)
{
var mappedProject = _postProjectsMapper.Map(project);
var jsonBody = JsonConvert.SerializeObject(mappedProject);
var buffer = System.Text.Encoding.UTF8.GetBytes(jsonBody);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = await _client.PostAsync(Route, byteContent);
var responseContent = await response.Content?.ReadAsStringAsync();
var responseStatusCode = response.StatusCode;
if (response.IsSuccessStatusCode)
{
if (response.Headers.TryGetValues("OData-EntityId", out var headerValues))
{
var value = headerValues.First();
var guidString = value.Substring(value.Length - 37, 36);
if (Guid.TryParse(guidString, out var guidValue))
{
return(new RepositoryResult <Guid?> {
Result = guidValue
});
}
}
}
//At this point, log the error and configure the repository result to inform the caller that the repo failed
_logger.LogError(RepositoryErrorMessages.RepositoryErrorLogFormat, responseStatusCode, responseContent);
return(new RepositoryResult <Guid?>
{
Error = new RepositoryResultBase.RepositoryError
{
StatusCode = responseStatusCode,
ErrorMessage = responseContent
}
});
}
public async Task <IActionResult> SubmitProject()
{
var outgoingTrustId = Guid.Parse(HttpContext.Session.GetString(OutgoingTrustIdSessionKey));
var incomingTrustId = Guid.Parse(HttpContext.Session.GetString(IncomingTrustIdSessionKey));
var academyIds = Session.GetStringListFromSession(HttpContext.Session, OutgoingAcademyIdSessionKey)
.Select(Guid.Parse);
var academies = academyIds.Select(id => new PostProjectsAcademiesModel
{
AcademyId = id,
Trusts = new List <PostProjectsAcademiesTrustsModel>
{
new PostProjectsAcademiesTrustsModel {
TrustId = outgoingTrustId
}
}
}).ToList();
var project = new PostProjectsRequestModel
{
ProjectInitiatorFullName = "academy",
ProjectInitiatorUid = Guid.NewGuid().ToString(),
ProjectAcademies = academies,
ProjectStatus = ProjectStatusEnum.InProgress,
ProjectTrusts = new List <PostProjectsTrustsModel>
{
new PostProjectsTrustsModel {
TrustId = incomingTrustId
},
new PostProjectsTrustsModel {
TrustId = outgoingTrustId
}
}
};
var result = await _projectsRepository.InsertProject(project);
HttpContext.Session.Remove(OutgoingTrustIdSessionKey);
HttpContext.Session.Remove(IncomingTrustIdSessionKey);
HttpContext.Session.Remove(OutgoingAcademyIdSessionKey);
return(RedirectToAction("Index", "Project", new { id = result.Result }));
}
public void RddOrRscInterventionReasons_OneAcademy_OneValue_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
RddOrRscInterventionReasons = new List <RddOrRscInterventionReasonEnum>
{
RddOrRscInterventionReasonEnum.OfstedInadequateRating
}
}
}
};
var result = _mapper.Map(request);
Assert.Equal("596500002", result.Academies[0].RddOrRscInterventionReasons);
}
public void EsfaInterventionReasons_OneAcademy_OneValue_MapTest()
{
var request = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
EsfaInterventionReasons = new List <Models.Upstream.Enums.EsfaInterventionReasonEnum>
{
Models.Upstream.Enums.EsfaInterventionReasonEnum.FinanceConcerns
}
}
}
};
var result = _mapper.Map(request);
Assert.Equal("596500001", result.Academies[0].EsfaInterventionReasons);
}
public void ProjectInitiatorUid_Is_Required()
{
//Assert error raised when Project Initiator Uid is empty
var model = new PostProjectsRequestModel();
var result = _validator.Validate(model);
Assert.Contains(result.Errors, t => t.PropertyName == "ProjectInitiatorUid" && t.ErrorMessage == "Must not be empty");
//Assert error not raised when Project Initiator Uid is not empty
model = new PostProjectsRequestModel
{
ProjectInitiatorUid = "*****@*****.**"
};
result = _validator.Validate(model);
Assert.DoesNotContain(result.Errors, e => e.PropertyName == "ProjectInitiatorUid" && e.ErrorMessage == "Must not be empty");
}
public void ProjectStatus_Is_Required()
{
//Assert error raised when Project Status is empty
var model = new PostProjectsRequestModel();
var result = _validator.Validate(model);
Assert.Contains(result.Errors, t => t.PropertyName == "ProjectStatus" && t.ErrorMessage == "Must not be empty");
//Assert error not raised when Project Status is not empty
model = new PostProjectsRequestModel
{
ProjectStatus = (Models.Upstream.Enums.ProjectStatusEnum) 8
};
result = _validator.Validate(model);
Assert.DoesNotContain(result.Errors, e => e.PropertyName == "ProjectStatus" && e.ErrorMessage == "Must not be empty");
}
public void ProjectAcademy_EsfaInterventionReasons_Must_Be_Unique()
{
var model = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
EsfaInterventionReasons = new List <EsfaInterventionReasonEnum>
{
EsfaInterventionReasonEnum.FinanceConcerns,
EsfaInterventionReasonEnum.GovernanceConcerns,
EsfaInterventionReasonEnum.FinanceConcerns
}
}
}
};
var result = _validator.Validate(model);
Assert.Contains(result.Errors, e => e.PropertyName == "ProjectAcademies[0].EsfaInterventionReasons" && e.ErrorMessage == "Duplicate status code detected");
}
public void ProjectAcademy_RddOrRscInterventionReasons_Must_Be_Unique()
{
var model = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
RddOrRscInterventionReasons = new List <RddOrRscInterventionReasonEnum>
{
RddOrRscInterventionReasonEnum.OfstedInadequateRating,
RddOrRscInterventionReasonEnum.RSCMindedToTerminateNotice,
RddOrRscInterventionReasonEnum.OfstedInadequateRating
}
}
}
};
var result = _validator.Validate(model);
Assert.Contains(result.Errors, e => e.PropertyName == "ProjectAcademies[0].RddOrRscInterventionReasons" && e.ErrorMessage == "Duplicate status code detected");
}
public void ProjectAcademy_RddOrRscInterventionReasons_MustBe_Valid()
{
//Invalid code raises error
var model = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
RddOrRscInterventionReasons = new List <RddOrRscInterventionReasonEnum> {
(RddOrRscInterventionReasonEnum)42
}
}
}
};
var result = _validator.Validate(model);
Assert.Contains(result.Errors, e => e.PropertyName == "ProjectAcademies[0].RddOrRscInterventionReasons[0]" && e.ErrorMessage == "Invalid status code");
//Valid code doesn't raise error
model = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
RddOrRscInterventionReasons = new List <RddOrRscInterventionReasonEnum> {
(RddOrRscInterventionReasonEnum)1
}
}
}
};
result = _validator.Validate(model);
Assert.DoesNotContain(result.Errors, e => e.PropertyName == "ProjectAcademies[0].RddOrRscInterventionReasons[0]");
}
public void ProjectAcademy_Id_IsRequired()
{
//Set up two project academies, one with a null ID one with a set ID
var model = new PostProjectsRequestModel
{
ProjectAcademies = new List <PostProjectsAcademiesModel>
{
new PostProjectsAcademiesModel
{
},
new PostProjectsAcademiesModel
{
AcademyId = Guid.NewGuid()
}
}
};
var result = _validator.Validate(model);
Assert.Contains(result.Errors, e => e.PropertyName == "ProjectAcademies[0].AcademyId" && e.ErrorMessage == "Must not be empty");
Assert.DoesNotContain(result.Errors, e => e.PropertyName == "ProjectAcademies[1].AcademyId");
}
public void ProjectStatus_Should_Be_Valid()
{
//Assert error raised when Project Status is provided but invalid
var model = new PostProjectsRequestModel
{
ProjectStatus = (Models.Upstream.Enums.ProjectStatusEnum) 8
};
var result = _validator.Validate(model);
Assert.Contains(result.Errors, t => t.PropertyName == "ProjectStatus" && t.ErrorMessage == "Invalid status code");
//Assert error not raised when Project Status is provided and valid
model = new PostProjectsRequestModel
{
ProjectStatus = (Models.Upstream.Enums.ProjectStatusEnum) 1
};
result = _validator.Validate(model);
Assert.DoesNotContain(result.Errors, e => e.PropertyName == "ProjectStatus" && e.ErrorMessage == "Invalid status code");
}
public async Task <IActionResult> InsertTrust([FromBody] PostProjectsRequestModel model)
{
var projectAcademiesIds = model.ProjectAcademies.Select(a => a.AcademyId).ToList();
var unprocessableEntityErrors = new List <string>();
#region Check Referenced Entities
foreach (var academyId in projectAcademiesIds)
{
var academyRepoResult = await _academiesRepository.GetAcademyById(academyId);
if (!academyRepoResult.IsValid)
{
return(_repositoryErrorHandler.LogAndCreateResponse(academyRepoResult));
}
if (academyRepoResult.Result == null)
{
unprocessableEntityErrors.Add($"No academy found with the id of: {academyId}");
}
}
var allTrustIds = new List <Guid>();
if (model.ProjectAcademies != null && model.ProjectAcademies.Any())
{
allTrustIds.AddRange(model.ProjectAcademies.Where(a => a.Trusts != null && a.Trusts.Any())
.SelectMany(s => s.Trusts)
.Select(s => s.TrustId));
}
if (model.ProjectTrusts != null && model.ProjectTrusts.Any())
{
allTrustIds.AddRange(model.ProjectTrusts.Select(p => p.TrustId));
}
if (allTrustIds.Any())
{
foreach (var trustId in allTrustIds.Distinct())
{
var trustsRepositoryResult = await _trustsRepository.GetTrustById(trustId);
if (!trustsRepositoryResult.IsValid)
{
return(_repositoryErrorHandler.LogAndCreateResponse(trustsRepositoryResult));
}
if (trustsRepositoryResult.Result == null)
{
unprocessableEntityErrors.Add($"No trust found with the id of: {trustId}");
}
}
}
#endregion
//If errors are detected with entity referencing, return an UnprocessableEntity result
if (unprocessableEntityErrors.Any())
{
var error = unprocessableEntityErrors.ToDelimitedString(". ");
return(UnprocessableEntity(error));
}
var internalModel = _postProjectsMapper.Map(model);
var insertProjectRepositoryResult = await _projectsRepository.InsertProject(internalModel);
if (!insertProjectRepositoryResult.IsValid)
{
return(_repositoryErrorHandler.LogAndCreateResponse(insertProjectRepositoryResult));
}
var getProjectRepositoryResult = await _projectsRepository.GetProjectById(insertProjectRepositoryResult.Result.Value);
if (!getProjectRepositoryResult.IsValid)
{
return(_repositoryErrorHandler.LogAndCreateResponse(getProjectRepositoryResult));
}
var externalModel = _getProjectsMapper.Map(getProjectRepositoryResult.Result);
var apiBaseUrl = _config["API:Url"];
return(Created($"{apiBaseUrl}/projects/{externalModel.ProjectId}", externalModel));
}
