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)); }