Ejemplo n.º 1
0
        private async Task <decimal> RequestQuoteFromAWS(AWSSmartSpotPriceRequest awsModel)
        {
            AssertAWSModelForQuote(awsModel);

            var quotes = await RequestQuoteFromAWS(new List <Guid> {
                Guid.Empty
            }, new List <AWSSmartSpotPriceRequest> {
                awsModel
            });

            var price = quotes.Select(_ => _.Price).Single();

            return(price);
        }
Ejemplo n.º 2
0
        private void AssertAWSModelForQuote(AWSSmartSpotPriceRequest awsModel)
        {
            if (awsModel == null)
            {
                throw new ValidationException($"{ERROR_TYPE}: AWS Model is required");
            }
            if (awsModel.LoadId != Guid.Empty)
            {
                throw new ValidationException($"{ERROR_TYPE}: {nameof(awsModel.LoadId)} is must be empty");
            }
            if (awsModel.TransactionCreate.Equals(DateTime.MinValue))
            {
                throw new ValidationException($"{ERROR_TYPE}: {nameof(awsModel.TransactionCreate)} is required");
            }
            if (string.IsNullOrWhiteSpace(awsModel.TransactionTypeId))
            {
                throw new ValidationException($"{ERROR_TYPE}: {nameof(awsModel.TransactionTypeId)} is required");
            }
            if (string.IsNullOrWhiteSpace(awsModel.Commodity))
            {
                throw new ValidationException($"{ERROR_TYPE}: {nameof(awsModel.Commodity)} is required");
            }
            if (string.IsNullOrWhiteSpace(awsModel.EquipmentId))
            {
                throw new ValidationException($"{ERROR_TYPE}: {nameof(awsModel.EquipmentId)} is required");
            }
            if (awsModel.PkupDate.Equals(DateTime.MinValue))
            {
                throw new ValidationException($"{ERROR_TYPE}: {nameof(awsModel.PkupDate)} is required");
            }

            if (string.IsNullOrWhiteSpace(awsModel.OrigState))
            {
                throw new ValidationException($"{ERROR_TYPE}: {nameof(awsModel.OrigState)} is required");
            }
            if (string.IsNullOrWhiteSpace(awsModel.O3Zip))
            {
                throw new ValidationException($"{ERROR_TYPE}: {nameof(awsModel.O3Zip)} is required");
            }
            if (string.IsNullOrWhiteSpace(awsModel.DestState))
            {
                throw new ValidationException($"{ERROR_TYPE}: {nameof(awsModel.DestState)} is required");
            }
            if (string.IsNullOrWhiteSpace(awsModel.D3Zip))
            {
                throw new ValidationException($"{ERROR_TYPE}: {nameof(awsModel.D3Zip)} is required");
            }
        }
Ejemplo n.º 3
0
        private async Task <AWSSmartSpotPriceRequest> MapFromLoadshopSmartSpotQuoteRequest(LoadshopSmartSpotQuoteRequest request, BaseServiceResponse response)
        {
            AssertRequest(request, response);
            if (!response.IsSuccess)
            {
                return(null);
            }

            var(routeMiles, directMiles) = await GetMileage(request);

            var carriers          = (await _securityService.GetContractedCarriersByPrimaryCustomerIdAsync());
            var carrierCount      = carriers?.Count() ?? 1;
            var distinctScacCount = carriers?.SelectMany(_ => _.CarrierScacs).Distinct().Count() ?? 1;


            var aws = new AWSSmartSpotPriceRequest();

            aws.LoadId            = Guid.Empty;
            aws.TransactionCreate = DateTime.Now;
            aws.TransactionTypeId = "New";
            aws.LoadShopMiles     = routeMiles;
            aws.DirectMiles       = directMiles;
            aws.Stops             = 2;
            aws.Weight            = request.Weight.Value;
            aws.Commodity         = "Misc/Other";
            aws.EquipmentId       = request.EquipmentId;
            aws.PkupDate          = request.PickupDate.Value.Date;
            aws.OrigState         = request.OriginState;
            aws.O3Zip             = request.OriginPostalCode.Length >= 3 ? request.OriginPostalCode.Substring(0, 3) : null;
            aws.DestState         = request.DestinationState;
            aws.D3Zip             = request.DestinationPostalCode.Length >= 3 ? request.DestinationPostalCode.Substring(0, 3) : null;

            aws.NbrSCACsRequest        = distinctScacCount;
            aws.NbrCarriersRequest     = carrierCount;
            aws.NbrSCACsPosted         = 0;
            aws.NbrContractSCACsPosted = 0;
            aws.NbrSCACsHidden         = 0;

            return(aws);
        }
Ejemplo n.º 4
0
        private async Task <AWSSmartSpotPriceRequest> MapFromLoadshopSmartSpotPriceRequestAsync(LoadshopSmartSpotPriceRequest request)
        {
            AssertRequest(request);
            var aws = new AWSSmartSpotPriceRequest();

            var load = await _db.Loads.AsNoTracking()
                       .Include(x => x.LoadStops)
                       .Include(x => x.CarrierScacs)
                       .SingleOrDefaultAsync(x => x.LoadId == request.LoadId);

            if (load == null)
            {
                throw new Exception($"Unable to find load with ID {request.LoadId}.");
            }

            var origin = load.LoadStops.FirstOrDefault(x => x.StopNbr == 1);

            if (origin == null)
            {
                throw new Exception("Unable to find origin pickup stop");
            }
            var dest = load.LoadStops.FirstOrDefault(x => x.StopNbr == load.Stops);

            if (dest == null)
            {
                throw new Exception("Unable to find destination delivery stop");
            }

            aws.LoadId            = request.LoadId;
            aws.TransactionCreate = DateTime.Now;
            aws.TransactionTypeId = load.LatestTransactionTypeId;
            aws.LoadShopMiles     = load.Miles;
            aws.DirectMiles       = load.DirectMiles;
            aws.Stops             = load.LoadStops.Count;
            aws.Weight            = request.Weight;
            aws.Commodity         = request.Commodity;
            aws.EquipmentId       = request.EquipmentId;
            aws.PkupDate          = origin.LateDtTm;
            aws.OrigState         = origin.State;
            aws.OriginZip         = origin.PostalCode;
            aws.O3Zip             = (origin.PostalCode != null && origin.PostalCode.Length >= 3) ? origin.PostalCode.Substring(0, 3) : null;
            aws.DestState         = dest.State;
            aws.DestZip           = dest.PostalCode;
            aws.D3Zip             = (dest.PostalCode != null && dest.PostalCode.Length >= 3) ? dest.PostalCode.Substring(0, 3) : null;

            var carrierScacs = _db.CarrierScacs.Where(x => request.CarrierIds.Contains(x.CarrierId)).Select(x => x.Scac).Distinct().ToList();

            aws.NbrSCACsRequest    = carrierScacs.Count;
            aws.NbrCarriersRequest = request.CarrierIds.Count;

            aws.NbrSCACsPosted = load.CarrierScacs
                                 .Where(x => x.ContractRate == null || x.ContractRate.Value <= load.LineHaulRate)
                                 .Select(x => x.Scac)
                                 .Distinct()
                                 .Count();

            aws.NbrContractSCACsPosted = load.CarrierScacs
                                         .Where(x => x.ContractRate != null && x.ContractRate.Value <= load.LineHaulRate)
                                         .Select(x => x.Scac)
                                         .Distinct()
                                         .Count();

            aws.NbrSCACsHidden = load.CarrierScacs
                                 .Where(x => x.ContractRate != null && x.ContractRate.Value > load.LineHaulRate)
                                 .Select(x => x.Scac)
                                 .Distinct()
                                 .Count();

            return(aws);
        }