public async Task UpdateWorkOrderStatus(int workOrderId, WorkStatusCode newCode)
{
var order = await GetWorkOrder(workOrderId);
order.StatusCode = newCode;
await _repairsContext.SaveChangesAsync();
}
public async Task ContractorUpdatesWorkOrderStatusNoAccess()
{
// arrange
const string Comment = "expectedComment";
DateTime jobStatusUpdateTime = DateTime.Now;
const Generated.JobStatusUpdateTypeCode NoAccess = Generated.JobStatusUpdateTypeCode.DeniedAccess_70;
WorkStatusCode expectedNewStatus = WorkStatusCode.NoAccess;
_currentUserServiceMock.SetSecurityGroup(UserGroups.Contractor, true);
var expectedWorkOrder = CreateWorkOrder();
var workOrderCompleteRequest = CreateRequest(expectedWorkOrder.Id);
workOrderCompleteRequest.JobStatusUpdates = new List <Generated.JobStatusUpdates>
{
new Generated.JobStatusUpdates
{
TypeCode = NoAccess, Comments = Comment, EventTime = jobStatusUpdateTime
}
};
// act
await _classUnderTest.Execute(workOrderCompleteRequest);
// assert
var lastWorkOrderComplete = _workOrderCompletionGatewayMock.LastWorkOrderComplete;
_repairsGatewayMock.Verify(rgm => rgm.UpdateWorkOrderStatus(expectedWorkOrder.Id, expectedNewStatus));
lastWorkOrderComplete.JobStatusUpdates.Single().Comments.Should().Be(Resources.WorkOrderNoAccessPrefix + $"{jobStatusUpdateTime:dd MMMM yyyy HH:mm} " + Comment);
}
public async Task UpdatesWorkOrderStatusCancelled()
{
// arrange
const string Comment = "expectedComment";
string customUpdateType = CustomJobStatusUpdates.Cancelled;
WorkStatusCode expectedNewStatus = WorkStatusCode.Canceled;
var expectedWorkOrder = CreateWorkOrder();
var workOrderCompleteRequest = CreateRequest(expectedWorkOrder.Id);
workOrderCompleteRequest.JobStatusUpdates = new List <Generated.JobStatusUpdates>
{
new Generated.JobStatusUpdates
{
TypeCode = Generated.JobStatusUpdateTypeCode.Other_0, OtherType = customUpdateType, Comments = Comment
}
};
// act
await _classUnderTest.Execute(workOrderCompleteRequest);
// assert
var lastWorkOrderComplete = _workOrderCompletionGatewayMock.LastWorkOrderComplete;
_repairsGatewayMock.Verify(rgm => rgm.UpdateWorkOrderStatus(expectedWorkOrder.Id, expectedNewStatus));
lastWorkOrderComplete.JobStatusUpdates.Single().Comments.Should().Be(Resources.WorkOrderCancelledPrefix + Comment);
}
public CreateOrderResult(int id, WorkStatusCode statusCode, string statusCodeDescription)
{
Id = id;
StatusCode = statusCode;
StatusCodeDescription = statusCodeDescription;
ExternallyManagedAppointment = false;
}
private WorkOrder CreateReturnWorkOrder(int expectedId, WorkStatusCode workStatusCode = WorkStatusCode.VariationApproved)
{
var workOrder = BuildWorkOrder(expectedId, workStatusCode);
_repairsGatewayMock.Setup(gateway => gateway.GetWorkOrder(It.Is <int>(i => i == expectedId)))
.ReturnsAsync(workOrder);
return(workOrder);
}
public async Task ThrowsNotSupportedIfNotPendingApproval(WorkStatusCode status)
{
_repairsGatewayMock.Setup(g => g.GetWorkOrder(It.IsAny <int>())).ReturnsAsync(new WorkOrder {
StatusCode = status
});
Func <Task> testFn = async() => await _classUnderTest.Execute(1);
await testFn.Should().ThrowAsync <NotSupportedException>();
}
public async Task ThrowNotSupportedExceptionWhenWorkStatusNotPendingApproval(WorkStatusCode status)
{
const int desiredWorkOrderId = 42;
var workOrder = CreateReturnWorkOrder(desiredWorkOrderId, status);
var request = CreateJobStatusUpdateRequest(workOrder,
Generated.JobStatusUpdateTypeCode.RejectVariation_125);
_currentUserServiceMock.SetSecurityGroup(UserGroups.ContractManager);
Func <Task> fn = () => _classUnderTest.Execute(request);
await fn.Should().ThrowAsync <NotSupportedException>();
}
public async Task ThrowsNotSupportedWhenWOInWrongState(WorkStatusCode status)
{
var workOrder = _fixture.Create <WorkOrder>();
workOrder.StatusCode = status;
var jobStatusUpdate = BuildUpdate(workOrder);
Func <Task> act = async() => await _classUnderTest.Execute(jobStatusUpdate);
(await act.Should().ThrowAsync <NotSupportedException>())
.Which.Message.Should().Be(Resources.WorkOrderNotPendingApproval);
}
private List <WorkOrder> GenerateWorkOrders(int workOrderCount, WorkStatusCode workStatusCode, DateTime closedDate)
{
_generator.AddValue(workStatusCode, (RepairsApi.V2.Infrastructure.WorkOrder wo) => wo.StatusCode);
_generator.AddValue(closedDate, (RepairsApi.V2.Infrastructure.WorkOrder wo) => wo.ClosedDate);
var generatedWorkOrders = _generator.GenerateList(workOrderCount);
foreach (var wo in generatedWorkOrders)
{
wo.Appointments.First().Date = DateTime.Today;
}
return(generatedWorkOrders);
}
public async Task ThrowWhenWorkOrderNotInCorrectState(WorkStatusCode state)
{
const int desiredWorkOrderId = 42;
var workOrder = BuildWorkOrder(desiredWorkOrderId);
workOrder.StatusCode = state;
var request = BuildUpdate(workOrder);
Func <Task> fn = () => _classUnderTest.Execute(request);
(await fn.Should().ThrowAsync <NotSupportedException>())
.Which.Message.Should().Be(Resources.ActionUnsupported);
}
public async Task UpdatesWorkOrderStatus(WorkStatusCode statusCode)
{
var workOrder = _fixture.Create <WorkOrder>();
workOrder.StatusCode = statusCode;
var jobStatusUpdate = BuildUpdate(workOrder);
_repairsGatewayMock.ReturnsWorkOrders(workOrder);
await _classUnderTest.Execute(jobStatusUpdate);
workOrder.StatusCode.Should().Be(WorkStatusCode.PendMaterial);
}
public async Task ThrowsNotSupportedWhenWoInWrongStatus(WorkStatusCode statusCode)
{
var workOrder = _fixture.Create <WorkOrder>();
workOrder.StatusCode = statusCode;
var jobStatusUpdate = BuildUpdate(workOrder);
_repairsGatewayMock.ReturnsWorkOrders(workOrder);
Func <Task> act = () => _classUnderTest.Execute(jobStatusUpdate);
(await act.Should().ThrowAsync <NotSupportedException>())
.Which.Message.Should().Be(Resources.CannotResumeJob);
}
public async Task ThrowNotSupportedExceptionWhenWoInWrongState([Values] WorkStatusCode statusCode)
{
if (statusCode == WorkStatusCode.VariationPendingApproval)
{
return;
}
_currentUserServiceMock.SetSecurityGroup(UserGroups.ContractManager);
const int desiredWorkOrderId = 42;
var workOrder = CreateReturnWorkOrder(desiredWorkOrderId);
workOrder.StatusCode = statusCode;
var request = CreateJobStatusUpdateRequest(workOrder,
Generated.JobStatusUpdateTypeCode.ApproveVariation_10020);
Func <Task> fn = async() => await _classUnderTest.Execute(request);
(await fn.Should().ThrowAsync <NotSupportedException>())
.Which.Message.Should().Be(Resources.ActionUnsupported);
}
public async Task HoldAndResumeWorkOrder(JobStatusUpdateTypeCode updateCode, WorkStatusCode workOrderHoldCode)
{
// Arrange
var result = await CreateWorkOrder();
// Act
await UpdateSorCodes(result.Id, req => req.TypeCode = updateCode);
var heldOrder = GetWorkOrderFromDB(result.Id);
await UpdateSorCodes(result.Id, req =>
{
req.TypeCode = JobStatusUpdateTypeCode.Other_0;
req.OtherType = CustomJobStatusUpdates.Resume;
});
var resumedOrder = GetWorkOrderFromDB(result.Id);
// Assert
heldOrder.StatusCode.Should().Be(workOrderHoldCode);
resumedOrder.StatusCode.Should().Be(WorkStatusCode.Open);
}
public async Task ContractManagerUpdatesWorkOrderStatusComplete()
{
// arrange
string customUpdateType = CustomJobStatusUpdates.Completed;
WorkStatusCode expectedNewStatus = WorkStatusCode.Complete;
_currentUserServiceMock.SetSecurityGroup(UserGroups.ContractManager, true);
var expectedWorkOrder = CreateWorkOrder();
var workOrderCompleteRequest = CreateRequest(expectedWorkOrder.Id);
workOrderCompleteRequest.JobStatusUpdates = new List <Generated.JobStatusUpdates>
{
new Generated.JobStatusUpdates
{
TypeCode = Generated.JobStatusUpdateTypeCode.Other_0, OtherType = customUpdateType, Comments = "expectedComment"
}
};
// act
await _classUnderTest.Execute(workOrderCompleteRequest);
// assert
_repairsGatewayMock.Verify(rgm => rgm.UpdateWorkOrderStatus(expectedWorkOrder.Id, expectedNewStatus));
}
public async Task ContractManagerUpdatesWorkOrderStatusNoAccess()
{
// arrange
const Generated.JobStatusUpdateTypeCode NoAccess = Generated.JobStatusUpdateTypeCode.DeniedAccess_70;
WorkStatusCode expectedNewStatus = WorkStatusCode.NoAccess;
_currentUserServiceMock.SetSecurityGroup(UserGroups.ContractManager, true);
var expectedWorkOrder = CreateWorkOrder();
var workOrderCompleteRequest = CreateRequest(expectedWorkOrder.Id);
workOrderCompleteRequest.JobStatusUpdates = new List <Generated.JobStatusUpdates>
{
new Generated.JobStatusUpdates
{
TypeCode = NoAccess, Comments = "expectedComment"
}
};
// act
await _classUnderTest.Execute(workOrderCompleteRequest);
// assert
_repairsGatewayMock.Verify(rgm => rgm.UpdateWorkOrderStatus(expectedWorkOrder.Id, expectedNewStatus));
}
private WorkOrder BuildWorkOrder(int expectedId, WorkStatusCode workStatusCode)
{
var workOrder = _fixture.Build <WorkOrder>()
.With(x => x.WorkElements, new List <WorkElement>
{
_fixture.Build <WorkElement>()
.With(x => x.RateScheduleItem,
new List <RateScheduleItem>
{
_fixture.Create <RateScheduleItem>()
}
).With(x => x.Trade,
new List <Trade>
{
_fixture.Create <Trade>()
})
.Create()
})
.With(x => x.Id, expectedId)
.With(x => x.StatusCode, workStatusCode)
.Create();
return(workOrder);
}
public async Task OperativeCanCompleteJobWhenAssigned(Generated.JobStatusUpdateTypeCode updateCode, string otherTypeCode, WorkStatusCode expectedStatus)
{
const string expectedPayroll = "payrollNumber";
_currentUserServiceMock.SetUser("id", "*****@*****.**", "operative", null, null, null, expectedPayroll);
_currentUserServiceMock.SetSecurityGroup(UserGroups.Contractor, false);
_currentUserServiceMock.SetSecurityGroup(UserGroups.ContractManager, false);
_currentUserServiceMock.SetSecurityGroup(UserGroups.Agent, false);
_currentUserServiceMock.SetSecurityGroup(UserGroups.Operative, true);
var assignedOperatives = new List <Operative>
{
new Operative {
PayrollNumber = expectedPayroll
}
};
var woGenerator = CreateGenerator()
.AddValue(assignedOperatives, (WorkOrder wo) => wo.AssignedOperatives);
var expectedWorkOrder = CreateWorkOrder(woGenerator);
var workOrderCompleteRequest = CreateRequest(expectedWorkOrder.Id);
workOrderCompleteRequest.JobStatusUpdates = new List <Generated.JobStatusUpdates>
{
new Generated.JobStatusUpdates
{
TypeCode = updateCode, OtherType = otherTypeCode, Comments = "expectedComment"
}
};
await _classUnderTest.Execute(workOrderCompleteRequest);
_repairsGatewayMock.Verify(x => x.UpdateWorkOrderStatus(expectedWorkOrder.Id, expectedStatus));
}
public async Task UpdatesAssignedOperativesWhenFeatureFlagSetAndContractorUsesDrs(WorkStatusCode workStatus,
bool updateFeatureEnabled,
bool drsFeatureEnabled,
bool contractorUsesDrs,
bool shouldAssign)
{
var expectedWorkOrder = _generator
.AddValue(workStatus, (WorkOrder wo) => wo.StatusCode)
.Generate();
_repairsGatewayMock.ReturnsWorkOrders(expectedWorkOrder);
_sorGatewayMock.Setup(x => x.GetContractor(expectedWorkOrder.AssignedToPrimary.ContractorReference))
.ReturnsAsync(new Contractor
{
UseExternalScheduleManager = contractorUsesDrs
});
_featureManager.Setup(x => x.IsEnabledAsync(FeatureFlags.UpdateOperativesOnWorkOrderGet))
.ReturnsAsync(updateFeatureEnabled);
_featureManager.Setup(x => x.IsEnabledAsync(FeatureFlags.DRSIntegration))
.ReturnsAsync(drsFeatureEnabled);
await _classUnderTest.Execute(expectedWorkOrder.Id);
_drsService.Verify(x => x.UpdateWorkOrderDetails(expectedWorkOrder.Id), shouldAssign ? Times.Once() : Times.Never());
}
