private OrderMatchQuantity CalculateOrderMatchQuantities(Olma.Order order, int stackHeight)
        {
            var quantities = new OrderMatchQuantity();

            var loadcarrierIds = new[] { order.LoadCarrierId, order.BaseLoadCarrierId }
            .Where(i => i.HasValue)
            .Select(i => i.Value)
            .Distinct()
            .ToArray();

            // TODO move call to load carriers into cached method
            var loadCarriersServiceResponse   = (IWrappedResponse <IEnumerable <LoadCarrier> >)_loadCarriersService.GetAll().Result;
            var loadCarrierQuantityPerEurDict = loadCarriersServiceResponse.Data
                                                .Where(i => loadcarrierIds.Contains(i.Id))
                                                .ToDictionary(i => i.Id, i => i.Type.QuantityPerEur);

            // TODO expand live pooling to provide base load carrier info
            //var hasBaseLoadCarrier = selfTransportOrderGroup.BaseLoadCarrierId != null || request.BaseLoadCarrierId != null;
            var hasBaseLoadCarrier = order.BaseLoadCarrierId != null;

            switch (order.QuantityType)
            {
            case OrderQuantityType.Load:
            {
                var quantityPerEurLoadCarrier     = loadCarrierQuantityPerEurDict[order.LoadCarrierId];
                var quantityPerEurBaseLoadCarrier = order.BaseLoadCarrierId.HasValue
                            ? loadCarrierQuantityPerEurDict[order.BaseLoadCarrierId.Value]
                            : 0;

                // TODO HACK, current assumes number of stacks = 33 both load/baseLoad carrier
                // instead this should be dependent on their types
                var numberOfStacks = 33;

                return(new OrderMatchQuantity()
                    {
                        LoadCarrierQuantity = numberOfStacks * quantityPerEurLoadCarrier * stackHeight,
                        BaseLoadCarrierQuantity = hasBaseLoadCarrier
                                ? 33 * quantityPerEurBaseLoadCarrier
                                : 0,
                        LoadCarrierStackHeight = stackHeight,
                        NumberOfStacks = numberOfStacks
                    });
            }

            case OrderQuantityType.Stacks:
            {
                var numberOfStacks                = order.NumberOfStacks.HasValue ? order.NumberOfStacks.Value : 0;
                var quantityPerEurLoadCarrier     = loadCarrierQuantityPerEurDict[order.LoadCarrierId];
                var quantityPerEurBaseLoadCarrier = order.BaseLoadCarrierId.HasValue
                            ? loadCarrierQuantityPerEurDict[order.BaseLoadCarrierId.Value]
                            : 0;

                return(new OrderMatchQuantity
                    {
                        LoadCarrierQuantity = numberOfStacks * quantityPerEurLoadCarrier * stackHeight,
                        BaseLoadCarrierQuantity = hasBaseLoadCarrier
                                ? numberOfStacks * quantityPerEurBaseLoadCarrier
                                : 0,
                        LoadCarrierStackHeight = stackHeight,
                        NumberOfStacks = numberOfStacks
                    });
            }

            case OrderQuantityType.LoadCarrierQuantity:
            {
                var loadCarrierQuantity       = order.LoadCarrierQuantity.Value;
                var quantityPerEurLoadCarrier = loadCarrierQuantityPerEurDict[order.LoadCarrierId];

                int remainder;
                var numberOfStacks =
                    Math.DivRem(loadCarrierQuantity, quantityPerEurLoadCarrier * stackHeight, out remainder) +
                    (remainder > 0 ? 1 : 0);

                var quantityPerEurBaseLoadCarrier = order.BaseLoadCarrierId.HasValue
                            ? loadCarrierQuantityPerEurDict[order.BaseLoadCarrierId.Value]
                            : 0;

                var baseLoadCarrierQuantity = hasBaseLoadCarrier
                            ? numberOfStacks * quantityPerEurBaseLoadCarrier
                            : 0;

                return(new OrderMatchQuantity()
                    {
                        LoadCarrierQuantity = loadCarrierQuantity,
                        BaseLoadCarrierQuantity = baseLoadCarrierQuantity,
                        LoadCarrierStackHeight = loadCarrierQuantity < stackHeight ? loadCarrierQuantity : stackHeight,
                        NumberOfStacks = numberOfStacks,
                    });
            }

            default:
                throw new ArgumentOutOfRangeException($"Unknown quantity type {order.QuantityType}");
            }
        }
        public async Task <IWrappedResponse> Get()
        {
            var countries = _olmaCountryRepo.FindAll()
                            .AsNoTracking()
                            .ProjectTo <Country>(Mapper.ConfigurationProvider)
                            .FromCache()
                            .ToList();

            var documentStates = _olmaDocumentStateRepo.FindAll()
                                 .AsNoTracking()
                                 .ProjectTo <DocumentState>(Mapper.ConfigurationProvider)
                                 .FromCache()
                                 .ToList();

            var languages = _olmaLanguagesRepo.FindAll()
                            .AsNoTracking()
                            .ProjectTo <Language>(Mapper.ConfigurationProvider)
                            .FromCache()
                            .ToList();

            var loadCarriersServiceResponse = (IWrappedResponse <IEnumerable <LoadCarrier> >)_loadCarriersService.GetAll().Result;
            var loadCarriers = loadCarriersServiceResponse.Data;

            var voucherReasonTypes = _olmaVoucherReasonTypeRepo.FindAll()
                                     .AsNoTracking()
                                     .OrderBy(v => v.Order)
                                     .ProjectTo <VoucherReasonType>(Mapper.ConfigurationProvider)
                                     .FromCache()
                                     .ToList();


            var masterData = new MasterData()
            {
                Countries          = countries,
                DocumentStates     = documentStates,
                Languages          = languages,
                LoadCarriers       = loadCarriers,
                VoucherReasonTypes = voucherReasonTypes
            };

            return(Ok(masterData));
        }
Exemplo n.º 3
0
 public Task <ActionResult <IEnumerable <LoadCarrier> > > Get()
 {
     return(_loadCarriersService.GetAll().Convert <IEnumerable <LoadCarrier> >(this));
 }