public Task <ActionResult <OrderGroup> > Patch(int id, [FromBody] OrderGroupsUpdateRequest request)
{
if (request != null && request.DplNote != null && _authData.GetUserRole() == UserRole.DplEmployee)
{
request.DplNote.UserId = _authData.GetUserId();
}
return(this._orderGroupsService.Update(id, request).Convert(this));
}
public static bool CheckUpdatedProperties(this OrderGroupsUpdateRequest request, Olma.Order order)
{
if (order.LoadCarrierId != request.LoadCarrierId ||
order.LoadingLocationId != request.LoadingLocationId ||
order.LatestFulfillmentDateTime != request.LatestFulfillmentDateTime ||
order.EarliestFulfillmentDateTime != request.EarliestFulfillmentDateTime ||
order.BaseLoadCarrierId != request.BaseLoadCarrierId ||
order.QuantityType != request.QuantityType ||
order.StackHeightMax != request.StackHeightMax ||
order.StackHeightMin != request.StackHeightMin ||
order.SupportsJumboVehicles != request.SupportsJumboVehicles ||
order.SupportsRearLoading != request.SupportsRearLoading ||
order.SupportsSideLoading != request.SupportsSideLoading)
{
return(true);
}
return(false);
}
public async Task <IWrappedResponse <OrderGroup> > Update(int id, OrderGroupsUpdateRequest request)
{
#region security
// TODO add security
#endregion
var orderGroup = _olmaOrderGroupRepo.FindByCondition(og => og.Id == id)
.Include(o => o.Orders).ThenInclude((i => i.DplNotes))
.FirstOrDefault();
if (orderGroup == null || orderGroup.Orders.Count == 0)
{
return new WrappedResponse <OrderGroup>
{
ResultType = ResultType.NotFound,
Data = null,
Errors = new[] { "Orders not found" }
}
}
;
var openedOrders = orderGroup.Orders
.Where(o => o.Status == OrderStatus.Pending)
.ToList();
if (openedOrders.Count > 0 &&
openedOrders.Count != orderGroup.Orders.Count &&
request.CheckUpdatedProperties(orderGroup.Orders.First()))
{
Olma.OrderGroup newOrderGroup = Mapper.Map <OrderGroupsUpdateRequest, Olma.OrderGroup>(request);
_olmaOrderGroupRepo.Create(newOrderGroup);
foreach (var order in openedOrders)
{
Mapper.Map(request, order);
order.Group = newOrderGroup;
}
_olmaOrderGroupRepo.Save();
var newOrderGroupData = Mapper.Map <Olma.OrderGroup, OrderGroup>(newOrderGroup);
return(new WrappedResponse <OrderGroup>
{
ResultType = ResultType.Updated,
Data = newOrderGroupData
});
}
var numberOfOrders = orderGroup.Orders.Count;
bool updated = false;
if (orderGroup.Orders.Count < request.NumberOfLoads)
{
for (int i = 0; i < request.NumberOfLoads - numberOfOrders; i++)
{
orderGroup.Orders.Add(Mapper.Map <OrderGroupsUpdateRequest, Olma.Order>(request));
}
updated = true;
}
else
{
if (numberOfOrders > request.NumberOfLoads &&
numberOfOrders - request.NumberOfLoads <= openedOrders.Count)
{
var ordersToDelete = orderGroup.Orders.Where(o => o.Status == OrderStatus.Pending)
.Take(orderGroup.Orders.Count - request.NumberOfLoads);
foreach (var order in ordersToDelete)
{
orderGroup.Orders.Remove(order);
}
updated = true;
}
}
if (request.CheckUpdatedProperties(orderGroup.Orders.First()))
{
Mapper.Map(request, orderGroup);
foreach (var order in orderGroup.Orders)
{
Mapper.Map(request, order);
}
updated = true;
}
if (!updated)
{
return(new WrappedResponse <OrderGroup>
{
ResultType = ResultType.BadRequest,
Data = null,
Errors = new[] { string.Empty }
});
}
var result = Mapper.Map <Olma.OrderGroup, OrderGroup>(orderGroup);
return(new WrappedResponse <OrderGroup>
{
ResultType = ResultType.Updated,
Data = result
});
}
