public async Task <IActionResult> Get(long uln, string lastname, string standard, int ukPrn)
{
var request = new GetBatchLearnerRequest
{
Uln = uln,
FamilyName = lastname,
Standard = standard,
IncludeCertificate = true,
UkPrn = ukPrn
};
var validationResult = await _getValidator.ValidateAsync(request);
var isRequestValid = validationResult.IsValid;
var validationErrors = validationResult.Errors.Select(error => error.ErrorMessage).ToList();
var getResponse = new GetBatchLearnerResponse
{
ValidationErrors = validationErrors
};
if (!validationErrors.Any() && isRequestValid)
{
var result = await _mediator.Send(request);
getResponse.Learner = result.Learner;
getResponse.Certificate = result.Certificate;
getResponse.EpaDetails = result.EpaDetails;
}
return(Ok(getResponse));
}
public async Task <IActionResult> GetLearner(long uln, string familyName, [SwaggerParameter("Standard Code or Standard Reference Number")] string standard)
{
var getRequest = new GetBatchLearnerRequest {
UkPrn = _headerInfo.Ukprn, Uln = uln, FamilyName = familyName, Standard = standard
};
var response = await _apiClient.GetLearner(getRequest);
if (response.ValidationErrors.Any())
{
ApiResponse error = new ApiResponse((int)HttpStatusCode.Forbidden, string.Join("; ", response.ValidationErrors));
return(StatusCode(error.StatusCode, error));
}
else if (response.Learner is null)
{
return(NotFound());
}
else if (response.Learner.Certificate is null)
{
return(Ok(response.Learner));
}
else
{
if (CertificateHelpers.IsDraftCertificateDeemedAsReady(response.Learner.Certificate))
{
response.Learner.Certificate.Status.CurrentStatus = CertificateStatus.Ready;
}
else if (response.Learner.Certificate.Status.CurrentStatus == CertificateStatus.Printed || response.Learner.Certificate.Status.CurrentStatus == CertificateStatus.Reprint)
{
response.Learner.Certificate.Status.CurrentStatus = CertificateStatus.Submitted;
}
return(Ok(response.Learner));
}
}
public async Task <IActionResult> GetLearnerDetails(string standard, long uln)
{
var request = new GetBatchLearnerRequest
{
Uln = uln,
Standard = standard,
IncludeCertificate = false,
};
var learnerDetails = await _mediator.Send(request);
return(Ok(learnerDetails.Learner));
}
public void Arrange()
{
var fixture = new Fixture();
_request = fixture.Create <GetBatchLearnerRequest>();
_response = fixture.Build <GetLearnerResponse>()
.With(r => r.ValidationErrors, new List <string>()).Create();
_mockApiClient = new Mock <IApiClient>();
_mockApiClient.Setup(c => c.GetLearner(It.IsAny <GetBatchLearnerRequest>())).ReturnsAsync(_response);
_learnerController = new LearnerController(Mock.Of <ILogger <LearnerController> >(), Mock.Of <IHeaderInfo>(), _mockApiClient.Object);
}
public void Arrange()
{
_request = Builder <GetBatchLearnerRequest> .CreateNew()
.With(r => r.IncludeCertificate = true).Build();
_certificateData = Builder <CertificateData> .CreateNew().Build();
_learnerResponse = Builder <Domain.Entities.Learner> .CreateNew().Build();
_epaoResponse = Builder <Organisation> .CreateNew().Build();
_certificateResponse = Builder <Certificate> .CreateNew()
.With(cr => cr.CertificateData = JsonConvert.SerializeObject(_certificateData))
.Build();
_standardResponse = Builder <Standard> .CreateNew().Build();
_mockMediator = new Mock <IMediator>();
_mockLearnerRepository = new Mock <ILearnerRepository>();
_mockOrgQueryRepository = new Mock <IOrganisationQueryRepository>();
_mockStandardService = new Mock <IStandardService>();
_mockCertificateRepoistory = new Mock <ICertificateRepository>();
_mockStandardService.Setup(ss => ss.GetStandardVersionById(_request.Standard, null))
.ReturnsAsync(_standardResponse);
_mockLearnerRepository.Setup(learner => learner.Get(_request.Uln, It.IsAny <int>()))
.ReturnsAsync(_learnerResponse);
_mockOrgQueryRepository.Setup(org => org.GetByUkPrn(It.IsAny <long>()))
.ReturnsAsync(_epaoResponse);
_mockMediator.Setup(m => m.Send(It.IsAny <GetBatchCertificateRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(_certificateResponse);
_mockCertificateRepoistory.Setup(cr => cr.GetCertificate(_request.Uln, It.IsAny <int>(), _request.FamilyName))
.ReturnsAsync(_certificateResponse);
_handler = new GetBatchLearnerHandler(_mockMediator.Object,
Mock.Of <ILogger <GetBatchLearnerHandler> >(),
_mockLearnerRepository.Object,
_mockOrgQueryRepository.Object,
_mockStandardService.Object,
_mockCertificateRepoistory.Object);
}
public virtual async Task <GetLearnerResponse> GetLearner(GetBatchLearnerRequest request)
{
var apiResponse = await Get <AssessorService.Api.Types.Models.ExternalApi.Learners.GetBatchLearnerResponse>($"/api/v1/learners/batch/{request.Uln}/{request.FamilyName}/{request.Standard}/{request.UkPrn}");
return(Mapper.Map <AssessorService.Api.Types.Models.ExternalApi.Learners.GetBatchLearnerResponse, GetLearnerResponse>(apiResponse));
}
