public async Task Execute(Generated.WorkOrderComplete workOrderCompleteRequest)
{
var workOrderId = int.Parse(workOrderCompleteRequest.WorkOrderReference.ID);
_logger.LogInformation($"Starting execution of CompleteWorkOrderUseCase for order {workOrderId}");
if (await _workOrderCompletionGateway.IsWorkOrderCompleted(workOrderId))
{
throw new NotSupportedException(Resources.CannotCompleteWorkOrderTwice);
}
var workOrder = await _repairsGateway.GetWorkOrder(workOrderId, true);
ValidateRequest(workOrderCompleteRequest);
var workOrderComplete = workOrderCompleteRequest.ToDb(workOrder, null);
await using var transaction = await _transactionManager.Start();
await UpdateWorkOrderStatus(workOrder, workOrderComplete);
await _workOrderCompletionGateway.CreateWorkOrderCompletion(workOrderComplete);
await transaction.Commit();
_logger.LogInformation($"Finished execution of CompleteWorkOrderUseCase for order {workOrderId}, publishing result");
await _repairsSnsService.PublishUpdate(workOrder);
}
public async Task <WorkOrderResponse> Execute(int id)
{
var workOrder = await _repairsGateway.GetWorkOrder(id);
var manuallyAssignedOperatives = workOrder.HasManuallyAssignedOperatives();
if (await _featureManager.IsEnabledAsync(FeatureFlags.UpdateOperativesOnWorkOrderGet) &&
await _featureManager.IsEnabledAsync(FeatureFlags.DRSIntegration) &&
await workOrder.ContractorUsingDrs(_sorGateway) &&
workOrder.StatusCode == WorkStatusCode.Open &&
!manuallyAssignedOperatives)
{
_logger.LogInformation($"Calling DrsService.UpdateWorkOrderDetails from GetWorkOrderUseCase for {workOrder.Id}");
try
{
await _drsService.UpdateWorkOrderDetails(id);
}
catch (Exception e)
{
_logger.LogError(e, $"Failed to update work order {id} from DRS");
try
{
if (e.Message.Contains("Unable to find order in OptiTime Web"))
{
_logger.LogError(e, $"Couldn't find workorder, creating {id} instead DRS");
await _drsService.CreateOrder(workOrder);
}
}
catch (Exception)
{
//swallow exceptions for create
}
}
}
var appointment = await _appointmentGateway.GetAppointment(workOrder.Id);
var canAssignOperative = await workOrder.CanAssignOperative(_sorGateway);
var workOrderResponse = workOrder.ToResponse(appointment, _drsOptions.Value.ManagementAddress, canAssignOperative);
var tasks = await _repairsGateway.GetWorkOrderTasksForWorkOrder(workOrder);
workOrderResponse.TotalSMVs = tasks is null ? 0 : tasks.Sum(t => t.StandardMinuteValue * t.Quantity);
return(workOrderResponse);
}
public async Task <IEnumerable <NoteListItem> > Execute(int id)
{
var workOrder = await _repairsGateway.GetWorkOrder(id);
return(workOrder.JobStatusUpdates?
.Where(jsu => !jsu.Comments.IsNullOrEmpty())
.Where(jsu => jsu.EventTime.HasValue)
.Select(jsu => new NoteListItem
{
Note = jsu.Comments,
Time = jsu.EventTime.Value,
User = jsu.AuthorName,
UserEmail = jsu.AuthorEmail
})
.OrderBy(note => note.Time));
}
public async Task Execute(JobStatusUpdate jobStatusUpdate)
{
var workOrderId = int.Parse(jobStatusUpdate.RelatedWorkOrderReference.ID);
var workOrder = await _repairsGateway.GetWorkOrder(workOrderId);
var jsu = jobStatusUpdate.ToDb(workOrder);
await _strategyFactory.ProcessActions(jsu);
workOrder.IsSplit = jobStatusUpdate.IsSplit ?? workOrder.IsSplit;
workOrder.IsOvertime = jobStatusUpdate.IsOvertime ?? workOrder.IsOvertime;
await _repairsGateway.SaveChangesAsync();
await _jobStatusUpdateGateway.CreateJobStatusUpdate(jsu);
}
public async Task <GetVariationResponse> Execute(int workOrderId)
{
var workOrder = await _repairsGateway.GetWorkOrder(workOrderId);
workOrder.VerifyCanGetVariation();
var workOrderTasks = workOrder.WorkElements.SelectMany(we => we.RateScheduleItem);
var variation = await _jobStatusUpdateGateway.GetOutstandingVariation(workOrderId);
var variationTasks = variation.MoreSpecificSORCode.RateScheduleItem;
return(new GetVariationResponse
{
Notes = variation.Comments,
Tasks = MapTasks(variationTasks, workOrderTasks),
AuthorName = variation.AuthorName,
VariationDate = variation.EventTime ?? DateTime.UtcNow
});
}
private async Task <bool> UpdateWorkOrderDetails(int workOrderId)
{
var wo = await _repairsGateway.GetWorkOrder(workOrderId);
if (!await ValidateWorkOrder(wo))
{
return(false);
}
try
{
await _drsService.UpdateWorkOrderDetails(workOrderId);
}
catch (ApiException e)
{
// Catch API exceptions from DRS as we dont want to potentially fail updating other work orders
// when there is a problem in DRS with one of them
_logger.LogInformation($"Failed to update workOrder {workOrderId}: {e.Message}");
return(false);
}
return(true);
}
public async Task <IEnumerable <AppointmentDayViewModel> > Execute(int workOrderId, DateTime fromDate, DateTime toDate)
{
var workOrder = await _repairsGateway.GetWorkOrder(workOrderId);
if (workOrder is null)
{
throw new ResourceNotFoundException("Work Order does not exist");
}
return((await _appointmentsGateway.ListAppointments(GetContractor(workOrder), fromDate, toDate))
.GroupBy(a => a.Date)
.Select(a => new AppointmentDayViewModel
{
Date = a.Key.ToDate(),
Slots = a.Select(slot => new AppointmentSlot
{
Description = slot.Description,
End = slot.End.ToTime(),
Start = slot.Start.ToTime(),
Reference = $"{slot.Id}/{slot.Date:yyyy-MM-dd}"
}).OrderBy(slot => slot.Start)
}));
}
public async Task Execute(string appointmentRef, int workOrderId, string notes = null)
{
var workOrder = await _repairsGateway.GetWorkOrder(workOrderId);
if (workOrder is null)
{
throw new ResourceNotFoundException("work order does not exist");
}
workOrder.VerifyCanBookAppointment();
await _appointmentsGateway.CreateSlotBooking(appointmentRef, workOrderId, notes);
await _jobStatusUseCase.Execute(new JobStatusUpdate
{
Comments = notes,
OtherType = CustomJobStatusUpdates.AddNote,
RelatedWorkOrderReference = new Reference
{
ID = workOrderId.ToString()
},
TypeCode = JobStatusUpdateTypeCode.Other_0
});
}