public async Task CanFilterByPropertyRef()
{
// Arrange
var expectedPropertyRef = Guid.NewGuid().ToString();
var allWorkOrders = _generator.GenerateList(3);
SetPropertyRefs(allWorkOrders, "not" + expectedPropertyRef);
var expectedWorkOrders = _generator.GenerateList(3);
SetPropertyRefs(expectedWorkOrders, expectedPropertyRef);
allWorkOrders.AddRange(expectedWorkOrders);
_repairsMock.ReturnsWorkOrders(allWorkOrders);
var workOrderSearchParameters = new WorkOrderSearchParameters
{
PropertyReference = expectedPropertyRef
};
// Act
var workOrders = await _classUnderTest.Execute(workOrderSearchParameters);
// Assert
workOrders.Should().BeEquivalentTo(expectedWorkOrders);
}
public async Task ListsWorkOrders()
{
const int count = 5;
var index = new Random().Next(0, count - 1);
var operatives = _fixture.CreateMany <WorkOrderOperativeResponse>(count);
var operativePrn = operatives.ElementAt(index).PayrollNumber;
var expectedWorkOrders = _fixture.CreateMany <OperativeWorkOrderListItem>();
var expectedSearchParams = new WorkOrderSearchParameters
{
OperativePRNs = new List <string>
{
operativePrn
}
};
_listOperativeWorkOrdersMock
.Setup(m => m.Execute(It.IsAny <OperativeWorkOrderSearch>()))
.ReturnsAsync(expectedWorkOrders);
var objectResult = await _classUnderTest.ListWorkOrders(operativePrn);
var workOrderResponse = GetResultData <List <OperativeWorkOrderListItem> >(objectResult);
var statusCode = GetStatusCode(objectResult);
// Assert
statusCode.Should().Be((int)HttpStatusCode.OK);
workOrderResponse.Should().BeEquivalentTo(expectedWorkOrders);
}
public async Task ReturnsCorrectPageOfWorkOrders()
{
//Arrange
const int workOrderCount = 50;
const int expectedPageSize = 10;
var generatedWorkOrders = GenerateAndReturnWorkOrdersWithRandomStatus(workOrderCount);
var workOrderSearchParameters = new WorkOrderSearchParameters
{
PageNumber = 2,
PageSize = expectedPageSize
};
var statusOrder = new[] {
WorkStatusCode.Open,
WorkStatusCode.VariationPendingApproval,
WorkStatusCode.Canceled,
WorkStatusCode.Complete
};
//Act
var workOrders = await _classUnderTest.Execute(workOrderSearchParameters);
//Assert
var expectedResult = generatedWorkOrders
.OrderBy(wo => Array.IndexOf(statusOrder, wo.StatusCode))
.ThenByDescending(wo => wo.DateRaised)
.Skip((workOrderSearchParameters.PageNumber - 1) * workOrderSearchParameters.PageSize)
.Take(workOrderSearchParameters.PageSize);
workOrders.Should().BeEquivalentTo(expectedResult);
}
public async Task <IEnumerable <OperativeWorkOrderListItem> > Execute(OperativeWorkOrderSearch opSearch)
{
var loggedInUser = _currentUserService.GetUser();
if (!string.Equals(loggedInUser.PayrollNumber(), opSearch.PayrollNumber, StringComparison.CurrentCultureIgnoreCase))
{
ThrowHelper.ThrowUnauthorizedAccessException("Only the operative can retrieve their list of work orders.");
}
var operativeDashActiveStatusCodes = Enum.GetValues(typeof(WorkStatusCode)).Cast <int>().ToList();
operativeDashActiveStatusCodes.RemoveAll(c => c == (int)WorkStatusCode.Canceled ||
c == (int)WorkStatusCode.PendingApproval);
_logger.LogInformation($"Searching for operative number {opSearch.PayrollNumber} work orders with statuses {string.Join(", ", operativeDashActiveStatusCodes.Select(x => x.ToString()))}");
var searchParams = new WorkOrderSearchParameters
{
StartDate = DateTime.Today,
EndDate = DateTime.Today.AddDays(1),
OperativePRNs = new List <string>
{
opSearch.PayrollNumber
},
StatusCode = operativeDashActiveStatusCodes,
PageSize = opSearch.PageSize
};
var workOrders = await _listWorkOrdersUseCase.Execute(searchParams);
if (!workOrders.Any())
{
_logger.LogWarning($"Search for work orders for operative {opSearch.PayrollNumber} did not find anything");
}
else
{
_logger.LogInformation($"{workOrders.Count()} work orders for operative {opSearch.PayrollNumber}: [${string.Join(", ", workOrders.Select(w => w.Id.ToString()))}]");
}
DateTime earliestAppointementDate = GetEarliestAppointmentFromWorkOrders(workOrders);
var excludedWorkOrders = workOrders.Where(wo =>
(wo.StatusCode == WorkStatusCode.Complete && wo.ClosedDate.Value.Date < earliestAppointementDate.Date ||
wo.StatusCode == WorkStatusCode.NoAccess && wo.ClosedDate.Value.Date < earliestAppointementDate.Date
));
workOrders = workOrders
.Except(excludedWorkOrders);
workOrders = workOrders.OrderBy(wo => wo.Appointments.Min(a => a.StartTime));
return(workOrders.Select(wo => wo.ToOperativeListItem()));
}
private async Task <IEnumerable <WorkOrder> > GetWorkOrdersFromToday()
{
var todaysJobsParams = new WorkOrderSearchParameters
{
StartDate = DateTime.Today,
EndDate = DateTime.Today.AddDays(1),
PageSize = 0
};
return((await _listWorkOrdersUseCase.Execute(todaysJobsParams))
.Where(wo => wo.StatusCode != WorkStatusCode.Complete)
.Where(wo => !wo.HasManuallyAssignedOperatives()));
}
private static IEnumerable <WorkOrder> EnsureSorting(WorkOrderSearchParameters searchParameters, IEnumerable <WorkOrder> workOrders)
{
var statusOrders = new[]
{
WorkStatusCode.Open, WorkStatusCode.VariationPendingApproval, WorkStatusCode.Canceled, WorkStatusCode.Complete
};
if (!IsSortSpecified(searchParameters))
{
workOrders = AddDefaultSort(workOrders, statusOrders);
}
return(workOrders);
}
public async Task <IEnumerable <WorkOrder> > Execute(WorkOrderSearchParameters searchParameters)
{
var filter = _filterBuilder.BuildFilter(searchParameters);
var workOrders = await _repairsGateway.GetWorkOrders(filter, searchParameters.IncludeHistorical);
workOrders = EnsureSorting(searchParameters, workOrders);
if (searchParameters.PageSize == 0)
{
return(workOrders);
}
return(workOrders
.Skip((searchParameters.PageNumber - 1) * searchParameters.PageSize)
.Take(searchParameters.PageSize));
}
private async Task <IEnumerable <WorkOrder> > GetHistoricalWorkOrders()
{
var searchParams = new WorkOrderSearchParameters
{
StartDate = DateTime.Today.AddDays(1),
EndDate = DateTime.Today.AddDays(30),
PageSize = 0
};
var workOrders = await _listWorkOrdersUseCase.Execute(searchParams);
return(workOrders
.Where(wo => wo.StatusCode != WorkStatusCode.Complete)
.Where(wo => !wo.HasManuallyAssignedOperatives())
.OrderBy(wo => wo.Appointments.Min(appt => appt.StartTime)));
}
public async Task ReturnsAllWorkOrdersWhenPageSizeIsZero()
{
//Arrange
const int workOrderCount = 50;
GenerateAndReturnWorkOrdersWithRandomStatus(workOrderCount);
var workOrderSearchParameters = new WorkOrderSearchParameters
{
PageSize = 0
};
//Act
var workOrders = await _classUnderTest.Execute(workOrderSearchParameters);
//Assert
workOrders.Should().HaveCount(workOrderCount);
}
public async Task FiltersWorkOrders()
{
// Arrange
CreateWorkOrders();
var expectedSearchParams = new WorkOrderSearchParameters
{
StartDate = DateTime.Today.AddDays(1),
EndDate = DateTime.Today.AddDays(30)
};
// Act
await _classUnderTest.ExecuteAsync();
// Assert
_listWorkOrdersMock.Verify(x => x.Execute(It.Is <WorkOrderSearchParameters>(wosp =>
wosp.StartDate == expectedSearchParams.StartDate &&
wosp.EndDate == expectedSearchParams.EndDate &&
wosp.PageSize == 0
)));
}
private static bool ValidateExclusions(WorkOrderSearchParameters sp)
{
return(!sp.StatusCode.Contains((int)WorkStatusCode.Canceled) &&
!sp.StatusCode.Contains((int)WorkStatusCode.PendingApproval));
}
private static bool ValidateSearchParams(string expectedPRN, WorkOrderSearchParameters sp)
{
return(sp.OperativePRNs.Contains(expectedPRN) &&
sp.StartDate == DateTime.Today &&
sp.EndDate == DateTime.Today.AddDays(1));
}
public void Setup()
{
_classUnderTest = new WorkOrderSearchParameters();
}
public async Task <IActionResult> GetList([FromQuery] WorkOrderSearchParameters parameters)
{
var workOrders = await _listWorkOrdersUseCase.Execute(parameters);
return(Ok(workOrders.Select(wo => wo.ToListItem()).ToList()));
}
private static bool IsSortSpecified(WorkOrderSearchParameters searchParameters)
{
return(!string.IsNullOrWhiteSpace(searchParameters.Sort));
}
