public async Task <Certificate> Start(StartCertificateRequest request) { using (var httpRequest = new HttpRequestMessage(HttpMethod.Post, "api/v1/certificates/start")) { return(await PostPutRequestWithResponse <StartCertificateRequest, Certificate>(httpRequest, request)); } }
public async Task WhenHandlingStartCertificateRequest_AndThereIsExistingCertificate_NotDeleted_UpdatesCertificateForNewGrade( StartCertificateRequest request, Organisation organisationRecord, Certificate existingCertificate, CertificateData certificateData, Standard standard, Provider provider, Domain.Entities.Learner learnerRecord) { // Arrange existingCertificate.Status = CertificateStatus.Submitted; certificateData.OverallGrade = CertificateGrade.Fail; existingCertificate.CertificateData = JsonConvert.SerializeObject(certificateData); _mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord); _mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync(existingCertificate); _mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync(standard); _mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord); _mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider); Certificate updatedCertficate = null; _mockCertificateRepository.Setup(s => s.Update(It.IsAny <Certificate>(), It.IsAny <string>(), It.IsAny <string>(), true, null)) .Callback <Certificate, string, string, bool, string>((cert, username, action, updateLogs, reason) => { updatedCertficate = cert; }).ReturnsAsync(updatedCertficate); // Act var response = await _sut.Handle(request, new CancellationToken()); // Assertions updatedCertficate.Status.Should().Be(CertificateStatus.Draft); _mockCertificateRepository.Verify(s => s.Update(existingCertificate, request.Username, CertificateActions.Restart, true, null), Times.Once); }
public async Task WhenHandlingStartCertificateRequest_AndNoExistingCertificate_StandardUIdSet_CreatesNewCertificate_WithVersionDetails( StartCertificateRequest request, Domain.Entities.Learner learnerRecord, Organisation organisationRecord, Provider provider, Certificate stubCertificate, Standard standard) { // Arrange learnerRecord.FundingModel = 81; _mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync((Certificate)null); _mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord); _mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord); _mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider); _mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync(standard); Certificate createdCertificate = null; _mockCertificateRepository.Setup(s => s.New(It.IsAny <Certificate>())).Callback <Certificate>((cert) => { createdCertificate = cert; }).ReturnsAsync(stubCertificate); // Act var response = await _sut.Handle(request, new CancellationToken()); // Assertions response.Should().BeEquivalentTo(stubCertificate); createdCertificate.Should().BeEquivalentTo(new { request.Uln, request.StandardCode, ProviderUkPrn = learnerRecord.UkPrn, OrganisationId = organisationRecord.Id, CreatedBy = request.Username, Status = CertificateStatus.Draft, CertificateReference = string.Empty, learnerRecord.LearnRefNumber, CreateDay = DateTime.UtcNow.Date, IsPrivatelyFunded = false, StandardUId = standard.StandardUId }); var certData = JsonConvert.DeserializeObject <CertificateData>(createdCertificate.CertificateData); certData.Should().BeEquivalentTo(new { LearnerGivenNames = learnerRecord.GivenNames, LearnerFamilyName = learnerRecord.FamilyName, LearningStartDate = learnerRecord.LearnStartDate, FullName = $"{learnerRecord.GivenNames} {learnerRecord.FamilyName}", ProviderName = provider.Name, StandardName = standard.Title, StandardReference = standard.IfateReferenceNumber, StandardLevel = standard.Level, StandardPublicationDate = standard.VersionApprovedForDelivery, Version = standard.Version, CourseOption = request.CourseOption }); }
public async Task WhenHandlingStartCertificateRequest_AndNoExistingCertificate_CreatesNewCertificate_WhenStandardUIdNotSet( StartCertificateRequest request, Domain.Entities.Learner learnerRecord, Organisation organisationRecord, Provider provider, Certificate stubCertificate, IEnumerable <Standard> standards) { // Arrange request.StandardUId = null; learnerRecord.FundingModel = 81; _mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync((Certificate)null); _mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord); _mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord); _mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider); _mockStandardService.Setup(s => s.GetStandardVersionsByLarsCode(learnerRecord.StdCode)).ReturnsAsync(standards); Certificate createdCertificate = null; _mockCertificateRepository.Setup(s => s.New(It.IsAny <Certificate>())).Callback <Certificate>((cert) => { createdCertificate = cert; }).ReturnsAsync(stubCertificate); // Act var response = await _sut.Handle(request, new CancellationToken()); // Assertions response.Should().BeEquivalentTo(stubCertificate); createdCertificate.Should().BeEquivalentTo(new { request.Uln, request.StandardCode, ProviderUkPrn = learnerRecord.UkPrn, OrganisationId = organisationRecord.Id, CreatedBy = request.Username, Status = CertificateStatus.Draft, CertificateReference = string.Empty, learnerRecord.LearnRefNumber, CreateDay = DateTime.UtcNow.Date, IsPrivatelyFunded = false }); var certData = JsonConvert.DeserializeObject <CertificateData>(createdCertificate.CertificateData); certData.Should().BeEquivalentTo(new { LearnerGivenNames = learnerRecord.GivenNames, LearnerFamilyName = learnerRecord.FamilyName, LearningStartDate = learnerRecord.LearnStartDate, FullName = $"{learnerRecord.GivenNames} {learnerRecord.FamilyName}", ProviderName = provider.Name, StandardName = standards.OrderByDescending(s => s.VersionMajor).ThenByDescending(t => t.VersionMinor).First().Title }); }
private async Task <EpaDetails> CreateNewEpa(CreateBatchEpaRequest request) { _logger.LogInformation("CreateNewEpa Before Get Certificate from db"); var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode); if (certificate is null) { _logger.LogInformation("CreateNewEpa Before StartCertificateRequest"); var startCertificateRequest = new StartCertificateRequest { StandardCode = request.StandardCode, UkPrn = request.UkPrn, Uln = request.Uln, Username = ExternalApiConstants.ApiUserName }; certificate = await _mediator.Send(startCertificateRequest); } else { certificate = EpaHelpers.ResetCertificateData(certificate); } if (certificate is null) { _logger.LogError($"CreateNewEpa StartCertificateRequest did not create Certificate for Uln {request.Uln} StandardCode {request.StandardCode}"); throw new NotFound(); } certificate.Status = Domain.Consts.CertificateStatus.Draft; _logger.LogInformation("CreateNewEpa Before Resetting Certificate Data"); var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData); _logger.LogInformation("CreateNewEpa Before Adding EPAs"); if (request.EpaDetails?.Epas != null) { foreach (var epa in request.EpaDetails.Epas) { epa.EpaOutcome = EpaHelpers.NormalizeEpaOutcome(epa.EpaOutcome); certData.EpaDetails.Epas.Add(epa); } } var latestEpaRecord = certData.EpaDetails.Epas.OrderByDescending(epa => epa.EpaDate).FirstOrDefault(); certData.EpaDetails.LatestEpaDate = latestEpaRecord?.EpaDate; certData.EpaDetails.LatestEpaOutcome = latestEpaRecord?.EpaOutcome; _logger.LogInformation("CreateNewEpa Before Update CertificateData"); certificate.CertificateData = JsonConvert.SerializeObject(certData); _logger.LogInformation("CreateNewEpa Before Update Cert in db"); await _certificateRepository.Update(certificate, ExternalApiConstants.ApiUserName, CertificateActions.Epa); return(certData.EpaDetails); }
public async Task WhenHandlingStartCertificateRequest_AndThereIsExistingCertificate_WhichIsDeleted_ResetCertificateData( StartCertificateRequest request, Organisation organisationRecord, Certificate existingCertificate, Domain.Entities.Learner learnerRecord, CertificateData certificateData, Standard standard, Provider provider, Certificate stubCertificate) { // Arrange learnerRecord.FundingModel = 81; existingCertificate.Status = CertificateStatus.Deleted; existingCertificate.CertificateData = JsonConvert.SerializeObject(certificateData); _mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord); _mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync(existingCertificate); _mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord); _mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync(standard); _mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider); Certificate updatedCertficate = null; _mockCertificateRepository.Setup(s => s.Update(It.IsAny <Certificate>(), It.IsAny <string>(), It.IsAny <string>(), true, null)) .Callback <Certificate, string, string, bool, string>((cert, username, action, updateLogs, reason) => { updatedCertficate = cert; }).ReturnsAsync(stubCertificate); // Act var response = await _sut.Handle(request, new CancellationToken()); // Assertions updatedCertficate.IsPrivatelyFunded.Should().BeFalse(); var responseCertData = JsonConvert.DeserializeObject <CertificateData>(updatedCertficate.CertificateData); responseCertData.LearnerGivenNames.Should().Be(learnerRecord.GivenNames); responseCertData.LearnerFamilyName.Should().Be(learnerRecord.FamilyName); responseCertData.LearningStartDate.Should().Be(learnerRecord.LearnStartDate); responseCertData.FullName.Should().Be($"{learnerRecord.GivenNames} {learnerRecord.FamilyName}"); _mockCertificateRepository.Verify(s => s.Update(existingCertificate, request.Username, null, true, null), Times.Once); }
public void WhenHandlingStartCertificateRequest_AndNoExistingCertificate_WhenStandardUIdSet_ButVersionInvalid_ThrowsException( StartCertificateRequest request, Domain.Entities.Learner learnerRecord, Organisation organisationRecord, Provider provider, Certificate stubCertificate, IEnumerable <Standard> standards) { // Arrange _mockCertificateRepository.Setup(s => s.GetCertificate(request.Uln, request.StandardCode)).ReturnsAsync((Certificate)null); _mockLearnerRepository.Setup(s => s.Get(request.Uln, request.StandardCode)).ReturnsAsync(learnerRecord); _mockOrganisationQueryRepository.Setup(s => s.GetByUkPrn(request.UkPrn)).ReturnsAsync(organisationRecord); _mockProvidersRepository.Setup(s => s.GetProvider(learnerRecord.UkPrn)).ReturnsAsync(provider); _mockStandardService.Setup(s => s.GetStandardVersionById(request.StandardUId, null)).ReturnsAsync((Standard)null); // Act Func <Task> act = async() => { await _sut.Handle(request, new CancellationToken()); }; act.Should().Throw <InvalidOperationException>().WithMessage($"StandardUId:{request.StandardUId} not found, unable to populate certificate data"); }
private async Task <EpaDetails> CreateNewEpa(CreateBatchEpaRequest request) { _logger.LogInformation("CreateNewEpa Before Get Certificate from db"); var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode); if (certificate is null) { _logger.LogInformation("CreateNewEpa Before StartCertificateRequest"); var startCertificateRequest = new StartCertificateRequest { StandardCode = request.StandardCode, UkPrn = request.UkPrn, Uln = request.Uln, Username = ExternalApiConstants.ApiUserName, CourseOption = request.CourseOption, StandardUId = request.StandardUId }; certificate = await _mediator.Send(startCertificateRequest); } else { certificate = EpaHelpers.ResetCertificateData(certificate); } if (certificate is null) { _logger.LogError($"CreateNewEpa StartCertificateRequest did not create Certificate for Uln {request.Uln} StandardCode {request.StandardCode}"); throw new NotFoundException(); } certificate.Status = Domain.Consts.CertificateStatus.Draft; _logger.LogInformation("CreateNewEpa Before Resetting Certificate Data"); var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData); _logger.LogInformation("CreateNewEpa Before Adding EPAs"); if (request.EpaDetails?.Epas != null) { foreach (var epa in request.EpaDetails.Epas) { epa.EpaOutcome = EpaHelpers.NormalizeEpaOutcome(epa.EpaOutcome); certData.EpaDetails.Epas.Add(epa); } } var latestEpaRecord = certData.EpaDetails.Epas.OrderByDescending(epa => epa.EpaDate).FirstOrDefault(); certData.EpaDetails.LatestEpaDate = latestEpaRecord?.EpaDate; certData.EpaDetails.LatestEpaOutcome = latestEpaRecord?.EpaOutcome; var epaAction = CertificateActions.Epa; if (latestEpaRecord?.EpaOutcome.Equals(EpaOutcome.Fail, StringComparison.InvariantCultureIgnoreCase) == true) { certData.AchievementDate = latestEpaRecord?.EpaDate; certData.OverallGrade = CertificateGrade.Fail; certificate.Status = CertificateStatus.Submitted; epaAction = CertificateActions.Submit; } else { certData.AchievementDate = null; certData.OverallGrade = null; certificate.Status = CertificateStatus.Draft; } _logger.LogInformation("CreateNewEpa Before Update CertificateData"); certificate.CertificateData = JsonConvert.SerializeObject(certData); _logger.LogInformation("CreateNewEpa Before Update Cert in db"); await _certificateRepository.Update(certificate, ExternalApiConstants.ApiUserName, epaAction); return(certData.EpaDetails); }
public async Task <IActionResult> Start([FromBody] StartCertificateRequest request) { return(Ok(await _mediator.Send(request))); }
public async Task <IActionResult> Start(CertificateStartViewModel vm) { _sessionService.Remove(nameof(CertificateSession)); var ukprn = _contextAccessor.HttpContext.User.FindFirst("http://schemas.portal.com/ukprn")?.Value; var username = _contextAccessor.HttpContext.User.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn")?.Value; List <string> options = new List <string>(); var singleOption = string.Empty; List <StandardVersion> versions = new List <StandardVersion>(); var startCertificateRequest = new StartCertificateRequest() { UkPrn = int.Parse(ukprn), StandardCode = vm.StdCode, Uln = vm.Uln, Username = username }; async Task RetrieveAndPopulateStandardOptions(string standardUId) { var optionsResult = await _standardVersionClient.GetStandardOptions(standardUId); if (optionsResult != null && optionsResult.HasOptions()) { if (optionsResult.OnlyOneOption()) { singleOption = optionsResult.CourseOption.Single(); startCertificateRequest.CourseOption = singleOption; } options = optionsResult.CourseOption.ToList(); } } var learner = await _learnerApiClient.GetLearnerRecord(vm.StdCode, vm.Uln); var versionsResult = await _standardVersionClient.GetStandardVersionsByLarsCode(vm.StdCode); if (learner.VersionConfirmed && !string.IsNullOrEmpty(learner.Version)) { var version = versionsResult.First(v => v.Version == learner.Version); startCertificateRequest.StandardUId = version.StandardUId; versions.Add(version); if (!string.IsNullOrEmpty(learner.CourseOption)) { options.Add(learner.CourseOption); startCertificateRequest.CourseOption = learner.CourseOption; } else { await RetrieveAndPopulateStandardOptions(version.StandardUId); } } else { versions = versionsResult.ToList(); if (versionsResult.Count() == 1) { startCertificateRequest.StandardUId = versionsResult.First().StandardUId; await RetrieveAndPopulateStandardOptions(versionsResult.First().StandardUId); } } _logger.LogInformation($"Start of Certificate Start for ULN {vm.Uln} and Standard Code: {vm.StdCode} by user {username}"); var cert = await _certificateApiClient.Start(startCertificateRequest); var certificateSession = new CertificateSession() { CertificateId = cert.Id, Uln = vm.Uln, StandardCode = vm.StdCode, StandardUId = startCertificateRequest.StandardUId, Versions = Mapper.Map <List <StandardVersionViewModel> >(versions), Options = options }; _sessionService.Set(nameof(CertificateSession), certificateSession); _logger.LogInformation($"New Certificate received for ULN {vm.Uln} and Standard Code: {vm.StdCode} with ID {cert.Id}"); if (versions.Count() > 1) { return(RedirectToAction("Version", "CertificateVersion")); } else if (!string.IsNullOrWhiteSpace(singleOption)) { return(RedirectToAction("Declare", "CertificateDeclaration")); } else if (options.Count > 1) { return(RedirectToAction("Option", "CertificateOption")); } return(RedirectToAction("Declare", "CertificateDeclaration")); }