public async Task <OrchestratorResponse <UpdateApprenticeshipViewModel> > GetConfirmChangesModel(
string hashedAccountId, string hashedApprenticeshipId, string externalUserId,
ApprenticeshipViewModel apprenticeship)
{
var accountId = _hashingService.DecodeValue(hashedAccountId);
var apprenticeshipId = _hashingService.DecodeValue(hashedApprenticeshipId);
_logger.Debug($"Getting confirm change model: {accountId}, ApprenticeshipId: {apprenticeshipId}");
return(await CheckUserAuthorization(async() =>
{
await AssertApprenticeshipStatus(accountId, apprenticeshipId);
var data = await _mediator.SendAsync(new GetApprenticeshipQueryRequest
{
AccountId = accountId,
ApprenticeshipId = apprenticeshipId
});
var apprenticeships = _apprenticeshipMapper.CompareAndMapToApprenticeshipViewModel(data.Apprenticeship,
apprenticeship);
return new OrchestratorResponse <UpdateApprenticeshipViewModel>
{
Data = await apprenticeships
};
}, hashedAccountId, externalUserId));
}
public async Task ShouldUpdateTrainngProgramForStandard()
{
var a = new Apprenticeship
{
TrainingCode = "abba-666"
};
var updated = new ApprenticeshipViewModel
{
TrainingCode = "007"
};
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetTrainingProgrammesQueryRequest>()))
.ReturnsAsync(
new GetTrainingProgrammesQueryResponse
{
TrainingProgrammes = new List <TrainingProgramme>
{
new TrainingProgramme {
CourseCode = "abba-555", Name = "Framework Title"
},
new TrainingProgramme {
CourseCode = "007", Name = "Standard Title",
}
}
});
var model = await Sut.CompareAndMapToApprenticeshipViewModel(a, updated);
model.TrainingCode.Should().Be("007");
model.TrainingName.Should().Be("Standard Title");
model.TrainingType.Should().Be(TrainingType.Standard);
}
public Dictionary <string, string> ValidateToDictionary(ApprenticeshipViewModel model)
{
var result = Validate(model);
return(result.Errors.ToDictionary(
approvedError => approvedError.PropertyName, approvedError => approvedError.ErrorMessage));
}
public async Task GivenValidUlnAndAccountIdShouldCallServiceAndReturnApprenticeshipView()
{
///Arrange
var apprenticeshipHashId = "V673UHWE";
var accountHashId = "HTYDUD120";
var apprenticeshipVm = new ApprenticeshipViewModel
{
Uln = "123456782"
};
_orchestrator
.Setup(x => x.GetApprenticeship(apprenticeshipHashId, accountHashId))
.ReturnsAsync(apprenticeshipVm)
.Verifiable();
var controller = new ApprenticeshipsController(_orchestrator.Object);
// Act
var result = await controller.Index(apprenticeshipHashId, accountHashId);
// Assert
_orchestrator.VerifyAll();
var view = result as ViewResult;
view.Should().NotBeNull();
view.Model.Should().BeOfType <ApprenticeshipViewModel>();
}
public Apprenticeship MapFrom(long commitmentId, ApprenticeshipViewModel viewModel, IList <TrainingProgramme> trainingProgrammes)
{
var apprenticeship = new Apprenticeship
{
CommitmentId = commitmentId,
FirstName = viewModel.FirstName,
LastName = viewModel.LastName,
DateOfBirth = viewModel.DateOfBirth.DateTime,
NINumber = viewModel.NINumber,
ULN = viewModel.ULN,
Cost = viewModel.Cost == null ? default(decimal?) : decimal.Parse(viewModel.Cost),
StartDate = viewModel.StartDate.DateTime,
EndDate = viewModel.EndDate.DateTime,
ProviderRef = viewModel.ProviderRef
};
if (!string.IsNullOrWhiteSpace(viewModel.CourseCode))
{
var training = trainingProgrammes.Single(x => x.CourseCode == viewModel.CourseCode);
apprenticeship.TrainingType = int.TryParse(training.CourseCode, out _) ? ApiTrainingType.Standard : ApiTrainingType.Framework;
apprenticeship.TrainingCode = viewModel.CourseCode;
apprenticeship.TrainingName = training.Name;
}
return(apprenticeship);
}
public async Task <IDictionary <string, string> > ValidateApprenticeship(ApprenticeshipViewModel apprenticeship, UpdateApprenticeshipViewModel updatedModel)
{
ConcurrentDictionary <string, string> errors = new ConcurrentDictionary <string, string>();
await Task.WhenAll(AddOverlapAndDateValidationErrors(errors, apprenticeship, updatedModel), AddReservationValidationErrors(errors, apprenticeship));
return(errors);
}
public async Task ShouldUpdateTrainngProgramForStandard()
{
var a = new Apprenticeship
{
TrainingCode = "abba-666"
};
var updated = new ApprenticeshipViewModel
{
TrainingCode = "standard-007"
};
_mockMediator.Setup(m => m.SendAsync(It.IsAny <GetTrainingProgrammesQueryRequest>()))
.ReturnsAsync(
new GetTrainingProgrammesQueryResponse
{
TrainingProgrammes = new List <ITrainingProgramme>
{
new Framework {
Id = "abba-555", FrameworkCode = 05, PathwayCode = 88, ProgrammeType = 2, Title = "Framework Title"
},
new Standard {
Id = "standard-007", Title = "Standard Title",
}
}
});
var model = await _mappingTjänst.CompareAndMapToApprenticeshipViewModel(a, updated);
model.TrainingCode.Should().Be("standard-007");
model.TrainingName.Should().Be("Standard Title");
model.TrainingType.Should().Be(TrainingType.Standard);
}
public async Task <ActionResult> EditApprenticeship(ApprenticeshipViewModel apprenticeship)
{
if (!ModelState.IsValid)
{
apprenticeship.AddErrorsFromModelState(ModelState);
}
var validatorResult = await _employerCommitmentsOrchestrator.ValidateApprenticeship(apprenticeship);
if (validatorResult.Any())
{
apprenticeship.AddErrorsFromDictionary(validatorResult);
}
if (apprenticeship.ErrorDictionary.Any())
{
return(await RedisplayEditApprenticeshipView(apprenticeship));
}
try
{
await _employerCommitmentsOrchestrator.UpdateApprenticeship(apprenticeship, OwinWrapper.GetClaimValue(@"sub"));
}
catch (InvalidRequestException ex)
{
apprenticeship.AddErrorsFromDictionary(ex.ErrorMessages);
return(await RedisplayEditApprenticeshipView(apprenticeship));
}
return(RedirectToAction("Details", new { hashedAccountId = apprenticeship.HashedAccountId, hashedCommitmentId = apprenticeship.HashedCommitmentId }));
}
public async Task <ActionResult> ConfirmChanges(long providerId, ApprenticeshipViewModel model)
{
var updateViewModel = await _orchestrator.GetConfirmChangesModel(providerId, model.HashedApprenticeshipId, model);
var validationErrors = await _orchestrator.ValidateEditApprenticeship(model, updateViewModel);
foreach (var error in validationErrors)
{
if (ModelState.ContainsKey(error.Key))
{
continue;
}
ModelState.AddModelError(error.Key, error.Value);
}
if (!ModelState.IsValid)
{
return(await RedisplayEditApprenticeshipView(model));
}
if (!AnyChanges(updateViewModel))
{
ModelState.AddModelError("NoChangesRequested", "No changes made");
return(await RedisplayEditApprenticeshipView(model));
}
ModelState.Clear();
return(View(updateViewModel));
}
public void BaseSetup()
{
MockMediator = new Mock <IMediator>();
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetTrainingProgrammesQueryRequest>()))
.ReturnsAsync(new GetTrainingProgrammesQueryResponse
{
TrainingProgrammes = new List <TrainingProgramme>
{
new TrainingProgramme
{
CourseCode = "TESTCOURSE",
EffectiveFrom = new DateTime(2018, 5, 1),
EffectiveTo = new DateTime(2018, 7, 1)
}
}
});
YearNow = DateTime.Now.Year;
CurrentDateTime.Setup(x => x.Now).Returns(DateTime.Now.AddMonths(6));
var academicYearProvider = new AcademicYearDateProvider(CurrentDateTime.Object);
Validator = new ApprenticeshipViewModelValidator(
new WebApprenticeshipValidationText(academicYearProvider),
academicYearProvider,
new AcademicYearValidator(CurrentDateTime.Object, academicYearProvider),
CurrentDateTime.Object,
MockMediator.Object);
ValidModel = new ApprenticeshipViewModel
{
ULN = "1001234567",
FirstName = "TestFirstName",
LastName = "TestLastName"
};
}
public async Task <Dictionary <string, string> > ValidateApprenticeship(ApprenticeshipViewModel viewModel)
{
var overlappingErrors = await Mediator.Send(
new GetOverlappingApprenticeshipsQueryRequest
{
Apprenticeship = new List <Apprenticeship> {
await _apprenticeshipMapper.MapApprenticeship(viewModel)
}
});
var result = _apprenticeshipCoreValidator.MapOverlappingErrors(overlappingErrors);
// EndDate is optional before approval
if (viewModel.EndDate.DateTime != null)
{
var endDateError = _apprenticeshipCoreValidator.CheckEndDateInFuture(viewModel.EndDate);
if (endDateError != null)
{
result.AddIfNotExists(endDateError.Value);
}
}
var uniqueUlnValidationResult = await _uniqueUlnValidator.ValidateAsyncOverride(viewModel);
if (!uniqueUlnValidationResult.IsValid)
{
foreach (var error in uniqueUlnValidationResult.Errors)
{
result.AddIfNotExists(error.PropertyName, error.ErrorMessage);
}
}
return(result);
}
private async Task <ActionResult> RedisplayEditApprenticeshipView(ApprenticeshipViewModel apprenticeship)
{
var viewModel = await _orchestrator.GetApprenticeshipForEdit(apprenticeship.ProviderId, apprenticeship.HashedApprenticeshipId);
ViewBag.ApprenticeshipProgrammes = viewModel.ApprenticeshipProgrammes;
return(View("Edit", apprenticeship));
}
public async Task ThenIfTheUlnIsNotUniqueThenNotValid()
{
//Arrange
var viewModel = new ApprenticeshipViewModel
{
ULN = "TEST"
};
_mediator.Setup(x => x.Send(It.IsAny <GetCommitmentQueryRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => new GetCommitmentQueryResponse
{
Commitment = new CommitmentView
{
Apprenticeships = new List <Apprenticeship>
{
new Apprenticeship {
Id = 1, ULN = "TEST2"
},
new Apprenticeship {
Id = 2, ULN = "TEST"
},
new Apprenticeship {
Id = 3, ULN = "TEST3"
}
}
}
});
//Act
var result = await _validator.ValidateAsync(viewModel);
//Assert
Assert.IsFalse(result.IsValid);
}
public async Task ShouldCallReservationValidationsAndReturnErrors()
{
var viewModel = new ApprenticeshipViewModel();
viewModel.ReservationId = Guid.NewGuid();
viewModel.StartDate = new DateTimeViewModel(1, 1, 2001);
var updateModel = new UpdateApprenticeshipViewModel();
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetReservationValidationRequest>()))
.ReturnsAsync(new GetReservationValidationResponse
{
Data = new ReservationValidationResult(new List <ReservationValidationError>
{
new ReservationValidationError("Reservation", "A reservation issue")
})
});
var result = await Orchestrator.ValidateApprenticeship(viewModel, updateModel);
Assert.IsTrue(result.ContainsKey("Reservation"));
Assert.AreEqual("A reservation issue", result["Reservation"]);
MockMediator.Verify(m => m.SendAsync(It.IsAny <GetReservationValidationRequest>()), Times.Once);
}
public async Task ShouldNotUpdateDatesIfNotChanged()
{
var a = new Apprenticeship
{
DateOfBirth = new DateTime(1998, 12, 8),
StartDate = new DateTime(2045, 12, 08),
EndDate = new DateTime(2046, 12, 08)
};
var dob = new DateTimeViewModel(8, 12, 1998);
var sd = new DateTimeViewModel(08, 12, 2045);
var ed = new DateTimeViewModel(08, 12, 2046);
var updated = new ApprenticeshipViewModel
{
DateOfBirth = dob,
StartDate = sd,
EndDate = ed
};
var model = await Sut.CompareAndMapToApprenticeshipViewModel(a, updated);
model.DateOfBirth.Should().BeNull();
model.StartDate.Should().BeNull();
model.EndDate.Should().BeNull();
}
public async Task UpdateEveryField()
{
var a = new Apprenticeship
{
FirstName = "Kalle",
LastName = "Abba",
EmployerRef = "This is a reference",
Cost = 4.0M
};
var updated = new ApprenticeshipViewModel
{
FirstName = "Fredrik",
LastName = "Stockborg",
EmployerRef = "New ref",
Cost = "5"
};
var model = await Sut.CompareAndMapToApprenticeshipViewModel(a, updated);
model.FirstName.Should().Be("Fredrik");
model.LastName.Should().Be("Stockborg");
model.EmployerRef.Should().Be("New ref");
model.Cost.Should().Be("5");
}
public async Task ShouldValidate()
{
var viewModel = new ApprenticeshipViewModel();
var updateModel = new CreateApprenticeshipUpdateViewModel();
_mockMapper
.Setup(m => m.MapApprenticeship(It.IsAny <ApprenticeshipViewModel>()))
.ReturnsAsync(new Apprenticeship {
ReservationId = Guid.NewGuid(), StartDate = DateTime.Today
});
_mockMediator
.Setup(m => m.Send(It.IsAny <GetOverlappingApprenticeshipsQueryRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetOverlappingApprenticeshipsQueryResponse {
Overlaps = new List <ApprenticeshipOverlapValidationResult>()
});
_mockMediator
.Setup(m => m.Send(It.IsAny <GetReservationValidationRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetReservationValidationResponse {
Data = new ReservationValidationResult(new ReservationValidationError[0])
});
await _orchestrator.ValidateEditApprenticeship(viewModel, updateModel);
_mockMediator.Verify(m => m.Send(It.IsAny <GetOverlappingApprenticeshipsQueryRequest>(), It.IsAny <CancellationToken>()), Times.Once, failMessage: "Should call");
_mockMediator.Verify(m => m.Send(It.IsAny <GetReservationValidationRequest>(), It.IsAny <CancellationToken>()), Times.Once, failMessage: "Should call");
_mockValidator.Verify(m => m.MapOverlappingErrors(It.IsAny <GetOverlappingApprenticeshipsQueryResponse>()), Times.Once, failMessage: "Should verify overlapping apprenticeship");
_mockValidator.Verify(m => m.ValidateToDictionary(It.IsAny <ApprenticeshipViewModel>()), Times.Once, failMessage: "Should validate apprenticeship");
_mockValidator.Verify(m => m.ValidateAcademicYear(It.IsAny <CreateApprenticeshipUpdateViewModel>()), Times.Once, failMessage: "Should validate academic year");
}
private ApprenticeshipUploadModel MapTo(CsvRecord record, CommitmentView commitment)
{
var dateOfBirth = GetValidDate(record.DateOfBirth, "yyyy-MM-dd");
var learnerStartDate = GetValidDate(record.StartDate, "yyyy-MM");
var learnerEndDate = GetValidDate(record.EndDate, "yyyy-MM");
var courseCode = record.ProgType == "25"
? record.StdCode
: $"{record.FworkCode}-{record.ProgType}-{record.PwayCode}";
var apprenticeshipViewModel = new ApprenticeshipViewModel
{
AgreementStatus = AgreementStatus.NotAgreed,
PaymentStatus = PaymentStatus.Active,
ULN = record.ULN,
FirstName = record.GivenNames,
LastName = record.FamilyName,
DateOfBirth = new DateTimeViewModel(dateOfBirth),
Cost = record.TotalPrice,
ProviderRef = record.ProviderRef,
StartDate = new DateTimeViewModel(learnerStartDate),
EndDate = new DateTimeViewModel(learnerEndDate),
ProgType = record.ProgType.TryParse(),
CourseCode = courseCode,
IsPaidForByTransfer = commitment.IsTransfer()
};
return(new ApprenticeshipUploadModel
{
ApprenticeshipViewModel = apprenticeshipViewModel,
CsvRecord = record
});
}
public async Task <Apprenticeship> MapFrom(ApprenticeshipViewModel viewModel)
{
var apprenticeship = new Apprenticeship
{
CommitmentId = _hashingService.DecodeValue(viewModel.HashedCommitmentId),
Id = string.IsNullOrWhiteSpace(viewModel.HashedApprenticeshipId) ? 0L : _hashingService.DecodeValue(viewModel.HashedApprenticeshipId),
FirstName = viewModel.FirstName,
LastName = viewModel.LastName,
DateOfBirth = viewModel.DateOfBirth.DateTime,
NINumber = viewModel.NINumber,
ULN = viewModel.ULN,
Cost = viewModel.Cost.AsNullableDecimal(),
StartDate = viewModel.StartDate.DateTime,
EndDate = viewModel.EndDate.DateTime,
ProviderRef = viewModel.ProviderRef,
EmployerRef = viewModel.EmployerRef
};
if (!string.IsNullOrWhiteSpace(viewModel.TrainingCode))
{
var training = await GetTrainingProgramme(viewModel.TrainingCode);
apprenticeship.TrainingType = training is Standard ? TrainingType.Standard : TrainingType.Framework;
apprenticeship.TrainingCode = viewModel.TrainingCode;
apprenticeship.TrainingName = training.Title;
}
return(apprenticeship);
}
public async Task ShouldUpdateDate()
{
var a = new Apprenticeship
{
DateOfBirth = new DateTime(1990, 11, 11),
StartDate = new DateTime(2045, 12, 08),
EndDate = new DateTime(2046, 12, 08)
};
var dob = new DateTimeViewModel(8, 12, 1998);
var sd = new DateTimeViewModel(08, 5, 2044);
var ed = new DateTimeViewModel(09, 12, 2047);
var updated = new ApprenticeshipViewModel
{
DateOfBirth = dob,
StartDate = sd,
EndDate = ed
};
var model = await Sut.CompareAndMapToApprenticeshipViewModel(a, updated);
model.DateOfBirth.Should().Be(dob);
model.StartDate.Should().Be(sd);
model.EndDate.Should().Be(ed);
}
public void BaseSetup()
{
CurrentDateTime.Setup(x => x.Now).Returns(new DateTime(2018, 5, 1));
Validator = new ApprenticeshipViewModelValidator(new WebApprenticeshipValidationText(), CurrentDateTime.Object, new AcademicYear(CurrentDateTime.Object));
ValidModel = new ApprenticeshipViewModel {
ULN = "1001234567", FirstName = "TestFirstName", LastName = "TestLastName"
};
}
public async Task ThenEndDateShouldntBeValidatedIfNotSupplied()
{
var apprenticeship = new ApprenticeshipViewModel {
EndDate = new DateTimeViewModel()
};
var result = await _orchestrator.ValidateApprenticeship(apprenticeship);
CollectionAssert.AreEqual(new Dictionary <string, string>(), result);
}
public async Task ThenValidationIsNotPerformedOnAnEmptyUln()
{
//Arrange
var viewModel = new ApprenticeshipViewModel();
//Act
await _validator.ValidateAsync(viewModel);
//Assert
_mediator.Verify(x => x.Send(It.IsAny <GetCommitmentQueryRequest>(), It.IsAny <CancellationToken>()), Times.Never);
}
public async Task ShouldAppendErrorsTogether()
{
var viewModel = new ApprenticeshipViewModel();
var updateModel = new CreateApprenticeshipUpdateViewModel();
_mockMapper
.Setup(m => m.MapApprenticeship(It.IsAny <ApprenticeshipViewModel>()))
.ReturnsAsync(new Apprenticeship {
ReservationId = Guid.NewGuid(), StartDate = DateTime.Today
});
_mockMediator
.Setup(m => m.Send(It.IsAny <GetOverlappingApprenticeshipsQueryRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetOverlappingApprenticeshipsQueryResponse {
Overlaps = new List <ApprenticeshipOverlapValidationResult>()
});
_mockValidator
.Setup(v => v.ValidateToDictionary(viewModel))
.Returns(BuildDictionary("VTD1=error1", "VTD2=error2"));
_mockValidator
.Setup(v => v.ValidateAcademicYear(updateModel))
.Returns(BuildDictionary("VAY1=error3", "VAY2=error4"));
_mockValidator
.Setup(v => v.MapOverlappingErrors(It.IsAny <GetOverlappingApprenticeshipsQueryResponse>()))
.Returns(BuildDictionary("OLE1=error7", "OLE2=error8"));
_mockMediator
.Setup(m => m.Send(It.IsAny <GetReservationValidationRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetReservationValidationResponse
{
Data = new ReservationValidationResult(new[]
{
new ReservationValidationError("RVE1", "error9"),
new ReservationValidationError("RVE2", "error10")
})
});
var errors = await _orchestrator.ValidateEditApprenticeship(viewModel, updateModel);
TickoffError(errors, "VTD1", "error1");
TickoffError(errors, "VTD2", "error2");
TickoffError(errors, "VAY1", "error3");
TickoffError(errors, "VAY2", "error4");
TickoffError(errors, "OLE1", "error7");
TickoffError(errors, "OLE2", "error8");
TickoffError(errors, "RVE1", "error9");
TickoffError(errors, "RVE2", "error10");
Assert.AreEqual(0, errors.Count, "Additional unexpected errors were returned by the validator");
}
public Dictionary <string, string> ValidateAcademicYear(ApprenticeshipViewModel model)
{
var dict = new Dictionary <string, string>();
if (model.StartDate?.DateTime != null &&
_academicYearValidator.Validate(model.StartDate.DateTime.Value) == AcademicYearValidationResult.NotWithinFundingPeriod)
{
dict.Add($"{nameof(model.StartDate)}", ValidationText.AcademicYearStartDate01.Text);
}
return(dict);
}
public async Task ShouldValidateOverlapAndDateChecks()
{
var viewModel = new ApprenticeshipViewModel();
var updateModel = new UpdateApprenticeshipViewModel();
await Orchestrator.ValidateApprenticeship(viewModel, updateModel);
MockMediator.Verify(m => m.SendAsync(It.IsAny <GetOverlappingApprenticeshipsQueryRequest>()), Times.Once, failMessage: "Should call");
_mockValidator.Verify(m => m.MapOverlappingErrors(It.IsAny <GetOverlappingApprenticeshipsQueryResponse>()), Times.Once, failMessage: "Should verify overlapping apprenticeship");
_mockValidator.Verify(m => m.ValidateToDictionary(It.IsAny <ApprenticeshipViewModel>()), Times.Once, failMessage: "Should validate apprenticeship");
_mockValidator.Verify(m => m.ValidateAcademicYear(It.IsAny <UpdateApprenticeshipViewModel>()), Times.Once, failMessage: "Should validate academic year");
}
public async Task ThenEndDateShouldntBeValidatedIfNotSupplied()
{
MockApprenticeshipCoreValidator.Setup(v => v.MapOverlappingErrors(It.IsAny <GetOverlappingApprenticeshipsQueryResponse>()))
.Returns(new Dictionary <string, string>());
var apprenticeship = new ApprenticeshipViewModel {
EndDate = new DateTimeViewModel()
};
var result = await EmployerCommitmentOrchestrator.ValidateApprenticeship(apprenticeship);
CollectionAssert.AreEqual(new Dictionary <string, string>(), result);
}
public async Task ShouldMapHasHadDataLockSuccess(bool expectedHasHadDataLockSuccess, bool hasHadDataLockSuccess)
{
var apprenticeship = new Apprenticeship
{
HasHadDataLockSuccess = hasHadDataLockSuccess
};
var updated = new ApprenticeshipViewModel();
var model = await Sut.CompareAndMapToApprenticeshipViewModel(apprenticeship, updated);
model.HasHadDataLockSuccess.Should().Be(expectedHasHadDataLockSuccess);
}
public async Task <ActionResult> ConfirmChanges(ApprenticeshipViewModel apprenticeship)
{
if (!await IsUserRoleAuthorized(apprenticeship.HashedAccountId, Role.Owner, Role.Transactor))
{
return(View("AccessDenied"));
}
if (!ModelState.IsValid)
{
apprenticeship.AddErrorsFromModelState(ModelState);
}
var model = await _orchestrator.GetConfirmChangesModel(
apprenticeship.HashedAccountId,
apprenticeship.HashedApprenticeshipId,
OwinWrapper.GetClaimValue(@"sub"),
apprenticeship);
var validatorResult = await _orchestrator.ValidateApprenticeship(apprenticeship, model.Data);
if (validatorResult.Any())
{
apprenticeship.AddErrorsFromDictionary(validatorResult);
}
if (apprenticeship.ErrorDictionary.Any())
{
var viewModel = await _orchestrator.GetApprenticeshipForEdit(apprenticeship.HashedAccountId, apprenticeship.HashedApprenticeshipId, OwinWrapper.GetClaimValue(@"sub"));
viewModel.Data.Apprenticeship = apprenticeship;
SetErrorMessage(viewModel, viewModel.Data.Apprenticeship.ErrorDictionary);
return(View("Edit", viewModel));
}
if (!AnyChanges(model.Data))
{
var viewModel = await _orchestrator.GetApprenticeshipForEdit(apprenticeship.HashedAccountId, apprenticeship.HashedApprenticeshipId, OwinWrapper.GetClaimValue(@"sub"));
viewModel.Data.Apprenticeship = apprenticeship;
viewModel.Data.Apprenticeship.ErrorDictionary.Add("NoChangesRequested", "No changes made");
SetErrorMessage(viewModel, viewModel.Data.Apprenticeship.ErrorDictionary);
return(View("Edit", viewModel));
}
_orchestrator.CreateApprenticeshipViewModelCookie(model.Data);
return(RedirectToAction("ConfirmChanges"));
}
public async Task <UpdateApprenticeshipViewModel> CompareAndMapToApprenticeshipViewModel(
Apprenticeship original, ApprenticeshipViewModel edited)
{
string ChangedOrNull(string a, string edit) => a?.Trim() == edit?.Trim() ? null : edit;
var apprenticeshipDetailsViewModel = MapToApprenticeshipDetailsViewModel(original);
var model = new UpdateApprenticeshipViewModel
{
FirstName = ChangedOrNull(original.FirstName, edited.FirstName),
LastName = ChangedOrNull(original.LastName, edited.LastName),
DateOfBirth = original.DateOfBirth == edited.DateOfBirth.DateTime
? null
: edited.DateOfBirth,
Cost = original.Cost == edited.Cost.AsNullableDecimal() ? null : edited.Cost,
StartDate = original.StartDate == edited.StartDate.DateTime
? null
: edited.StartDate,
EndDate = original.EndDate == edited.EndDate.DateTime
? null
: edited.EndDate,
EmployerRef = original.EmployerRef?.Trim() == edited.EmployerRef?.Trim() ||
(string.IsNullOrEmpty(original.EmployerRef) && string.IsNullOrEmpty(edited.EmployerRef))
? null
: edited.EmployerRef ?? "",
OriginalApprenticeship = apprenticeshipDetailsViewModel
};
if (!string.IsNullOrWhiteSpace(edited.TrainingCode) && original.TrainingCode != edited.TrainingCode)
{
var training = await GetTrainingProgramme(edited.TrainingCode);
if (training != null)
{
model.TrainingType = int.TryParse(training.CourseCode, out _) ? TrainingType.Standard : TrainingType.Framework;
model.TrainingCode = edited.TrainingCode;
model.TrainingName = training.Name;
}
else
{
model.TrainingType = edited.TrainingType;
model.TrainingCode = edited.TrainingCode;
model.TrainingName = edited.TrainingName;
_logger.Warn($"Apprentice training course has expired. TrainingName: {edited.TrainingName}, TrainingCode: {edited.TrainingCode}, Employer Ref: {edited.EmployerRef}, Apprenticeship ULN: {edited.ULN}");
}
}
model.HasHadDataLockSuccess = original.HasHadDataLockSuccess;
return(model);
}
