public void BaseSetup()
{
MockCurrentDateTime = new Mock <ICurrentDateTime>();
MockUlnValidator = new Mock <IUlnValidator>();
MockAcademicYear = new Mock <IAcademicYearDateProvider>();
MockAcademicYearValidator = new Mock <IAcademicYearValidator>();
MockAcademicYearDateProvider = new Moq.Mock <IAcademicYearDateProvider>();
MockAcademicYearDateProvider.Setup(m => m.CurrentAcademicYearEndDate).Returns(new DateTime(2030, 12, 1));
Validator = new ApprenticeshipUploadModelValidator(new BulkUploadApprenticeshipValidationText(MockAcademicYear.Object), MockCurrentDateTime.Object, MockUlnValidator.Object, MockAcademicYearDateProvider.Object);
ValidModel = new ApprenticeshipUploadModel
{
ApprenticeshipViewModel = new ApprenticeshipViewModel
{
ULN = "1001234567",
FirstName = "TestFirstName",
LastName = "TestLastName",
CourseCode = "12",
DateOfBirth = new DateTimeViewModel(DateTime.UtcNow.AddYears(-39)),
StartDate = new DateTimeViewModel(new DateTime(2017, 06, 20)),
EndDate = new DateTimeViewModel(new DateTime(2018, 05, 15)),
Cost = "1234"
},
CsvRecord = new CsvRecord {
CohortRef = "abba123", ProgType = "25", StdCode = "123"
}
};
}
private ValidationFailure ValidateFworkCode(ApprenticeshipUploadModel model)
{
if (!string.IsNullOrWhiteSpace(model.CsvRecord.FworkCode) && (model.CsvRecord.FworkCode.TryParse() ?? 1000) > 999)
{
return(CreateValidationFailure("FworkCode", _validationText.FworkCode01));
}
if (!string.IsNullOrWhiteSpace(model.CsvRecord.ProgType) && InList(model.CsvRecord.ProgType, new[] { "2", "3", "20", "21", "22", "23" }) && (model.CsvRecord.FworkCode.TryParse() ?? 0) <= 0)
{
return(CreateValidationFailure("FworkCode", _validationText.FworkCode02));
}
if (model.CsvRecord.ProgType == "25" && !string.IsNullOrWhiteSpace(model.CsvRecord.FworkCode) && model.CsvRecord.FworkCode != "0")
{
return(CreateValidationFailure("FworkCode", _validationText.FworkCode03));
}
if (!string.IsNullOrWhiteSpace(model.CsvRecord.FworkCode) &&
model.ApprenticeshipViewModel.IsPaidForByTransfer)
{
return(CreateValidationFailure("FworkCode", _validationText.FworkCode04));
}
return(null);
}
public void Setup()
{
var now = DateTime.UtcNow;
_validModel = new ApprenticeshipUploadModel
{
ApprenticeshipViewModel = new ApprenticeshipViewModel
{
ULN = "1001234567",
FirstName = "TestFirstName",
LastName = "TestLastName",
CourseCode = "12",
DateOfBirth = new DateTimeViewModel(now.AddYears(-16)),
StartDate = new DateTimeViewModel(now),
EndDate = new DateTimeViewModel(now.AddYears(3)),
Cost = "1234"
},
CsvRecord = new CsvRecord {
CohortRef = "abba123"
}
};
_mockAcademicYear = new Moq.Mock <IAcademicYearDateProvider>();
_mockUlnValidator = new Moq.Mock <IUlnValidator>();
_mockUlnValidator.Setup(m => m.Validate(_validModel.ApprenticeshipViewModel.ULN)).Returns(UlnValidationResult.Success);
_mockAcademicYear.Setup(m => m.CurrentAcademicYearEndDate).Returns(new DateTime(2030, 12, 1));
_validator = new ApprenticeshipUploadModelValidator(new BulkUploadApprenticeshipValidationText(_mockAcademicYear.Object), new CurrentDateTime(), _mockUlnValidator.Object, _mockAcademicYear.Object);
}
private ValidationFailure ValidateDateOfBirth(ApprenticeshipUploadModel model)
{
if (model.ApprenticeshipViewModel.DateOfBirth == null)
{
return(CreateValidationFailure("DateOfBirth", _validationText.DateOfBirth01));
}
if (model.ApprenticeshipViewModel.DateOfBirth.DateTime == null || !model.ApprenticeshipViewModel.DateOfBirth.Day.HasValue)
{
return(CreateValidationFailure("DateOfBirth", _validationText.DateOfBirth01));
}
if (!ApprenticeDobMustBeGreaterThenMinimumDob(model.ApprenticeshipViewModel.DateOfBirth))
{
return(CreateValidationFailure("DateOfBirth", _validationText.DateOfBirth07));
}
if (!WillApprenticeBeAtLeast15AtStartOfTraining(model.ApprenticeshipViewModel, model.ApprenticeshipViewModel.DateOfBirth))
{
return(CreateValidationFailure("DateOfBirth", _validationText.DateOfBirth02));
}
if (!ApprenticeAgeMustBeLessThen115AtStartOfTraining(model.ApprenticeshipViewModel, model.ApprenticeshipViewModel.DateOfBirth))
{
return(CreateValidationFailure("DateOfBirth", _validationText.DateOfBirth06));
}
return(null);
}
private ValidationFailure ValidateProviderRef(ApprenticeshipUploadModel model)
{
if (!string.IsNullOrWhiteSpace(model.ApprenticeshipViewModel.ProviderRef) && model.ApprenticeshipViewModel.ProviderRef.Length > 20)
{
return(CreateValidationFailure("ProviderRef", _validationText.ProviderRef01));
}
return(null);
}
public UploadError(string message, string errorCode, int?index = null, ApprenticeshipUploadModel record = null)
{
Message = message;
ErrorCode = errorCode;
Row = index;
IsGeneralError = index == null || record == null;
Uln = record?.ApprenticeshipViewModel?.ULN;
FirstName = record?.ApprenticeshipViewModel?.FirstName;
LastName = record?.ApprenticeshipViewModel?.LastName;
DateOfBirth = record?.ApprenticeshipViewModel?.DateOfBirth;
}
private ValidationFailure ValidateLastName(ApprenticeshipUploadModel model)
{
if (string.IsNullOrWhiteSpace(model.ApprenticeshipViewModel.LastName))
{
return(CreateValidationFailure("LastName", _validationText.FamilyName01));
}
if (model.ApprenticeshipViewModel.LastName.Length > 100)
{
return(CreateValidationFailure("LastName", _validationText.FamilyName02));
}
return(null);
}
private ValidationFailure ValidateFirstName(ApprenticeshipUploadModel model)
{
if (string.IsNullOrWhiteSpace(model.ApprenticeshipViewModel.FirstName))
{
return(CreateValidationFailure("FirstName", _validationText.GivenNames01));
}
if (model.ApprenticeshipViewModel.FirstName.Length > 100)
{
return(CreateValidationFailure("FirstName", _validationText.GivenNames02));
}
return(null);
}
private ValidationFailure ValidateProgType(ApprenticeshipUploadModel model)
{
if ((model.CsvRecord.ProgType.TryParse() ?? 100) > 99)
{
return(CreateValidationFailure("ProgType", _validationText.ProgType01));
}
if (!InList(model.CsvRecord.ProgType, new[] { "2", "3", "20", "21", "22", "23", "25" }))
{
return(CreateValidationFailure("ProgType", _validationText.ProgType02));
}
return(null);
}
private ValidationFailure ValidateULN(ApprenticeshipUploadModel model)
{
var result = _ulnValidator.Validate(model.ApprenticeshipViewModel.ULN);
switch (result)
{
case UlnValidationResult.IsEmptyUlnNumber:
case UlnValidationResult.IsInValidTenDigitUlnNumber:
return(CreateValidationFailure("ULN", _validationText.Uln01));
case UlnValidationResult.IsInvalidUln:
return(CreateValidationFailure("ULN", _validationText.Uln03));
}
return(null);
}
public ValidationResult Validate(ApprenticeshipUploadModel model)
{
var validationResult = new ValidationResult();
ValidateField(validationResult, ValidateFirstName, model);
ValidateField(validationResult, ValidateLastName, model);
ValidateField(validationResult, ValidateULN, model);
ValidateField(validationResult, ValidateDateOfBirth, model);
ValidateField(validationResult, ValidateStartDate, model);
ValidateField(validationResult, ValidateEndDate, model);
ValidateField(validationResult, ValidateCost, model);
ValidateField(validationResult, ValidateProviderRef, model);
ValidateField(validationResult, ValidateProgType, model);
ValidateField(validationResult, ValidateFworkCode, model);
ValidateField(validationResult, ValidatePwayCode, model);
ValidateField(validationResult, ValidateStdCode, model);
return(validationResult);
}
private ValidationFailure ValidateStdCode(ApprenticeshipUploadModel model)
{
if (!string.IsNullOrWhiteSpace(model.CsvRecord.StdCode) && (model.CsvRecord.StdCode.TryParse() ?? 100000) > 99999)
{
return(CreateValidationFailure("StdCode", _validationText.StdCode01));
}
if (model.CsvRecord.ProgType == "25" && (model.CsvRecord.StdCode.TryParse() ?? 0) <= 0)
{
return(CreateValidationFailure("StdCode", _validationText.StdCode02));
}
if (FrameworkProgTypeSelected(model.CsvRecord) && !string.IsNullOrWhiteSpace(model.CsvRecord.StdCode) && model.CsvRecord.StdCode != "0")
{
return(CreateValidationFailure("StdCode", _validationText.StdCode03));
}
return(null);
}
private ValidationFailure ValidateCost(ApprenticeshipUploadModel model)
{
if (string.IsNullOrWhiteSpace(model.ApprenticeshipViewModel.Cost))
{
return(CreateValidationFailure("Cost", _validationText.TrainingPrice01));
}
if (!Regex.Match(model.ApprenticeshipViewModel.Cost, "^([1-9]{1}([0-9]{1,2})?)+(,[0-9]{3})*$|^[1-9]{1}[0-9]*$").Success)
{
return(CreateValidationFailure("Cost", _validationText.TrainingPrice01));
}
if (!decimal.TryParse(model.ApprenticeshipViewModel.Cost, out var parsed) || parsed > 100000)
{
return(CreateValidationFailure("Cost", _validationText.TrainingPrice02));
}
return(null);
}
private ValidationFailure ValidateEndDate(ApprenticeshipUploadModel model)
{
if (model.ApprenticeshipViewModel.EndDate == null)
{
return(CreateValidationFailure("EndDate", _validationText.LearnPlanEndDate01));
}
if (model.ApprenticeshipViewModel.EndDate.DateTime == null)
{
return(CreateValidationFailure("EndDate", _validationText.LearnPlanEndDate01));
}
if (model.ApprenticeshipViewModel.StartDate != null && model.ApprenticeshipViewModel.EndDate.DateTime <= model.ApprenticeshipViewModel.StartDate.DateTime)
{
return(CreateValidationFailure("EndDate", _validationText.LearnPlanEndDate02));
}
return(null);
}
private ValidationFailure ValidateStartDate(ApprenticeshipUploadModel model)
{
if (model.ApprenticeshipViewModel.StartDate == null)
{
// we pass the field that failed, but that ultimatly gets discarded anyway, so why bother? we could just work with validationmessages
return(CreateValidationFailure("StartDate", _validationText.LearnStartDate01));
}
if (model.ApprenticeshipViewModel.StartDate.DateTime == null)
{
return(CreateValidationFailure("StartDate", _validationText.LearnStartDate01));
}
var apprenticeshipAllowedStartDate = new DateTime(2017, 05, 01);
if (model.ApprenticeshipViewModel.StartDate.DateTime < apprenticeshipAllowedStartDate &&
!model.ApprenticeshipViewModel.IsPaidForByTransfer)
{
return(CreateValidationFailure("StartDate", _validationText.LearnStartDate02));
}
var transfersAllowedStartDate = new DateTime(2018, 05, 01);
if (model.ApprenticeshipViewModel.StartDate.DateTime < transfersAllowedStartDate &&
model.ApprenticeshipViewModel.IsPaidForByTransfer)
{
return(CreateValidationFailure("StartDate", _validationText.LearnStartDate06));
}
if (model.ApprenticeshipViewModel.StartDate.DateTime > _academicYearDateProvider.CurrentAcademicYearEndDate.AddYears(1))
{
return(CreateValidationFailure("StartDate", _validationText.LearnStartDate05));
}
// we could check the start date against the training programme here, but we'd have to pass the trainingprogrammes through the call stack, or refetch them, or make them available another way e.g. static.
// none of these choices are appealing, so we'll wait until bulk upload is refactored
return(null);
}
private IEnumerable <UploadError> GetOverlappingErrors(OverlappingApprenticeship overlappingResult, int i, ApprenticeshipUploadModel record)
{
const string textStartDate = "The <strong>start date</strong> overlaps with existing training dates for the same apprentice";
const string textEndDate = "The <strong>finish date</strong> overlaps with existing training dates for the same apprentice";
switch (overlappingResult.ValidationFailReason)
{
case ValidationFailReason.OverlappingStartDate:
return(new List <UploadError> {
new UploadError(textStartDate, "OverlappingError", i, record)
});
case ValidationFailReason.OverlappingEndDate:
return(new List <UploadError> {
new UploadError(textEndDate, "OverlappingError", i, record)
});
case ValidationFailReason.DateEmbrace:
case ValidationFailReason.DateWithin:
return(new List <UploadError>
{
new UploadError(textStartDate, "OverlappingError", i, record),
new UploadError(textEndDate, "OverlappingError", i, record)
});
}
return(Enumerable.Empty <UploadError>());
}
private void ValidateField(ValidationResult validationResult, Func <ApprenticeshipUploadModel, ValidationFailure> validationFunc, ApprenticeshipUploadModel model)
{
var validationFailure = validationFunc(model);
if (validationFailure != null)
{
validationResult.Errors.Add(validationFailure);
}
}
