public async Task And_Has_ErrorCode_DLock07_And_TriageStatus_Unknown_Then_ILR_Data_mismatch_Alert(
Apprenticeship source,
DataLockStatus dataLockStatus,
PriceHistory priceHistory,
ApprenticeshipToApprenticeshipDetailsMapper mapper)
{
source.PriceHistory = new List <PriceHistory> {
priceHistory
};
source.IsProviderSearch = true;
dataLockStatus.ErrorCode = DataLockErrorCode.Dlock07;
dataLockStatus.TriageStatus = TriageStatus.Unknown;
dataLockStatus.IsResolved = false;
source.PriceHistory = new List <PriceHistory> {
priceHistory
};
source.DataLockStatus = new List <DataLockStatus> {
dataLockStatus
};
source.ApprenticeshipUpdate = new List <ApprenticeshipUpdate>();
var result = await mapper.Map(source);
result.Alerts.Should().BeEquivalentTo(new List <Alerts> {
Alerts.IlrDataMismatch
});
}
public async Task ShouldNotUpdateApprenticeshipIfApprenticeshipHasHadSuccessDataLock()
{
var isDataLockWithCourse = new DataLockStatus {
DataLockEventId = 1, ApprenticeshipId = _command.ApprenticeshipId, IsResolved = false, Status = Status.Fail, IlrTotalCost = 505,
ErrorCode = DataLockErrorCode.Dlock07 | DataLockErrorCode.Dlock03, IlrEffectiveFromDate = DateTime.Now, TriageStatus = TriageStatus.Change
};
var toBeUpdateDataLock = new DataLockStatus {
DataLockEventId = 3, ApprenticeshipId = _command.ApprenticeshipId, IsResolved = false, Status = Status.Fail, IlrTotalCost = 400,
ErrorCode = DataLockErrorCode.Dlock07, IlrEffectiveFromDate = DateTime.Now.AddMonths(1), TriageStatus = TriageStatus.Change
};
_dataLockRepository.Setup(m => m.GetDataLocks(_command.ApprenticeshipId, false))
.ReturnsAsync(new List <DataLockStatus> {
isDataLockWithCourse, toBeUpdateDataLock
});
_apprenticeshipRepository.Setup(m => m.GetApprenticeship(_command.ApprenticeshipId))
.ReturnsAsync(new Apprenticeship {
CommitmentId = 123456L, HasHadDataLockSuccess = true
});
await _sut.Handle(_command);
_dataLockRepository.Verify(m => m.ResolveDataLock(It.IsAny <IEnumerable <long> >()), Times.Once);
_apprenticeshipTrainingService.Verify(m => m.GetTrainingProgramAsync(It.IsAny <string>(), false), Times.Never);
_apprenticeshipRepository.Verify(m => m.UpdateApprenticeship(It.IsAny <Apprenticeship>(), new Caller()), Times.Never);
}
public static bool PreviousResolvedPriceDataLocks(this DataLockStatus dataLockStatus)
{
return(dataLockStatus.ErrorCode == DataLockErrorCode.Dlock07 &&
dataLockStatus.Status == Status.Fail &&
dataLockStatus.TriageStatus == TriageStatus.Change &&
dataLockStatus.IsResolved);
}
public static DateTime GetDateFromPriceEpisodeIdentifier(this DataLockStatus dataLockStatus)
{
return(DateTime.ParseExact(
dataLockStatus.PriceEpisodeIdentifier.Substring(dataLockStatus.PriceEpisodeIdentifier.Length - 10),
"dd/MM/yyyy",
new CultureInfo("en-GB")));
}
private void AssertDataLockBelongsToApprenticeship(long apprenticeshipId, DataLockStatus dataLockStatus)
{
if (apprenticeshipId != dataLockStatus.ApprenticeshipId)
{
throw new ValidationException($"Data lock {dataLockStatus.DataLockEventId} does not belong to Apprenticeship {apprenticeshipId}");
}
}
private void ApplyErrorCodeWhiteList(DataLockStatus dataLockStatus)
{
var whitelisted = DataLockErrorCode.None;
var skipped = DataLockErrorCode.None;
foreach (DataLockErrorCode errorCode in Enum.GetValues(typeof(DataLockErrorCode)))
{
if (dataLockStatus.ErrorCode.HasFlag(errorCode))
{
if (_whiteList.Contains(errorCode))
{
whitelisted = whitelisted == DataLockErrorCode.None ? errorCode : whitelisted | errorCode;
}
else
{
skipped = skipped == DataLockErrorCode.None ? errorCode : skipped | errorCode;
}
}
}
if (skipped != DataLockErrorCode.None)
{
_logger.Info($"Skipping {skipped}");
}
dataLockStatus.ErrorCode = whitelisted;
}
public async Task And_Provider_Has_Unresolved_Errors_That_Have_Known_Triage_Status(
Apprenticeship source,
DataLockStatus dataLockStatus,
PriceHistory priceHistory,
ApprenticeshipToApprenticeshipDetailsMapper mapper)
{
//Arrange
dataLockStatus.Status = Status.Fail;
dataLockStatus.TriageStatus = TriageStatus.Restart;
dataLockStatus.IsResolved = false;
source.IsProviderSearch = true;
source.PriceHistory = new List <PriceHistory> {
priceHistory
};
source.DataLockStatus = new List <DataLockStatus> {
dataLockStatus
};
source.ApprenticeshipUpdate = new List <ApprenticeshipUpdate>();
//Act
var result = await mapper.Map(source);
//Assert
result.Alerts.Should().BeNullOrEmpty();
}
public async Task And_Employer_Has_Unresolved_Errors_That_Have_Known_Triage_Status_And_Has_Course_DataLock_Changes_Requested_Only_One_Changes_Requested_Added(
Apprenticeship source,
DataLockStatus dataLockStatus,
DataLockStatus dataLockStatus2,
PriceHistory priceHistory,
ApprenticeshipToApprenticeshipDetailsMapper mapper)
{
//Arrange
dataLockStatus.Status = Status.Fail;
dataLockStatus.TriageStatus = TriageStatus.Restart;
dataLockStatus.IsResolved = false;
dataLockStatus2.ErrorCode = DataLockErrorCode.Dlock03;
dataLockStatus2.TriageStatus = TriageStatus.Restart;
dataLockStatus2.IsResolved = false;
source.IsProviderSearch = false;
source.DataLockStatus = new List <DataLockStatus> {
dataLockStatus, dataLockStatus2
};
source.PriceHistory = new List <PriceHistory> {
priceHistory
};
source.ApprenticeshipUpdate = new List <ApprenticeshipUpdate>();
//Act
var result = await mapper.Map(source);
//Assert
result.Alerts.Should().NotBeNullOrEmpty();
result.Alerts.Should().BeEquivalentTo(new List <Alerts> {
Alerts.ChangesRequested
});
}
public static bool WithCourseError(this DataLockStatus dataLockStatus)
{
return(dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock03) ||
dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock04) ||
dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock05) ||
dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock06));
}
public void ThenTheDateIsParsedCorrectly(string priceEpisodeIdentifer, DateTime expectedDate)
{
var datalock = new DataLockStatus
{
PriceEpisodeIdentifier = priceEpisodeIdentifer
};
Assert.AreEqual(expectedDate, datalock.GetDateFromPriceEpisodeIdentifier());
}
private async Task AssertNoPendingApprenticeshipUpdate(DataLockStatus dataLockStatus, long apprenticeshipId)
{
var pending = await _apprenticeshipUpdateRepository.GetPendingApprenticeshipUpdate(apprenticeshipId);
if (pending != null)
{
throw new ValidationException($"Data lock {dataLockStatus.DataLockEventId} with error code {dataLockStatus.ErrorCode} cannot be triaged due to apprenticeship {apprenticeshipId} having pending update");
}
}
public static bool WithCourseAndPriceError(this DataLockStatus dataLockStatus)
{
var hasCourse = dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock03) ||
dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock04) ||
dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock05) ||
dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock06);
return(hasCourse && dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock07));
}
/// <summary>
/// Generates a set of datalocks for the input apprenticeships
/// </summary>
/// <param name="rows"></param>
private static DataLockCollection CreateDataLockCollection(List <DataRow> rows)
{
var result = new DataLockCollection
{
PageNumber = 1,
TotalNumberOfPages = 1
};
foreach (var row in rows)
{
var datalock = new DataLockStatus();
var course = row.ProgType == "25" ?
row.StdCode :
$"{row.FworkCode}-{row.ProgType}-{row.PwayCode}";
var pei = $"{course}-{row.StartDate.ToString("d")}"; //todo: also simulate 01/08/2018
datalock.Id = DataHelper.GetNextDataLockEventId();
datalock.ProcessDateTime = DateTime.UtcNow;
datalock.IlrFileName = "ilr-submission.xml";
datalock.Ukprn = 10000534;
datalock.Uln = Int64.Parse(row.ULN);
datalock.Status = "New"; //todo: simulate multiple events of diff. statuses
datalock.LearnRefNumber = "1";
datalock.AimSeqNumber = 1;
datalock.PriceEpisodeIdentifier = pei;
datalock.ApprenticeshipId = row.Id;
datalock.EventSource = "Submission";
datalock.IlrStartDate = row.StartDate; //todo: provide variance with below
datalock.IlrProgrammeType = Int32.Parse(row.ProgType);
datalock.IlrStandardCode = row.StdCode == null ? default(int?) : Int32.Parse(row.StdCode);
datalock.IlrFrameworkCode = row.FworkCode == null ? default(int?) : Int32.Parse(row.FworkCode);
datalock.IlrPathwayCode = row.PwayCode == null ? default(int?) : Int32.Parse(row.PwayCode);
datalock.IlrTrainingPrice = row.TotalPrice * 2;
datalock.IlrEndpointAssessorPrice = 0;
datalock.IlrPriceEffectiveDate = row.StartDate;
datalock.IlrPriceEffectiveFromDate = row.StartDate;
datalock.Errors.Add(new DataLockError
{
ErrorCode = "DLOCK_07",
SystemDescription = "Price datalock"
});
result.Items.Add(datalock);
}
//if programme type == 25, then include a std code, otherwise framework + prog type + pathway
// new TrainingCourse { FworkCode = "583", ProgType = "3", PwayCode = "4"},
return(result);
}
public async Task ShouldUpdateApprenticeshipIfCourseHasChanged()
{
var trainingCode = 10123;
var standard = new Standard {
Title = "Standard 1", Code = trainingCode, CourseName = "Standard 1 Course Name", Level = 1
};
var isDataLockWithCourse = new DataLockStatus {
DataLockEventId = 1, ApprenticeshipId = _command.ApprenticeshipId, IsResolved = false, Status = Status.Fail, IlrTotalCost = 505,
ErrorCode = DataLockErrorCode.Dlock07 | DataLockErrorCode.Dlock03, IlrEffectiveFromDate = DateTime.Now, TriageStatus = TriageStatus.Change, IlrTrainingCourseCode = $"{trainingCode}"
};
var toBeUpdateDataLock = new DataLockStatus {
DataLockEventId = 3, ApprenticeshipId = _command.ApprenticeshipId, IsResolved = false, Status = Status.Fail, IlrTotalCost = 400,
ErrorCode = DataLockErrorCode.Dlock07, IlrEffectiveFromDate = DateTime.Now.AddMonths(1), TriageStatus = TriageStatus.Change
};
_dataLockRepository.Setup(m => m.GetDataLocks(_command.ApprenticeshipId, false))
.ReturnsAsync(new List <DataLockStatus> {
isDataLockWithCourse, toBeUpdateDataLock
});
_apprenticeshipRepository.Setup(m => m.GetApprenticeship(_command.ApprenticeshipId))
.ReturnsAsync(new Apprenticeship {
CommitmentId = 123456L, HasHadDataLockSuccess = false, EmployerAccountId = 12345
});
_apprenticeshipTrainingService.Setup(m => m.GetTrainingProgramAsync($"{trainingCode}", false))
.ReturnsAsync(standard);
Apprenticeship updatedApprenticeship = null;
_apprenticeshipRepository.Setup(
m => m.UpdateApprenticeship(It.IsAny <Apprenticeship>(), It.IsAny <Caller>()))
.Callback <Apprenticeship, Caller>((a, c) => updatedApprenticeship = a)
.Returns(Task.FromResult(0));
await _sut.Handle(_command);
_dataLockRepository.Verify(m => m.ResolveDataLock(It.IsAny <IEnumerable <long> >()), Times.Once);
_apprenticeshipTrainingService.Verify(m => m.GetTrainingProgramAsync(standard.Code.ToString(), false), Times.Once);
_apprenticeshipRepository.Verify(m => m.UpdateApprenticeship(It.IsAny <Apprenticeship>(), It.IsAny <Caller>()), Times.Once);
updatedApprenticeship.TrainingCode.Should().Be(standard.Code.ToString());
updatedApprenticeship.TrainingName.Should().Be(standard.Title);
updatedApprenticeship.TrainingType.Should().Be(TrainingType.Standard);
}
public async Task ThenTheResultShouldBeMapped()
{
//Arrange
var dataLockStatus = new DataLockStatus
{
DataLockEventId = 1L,
DataLockEventDatetime = new DateTime(2018, 3, 1),
PriceEpisodeIdentifier = "PRICE_EPISODE_ID",
ApprenticeshipId = 999L,
IlrTrainingCourseCode = "TRAINING_COURSE_CODE",
IlrTrainingType = TrainingType.Framework,
IlrActualStartDate = new DateTime(2018, 1, 1),
IlrEffectiveFromDate = new DateTime(2018, 12, 31),
IlrTotalCost = decimal.One,
Status = Status.Fail,
TriageStatus = TriageStatus.Change,
ErrorCode = DataLockErrorCode.Dlock01
};
_dataLockRepository.Setup(x => x.GetDataLocks(It.IsAny <long>(), It.IsAny <bool>()))
.ReturnsAsync(new List <DataLockStatus>
{
dataLockStatus
});
var request = new GetDataLocksRequest();
//Act
var result = await _handler.Handle(request);
//Assert
Assert.AreEqual(1, result.Data.Count);
var dataLockResult = result.Data[0];
Assert.AreEqual(dataLockStatus.DataLockEventId, dataLockResult.DataLockEventId);
Assert.AreEqual(dataLockStatus.DataLockEventDatetime, dataLockResult.DataLockEventDatetime);
Assert.AreEqual(dataLockStatus.PriceEpisodeIdentifier, dataLockResult.PriceEpisodeIdentifier);
Assert.AreEqual(dataLockStatus.ApprenticeshipId, dataLockResult.ApprenticeshipId);
Assert.AreEqual(dataLockStatus.IlrTrainingCourseCode, dataLockResult.IlrTrainingCourseCode);
Assert.AreEqual(dataLockStatus.IlrTrainingType, (TrainingType)dataLockResult.IlrTrainingType);
Assert.AreEqual(dataLockStatus.IlrActualStartDate, dataLockResult.IlrActualStartDate);
Assert.AreEqual(dataLockStatus.IlrEffectiveFromDate, dataLockResult.IlrEffectiveFromDate);
Assert.AreEqual(dataLockStatus.IlrTotalCost, dataLockResult.IlrTotalCost);
Assert.AreEqual(dataLockStatus.Status, (Status)dataLockResult.Status);
Assert.AreEqual(dataLockStatus.TriageStatus, (TriageStatus)dataLockResult.TriageStatus);
Assert.AreEqual(dataLockStatus.ErrorCode, (DataLockErrorCode)dataLockResult.ErrorCode);
}
private static void AssertEquality(DataLockStatus source, GetDataLocksQueryResult.DataLock result)
{
Assert.AreEqual(source.Id, result.Id);
Assert.AreEqual(source.DataLockEventDatetime, result.DataLockEventDatetime);
Assert.AreEqual(source.PriceEpisodeIdentifier, result.PriceEpisodeIdentifier);
Assert.AreEqual(source.ApprenticeshipId, result.ApprenticeshipId);
Assert.AreEqual(source.IlrTrainingCourseCode, result.IlrTrainingCourseCode);
Assert.AreEqual(source.IlrActualStartDate, result.IlrActualStartDate);
Assert.AreEqual(source.IlrEffectiveFromDate, result.IlrEffectiveFromDate);
Assert.AreEqual(source.IlrPriceEffectiveToDate, result.IlrPriceEffectiveToDate);
Assert.AreEqual(source.IlrTotalCost, result.IlrTotalCost);
Assert.AreEqual(source.ErrorCode, result.ErrorCode);
Assert.AreEqual(source.Status, result.DataLockStatus);
Assert.AreEqual(source.TriageStatus, result.TriageStatus);
Assert.AreEqual(source.IsResolved, result.IsResolved);
}
private DataLockViewModel MapDataLockStatus(DataLockStatus dataLock, TrainingProgramme training)
{
return(new DataLockViewModel
{
DataLockEventId = dataLock.DataLockEventId,
DataLockEventDatetime = dataLock.DataLockEventDatetime,
PriceEpisodeIdentifier = dataLock.PriceEpisodeIdentifier,
ApprenticeshipId = dataLock.ApprenticeshipId,
IlrTrainingCourseCode = dataLock.IlrTrainingCourseCode,
IlrTrainingType = (TrainingType)dataLock.IlrTrainingType,
IlrTrainingCourseName = training.Name,
IlrActualStartDate = dataLock.IlrActualStartDate,
IlrEffectiveFromDate = dataLock.IlrEffectiveFromDate,
IlrEffectiveToDate = dataLock.IlrEffectiveToDate,
IlrTotalCost = dataLock.IlrTotalCost,
TriageStatusViewModel = (TriageStatusViewModel)dataLock.TriageStatus,
DataLockErrorCode = dataLock.ErrorCode
});
}
public async Task And_Has_PendingUpdateOriginator_Null_Then_No_Alert(
Apprenticeship source,
DataLockStatus dataLockStatus,
PriceHistory priceHistory,
ApprenticeshipToApprenticeshipDetailsMapper mapper)
{
source.ApprenticeshipUpdate = new List <ApprenticeshipUpdate>();
source.ApprenticeshipUpdate = null;
source.DataLockStatus = new List <DataLockStatus> {
dataLockStatus
};
source.PriceHistory = new List <PriceHistory> {
priceHistory
};
var result = await mapper.Map(source);
result.Alerts.Should().BeEmpty();
}
public async Task ShouldExcludeSomeDataLocksWhenUpdatingPriceHistory()
{
var isResolvedDataLock = new DataLockStatus {
DataLockEventId = 1, ApprenticeshipId = _command.ApprenticeshipId, IsResolved = true, Status = Status.Fail, IlrTotalCost = 505,
ErrorCode = DataLockErrorCode.Dlock07, IlrEffectiveFromDate = DateTime.Now, TriageStatus = TriageStatus.Change
};
var isPassedDataLock = new DataLockStatus {
DataLockEventId = 2, ApprenticeshipId = _command.ApprenticeshipId, IsResolved = false, Status = Status.Pass, IlrTotalCost = 499,
ErrorCode = DataLockErrorCode.Dlock07, IlrEffectiveFromDate = DateTime.Now
};
var toBeUpdateDataLock = new DataLockStatus {
DataLockEventId = 3, ApprenticeshipId = _command.ApprenticeshipId, IsResolved = false, Status = Status.Fail, IlrTotalCost = 400,
ErrorCode = DataLockErrorCode.Dlock07, IlrEffectiveFromDate = DateTime.Now.AddMonths(1), TriageStatus = TriageStatus.Change
};
_dataLockRepository.Setup(m => m.GetDataLocks(_command.ApprenticeshipId, false))
.ReturnsAsync(new List <DataLockStatus> {
isResolvedDataLock, isPassedDataLock, toBeUpdateDataLock
});
long[] idsToBeUpdated = null;
_dataLockRepository.Setup(m => m.ResolveDataLock(It.IsAny <IEnumerable <long> >())).Callback <IEnumerable <long> >((ids) => { idsToBeUpdated = ids.ToArray(); })
.ReturnsAsync(0);
IEnumerable <PriceHistory> prices = null;
_apprenticeshipRepository.Setup(
m => m.InsertPriceHistory(_command.ApprenticeshipId, It.IsAny <IEnumerable <PriceHistory> >()))
.Callback <long, IEnumerable <PriceHistory> >((i, l) => prices = l)
.Returns(Task.FromResult(1L));
await _sut.Handle(_command);
_apprenticeshipRepository.Verify(m => m.InsertPriceHistory(_command.ApprenticeshipId, It.IsAny <IEnumerable <PriceHistory> >()), Times.Once);
prices.Count().ShouldBeEquivalentTo(3);
_dataLockRepository.Verify(m => m.ResolveDataLock(
It.Is <IEnumerable <long> >(d => d.Contains(toBeUpdateDataLock.DataLockEventId) && d.Count() == 1)), Times.Once);
idsToBeUpdated.Should().NotContain(isResolvedDataLock.DataLockEventId, because: "Should not update already resolved datalocks");
idsToBeUpdated.Should().NotContain(isPassedDataLock.DataLockEventId, because: "Should not update passed datalocks");
idsToBeUpdated.Should().Contain(toBeUpdateDataLock.DataLockEventId, because: "Should update datalocks with triage status 'change' that is not passed or resolved");
}
private ICollection <DataLockStatus> SetupDataLocks(long apprenticeshipId)
{
var activeDataLock4 = new DataLockStatus
{
ApprenticeshipId = apprenticeshipId,
EventStatus = EventStatus.New,
IsExpired = false,
TriageStatus = TriageStatus.Restart,
ErrorCode = DataLockErrorCode.Dlock04
};
var activeDataLock5 = new DataLockStatus
{
ApprenticeshipId = apprenticeshipId,
EventStatus = EventStatus.New,
IsExpired = false,
TriageStatus = TriageStatus.Restart,
ErrorCode = DataLockErrorCode.Dlock05
};
var inactiveDataLock6 = new DataLockStatus
{
ApprenticeshipId = apprenticeshipId,
EventStatus = EventStatus.Removed,
IsExpired = false,
TriageStatus = TriageStatus.Restart,
ErrorCode = DataLockErrorCode.Dlock04
};
var dataLockForApprenticeshipBeforeStart = new DataLockStatus
{
ApprenticeshipId = apprenticeshipId,
EventStatus = EventStatus.New,
IsExpired = false,
TriageStatus = TriageStatus.Change,
ErrorCode = DataLockErrorCode.Dlock04
};
return(new List <DataLockStatus> {
activeDataLock4, activeDataLock5, inactiveDataLock6, dataLockForApprenticeshipBeforeStart
});
}
public async Task And_Has_ErrorCode_None_And_TriageStatus_Unknown_Then_No_Alerts(
Apprenticeship source,
DataLockStatus dataLockStatus,
PriceHistory priceHistory,
ApprenticeshipToApprenticeshipDetailsMapper mapper)
{
dataLockStatus.ErrorCode = DataLockErrorCode.None;
dataLockStatus.TriageStatus = TriageStatus.Unknown;
source.PriceHistory = new List <PriceHistory> {
priceHistory
};
source.DataLockStatus = new List <DataLockStatus> {
dataLockStatus
};
source.ApprenticeshipUpdate = new List <ApprenticeshipUpdate>();
var result = await mapper.Map(source);
result.Alerts.Should().BeEmpty();
}
public async Task ShouldResolveDataLockWithCourse(bool hasHadDatalockSuccess)
{
var isDataLockWithCourse = new DataLockStatus {
DataLockEventId = 1, ApprenticeshipId = _command.ApprenticeshipId, IsResolved = false, Status = Status.Fail, IlrTotalCost = 505,
ErrorCode = DataLockErrorCode.Dlock07 | DataLockErrorCode.Dlock03, IlrEffectiveFromDate = DateTime.Now, TriageStatus = TriageStatus.Change
};
var toBeUpdateDataLock = new DataLockStatus {
DataLockEventId = 3, ApprenticeshipId = _command.ApprenticeshipId, IsResolved = false, Status = Status.Fail, IlrTotalCost = 400,
ErrorCode = DataLockErrorCode.Dlock07, IlrEffectiveFromDate = DateTime.Now.AddMonths(1), TriageStatus = TriageStatus.Change
};
_dataLockRepository.Setup(m => m.GetDataLocks(_command.ApprenticeshipId, false))
.ReturnsAsync(new List <DataLockStatus> {
isDataLockWithCourse, toBeUpdateDataLock
});
_apprenticeshipRepository.Setup(m => m.GetApprenticeship(_command.ApprenticeshipId))
.ReturnsAsync(new Apprenticeship {
CommitmentId = 123456L, HasHadDataLockSuccess = hasHadDatalockSuccess
});
long[] idsToBeUpdated = null;
_dataLockRepository.Setup(m => m.ResolveDataLock(It.IsAny <IEnumerable <long> >())).Callback <IEnumerable <long> >((ids) => { idsToBeUpdated = ids.ToArray(); })
.ReturnsAsync(0);
await _sut.Handle(_command);
_dataLockRepository.Verify(m => m.ResolveDataLock(It.IsAny <IEnumerable <long> >()), Times.Once);
if (hasHadDatalockSuccess)
{
idsToBeUpdated.Should().NotContain(isDataLockWithCourse.DataLockEventId, because: "Should not update when apprenticeship has had a datalock success");
}
else
{
idsToBeUpdated.Should().Contain(isDataLockWithCourse.DataLockEventId, because: "Should not update when apprenticeship has NOT had a datalock success");
}
idsToBeUpdated.Should().Contain(toBeUpdateDataLock.DataLockEventId, because: "Should update datalocks with triage status 'change' that is not passed or resolved");
}
public async Task And_Has_Resolved_Alert_Then_Nothing_Is_Mapped(
Apprenticeship source,
DataLockStatus dataLockStatus,
PriceHistory priceHistory,
ApprenticeshipToApprenticeshipDetailsMapper mapper)
{
dataLockStatus.ErrorCode = DataLockErrorCode.Dlock07;
dataLockStatus.TriageStatus = TriageStatus.Change;
dataLockStatus.IsResolved = true;
source.DataLockStatus = new List <DataLockStatus> {
dataLockStatus
};
source.PriceHistory = new List <PriceHistory> {
priceHistory
};
source.ApprenticeshipUpdate = new List <ApprenticeshipUpdate>();
var result = await mapper.Map(source);
result.Alerts.Should().BeEmpty();
}
public async Task <long> UpdateDataLockStatus(DataLockStatus dataLockStatus)
{
_logger.Info($"Updating or inserting data lock status {dataLockStatus.DataLockEventId}, EventsStatus: {dataLockStatus.EventStatus}");
try
{
var result = await WithConnection(async connection =>
{
var parameters = new DynamicParameters();
parameters.Add("@DataLockEventId", dataLockStatus.DataLockEventId);
parameters.Add("@DataLockEventDatetime", dataLockStatus.DataLockEventDatetime);
parameters.Add("@PriceEpisodeIdentifier", dataLockStatus.PriceEpisodeIdentifier);
parameters.Add("@ApprenticeshipId", dataLockStatus.ApprenticeshipId);
parameters.Add("@IlrTrainingCourseCode", dataLockStatus.IlrTrainingCourseCode);
parameters.Add("@IlrTrainingType", dataLockStatus.IlrTrainingType);
parameters.Add("@IlrActualStartDate", dataLockStatus.IlrActualStartDate);
parameters.Add("@IlrEffectiveFromDate", dataLockStatus.IlrEffectiveFromDate);
parameters.Add("@IlrPriceEffectiveToDate", dataLockStatus.IlrPriceEffectiveToDate);
parameters.Add("@IlrTotalCost", dataLockStatus.IlrTotalCost);
parameters.Add("@ErrorCode", dataLockStatus.ErrorCode);
parameters.Add("@Status", dataLockStatus.Status);
parameters.Add("@TriageStatus", dataLockStatus.TriageStatus);
parameters.Add("@ApprenticeshipUpdateId", dataLockStatus.ApprenticeshipUpdateId);
parameters.Add("@IsResolved", dataLockStatus.IsResolved);
parameters.Add("@EventStatus", dataLockStatus.EventStatus);
return(await connection.ExecuteAsync(
sql: $"[dbo].[UpdateDataLockStatus]",
param: parameters,
commandType: CommandType.StoredProcedure));
});
return(result);
}
catch (Exception ex) when(ex.InnerException is SqlException && IsConstraintError(ex.InnerException as SqlException))
{
throw new RepositoryConstraintException("Unable to insert datalockstatus record", ex);
}
}
public async Task And_Has_ErrorCode_DLock03_And_TriageStatus_Restart_Then_Changes_Requested_Alert(
Apprenticeship source,
DataLockStatus dataLockStatus,
PriceHistory priceHistory,
ApprenticeshipToApprenticeshipDetailsMapper mapper)
{
dataLockStatus.ErrorCode = DataLockErrorCode.Dlock03;
dataLockStatus.TriageStatus = TriageStatus.Restart;
dataLockStatus.IsResolved = false;
source.PriceHistory = new List <PriceHistory> {
priceHistory
};
source.DataLockStatus = new List <DataLockStatus> {
dataLockStatus
};
source.ApprenticeshipUpdate = new List <ApprenticeshipUpdate>();
var result = await mapper.Map(source);
result.Alerts.Should().BeEquivalentTo(new List <Alerts> {
Alerts.ChangesRequested
});
}
private void AssertValidTriageStatus(TriageStatus triageStatus, DataLockStatus dataLockStatus)
{
if (triageStatus == TriageStatus.Change)
{
if (!(dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock07) ||
dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock09)))
{
throw new ValidationException($"Data lock {dataLockStatus.DataLockEventId} with error code {dataLockStatus.ErrorCode} cannot be triaged as {triageStatus}");
}
}
if (triageStatus == TriageStatus.Restart)
{
if (!(dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock03) ||
dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock04) ||
dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock05) ||
dataLockStatus.ErrorCode.HasFlag(DataLockErrorCode.Dlock06)
))
{
throw new ValidationException($"Data lock {dataLockStatus.DataLockEventId} with error code {dataLockStatus.ErrorCode} cannot be triaged as {triageStatus}");
}
}
}
public static bool UnHandled(this DataLockStatus dl)
{
return(!dl.IsResolved && dl.Status != Status.Pass);
}
public static bool IsPriceOnly(this DataLockStatus dataLockStatus)
{
return((int)dataLockStatus.ErrorCode == (int)DataLockErrorCode.Dlock07);
}
public async Task <DataLockViewModel> MapDataLockStatus(DataLockStatus dataLock)
{
var training = await GetTrainingProgramme(dataLock.IlrTrainingCourseCode);
return(MapDataLockStatus(dataLock, training));
}
private void AutoResolveDataLockIfApprenticeshipStoppedAndBackdated(Apprenticeship apprenticeship, DataLockStatus datalock)
{
if (apprenticeship.PaymentStatus == PaymentStatus.Withdrawn &&
apprenticeship.StopDate == apprenticeship.StartDate)
{
_logger.Info($"Auto-resolving datalock for Apprenticeship #{datalock.ApprenticeshipId} withdrawn effective at start date. Event Id {datalock.DataLockEventId}");
datalock.IsResolved = true;
}
}
