public override Attempt<IShipmentRateQuote> QuoteShipment(IShipment shipment)
        {
            try
            {
                var visitor = new FoaShipmentLineItemVisitor() { UseOnSalePriceIfOnSale = false };

                shipment.Items.Accept(visitor);

                if (visitor.TotalPrice >= _processorSettings.Amount)
                {
                    return Attempt<IShipmentRateQuote>.Succeed(new ShipmentRateQuote(shipment, ShipMethod) { Rate = 0 });
                }
                else
                {
                    return Attempt<IShipmentRateQuote>.Succeed(new ShipmentRateQuote(shipment, ShipMethod) { Rate = 100 });
                }
            }
            catch (Exception ex)
            {
                return Attempt<IShipmentRateQuote>.Fail(
                           new Exception("An error occured during your request : " +
                                                        ex.Message +
                                                        " Please contact your administrator or try again."));
            }
        }
        public Attempt<IShipmentRateQuote> CalculatePrice(IShipment shipment, IShipMethod shipMethod, decimal totalWeight, int quantity, IShipProvince province)
        {
            // First sum up the total weight for the shipment.
            // We're assumning that a custom order line property 
            // was set on the order line prior when the product was added to the order line.

            var shippingPrice = 0M;
            try
            {
                var service = new RateService {Url = "https://wsbeta.fedex.com:443/web-services/rate"};
                
                var reply = service.getRates(RateRequest(shipment, totalWeight, quantity));
                                                            
                if (reply.HighestSeverity == NotificationSeverityType.SUCCESS || reply.HighestSeverity == NotificationSeverityType.NOTE || reply.HighestSeverity == NotificationSeverityType.WARNING)
                {
                    var collection = BuildDeliveryOptions(reply, shipment);

                    var firstCarrierRate = collection.FirstOrDefault(option => option.Service.Contains(shipMethod.ServiceCode.Split('-').First()));
                    if (firstCarrierRate != null)
                        shippingPrice = firstCarrierRate.Rate;
                }

            }
            catch (Exception ex)
            {
                return Attempt<IShipmentRateQuote>.Fail(
                        new Exception("An error occured during your request : " +
                                                     ex.Message +
                                                     " Please contact your administrator or try again."));
            }

            return Attempt<IShipmentRateQuote>.Succeed(new ShipmentRateQuote(shipment, shipMethod) { Rate = shippingPrice });
        }
        public override Attempt<IShipmentRateQuote> QuoteShipment(IShipment shipment)
        {
            try
            {
                var visitor = new FoaShipmentLineItemVisitor() { UseOnSalePriceIfOnSale = false };

                shipment.Items.Accept(visitor);

                if (visitor.TotalPrice >= _processorSettings.Amount)
                {
                    return Attempt<IShipmentRateQuote>.Succeed(new ShipmentRateQuote(shipment, ShipMethod) { Rate = 0 });
                }
                else
                {
                    // TODO shouldn't this just fail so that a different method is selected or have a configurable default rate.
                    return Attempt<IShipmentRateQuote>.Succeed(new ShipmentRateQuote(shipment, ShipMethod) { Rate = 100 });
                }
            }
            catch (Exception ex)
            {
                return Attempt<IShipmentRateQuote>.Fail(
                           new Exception("An error occured during your request : " +
                                                        ex.Message +
                                                        " Please contact your administrator or try again."));
            }
        }
Beispiel #4
0
        /// <summary>
        /// The perform task.
        /// </summary>
        /// <param name="value">
        /// The value.
        /// </param>
        /// <returns>
        /// The <see cref="Attempt"/>.
        /// </returns>
        public override Attempt<IShipment> PerformTask(IShipment value)
        {
            Guid orderStatusKey;

            // not fulfilled
            if (Order.ShippableItems().All(x => ((OrderLineItem)x).ShipmentKey == null))
            {
                orderStatusKey = Core.Constants.DefaultKeys.OrderStatus.NotFulfilled;
                return this.SaveOrderStatus(value, orderStatusKey);
            }

            if (Order.ShippableItems().Any(x => ((OrderLineItem)x).ShipmentKey == null))
            {
                orderStatusKey = Core.Constants.DefaultKeys.OrderStatus.Open;
                return this.SaveOrderStatus(value, orderStatusKey);
            }

            // now we need to look at all of the shipments to make sure the shipment statuses are either
            // shipped or delivered.  If either of those two, we will consider the shipment as 'Fulfilled',
            // otherwise the shipment will remain in the open status
            var shipmentKeys = Order.ShippableItems().Select(x => ((OrderLineItem)x).ShipmentKey.GetValueOrDefault()).Distinct();
            var shipments = _shipmentService.GetByKeys(shipmentKeys);
            orderStatusKey =
                shipments.All(x =>
                    x.ShipmentStatusKey.Equals(Core.Constants.DefaultKeys.ShipmentStatus.Delivered)
                    || x.ShipmentStatusKey.Equals(Core.Constants.DefaultKeys.ShipmentStatus.Shipped)) ?
                        Core.Constants.DefaultKeys.OrderStatus.Fulfilled :
                        Core.Constants.DefaultKeys.OrderStatus.Open;

            return this.SaveOrderStatus(value, orderStatusKey);
        }
 public virtual ShippingRate GetRate(IShipment shipment, ShippingMethodInfoModel shippingMethodInfoModel, IMarket currentMarket)
 {
     var type = Type.GetType(shippingMethodInfoModel.ClassName);
     var shippingGateway = (IShippingGateway)Activator.CreateInstance(type, currentMarket);
     string message = null;
     return shippingGateway.GetRate(shippingMethodInfoModel.MethodId, (Shipment)shipment, ref message);
 }
Beispiel #6
0
        public List<IShippingRate> RateShipment(IShipment shipment)
        {
            int totalItems = 0;

            foreach (IShippable item in shipment.Items)
            {
                totalItems += item.QuantityOfItemsInBox;
            }


            decimal amountPerItem = 0;
            if (Settings != null)
            {
                if (Settings.GetLevels() != null)
                {
                    amountPerItem = RateTableLevel.FindRateFromLevels(totalItems, Settings.GetLevels());
                }
            }

            ShippingRate r = new ShippingRate();
            r.ServiceId = this.Id;
            r.EstimatedCost = amountPerItem * totalItems;

            List<IShippingRate> rates = new List<IShippingRate>();
            rates.Add(r);
            
            return rates;
        }
        public List<IShippingRate> RateShipment(IShipment shipment)
        {
            decimal totalValue = 0;

            foreach (IShippable item in shipment.Items)
            {
                totalValue += item.BoxValue;
            }


            decimal amount = 0;
            if (Settings != null)
            {
                if (Settings.GetLevels() != null)
                {
                    amount = RateTableLevel.FindRateFromLevels(totalValue, Settings.GetLevels());
                }
            }

            ShippingRate r = new ShippingRate();
            r.ServiceId = this.Id;
            r.EstimatedCost = amount;

            List<IShippingRate> rates = new List<IShippingRate>();
            rates.Add(r);
            
            return rates;
        }
        public Attempt<IShipmentRateQuote> CalculatePrice(IShipment shipment, IShipMethod shipMethod, decimal totalWeight, IShipProvince province)
        {
            // First sum up the total weight for the shipment.
            // We're assumning that a custom order line property 
            // was set on the order line prior when the product was added to the order line.

            var shippingPrice = 0M;
            try
            {
                var http = new UpsHttpRequestHandler();
                var rateXml = http.Post(RateRequest(shipment, totalWeight));

                var collection = UpsParseRates(rateXml);

                var firstCarrierRate = collection.FirstOrDefault(option => option.Service == shipMethod.Name);
                if (firstCarrierRate != null)
                    shippingPrice = firstCarrierRate.Rate;
            }
            catch (Exception ex)
            {
                return Attempt<IShipmentRateQuote>.Fail(
                        new Exception("An error occured during your request : " +
                                                     ex.Message +
                                                     " Please contact your administrator or try again."));
            }

            return Attempt<IShipmentRateQuote>.Succeed(new ShipmentRateQuote(shipment, shipMethod) { Rate = shippingPrice });
        }
Beispiel #9
0
 public static Shipment CloneAddressesFromInterface(IShipment source)
 {
     Shipment result = new Shipment();
     result.DestinationAddress = MerchantTribe.Web.Geography.SimpleAddress.CloneAddress(source.DestinationAddress);
     result.SourceAddress = MerchantTribe.Web.Geography.SimpleAddress.CloneAddress(source.SourceAddress);
     return result;
 }
Beispiel #10
0
        // Gets all rates filtered by service settings
        private List<IShippingRate> GetUPSRatesForShipment(IShipment shipment)
        {
            List<IShippingRate> rates = new List<IShippingRate>();

            List<IShippingRate> allrates = GetAllShippingRatesForShipment(shipment);

            // Filter all rates by just the ones we want
            List<IServiceCode> codefilters = this.Settings.ServiceCodeFilter;
            foreach (IShippingRate rate in allrates)
            {
                if (this.Settings.GetAllRates || codefilters.Count < 1)
                {
                    rates.Add(rate);
                    continue;
                }
                else
                {
                    if (codefilters.Where(y => y.Code == (rate.ServiceCodes.TrimStart('0'))).Count() > 0)
                    {
                        rates.Add(rate);
                        continue;
                    }
                }
            }

            return rates;
        }
        /// <summary>
        /// The build.
        /// </summary>
        /// <param name="shipment">
        /// The shipment.
        /// </param>
        /// <param name="contacts">
        /// The collection of contact addresses
        /// </param>
        /// <returns>
        /// The <see cref="IShipmentResultNotifyModel"/>.
        /// </returns>
        public IShipmentResultNotifyModel Build(IShipment shipment, IEnumerable<string> contacts)
        {
            var notifyModel = new ShipmentResultNotifyModel()
                                  {
                                      Shipment = shipment,
                                      Contacts = contacts == null ? new string[] { } : contacts.ToArray()
                                    };

            var item = shipment.Items.FirstOrDefault(x => !x.ContainerKey.Equals(Guid.Empty));
            if (item != null)
            {
                var orderKey = item.ContainerKey;

                var order = _orderService.GetByKey(orderKey);

                if (order != null)
                {
                    var invoice = _invoiceService.GetByKey(order.InvoiceKey);
                    if (invoice != null)
                    {
                        notifyModel.Invoice = invoice;
                        if (invoice.Items.Any())
                        {
                            var currencyCode =
                                invoice.Items.First()
                                    .ExtendedData.GetValue(Core.Constants.ExtendedDataKeys.CurrencyCode);
                            var currency = _storeSettingService.GetCurrencyByCode(currencyCode);
                            notifyModel.CurrencySymbol = currency.Symbol;
                        }
                    }
                }
            }

            return notifyModel;
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="DefaultShipmentRateQuoteStrategy"/> class.
 /// </summary>
 /// <param name="shipment">
 /// The shipment.
 /// </param>
 /// <param name="shippingGatewayMethods">
 /// The shipping gateway methods.
 /// </param>
 /// <param name="runtimeCache">
 /// The runtime cache.
 /// </param>
 public DefaultShipmentRateQuoteStrategy(
     IShipment shipment,
     IShippingGatewayMethod[] shippingGatewayMethods,
     IRuntimeCacheProvider runtimeCache)
     : base(shipment, shippingGatewayMethods, runtimeCache)
 {
 }
        /// <summary>
        /// The perform task.
        /// </summary>
        /// <param name="value">
        /// The value.
        /// </param>
        /// <returns>
        /// The <see cref="Attempt"/>.
        /// </returns>
        public override Attempt<IShipment> PerformTask(IShipment value)
        {
            var trackableItems = Order.InventoryTrackedItems().Where(x => KeysToShip.Contains(x.Key)).ToArray();

            var variants = _productVariantService.GetByKeys(trackableItems.Select(x => x.ExtendedData.GetProductVariantKey())).ToArray();

            if (variants.Any())
            {
                foreach (var item in trackableItems)
                {
                    var variant = variants.FirstOrDefault(x => x.Key == item.ExtendedData.GetProductVariantKey());
                    if (variant == null) return Attempt<IShipment>.Fail(new NullReferenceException("A ProductVariant reference in the order could not be found"));

                    var inventory = variant.CatalogInventories.FirstOrDefault(x => x.CatalogKey == item.ExtendedData.GetWarehouseCatalogKey());
                    if (inventory == null) return Attempt<IShipment>.Fail(new NullReferenceException("An inventory record could not be found for an order line item"));

                    inventory.Count -= item.Quantity;
                }

                if (trackableItems.Any()) _productVariantService.Save(variants);
            }

            // persist the shipment and update the line items
            if (value.ShipMethodKey == Guid.Empty) value.ShipMethodKey = null;
            _shipmentService.Save(value);            

            return Attempt<IShipment>.Succeed(value);
        }
Beispiel #14
0
        public static ShippingRate RatePackage(FedExGlobalServiceSettings globals,
                                       MerchantTribe.Web.Logging.ILogger logger,
                                       FedExServiceSettings settings,
                                       IShipment package)
        {
            ShippingRate result = new ShippingRate();

                // Get ServiceType
                ServiceType currentServiceType = ServiceType.FEDEXGROUND;
                currentServiceType = (ServiceType)settings.ServiceCode;

                // Get PackageType
                PackageType currentPackagingType = PackageType.YOURPACKAGING;
                currentPackagingType = (PackageType)settings.Packaging;

                // Set max weight by service
                CarrierCodeType carCode = GetCarrierCode(currentServiceType);

                result.EstimatedCost = RateSinglePackage(globals, 
                                                        logger,
                                                        package, 
                                                        currentServiceType, 
                                                        currentPackagingType, 
                                                        carCode);

            return result;
        }
 public override Attempt<IShipment> PerformTask(IShipment value)
 {
     return Order.ShippableItems().All(x => ((OrderLineItem)x).ShipmentKey == null)
         ? SaveOrderStatus(value, Constants.DefaultKeys.OrderStatus.NotFulfilled)
         : SaveOrderStatus(value, Order.ShippableItems().All(x => ((OrderLineItem) x).ShipmentKey != null)
             ? Constants.DefaultKeys.OrderStatus.Fulfilled
             : Constants.DefaultKeys.OrderStatus.BackOrder);
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="ShipmentRateQuoteStrategyBase"/> class.
        /// </summary>
        /// <param name="shipment">
        /// The shipment.
        /// </param>
        /// <param name="shippingGatewayMethods">
        /// The shipping gateway methods.
        /// </param>
        /// <param name="runtimeCache">
        /// The runtime cache.
        /// </param>
        protected ShipmentRateQuoteStrategyBase(IShipment shipment, IShippingGatewayMethod[] shippingGatewayMethods, IRuntimeCacheProvider runtimeCache)
        {
            Mandate.ParameterNotNull(shipment, "shipment");
            Mandate.ParameterNotNull(shippingGatewayMethods, "gatewayShipMethods");
            Mandate.ParameterNotNull(runtimeCache, "runtimeCache");

            _shipment = shipment;
            _shippingGatewayMethods = shippingGatewayMethods;
            _runtimeCache = runtimeCache;
        }
        public List<IShippingRate> RateShipment(IShipment shipment)
        {                        
            ShippingRate r = new ShippingRate();
            r.ServiceId = this.Id;
            r.EstimatedCost = Settings.Amount;

            List<IShippingRate> rates = new List<IShippingRate>();
            rates.Add(r);
            
            return rates;
        }
        private Attempt<IShipment> SaveOrderStatus(IShipment shipment, Guid orderStatusKey)
        {
            var orderStatus = _orderService.GetOrderStatusByKey(orderStatusKey);

            if (orderStatus == null) return Attempt<IShipment>.Fail(new NullReferenceException("Order status was not found"));

            Order.OrderStatus = orderStatus;
            _orderService.Save(Order);

            return Attempt<IShipment>.Succeed(shipment);
        }
Beispiel #19
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ShipmentRateQuote"/> class.
        /// </summary>
        /// <param name="shipment">
        /// The shipment.
        /// </param>
        /// <param name="shipMethod">
        /// The ship method.
        /// </param>
        /// <param name="extendedData">
        /// The extended data.
        /// </param>
        public ShipmentRateQuote(IShipment shipment, IShipMethod shipMethod, ExtendedDataCollection extendedData)
        {
            Mandate.ParameterNotNull(shipment, "shipment");
            Mandate.ParameterNotNull(shipMethod, "shipMethod");
            Mandate.ParameterNotNull(extendedData, "extendedData");

            shipment.ShipMethodKey = shipMethod.Key;

            Shipment = shipment;
            ShipMethod = shipMethod;
            ExtendedData = extendedData;
        }
        public override Attempt<IShipmentRateQuote> QuoteShipment(IShipment shipment)
        {
            try
            {
                // TODO this should be made configurable
                var visitor = new FedExShipmentLineItemVisitor() { UseOnSalePriceIfOnSale = false };

                shipment.Items.Accept(visitor);

                var province = ShipMethod.Provinces.FirstOrDefault(x => x.Code == shipment.ToRegion);

                var shippingPrice = 0M;
                try
                {
                    var service = new RateService { Url = "https://wsbeta.fedex.com:443/web-services/rate" };

                    var collection = GetCollectionFromCache(shipment);
                    if (collection == null)
                    {
                        var reply = service.getRates(RateRequest(shipment, visitor.TotalWeight, visitor.Quantity));



                        if (reply.HighestSeverity == NotificationSeverityType.SUCCESS || reply.HighestSeverity == NotificationSeverityType.NOTE || reply.HighestSeverity == NotificationSeverityType.WARNING)
                        {
                            collection = BuildDeliveryOptions(reply, shipment);

                            _runtimeCache.InsertCacheItem(MakeCacheKey(shipment), () => collection);       
                        }
                    }

                    var firstCarrierRate = collection.FirstOrDefault(option => option.Service.Contains(_shipMethod.ServiceCode));
                    if (firstCarrierRate != null)
                        shippingPrice = firstCarrierRate.Rate;
                }
                catch (Exception ex)
                {
                    return Attempt<IShipmentRateQuote>.Fail(
                            new Exception("An error occured during your request : " +
                                                         ex.Message +
                                                         " Please contact your administrator or try again."));
                }

                return Attempt<IShipmentRateQuote>.Succeed(new ShipmentRateQuote(shipment, _shipMethod) { Rate = shippingPrice });
            }
            catch (Exception ex)
            {
                return Attempt<IShipmentRateQuote>.Fail(
                           new Exception("An error occured during your request : " +
                                                        ex.Message +
                                                        " Please contact your administrator or try again."));
            }
        }
 public bool ShipmentHasAddresses(IShipment shipment)
 {
     if (shipment.SourceAddress == null)
     {
         return false;
     }
     if (shipment.DestinationAddress == null)
     {
         return false;
     }
     return true;
 }
        public override Attempt<IShipmentRateQuote> QuoteShipment(IShipment shipment)
        {
            // TODO this should be made configurable
            var visitor = new FixedRateShipmentLineItemVisitor { UseOnSalePriceIfOnSale = false };

            shipment.Items.Accept(visitor);

            var province = ShipMethod.Provinces.FirstOrDefault(x => x.Code == shipment.ToRegion);

            return _quoteType == QuoteType.VaryByWeight
                ? CalculateVaryByWeight(shipment, visitor.TotalWeight, province)
                : CalculateVaryByPrice(shipment, visitor.TotalPrice, province);
        }
        /// <summary>
        /// The perform task.
        /// </summary>
        /// <param name="value">
        /// The value.
        /// </param>
        /// <returns>
        /// The <see cref="Attempt"/>.
        /// </returns>
        public override Attempt<IShipment> PerformTask(IShipment value)
        {
            var unfulfilled = Order.UnfulfilledItems(MerchelloContext).Where(x => x.BackOrder == false && KeysToShip.Contains(x.Key)).ToArray();

            if (unfulfilled.Count() != Order.Items.Count(x => KeysToShip.Contains(x.Key))) return Attempt<IShipment>.Fail(new InvalidOperationException("The order contains items that are either on back order or cannot be shipped."));

            foreach (var item in unfulfilled)
            {
                value.Items.Add(item);
            }

            return Attempt<IShipment>.Succeed(value);
        }
        public override Attempt<IShipmentRateQuote> QuoteShipment(IShipment shipment)
        {
            try
            {
                // TODO this should be made configurable
                var visitor = new UPSShipmentLineItemVisitor() { UseOnSalePriceIfOnSale = false };

                shipment.Items.Accept(visitor);

                var province = ShipMethod.Provinces.FirstOrDefault(x => x.Code == shipment.ToRegion);
                                                  
                var collection = GetCollectionFromCache(shipment);

                if (collection == null)
                {
                    try
                    {
                        var http = new UpsHttpRequestHandler();
                        var rateXml = http.Post(RateRequest(shipment, visitor));

                        collection = UpsParseRates(rateXml);

                        _runtimeCache.InsertCacheItem(MakeCacheKey(shipment), () => collection);  
                    }
                    catch (Exception ex)
                    {
                        return Attempt<IShipmentRateQuote>.Fail(
                            new Exception("An error occured during your request : " +
                                          ex.Message +
                                          " Please contact your administrator or try again."));
                    }

                }
                var shippingPrice = 0M;

                var firstCarrierRate = collection.FirstOrDefault(option => option.Service == _shipMethod.ServiceCode);
                if (firstCarrierRate != null)
                    shippingPrice = firstCarrierRate.Rate;
                
                return Attempt<IShipmentRateQuote>.Succeed(new ShipmentRateQuote(shipment, _shipMethod) { Rate = shippingPrice });


            }
            catch (Exception ex)
            {
                return Attempt<IShipmentRateQuote>.Fail(
                           new Exception("An error occured during your request : " +
                                                        ex.Message +
                                                        " Please contact your administrator or try again."));
            }
        }
 /// <summary>
 /// The to order confirmation notification.
 /// </summary>
 /// <param name="paymentResult">
 /// The payment result.
 /// </param>
 /// <param name="contacts">
 /// The contacts.
 /// </param>
 /// <param name="shipment">
 /// The shipment.
 /// </param>
 /// <param name="shipMethod">
 /// The ship Method.
 /// </param>
 /// <param name="currencySymbol">
 /// The currency Symbol.
 /// </param>
 /// <returns>
 /// The <see cref="IPaymentResultMonitorModel"/>.
 /// </returns>
 public static IPaymentResultMonitorModel ToOrderConfirmationNotification(this IPaymentResult paymentResult, IEnumerable<string> contacts, IShipment shipment = null, IShipMethod shipMethod = null, string currencySymbol = "")
 {
     return new PaymentResultNotifyModel()
         {
             PaymentSuccess = paymentResult.Payment.Success,
             Payment = paymentResult.Payment.Success ? paymentResult.Payment.Result : null,
             Invoice = paymentResult.Invoice,
             Contacts = contacts.ToArray(),
             Shipment = shipment,
             ShipMethod = shipMethod,
             CurrencySymbol = currencySymbol,
             ApproveOrderCreation = paymentResult.ApproveOrderCreation
         };
 }
        private RateRequest RateRequest(IShipment shipment, decimal totalWeight, int quantity)
        {
            // Build the RateRequest
            var request = new RateRequest
            {
                WebAuthenticationDetail =
                    new WebAuthenticationDetail
                    {
                        UserCredential =
                            new WebAuthenticationCredential
                            {
                                Key = "fhbqZrPFKWRe2Ndf",
                                Password = "******"
                            }
                    }
            };

            if (usePropertyFile()) //Set values from a file for testing purposes
            {
                request.WebAuthenticationDetail.UserCredential.Key = getProperty("key");
                request.WebAuthenticationDetail.UserCredential.Password = getProperty("password");
            }

            request.ClientDetail = new ClientDetail {AccountNumber = "510087569", MeterNumber = "118628262"};
            if (usePropertyFile()) //Set values from a file for testing purposes
            {
                request.ClientDetail.AccountNumber = getProperty("accountnumber");
                request.ClientDetail.MeterNumber = getProperty("meternumber");
            }

            request.TransactionDetail = new TransactionDetail
            {
                CustomerTransactionId = "***Rate Available Services v14 Request using VC#***"
            };

            request.Version = new VersionId();

            request.ReturnTransitAndCommit = true;
            request.ReturnTransitAndCommitSpecified = true;

            SetShipmentDetails(request, shipment, totalWeight, quantity);

            return request;
        }
Beispiel #27
0
        public List<IShippingRate> RateShipment(IShipment shipment)
        {
            _Messages.Clear();

            List<IShippingRate> result = new List<IShippingRate>();

            bool hasErrors = false;


            int serviceCode = Settings.ServiceCode;
            int packaging = Settings.Packaging;

            try
            {
                List<Shipment> optimizedPackages = this.OptimizeSingleGroup(shipment);

                if (optimizedPackages.Count > 0)
                {
                    result = RatePackages(optimizedPackages);
                }
                else
                {
                    if (this.GlobalSettings.DiagnosticsMode)
                    {
                        _Logger.LogMessage("No packages found to rate for FedEx");
                    }
                }

                
            }
            catch (Exception ex)
            {
                _Logger.LogException(ex);
                ShippingServiceMessage m = new ShippingServiceMessage();
                m.SetError("Exception", ex.Message + " | " + ex.StackTrace);
                _Messages.Add(m);
            }

            if (hasErrors)
            {
                result = new List<IShippingRate>();
            }            
            return result;
        }
        /// <summary>
        /// Performs the actual work of performing the shipment rate quote for the shipment based on what items are in the shipment.
        /// </summary>
        /// <param name="shipment">
        /// The shipment.
        /// </param>
        /// <returns>
        /// An Umbraco <see cref="Attempt"/>.
        /// </returns>
        public override Attempt<IShipmentRateQuote> QuoteShipment(IShipment shipment)
        {
            var itemHeavyCount = 0;

            foreach (ILineItem item in shipment.Items)
            {
                var isHeavyItem = false;
                bool.TryParse(item.ExtendedData.GetValue("IsOverweight"), out isHeavyItem);

                if (isHeavyItem)
                {
                    itemHeavyCount++;
                }
            }

            // each item gets an added charge, instead of one charge regardless of how many items there are
            var shippingRate = itemHeavyCount * _isHeavyShippingRate;

            return Attempt<IShipmentRateQuote>.Succeed(new ShipmentRateQuote(shipment, this.ShipMethod){Rate = shippingRate});
        }
        public List<IShippingRate> RateShipment(IShipment shipment)
        {
            int totalItems = 0;

            foreach (IShippable item in shipment.Items)
            {
                totalItems += item.QuantityOfItemsInBox;
            }

            decimal perItemAmount = Settings.Amount;

            ShippingRate r = new ShippingRate();
            r.ServiceId = this.Id;
            r.EstimatedCost = perItemAmount * totalItems;

            List<IShippingRate> rates = new List<IShippingRate>();
            rates.Add(r);
            
            return rates;
        }
Beispiel #30
0
        /// <summary>
        /// Saves a single <see cref="IShipment"/> object
        /// </summary>
        /// <param name="shipment">The <see cref="IShipment"/> to save</param>
        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events</param>
        public void Save(IShipment shipment, bool raiseEvents = true)
        {
            if (raiseEvents)
                if (Saving.IsRaisedEventCancelled(new SaveEventArgs<IShipment>(shipment), this))
                {
                    ((Shipment)shipment).WasCancelled = true;
                    return;
                }

            using (new WriteLock(Locker))
            {
                var uow = _uowProvider.GetUnitOfWork();
                using (var repository = _repositoryFactory.CreateShipmentRepository(uow))
                {
                    repository.AddOrUpdate(shipment);
                    uow.Commit();
                }
            }

            if (raiseEvents) Saved.RaiseEvent(new SaveEventArgs<IShipment>(shipment), this);
        }
Beispiel #31
0
        /// <summary>
        /// Adds shipment replaceable patters.
        /// </summary>
        /// <param name="shipment">
        /// The shipment.
        /// </param>
        /// <param name="currencySymbol">
        /// The currency Symbol.
        /// </param>
        /// <returns>
        /// The <see cref="IEnumerable{IReplaceablePattern}"/>.
        /// </returns>
        internal static IEnumerable <IReplaceablePattern> ReplaceablePatterns(this IShipment shipment, string currencySymbol)
        {
            var patterns = new List <IReplaceablePattern>
            {
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShippedDate", shipment.ShippedDate.FormatAsStoreDate()),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToOrganization", shipment.ToOrganization),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToName", shipment.ToName),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToAddress1", shipment.ToAddress1),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToAddress2", shipment.ToAddress2),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToLocality", shipment.ToLocality),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToRegion", shipment.ToRegion),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToPostalCode", shipment.ToPostalCode),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToCountryCode", shipment.ToCountryCode),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToEmail", shipment.Email),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToPhone", shipment.Phone),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToOrganization", shipment.ToOrganization),
                ReplaceablePattern.GetConfigurationReplaceablePattern("TrackingCode", shipment.TrackingCode)
            };

            patterns.AddRange(shipment.LineItemReplaceablePatterns(currencySymbol));

            return(patterns.Where(x => x != null));
        }
        public Attempt <IShipmentRateQuote> CalculatePrice(IShipment shipment, IShipMethod shipMethod, decimal totalWeight, int quantity, IShipProvince province)
        {
            // First sum up the total weight for the shipment.
            // We're assumning that a custom order line property
            // was set on the order line prior when the product was added to the order line.

            var shippingPrice = 0M;

            try
            {
                var service = new RateService {
                    Url = "https://wsbeta.fedex.com:443/web-services/rate"
                };

                var reply = service.getRates(RateRequest(shipment, totalWeight, quantity));

                if (reply.HighestSeverity == NotificationSeverityType.SUCCESS || reply.HighestSeverity == NotificationSeverityType.NOTE || reply.HighestSeverity == NotificationSeverityType.WARNING)
                {
                    var collection = BuildDeliveryOptions(reply, shipment);

                    var firstCarrierRate = collection.FirstOrDefault(option => option.Service.Contains(shipMethod.ServiceCode.Split('-').First()));
                    if (firstCarrierRate != null)
                    {
                        shippingPrice = firstCarrierRate.Rate;
                    }
                }
            }
            catch (Exception ex)
            {
                return(Attempt <IShipmentRateQuote> .Fail(
                           new Exception("An error occured during your request : " +
                                         ex.Message +
                                         " Please contact your administrator or try again.")));
            }

            return(Attempt <IShipmentRateQuote> .Succeed(new ShipmentRateQuote(shipment, shipMethod) { Rate = shippingPrice }));
        }
Beispiel #33
0
        private List <IShippingRate> GetAllShippingRatesForShipment(IShipment shipment)
        {
            var rates = new List <IShippingRate>();

            var hasErrors = false;

            try
            {
                var packagesToRate = OptimizePackages(shipment);

                if (packagesToRate.Count > 0)
                {
                    rates = RatePackages(packagesToRate);
                }
                else
                {
                    if (GlobalSettings.DiagnosticsMode)
                    {
                        _Logger.LogMessage("No Packaged to Rate for US Postal Service: Code 795");
                    }
                }
            }

            catch (Exception ex)
            {
                _Logger.LogException(ex);
                var m = new ShippingServiceMessage();
                m.SetError("Exception", ex.Message + " | " + ex.StackTrace);
                _Messages.Add(m);
            }

            if (hasErrors)
            {
                rates = new List <IShippingRate>();
            }
            return(rates);
        }
        public void RecreateLineItemsBasedOnShipments(ICart cart, IEnumerable <CartItemViewModel> cartItems, IEnumerable <AddressModel> addresses)
        {
            var form  = cart.GetFirstForm();
            var items = cartItems
                        .GroupBy(x => new { x.AddressId, x.Code, x.IsGift })
                        .Select(x => new
            {
                Code      = x.Key.Code,
                AddressId = x.Key.AddressId,
                Quantity  = x.Count(),
                IsGift    = x.Key.IsGift
            });

            foreach (var shipment in form.Shipments)
            {
                shipment.LineItems.Clear();
            }

            form.Shipments.Clear();

            foreach (var address in addresses)
            {
                IShipment shipment = _orderGroupFactory.CreateShipment(cart);
                form.Shipments.Add(shipment);
                shipment.ShippingAddress = _addressBookService.ConvertToAddress(cart, address);

                foreach (var item in items.Where(x => x.AddressId == address.AddressId))
                {
                    var lineItem = _orderGroupFactory.CreateLineItem(item.Code, cart);
                    lineItem.IsGift   = item.IsGift;
                    lineItem.Quantity = item.Quantity;
                    shipment.LineItems.Add(lineItem);
                }
            }

            ValidateCart(cart);
        }
        public List <IShippingRate> RateShipment(IShipment shipment)
        {
            decimal totalValue = 0;

            foreach (var item in shipment.Items)
            {
                totalValue += item.BoxValue;
            }

            decimal amount = 0;

            if (Settings != null)
            {
                if (Settings.GetLevels() != null)
                {
                    var level = RateTableLevel.FindRateForLevel(totalValue, Settings.GetLevels());
                    if (level != null && level.Rate >= 0)
                    {
                        amount = level.Rate;
                        var percent = totalValue * (level.Percent / 100);
                        amount += percent;
                    }
                }
            }

            var r = new ShippingRate
            {
                ServiceId     = Id,
                EstimatedCost = amount
            };

            var rates = new List <IShippingRate> {
                r
            };

            return(rates);
        }
        /// <summary>
        /// The perform task.
        /// </summary>
        /// <param name="value">
        /// The value.
        /// </param>
        /// <returns>
        /// The <see cref="Attempt"/>.
        /// </returns>
        public override Attempt <IShipment> PerformTask(IShipment value)
        {
            var trackableItems = Order.InventoryTrackedItems().Where(x => KeysToShip.Contains(x.Key)).ToArray();

            var variants = _productVariantService.GetByKeys(trackableItems.Select(x => x.ExtendedData.GetProductVariantKey())).ToArray();

            if (variants.Any())
            {
                foreach (var item in trackableItems)
                {
                    var variant = variants.FirstOrDefault(x => x.Key == item.ExtendedData.GetProductVariantKey());
                    if (variant == null)
                    {
                        return(Attempt <IShipment> .Fail(new NullReferenceException("A ProductVariant reference in the order could not be found")));
                    }

                    var inventory = variant.CatalogInventories.FirstOrDefault(x => x.CatalogKey == item.ExtendedData.GetWarehouseCatalogKey());
                    if (inventory == null)
                    {
                        return(Attempt <IShipment> .Fail(new NullReferenceException("An inventory record could not be found for an order line item")));
                    }

                    inventory.Count -= item.Quantity;
                }

                _productVariantService.Save(variants);
            }

            // persist the shipment and update the line items
            if (value.ShipMethodKey == Guid.Empty)
            {
                value.ShipMethodKey = null;
            }
            _shipmentService.Save(value);

            return(Attempt <IShipment> .Succeed(value));
        }
        /// <summary>
        /// Gets a collection of <see cref="IReplaceablePattern"/> for the invoice
        /// </summary>
        /// <param name="invoice">
        /// The invoice.
        /// </param>
        /// <returns>
        /// The collection of replaceable patterns
        /// </returns>
        internal static IEnumerable <IReplaceablePattern> ReplaceablePatterns(this IShipment shipment)
        {
            // TODO localization needed on pricing and datetime
            var patterns = new List <IReplaceablePattern>
            {
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShippedDate", shipment.ShippedDate.ToShortDateString()),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToOrganization", shipment.ToOrganization),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToName", shipment.ToName),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToAddress1", shipment.ToAddress1),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToAddress2", shipment.ToAddress2),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToLocality", shipment.ToLocality),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToRegion", shipment.ToRegion),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToPostalCode", shipment.ToPostalCode),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToCountryCode", shipment.ToCountryCode),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToEmail", shipment.Email),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToPhone", shipment.Phone),
                ReplaceablePattern.GetConfigurationReplaceablePattern("ShipToOrganization", shipment.ToOrganization),
                ReplaceablePattern.GetConfigurationReplaceablePattern("TrackingCode", shipment.TrackingCode)
            };

            patterns.AddRange(shipment.LineItemReplaceablePatterns());

            return(patterns);
        }
Beispiel #38
0
        // Create rating request XML string
        private string RateRequest(IShipment shipment, UspsShipmentLineItemVisitor visitor)
        {
            // Changed weight logic per JeffreyABecker suggestions
            //int tOz = (int)Math.Ceiling(weight * 16.0m);
            //int packageWeightPounds = tOz / 16;
            //int packageWeightOunces = tOz % 16;

            var sb = new StringBuilder();

            using (var writer = XmlWriter.Create(sb, new XmlWriterSettings()
            {
                OmitXmlDeclaration = true
            }))
            {
                writer.WriteStartDocument();
                writer.WriteStartElement(shipment.ToCountryCode == "US" ? "RateV4Request" : "IntlRateV2Response");
                writer.WriteAttributeString("USERID", _processorSettings.UspsUsername);
                writer.WriteAttributeString("PASSWORD", _processorSettings.UspsPassword);
                writer.WriteElementString("Revision", null);
                BuildRatePackage(writer, shipment, visitor);
                writer.WriteEndDocument();
            }
            return("API=RateV4&XML=" + ApplicationXWwwFormUrlencodedEncode(sb.ToString()));
        }
Beispiel #39
0
        /// <summary>
        /// The build.
        /// </summary>
        /// <param name="shipment">
        /// The shipment.
        /// </param>
        /// <param name="contacts">
        /// The collection of contact addresses
        /// </param>
        /// <returns>
        /// The <see cref="IShipmentResultNotifyModel"/>.
        /// </returns>
        public IShipmentResultNotifyModel Build(IShipment shipment, IEnumerable <string> contacts)
        {
            var notifyModel = new ShipmentResultNotifyModel()
            {
                Shipment = shipment,
                Contacts = contacts == null ? new string[] { } : contacts.ToArray()
            };

            var item = shipment.Items.FirstOrDefault(x => !x.ContainerKey.Equals(Guid.Empty));

            if (item != null)
            {
                var orderKey = item.ContainerKey;

                var order = _orderService.GetByKey(orderKey);

                if (order != null)
                {
                    var invoice = _invoiceService.GetByKey(order.InvoiceKey);
                    if (invoice != null)
                    {
                        notifyModel.Invoice = invoice;
                        if (invoice.Items.Any())
                        {
                            var currencyCode =
                                invoice.Items.First()
                                .ExtendedData.GetValue(Core.Constants.ExtendedDataKeys.CurrencyCode);
                            var currency = _storeSettingService.GetCurrencyByCode(currencyCode);
                            notifyModel.CurrencySymbol = currency != null ? currency.Symbol : "£";
                        }
                    }
                }
            }

            return(notifyModel);
        }
Beispiel #40
0
        public virtual ShippingRate GetRate(IShipment shipment, ShippingMethodInfoModel shippingMethodInfoModel, IMarket currentMarket)
        {
            var type = Type.GetType(shippingMethodInfoModel.ClassName);

            if (type == null)
            {
                throw new TypeInitializationException(shippingMethodInfoModel.ClassName, null);
            }
            string message        = string.Empty;
            var    shippingPlugin = _shippingPluginsAccessor().FirstOrDefault(s => s.GetType() == type);

            if (shippingPlugin != null)
            {
                return(shippingPlugin.GetRate(currentMarket, shippingMethodInfoModel.MethodId, shipment, ref message));
            }

            var shippingGateway = _shippingGatewaysAccessor().FirstOrDefault(s => s.GetType() == type);

            if (shippingGateway != null)
            {
                return(shippingGateway.GetRate(currentMarket, shippingMethodInfoModel.MethodId, (Shipment)shipment, ref message));
            }
            throw new InvalidOperationException($"There is no registered {nameof(IShippingPlugin)} or {nameof(IShippingGateway)} instance.");
        }
Beispiel #41
0
        /// <summary>
        /// Returns a collection of all available <see cref="IShipmentRateQuote"/> for a given shipment
        /// </summary>
        /// <param name="shipment"><see cref="IShipmentRateQuote"/></param>
        /// <returns>A collection of <see cref="IShipmentRateQuote"/></returns>
        public virtual IEnumerable <IShipmentRateQuote> QuoteShippingGatewayMethodsForShipment(IShipment shipment)
        {
            var gatewayShipMethods = GetShippingGatewayMethodsForShipment(shipment);

            var ctrValues = new object[] { shipment, gatewayShipMethods.ToArray(), RuntimeCache };

            var typeName = MerchelloConfiguration.Current.GetStrategyElement(Constants.StrategyTypeAlias.DefaultShipmentRateQuote).Type;

            var attempt = ActivatorHelper.CreateInstance <ShipmentRateQuoteStrategyBase>(typeName, ctrValues);

            if (!attempt.Success)
            {
                LogHelper.Error <ShippingGatewayProviderBase>("Failed to instantiate strategy " + typeName, attempt.Exception);
                throw attempt.Exception;
            }

            return(QuoteShippingGatewayMethodsForShipment(attempt.Result));
        }
Beispiel #42
0
        /// <summary>
        /// Returns a collection of available <see cref="IShippingGatewayMethod"/> associated by this provider for a given shipment
        /// </summary>
        /// <param name="shipment">the <see cref="IShipment"/></param>
        /// <returns>A collection of <see cref="IShippingGatewayMethod"/></returns>
        public virtual IEnumerable <IShippingGatewayMethod> GetShippingGatewayMethodsForShipment(IShipment shipment)
        {
            var attempt = shipment.GetValidatedShipCountry(GatewayProviderService);

            // quick validation of shipment
            if (!attempt.Success)
            {
                LogHelper.Error <ShippingGatewayProviderBase>("ShipMethods could not be determined for Shipment passed to GetAvailableShipMethodsForDestination method. Attempt message: " + attempt.Exception.Message, new ArgumentException("merchWarehouseCatalogKey"));
                return(new List <IShippingGatewayMethod>());
            }

            var shipCountry = attempt.Result;

            var shipmethods = GetAllShippingGatewayMethods(shipCountry);

            var gatewayShipMethods = shipmethods as IShippingGatewayMethod[] ?? shipmethods.ToArray();

            if (!gatewayShipMethods.Any())
            {
                return(new List <IShippingGatewayMethod>());
            }

            if (!shipCountry.HasProvinces)
            {
                return(gatewayShipMethods);
            }

            var available = new List <IShippingGatewayMethod>();

            foreach (var gwshipmethod in gatewayShipMethods)
            {
                var province = gwshipmethod.ShipMethod.Provinces.FirstOrDefault(x => x.Code == shipment.ToRegion);
                if (province == null)
                {
                    LogHelper.Debug <ShippingGatewayProviderBase>("Province code '" + shipment.ToRegion + "' was not found in ShipCountry with code : " + shipCountry.CountryCode);
                    available.Add(gwshipmethod);
                }
                else
                {
                    if (province.AllowShipping)
                    {
                        available.Add(gwshipmethod);
                    }
                }
            }

            return(available);
        }
Beispiel #43
0
        public AddToCartResult AddToCart(ICart cart, string code, string warehouseCode, decimal quantity)
        {
            var result       = new AddToCartResult();
            var contentLink  = _referenceConverter.GetContentLink(code);
            var entryContent = _contentLoader.Get <EntryContentBase>(contentLink);

            if (entryContent is BundleContent)
            {
                foreach (var relation in _relationRepository.GetChildren <BundleEntry>(contentLink))
                {
                    var entry           = _contentLoader.Get <EntryContentBase>(relation.Child);
                    var recursiveResult = AddToCart(cart, entry.Code, warehouseCode, relation.Quantity ?? 1);
                    if (recursiveResult.EntriesAddedToCart)
                    {
                        result.EntriesAddedToCart = true;
                    }

                    foreach (var message in recursiveResult.ValidationMessages)
                    {
                        result.ValidationMessages.Add(message);
                    }
                }

                return(result);
            }

            ILineItem lineItem = null;

            if (!string.IsNullOrEmpty(warehouseCode))
            {
                IShipment shipment = null;
                if (cart.GetFirstForm().Shipments.Count == 1 && string.IsNullOrEmpty(cart.GetFirstForm().Shipments.First().WarehouseCode))
                {
                    shipment = cart.GetFirstForm().Shipments.First();
                    shipment.WarehouseCode = warehouseCode;
                }
                else
                {
                    shipment = cart.GetFirstForm().Shipments.FirstOrDefault(s => s.WarehouseCode.Equals(warehouseCode, StringComparison.CurrentCultureIgnoreCase));
                }
                if (shipment == null)
                {
                    shipment = cart.CreateShipment(_orderGroupFactory);
                    shipment.WarehouseCode = warehouseCode;
                    cart.AddShipment(shipment);
                }

                lineItem = shipment.LineItems.FirstOrDefault(x => x.Code == code && !x.IsGift);

                if (lineItem == null)
                {
                    //this is just like AddNewLineItem but doesn't add there - adds to shipment instead
                    lineItem             = cart.CreateLineItem(code, _orderGroupFactory);
                    lineItem.Quantity    = quantity;
                    lineItem.DisplayName = entryContent.DisplayName;
                    //cart.AddLineItem(newLineItem, _orderGroupFactory);

                    var price = _pricingService.GetPrice(code);
                    if (price != null)
                    {
                        lineItem.PlacedPrice = price.UnitPrice.Amount;
                    }

                    cart.AddLineItem(shipment, lineItem);
                }
                else
                {
                    cart.UpdateLineItemQuantity(shipment, lineItem, lineItem.Quantity + quantity);
                }
            }
            else
            {
                lineItem = cart.GetAllLineItems().FirstOrDefault(x => x.Code == code && !x.IsGift);

                if (lineItem == null)
                {
                    lineItem = AddNewLineItem(cart, code, quantity, entryContent.DisplayName);
                }
                else
                {
                    var shipment = cart.GetFirstShipment();
                    cart.UpdateLineItemQuantity(shipment, lineItem, lineItem.Quantity + quantity);
                }
            }

            var validationIssues = ValidateCart(cart);

            AddValidationMessagesToResult(result, lineItem, validationIssues);

            return(result);
        }
Beispiel #44
0
        public List <IShippingRate> RateShipment(IShipment shipment)
        {
            _Messages.Clear();

            var result    = new List <IShippingRate>();
            var hasErrors = false;

            try
            {
                var optimizedPackages = OptimizeSingleGroup(shipment);

                if (optimizedPackages.Count > 0)
                {
                    result = RatePackages(optimizedPackages);

                    if (GlobalSettings.DiagnosticsMode)
                    {
                        foreach (var package in optimizedPackages)
                        {
                            _Logger.LogMessage("FEDEX SHIPMENT",
                                               string.Format("Source Address: {0}, {1}, {2}, {3}, {4} {5}",
                                                             package.SourceAddress.Street, package.SourceAddress.Street2,
                                                             package.SourceAddress.City, package.SourceAddress.RegionData.DisplayName,
                                                             package.SourceAddress.CountryData.DisplayName, package.SourceAddress.PostalCode),
                                               EventLogSeverity.Information);

                            _Logger.LogMessage("FEDEX SHIPMENT",
                                               string.Format("Destination Address: {0}, {1}, {2}, {3}, {4} {5}",
                                                             package.DestinationAddress.Street, package.DestinationAddress.Street2,
                                                             package.DestinationAddress.City, package.DestinationAddress.RegionData.DisplayName,
                                                             package.DestinationAddress.CountryData.DisplayName,
                                                             package.DestinationAddress.PostalCode),
                                               EventLogSeverity.Information);
                        }
                    }
                }
                else
                {
                    if (GlobalSettings.DiagnosticsMode)
                    {
                        _Logger.LogMessage("No packages found to rate for FedEx");
                    }
                }
            }
            catch (Exception ex)
            {
                _Logger.LogException(ex);
                var m = new ShippingServiceMessage();
                m.SetError("Exception", ex.Message + " | " + ex.StackTrace);
                _Messages.Add(m);
            }

            if (GlobalSettings.DiagnosticsMode)
            {
                foreach (var rate in result)
                {
                    _Logger.LogMessage("OPTIMIZED FEDEX RATE",
                                       string.Format(
                                           "Service Id: {0}<br />Display Name: {1}<br />Service Codes:{2}<br />Estimated Cost:{3}",
                                           rate.ServiceId, rate.DisplayName, rate.ServiceCodes, rate.EstimatedCost),
                                       EventLogSeverity.Information);
                }
            }

            if (hasErrors)
            {
                result = new List <IShippingRate>();
            }
            return(result);
        }
Beispiel #45
0
        public override Attempt <IShipmentRateQuote> QuoteShipment(IShipment shipment)
        {
            decimal shippingPrice = 0M;

            try
            {
                var visitor = new UspsShipmentLineItemVisitor()
                {
                    UseOnSalePriceIfOnSale = false
                };

                shipment.Items.Accept(visitor);

                var http = new HttpRequestHandler();

                var collection = GetCollectionFromCache(shipment);

                if (collection == null)
                {
                    var rateXml = http.Post(RateRequest(shipment, visitor));

                    collection = UspsParseRates(rateXml, shipment);

                    _runtimeCache.InsertCacheItem(MakeCacheKey(shipment), () => collection);
                }
                //if (collection.Any(option => option.Service.Contains(shipment.ShipmentName) &&
                //                             option.Service.ToLower().Contains("medium") || option.Service.ToLower().Contains("large")))
                //{
                //    var packageSize = GetPackageSize(length, height, width);
                //    shippingPrice = packageSize == "REGULAR" ? collection.First(option => option.Service.Contains(shipment.ShipmentName) &&
                //        option.Service.ToLower().Contains("medium")).Rate : collection.First(option => option.Service.Contains(shipment.ShipmentName) &&
                //            option.Service.ToLower().Contains("large")).Rate;
                //}
                //else
                //{
                //    shippingPrice = collection.First(option => option.Service.Contains(shipment.ShipmentName)).Rate;
                //}
                var namedCollection = collection.Where(option => HttpUtility.HtmlDecode(option.Service).Contains(HttpUtility.HtmlDecode(_shipMethod.ServiceCode)));
                var deliveryOptions = namedCollection as IList <DeliveryOption> ?? namedCollection.ToList();
                if (deliveryOptions.Any(o => o.Service.Contains("medium") || o.Service.Contains("large")))
                {
                    var packageSize    = GetPackageSize(1, 1, 1);
                    var firstOrDefault = deliveryOptions.FirstOrDefault(x => x.Service.Contains("medium"));
                    if (firstOrDefault != null)
                    {
                        var deliveryOption = deliveryOptions.FirstOrDefault(x => x.Service.Contains("large"));
                        if (deliveryOption != null)
                        {
                            shippingPrice = packageSize == "REGULAR" ? firstOrDefault.Rate : deliveryOption.Rate;
                        }
                    }
                }
                else
                {
                    var firstOrDefault = deliveryOptions.FirstOrDefault();
                    if (firstOrDefault != null)
                    {
                        shippingPrice = firstOrDefault.Rate;
                    }
                }
            }
            catch (Exception ex)
            {
                return(Attempt <IShipmentRateQuote> .Fail(
                           new Exception("An error occured during your request : " +
                                         ex.Message +
                                         " Please contact your administrator or try again.")));
            }

            return(Attempt <IShipmentRateQuote> .Succeed(new ShipmentRateQuote(shipment, _shipMethod) { Rate = shippingPrice }));
        }
        /// <summary>Process payment associated with shipment.</summary>
        /// <param name="orderGroup">The order group.</param>
        /// <param name="payment">The payment.</param>
        /// <param name="shipment">The shipment.</param>
        /// <returns><c>True</c> if process successful, otherwise <c>False</c>.</returns>
        public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment, IShipment shipment)
        {
            OrderGroup = orderGroup;
            _orderForm = orderGroup.GetFirstForm();
            var result  = ProcessPayment(payment, shipment);
            var message = result.Message;

            return(result.Status
                ? PaymentProcessingResult.CreateSuccessfulResult(message)
                : PaymentProcessingResult.CreateUnsuccessfulResult(message));
        }
        private List <IShippable> OptimizeSingleGroup(IShipment shipment)
        {
            const decimal MAXWEIGHT = 70;

            var result       = new List <IShippable>();
            var itemsToSplit = new List <IShippable>();

            foreach (var item in shipment.Items)
            {
                if (IsOversized(item))
                {
                    result.Add(item.CloneShippable());
                }
                else
                {
                    itemsToSplit.Add(item);
                }
            }

            IShippable tempPackage = new Shippable();

            foreach (var pak in itemsToSplit)
            {
                if (MAXWEIGHT - tempPackage.BoxWeight >= pak.BoxWeight)
                {
                    // add to current box
                    tempPackage.BoxWeight            += pak.BoxWeight;
                    tempPackage.QuantityOfItemsInBox += pak.QuantityOfItemsInBox;
                    tempPackage.BoxValue             += pak.BoxValue;
                }
                else
                {
                    // Save the temp package if it has items
                    if (tempPackage.BoxWeight > 0 || tempPackage.QuantityOfItemsInBox > 0)
                    {
                        result.Add(tempPackage.CloneShippable());
                        tempPackage = new Shippable();
                    }

                    // create new box
                    if (pak.BoxWeight > MAXWEIGHT)
                    {
                        //Loop to break up > maxWeight Packages
                        var currentItemsInBox = pak.QuantityOfItemsInBox;
                        var currentWeight     = pak.BoxWeight;

                        while (currentWeight > 0)
                        {
                            if (currentWeight > MAXWEIGHT)
                            {
                                var newP = pak.CloneShippable();
                                newP.BoxWeight = MAXWEIGHT;

                                if (currentItemsInBox > 0)
                                {
                                    currentItemsInBox        -= 1;
                                    newP.QuantityOfItemsInBox = 1;
                                }

                                result.Add(newP);
                                currentWeight = currentWeight - MAXWEIGHT;

                                if (currentWeight < 0)
                                {
                                    currentWeight = 0;
                                }
                            }
                            else
                            {
                                // Create a new shippable box
                                var newP = pak.CloneShippable();
                                newP.BoxWeight = currentWeight;

                                if (currentItemsInBox > 0)
                                {
                                    newP.QuantityOfItemsInBox = currentItemsInBox;
                                }

                                result.Add(newP);
                                currentWeight = 0;
                            }
                        }
                    }
                    else
                    {
                        tempPackage = pak.CloneShippable();
                    }
                }
            }

            // Save the temp package if it has items
            if (tempPackage.BoxWeight > 0 || tempPackage.QuantityOfItemsInBox > 0)
            {
                result.Add(tempPackage.CloneShippable());
                tempPackage = new Shippable();
            }

            return(result);
        }
Beispiel #48
0
        private static decimal RateSinglePackage(FedExGlobalServiceSettings globalSettings, ILogger logger,
                                                 IShipment pak,
                                                 ServiceType service, PackageType packaging, CarrierCodeType carCode,
                                                 bool useNegotiatedRates)
        {
            var result = 0m;

            try
            {
                // Auth Header Data
                var req = new RateRequest
                {
                    WebAuthenticationDetail = new WebAuthenticationDetail
                    {
                        UserCredential = new WebAuthenticationCredential
                        {
                            Key      = globalSettings.UserKey,
                            Password = globalSettings.UserPassword
                        }
                    }
                };
                req.ClientDetail = new ClientDetail
                {
                    AccountNumber = globalSettings.AccountNumber,
                    MeterNumber   = globalSettings.MeterNumber,
                    IntegratorId  = "Hotcakes"
                };
                req.Version = new VersionId();

                // Basic Transaction Data
                req.TransactionDetail = new TransactionDetail
                {
                    CustomerTransactionId = Guid.NewGuid().ToString()
                };
                req.ReturnTransitAndCommit = false;
                req.CarrierCodes           = new CarrierCodeType[1] {
                    carCode
                };

                // Shipment Details
                req.RequestedShipment = new RequestedShipment
                {
                    LabelSpecification = new LabelSpecification
                    {
                        ImageType               = ShippingDocumentImageType.PDF,
                        LabelFormatType         = LabelFormatType.COMMON2D,
                        CustomerSpecifiedDetail = new CustomerSpecifiedLabelDetail()
                    },
                    RateRequestTypes = new[] { RateRequestType.LIST },
                    DropoffType      = GetDropOffType(globalSettings.DefaultDropOffType),
                    PackagingType    = GetPackageType(packaging),
                    TotalWeight      = new Weight
                    {
                        Value = Math.Round(pak.Items.Sum(y => y.BoxWeight), 1),
                        Units =
                            pak.Items[0].BoxWeightType == Shipping.WeightType.Kilograms
                                ? WeightUnits.KG
                                : WeightUnits.LB
                    },
                    PackageCount = pak.Items.Count.ToString(),
                    RequestedPackageLineItems = new RequestedPackageLineItem[pak.Items.Count]
                };

                /*
                 * Possible values for RateRequestType include: LIST and ACCOUNT.
                 * ACCOUNT will return negotiated rates, but LIST will return both regular and negotiated rates.
                 * http://www.fedex.com/us/developer/product/WebServices/MyWebHelp_March2010/Content/WS_Developer_Guide/Rate_Services.htm
                 */
                //req.RequestedShipment.RateRequestTypes = new[] { RateRequestType.ACCOUNT };

                // Uncomment these lines to get insured values passed in
                //
                //var totalValue = pak.Items.Sum(y => y.BoxValue);
                //req.RequestedShipment.TotalInsuredValue = new Money();
                //req.RequestedShipment.TotalInsuredValue.Amount = totalValue;
                //req.RequestedShipment.TotalInsuredValue.Currency = "USD";

                for (var i = 0; i < pak.Items.Count; i++)
                {
                    req.RequestedShipment.RequestedPackageLineItems[i] = new RequestedPackageLineItem
                    {
                        GroupNumber       = "1",
                        GroupPackageCount = (i + 1).ToString(),
                        Weight            = new Weight
                        {
                            Value = pak.Items[i].BoxWeight,
                            Units =
                                pak.Items[i].BoxWeightType == Shipping.WeightType.Kilograms
                                    ? WeightUnits.KG
                                    : WeightUnits.LB
                        }
                    };

                    req.RequestedShipment.RequestedPackageLineItems[i].Dimensions = new Dimensions
                    {
                        Height = pak.Items[i].BoxHeight.ToString(),
                        Length = pak.Items[i].BoxLength.ToString(),
                        Width  = pak.Items[i].BoxWidth.ToString(),
                        Units  = pak.Items[i].BoxLengthType == LengthType.Centimeters ? LinearUnits.CM : LinearUnits.IN
                    };
                }

                req.RequestedShipment.Recipient = new Party
                {
                    Address = new FedExRateServices.Address
                    {
                        City        = pak.DestinationAddress.City,
                        CountryCode = GetCountryCode(pak.DestinationAddress.CountryData),
                        PostalCode  = pak.DestinationAddress.PostalCode
                    }
                };


                if (pak.DestinationAddress.CountryData.IsoCode == "US" ||
                    pak.DestinationAddress.CountryData.IsoCode == "CA")
                {
                    req.RequestedShipment.Recipient.Address.StateOrProvinceCode = pak.DestinationAddress.RegionBvin;
                }
                else
                {
                    req.RequestedShipment.Recipient.Address.StateOrProvinceCode = string.Empty;
                }
                req.RequestedShipment.Recipient.Address.StreetLines = new string[2]
                {
                    pak.DestinationAddress.Street, pak.DestinationAddress.Street2
                };

                switch (service)
                {
                case ServiceType.GROUNDHOMEDELIVERY:
                    req.RequestedShipment.Recipient.Address.Residential          = true;
                    req.RequestedShipment.Recipient.Address.ResidentialSpecified = true;
                    break;

                case ServiceType.FEDEXGROUND:
                    req.RequestedShipment.Recipient.Address.Residential          = false;
                    req.RequestedShipment.Recipient.Address.ResidentialSpecified = true;
                    break;

                default:
                    req.RequestedShipment.Recipient.Address.ResidentialSpecified = false;
                    break;
                }

                req.RequestedShipment.Shipper = new Party
                {
                    AccountNumber = globalSettings.AccountNumber,
                    Address       = new FedExRateServices.Address
                    {
                        City        = pak.SourceAddress.City,
                        CountryCode = GetCountryCode(pak.SourceAddress.CountryData),
                        PostalCode  = pak.SourceAddress.PostalCode,
                        Residential = false
                    }
                };

                if (pak.SourceAddress.CountryData.IsoCode == "US" || // US or Canada
                    pak.SourceAddress.CountryData.IsoCode == "CA")
                {
                    req.RequestedShipment.Shipper.Address.StateOrProvinceCode = pak.SourceAddress.RegionBvin;
                }
                else
                {
                    req.RequestedShipment.Shipper.Address.StateOrProvinceCode = string.Empty;
                }
                req.RequestedShipment.Shipper.Address.StreetLines = new string[2]
                {
                    pak.SourceAddress.Street, pak.SourceAddress.Street2
                };

                var svc = new FedExRateServices.RateService
                {
                    Url =
                        globalSettings.UseDevelopmentServiceUrl
                            ? FedExConstants.DevRateServiceUrl
                            : FedExConstants.LiveRateServiceUrl
                };

                var res = svc.getRates(req);

                if (res.HighestSeverity == NotificationSeverityType.ERROR ||
                    res.HighestSeverity == NotificationSeverityType.FAILURE)
                {
                    if (globalSettings.DiagnosticsMode)
                    {
                        foreach (var err in res.Notifications)
                        {
                            logger.LogMessage("FEDEX", err.Message, EventLogSeverity.Debug);
                        }
                    }
                    result = 0m;
                }
                else
                {
                    result = 0m;

                    var lookingForService = GetServiceType(service);
                    var matchingResponse  = res.RateReplyDetails.FirstOrDefault(y => y.ServiceType == lookingForService);
                    if (matchingResponse != null)
                    {
                        if (useNegotiatedRates)
                        {
                            var matchedRate =
                                matchingResponse.RatedShipmentDetails.FirstOrDefault(
                                    y => y.ShipmentRateDetail.RateType == ReturnedRateType.PAYOR_ACCOUNT_PACKAGE ||
                                    y.ShipmentRateDetail.RateType == ReturnedRateType.PAYOR_ACCOUNT_SHIPMENT);

                            if (matchedRate != null)
                            {
                                result = matchedRate.ShipmentRateDetail.TotalNetCharge.Amount;

                                if (globalSettings.DiagnosticsMode)
                                {
                                    logger.LogMessage("FEDEX SHIPMENT",
                                                      "Negotiated rates were found and are currently being used.",
                                                      EventLogSeverity.Information);
                                }
                            }
                            else
                            {
                                matchedRate =
                                    matchingResponse.RatedShipmentDetails.FirstOrDefault(
                                        y => y.ShipmentRateDetail.RateType == ReturnedRateType.PAYOR_LIST_PACKAGE ||
                                        y.ShipmentRateDetail.RateType == ReturnedRateType.PAYOR_LIST_SHIPMENT);

                                result = matchedRate.ShipmentRateDetail.TotalNetCharge.Amount;

                                if (globalSettings.DiagnosticsMode)
                                {
                                    logger.LogMessage("FEDEX SHIPMENT",
                                                      "No negotiated rates were found. Public rates are being shown. You should update your account information, or uncheck the ‘Use Negotiated Rates’ checkbox.",
                                                      EventLogSeverity.Information);
                                }
                                else
                                {
                                    logger.LogMessage("FEDEX SHIPMENT", "No negotiated rates were found.",
                                                      EventLogSeverity.Information);
                                }
                            }
                        }
                        else
                        {
                            var matchedRate =
                                matchingResponse.RatedShipmentDetails.FirstOrDefault(
                                    y => y.ShipmentRateDetail.RateType == ReturnedRateType.PAYOR_LIST_PACKAGE ||
                                    y.ShipmentRateDetail.RateType == ReturnedRateType.PAYOR_LIST_SHIPMENT);

                            if (matchedRate != null)
                            {
                                result = matchedRate.ShipmentRateDetail.TotalNetCharge.Amount;

                                if (
                                    matchingResponse.RatedShipmentDetails.Any(
                                        y => y.ShipmentRateDetail.RateType == ReturnedRateType.PAYOR_ACCOUNT_PACKAGE ||
                                        y.ShipmentRateDetail.RateType == ReturnedRateType.PAYOR_ACCOUNT_SHIPMENT))
                                {
                                    if (globalSettings.DiagnosticsMode)
                                    {
                                        logger.LogMessage("FEDEX SHIPMENT",
                                                          "We also found negotiated rates for your account. You should consider checking the ‘Use Negotiated Rates’ checkbox.",
                                                          EventLogSeverity.Information);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                result = 0m;
                logger.LogException(ex);
            }

            return(result);
        }
        public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment, IShipment shipment)
        {
            switch (payment.TransactionType)
            {
            case nameof(TransactionType.Authorization):
                return(VippsPaymentsService.Initiate(orderGroup, payment));

            case nameof(TransactionType.Capture):
                return(VippsPaymentsService.Capture(orderGroup, payment));

            case nameof(TransactionType.Sale):
                return(VippsPaymentsService.Initiate(orderGroup, payment));

            case nameof(TransactionType.Void):
                return(VippsPaymentsService.Cancel(orderGroup, payment));

            case nameof(TransactionType.Credit):
                return(VippsPaymentsService.Refund(orderGroup, payment));

            default:
                throw new NotImplementedException();
            }
        }
Beispiel #50
0
 /// <summary>
 /// Generates a unique cache key for runtime caching of the <see cref="FedExShippingGatewayMethod"/>
 /// </summary>
 /// <param name="shipment"> The Shipment</param>
 /// <returns>The unique CacheKey string</returns>
 /// <remarks>
 ///
 /// CacheKey is assumed to be unique per customer and globally for CheckoutBase.  Therefore this will NOT be unique if
 /// to different checkouts are happening for the same customer at the same time - we consider that an extreme edge case.
 ///
 /// </remarks>
 private string MakeCacheKey(IShipment shipment)
 {
     return(string.Format("merchello.shippingquotecollection.{0}.{1}.{2}", _shipMethod.ProviderKey, _gatewayProviderSettings.Key, shipment.VersionKey));
 }
Beispiel #51
0
        private IEnumerable <DeliveryOption> UspsParseRates(string response, IShipment package)
        {
            var optionCollection = new List <DeliveryOption>();

            using (var reader = new XmlTextReader(new StringReader(response)))
            {
                while (reader.Read())
                {
                    if ((reader.Name == "Error") && (reader.NodeType == XmlNodeType.Element))
                    {
                        string errorText = "";

                        while (reader.Read())
                        {
                            if ((reader.Name == "HelpContext") && (reader.NodeType == XmlNodeType.Element))
                            {
                                errorText += "USPS Help Context: " + reader.ReadString() + ", ";
                            }

                            if ((reader.Name == "Description") && (reader.NodeType == XmlNodeType.Element))
                            {
                                errorText += "Error Desc: " + reader.ReadString();
                            }
                        }

                        throw new ProviderException("USPS Error returned: " + errorText);
                    }

                    if ((reader.Name == "Postage") && (reader.NodeType == XmlNodeType.Element))
                    {
                        int serviceCode;
                        Int32.TryParse(reader.GetAttribute("CLASSID"), out serviceCode);
                        string postalRate  = "";
                        String mailService = "";

                        reader.Read();

                        if (reader.Name == "MailService" && reader.NodeType == XmlNodeType.Element)
                        {
                            mailService = reader.ReadString();
                            reader.ReadEndElement();
                        }

                        if (reader.Name == "Rate" && reader.NodeType == XmlNodeType.Element)
                        {
                            postalRate = reader.ReadString();
                            reader.ReadEndElement();
                        }

                        IEnumerable <UspsDeliveryOption> options = GetDeliveryOptions(serviceCode, package);

                        if (options == null)
                        {
                            continue;
                        }

                        decimal rate;

                        if (!Decimal.TryParse(postalRate, out rate))
                        {
                            continue;
                        }

                        if (!String.IsNullOrEmpty(_processorSettings.UspsAdditionalHandlingCharge))
                        {
                            decimal additionalHandling;

                            if (Decimal.TryParse(_processorSettings.UspsAdditionalHandlingCharge, out additionalHandling))
                            {
                                rate += additionalHandling;
                            }
                        }

                        // Weed out unavailable service rates
                        //if (options.Any(option => option.Fits(weight, width, length, height)))
                        //{
                        var deliveryOption = new DeliveryOption {
                            Rate = rate, Service = mailService, ServiceCode = serviceCode.ToString()
                        };
                        optionCollection.Add(deliveryOption);
                        //}
                    }
                }

                return(optionCollection);
            }
        }
Beispiel #52
0
        public CaptureData CaptureOrder(string orderId, int?amount, string description, IOrderGroup orderGroup, IOrderForm orderForm, IPayment payment, IShipment shipment)
        {
            var order   = _client.NewOrder(orderId);
            var capture = _client.NewCapture(order.Location);

            if (shipment == null)
            {
                throw new InvalidOperationException("Can't find correct shipment");
            }
            var lines        = shipment.LineItems.Select(l => FromLineItem(l, orderGroup.Currency)).ToList();
            var shippingInfo = new ShippingInfo
            {
                // TODO shipping info
                ShippingMethod = "Own",
                TrackingNumber = shipment.ShipmentTrackingNumber
            };

            var captureData = new CaptureData
            {
                CapturedAmount = amount,
                Description    = description,
                OrderLines     = lines,
                ShippingInfo   = new List <ShippingInfo>()
                {
                    shippingInfo
                }
            };

            if (ServiceLocator.Current.TryGetExistingInstance(out ICaptureBuilder captureBuilder))
            {
                captureData = captureBuilder.Build(captureData, orderGroup, orderForm, payment);
            }

            capture.Create(captureData);
            return(capture.Fetch());
        }
        // Gets all available rates regardless of settings
        private List <IShippingRate> GetAllShippingRatesForShipment(IShipment shipment)
        {
            var rates     = new List <IShippingRate>();
            var hasErrors = false;

            try
            {
                var sErrorMessage = string.Empty;
                var sErrorCode    = string.Empty;

                var sURL = string.Concat(UPSLIVESERVER, "Rate");

                // Build XML
                var settings = new UpsSettings
                {
                    UserID    = GlobalSettings.Username,
                    Password  = GlobalSettings.Password,
                    ServerUrl = UPSLIVESERVER,
                    License   = GlobalSettings.LicenseNumber
                };

                var sXML = string.Empty;

                sXML  = XmlTools.BuildAccessKey(settings);
                sXML += "\n";

                sXML += BuildUPSRateRequestForShipment(shipment, settings);

                var sResponse = string.Empty;
                sResponse = XmlTools.ReadHtmlPage_POST(sURL, sXML);

                XmlDocument xDoc;
                XmlNodeList NodeList;
                var         sStatusCode = "-1";

                try
                {
                    xDoc = new XmlDocument();
                    xDoc.LoadXml(sResponse);

                    if (xDoc.DocumentElement.Name == "RatingServiceSelectionResponse")
                    {
                        XmlNode n;
                        var     i = 0;
                        XmlNode nTag;

                        NodeList = xDoc.GetElementsByTagName("RatingServiceSelectionResponse");
                        n        = NodeList.Item(0);
                        for (i = 0; i <= n.ChildNodes.Count - 1; i++)
                        {
                            nTag = n.ChildNodes.Item(i);
                            switch (nTag.Name)
                            {
                            case "Response":
                                var     iRes = 0;
                                XmlNode nRes;
                                for (iRes = 0; iRes <= nTag.ChildNodes.Count - 1; iRes++)
                                {
                                    nRes = nTag.ChildNodes[iRes];
                                    switch (nRes.Name)
                                    {
                                    case "ResponseStatusCode":
                                        sStatusCode = nRes.FirstChild.Value;
                                        break;

                                    case "ResponseStatusDescription":
                                        // Not Used
                                        break;

                                    case "Error":
                                        var     iErr = 0;
                                        XmlNode nErr;
                                        for (iErr = 0; iErr <= nRes.ChildNodes.Count - 1; iErr++)
                                        {
                                            nErr = nRes.ChildNodes[iErr];
                                            switch (nErr.Name)
                                            {
                                            case "ErrorCode":
                                                sErrorCode = nErr.FirstChild.Value;
                                                break;

                                            case "ErrorDescription":
                                                sErrorMessage = nErr.FirstChild.Value;
                                                break;

                                            case "ErrorSeverity":
                                                // Not Used
                                                break;
                                            }
                                        }
                                        break;
                                    }
                                }
                                break;

                            case "RatedShipment":

                                var     iRated = 0;
                                XmlNode nRated;

                                var sPostage      = string.Empty;
                                var sCurrencyCode = string.Empty;
                                var sCode         = string.Empty;
                                var sDescription  = string.Empty;

                                for (iRated = 0; iRated <= nTag.ChildNodes.Count - 1; iRated++)
                                {
                                    nRated = nTag.ChildNodes[iRated];
                                    switch (nRated.Name)
                                    {
                                    case "Service":
                                        var     iServices = 0;
                                        XmlNode nServices;
                                        for (iServices = 0;
                                             iServices <= nRated.ChildNodes.Count - 1;
                                             iServices++)
                                        {
                                            nServices = nRated.ChildNodes[iServices];
                                            switch (nServices.Name)
                                            {
                                            case "Code":
                                                sCode        = nServices.FirstChild.Value;
                                                sDescription = DecodeUpsServiceCode(sCode);
                                                break;

                                            case "Description":
                                                sDescription = nServices.FirstChild.Value;
                                                break;
                                            }
                                        }
                                        break;

                                    case "TotalCharges":
                                        var     iCharges = 0;
                                        XmlNode nCharges;
                                        for (iCharges = 0; iCharges <= nRated.ChildNodes.Count - 1; iCharges++)
                                        {
                                            nCharges = nRated.ChildNodes[iCharges];
                                            switch (nCharges.Name)
                                            {
                                            case "MonetaryValue":
                                                sPostage = nCharges.FirstChild.Value;
                                                break;

                                            case "CurrencyCode":
                                                sCurrencyCode = nCharges.FirstChild.Value;
                                                break;
                                            }
                                        }
                                        break;
                                    }
                                }

                                var dRate = -1m;

                                if (sPostage.Length > 0)
                                {
                                    dRate = decimal.Parse(sPostage, NumberStyles.Currency,
                                                          CultureInfo.InvariantCulture);
                                }
                                else
                                {
                                    var nop = new ShippingServiceMessage();
                                    nop.SetInfo(string.Empty, "No UPS Postage Found");
                                    _Messages.Add(nop);
                                    hasErrors = true;
                                }

                                if (dRate >= 0)
                                {
                                    var r = new ShippingRate
                                    {
                                        DisplayName   = sDescription,
                                        EstimatedCost = dRate,
                                        ServiceCodes  = sCode,
                                        ServiceId     = Id
                                    };
                                    rates.Add(r);
                                }

                                if (GlobalSettings.DiagnosticsMode)
                                {
                                    var msg = new ShippingServiceMessage();

                                    msg.SetDiagnostics("UPS Rates Found",
                                                       string.Concat("StatusCode = ", sStatusCode, ", Postage = ", sPostage,
                                                                     ", Errors = ", sErrorMessage, ", Rate = ", dRate));

                                    _Messages.Add(msg);
                                }

                                break;
                            }
                        }
                    }
                    else
                    {
                        hasErrors     = true;
                        sErrorMessage = "Couldn't find valid XML response from server.";
                    }
                }
                catch (Exception Exx)
                {
                    _Logger.LogException(Exx);

                    var mex = new ShippingServiceMessage();

                    mex.SetError("Exception", string.Concat(Exx.Message, " | ", Exx.Source));

                    _Messages.Add(mex);

                    return(rates);
                }

                if (sStatusCode != "1")
                {
                    hasErrors = true;
                }
            }

            catch (Exception ex)
            {
                _Logger.LogException(ex);

                var m = new ShippingServiceMessage();

                m.SetError("Exception", string.Concat(ex.Message, " | ", ex.StackTrace));

                _Messages.Add(m);
            }

            if (hasErrors)
            {
                rates = new List <IShippingRate>();
            }

            return(rates);
        }
Beispiel #54
0
        private IEnumerable <ShippingMethodViewModel> CreateShippingMethodViewModels(IMarket market, Currency currency, IShipment shipment)
        {
            var shippingRates = GetShippingRates(market, currency, shipment);

            return(shippingRates.Select(r => new ShippingMethodViewModel {
                Id = r.Id, DisplayName = r.Name, Price = r.Money
            }));
        }
        private string BuildUPSRateRequestForShipment(IShipment shipment, UpsSettings settings)
        {
            var sXML      = string.Empty;
            var strWriter = new StringWriter();
            var xw        = new XmlTextWriter(strWriter);

            try
            {
                xw.Formatting  = Formatting.Indented;
                xw.Indentation = 3;

                //--------------------------------------------
                // Agreement Request
                xw.WriteStartElement("RatingServiceSelectionRequest");

                //--------------------------------------------
                // Request
                xw.WriteStartElement("Request");
                //--------------------------------------------
                // TransactionReference
                xw.WriteStartElement("TransactionReference");
                xw.WriteElementString("CustomerContext", "Rate Request");
                xw.WriteElementString("XpciVersion", "1.0001");
                xw.WriteEndElement();
                // End TransactionReference
                //--------------------------------------------
                xw.WriteElementString("RequestOption", "Shop");
                xw.WriteEndElement();
                // End Request
                //--------------------------------------------

                //--------------------------------------------
                // Pickup Type
                if (GlobalSettings.PickUpType != PickupType.Unknown)
                {
                    var pickupCode = ((int)GlobalSettings.PickUpType).ToString();

                    if (pickupCode.Trim().Length < 2)
                    {
                        pickupCode = "0" + pickupCode;
                    }

                    xw.WriteStartElement("PickupType");
                    xw.WriteElementString("Code", pickupCode);
                    xw.WriteEndElement();
                }
                // End Pickup Type
                //--------------------------------------------

                //--------------------------------------------
                // Shipment
                xw.WriteStartElement("Shipment");

                // Shipper
                xw.WriteStartElement("Shipper");
                xw.WriteStartElement("Address");

                //Use City name for countries that don't have postal codes
                if (shipment.SourceAddress.PostalCode.Trim().Length > 0)
                {
                    xw.WriteElementString("PostalCode",
                                          XmlTools.TrimToLength(shipment.SourceAddress.PostalCode.Trim(), 9));
                }
                else
                {
                    xw.WriteElementString("City", XmlTools.TrimToLength(shipment.SourceAddress.City.Trim(), 30));
                }

                if (shipment.SourceAddress.RegionData != null)
                {
                    xw.WriteElementString("StateProvinceCode", shipment.SourceAddress.RegionData.Abbreviation);
                }

                xw.WriteElementString("CountryCode", shipment.SourceAddress.CountryData.IsoCode);

                xw.WriteElementString("ShipperNumber", settings.License);

                xw.WriteEndElement();
                xw.WriteEndElement();

                // Ship To
                xw.WriteStartElement("ShipTo");
                xw.WriteStartElement("Address");

                if (shipment.DestinationAddress.PostalCode.Length > 0)
                {
                    xw.WriteElementString("PostalCode", shipment.DestinationAddress.PostalCode);
                }
                else
                {
                    if (shipment.DestinationAddress.City.Length > 0)
                    {
                        xw.WriteElementString("City", shipment.DestinationAddress.City);
                    }
                }

                if (shipment.DestinationAddress.RegionData != null)
                {
                    xw.WriteElementString("StateProvinceCode", shipment.DestinationAddress.RegionData.Abbreviation);
                }

                if (shipment.DestinationAddress.CountryData.Bvin.Length > 0)
                {
                    xw.WriteElementString("CountryCode", shipment.DestinationAddress.CountryData.IsoCode);
                }

                if (GlobalSettings.ForceResidential)
                {
                    xw.WriteElementString("ResidentialAddress", string.Empty);
                }

                xw.WriteEndElement();
                xw.WriteEndElement();

                var ignoreDimensions = GlobalSettings.IgnoreDimensions;

                // Optimize Packages for Weight
                var optimizedPackages = OptimizeSingleGroup(shipment);

                foreach (var p in optimizedPackages)
                {
                    WriteSingleUPSPackage(ref xw, p, ignoreDimensions);
                }

                if (Settings.NegotiatedRates)
                {
                    xw.WriteStartElement("RateInformation");
                    xw.WriteElementString("NegotiatedRatesIndicator", string.Empty);
                    xw.WriteEndElement();
                }

                xw.WriteEndElement();
                // End Shipment
                //--------------------------------------------

                xw.WriteEndElement();
                // End Agreement Request
                //--------------------------------------------

                xw.Flush();
                xw.Close();
            }
            catch (Exception ex)
            {
                _Logger.LogException(ex);
            }

            sXML = strWriter.GetStringBuilder().ToString();

            return(sXML);
        }
Beispiel #56
0
        private IEnumerable <ShippingRate> GetShippingRates(IMarket market, Currency currency, IShipment shipment)
        {
            var methods         = _shippingManagerFacade.GetShippingMethodsByMarket(market.MarketId.Value, false);
            var currentLanguage = _languageService.GetCurrentLanguage().TwoLetterISOLanguageName;

            return(methods.Where(shippingMethodRow => currentLanguage.Equals(shippingMethodRow.LanguageId, StringComparison.OrdinalIgnoreCase) &&
                                 string.Equals(currency, shippingMethodRow.Currency, StringComparison.OrdinalIgnoreCase))
                   .OrderBy(shippingMethodRow => shippingMethodRow.Ordering)
                   .Select(shippingMethodRow => _shippingManagerFacade.GetRate(shipment, shippingMethodRow, market)));
        }
 public List <IShippingRate> RateShipment(IShipment shipment)
 {
     _Messages.Clear();
     return(GetUPSRatesForShipment(shipment));
 }
Beispiel #58
0
 protected IEnumerable <DeliveryOption> GetCollectionFromCache(IShipment shipment)
 {
     return(_runtimeCache.GetCacheItem(MakeCacheKey(shipment)) as IEnumerable <DeliveryOption>);
 }
Beispiel #59
0
        public override bool Process(IPayment payment, IOrderForm orderForm, IOrderGroup orderGroup, IShipment shipment, ref string message)
        {
            if (payment.TransactionType == TransactionType.Void.ToString())
            {
                try
                {
                    var orderId = orderGroup.Properties[Common.Constants.KlarnaOrderIdField]?.ToString();
                    if (!string.IsNullOrEmpty(orderId))
                    {
                        KlarnaOrderService.CancelOrder(orderId);

                        payment.Status = PaymentStatus.Processed.ToString();

                        AddNoteAndSaveChanges(orderGroup, payment.TransactionType, "Order cancelled at Klarna");

                        return(true);
                    }
                }
                catch (Exception ex) when(ex is ApiException || ex is WebException)
                {
                    var exceptionMessage = GetExceptionMessage(ex);

                    payment.Status = PaymentStatus.Failed.ToString();
                    message        = exceptionMessage;
                    AddNoteAndSaveChanges(orderGroup, payment.TransactionType, $"Error occurred {exceptionMessage}");
                    Logger.Error(exceptionMessage, ex);
                    return(false);
                }
            }
            else if (Successor != null)
            {
                return(Successor.Process(payment, orderForm, orderGroup, shipment, ref message));
            }
            return(false);
        }
 /// <summary>
 /// Validate a shipment with a rule set.
 /// </summary>
 /// <param name="shipment"></param>
 /// <param name="rules"></param>
 /// <returns></returns>
 public bool Validate(IShipment shipment, CarrierRule rules)
 {
     Shipment = shipment;
     Visit(rules);
     return(IsValid);
 }