Esempio n. 1
0
        public override List <DeliveryOption> GetDeliveryOptionsListForShipping(string Country, string locale, ShippingAddress_V01 address)
        {
            var deliveryOptions = HttpRuntime.Cache[ShippingOptionsCacheKey] as List <DeliveryOption>;

            if (deliveryOptions == null || deliveryOptions.Count == 0)
            {
                if (deliveryOptions == null)
                {
                    deliveryOptions = new List <DeliveryOption>();
                }

                var proxy   = ServiceClientProvider.GetShippingServiceProxy();
                var request = new DeliveryOptionForCountryRequest_V01
                {
                    Country = Country,
                    State   = "*",
                    Locale  = locale
                };
                var response = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;
                if (response != null && response.DeliveryAlternatives != null)
                {
                    deliveryOptions.AddRange(response.DeliveryAlternatives.Select(option => new DeliveryOption(option)));
                }
                if (deliveryOptions.Any())
                {
                    HttpRuntime.Cache.Insert(ShippingOptionsCacheKey, deliveryOptions, null,
                                             DateTime.Now.AddMinutes(ShippingOptionsCacheMinutes),
                                             Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);
                }
            }
            return(deliveryOptions);
        }
Esempio n. 2
0
        /// <summary>
        /// Retrieves FreightCode and WareHouse from mappings defined in dbo.LuShippingFreightCode table.
        /// Combines STATE|CITY|COUNTY to search for a matching FreightCode and WareHouse in DB.
        /// </summary>
        /// <param name="a">The address used as input for mapping lookup</param>
        /// <returns></returns>
        private static string[] GetFreightCodeAndWarehouseFromService(ShippingAddress_V01 a)
        {
            var request = new DeliveryOptionForCountryRequest_V01
            {
                Country = "PA",
                State   = string.Format("{0}|{1}|{2}",
                                        a.Address.StateProvinceTerritory,
                                        a.Address.City,
                                        a.Address.CountyDistrict),
                Locale = "es-PA"
            };

            using (var proxy = ServiceClientProvider.GetShippingServiceProxy())
            {
                try
                {
                    var response = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;
                    if (response != null && response.DeliveryAlternatives != null &&
                        response.DeliveryAlternatives.Count > 0)
                    {
                        var shippingOption = response.DeliveryAlternatives.FirstOrDefault();
                        if (shippingOption != null)
                        {
                            return(new[] { shippingOption.FreightCode, shippingOption.WarehouseCode });
                        }
                    }
                }
                catch (Exception ex)
                {
                    LoggerHelper.Error(string.Format("GetFreightCodeAndWarehouseFromService error: Country: GT, error: {0}",
                                                     ex.ToString()));
                }
            }
            return(null);
        }
        public override List <DeliveryOption> GetDeliveryOptionsListForShipping(string Country,
                                                                                string locale,
                                                                                ShippingAddress_V01 address)
        {
            var final = new List <DeliveryOption>();

            if (HLConfigManager.Configurations.DOConfiguration.AllowHAP && OrderType.ToString().Equals("HSO"))
            {
                final.Add(new DeliveryOption(
                              new ShippingOption_V01(HLConfigManager.Configurations.ShoppingCartConfiguration.DefaultFreightCodeForHAP, "FedEx", DateTime.MinValue, DateTime.MaxValue)));
                return(final);
            }

            var proxy   = ServiceClientProvider.GetShippingServiceProxy();
            var request = new DeliveryOptionForCountryRequest_V01();

            request.Country = Country;
            request.State   = address.Address.StateProvinceTerritory.Trim();
            request.Locale  = locale;
            var response =
                proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;

            foreach (ShippingOption_V01 option in response.DeliveryAlternatives)
            {
                final.Add(new DeliveryOption(option));
            }

            return(final);
        }
Esempio n. 4
0
        private static List <DeliveryOption> GetDeliveryOptionsFromService(string Country,
                                                                           string locale,
                                                                           ShippingAddress_V01 address)
        {
            List <DeliveryOption> result = new List <DeliveryOption>();
            var proxy = ServiceClientProvider.GetShippingServiceProxy();
            DeliveryOptionForCountryRequest_V01 request = new DeliveryOptionForCountryRequest_V01();

            request.Country = Country;

            //request.State = request.State = (address != null && address.Address != null && !string.IsNullOrEmpty(address.Address.StateProvinceTerritory)) ? address.Address.StateProvinceTerritory : "HK";
            request.Locale = locale;
            ShippingAlternativesResponse_V01 response =
                proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;

            foreach (ShippingOption_V01 option in response.DeliveryAlternatives)
            {
                DeliveryOption currentOption = new DeliveryOption(option);
                currentOption.Name          = option.Description;
                currentOption.WarehouseCode = option.WarehouseCode;
                currentOption.State         = request.State;
                result.Add(currentOption);
            }
            return(result.OrderBy(d => d.displayIndex.ToString() + "_" + d.DisplayName).ToList());
        }
Esempio n. 5
0
        private static List <DeliveryOption> GetDeliveryOptionsFromService(string Country, string locale, ShippingAddress_V01 address, DeliveryOptionType type)
        {
            DeliveryPickupAlternativesResponse_V03 pickupAlternativesResponse = null;

            if (type == DeliveryOptionType.PickupFromCourier)
            {
                List <DeliveryOption> result = new List <DeliveryOption>();
                var proxy = ServiceClientProvider.GetShippingServiceProxy();
                pickupAlternativesResponse =
                    proxy.GetDeliveryPickupAlternatives(new GetDeliveryPickupAlternativesRequest(new DeliveryPickupAlternativesRequest_V03
                {
                    CountryCode = Country,
                    State       = string.Empty
                })).GetDeliveryPickupAlternativesResult as DeliveryPickupAlternativesResponse_V03;

                if (pickupAlternativesResponse != null && pickupAlternativesResponse.DeliveryPickupAlternatives != null)
                {
                    bool courier = false;
                    if (type == DeliveryOptionType.PickupFromCourier)
                    {
                        courier = true;
                    }
                    result.AddRange(
                        from po in pickupAlternativesResponse.DeliveryPickupAlternatives
                        select new DeliveryOption(po, courier));
                    Array.ForEach(result.ToArray(), a => a.Address = getAddress(pickupAlternativesResponse, a.Id));
                }

                return(result);
            }
            else
            {
                List <DeliveryOption> result = new List <DeliveryOption>();
                var proxy = ServiceClientProvider.GetShippingServiceProxy();
                DeliveryOptionForCountryRequest_V01 request = new DeliveryOptionForCountryRequest_V01();
                request.Country = Country;
                request.State   = (address != null && address.Address != null &&
                                   !string.IsNullOrEmpty(address.Address.StateProvinceTerritory))
                                    ? address.Address.StateProvinceTerritory
                                    : "Москва";
                request.Locale = locale;
                ShippingAlternativesResponse_V01 response =
                    proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;
                foreach (ShippingOption_V01 option in response.DeliveryAlternatives)
                {
                    DeliveryOption currentOption = new DeliveryOption(option);
                    currentOption.Name          = option.Description;
                    currentOption.WarehouseCode = option.WarehouseCode;
                    currentOption.State         = request.State;
                    currentOption.displayIndex  = option.DisplayOrder;
                    currentOption.DisplayName   = option.Description;
                    result.Add(currentOption);
                }
                //result.Sort((x, y) => x.displayIndex.CompareTo(y.displayIndex));
                return(result.OrderBy(d => d.displayIndex.ToString() + "_" + d.DisplayName).ToList());
            }
        }
        private DeliveryOption GetDeliveryOptionsListForShippingFromService(ShippingAddress_V01 address)
        {
            if (address != null && address.Address != null &&
                !string.IsNullOrEmpty(address.Address.StateProvinceTerritory) &&
                !string.IsNullOrEmpty(address.Address.City))
            {
                var cityState = IsValidShippingAddress(address.Address) ?
                                string.Format("{0}|{1}|{2}", address.Address.StateProvinceTerritory, address.Address.City, address.Address.Line4) :
                                string.Format("{0}|{1}|{2}|{3}", address.Address.StateProvinceTerritory, address.Address.CountyDistrict, address.Address.Line3, address.Address.Line4);
                var options = HttpRuntime.Cache[CacheKey] as Dictionary <string, DeliveryOption>;
                if (options == null || !options.ContainsKey(cityState))
                {
                    using (var proxy = ServiceClientProvider.GetShippingServiceProxy())
                    {
                        try
                        {
                            var request = new DeliveryOptionForCountryRequest_V01
                            {
                                Country = "GT",
                                State   = cityState,
                                Locale  = "es-GT"
                            };

                            var response = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;
                            if (response != null && response.DeliveryAlternatives != null && response.DeliveryAlternatives.Count > 0)
                            {
                                var shippingOption = response.DeliveryAlternatives.FirstOrDefault();
                                if (shippingOption != null)
                                {
                                    if (options == null)
                                    {
                                        options = new Dictionary <string, DeliveryOption>();
                                    }
                                    options.Add(cityState, new DeliveryOption(shippingOption));
                                    HttpRuntime.Cache.Insert(CacheKey, options, null, DateTime.Now.AddMinutes(GT_DELIVERYINFO_CACHE_MINUTES),
                                                             Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            LoggerHelper.Error(string.Format("GetDeliveryOptionsListForShippingFromService error: Country: GT, error: {0}", ex.ToString()));
                        }
                    }
                }
                if (options != null && options.ContainsKey(cityState))
                {
                    var deliveryOption = options.FirstOrDefault(o => o.Key == cityState);
                    return(deliveryOption.Value);
                }
            }

            return(null);
        }
        private static List <ShippingOption_V01> GetDeliveryOptionsFromService(string Country, string locale, ShippingAddress_V01 address)
        {
            var final   = new List <DeliveryOption>();
            var proxy   = ServiceClientProvider.GetShippingServiceProxy();
            var request = new DeliveryOptionForCountryRequest_V01();

            request.Country = Country;
            request.State   = string.IsNullOrWhiteSpace(address.Address.CountyDistrict)
                                      ? string.Format("{0}|{1}", address.Address.StateProvinceTerritory,
                                                      address.Address.City)
                                      : string.Format("{0}|{1}|{2}", address.Address.StateProvinceTerritory,
                                                      address.Address.City, address.Address.CountyDistrict);
            request.Locale = locale;
            var response = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;

            return(response.DeliveryAlternatives);
        }
        public override List <DeliveryOption> GetDeliveryOptionsListForShipping(string country, string locale, ShippingAddress_V01 address)
        {
            var final = new List <DeliveryOption>();

            if (!String.IsNullOrEmpty(address.Address.PostalCode))
            {
                int  postalCodeIntValue = 0;
                bool validCode          = int.TryParse(address.Address.PostalCode.Split('-')[0], out postalCodeIntValue);
                if (validCode)
                {
                    var deliveryOptionList = GetDeliveryOptionsListForShipping(locale);
                    if (deliveryOptionList.Count > 0)
                    {
                        foreach (var option in deliveryOptionList)
                        {
                            var minRange = 0;
                            var maxRange = 0;
                            var range    = option.PostalCode.Split('-');
                            if (range.Count() == 2 && int.TryParse(range[0], out minRange) &&
                                int.TryParse(range[1], out maxRange))
                            {
                                if (postalCodeIntValue >= minRange && postalCodeIntValue <= maxRange)
                                {
                                    final.Add(option);
                                }
                            }
                        }
                    }

                    if (final.Count == 0)
                    {
                        var proxy = ServiceClientProvider.GetShippingServiceProxy();
                        DeliveryOptionForCountryRequest_V01 request = new DeliveryOptionForCountryRequest_V01();
                        request.Country = country;
                        request.State   = String.Empty;
                        request.Locale  = locale;
                        ShippingAlternativesResponse_V01 response = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;
                        foreach (ShippingOption_V01 option in response.DeliveryAlternatives)
                        {
                            final.Add(new DeliveryOption(option));
                        }
                    }
                }
            }
            return(final);
        }
Esempio n. 9
0
        private string[] GetFreightCodeAndWarehouseFromService(string state)
        {
            var proxy   = ServiceClientProvider.GetShippingServiceProxy();
            var request = new DeliveryOptionForCountryRequest_V01
            {
                Country = "TH",
                Locale  = "th-TH",
                State   = state
            };
            var response       = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;
            var shippingOption = response.DeliveryAlternatives.FirstOrDefault();

            if (shippingOption != null)
            {
                return(new[] { shippingOption.FreightCode, shippingOption.WarehouseCode });
            }
            return(null);
        }
Esempio n. 10
0
        private static string[] GetFreightCodeAndWarehouseFromService(ShippingAddress_V01 address)
        {
            var proxy   = ServiceClientProvider.GetShippingServiceProxy();
            var request = new DeliveryOptionForCountryRequest_V01
            {
                Country = "AR",
                Locale  = "es-AR",
                State   = string.Format("{0}-{1}", address.Address.StateProvinceTerritory, address.Address.PostalCode)
            };
            var response       = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;
            var shippingOption = response.DeliveryAlternatives.FirstOrDefault();

            if (shippingOption != null)
            {
                return(new[] { shippingOption.FreightCode, shippingOption.WarehouseCode });
            }
            return(null);
        }
Esempio n. 11
0
        public override List <DeliveryOption> GetDeliveryOptionsListForShipping(string country,
                                                                                string locale,
                                                                                ShippingAddress_V01 address)
        {
            var final   = new List <DeliveryOption>();
            var proxy   = ServiceClientProvider.GetShippingServiceProxy();
            var request = new DeliveryOptionForCountryRequest_V01();

            request.Country = country;
            request.State   = String.Empty;
            request.Locale  = locale;
            var response = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;

            foreach (ShippingOption_V01 option in response.DeliveryAlternatives)
            {
                final.Add(new DeliveryOption(option));
            }
            return(final);
        }
Esempio n. 12
0
        private ShippingAlternativesResponse_V01 GetDeliveryOptionsFromService(string Country,
                                                                               string locale,
                                                                               ShippingAddress_V01 address)
        {
            var proxy   = ServiceClientProvider.GetShippingServiceProxy();
            var request = new DeliveryOptionForCountryRequest_V01();

            request.Country = Country;
            request.State   = address.Address.PostalCode.Substring(0, 2);
            request.Locale  = locale;
            var response = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;

            if (response.DeliveryAlternatives.Count == 0)
            {
                request.State = "*";
                response      = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;
            }
            return(response);
        }
        public override List <DeliveryOption> GetDeliveryOptionsListForPickup(string country,
                                                                              string locale,
                                                                              ShippingAddress_V01 address)
        {
            var cacheKey        = string.Format("{0}_FreightCodes_{1}", FedexLocationCacheKey, locale);
            var deliveryOptions = HttpRuntime.Cache[cacheKey] as List <DeliveryOption>;

            if (deliveryOptions == null)
            {
                deliveryOptions = new List <DeliveryOption>();
                var proxy   = ServiceClientProvider.GetShippingServiceProxy();
                var request = new DeliveryOptionForCountryRequest_V01
                {
                    Country = country,
                    State   = "*",
                    Locale  = locale
                };
                try
                {
                    var response = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;
                    if (response != null && response.DeliveryAlternatives.Count > 0)
                    {
                        deliveryOptions.AddRange(
                            response.DeliveryAlternatives.Where(option => option.FreightCode.StartsWith("H"))
                            .Select(option => new DeliveryOption(option)));
                    }
                    if (deliveryOptions.Any())
                    {
                        HttpRuntime.Cache.Insert(cacheKey, deliveryOptions, null,
                                                 DateTime.Now.AddMinutes(FedexCacheMinutes),
                                                 Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);
                    }
                }
                catch (Exception ex)
                {
                    LoggerHelper.Error(string.Format("GetDeliveryOptionsListForPickup error: Country: PR, error: {0}",
                                                     ex.Message));
                }
            }
            return(deliveryOptions);
        }
Esempio n. 14
0
        private static List <DeliveryOption> GetDeliveryOptionsFromService(string Country, string locale, ShippingAddress_V01 address)
        {
            List <DeliveryOption> result = new List <DeliveryOption>();
            var proxy = ServiceClientProvider.GetShippingServiceProxy();
            DeliveryOptionForCountryRequest_V01 request = new DeliveryOptionForCountryRequest_V01();

            request.Country = Country;
            request.State   = (address != null && address.Address != null && !string.IsNullOrEmpty(address.Address.City)) ? address.Address.City : string.Empty;
            request.Locale  = locale;
            ShippingAlternativesResponse_V01 response = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;

            foreach (ShippingOption_V01 option in response.DeliveryAlternatives)
            {
                DeliveryOption currentOption = new DeliveryOption(option);
                currentOption.State         = request.State;
                currentOption.WarehouseCode = option.WarehouseCode;
                currentOption.FreightCode   = option.FreightCode;
                result.Add(currentOption);
            }
            return(result.ToList());
        }
        private static string[] GetFreightCodeAndWarehouseFromService(string state)
        {
            var freightCodesAndWarehouses = HttpRuntime.Cache[cacheKey] as Dictionary <string, string[]> ?? new Dictionary <string, string[]>();

            var proxy   = ServiceClientProvider.GetShippingServiceProxy();
            var request = new DeliveryOptionForCountryRequest_V01
            {
                Country = "AU",
                Locale  = "en-AU",
                State   = state
            };
            var response       = proxy.GetDeliveryOptions(new GetDeliveryOptionsRequest(request)).GetDeliveryOptionsResult as ShippingAlternativesResponse_V01;
            var shippingOption = response.DeliveryAlternatives.FirstOrDefault();

            if (shippingOption != null)
            {
                var freightCodeAndWarehouse = new[] { shippingOption.FreightCode, shippingOption.WarehouseCode };
                freightCodesAndWarehouses.Add(state, freightCodeAndWarehouse);
                HttpRuntime.Cache.Insert(cacheKey, freightCodesAndWarehouses, null, DateTime.Now.AddMinutes(cacheMinutes), Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);
                return(freightCodeAndWarehouse);
            }

            return(null);
        }