/// <remarks>
/// Note: any commitments with CommitmentStatus == Active are filtered out before GetStatus is called on them
/// </remarks>
public RequestStatus GetStatus(EditStatus editStatus, int apprenticeshipCount, LastAction lastAction,
AgreementStatus overallAgreementStatus, LastUpdateInfo providerLastUpdateInfo,
long?transferSenderId, TransferApprovalStatus?transferApprovalStatus)
{
if (transferSenderId.HasValue)
{
return(GetTransferStatus(editStatus, transferApprovalStatus, lastAction, overallAgreementStatus));
}
if (editStatus == EditStatus.Both)
{
return(RequestStatus.Approved);
}
if (editStatus == EditStatus.ProviderOnly)
{
return(GetProviderOnlyStatus(lastAction, overallAgreementStatus));
}
if (editStatus == EditStatus.EmployerOnly)
{
return(GetEmployerOnlyStatus(lastAction));
}
return(RequestStatus.None);
}
void ICMService.DeleteAgreementStatus(AgreementStatus agreementStatus)
{
using (DomainService service = new DomainService())
{
service.DeleteAgreementStatus(agreementStatus);
}
}
public async Task ThenCountsShouldBeCorrectWhenEmployerHasASingleCommitmentThats(
int expectedDraftCount, int expectedReadyForReviewCount, int expectedWithProviderCount, int expectedTransferFundedCohortsCount, int expectedRejectedTransferFundedCohortsCount,
long?transferSenderId, TransferApprovalStatus transferApprovalStatus,
AgreementStatus agreementStatus, EditStatus editStatus, LastAction lastAction, int apprenticeshipCount)
{
//Arrange
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetCommitmentsQuery>()))
.ReturnsAsync(new GetCommitmentsResponse
{
Commitments = new List <CommitmentListItem>
{
new CommitmentListItem
{
TransferSenderId = transferSenderId,
TransferApprovalStatus = transferApprovalStatus,
AgreementStatus = agreementStatus,
EditStatus = editStatus,
LastAction = lastAction,
ApprenticeshipCount = apprenticeshipCount
}
}
});
//Act
var result = await EmployerCommitmentOrchestrator.GetYourCohorts("ABC123", "ABC321");
//Assert
Assert.AreEqual(expectedDraftCount, result.Data.DraftCount, "Incorrect DraftCount");
Assert.AreEqual(expectedReadyForReviewCount, result.Data.ReadyForReviewCount, "Incorrect ReadyForReviewCount");
Assert.AreEqual(expectedWithProviderCount, result.Data.WithProviderCount, "Incorrect WithProviderCount");
Assert.AreEqual(expectedTransferFundedCohortsCount, result.Data.TransferFundedCohortsCount, "IncorrectTransferFundedCohortsCount");
Assert.AreEqual(expectedRejectedTransferFundedCohortsCount, result.Data.RejectedTransferFundedCohortsCount, "IncorrectRejectedTransferFundedCohortsCount");
}
public void Scenario3(RequestStatus expectedResult, AgreementStatus agreementStatus, EditStatus editStatus, int numberOfApprenticeships, LastAction lastAction)
{
// Scenario 3
var status = _calculator.GetStatus(editStatus, numberOfApprenticeships, lastAction, agreementStatus);
status.Should().Be(expectedResult);
}
public async Task ThenIsSecondApprovalShouldBeSetCorrectly(AgreementStatus agreementStatus, bool expectedIsSecondApproval)
{
CommitmentView.AgreementStatus = agreementStatus;
var result = await EmployerCommitmentOrchestrator.GetAcknowledgementModelForExistingCommitment("ABC123", "XYZ123", "ABC321");
Assert.AreEqual(expectedIsSecondApproval, result.Data.IsSecondApproval);
}
public void ThenIfNoActionWasTakenThenTheAgreementStatusIsNotChanged(AgreementStatus currentAgreementStatus, CallerType callerType)
{
//Act
var result = _rules.DetermineNewAgreementStatus(currentAgreementStatus, callerType, LastAction.None);
//Assert
Assert.AreEqual(currentAgreementStatus, result);
}
public AgreementStatus DetermineNewAgreementStatus(AgreementStatus currentAgreementStatus, CallerType caller, bool doChangesRequireAgreement)
{
if (!doChangesRequireAgreement)
{
return(currentAgreementStatus);
}
return(AgreementStatus.NotAgreed);
}
private DateTime?DetermineApprovalEventEffectiveFromDate(AgreementStatus agreementStatus, IEnumerable <ApprenticeshipResult> existingApprenticeships, DateTime?startDate)
{
var previousApprenticeshipStoppedDate = GetPreviousApprenticeshipStoppedDate(existingApprenticeships, startDate);
if (HasPreviousApprenticeshipStoppedInTheSameMonth(previousApprenticeshipStoppedDate, startDate))
{
return(previousApprenticeshipStoppedDate.Value.AddDays(1));
}
return(new DateTime(startDate.Value.Year, startDate.Value.Month, 1));
}
private bool CallerApproved(AgreementStatus currentAgreementStatus, CallerType caller)
{
switch (caller)
{
case CallerType.Employer:
return(currentAgreementStatus == AgreementStatus.EmployerAgreed);
case CallerType.Provider:
return(currentAgreementStatus == AgreementStatus.ProviderAgreed);
default:
throw new ArgumentOutOfRangeException(nameof(caller), caller, null);
}
}
public void ThenTheRequestHasTheCorrectStatus(LastAction lastAction, AgreementStatus agreementStatus, RequestStatus expectRequestStatus)
{
var commitment = new CommitmentListItem
{
LastAction = lastAction,
AgreementStatus = agreementStatus,
EditStatus = EditStatus.ProviderOnly,
ApprenticeshipCount = 2
};
//Act
var status = commitment.GetStatus();
//Assert
Assert.AreEqual(expectRequestStatus, status);
}
public AgreementStatus DetermineNewAgreementStatus(AgreementStatus currentAgreementStatus, CallerType caller, LastAction action)
{
if (action == LastAction.None)
{
return(currentAgreementStatus);
}
if (action == LastAction.Amend)
{
if (!CallerApproved(currentAgreementStatus, caller))
{
return(AgreementStatus.NotAgreed);
}
return(currentAgreementStatus);
}
switch (caller)
{
case CallerType.Employer:
if (currentAgreementStatus == AgreementStatus.ProviderAgreed)
{
return(AgreementStatus.BothAgreed);
}
if (currentAgreementStatus == AgreementStatus.NotAgreed)
{
return(AgreementStatus.EmployerAgreed);
}
break;
case CallerType.Provider:
if (currentAgreementStatus == AgreementStatus.EmployerAgreed)
{
return(AgreementStatus.BothAgreed);
}
if (currentAgreementStatus == AgreementStatus.NotAgreed)
{
return(AgreementStatus.ProviderAgreed);
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(action), action, null);
}
throw new ArgumentException($"Invalid combination of values - CurrentAgreementStatus:{currentAgreementStatus}, Caller:{caller}, Action:{action}");
}
public void ShouldReturnSameAsAllApprenticeships(AgreementStatus agreementStatus)
{
var _sut = new CommitmentRules();
var fixture = new Fixture();
fixture.Customize <Apprenticeship>(ob => ob
.With(x => x.AgreementStatus, agreementStatus));
var apprenticeships = new List <Apprenticeship>
{
fixture.Create <Apprenticeship>(),
fixture.Create <Apprenticeship>(),
fixture.Create <Apprenticeship>()
};
_sut.DetermineAgreementStatus(apprenticeships).ShouldBeEquivalentTo(agreementStatus);
}
public AgreementStatus DetermineNewAgreementStatus(AgreementStatus currentAgreementStatus, CallerType caller, LastAction action)
{
if (action == LastAction.None)
{
return(currentAgreementStatus);
}
if (action == LastAction.Amend)
{
if (!CallerApproved(currentAgreementStatus, caller))
{
return(AgreementStatus.NotAgreed);
}
return(currentAgreementStatus);
}
throw new ArgumentException($"Invalid combination of values - CurrentAgreementStatus:{currentAgreementStatus}, Caller:{caller}, Action:{action}");
}
private static RequestStatus GetProviderOnlyStatus(LastAction lastAction, AgreementStatus overallAgreementStatus)
{
if (lastAction == LastAction.None)
{
return(RequestStatus.NewRequest);
}
if (lastAction == LastAction.Amend)
{
return(RequestStatus.ReadyForReview);
}
if (lastAction == LastAction.Approve)
{
if (overallAgreementStatus == AgreementStatus.NotAgreed)
{
return(RequestStatus.ReadyForReview);
}
return(RequestStatus.ReadyForApproval);
}
return(RequestStatus.None);
}
public void ThenLeaveAsCurrentStatusIfIsApprovedByPartyAndAmending(AgreementStatus currentAgreementStatus, CallerType caller, LastAction action)
{
Assert.AreEqual(currentAgreementStatus, _rules.DetermineNewAgreementStatus(currentAgreementStatus, caller, action));
}
public void ThenSetToToNotAgreedIfOtherPartyIsApprovedAndAmending(AgreementStatus currentAgreementStatus, CallerType caller, LastAction action)
{
Assert.AreEqual(AgreementStatus.NotAgreed, _rules.DetermineNewAgreementStatus(currentAgreementStatus, caller, action));
}
public void ThenSetToCallingPartyAgreedIfCurrentlyNotAgreed(CallerType caller, LastAction action, AgreementStatus expectedAgreementStatus)
{
Assert.AreEqual(expectedAgreementStatus, _rules.DetermineNewAgreementStatus(AgreementStatus.NotAgreed, caller, action));
}
public void ThenSetToBothPartiesAgreedIfOtherPartyHasAlreadyAgreed(AgreementStatus currentAgreementStatus, CallerType caller, LastAction action)
{
Assert.AreEqual(AgreementStatus.BothAgreed, _rules.DetermineNewAgreementStatus(currentAgreementStatus, caller, action));
}
public virtual void Suspend()
{
Status = AgreementStatus.Suspended;
DomainEvents.Raise(new AgreementSuspendedDomainEvent(this));
}
public async Task ThenShouldReturnListOfCommitmentsInResponseWithAgreementStatusAndCount(AgreementStatus agreementStatus)
{
var fixture = new Fixture();
fixture.Customize <CommitmentSummary>(ob => ob
.With(x => x.AgreementStatus, agreementStatus));
var commitment = fixture.Create <CommitmentSummary>();
commitment.ApprenticeshipCount = 3;
IList <CommitmentSummary> commitmentsFromRepository = new List <CommitmentSummary> {
commitment
};
_mockCommitmentRespository.Setup(x => x.GetCommitmentsByEmployer(It.IsAny <long>())).ReturnsAsync(commitmentsFromRepository);
var response = await _handler.Handle(new GetCommitmentsRequest
{
Caller = new Caller
{
CallerType = CallerType.Employer,
Id = 123
}
});
response.Data.Should().HaveSameCount(commitmentsFromRepository);
response.Data[0].Messages.Should().HaveSameCount(commitmentsFromRepository[0].Messages);
commitmentsFromRepository.Should()
.OnlyContain(x => response.Data.All(y =>
y.AgreementStatus == agreementStatus &&
y.ApprenticeshipCount == x.ApprenticeshipCount));
}
internal static void SetDefaultColValues(SPListItem spItm, string agreementId, AgreementStatus status)
{
spItm[Constants.ColSignedStatus] = status.ToString();
spItm.Update();
try
{
spItm[Constants.ColAgreementID] = agreementId;
spItm.Update();
}
catch {
// do nothign as it might not exist
}
}
private RequestStatus GetTransferStatus(EditStatus edit, TransferApprovalStatus?transferApproval, LastAction lastAction, AgreementStatus agreementStatus)
{
const string invalidStateExceptionMessagePrefix = "Transfer funder commitment in invalid state: ";
if (edit >= EditStatus.Neither)
{
throw new Exception("Unexpected EditStatus");
}
switch (transferApproval ?? TransferApprovalStatus.Pending)
{
case TransferApprovalStatus.Pending:
switch (edit)
{
case EditStatus.Both:
return(RequestStatus.WithSenderForApproval);
//todo: these (EmployerOnly & ProviderOnly) status calculations will have to be updated/checked by later stories
case EditStatus.EmployerOnly:
return(GetEmployerOnlyStatus(lastAction));
case EditStatus.ProviderOnly:
return(GetProviderOnlyStatus(lastAction, agreementStatus));
default:
throw new Exception("Unexpected EditStatus");
}
case TransferApprovalStatus.Approved:
if (edit != EditStatus.Both)
{
throw new InvalidStateException($"{invalidStateExceptionMessagePrefix}If approved by sender, must be approved by receiver and provider");
}
return(RequestStatus.None);
case TransferApprovalStatus.Rejected:
if (edit != EditStatus.EmployerOnly)
{
throw new InvalidStateException($"{invalidStateExceptionMessagePrefix}If just rejected by sender, must be with receiver");
}
return(RequestStatus.SentForReview);
default:
throw new Exception("Unexpected TransferApprovalStatus");
}
}
public async Task ThenShouldReturnListOfCommitmentsInResponseWithAgreementStatusAndCount(AgreementStatus agreementStatus)
{
var fixture = new Fixture();
fixture.Customize <Apprenticeship>(ob => ob
.With(x => x.AgreementStatus, agreementStatus));
var commitment = fixture.Create <Commitment>();
commitment.EmployerAccountId = 123L;
commitment.Apprenticeships = new List <Apprenticeship>
{
fixture.Create <Apprenticeship>(),
fixture.Create <Apprenticeship>(),
fixture.Create <Apprenticeship>()
};
_mockCommitmentRespository.Setup(x => x.GetCommitmentById(It.IsAny <long>())).ReturnsAsync(commitment);
var response = await _handler.Handle(new GetCommitmentRequest
{
CommitmentId = 123L,
Caller = new Caller
{
CallerType = CallerType.Employer,
Id = 123
}
});
commitment.Apprenticeships.Should()
.OnlyContain(x => response.Data.Apprenticeships.All(y =>
y.AgreementStatus == agreementStatus));
}
public void EmployerSendsToProviderToAddApprentices(RequestStatus expectedResult, AgreementStatus agreementStatus, EditStatus editStatus, int numberOfApprenticeships, LastAction lastAction)
{
// Scenario 1
var status = _calculator.GetStatus(editStatus, numberOfApprenticeships, lastAction, agreementStatus);
status.Should().Be(expectedResult);
}
/*********************************************************/
/* AgreementStatus Implementations */
/*********************************************************/
#region AgreementStatus Implementations
public CreateAgreementStatusResponse CreateAgreementStatus(CreateAgreementStatusRequest request)
{
CreateAgreementStatusResponse response = new CreateAgreementStatusResponse();
response.ExceptionState = false;
AgreementStatus agreementStatus = new AgreementStatus();
agreementStatus.Name = request.Name.ToUpper(new CultureInfo("tr-TR"));
agreementStatus.Description = request.Description.ToUpper(new CultureInfo("tr-TR"));
Query query = new Query();
query.Add(Criterion.Create<AgreementStatus>(c => c.Name, request.Name, CriteriaOperator.Equal));
if (_agreementStatusRepository.FindBy(query).Count() > 0)
{
response.ExceptionState = true;
response.ExceptionMessage = @"Bu isimde bir sözleşme durumu zaten var. Lütfen sözleşme durumu adını benzersiz bir isim olarak düzenleyin.";
response.AgreementStatus = agreementStatus.ConvertToAgreementStatusView();
return response;
}
object identityToken = _agreementStatusRepository.Add(agreementStatus);
_unitOfWork.Commit();
if (identityToken == null)
{
response.ExceptionState = true;
response.ExceptionMessage = @"Sözleşme durumu kaydedilemedi. Lütfen daha sonra tekrar deneyin.";
return response;
}
response.AgreementStatus = _agreementStatusRepository.FindBy((int)identityToken).ConvertToAgreementStatusView();
return response;
}
public PaymentStatus DetermineNewPaymentStatus(PaymentStatus currentPaymentStatus, AgreementStatus newApprenticeshipAgreementStatus)
{
switch (currentPaymentStatus)
{
case PaymentStatus.PendingApproval:
case PaymentStatus.Active:
case PaymentStatus.Paused:
return(newApprenticeshipAgreementStatus == AgreementStatus.BothAgreed ? PaymentStatus.Active : PaymentStatus.PendingApproval);
default:
throw new ArgumentOutOfRangeException(nameof(currentPaymentStatus), currentPaymentStatus, null);
}
}
public void WhenThereAreApprentices(RequestStatus expectedResult, LastAction lastAction, AgreementStatus overallAgreementStatus)
{
var status = _calculator.GetStatus(EditStatus.ProviderOnly, 2, lastAction, overallAgreementStatus);
status.Should().Be(expectedResult);
}
public async Task UpdateApprenticeshipStatus(long commitmentId, long apprenticeshipId, AgreementStatus agreementStatus)
{
_logger.Debug($"Updating apprenticeship {apprenticeshipId} for commitment {commitmentId} agreement status to {agreementStatus}", commitmentId: commitmentId, apprenticeshipId: apprenticeshipId);
await WithConnection(async connection =>
{
var parameters = new DynamicParameters();
parameters.Add("@id", apprenticeshipId, DbType.Int64);
parameters.Add("@agreementStatus", agreementStatus, DbType.Int16);
parameters.Add("@agreedOn", _currentDateTime.Now, DbType.DateTime);
var returnCode = await connection.ExecuteAsync(
"UPDATE [dbo].[Apprenticeship] SET AgreementStatus = @agreementStatus " +
"WHERE Id = @id;",
parameters,
commandType: CommandType.Text);
if (agreementStatus == AgreementStatus.BothAgreed)
{
returnCode = await connection.ExecuteAsync(
"UPDATE [dbo].[Apprenticeship] SET AgreedOn = @agreedOn " +
"WHERE Id = @id AND AgreedOn IS NULL;",
parameters,
commandType: CommandType.Text);
}
return(returnCode);
});
}
public void ThenLeaveAsIsIfNoChangesThatRequirementAgreementWereMade(AgreementStatus agreementStatus)
{
Assert.AreEqual(agreementStatus, _rules.DetermineNewAgreementStatus(agreementStatus, CallerType.Employer, false));
}
public void ThenSetAsNotAgreedIfChangesThatRequireAgreementWereMade(AgreementStatus agreementStatus)
{
Assert.AreEqual(AgreementStatus.NotAgreed, _rules.DetermineNewAgreementStatus(agreementStatus, CallerType.Employer, true));
}
public UpdateAgreementStatusResponse UpdateAgreementStatus(UpdateAgreementStatusRequest request)
{
UpdateAgreementStatusResponse response = new UpdateAgreementStatusResponse();
response.ExceptionState = false;
AgreementStatus agreementStatus = new AgreementStatus();
agreementStatus.Id = request.Id;
agreementStatus.Name = request.Name.ToUpper(new CultureInfo("tr-TR"));
agreementStatus.Description = request.Description.ToUpper(new CultureInfo("tr-TR"));
if (agreementStatus.Name != _agreementStatusRepository.FindBy(request.Id).Name)
{
Query query = new Query();
query.Add(Criterion.Create<AgreementStatus>(c => c.Name, request.Name, CriteriaOperator.Equal));
if (_agreementStatusRepository.FindBy(query).Count() > 0)
{
response.ExceptionState = true;
response.ExceptionMessage = @"Bu isimde bir sözleşme durumu zaten var. Lütfen sözleşme durumu adını benzersiz bir isim olarak düzenleyin.";
response.AgreementStatus = agreementStatus.ConvertToAgreementStatusView();
return response;
}
}
_agreementStatusRepository.Save(agreementStatus);
_unitOfWork.Commit();
response.AgreementStatus = agreementStatus.ConvertToAgreementStatusView();
return response;
}
public virtual void Cancel()
{
Status = AgreementStatus.Cancelled;
DomainEvents.Raise(new AgreementCancelledDomainEvent(this));
}
