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

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

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

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

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

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

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

 /// <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)
 {
 }

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

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

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

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

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

 public bool ShipmentHasAddresses(IShipment shipment)
 {
     if (shipment.SourceAddress == null)
     {
         return false;
     }
     if (shipment.DestinationAddress == null)
     {
         return false;
     }
     return true;
 }

        /// <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."));
            }
        }