private async Task <IWrappedResponse> CreateAction(Rules.OrderGroup.Create.MainRule rule)
{
Olma.OrderGroup orderGroup = new Olma.OrderGroup()
{
Orders = new List <Olma.Order>()
};
// create orders for order group
switch (rule.Context.OrderGroupsCreateRequest.QuantityType)
{
case OrderQuantityType.Load:
{
for (var i = 0; i < rule.Context.OrderGroupsCreateRequest.NumberOfLoads; i++)
{
Olma.Order order = Mapper.Map <Olma.Order>(rule.Context.OrderGroupsCreateRequest);
order.Status = OrderStatus.Pending;
orderGroup.Orders.Add(order);
}
break;
}
case OrderQuantityType.LoadCarrierQuantity:
{
Olma.Order order = Mapper.Map <Olma.Order>(rule.Context.OrderGroupsCreateRequest);
order.Status = OrderStatus.Pending;
orderGroup.Orders.Add(order);
break;
}
case OrderQuantityType.Stacks:
{
Olma.Order order = Mapper.Map <Olma.Order>(rule.Context.OrderGroupsCreateRequest);
order.Status = OrderStatus.Pending;
orderGroup.Orders.Add(order);
break;
}
default:
throw new ArgumentOutOfRangeException($"Unknown QuantityType: {rule.Context.OrderGroupsCreateRequest.QuantityType}");
}
bool transactionRolledBack = false;
IWrappedResponse <OrderMatch> orderMatchServiceResponse = null;
_olmaDbContext.Database.CreateExecutionStrategy().Execute(operation: () =>
{
using (_olmaDbContext.Database.BeginTransaction())
{
_olmaOrderGroupRepo.Create(orderGroup);
_olmaOrderGroupRepo.Save();
// this needs to happen after order is created in db as otherwise no orderGroupid exists
if (rule.Context.OrderGroupsCreateRequest.MatchLmsOrderGroupRowGuid.HasValue)
{
var order = orderGroup.Orders.Single();
var orderMatchQuantity = this.CalculateOrderMatchQuantities(order, order.StackHeightMax);
var orderMatchesCreateRequest = Mapper.Map <OrderMatchesCreateRequest>(order);
orderMatchesCreateRequest = Mapper.Map(orderMatchQuantity, orderMatchesCreateRequest);
if (rule.Context.OrderGroupsCreateRequest.Type == OrderType.Demand)
{
orderMatchesCreateRequest.SupplyOrderRowGuid = rule.Context.OrderGroupsCreateRequest.MatchLmsOrderGroupRowGuid.Value;
orderMatchesCreateRequest.DemandOrderRowGuid = order.RefLmsOrderRowGuid;
}
else
{
orderMatchesCreateRequest.DemandOrderRowGuid = rule.Context.OrderGroupsCreateRequest.MatchLmsOrderGroupRowGuid.Value;
orderMatchesCreateRequest.SupplyOrderRowGuid = order.RefLmsOrderRowGuid;
}
orderMatchServiceResponse = (IWrappedResponse <OrderMatch>)_orderMatchesService.Create(orderMatchesCreateRequest).Result;
if (orderMatchServiceResponse.ResultType != ResultType.Created)
{
_olmaDbContext.Database.RollbackTransaction();
transactionRolledBack = true;
}
else
{
_olmaDbContext.Database.CommitTransaction();
}
}
else
{
_olmaDbContext.Database.CommitTransaction();
}
}
});
if (transactionRolledBack)
{
return(orderMatchServiceResponse);
}
var orders = _olmaDbContext.Orders.Where(i => i.GroupId == orderGroup.Id)
.Include(og => og.LoadingLocation).ThenInclude(loc => loc.Address)
.Include(og => og.LoadingLocation.BusinessHours)
.Include(og => og.LoadingLocation.CustomerDivision).ThenInclude(cd => cd.Customer)
.Include(og => og.CreatedBy).ThenInclude(u => u.Person)
.Include(og => og.LoadCarrier)
.Include(og => og.BaseLoadCarrier)
.Include(og => og.PostingAccount).ThenInclude(pa => pa.CustomerDivisions)
.ThenInclude(cd => cd.Customer);
DateTime syncDate = DateTime.UtcNow;
foreach (var order in orders)
{
order.OrderNumber = await _numberSequencesService.GetProcessNumber(ProcessType.Order, order.Id);
var orderCreateSyncRequest = Mapper.Map <Olma.Order, OrderCreateSyncRequest>(order);
if (orderMatchServiceResponse != null)
{
switch (order.Type)
{
case OrderType.Demand:
orderCreateSyncRequest.RefLmsAvailabilityRowGuid = orderMatchServiceResponse.Data.RefLmsAvailabilityRowGuid;
orderCreateSyncRequest.RefLmsPermanentAvailabilityRowGuid = orderMatchServiceResponse.Data.RefLmsPermanentAvailabilityRowGuid;
break;
case OrderType.Supply:
orderCreateSyncRequest.RefLmsDeliveryRowGuid = orderMatchServiceResponse.Data.RefLmsDeliveryRowGuid;
orderCreateSyncRequest.RefLmsPermanentDeliveryRowGuid = orderMatchServiceResponse.Data.RefLmsPermanentDeliveryRowGuid;
break;
}
orderCreateSyncRequest.DigitalCode = orderMatchServiceResponse.Data.DigitalCode;
orderCreateSyncRequest.LoadCarrierQuantity = orderMatchServiceResponse.Data.LoadCarrierQuantity;
orderCreateSyncRequest.BaseLoadCarrierQuantity = orderMatchServiceResponse.Data.BaseLoadCarrierQuantity;
}
var ordersSyncRequest = new OrdersSyncRequest
{
OrderCreateSyncRequests = new List <OrderCreateSyncRequest>
{
orderCreateSyncRequest
}
};
var syncResult = await _synchronizationsService.SendOrdersAsync(ordersSyncRequest);
if (syncResult.ResultType == ResultType.Ok)
{
order.SyncDate ??= syncDate;
}
}
_olmaDbContext.SaveChanges();
var result = Mapper.Map <Olma.OrderGroup, OrderGroup>(orderGroup);
return(new WrappedResponse <OrderGroup>
{
ResultType = ResultType.Created,
Data = result
});
}
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
});
}
public static bool HasValidMatchingStatus(this Olma.OrderGroup orderGroup)
{
return(orderGroup.Orders != null && orderGroup.Orders.Any(o => (o.Status == OrderStatus.Pending || o.Status == OrderStatus.Confirmed) && !o.IsDeleted));
}
