Inheritance: ExtensibleDataObject
 /// <summary>
 /// Gets the shipping options.
 /// </summary>
 /// <param name="order"></param>
 /// <returns></returns>
 public ShippingOptionCollection GetShippingOptions(Order order)
 {
     ShippingOptionCollection shippingOptionCollection = new ShippingOptionCollection();
       SimpleWeightShippingRateCollection simpleWeightShippingRateCollection = new SimpleWeightShippingRateController().FetchAll();
       ShippingOption shippingOption;
       foreach(SimpleWeightShippingRate simpleWeightShippingRate in simpleWeightShippingRateCollection) {
     shippingOption = new ShippingOption();
     shippingOption.Service = simpleWeightShippingRate.Service;
     shippingOption.Rate = simpleWeightShippingRate.AmountPerUnit * order.TotalWeight;
     shippingOptionCollection.Add(shippingOption);
       }
       return shippingOptionCollection;
 }
        /// <summary>
        ///  Gets available shipping options
        /// </summary>
        /// <param name="shipmentPackage">Shipment package</param>
        /// <param name="error">Error</param>
        /// <returns>Shipping options</returns>
        public List <ShippingOption> GetShippingOptions(ShipmentPackage shipmentPackage, ref string error)
        {
            var shippingOptions = new List <ShippingOption>();

            if (shipmentPackage == null)
            {
                throw new ArgumentNullException("shipmentPackage");
            }
            if (shipmentPackage.Items == null)
            {
                throw new NopException("No shipment items");
            }
            if (shipmentPackage.ShippingAddress == null)
            {
                error = "Shipping address is not set";
                return(shippingOptions);
            }
            if (shipmentPackage.ShippingAddress.Country == null)
            {
                error = "Shipping country is not set";
                return(shippingOptions);
            }

            var shippingMethods = ShippingMethodManager.GetAllShippingMethods(shipmentPackage.ShippingAddress.CountryId);

            foreach (var shippingMethod in shippingMethods)
            {
                var shippingOption = new ShippingOption();
                shippingOption.Name        = shippingMethod.Name;
                shippingOption.Description = shippingMethod.Description;
                shippingOption.Rate        = GetRate();
                shippingOptions.Add(shippingOption);
            }

            return(shippingOptions);
        }
Esempio n. 3
0
        /// <summary>
        /// get shipping method model.
        /// </summary>
        /// <param name="customer">The customer.</param>
        /// <param name="storeId">The store ID.</param>
        /// <returns>The shipping method model.</returns>
        protected ShippingMethodModel GetShippingMethodModel(Customer customer, int storeId)
        {
            ShippingOption selectedShippingOption = null;

            try
            {
                selectedShippingOption = customer.GetAttribute <ShippingOption>(SystemCustomerAttributeNames.SelectedShippingOption, storeId);
            }
            catch
            {
                // ignored
            }

            var shippingOption = selectedShippingOption != null ?
                                 new ShippingMethodModel
            {
                SystemName  = selectedShippingOption.ShippingRateComputationMethodSystemName,
                Name        = selectedShippingOption.Name,
                Description = selectedShippingOption.Description
            }
              : null;

            return(shippingOption);
        }
Esempio n. 4
0
        private List <ShippingOption> ParseResponse(string response, bool isDomestic, ref string error)
        {
            var shippingOptions = new List <ShippingOption>();

            string postageStr             = isDomestic ? "Postage" : "Service";
            string mailServiceStr         = isDomestic ? "MailService" : "SvcDescription";
            string rateStr                = isDomestic ? "Rate" : "Postage";
            string classStr               = isDomestic ? "CLASSID" : "ID";
            string carrierServicesOffered = String.Empty;

            if (isDomestic)
            {
                carrierServicesOffered = IoC.Resolve <ISettingManager>().GetSettingValue("ShippingRateComputationMethod.USPS.CarrierServicesOfferedDomestic", string.Empty);
            }
            else
            {
                carrierServicesOffered = IoC.Resolve <ISettingManager>().GetSettingValue("ShippingRateComputationMethod.USPS.CarrierServicesOfferedInternational", string.Empty);
            }

            using (var sr = new StringReader(response))
                using (var tr = new XmlTextReader(sr))
                {
                    do
                    {
                        tr.Read();

                        if ((tr.Name == "Error") && (tr.NodeType == XmlNodeType.Element))
                        {
                            string errorText = "";
                            while (tr.Read())
                            {
                                if ((tr.Name == "Description") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    errorText += "Error Desc: " + tr.ReadString();
                                }
                                if ((tr.Name == "HelpContext") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    errorText += "USPS Help Context: " + tr.ReadString() + ". ";
                                }
                            }
                            error = "USPS Error returned: " + errorText;
                        }

                        if ((tr.Name == postageStr) && (tr.NodeType == XmlNodeType.Element))
                        {
                            string serviceId = string.Empty;

                            // Find the ID for the service
                            if (tr.HasAttributes)
                            {
                                for (int i = 0; i < tr.AttributeCount; i++)
                                {
                                    tr.MoveToAttribute(i);
                                    if (tr.Name.Equals(classStr))
                                    {
                                        // Add delimiters [] so that single digit IDs aren't found in mutli-digit IDs
                                        serviceId = String.Format("[{0}]", tr.Value);
                                        break;
                                    }
                                }
                            }

                            // Go to the next rate if the service ID is not in the list of services to offer
                            if (!String.IsNullOrEmpty(serviceId) &&
                                !String.IsNullOrEmpty(carrierServicesOffered) &&
                                !carrierServicesOffered.Contains(serviceId))
                            {
                                continue;
                            }

                            string serviceCode = string.Empty;
                            string postalRate  = string.Empty;

                            do
                            {
                                tr.Read();

                                if ((tr.Name == mailServiceStr) && (tr.NodeType == XmlNodeType.Element))
                                {
                                    serviceCode = tr.ReadString();

                                    tr.ReadEndElement();
                                    if ((tr.Name == mailServiceStr) && (tr.NodeType == XmlNodeType.EndElement))
                                    {
                                        break;
                                    }
                                }

                                if ((tr.Name == rateStr) && (tr.NodeType == XmlNodeType.Element))
                                {
                                    postalRate = tr.ReadString();
                                    tr.ReadEndElement();
                                    if ((tr.Name == rateStr) && (tr.NodeType == XmlNodeType.EndElement))
                                    {
                                        break;
                                    }
                                }
                            }while (!((tr.Name == postageStr) && (tr.NodeType == XmlNodeType.EndElement)));

                            if (shippingOptions.Find((s) => s.Name == serviceCode) == null)
                            {
                                var shippingOption = new ShippingOption();
                                //TODO check whether we need to multiply rate by package quantity
                                shippingOption.Rate = Convert.ToDecimal(postalRate, new CultureInfo("en-US"));
                                shippingOption.Name = serviceCode;
                                shippingOptions.Add(shippingOption);
                            }
                        }
                    }while (!tr.EOF);
                }
            return(shippingOptions);
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="GetShippingMethodsRequest"/> class.
 /// </summary>
 /// <param name="language">The language.</param>
 /// <param name="shippingOption">The shipping option.</param>
 /// <param name="party">The party.</param>
 public GetShippingMethodsRequest(string language, ShippingOption shippingOption, Party party = null)
     : base(language, shippingOption, party)
 {
 }
Esempio n. 6
0
        private ShippingOption RequestShippingOption(string zipPostalCodeFrom,
                                                     string zipPostalCodeTo, string countryCode, string serviceType,
                                                     int weight, int length, int width, int height, int quantity)
        {
            var shippingOption = new ShippingOption();
            var sb             = new StringBuilder();

            sb.AppendFormat(GetGatewayUrl());
            sb.AppendFormat("?Pickup_Postcode={0}&", zipPostalCodeFrom);
            sb.AppendFormat("Destination_Postcode={0}&", zipPostalCodeTo);
            sb.AppendFormat("Country={0}&", countryCode);
            sb.AppendFormat("Service_Type={0}&", serviceType);
            sb.AppendFormat("Weight={0}&", weight);
            sb.AppendFormat("Length={0}&", length);
            sb.AppendFormat("Width={0}&", width);
            sb.AppendFormat("Height={0}&", height);
            sb.AppendFormat("Quantity={0}", quantity);

            HttpWebRequest request = WebRequest.Create(sb.ToString()) as HttpWebRequest;

            request.Method = "GET";
            //request.ContentType = "application/x-www-form-urlencoded";
            //byte[] reqContent = Encoding.ASCII.GetBytes(sb.ToString());
            //request.ContentLength = reqContent.Length;
            //using (Stream newStream = request.GetRequestStream())
            //{
            //    newStream.Write(reqContent, 0, reqContent.Length);
            //}

            WebResponse response = request.GetResponse();
            string      rspContent;

            using (StreamReader reader = new StreamReader(response.GetResponseStream()))
            {
                rspContent = reader.ReadToEnd();
            }

            string[] tmp = rspContent.Split(new char[] { '\n' }, 3);
            if (tmp.Length != 3)
            {
                throw new NasException("Response is not valid.");
            }

            var rspParams = new NameValueCollection();

            foreach (string s in tmp)
            {
                string[] tmp2 = s.Split(new char[] { '=' });
                if (tmp2.Length != 2)
                {
                    throw new NasException("Response is not valid.");
                }
                rspParams.Add(tmp2[0].Trim(), tmp2[1].Trim());
            }


            string err_msg = rspParams["err_msg"];

            if (!err_msg.ToUpperInvariant().StartsWith("OK"))
            {
                throw new NasException(err_msg);
            }

            var serviceName = GetServiceNameByType(serviceType);

            if (serviceName != null && !serviceName.StartsWith("Australia Post.", StringComparison.InvariantCultureIgnoreCase))
            {
                serviceName = string.Format("Australia Post. {0}", serviceName);
            }
            shippingOption.Name        = serviceName;
            shippingOption.Description = String.Format("{0} Days", rspParams["days"]);
            shippingOption.Rate        = Decimal.Parse(rspParams["charge"]);

            return(shippingOption);
        }
        private void processNewOrderNotification(string xmlData)
        {
            try
            {
                NewOrderNotification newOrderNotification = (NewOrderNotification)EncodeHelper.Deserialize(xmlData, typeof(NewOrderNotification));
                string googleOrderNumber = newOrderNotification.googleordernumber;

                XmlNode  CustomerInfo       = newOrderNotification.shoppingcart.merchantprivatedata.Any[0];
                int      CustomerID         = Convert.ToInt32(CustomerInfo.Attributes["CustomerID"].Value);
                int      CustomerLanguageID = Convert.ToInt32(CustomerInfo.Attributes["CustomerLanguageID"].Value);
                int      CustomerCurrencyID = Convert.ToInt32(CustomerInfo.Attributes["CustomerCurrencyID"].Value);
                Customer customer           = CustomerManager.GetCustomerById(CustomerID);

                NopSolutions.NopCommerce.BusinessLogic.Orders.ShoppingCart Cart = ShoppingCartManager.GetCustomerShoppingCart(customer.CustomerId, ShoppingCartTypeEnum.ShoppingCart);

                if (customer == null)
                {
                    logMessage("Could not load a customer");
                    return;
                }

                NopContext.Current.User = customer;

                if (Cart.Count == 0)
                {
                    logMessage("Cart is empty");
                    return;
                }

                //validate cart
                foreach (NopSolutions.NopCommerce.BusinessLogic.Orders.ShoppingCartItem sci in Cart)
                {
                    bool ok = false;
                    foreach (Item item in newOrderNotification.shoppingcart.items)
                    {
                        if (!String.IsNullOrEmpty(item.merchantitemid))
                        {
                            if ((Convert.ToInt32(item.merchantitemid) == sci.ShoppingCartItemId) && (item.quantity == sci.Quantity))
                            {
                                ok = true;
                                break;
                            }
                        }
                    }

                    if (!ok)
                    {
                        logMessage(string.Format("Shopping Cart item has been changed. {0}. {1}", sci.ShoppingCartItemId, sci.Quantity));
                        return;
                    }
                }


                string[] billingFullname  = newOrderNotification.buyerbillingaddress.contactname.Trim().Split(new char[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
                string   billingFirstName = billingFullname[0];
                string   billingLastName  = string.Empty;
                if (billingFullname.Length > 1)
                {
                    billingLastName = billingFullname[1];
                }
                string        billingEmail           = newOrderNotification.buyerbillingaddress.email.Trim();
                string        billingAddress1        = newOrderNotification.buyerbillingaddress.address1.Trim();
                string        billingAddress2        = newOrderNotification.buyerbillingaddress.address2.Trim();
                string        billingPhoneNumber     = newOrderNotification.buyerbillingaddress.phone.Trim();
                string        billingCity            = newOrderNotification.buyerbillingaddress.city.Trim();
                int           billingStateProvinceID = 0;
                StateProvince billingStateProvince   = StateProvinceManager.GetStateProvinceByAbbreviation(newOrderNotification.buyerbillingaddress.region.Trim());
                if (billingStateProvince != null)
                {
                    billingStateProvinceID = billingStateProvince.StateProvinceId;
                }
                string  billingZipPostalCode = newOrderNotification.buyerbillingaddress.postalcode.Trim();
                int     billingCountryID     = 0;
                Country billingCountry       = CountryManager.GetCountryByTwoLetterIsoCode(newOrderNotification.buyerbillingaddress.countrycode.Trim());
                if (billingCountry != null)
                {
                    billingCountryID = billingCountry.CountryId;
                }

                NopSolutions.NopCommerce.BusinessLogic.CustomerManagement.Address BillingAddress = customer.BillingAddresses.FindAddress(
                    billingFirstName, billingLastName, billingPhoneNumber,
                    billingEmail, string.Empty, string.Empty, billingAddress1, billingAddress2, billingCity,
                    billingStateProvinceID, billingZipPostalCode, billingCountryID);

                if (BillingAddress == null)
                {
                    BillingAddress = CustomerManager.InsertAddress(CustomerID, true,
                                                                   billingFirstName, billingLastName, billingPhoneNumber, billingEmail,
                                                                   string.Empty, string.Empty, billingAddress1,
                                                                   billingAddress2, billingCity,
                                                                   billingStateProvinceID, billingZipPostalCode,
                                                                   billingCountryID, DateTime.Now, DateTime.Now);
                }
                customer = CustomerManager.SetDefaultBillingAddress(customer.CustomerId, BillingAddress.AddressId);

                NopSolutions.NopCommerce.BusinessLogic.CustomerManagement.Address ShippingAddress = null;
                customer.LastShippingOption = null;
                bool shoppingCartRequiresShipping = ShippingManager.ShoppingCartRequiresShipping(Cart);
                if (shoppingCartRequiresShipping)
                {
                    string[] shippingFullname  = newOrderNotification.buyershippingaddress.contactname.Trim().Split(new char[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
                    string   shippingFirstName = shippingFullname[0];
                    string   shippingLastName  = string.Empty;
                    if (shippingFullname.Length > 1)
                    {
                        shippingLastName = shippingFullname[1];
                    }
                    string        shippingEmail           = newOrderNotification.buyershippingaddress.email.Trim();
                    string        shippingAddress1        = newOrderNotification.buyershippingaddress.address1.Trim();
                    string        shippingAddress2        = newOrderNotification.buyershippingaddress.address2.Trim();
                    string        shippingPhoneNumber     = newOrderNotification.buyershippingaddress.phone.Trim();
                    string        shippingCity            = newOrderNotification.buyershippingaddress.city.Trim();
                    int           shippingStateProvinceID = 0;
                    StateProvince shippingStateProvince   = StateProvinceManager.GetStateProvinceByAbbreviation(newOrderNotification.buyershippingaddress.region.Trim());
                    if (shippingStateProvince != null)
                    {
                        shippingStateProvinceID = shippingStateProvince.StateProvinceId;
                    }
                    int     shippingCountryID     = 0;
                    string  shippingZipPostalCode = newOrderNotification.buyershippingaddress.postalcode.Trim();
                    Country shippingCountry       = CountryManager.GetCountryByTwoLetterIsoCode(newOrderNotification.buyershippingaddress.countrycode.Trim());
                    if (shippingCountry != null)
                    {
                        shippingCountryID = shippingCountry.CountryId;
                    }

                    ShippingAddress = customer.ShippingAddresses.FindAddress(
                        shippingFirstName, shippingLastName, shippingPhoneNumber,
                        shippingEmail, string.Empty, string.Empty,
                        shippingAddress1, shippingAddress2, shippingCity,
                        shippingStateProvinceID, shippingZipPostalCode, shippingCountryID);
                    if (ShippingAddress == null)
                    {
                        ShippingAddress = CustomerManager.InsertAddress(CustomerID, false,
                                                                        shippingFirstName, shippingLastName, shippingPhoneNumber, shippingEmail,
                                                                        string.Empty, string.Empty, shippingAddress1,
                                                                        shippingAddress2, shippingCity, shippingStateProvinceID,
                                                                        shippingZipPostalCode, shippingCountryID,
                                                                        DateTime.Now, DateTime.Now);
                    }

                    customer = CustomerManager.SetDefaultShippingAddress(customer.CustomerId, ShippingAddress.AddressId);

                    string  shippingMethod = string.Empty;
                    decimal shippingCost   = decimal.Zero;
                    if (newOrderNotification.orderadjustment != null &&
                        newOrderNotification.orderadjustment.shipping != null &&
                        newOrderNotification.orderadjustment.shipping.Item != null)
                    {
                        FlatRateShippingAdjustment ShippingMethod = (FlatRateShippingAdjustment)newOrderNotification.orderadjustment.shipping.Item;
                        shippingMethod = ShippingMethod.shippingname;
                        shippingCost   = ShippingMethod.shippingcost.Value;


                        ShippingOption shippingOption = new ShippingOption();
                        shippingOption.Name         = shippingMethod;
                        shippingOption.Rate         = shippingCost;
                        customer.LastShippingOption = shippingOption;
                    }
                }

                //customer.LastCalculatedTax = decimal.Zero;

                PaymentMethod googleCheckoutPaymentMethod = PaymentMethodManager.GetPaymentMethodBySystemKeyword("GoogleCheckout");

                PaymentInfo paymentInfo = new PaymentInfo();
                paymentInfo.PaymentMethodId   = googleCheckoutPaymentMethod.PaymentMethodId;
                paymentInfo.BillingAddress    = BillingAddress;
                paymentInfo.ShippingAddress   = ShippingAddress;
                paymentInfo.CustomerLanguage  = LanguageManager.GetLanguageById(CustomerLanguageID);
                paymentInfo.CustomerCurrency  = CurrencyManager.GetCurrencyById(CustomerCurrencyID);
                paymentInfo.GoogleOrderNumber = googleOrderNumber;
                int    orderID = 0;
                string result  = OrderManager.PlaceOrder(paymentInfo, customer, out orderID);
                if (!String.IsNullOrEmpty(result))
                {
                    logMessage("new-order-notification received. CreateOrder() error: Order Number " + orderID + ". " + result);
                    return;
                }

                Order order = OrderManager.GetOrderById(orderID);
                logMessage("new-order-notification received and saved: Order Number " + orderID);
            }
            catch (Exception exc)
            {
                logMessage("processNewOrderNotification Exception: " + exc.Message + ": " + exc.StackTrace);
            }
        }
        /// <summary>
        ///  Gets available shipping options
        /// </summary>
        /// <param name="request">A request for getting shipping options</param>
        /// <returns>Represents a response of getting shipping rate options</returns>
        public GetShippingOptionResponse GetShippingOptions(GetShippingOptionRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("getShippingOptionRequest");
            }

            var response = new GetShippingOptionResponse();

            if (request.Items == null || request.Items.Count == 0)
            {
                response.AddError(T("Admin.System.Warnings.NoShipmentItems"));
                return(response);
            }

            int     storeId         = request.StoreId > 0 ? request.StoreId : _storeContext.CurrentStore.Id;
            var     taxRate         = decimal.Zero;
            decimal subTotalInclTax = decimal.Zero;
            decimal subTotalExclTax = decimal.Zero;
            decimal currentSubTotal = decimal.Zero;
            int     countryId       = 0;
            string  zip             = null;

            if (request.ShippingAddress != null)
            {
                countryId = request.ShippingAddress.CountryId ?? 0;
                zip       = request.ShippingAddress.ZipPostalCode;
            }

            foreach (var shoppingCartItem in request.Items)
            {
                if (shoppingCartItem.Item.IsFreeShipping || !shoppingCartItem.Item.IsShipEnabled)
                {
                    continue;
                }

                var itemSubTotal = _priceCalculationService.GetSubTotal(shoppingCartItem, true);

                var itemSubTotalInclTax = _taxService.GetProductPrice(shoppingCartItem.Item.Product, itemSubTotal, true, request.Customer, out taxRate);
                subTotalInclTax += itemSubTotalInclTax;

                var itemSubTotalExclTax = _taxService.GetProductPrice(shoppingCartItem.Item.Product, itemSubTotal, false, request.Customer, out taxRate);
                subTotalExclTax += itemSubTotalExclTax;
            }

            var weight          = _shippingService.GetShoppingCartTotalWeight(request.Items, _shippingByWeightSettings.IncludeWeightOfFreeShippingProducts);
            var shippingMethods = _shippingService.GetAllShippingMethods(request, storeId);

            currentSubTotal = _services.WorkContext.TaxDisplayType == TaxDisplayType.ExcludingTax ? subTotalExclTax : subTotalInclTax;

            foreach (var shippingMethod in shippingMethods)
            {
                var record = _shippingByWeightService.FindRecord(shippingMethod.Id, storeId, countryId, weight, zip);

                decimal?rate = GetRate(subTotalInclTax, weight, shippingMethod.Id, storeId, countryId, zip);
                if (rate.HasValue)
                {
                    var shippingOption = new ShippingOption();
                    shippingOption.ShippingMethodId = shippingMethod.Id;
                    shippingOption.Name             = shippingMethod.GetLocalized(x => x.Name);

                    if (record != null && record.SmallQuantityThreshold > currentSubTotal)
                    {
                        string surchargeHint = T("Plugins.Shipping.ByWeight.SmallQuantitySurchargeNotReached",
                                                 _priceFormatter.FormatPrice(record.SmallQuantitySurcharge),
                                                 _priceFormatter.FormatPrice(record.SmallQuantityThreshold));

                        shippingOption.Description = shippingMethod.GetLocalized(x => x.Description) + surchargeHint;
                        shippingOption.Rate        = rate.Value + record.SmallQuantitySurcharge;
                    }
                    else
                    {
                        shippingOption.Description = shippingMethod.GetLocalized(x => x.Description);
                        shippingOption.Rate        = rate.Value;
                    }
                    response.ShippingOptions.Add(shippingOption);
                }
            }

            return(response);
        }
Esempio n. 9
0
 public static void NavigateToPaymentFormStep4(this INavigationService service, MessageViewModel message, PaymentForm paymentForm, OrderInfo info, ValidatedOrderInfo validatedInfo, ShippingOption shipping)
 {
     service.Navigate(typeof(PaymentFormStep4Page), Tuple.Create(message, paymentForm, info, validatedInfo, shipping));
 }
Esempio n. 10
0
        /// <summary>
        ///  Gets available shipping options
        /// </summary>
        /// <param name="getShippingOptionRequest">A request for getting shipping options</param>
        /// <returns>Represents a response of getting shipping rate options</returns>
        public GetShippingOptionResponse GetShippingOptions(GetShippingOptionRequest getShippingOptionRequest)
        {
            if (getShippingOptionRequest == null)
            {
                throw new ArgumentNullException("getShippingOptionRequest");
            }

            var response = new GetShippingOptionResponse();

            if (getShippingOptionRequest.Items == null || getShippingOptionRequest.Items.Count == 0)
            {
                response.AddError(T("Admin.System.Warnings.NoShipmentItems"));
                return(response);
            }

            int     countryId       = 0;
            int     stateProvinceId = 0;
            string  zip             = null;
            decimal subTotal        = decimal.Zero;
            int     storeId         = _storeContext.CurrentStore.Id;

            if (getShippingOptionRequest.ShippingAddress != null)
            {
                countryId       = getShippingOptionRequest.ShippingAddress.CountryId ?? 0;
                stateProvinceId = getShippingOptionRequest.ShippingAddress.StateProvinceId ?? 0;
                zip             = getShippingOptionRequest.ShippingAddress.ZipPostalCode;
            }

            foreach (var shoppingCartItem in getShippingOptionRequest.Items)
            {
                if (shoppingCartItem.Item.IsFreeShipping || !shoppingCartItem.Item.IsShipEnabled)
                {
                    continue;
                }
                subTotal += _priceCalculationService.GetSubTotal(shoppingCartItem, true);
            }

            decimal sqThreshold = _shippingByTotalSettings.SmallQuantityThreshold;
            decimal sqSurcharge = _shippingByTotalSettings.SmallQuantitySurcharge;

            var shippingMethods = _shippingService.GetAllShippingMethods(getShippingOptionRequest);

            foreach (var shippingMethod in shippingMethods)
            {
                decimal?rate = GetRate(subTotal, shippingMethod.Id, storeId, countryId, stateProvinceId, zip);
                if (rate.HasValue)
                {
                    if (rate > 0 && sqThreshold > 0 && subTotal <= sqThreshold)
                    {
                        // add small quantity surcharge (Mindermengenzuschalg)
                        rate += sqSurcharge;
                    }

                    var shippingOption = new ShippingOption();
                    shippingOption.ShippingMethodId = shippingMethod.Id;
                    shippingOption.Name             = shippingMethod.Name;
                    shippingOption.Description      = shippingMethod.Description;
                    shippingOption.Rate             = rate.Value;
                    response.ShippingOptions.Add(shippingOption);
                }
            }

            return(response);
        }
Esempio n. 11
0
        /// <summary>
        ///  Gets available shipping options
        /// </summary>
        /// <param name="getShippingOptionRequest">A request for getting shipping options</param>
        /// <returns>Represents a response of getting shipping rate options</returns>
        public GetShippingOptionResponse GetShippingOptions(GetShippingOptionRequest getShippingOptionRequest)
        {
            if (getShippingOptionRequest == null)
            {
                throw new ArgumentNullException("getShippingOptionRequest");
            }

            var response = new GetShippingOptionResponse();

            if (getShippingOptionRequest.Items == null || getShippingOptionRequest.Items.Count == 0)
            {
                response.AddError("No shipment items");
                return(response);
            }

            int     storeId   = _storeContext.CurrentStore.Id;
            decimal subTotal  = decimal.Zero;
            int     countryId = 0;

            if (getShippingOptionRequest.ShippingAddress != null)
            {
                countryId = getShippingOptionRequest.ShippingAddress.CountryId ?? 0;
            }

            foreach (var shoppingCartItem in getShippingOptionRequest.Items)
            {
                if (shoppingCartItem.Item.IsFreeShipping || !shoppingCartItem.Item.IsShipEnabled)
                {
                    continue;
                }
                subTotal += _priceCalculationService.GetSubTotal(shoppingCartItem, true);
            }
            decimal weight = _shippingService.GetShoppingCartTotalWeight(getShippingOptionRequest.Items);

            var shippingMethods = _shippingService.GetAllShippingMethods(countryId);

            foreach (var shippingMethod in shippingMethods)
            {
                var record = _shippingByWeightService.FindRecord(shippingMethod.Id, storeId, countryId, weight);

                decimal?rate = GetRate(subTotal, weight, shippingMethod.Id, storeId, countryId);
                if (rate.HasValue)
                {
                    var shippingOption = new ShippingOption();
                    shippingOption.Name = shippingMethod.GetLocalized(x => x.Name);

                    if (record != null && record.SmallQuantityThreshold > subTotal)
                    {
                        shippingOption.Description = shippingMethod.GetLocalized(x => x.Description)
                                                     + _localizationService.GetResource("Plugin.Shipping.ByWeight.SmallQuantitySurchargeNotReached").FormatWith(
                            _priceFormatter.FormatPrice(record.SmallQuantitySurcharge),
                            _priceFormatter.FormatPrice(record.SmallQuantityThreshold));

                        shippingOption.Rate = rate.Value + record.SmallQuantitySurcharge;
                    }
                    else
                    {
                        shippingOption.Description = shippingMethod.GetLocalized(x => x.Description);
                        shippingOption.Rate        = rate.Value;
                    }
                    response.ShippingOptions.Add(shippingOption);
                }
            }


            return(response);
        }
Esempio n. 12
0
        public async Task Should_Throw_When_Answer_Shipping_Query_With_Duplicate_Shipping_Id()
        {
            const string payload = "my-payload";

            LabeledPrice[] productPrices =
            {
                new LabeledPrice("PART_OF_PRODUCT_PRICE_1",  150),
                new LabeledPrice("PART_OF_PRODUCT_PRICE_2", 2029),
            };
            Invoice invoice = new Invoice
            {
                Title          = "PRODUCT_TITLE",
                Currency       = "USD",
                StartParameter = "start_param",
                TotalAmount    = productPrices.Sum(p => p.Amount),
                Description    = "PRODUCT_DESCRIPTION",
            };

            await _fixture.BotClient.SendInvoiceAsync(
                chatId : (int)_classFixture.PrivateChat.Id,
                title : invoice.Title,
                description : invoice.Description,
                payload : payload,
                providerToken : _classFixture.PaymentProviderToken,
                startParameter : invoice.StartParameter,
                currency : invoice.Currency,
                prices : productPrices,
                isFlexible : true
                );

            LabeledPrice[] shippingPrices =
            {
                new LabeledPrice("PART_OF_SHIPPING_TOTAL_PRICE_1", 500),
                new LabeledPrice("PART_OF_SHIPPING_TOTAL_PRICE_2", 299),
            };

            ShippingOption shippingOption = new ShippingOption
            {
                Id     = "option1",
                Title  = "OPTION-1",
                Prices = shippingPrices,
            };

            Update shippingUpdate = await GetShippingQueryUpdate();

            ApiRequestException exception = await Assert.ThrowsAnyAsync <ApiRequestException>(() =>
                                                                                              _fixture.BotClient.AnswerShippingQueryAsync(
                                                                                                  shippingQueryId: shippingUpdate.ShippingQuery.Id,
                                                                                                  shippingOptions: new[] { shippingOption, shippingOption }
                                                                                                  )
                                                                                              );

            // ToDo: Add exception
            Assert.Equal(400, exception.ErrorCode);
            Assert.Equal("Bad Request: SHIPPING_ID_DUPLICATE", exception.Message);

            await _fixture.BotClient.AnswerShippingQueryAsync(
                shippingQueryId : shippingUpdate.ShippingQuery.Id,
                errorMessage : "✅ Test Passed"
                );
        }
        /// <summary>
        /// Gets shopping cart shipping total
        /// </summary>
        /// <param name="cart">Cart</param>
        /// <param name="includingTax">A value indicating whether calculated price should include tax</param>
        /// <param name="taxRate">Applied tax rate</param>
        /// <param name="appliedDiscount">Applied discount</param>
        /// <returns>Shipping total</returns>
        public virtual decimal?GetShoppingCartShippingTotal(IList <ShoppingCartItem> cart, bool includingTax,
                                                            out decimal taxRate, out Discount appliedDiscount)
        {
            decimal?shippingTotal      = null;
            decimal?shippingTotalTaxed = null;

            appliedDiscount = null;
            taxRate         = decimal.Zero;

            var customer = cart.GetCustomer();

            bool isFreeShipping = IsFreeShipping(cart);

            if (isFreeShipping)
            {
                return(decimal.Zero);
            }

            ShippingOption shippingOption = null;

            if (customer != null)
            {
                shippingOption = customer.GetAttribute <ShippingOption>(SystemCustomerAttributeNames.SelectedShippingOption, _genericAttributeService, _storeContext.CurrentStore.Id);
            }

            if (shippingOption != null)
            {
                //use last shipping option (get from cache)

                var pickUpInStore = _shippingSettings.AllowPickUpInStore &&
                                    customer.GetAttribute <bool>(SystemCustomerAttributeNames.SelectedPickUpInStore, _storeContext.CurrentStore.Id);
                if (pickUpInStore)
                {
                    //"pick up in store" fee
                    //we do not adjust shipping rate ("AdjustShippingRate" method) for pickup in store
                    shippingTotal = _shippingSettings.PickUpInStoreFee;
                }
                else
                {
                    //adjust shipping rate
                    shippingTotal = AdjustShippingRate(shippingOption.Rate, cart, out appliedDiscount);
                }
            }
            else
            {
                //use fixed rate (if possible)
                Address shippingAddress = null;
                if (customer != null)
                {
                    shippingAddress = customer.ShippingAddress;
                }

                var shippingRateComputationMethods = _shippingService.LoadActiveShippingRateComputationMethods(_storeContext.CurrentStore.Id);
                if (shippingRateComputationMethods == null || shippingRateComputationMethods.Count == 0)
                {
                    throw new NopException("Shipping rate computation method could not be loaded");
                }

                if (shippingRateComputationMethods.Count == 1)
                {
                    var shippingRateComputationMethod = shippingRateComputationMethods[0];

                    var     shippingOptionRequests = _shippingService.CreateShippingOptionRequests(cart, shippingAddress);
                    decimal?fixedRate = null;
                    foreach (var shippingOptionRequest in shippingOptionRequests)
                    {
                        //calculate fixed rates for each request-package
                        var fixedRateTmp = shippingRateComputationMethod.GetFixedRate(shippingOptionRequest);
                        if (fixedRateTmp.HasValue)
                        {
                            if (!fixedRate.HasValue)
                            {
                                fixedRate = decimal.Zero;
                            }

                            fixedRate += fixedRateTmp.Value;
                        }
                    }

                    if (fixedRate.HasValue)
                    {
                        //adjust shipping rate
                        shippingTotal = AdjustShippingRate(fixedRate.Value, cart, out appliedDiscount);
                    }
                }
            }

            if (shippingTotal.HasValue)
            {
                if (shippingTotal.Value < decimal.Zero)
                {
                    shippingTotal = decimal.Zero;
                }

                //round
                if (_shoppingCartSettings.RoundPricesDuringCalculation)
                {
                    shippingTotal = RoundingHelper.RoundPrice(shippingTotal.Value);
                }

                shippingTotalTaxed = _taxService.GetShippingPrice(shippingTotal.Value,
                                                                  includingTax,
                                                                  customer,
                                                                  out taxRate);

                //round
                if (_shoppingCartSettings.RoundPricesDuringCalculation)
                {
                    shippingTotalTaxed = RoundingHelper.RoundPrice(shippingTotalTaxed.Value);
                }
            }

            return(shippingTotalTaxed);
        }
        /// <summary>
        ///  Gets available shipping options
        /// </summary>
        /// <param name="getShippingOptionRequest">A request for getting shipping options</param>
        /// <returns>Represents a response of getting shipping rate options</returns>
        public GetShippingOptionResponse GetShippingOptions(GetShippingOptionRequest getShippingOptionRequest)
        {
            if (getShippingOptionRequest == null)
            {
                throw new ArgumentNullException("getShippingOptionRequest");
            }

            var response = new GetShippingOptionResponse();

            if (getShippingOptionRequest.Items == null || !getShippingOptionRequest.Items.Any())
            {
                response.AddError("No shipment items");
                return(response);
            }

            //choose the shipping rate calculation method
            if (_fixedOrByWeightSettings.ShippingByWeightEnabled)
            {
                //shipping rate calculation by products weight

                if (getShippingOptionRequest.ShippingAddress == null)
                {
                    response.AddError("Shipping address is not set");
                    return(response);
                }

                var storeId = getShippingOptionRequest.StoreId;

                if (storeId == 0)
                {
                    storeId = _storeContext.CurrentStore.Id;
                }

                var countryId       = getShippingOptionRequest.ShippingAddress.CountryId.HasValue ? getShippingOptionRequest.ShippingAddress.CountryId.Value : 0;
                var stateProvinceId = getShippingOptionRequest.ShippingAddress.StateProvinceId.HasValue ? getShippingOptionRequest.ShippingAddress.StateProvinceId.Value : 0;
                var warehouseId     = getShippingOptionRequest.WarehouseFrom != null ? getShippingOptionRequest.WarehouseFrom.Id : 0;
                var zip             = getShippingOptionRequest.ShippingAddress.ZipPostalCode;
                var subTotal        = decimal.Zero;

                foreach (var packageItem in getShippingOptionRequest.Items)
                {
                    if (packageItem.ShoppingCartItem.IsFreeShipping)
                    {
                        continue;
                    }
                    //TODO we should use getShippingOptionRequest.Items.GetQuantity() method to get subtotal
                    subTotal += _priceCalculationService.GetSubTotal(packageItem.ShoppingCartItem);
                }

                var weight = _shippingService.GetTotalWeight(getShippingOptionRequest);

                var shippingMethods = _shippingService.GetAllShippingMethods(countryId);
                foreach (var shippingMethod in shippingMethods)
                {
                    var rate = GetRate(subTotal, weight, shippingMethod.Id, storeId, warehouseId, countryId, stateProvinceId, zip);

                    if (!rate.HasValue)
                    {
                        continue;
                    }

                    var shippingOption = new ShippingOption
                    {
                        Name        = shippingMethod.GetLocalized(x => x.Name),
                        Description = shippingMethod.GetLocalized(x => x.Description),
                        Rate        = rate.Value
                    };

                    response.ShippingOptions.Add(shippingOption);
                }
            }
            else
            {
                //shipping rate calculation by fixed rate

                var restrictByCountryId = getShippingOptionRequest.ShippingAddress != null && getShippingOptionRequest.ShippingAddress.Country != null ? (int?)getShippingOptionRequest.ShippingAddress.Country.Id : null;
                var shippingMethods     = _shippingService.GetAllShippingMethods(restrictByCountryId);

                foreach (var shippingMethod in shippingMethods)
                {
                    var shippingOption = new ShippingOption
                    {
                        Name        = shippingMethod.GetLocalized(x => x.Name),
                        Description = shippingMethod.GetLocalized(x => x.Description),
                        Rate        = GetRate(shippingMethod.Id)
                    };
                    response.ShippingOptions.Add(shippingOption);
                }
            }

            return(response);
        }
Esempio n. 15
0
        public HospitalPartnerCustomerListModel Create(IEnumerable <EventCustomer> eventCustomers, IEnumerable <Order> orders, IEnumerable <Customer> customers, IEnumerable <OrderedPair <long, string> > packages, IEnumerable <OrderedPair <long, string> > tests,
                                                       IEnumerable <HospitalPartnerCustomer> hospitalPartnerCustomers, IEnumerable <OrderedPair <long, string> > idNamePairs, IEnumerable <Event> events, IEnumerable <ShippingDetail> shippingDetails,
                                                       IEnumerable <CustomerResultStatusViewModel> resultStatuses, ShippingOption cdShippingOption, IEnumerable <Pod> pods, IEnumerable <OrderedPair <long, string> > eventHospitalPartnerNamePairs,
                                                       IEnumerable <OrderedPair <long, string> > eventIdCorporateAccounrNamePairs, IEnumerable <PrimaryCarePhysician> primaryCarePhysicians, IEnumerable <HealthAssessmentQuestion> healthAssessmentQuestions,
                                                       IEnumerable <HealthAssessmentAnswer> healthAssessmentAnswers, IEnumerable <EventCustomerResult> eventCustomerResults, HospitalPartner hospitalPartner, IEnumerable <CustomerCallNotes> notes,
                                                       IEnumerable <EventCustomerNotification> eventCustomerNotifications, IEnumerable <EventHospitalPartner> eventHospitalPartners, IEnumerable <OrderedPair <long, string> > eventCustomerIdHospitalFacilityNamePairs,
                                                       IEnumerable <HospitalFacility> hospitalFacilities, IEnumerable <long> showScannedDocumentHospitalPartnerIds, IEnumerable <Language> languages)
        {
            var model          = new HospitalPartnerCustomerListModel();
            var customerModels = new List <HospitalPartnerCustomerViewModel>();

            eventCustomers.ToList().ForEach(ec =>
            {
                var order    = orders.Where(o => o.EventId == ec.EventId && o.CustomerId == ec.CustomerId).FirstOrDefault();
                var customer =
                    customers.Where(c => c.CustomerId == ec.CustomerId).FirstOrDefault();
                var package = order == null ? null :
                              packages.Where(p => p.FirstValue == order.Id).FirstOrDefault();

                var test = order == null ? null : tests.Where(p => p.FirstValue == order.Id).ToList();

                var productPurchased = string.Empty;

                if (package != null && !test.IsNullOrEmpty())
                {
                    productPurchased =
                        package.SecondValue + " + " + string.Join(" + ", test.Select(t => t.SecondValue).ToArray());
                }
                else if (!test.IsNullOrEmpty())
                {
                    productPurchased = string.Join(" + ", test.Select(t => t.SecondValue).ToArray());
                }
                else if (package != null)
                {
                    productPurchased =
                        package.SecondValue;
                }

                ShippingDetail shippingDetail = null;

                string cdPurhased = "N/A";
                if (order != null)
                {
                    var shippingDetailIds = order.OrderDetails.SelectMany(od => od.ShippingDetailOrderDetails.Select(sdod => sdod.ShippingDetailId)).ToArray();

                    shippingDetail = shippingDetails.Where(sd => shippingDetailIds.Contains(sd.Id) && sd.ShippingOption.Id != (cdShippingOption != null ? cdShippingOption.Id : 0)).FirstOrDefault();

                    var cdShippingDetail = shippingDetails.Where(sd => shippingDetailIds.Contains(sd.Id) && sd.ShippingOption.Id == (cdShippingOption != null ? cdShippingOption.Id : 0)).FirstOrDefault();

                    var cdOrderDetail = order.OrderDetails.Where(od => od.IsCompleted && od.DetailType == OrderItemType.ProductItem).ToArray();
                    if (cdOrderDetail != null && cdOrderDetail.Count() > 0 && cdShippingDetail != null)
                    {
                        cdPurhased = "CD";
                    }
                    else if (cdOrderDetail != null && cdOrderDetail.Count() > 0 && cdShippingDetail == null)
                    {
                        cdPurhased = "Online";
                    }
                }
                var isEvaluated    = false;
                var isPdfGenerated = false;

                var evenCustomerResult = eventCustomerResults.Where(ecr => ecr.Id == ec.Id).FirstOrDefault();
                var result             = "Not Processed";
                var recommendation     = "Not Processed";
                if (evenCustomerResult != null)
                {
                    isEvaluated    = true;
                    isPdfGenerated = evenCustomerResult.IsClinicalFormGenerated && evenCustomerResult.IsResultPdfGenerated;
                    result         = evenCustomerResult.ResultSummary.HasValue ? ((ResultInterpretation)evenCustomerResult.ResultSummary.Value).GetDescription() : "Not Available";
                    recommendation = evenCustomerResult.PathwayRecommendation.HasValue ? ((PathwayRecommendation)evenCustomerResult.PathwayRecommendation.Value).GetDescription() : "Not Available";
                }

                HospitalPartnerCustomer hospitalPartnerCustomer = null;
                var customerActivities = hospitalPartnerCustomers.Where(hpc => hpc.EventId == ec.EventId && hpc.CustomerId == ec.CustomerId).ToArray();
                if (customerActivities.Count() > 0)
                {
                    customerActivities      = customerActivities.OrderBy(hpc => hpc.Id).ToArray();
                    hospitalPartnerCustomer = customerActivities.Last();
                }

                var care = "N/A";
                if (hospitalPartnerCustomer != null)
                {
                    care =
                        idNamePairs.Where(
                            cc =>
                            cc.FirstValue ==
                            hospitalPartnerCustomer.CareCoordinatorOrgRoleUserId).
                        First().SecondValue;
                }

                var resultStatus = resultStatuses != null ? resultStatuses.Where(rs => rs.EventCustomerId == ec.Id).SingleOrDefault() : null;
                IEnumerable <OrderedPair <long, string> > pairTestSummary = null;
                if (resultStatus != null && resultStatus.TestResults != null)
                {
                    pairTestSummary = resultStatus.TestResults.Select(tr => new OrderedPair <long, string>(tr.TestId, tr.TestInterpretation.HasValue ? ((ResultInterpretation)tr.TestInterpretation.Value).ToString() : ""));
                }

                var eventData = events.Where(e => e.Id == ec.EventId).FirstOrDefault();
                var eventPods =
                    pods.Where(p => eventData.PodIds.Contains(p.Id)).ToArray();

                DateTime?initialCallDate = null;

                if (evenCustomerResult != null && evenCustomerResult.ResultState == (int)TestResultStateNumber.ResultDelivered && (hospitalPartnerCustomer == null || ((HospitalPartnerCustomerStatus)hospitalPartnerCustomer.Status) == HospitalPartnerCustomerStatus.NotCalled))
                {
                    if (shippingDetail != null && shippingDetail.Status == ShipmentStatus.Shipped)
                    {
                        initialCallDate = (shippingDetail.ShipmentDate ?? DateTime.Now).AddDays(1).AddDays(hospitalPartner != null && hospitalPartner.MailTransitDays != null ? hospitalPartner.MailTransitDays.Value : 0);
                    }
                    else if (shippingDetail == null)
                    {
                        initialCallDate = (evenCustomerResult.DataRecorderMetaData.DateModified ?? evenCustomerResult.DataRecorderMetaData.DateCreated).AddDays(1);
                    }
                }

                var hospitalPartnername  = eventHospitalPartnerNamePairs.Where(ehp => ehp.FirstValue == eventData.Id).Select(ehp => ehp.SecondValue).SingleOrDefault();
                var corporateAccountName = eventIdCorporateAccounrNamePairs.Where(ecan => ecan.FirstValue == eventData.Id).Select(ecan => ecan.SecondValue).SingleOrDefault();

                var primaryCarePhysician = primaryCarePhysicians.Where(pcp => pcp.CustomerId == ec.CustomerId).SingleOrDefault();

                var customerHealthAnswers = healthAssessmentAnswers.Where(haa => haa.EventCustomerId == ec.Id).ToArray();

                var primaryCareAnswer = "No";
                var mammogramProstateScreeningAnswer = "No";
                var colonoscopyAnswer     = "No";
                var cancerAnswer          = "No";
                var weightBariatricAnswer = "No";
                if (customerHealthAnswers.Count() > 0)
                {
                    var primaryCareQuestionId = healthAssessmentQuestions.Where(haq => haq.Label == HealthAssessmentQuestionLabel.PrimaryCare.GetDescription()).Select(haq => haq.Id).SingleOrDefault();
                    if (primaryCareQuestionId > 0)
                    {
                        var healthassessmentAnswer = customerHealthAnswers.Where(cha => cha.QuestionId == primaryCareQuestionId).FirstOrDefault();
                        if (healthassessmentAnswer != null)
                        {
                            primaryCareAnswer = healthassessmentAnswer.Answer;
                        }
                    }

                    var mammogramProstateScreeningQuestionId = healthAssessmentQuestions.Where(haq => haq.Label == HealthAssessmentQuestionLabel.MammogramProstateScreening.GetDescription()).Select(haq => haq.Id).SingleOrDefault();
                    if (mammogramProstateScreeningQuestionId > 0)
                    {
                        var healthassessmentAnswer = customerHealthAnswers.Where(cha => cha.QuestionId == mammogramProstateScreeningQuestionId).SingleOrDefault();
                        if (healthassessmentAnswer != null)
                        {
                            mammogramProstateScreeningAnswer = healthassessmentAnswer.Answer;
                        }
                    }

                    var colonoscopyQuestionId = healthAssessmentQuestions.Where(haq => haq.Label == HealthAssessmentQuestionLabel.Colonoscopy.GetDescription()).Select(haq => haq.Id).SingleOrDefault();
                    if (colonoscopyQuestionId > 0)
                    {
                        var healthassessmentAnswer = customerHealthAnswers.Where(cha => cha.QuestionId == colonoscopyQuestionId).SingleOrDefault();
                        if (healthassessmentAnswer != null)
                        {
                            colonoscopyAnswer = healthassessmentAnswer.Answer;
                        }
                    }

                    var cancerQuestionId = healthAssessmentQuestions.Where(haq => haq.Label == HealthAssessmentQuestionLabel.Cancer.GetDescription()).Select(haq => haq.Id).SingleOrDefault();
                    if (cancerQuestionId > 0)
                    {
                        var healthassessmentAnswer = customerHealthAnswers.Where(cha => cha.QuestionId == cancerQuestionId).SingleOrDefault();
                        if (healthassessmentAnswer != null)
                        {
                            cancerAnswer = healthassessmentAnswer.Answer;
                        }
                    }

                    var weightBariatricQuestionId = healthAssessmentQuestions.Where(haq => haq.Label == HealthAssessmentQuestionLabel.WeightBariatric.GetDescription()).Select(haq => haq.Id).SingleOrDefault();
                    if (weightBariatricQuestionId > 0)
                    {
                        var healthassessmentAnswer = customerHealthAnswers.Where(cha => cha.QuestionId == weightBariatricQuestionId).SingleOrDefault();
                        if (healthassessmentAnswer != null)
                        {
                            weightBariatricAnswer = healthassessmentAnswer.Answer;
                        }
                    }
                }

                //var notes = _customerCallNotesRepository.GetCustomerNotes(eventData.Id, new[] { customer.CustomerId });
                var customerNotes         = notes.Where(n => n.CustomerId == customer.CustomerId && n.EventId == eventData.Id).Select(n => n).ToArray();
                string postScreeningNotes = string.Empty;

                if (!customerNotes.IsNullOrEmpty())
                {
                    //postScreeningNotes = string.Join("\\n\\n", notes.Where(n => n.NotesType == CustomerRegistrationNotesType.PostScreeningFollowUpNotes).Select(n => n.Notes).ToArray());
                    postScreeningNotes = string.Join("\\n\\n", customerNotes.Select(n => n.Notes).ToArray());
                }
                EventCustomerNotification eventCustomerNotification = null;

                if (eventCustomerNotifications != null && eventCustomerNotifications.Count() > 0)
                {
                    eventCustomerNotification = eventCustomerNotifications.FirstOrDefault(ecn => ecn.EventCustomerId == ec.Id);
                }

                var eventHospitalPartner = eventHospitalPartners.SingleOrDefault(ehp => ehp.EventId == eventData.Id);

                var showScannedDocumentUrl = false;
                var scannedDocumentUrl     = string.Empty;
                if (eventHospitalPartner != null && showScannedDocumentHospitalPartnerIds != null)
                {
                    showScannedDocumentUrl = showScannedDocumentHospitalPartnerIds.Contains(eventHospitalPartner.HospitalPartnerId);
                    if (showScannedDocumentUrl)
                    {
                        var mediaLocScannedDocs = _mediaRepository.GetScannedDocumentStorageFileLocation(eventHospitalPartner.EventId);
                        var filesScannedDocs    = Directory.GetFiles(mediaLocScannedDocs.PhysicalPath);
                        if (filesScannedDocs.Any())
                        {
                            var filename = filesScannedDocs.Where(fsd => !string.IsNullOrEmpty(fsd) && Path.GetFileName(fsd).StartsWith(customer.CustomerId.ToString())).Select(Path.GetFileName).FirstOrDefault();
                            if (!string.IsNullOrEmpty(filename))
                            {
                                scannedDocumentUrl = mediaLocScannedDocs.Url + filename;
                            }
                        }
                    }
                }


                HospitalFacility hospitalFacility = null;
                var hospitalFacilityName          = string.Empty;
                if (ec.HospitalFacilityId.HasValue)
                {
                    if (hospitalFacilities != null && hospitalFacilities.Any())
                    {
                        hospitalFacility = hospitalFacilities.FirstOrDefault(hf => hf.Id == ec.HospitalFacilityId);
                    }

                    if (eventCustomerIdHospitalFacilityNamePairs != null && eventCustomerIdHospitalFacilityNamePairs.Any())
                    {
                        hospitalFacilityName = eventCustomerIdHospitalFacilityNamePairs.Where(ehp => ehp.FirstValue == ec.Id).Select(ehp => ehp.SecondValue).FirstOrDefault();
                    }
                }

                var preferredLanguage = "N/A";
                if (customer.LanguageId.HasValue)
                {
                    var language = languages.FirstOrDefault(x => x.Id == customer.LanguageId);
                    if (language != null)
                    {
                        preferredLanguage = language.Name;
                    }
                }

                customerModels.Add(new HospitalPartnerCustomerViewModel
                {
                    CustomerName               = customer.Name,
                    Phone                      = customer.HomePhoneNumber != null ? customer.HomePhoneNumber.FormatPhoneNumber : string.Empty,
                    PhoneCell                  = customer.MobilePhoneNumber != null ? customer.MobilePhoneNumber.FormatPhoneNumber : string.Empty,
                    PhoneOffice                = customer.OfficePhoneNumber != null ? customer.OfficePhoneNumber.FormatPhoneNumber : string.Empty,
                    PhoneOfficeExtn            = customer.PhoneOfficeExtension,
                    DateofBirth                = customer.DateOfBirth,
                    Package                    = productPurchased,
                    CdPurchased                = cdPurhased,
                    EventDate                  = eventData.EventDate,
                    CustomerId                 = customer.CustomerId,
                    EventId                    = ec.EventId,
                    Gender                     = customer.Gender.ToString(),
                    Height                     = customer.Height != null && customer.Height.TotalInches > 0 ? customer.Height.TotalInches.ToString() : "N/A",
                    Weight                     = customer.Weight != null && customer.Weight.Pounds > 0 ? customer.Weight.Pounds.ToString() : "N/A",
                    Pod                        = string.Join(", ", eventPods.Select(ep => ep.Name)),
                    IsEvaluated                = isEvaluated,
                    IsPdfGenerated             = isPdfGenerated,
                    Status                     = hospitalPartnerCustomer != null ? ((HospitalPartnerCustomerStatus)hospitalPartnerCustomer.Status).GetDescription() : HospitalPartnerCustomerStatus.NotCalled.GetDescription(),
                    Outcome                    = hospitalPartnerCustomer != null ? ((HospitalPartnerCustomerOutcome)hospitalPartnerCustomer.Outcome).GetDescription() : HospitalPartnerCustomerOutcome.NotCalled.GetDescription(),
                    Care                       = care,
                    LastModified               = hospitalPartnerCustomer != null ? hospitalPartnerCustomer.DataRecorderMetaData.DateModified : null,
                    Result                     = result,
                    Recommendation             = recommendation,
                    Email                      = customer.Email != null ? customer.Email.ToString() : string.Empty,
                    Address                    = Mapper.Map <Address, AddressViewModel>(customer.Address),
                    ShippingMode               = shippingDetail != null ? "Paper" : "Online",
                    MailedStatus               = shippingDetail != null ? shippingDetail.Status.ToString() : "Online",
                    MailedOn                   = shippingDetail != null ? shippingDetail.ShipmentDate : null,
                    HospitalPartnerName        = hospitalPartnername ?? "N/A",
                    CorporateSponsor           = corporateAccountName ?? "N/A",
                    TestSummary                = pairTestSummary,
                    PrimaryCarePhysicianName   = primaryCarePhysician != null ? primaryCarePhysician.Name.FullName : "N/A",
                    Activities                 = GetHospitalPartnerCustomerActivities(customerActivities, idNamePairs),
                    PrimaryCare                = primaryCareAnswer,
                    MammogramProstateScreening = mammogramProstateScreeningAnswer,
                    Colonoscopy                = colonoscopyAnswer,
                    Cancer                     = cancerAnswer,
                    InitialCallDate            = initialCallDate,
                    WeightBariatric            = weightBariatricAnswer,
                    PostScreeningFollowUpNotes = postScreeningNotes,
                    // PreferredLanguage = string.IsNullOrEmpty(customer.PreferredLanguage) ? "N/A" : customer.PreferredLanguage,
                    PreferredLanguage   = preferredLanguage,
                    BestTimeToCall      = customer.BestTimeToCall.HasValue && customer.BestTimeToCall.Value > 0 ? ((BestTimeToCall)customer.BestTimeToCall).GetDescription() : "N/A",
                    EventCustomerId     = ec.Id,
                    HasCannedMessage    = (hospitalPartner != null && !string.IsNullOrEmpty(hospitalPartner.CannedMessage) || hospitalFacility != null && !string.IsNullOrEmpty(hospitalFacility.CannedMessage)),
                    IsCannedMessageSent = eventCustomerNotification != null,
                    Ssn = (eventHospitalPartner != null && eventHospitalPartner.CaptureSsn && !string.IsNullOrEmpty(customer.Ssn) && customer.Ssn.Length >= 9)
                                                                                           ? customer.Ssn.Substring(0, 3) + "-" + customer.Ssn.Substring(3, 2) + "-" + customer.Ssn.Substring(customer.Ssn.Length - 4) //"XXX-XX-" + customer.Ssn.Substring(customer.Ssn.Length - 4)
                                                                                           : string.Empty,                                                                                                             //"N/A"
                    HospitalFacility       = string.IsNullOrEmpty(hospitalFacilityName) ? "N/A" : hospitalFacilityName,
                    ShowScannedDocumentUrl = showScannedDocumentUrl,
                    ScannedDocumentUrl     = scannedDocumentUrl,
                    MemberId = string.IsNullOrEmpty(customer.InsuranceId) ? "N/A" : customer.InsuranceId
                });
            });

            model.Collection = customerModels;
            return(model);
        }
Esempio n. 16
0
        /// <summary>
        /// Gets shopping cart shipping total
        /// </summary>
        /// <param name="cart">Cart</param>
        /// <param name="includingTax">A value indicating whether calculated price should include tax</param>
        /// <param name="taxRate">Applied tax rate</param>
        /// <param name="appliedDiscount">Applied discount</param>
        /// <returns>Shipping total</returns>
        public virtual decimal?GetShoppingCartShippingTotal(IList <ShoppingCartItem> cart, bool includingTax,
                                                            out decimal taxRate, out Discount appliedDiscount)
        {
            decimal?shippingTotal      = null;
            decimal?shippingTotalTaxed = null;

            appliedDiscount = null;
            taxRate         = decimal.Zero;

            var customer = cart.GetCustomer();

            bool isFreeShipping = IsFreeShipping(cart);

            if (isFreeShipping)
            {
                return(decimal.Zero);
            }

            ShippingOption shippingOption = null;

            if (customer != null)
            {
                shippingOption = customer.GetAttribute <ShippingOption>(SystemCustomerAttributeNames.SelectedShippingOption, _genericAttributeService, _storeContext.CurrentStore.Id);
            }

            if (shippingOption != null)
            {
                //use last shipping option (get from cache)

                //adjust shipping rate
                shippingTotal = AdjustShippingRate(shippingOption.Rate, cart, out appliedDiscount);
            }
            else
            {
                //use fixed rate (if possible)
                Address shippingAddress = null;
                if (customer != null)
                {
                    shippingAddress = customer.ShippingAddress;
                }

                var shippingRateComputationMethods = _shippingService.LoadActiveShippingRateComputationMethods();
                if (shippingRateComputationMethods == null || shippingRateComputationMethods.Count == 0)
                {
                    throw new NasException("Shipping rate computation method could not be loaded");
                }

                if (shippingRateComputationMethods.Count == 1)
                {
                    var getShippingOptionRequest = _shippingService.CreateShippingOptionRequest(cart, shippingAddress);

                    var     shippingRateComputationMethod = shippingRateComputationMethods[0];
                    decimal?fixedRate = shippingRateComputationMethod.GetFixedRate(getShippingOptionRequest);
                    if (fixedRate.HasValue)
                    {
                        //adjust shipping rate
                        shippingTotal = AdjustShippingRate(fixedRate.Value, cart, out appliedDiscount);
                    }
                }
            }

            if (shippingTotal.HasValue)
            {
                if (shippingTotal.Value < decimal.Zero)
                {
                    shippingTotal = decimal.Zero;
                }

                //round
                if (_shoppingCartSettings.RoundPricesDuringCalculation)
                {
                    shippingTotal = Math.Round(shippingTotal.Value, 2);
                }

                shippingTotalTaxed = _taxService.GetShippingPrice(shippingTotal.Value,
                                                                  includingTax,
                                                                  customer,
                                                                  out taxRate);

                //round
                if (_shoppingCartSettings.RoundPricesDuringCalculation)
                {
                    shippingTotalTaxed = Math.Round(shippingTotalTaxed.Value, 2);
                }
            }

            return(shippingTotalTaxed);
        }
Esempio n. 17
0
        private List <ShippingOption> ParseResponse(string response)
        {
            string error           = "";
            var    shippingOptions = new List <ShippingOption>();

            using (var sr = new StringReader(response))
                using (var tr = new XmlTextReader(sr))
                    while (tr.Read())
                    {
                        if ((tr.Name == "Error") && (tr.NodeType == XmlNodeType.Element))
                        {
                            string errorText = "";
                            while (tr.Read())
                            {
                                if ((tr.Name == "ErrorCode") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    errorText += "UPS Rating Error, Error Code: " + tr.ReadString() + ", ";
                                }
                                if ((tr.Name == "ErrorDescription") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    errorText += "Error Desc: " + tr.ReadString();
                                }
                            }
                            error = "UPS Error returned: " + errorText;
                        }
                        if ((tr.Name == "RatedShipment") && (tr.NodeType == XmlNodeType.Element))
                        {
                            string serviceCode   = "";
                            string monetaryValue = "";
                            while (tr.Read())
                            {
                                if ((tr.Name == "Service") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    while (tr.Read())
                                    {
                                        if ((tr.Name == "Code") && (tr.NodeType == XmlNodeType.Element))
                                        {
                                            serviceCode = tr.ReadString();
                                            tr.ReadEndElement();
                                        }
                                        if ((tr.Name == "Service") && (tr.NodeType == XmlNodeType.EndElement))
                                        {
                                            break;
                                        }
                                    }
                                }
                                if (((tr.Name == "RatedShipment") && (tr.NodeType == XmlNodeType.EndElement)) || ((tr.Name == "RatedPackage") && (tr.NodeType == XmlNodeType.Element)))
                                {
                                    break;
                                }
                                if ((tr.Name == "TotalCharges") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    while (tr.Read())
                                    {
                                        if ((tr.Name == "MonetaryValue") && (tr.NodeType == XmlNodeType.Element))
                                        {
                                            monetaryValue = tr.ReadString();
                                            tr.ReadEndElement();
                                        }
                                        if ((tr.Name == "TotalCharges") && (tr.NodeType == XmlNodeType.EndElement))
                                        {
                                            break;
                                        }
                                    }
                                }
                            }
                            string service   = "03";
                            string serviceId = String.Format("[{0}]", serviceCode);

                            //Weed out unwanted or unkown service rates
                            if (service.ToUpper() != "UNKNOWN")
                            {
                                var shippingOption = new ShippingOption();
                                shippingOption.Rate = Convert.ToDecimal(monetaryValue, new CultureInfo("en-US"));
                                shippingOption.Name = serviceCode;
                                shippingOptions.Add(shippingOption);
                            }
                        }
                    }

            return(shippingOptions);
        }
Esempio n. 18
0
        protected void Page_Load(object sender, EventArgs e)
        {
            ddlpaymentmode.Attributes.Add("onChange", "OpenCloseDiv('" + ddlpaymentmode.ClientID + "')");

            if (!IsPostBack)
            {
                txtCashAmount.ReadOnly = true;

                BindAllDropDowns();

                if (IsFullfillmentOption)
                {
                    if (!string.IsNullOrEmpty(Request.QueryString["EventId"]))
                    {
                        ShippingOption.EventId = Convert.ToInt64(Request.QueryString["EventId"]);
                    }

                    EventCustomerId = Convert.ToInt64(Request.QueryString["EventCustomerID"]);
                    DivAcceptPayment.Style.Add(HtmlTextWriterStyle.Display, "none");
                    DivFullfillmentOption.Style.Add(HtmlTextWriterStyle.Display, "block");

                    _customer = ShippingOption.GetCustomerData();

                    FillShippingAddress();

                    ShippingOption.ShowOnlineOption = false;
                    Page.Title = "Fulfillment Option";

                    PartialPaymentDiv.Style.Add(HtmlTextWriterStyle.Display, "none");
                    var orderRepository = IoC.Resolve <IOrderRepository>();
                    var order           = orderRepository.GetOrder(CustomerId.Value, EventId.Value);
                    if (order != null && !order.OrderDetails.IsEmpty())
                    {
                        SetCreditCardOnFileDetails(order);
                    }
                }
                else
                {
                    EventCustomerId = Convert.ToInt64(Request.QueryString["EventCustomerID"]);
                    DivAcceptPayment.Style.Add(HtmlTextWriterStyle.Display, "block");
                    DivFullfillmentOption.Style.Add(HtmlTextWriterStyle.Display, "none");

                    IUniqueItemRepository <EventCustomer> eventCustomerRepository = new EventCustomerRepository();
                    var eventCustomer = eventCustomerRepository.GetById(EventCustomerId);
                    if (eventCustomer != null)
                    {
                        var organizationRoleUserRepository = IoC.Resolve <IOrganizationRoleUserRepository>();
                        var orgRoleUser = organizationRoleUserRepository.GetOrganizationRoleUser(eventCustomer.DataRecorderMetaData.DataRecorderCreator.Id);

                        EventRegisteredBy = (Roles)Enum.Parse(typeof(Roles), orgRoleUser.RoleId.ToString());
                    }

                    if (EventCustomerId > 0 && CheckValidCoupon())
                    {
                        var orderRepository        = IoC.Resolve <IOrderRepository>();
                        var orderId                = orderRepository.GetOrderIdByEventCustomerId(EventCustomerId);
                        var eventPackageRepository = IoC.Resolve <IEventPackageRepository>();
                        var eventPackage           = eventPackageRepository.GetPackageForOrder(orderId);

                        if (eventPackage != null)
                        {
                            PackageCost         = eventPackage.Package.Price;
                            hfpackagecost.Value = eventPackage.Package.Price.ToString();
                            hfeventid.Value     = eventPackage.EventId.ToString();
                        }
                    }
                    else
                    {
                        divapplycoupon.Visible = false;
                    }

                    GetCustomerBillingDetail();

                    if (CurrentRole == Roles.CallCenterRep)
                    {
                        PartialPaymentDiv.Style.Add(HtmlTextWriterStyle.Display, "block");
                    }
                    else if (CurrentRole == Roles.Technician)
                    {
                        PartialPaymentDiv.Style.Add(HtmlTextWriterStyle.Display, "none");
                    }
                }

                RegisterJavaScriptEvents();
            }
        }
Esempio n. 19
0
        public void BindData()
        {
            bool shoppingCartRequiresShipping = this.ShippingService.ShoppingCartRequiresShipping(Cart);

            if (!shoppingCartRequiresShipping)
            {
                NopContext.Current.User.LastShippingOption = null;
                var args1 = new CheckoutStepEventArgs()
                {
                    ShippingMethodSelected = true
                };
                OnCheckoutStepChanged(args1);
                if (!this.OnePageCheckout)
                {
                    Response.Redirect("~/checkoutpaymentmethod.aspx");
                }
            }
            else
            {
                string  error           = string.Empty;
                Address address         = NopContext.Current.User.ShippingAddress;
                var     shippingOptions = this.ShippingService.GetShippingOptions(Cart, NopContext.Current.User, address, ref error);
                if (!String.IsNullOrEmpty(error))
                {
                    this.LogService.InsertLog(LogTypeEnum.ShippingError, error, error);
                    phSelectShippingMethod.Visible = false;
                    lShippingMethodsError.Text     = Server.HtmlEncode(error);
                }
                else
                {
                    if (shippingOptions.Count > 0)
                    {
                        phSelectShippingMethod.Visible = true;
                        dlShippingOptions.DataSource   = shippingOptions;
                        dlShippingOptions.DataBind();

                        //select a default shipping option
                        if (dlShippingOptions.Items.Count > 0)
                        {
                            if (NopContext.Current.User != null &&
                                NopContext.Current.User.LastShippingOption != null)
                            {
                                //already selected shipping option
                                this.SelectedShippingOption = NopContext.Current.User.LastShippingOption;
                            }
                            else
                            {
                                //otherwise, the first shipping option
                                var tmp1             = dlShippingOptions.Items[0];
                                var rdShippingOption = tmp1.FindControl("rdShippingOption") as RadioButton;
                                if (rdShippingOption != null)
                                {
                                    rdShippingOption.Checked = true;
                                }
                            }
                        }
                    }
                    else
                    {
                        phSelectShippingMethod.Visible = false;
                        lShippingMethodsError.Text     = GetLocaleResourceString("Checkout.ShippingIsNotAllowed");
                    }
                }
            }
        }
        private void ProcessNewOrderNotification(string xmlData)
        {
            try
            {
                var    newOrderNotification = (NewOrderNotification)EncodeHelper.Deserialize(xmlData, typeof(NewOrderNotification));
                string googleOrderNumber    = newOrderNotification.googleordernumber;

                XmlNode customerInfo       = newOrderNotification.shoppingcart.merchantprivatedata.Any[0];
                int     customerId         = Convert.ToInt32(customerInfo.Attributes["CustomerID"].Value);
                int     customerLanguageId = Convert.ToInt32(customerInfo.Attributes["CustomerLanguageID"].Value);
                int     customerCurrencyId = Convert.ToInt32(customerInfo.Attributes["CustomerCurrencyID"].Value);
                var     customer           = _customerService.GetCustomerById(customerId);

                if (customer == null)
                {
                    LogMessage("Could not load a customer");
                    return;
                }

                var cart = customer.ShoppingCartItems.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart).ToList();

                _workContext.CurrentCustomer = customer;

                if (cart.Count == 0)
                {
                    LogMessage("Cart is empty");
                    return;
                }

                //validate cart
                foreach (var sci in cart)
                {
                    bool ok = false;
                    foreach (Item item in newOrderNotification.shoppingcart.items)
                    {
                        if (!String.IsNullOrEmpty(item.merchantitemid))
                        {
                            if ((Convert.ToInt32(item.merchantitemid) == sci.Id) && (item.quantity == sci.Quantity))
                            {
                                ok = true;
                                break;
                            }
                        }
                    }

                    if (!ok)
                    {
                        LogMessage(string.Format("Shopping Cart item has been changed. {0}. {1}", sci.Id, sci.Quantity));
                        return;
                    }
                }


                string[] billingFullname  = newOrderNotification.buyerbillingaddress.contactname.Trim().Split(new char[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
                string   billingFirstName = billingFullname[0];
                string   billingLastName  = string.Empty;
                if (billingFullname.Length > 1)
                {
                    billingLastName = billingFullname[1];
                }
                string billingEmail           = newOrderNotification.buyerbillingaddress.email.Trim();
                string billingAddress1        = newOrderNotification.buyerbillingaddress.address1.Trim();
                string billingAddress2        = newOrderNotification.buyerbillingaddress.address2.Trim();
                string billingPhoneNumber     = newOrderNotification.buyerbillingaddress.phone.Trim();
                string billingCity            = newOrderNotification.buyerbillingaddress.city.Trim();
                int?   billingStateProvinceId = null;
                var    billingStateProvince   = _stateProvinceService.GetStateProvinceByAbbreviation(newOrderNotification.buyerbillingaddress.region.Trim());
                if (billingStateProvince != null)
                {
                    billingStateProvinceId = billingStateProvince.Id;
                }
                string billingZipPostalCode = newOrderNotification.buyerbillingaddress.postalcode.Trim();
                int?   billingCountryId     = null;
                var    billingCountry       = _countryService.GetCountryByTwoLetterIsoCode(newOrderNotification.buyerbillingaddress.countrycode.Trim());
                if (billingCountry != null)
                {
                    billingCountryId = billingCountry.Id;
                }

                var billingAddress = customer.Addresses.ToList().FindAddress(
                    billingFirstName, billingLastName, billingPhoneNumber,
                    billingEmail, string.Empty, string.Empty, billingAddress1, billingAddress2, billingCity,
                    billingStateProvinceId, billingZipPostalCode, billingCountryId);

                if (billingAddress == null)
                {
                    billingAddress = new Core.Domain.Common.Address()
                    {
                        FirstName       = billingFirstName,
                        LastName        = billingLastName,
                        PhoneNumber     = billingPhoneNumber,
                        Email           = billingEmail,
                        Address1        = billingAddress1,
                        Address2        = billingAddress2,
                        City            = billingCity,
                        StateProvinceId = billingStateProvinceId,
                        ZipPostalCode   = billingZipPostalCode,
                        CountryId       = billingCountryId,
                        CreatedOnUtc    = DateTime.UtcNow,
                    };
                    customer.Addresses.Add(billingAddress);
                }
                //set default billing address
                customer.SetBillingAddress(billingAddress);
                _customerService.UpdateCustomer(customer);

                _customerService.SaveCustomerAttribute <ShippingOption>(customer, SystemCustomerAttributeNames.LastShippingOption, null);

                bool shoppingCartRequiresShipping = cart.RequiresShipping();
                if (shoppingCartRequiresShipping)
                {
                    string[] shippingFullname  = newOrderNotification.buyershippingaddress.contactname.Trim().Split(new char[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
                    string   shippingFirstName = shippingFullname[0];
                    string   shippingLastName  = string.Empty;
                    if (shippingFullname.Length > 1)
                    {
                        shippingLastName = shippingFullname[1];
                    }
                    string shippingEmail           = newOrderNotification.buyershippingaddress.email.Trim();
                    string shippingAddress1        = newOrderNotification.buyershippingaddress.address1.Trim();
                    string shippingAddress2        = newOrderNotification.buyershippingaddress.address2.Trim();
                    string shippingPhoneNumber     = newOrderNotification.buyershippingaddress.phone.Trim();
                    string shippingCity            = newOrderNotification.buyershippingaddress.city.Trim();
                    int?   shippingStateProvinceId = null;
                    var    shippingStateProvince   = _stateProvinceService.GetStateProvinceByAbbreviation(newOrderNotification.buyershippingaddress.region.Trim());
                    if (shippingStateProvince != null)
                    {
                        shippingStateProvinceId = shippingStateProvince.Id;
                    }
                    int?   shippingCountryId     = null;
                    string shippingZipPostalCode = newOrderNotification.buyershippingaddress.postalcode.Trim();
                    var    shippingCountry       = _countryService.GetCountryByTwoLetterIsoCode(newOrderNotification.buyershippingaddress.countrycode.Trim());
                    if (shippingCountry != null)
                    {
                        shippingCountryId = shippingCountry.Id;
                    }

                    var shippingAddress = customer.Addresses.ToList().FindAddress(
                        shippingFirstName, shippingLastName, shippingPhoneNumber,
                        shippingEmail, string.Empty, string.Empty,
                        shippingAddress1, shippingAddress2, shippingCity,
                        shippingStateProvinceId, shippingZipPostalCode, shippingCountryId);
                    if (shippingAddress == null)
                    {
                        shippingAddress = new Core.Domain.Common.Address()
                        {
                            FirstName       = shippingFirstName,
                            LastName        = shippingLastName,
                            PhoneNumber     = shippingPhoneNumber,
                            Email           = shippingEmail,
                            Address1        = shippingAddress1,
                            Address2        = shippingAddress2,
                            City            = shippingCity,
                            StateProvinceId = shippingStateProvinceId,
                            ZipPostalCode   = shippingZipPostalCode,
                            CountryId       = shippingCountryId,
                            CreatedOnUtc    = DateTime.UtcNow,
                        };
                        customer.Addresses.Add(shippingAddress);
                    }
                    //set default shipping address
                    customer.SetShippingAddress(shippingAddress);
                    _customerService.UpdateCustomer(customer);

                    if (newOrderNotification.orderadjustment != null &&
                        newOrderNotification.orderadjustment.shipping != null &&
                        newOrderNotification.orderadjustment.shipping.Item != null)
                    {
                        var shippingMethod = (FlatRateShippingAdjustment)newOrderNotification.orderadjustment.shipping.Item;
                        var shippingOption = new ShippingOption();
                        shippingOption.Name = shippingMethod.shippingname;
                        shippingOption.Rate = shippingMethod.shippingcost.Value;
                        _customerService.SaveCustomerAttribute <ShippingOption>(customer, SystemCustomerAttributeNames.LastShippingOption, shippingOption);
                    }
                }

                //customer.LastCalculatedTax = decimal.Zero;

                var paymentInfo = new ProcessPaymentRequest()
                {
                    PaymentMethodSystemName = "Payments.GoogleCheckout",
                    Customer          = customer,
                    GoogleOrderNumber = googleOrderNumber
                };
                //TODO set customer language and currency
                //paymentInfo.CustomerLanguage = IoC.Resolve<ILanguageService>().GetLanguageById(CustomerLanguageID);
                //paymentInfo.CustomerCurrency = IoC.Resolve<ICurrencyService>().GetCurrencyById(CustomerCurrencyID);
                var result = _orderProcessingService.PlaceOrder(paymentInfo);
                if (!result.Success)
                {
                    LogMessage("new-order-notification received. CreateOrder() error: Order Number " + googleOrderNumber + ". " + result);
                    return;
                }

                var order = result.PlacedOrder;
                if (order != null)
                {
                    LogMessage("new-order-notification received and saved: Order Number " + order.Id);
                }
            }
            catch (Exception exc)
            {
                LogMessage("processNewOrderNotification Exception: " + exc.Message + ": " + exc.StackTrace);
            }
        }
Esempio n. 21
0
        private IEnumerable <ShippingOption> ParseResponse(string response, bool isDomestic, ref string error)
        {
            var shippingOptions = new List <ShippingOption>();

            string postageStr             = isDomestic ? "Postage" : "Service";
            string mailServiceStr         = isDomestic ? "MailService" : "SvcDescription";
            string rateStr                = isDomestic ? "Rate" : "Postage";
            string classStr               = isDomestic ? "CLASSID" : "ID";
            string carrierServicesOffered = isDomestic ? _uspsSettings.CarrierServicesOfferedDomestic : _uspsSettings.CarrierServicesOfferedInternational;

            using (var sr = new StringReader(response))
                using (var tr = new XmlTextReader(sr))
                {
                    do
                    {
                        tr.Read();

                        if ((tr.Name == "Error") && (tr.NodeType == XmlNodeType.Element))
                        {
                            string errorText = "";
                            while (tr.Read())
                            {
                                if ((tr.Name == "Description") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    errorText += "Error Desc: " + tr.ReadString();
                                }
                                if ((tr.Name == "HelpContext") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    errorText += "USPS Help Context: " + tr.ReadString() + ". ";
                                }
                            }
                            error = "USPS Error returned: " + errorText;
                        }

                        if ((tr.Name == postageStr) && (tr.NodeType == XmlNodeType.Element))
                        {
                            string serviceId = string.Empty;

                            // Find the ID for the service
                            if (tr.HasAttributes)
                            {
                                for (int i = 0; i < tr.AttributeCount; i++)
                                {
                                    tr.MoveToAttribute(i);
                                    if (tr.Name.Equals(classStr))
                                    {
                                        // Add delimiters [] so that single digit IDs aren't found in multi-digit IDs
                                        serviceId = String.Format("[{0}]", tr.Value);
                                        break;
                                    }
                                }
                            }

                            // Go to the next rate if the service ID is not in the list of services to offer
                            if (!String.IsNullOrEmpty(serviceId) &&
                                !String.IsNullOrEmpty(carrierServicesOffered) &&
                                !carrierServicesOffered.Contains(serviceId))
                            {
                                continue;
                            }

                            string serviceCode = string.Empty;
                            string postalRate  = string.Empty;

                            do
                            {
                                tr.Read();

                                if ((tr.Name == mailServiceStr) && (tr.NodeType == XmlNodeType.Element))
                                {
                                    serviceCode = tr.ReadString();

                                    tr.ReadEndElement();
                                    if ((tr.Name == mailServiceStr) && (tr.NodeType == XmlNodeType.EndElement))
                                    {
                                        break;
                                    }
                                }

                                if ((tr.Name == rateStr) && (tr.NodeType == XmlNodeType.Element))
                                {
                                    postalRate = tr.ReadString();
                                    tr.ReadEndElement();
                                    if ((tr.Name == rateStr) && (tr.NodeType == XmlNodeType.EndElement))
                                    {
                                        break;
                                    }
                                }
                            }while (!((tr.Name == postageStr) && (tr.NodeType == XmlNodeType.EndElement)));

                            //go to the next rate if the "First-Class Mail Letter" is not in the list of domestic services to offer
                            if (isDomestic && !carrierServicesOffered.Contains("[letter]"))
                            {
                                var option = serviceCode.ToLowerInvariant();
                                if (option.Contains("letter") || option.Contains("postcard"))
                                {
                                    continue;
                                }
                            }

                            //USPS issue fixed
                            var    reg = (char)174; // registered sign "\u00AE"
                            string tm  = "\u2122";  // trademark sign
                            serviceCode = serviceCode.Replace("&lt;sup&gt;&amp;reg;&lt;/sup&gt;", reg.ToString());
                            serviceCode = serviceCode.Replace("&lt;sup&gt;&#174;&lt;/sup&gt;", reg.ToString());
                            serviceCode = serviceCode.Replace("&lt;sup&gt;&amp;trade;&lt;/sup&gt;", tm);
                            serviceCode = serviceCode.Replace("&lt;sup&gt;&#8482;&lt;/sup&gt;", tm);

                            ShippingOption shippingOption = shippingOptions.Find(s => s.Name == serviceCode);
                            if (shippingOption == null)
                            {
                                shippingOption      = new ShippingOption();
                                shippingOption.Name = serviceCode;
                                shippingOptions.Add(shippingOption);
                            }
                            shippingOption.Rate += Convert.ToDecimal(postalRate, new CultureInfo("en-US"));
                        }
                    }while (!tr.EOF);
                }
            return(shippingOptions);
        }
        public CorporateAccountCustomerListModel Create(IEnumerable <EventCustomer> eventCustomers, IEnumerable <Customer> customers, IEnumerable <Order> orders, IEnumerable <OrderedPair <long, string> > packages, IEnumerable <OrderedPair <long, string> > tests,
                                                        IEnumerable <ShippingDetail> shippingDetails, ShippingOption cdShippingOption, IEnumerable <EventCustomerResult> eventCustomerResults, IEnumerable <Event> events, IEnumerable <Pod> pods, IEnumerable <OrderedPair <long, string> > eventIdCorporateAccountNamePairs,
                                                        IEnumerable <CustomerResultStatusViewModel> resultStatuses, IEnumerable <PrimaryCarePhysician> primaryCarePhysicians, IEnumerable <HealthAssessmentAnswer> healthAssessmentAnswers, IEnumerable <HealthAssessmentQuestion> healthAssessmentQuestions,
                                                        IEnumerable <Language> languages, IEnumerable <EventCustomerNotification> eventCustomerNotifications, IEnumerable <EventHospitalPartner> eventHospitalPartners)
        {
            var collection = new List <CorporateAccountCustomerViewModel>();

            foreach (var eventCustomer in eventCustomers)
            {
                var customer = customers.FirstOrDefault(c => c.CustomerId == eventCustomer.CustomerId);
                var order    =
                    orders.FirstOrDefault(
                        o => o.EventId == eventCustomer.EventId && o.CustomerId == eventCustomer.CustomerId);
                var package = order == null ? null : packages.FirstOrDefault(p => p.FirstValue == order.Id);
                var test    = order == null ? null : tests.Where(t => t.FirstValue == order.Id).ToList();

                var productPurchased = string.Empty;

                if (package != null && !test.IsNullOrEmpty())
                {
                    productPurchased = package.SecondValue + " + " +
                                       string.Join(" + ", test.Select(t => t.SecondValue).ToArray());
                }
                else if (!test.IsNullOrEmpty())
                {
                    productPurchased = string.Join(" + ", test.Select(t => t.SecondValue).ToArray());
                }
                else if (package != null)
                {
                    productPurchased = package.SecondValue;
                }

                ShippingDetail shippingDetail = null;

                string cdPurchased = "N/A";

                if (order != null)
                {
                    var shippingDetailIds =
                        order.OrderDetails.SelectMany(
                            od => od.ShippingDetailOrderDetails.Select(sdod => sdod.ShippingDetailId)).ToArray();

                    shippingDetail =
                        shippingDetails.FirstOrDefault(
                            sd =>
                            shippingDetailIds.Contains(sd.Id) &&
                            sd.ShippingOption.Id != (cdShippingOption != null ? cdShippingOption.Id : 0));

                    var cdShippingDetail =
                        shippingDetails.FirstOrDefault(
                            sd =>
                            shippingDetailIds.Contains(sd.Id) &&
                            sd.ShippingOption.Id == (cdShippingOption != null ? cdShippingOption.Id : 0));

                    var cdOrderDetail =
                        order.OrderDetails.Where(od => od.IsCompleted && od.DetailType == OrderItemType.ProductItem)
                        .ToArray();
                    if (cdOrderDetail != null && cdOrderDetail.Any() && cdShippingDetail != null)
                    {
                        cdPurchased = "CD";
                    }
                    else if (cdOrderDetail != null && cdOrderDetail.Any() && cdShippingDetail == null)
                    {
                        cdPurchased = "Online";
                    }
                }
                var isEvaluated    = false;
                var isPdfGenerated = false;

                var eventCustomerResult = eventCustomerResults.FirstOrDefault(ecr => ecr.Id == eventCustomer.Id);
                var result         = "Not Processed";
                var recommendation = "Not Processed";
                if (eventCustomerResult != null)
                {
                    isEvaluated    = true;
                    isPdfGenerated = eventCustomerResult.IsClinicalFormGenerated && eventCustomerResult.IsResultPdfGenerated;
                    result         = eventCustomerResult.ResultSummary.HasValue ? ((ResultInterpretation)eventCustomerResult.ResultSummary.Value).GetDescription() : "Not Available";
                    recommendation = eventCustomerResult.PathwayRecommendation.HasValue ? ((PathwayRecommendation)eventCustomerResult.PathwayRecommendation.Value).GetDescription() : "Not Available";
                }

                var eventData            = events.FirstOrDefault(e => e.Id == eventCustomer.EventId);
                var eventPods            = pods.Where(p => eventData.PodIds.Contains(p.Id)).ToArray();
                var corporateAccountName = eventIdCorporateAccountNamePairs.Where(ecan => ecan.FirstValue == eventData.Id).Select(ecan => ecan.SecondValue).SingleOrDefault();

                var resultStatus = resultStatuses != null?resultStatuses.SingleOrDefault(rs => rs.EventCustomerId == eventCustomer.Id) : null;

                IEnumerable <OrderedPair <long, string> > pairTestSummary = null;
                if (resultStatus != null && resultStatus.TestResults != null)
                {
                    pairTestSummary = resultStatus.TestResults.Select(tr => new OrderedPair <long, string>(tr.TestId, tr.TestInterpretation.HasValue ? ((ResultInterpretation)tr.TestInterpretation.Value).ToString() : ""));
                }

                var primaryCarePhysician  = primaryCarePhysicians.SingleOrDefault(pcp => pcp.CustomerId == eventCustomer.CustomerId);
                var customerHealthAnswers = healthAssessmentAnswers.Where(haa => haa.EventCustomerId == eventCustomer.Id).ToArray();

                var primaryCareAnswer = "No";
                var mammogramProstateScreeningAnswer = "No";
                var colonoscopyAnswer     = "No";
                var cancerAnswer          = "No";
                var weightBariatricAnswer = "No";
                if (customerHealthAnswers.Any())
                {
                    var primaryCareQuestionId = healthAssessmentQuestions.Where(haq => haq.Label == HealthAssessmentQuestionLabel.PrimaryCare.GetDescription()).Select(haq => haq.Id).SingleOrDefault();
                    if (primaryCareQuestionId > 0)
                    {
                        var healthassessmentAnswer = customerHealthAnswers.FirstOrDefault(cha => cha.QuestionId == primaryCareQuestionId);
                        if (healthassessmentAnswer != null)
                        {
                            primaryCareAnswer = healthassessmentAnswer.Answer;
                        }
                    }

                    var mammogramProstateScreeningQuestionId = healthAssessmentQuestions.Where(haq => haq.Label == HealthAssessmentQuestionLabel.MammogramProstateScreening.GetDescription()).Select(haq => haq.Id).SingleOrDefault();
                    if (mammogramProstateScreeningQuestionId > 0)
                    {
                        var healthassessmentAnswer = customerHealthAnswers.SingleOrDefault(cha => cha.QuestionId == mammogramProstateScreeningQuestionId);
                        if (healthassessmentAnswer != null)
                        {
                            mammogramProstateScreeningAnswer = healthassessmentAnswer.Answer;
                        }
                    }

                    var colonoscopyQuestionId = healthAssessmentQuestions.Where(haq => haq.Label == HealthAssessmentQuestionLabel.Colonoscopy.GetDescription()).Select(haq => haq.Id).SingleOrDefault();
                    if (colonoscopyQuestionId > 0)
                    {
                        var healthassessmentAnswer = customerHealthAnswers.SingleOrDefault(cha => cha.QuestionId == colonoscopyQuestionId);
                        if (healthassessmentAnswer != null)
                        {
                            colonoscopyAnswer = healthassessmentAnswer.Answer;
                        }
                    }

                    var cancerQuestionId = healthAssessmentQuestions.Where(haq => haq.Label == HealthAssessmentQuestionLabel.Cancer.GetDescription()).Select(haq => haq.Id).SingleOrDefault();
                    if (cancerQuestionId > 0)
                    {
                        var healthassessmentAnswer = customerHealthAnswers.SingleOrDefault(cha => cha.QuestionId == cancerQuestionId);
                        if (healthassessmentAnswer != null)
                        {
                            cancerAnswer = healthassessmentAnswer.Answer;
                        }
                    }

                    var weightBariatricQuestionId = healthAssessmentQuestions.Where(haq => haq.Label == HealthAssessmentQuestionLabel.WeightBariatric.GetDescription()).Select(haq => haq.Id).SingleOrDefault();
                    if (weightBariatricQuestionId > 0)
                    {
                        var healthassessmentAnswer = customerHealthAnswers.SingleOrDefault(cha => cha.QuestionId == weightBariatricQuestionId);
                        if (healthassessmentAnswer != null)
                        {
                            weightBariatricAnswer = healthassessmentAnswer.Answer;
                        }
                    }
                }

                var preferredLanguage = "N/A";
                if (customer.LanguageId.HasValue)
                {
                    var language = languages.FirstOrDefault(x => x.Id == customer.LanguageId);
                    if (language != null)
                    {
                        preferredLanguage = language.Name;
                    }
                }
                EventCustomerNotification eventCustomerNotification = null;

                if (eventCustomerNotifications != null && eventCustomerNotifications.Any())
                {
                    eventCustomerNotification = eventCustomerNotifications.FirstOrDefault(ecn => ecn.EventCustomerId == eventCustomer.Id);
                }

                var eventHospitalPartner = eventHospitalPartners.FirstOrDefault(ehp => ehp.EventId == eventCustomer.EventId);

                var scannedDocumentUrl  = string.Empty;
                var mediaLocScannedDocs = _mediaRepository.GetScannedDocumentStorageFileLocation(eventCustomer.EventId);
                if (Directory.Exists(mediaLocScannedDocs.PhysicalPath))
                {
                    var filesScannedDocs = Directory.GetFiles(mediaLocScannedDocs.PhysicalPath);
                    if (filesScannedDocs.Any())
                    {
                        var filename = filesScannedDocs.Where(fsd => !string.IsNullOrEmpty(fsd) && Path.GetFileName(fsd).StartsWith(customer.CustomerId.ToString())).Select(Path.GetFileName).FirstOrDefault();
                        if (!string.IsNullOrEmpty(filename))
                        {
                            scannedDocumentUrl = mediaLocScannedDocs.Url + filename;
                        }
                    }
                }

                collection.Add(new CorporateAccountCustomerViewModel
                {
                    CustomerName               = customer.Name,
                    Phone                      = customer.HomePhoneNumber != null ? customer.HomePhoneNumber.FormatPhoneNumber : string.Empty,
                    PhoneCell                  = customer.MobilePhoneNumber != null ? customer.MobilePhoneNumber.FormatPhoneNumber : string.Empty,
                    PhoneOffice                = customer.OfficePhoneNumber != null ? customer.OfficePhoneNumber.FormatPhoneNumber : string.Empty,
                    PhoneOfficeExtn            = customer.PhoneOfficeExtension,
                    DateofBirth                = customer.DateOfBirth,
                    Package                    = productPurchased,
                    CdPurchased                = cdPurchased,
                    EventDate                  = eventData.EventDate,
                    CustomerId                 = customer.CustomerId,
                    EventId                    = eventCustomer.EventId,
                    Gender                     = customer.Gender.ToString(),
                    Height                     = customer.Height != null && customer.Height.TotalInches > 0 ? customer.Height.TotalInches.ToString() : "N/A",
                    Weight                     = customer.Weight != null && customer.Weight.Pounds > 0 ? customer.Weight.Pounds.ToString() : "N/A",
                    Pod                        = string.Join(", ", eventPods.Select(ep => ep.Name)),
                    IsEvaluated                = isEvaluated,
                    IsPdfGenerated             = isPdfGenerated,
                    Result                     = result,
                    Recommendation             = recommendation,
                    Email                      = customer.Email != null ? customer.Email.ToString() : string.Empty,
                    Address                    = Mapper.Map <Address, AddressViewModel>(customer.Address),
                    ShippingMode               = shippingDetail != null ? "Paper" : "Online",
                    MailedStatus               = shippingDetail != null ? shippingDetail.Status.ToString() : "Online",
                    MailedOn                   = shippingDetail != null ? shippingDetail.ShipmentDate : null,
                    CorporateSponsor           = corporateAccountName ?? "N/A",
                    TestSummary                = pairTestSummary,
                    PrimaryCarePhysicianName   = primaryCarePhysician != null ? primaryCarePhysician.Name.FullName : "N/A",
                    PrimaryCare                = primaryCareAnswer,
                    MammogramProstateScreening = mammogramProstateScreeningAnswer,
                    Colonoscopy                = colonoscopyAnswer,
                    Cancer                     = cancerAnswer,
                    WeightBariatric            = weightBariatricAnswer,
                    PreferredLanguage          = preferredLanguage,
                    BestTimeToCall             = customer.BestTimeToCall.HasValue && customer.BestTimeToCall.Value > 0 ? ((BestTimeToCall)customer.BestTimeToCall).GetDescription() : "N/A",
                    EventCustomerId            = eventCustomer.Id,
                    IsCannedMessageSent        = eventCustomerNotification != null,
                    Ssn                        = (eventHospitalPartner != null && eventHospitalPartner.CaptureSsn && !string.IsNullOrEmpty(customer.Ssn) && customer.Ssn.Length >= 9)
                                ? customer.Ssn.Substring(0, 3) + "-" + customer.Ssn.Substring(3, 2) + "-" + customer.Ssn.Substring(customer.Ssn.Length - 4)//"XXX-XX-" + customer.Ssn.Substring(customer.Ssn.Length - 4)
                                : string.Empty,
                    MemberId           = string.IsNullOrEmpty(customer.InsuranceId) ? "N/A" : customer.InsuranceId,
                    ScannedDocumentUrl = scannedDocumentUrl,
                    HicnNumber         = customer.Hicn
                });
            }

            return(new CorporateAccountCustomerListModel
            {
                Collection = collection
            });
        }
Esempio n. 23
0
        public EventCustomerOrderSummaryModel GetEventCustomerOrderSummaryModel(TempCart tempCart, SourceCodeApplyEditModel sourceCodeModel = null)
        {
            if (tempCart == null)
            {
                return(new EventCustomerOrderSummaryModel());
            }

            Event theEvent  = null;
            Host  eventHost = null;

            if (tempCart.EventId.HasValue)
            {
                theEvent  = _eventRepository.GetById(tempCart.EventId.Value);
                eventHost = _hostRepository.GetHostForEvent(tempCart.EventId.Value);
            }

            EventSchedulingSlot appointment = null;

            if (tempCart.AppointmentId.HasValue)
            {
                appointment = _slotRepository.GetbyId(tempCart.AppointmentId.Value);
            }

            EventPackage eventPackage = null;

            if (tempCart.EventPackageId.HasValue)
            {
                eventPackage = _eventPackageRepository.GetById(tempCart.EventPackageId.Value);
            }

            IEnumerable <EventTest> eventTests = null;
            var testIds = new List <long>();

            if (!string.IsNullOrEmpty(tempCart.TestId))
            {
                string[] testIdStrings = tempCart.TestId.Split(new[] { ',' });
                foreach (var testIdString in testIdStrings)
                {
                    int i = 0;
                    if (int.TryParse(testIdString, out i))
                    {
                        testIds.Add(i);
                    }
                }
            }

            if (testIds.Count > 0)
            {
                eventTests = _eventTestRepository.GetbyIds(testIds);
            }

            IEnumerable <ElectronicProduct> products = null;

            var productIds = new List <long>();

            if (!string.IsNullOrEmpty(tempCart.ProductId))
            {
                string[] productIdStrings = tempCart.ProductId.Split(new[] { ',' });
                foreach (var productIdIdString in productIdStrings)
                {
                    int i = 0;
                    if (int.TryParse(productIdIdString, out i))
                    {
                        productIds.Add(i);
                    }
                }
            }

            if (productIds.Count > 0)
            {
                products = _productRepository.GetByIds(productIds);
            }

            ShippingOption shippingOption = null;

            if (tempCart.ShippingId.HasValue && tempCart.ShippingId.Value > 0)
            {
                shippingOption = _shippingOptionRepository.GetById(tempCart.ShippingId.Value);
            }


            SourceCodeApplyEditModel applySourceCodemodel = sourceCodeModel ?? GetSourceCodeApplied(tempCart);

            Order order = null;

            if (tempCart.IsCompleted)
            {
                order = _orderRepository.GetOrder(tempCart.CustomerId.Value, tempCart.EventId.Value);
            }

            return(_eventCustomerSummaryModelFactory.Create(theEvent, eventHost, appointment, eventPackage, eventTests, products, shippingOption, applySourceCodemodel, order, tempCart.ShippingId));
        }
Esempio n. 24
0
        public MemberStatusListModel Create(IEnumerable <Customer> customers, IEnumerable <EventCustomer> eventCustomers, EventVolumeListModel eventListModel, IEnumerable <Order> orders,
                                            IEnumerable <OrderedPair <long, string> > packages, IEnumerable <OrderedPair <long, string> > tests, IEnumerable <Core.CallCenter.Domain.Call> calls,
                                            IEnumerable <CorporateCustomerCustomTag> customTags, IEnumerable <PrimaryCarePhysician> primaryCarePhysicians, IEnumerable <Notes> doNotContactReasonNotes,
                                            IEnumerable <OrderedPair <long, string> > customersPreApprovedTests, IEnumerable <OrderedPair <long, string> > customersPreApprovedPackages,
                                            IEnumerable <DirectMail> directMails, IEnumerable <Appointment> appointments, IEnumerable <ShippingDetail> shipingDetails,
                                            IEnumerable <OrderedPair <long, long> > shippingDetailIdEventCustomerIdPairs, IEnumerable <ShippingOption> shippingOptions, ShippingOption pcpShippingOptions,
                                            IEnumerable <CorporateAccount> corporateAccounts, IEnumerable <AccountAdditionalFields> accountAdditionalFields, DateTime fromDate, DateTime toDate,
                                            IEnumerable <ProspectCustomer> prospectCustomers, IEnumerable <CustomerPredictedZip> customerPredictedZips, IEnumerable <CustomerEligibility> customerEligibilityList,
                                            IEnumerable <CustomerTargeted> customerTargetedList, IEnumerable <Core.Medical.Domain.ActivityType> activityTypes)
        {
            var model = new MemberStatusListModel();
            var memberStatusModels = new List <MemberStatusModel>();

            foreach (var customer in customers)
            {
                var customerCalls        = calls.Where(c => c.CalledCustomerId == customer.CustomerId);
                var callDetail           = customerCalls.OrderByDescending(x => x.CallDateTime).FirstOrDefault();
                var customerDirectMails  = directMails.Where(x => x.CustomerId == customer.CustomerId);
                var customerPredictedZip = customerPredictedZips != null?customerPredictedZips.Where(x => x.CustomerId == customer.CustomerId) : null;

                var customerEligibility = customerEligibilityList.FirstOrDefault(x => x.CustomerId == customer.CustomerId);
                var customerTargeted    = customerTargetedList.FirstOrDefault(x => x.CustomerId == customer.CustomerId);

                var isEligible = "N/A";

                var corporateCustomTags = "N/A";

                if (customerEligibility != null && customerEligibility.IsEligible.HasValue)
                {
                    isEligible = customerEligibility.IsEligible.Value ? "Yes" : "No";
                }

                var prospectCustomer = prospectCustomers.FirstOrDefault(p => p.CustomerId == customer.CustomerId);

                if (customTags != null && customTags.Any())
                {
                    var customerCustomTags = customTags.Where(ct => ct.CustomerId == customer.CustomerId).Select(ct => ct.Tag).ToArray();

                    if (customerCustomTags.Any())
                    {
                        corporateCustomTags = string.Join(", ", customerCustomTags);
                    }
                }

                var pcp = primaryCarePhysicians.Where(p => p.CustomerId == customer.CustomerId).Select(p => p).FirstOrDefault();

                var customerPreApprovedTest = "N/A";

                if (customersPreApprovedTests != null && customersPreApprovedTests.Any())
                {
                    var customerTests = customersPreApprovedTests.Where(x => x.FirstValue == customer.CustomerId);
                    if (customerTests != null && customerTests.Any())
                    {
                        var preApproveTestTemp = customerTests.Select(x => string.Format("\"{0}\"", x.SecondValue)).ToArray();

                        customerPreApprovedTest = string.Join(", ", preApproveTestTemp);
                    }
                }

                var customerPreApprovedPakages = "N/A";

                if (customersPreApprovedPackages != null && customersPreApprovedPackages.Any())
                {
                    var customerPackages = customersPreApprovedPackages.Where(x => x.FirstValue == customer.CustomerId);
                    if (customerPackages != null && customerPackages.Any())
                    {
                        var preApproveTestTemp = customerPackages.Select(x => string.Format("\"{0}\"", x.SecondValue)).ToArray();

                        customerPreApprovedPakages = string.Join(", ", preApproveTestTemp);
                    }
                }
                var displayFielAandAdditionalFieldsPairs = new List <OrderedPair <string, string> >();
                if (corporateAccounts != null && corporateAccounts.Any() && !string.IsNullOrEmpty(customer.Tag) && accountAdditionalFields != null && accountAdditionalFields.Any())
                {
                    var corporateAccount = corporateAccounts.FirstOrDefault(a => a.Tag == customer.Tag);

                    if (corporateAccount != null)
                    {
                        var additionalFields = accountAdditionalFields.Where(x => x.AccountId == corporateAccount.Id).ToArray();

                        foreach (var additionalField in additionalFields)
                        {
                            displayFielAandAdditionalFieldsPairs.Add(new OrderedPair <string, string>(additionalField.DisplayName, GetCustomersAdditionFiledValue(customer, (AdditionalFieldsEnum)additionalField.AdditionalFieldId)));
                        }
                    }
                }

                string activityType = "N/A";
                if (customer.ActivityId.HasValue && !activityTypes.IsNullOrEmpty())
                {
                    activityType = activityTypes.Single(x => x.Id == customer.ActivityId.Value).Name;
                }

                var isTargetedMember = "N/A";
                if (customerTargeted != null && customerTargeted.IsTargated.HasValue)
                {
                    isTargetedMember = customerTargeted.IsTargated.Value ? "Yes" : "No";
                }

                var customerExportModel = new MemberStatusModel
                {
                    CustomerId                                                                                                                                         = customer.CustomerId,
                    FirstName                                                                                                                                          = customer.Name.FirstName,
                    MiddleName                                                                                                                                         = customer.Name.MiddleName,
                    LastName                                                                                                                                           = customer.Name.LastName,
                    PhoneHome                                                                                                                                          = customer.HomePhoneNumber != null?customer.HomePhoneNumber.ToString() : string.Empty,
                                                                                 Gender                                                                                = customer.Gender.ToString(),
                                                                                 DateofBirth                                                                           = customer.DateOfBirth,
                                                                                 Address1                                                                              = customer.Address.StreetAddressLine1,
                                                                                 Address2                                                                              = customer.Address.StreetAddressLine2,
                                                                                 City                                                                                  = customer.Address.City,
                                                                                 State                                                                                 = customer.Address.State,
                                                                                 Zip                                                                                   = customer.Address.ZipCode.Zip,
                                                                                 Email                                                                                 = customer.Email != null?customer.Email.ToString() : string.Empty,
                                                                                                                              Tag                                      = string.IsNullOrEmpty(customer.Tag) ? "N/A" : customer.Tag,
                                                                                                                              MemberId                                 = string.IsNullOrEmpty(customer.InsuranceId) ? "N/A" : customer.InsuranceId,
                                                                                                                              IsEligible                               = isEligible,
                                                                                                                              IsTargetedMember                         = isTargetedMember,
                                                                                                                              CustomTag                                = corporateCustomTags,
                                                                                                                              MedicarePlanName                         = string.IsNullOrEmpty(customer.MedicareAdvantagePlanName) ? "N/A" : customer.MedicareAdvantagePlanName,
                                                                                                                              Hicn                                     = string.IsNullOrEmpty(customer.Hicn) ? "N/A" : customer.Hicn,
                                                                                                                              Mbi                                      = string.IsNullOrEmpty(customer.Mbi) ? "N/A" : customer.Mbi,
                                                                                                                              Market                                   = string.IsNullOrEmpty(customer.Market) ? "N/A" : customer.Market,
                                                                                                                              GroupName                                = string.IsNullOrEmpty(customer.GroupName) ? "N/A" : customer.GroupName,
                                                                                                                              PreApprovedTest                          = customerPreApprovedTest,
                                                                                                                              PreApprovedPackage                       = customerPreApprovedPakages,
                                                                                                                              AdditionalFields                         = displayFielAandAdditionalFieldsPairs,
                                                                                                                              Activity                                 = activityType,
                                                                                                                              PredictedZip                             = customerPredictedZip != null?string.Join(", ", customerPredictedZip.Select(x => x.PredictedZip)) : "N/A",
                                                                                                                                                               AcesId  = customer.AcesId,
                                                                                                                                                               Product = customer.ProductTypeId.HasValue && customer.ProductTypeId.Value > 0 ? ((ProductType)customer.ProductTypeId.Value).GetDescription() : "N/A"
                };

                GetRestrictionData(customerExportModel, customer, fromDate, toDate, doNotContactReasonNotes);

                if (pcp != null)
                {
                    customerExportModel.PcpFirstName = pcp.Name.FirstName;
                    customerExportModel.PcpLastName  = pcp.Name.LastName;
                    customerExportModel.PcpNpi       = string.IsNullOrEmpty(pcp.Npi) ? "N/A" : pcp.Npi;

                    if (pcp.Address != null && !pcp.Address.IsEmpty())
                    {
                        customerExportModel.PcpAddress1 = pcp.Address.StreetAddressLine1;
                        customerExportModel.PcpAddress2 = pcp.Address.StreetAddressLine2;
                        customerExportModel.PcpCity     = pcp.Address.City;
                        customerExportModel.PcpState    = pcp.Address.State;
                        customerExportModel.PcpZip      = pcp.Address.ZipCode.Zip;
                    }
                    customerExportModel.PcpFax = pcp.Fax != null?pcp.Fax.ToString() : string.Empty;

                    customerExportModel.PcpPhone = pcp.Primary != null?pcp.Primary.ToString() : string.Empty;
                }

                EventCustomer    eventCustomer     = null;
                EventVolumeModel eventModel        = null;
                EventVolumeModel lastScreeningDate = null;

                var scheduledStatus = ScheduledStatus.NotScheduled;
                if (eventCustomers != null && eventCustomers.Any())
                {
                    //var startDate = new DateTime(DateTime.Today.Year, 1, 1);
                    //var endDate = new DateTime(DateTime.Today.Year, 12, 31);

                    eventCustomer = (from ec in eventCustomers
                                     join e in eventListModel.Collection on ec.EventId equals e.EventCode
                                     where ec.CustomerId == customer.CustomerId
                                     orderby e.EventDate descending
                                     select ec).FirstOrDefault();

                    var appointmentIds = eventCustomers.Where(ec => ec.AppointmentId.HasValue && ec.CustomerId == customer.CustomerId).Select(x => x.AppointmentId.Value).ToArray();


                    var hasBeenScheduledForCurrentyear = (from ec in eventCustomers
                                                          join e in eventListModel.Collection on ec.EventId equals e.EventCode
                                                          where ec.CustomerId == customer.CustomerId
                                                          select ec).Any();

                    lastScreeningDate = (from a in appointments
                                         join e in eventListModel.Collection on a.EventId equals e.EventCode
                                         join ec in eventCustomers on e.EventCode equals ec.EventId
                                         where a.CheckInTime != null && a.CheckOutTime != null && appointmentIds.Contains(a.Id) && !ec.NoShow && !ec.LeftWithoutScreeningReasonId.HasValue
                                         orderby e.EventDate descending
                                         select e).FirstOrDefault();

                    if (hasBeenScheduledForCurrentyear)
                    {
                        scheduledStatus = ScheduledStatus.Scheduled;
                    }

                    if (eventCustomer != null)
                    {
                        if (shipingDetails != null && shipingDetails.Any())
                        {
                            var shipingIds = shippingDetailIdEventCustomerIdPairs.Where(m => m.SecondValue == eventCustomer.Id).Select(m => m.FirstValue);
                            if (shipingIds != null && shipingIds.Any())
                            {
                                var shipingDetail = shipingDetails.Where(m => shipingIds.Contains(m.Id) && m.Status == ShipmentStatus.Shipped);
                                if (shipingDetail != null && shipingDetail.Any())
                                {
                                    var customerResultShipDetail = (from s in shipingDetail
                                                                    join so in shippingOptions on s.ShippingOption.Id equals so.Id
                                                                    orderby s.ShipmentDate descending
                                                                    select s).FirstOrDefault();

                                    var pcpResultShipDetail = (from s in shipingDetail
                                                               where s.ShippingOption.Id == pcpShippingOptions.Id
                                                               select s).FirstOrDefault();
                                    if (pcpResultShipDetail != null)
                                    {
                                        customerExportModel.PCPResultShipedDate = pcpResultShipDetail.ShipmentDate;
                                    }

                                    if (customerResultShipDetail != null)
                                    {
                                        customerExportModel.CustomerResultShipedDate = customerResultShipDetail.ShipmentDate;
                                    }
                                }
                            }
                        }


                        var order = orders.FirstOrDefault(o => o.EventId == eventCustomer.EventId && o.CustomerId == eventCustomer.CustomerId);
                        if (order != null)
                        {
                            var package = packages.FirstOrDefault(p => p.FirstValue == order.Id);

                            var test = tests.Where(p => p.FirstValue == order.Id).ToList();

                            var productPurchased = string.Empty;

                            if (package != null && !test.IsNullOrEmpty())
                            {
                                productPurchased = package.SecondValue + " + " + string.Join(" + ", test.Select(t => t.SecondValue).ToArray());
                            }
                            else if (!test.IsNullOrEmpty())
                            {
                                productPurchased = string.Join(" + ", test.Select(t => t.SecondValue).ToArray());
                            }
                            else if (package != null)
                            {
                                productPurchased = package.SecondValue;
                            }

                            customerExportModel.Package = productPurchased;
                        }

                        eventModel = eventListModel.Collection.FirstOrDefault(e => e.EventCode == eventCustomer.EventId);
                        if (eventModel != null)
                        {
                            customerExportModel.EventId          = eventModel.EventCode;
                            customerExportModel.EventName        = eventModel.Location;
                            customerExportModel.EventDate        = eventModel.EventDate;
                            customerExportModel.EventAddress1    = eventModel.StreetAddressLine1;
                            customerExportModel.EventAddress2    = eventModel.StreetAddressLine2;
                            customerExportModel.EventCity        = eventModel.City;
                            customerExportModel.EventState       = eventModel.State;
                            customerExportModel.EventZip         = eventModel.Zip;
                            customerExportModel.Pod              = eventModel.Pod;
                            customerExportModel.CompletionStatus = GetCompletionStatus(eventCustomer, eventModel.EventDate, lastScreeningDate);
                            customerExportModel.RegistrationDate = eventCustomer.DataRecorderMetaData.DateCreated;
                        }
                    }
                }

                customerExportModel.CurrentStatus   = GetCurrentStatus(customer, customerDirectMails, eventCustomer, eventModel, lastScreeningDate, prospectCustomer, fromDate, toDate, customerEligibility);
                customerExportModel.ScheduledStatus = scheduledStatus;

                if (callDetail != null)
                {
                    int?dispositionId = null;
                    if (!string.IsNullOrEmpty(callDetail.Disposition))
                    {
                        ProspectCustomerTag tag;
                        Enum.TryParse(callDetail.Disposition, true, out tag);

                        dispositionId = (int)tag;
                    }

                    customerExportModel.CurrentOutboundCallOutcome = ((CallStatus)callDetail.Status).GetDescription();

                    if (dispositionId.HasValue)
                    {
                        customerExportModel.CurrentOutboundCallDisposition = ((ProspectCustomerTag)dispositionId.Value).GetDescription();
                    }

                    customerExportModel.CurrentOutboundCallCategory = GetCallCategoryByStatus(callDetail.Status, dispositionId);
                }

                SetReportModelOutReachType(customerExportModel, customerCalls, customerDirectMails, customer.CustomerId);

                memberStatusModels.Add(customerExportModel);
            }

            model.Collection = memberStatusModels;
            return(model);
        }
Esempio n. 25
0
 public static void NavigateToPaymentFormStep5(this INavigationService service, MessageViewModel message, PaymentForm paymentForm, OrderInfo info, ValidatedOrderInfo validatedInfo, ShippingOption shipping, string title, string credentials, bool save)
 {
     service.Navigate(typeof(PaymentFormStep5Page), Tuple.Create(message, paymentForm, info, validatedInfo, shipping, title ?? string.Empty, credentials ?? string.Empty, save));
 }
Esempio n. 26
0
        public ProcessPaymentRequest SetCheckoutDetails(ProcessPaymentRequest processPaymentRequest, GetExpressCheckoutDetailsResponseDetailsType checkoutDetails)
        {
            int customerId = Convert.ToInt32(Services.WorkContext.CurrentCustomer.Id.ToString());
            var customer   = _customerService.GetCustomerById(customerId);
            var settings   = Services.Settings.LoadSetting <PayPalExpressPaymentSettings>(Services.StoreContext.CurrentStore.Id);

            Services.WorkContext.CurrentCustomer = customer;

            //var cart = customer.ShoppingCartItems.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart).ToList();
            var cart = Services.WorkContext.CurrentCustomer.GetCartItems(ShoppingCartType.ShoppingCart, Services.StoreContext.CurrentStore.Id);

            // get/update billing address
            string billingFirstName       = checkoutDetails.PayerInfo.PayerName.FirstName;
            string billingLastName        = checkoutDetails.PayerInfo.PayerName.LastName;
            string billingEmail           = checkoutDetails.PayerInfo.Payer;
            string billingAddress1        = checkoutDetails.PayerInfo.Address.Street1;
            string billingAddress2        = checkoutDetails.PayerInfo.Address.Street2;
            string billingPhoneNumber     = checkoutDetails.PayerInfo.ContactPhone;
            string billingCity            = checkoutDetails.PayerInfo.Address.CityName;
            int?   billingStateProvinceId = null;
            var    billingStateProvince   = _stateProvinceService.GetStateProvinceByAbbreviation(checkoutDetails.PayerInfo.Address.StateOrProvince);

            if (billingStateProvince != null)
            {
                billingStateProvinceId = billingStateProvince.Id;
            }
            string billingZipPostalCode = checkoutDetails.PayerInfo.Address.PostalCode;
            int?   billingCountryId     = null;
            var    billingCountry       = _countryService.GetCountryByTwoLetterIsoCode(checkoutDetails.PayerInfo.Address.Country.ToString());

            if (billingCountry != null)
            {
                billingCountryId = billingCountry.Id;
            }

            var billingAddress = customer.Addresses.FindAddress(
                billingFirstName, billingLastName, billingPhoneNumber,
                billingEmail, string.Empty, string.Empty, billingAddress1, billingAddress2, billingCity,
                billingStateProvinceId, billingZipPostalCode, billingCountryId);

            if (billingAddress == null)
            {
                billingAddress = new Core.Domain.Common.Address()
                {
                    FirstName       = billingFirstName,
                    LastName        = billingLastName,
                    PhoneNumber     = billingPhoneNumber,
                    Email           = billingEmail,
                    FaxNumber       = string.Empty,
                    Company         = string.Empty,
                    Address1        = billingAddress1,
                    Address2        = billingAddress2,
                    City            = billingCity,
                    StateProvinceId = billingStateProvinceId,
                    ZipPostalCode   = billingZipPostalCode,
                    CountryId       = billingCountryId,
                    CreatedOnUtc    = DateTime.UtcNow,
                };
                customer.Addresses.Add(billingAddress);
            }

            //set default billing address
            customer.BillingAddress = billingAddress;
            _customerService.UpdateCustomer(customer);

            var genericAttributeService = EngineContext.Current.Resolve <IGenericAttributeService>();

            genericAttributeService.SaveAttribute <ShippingOption>(customer, SystemCustomerAttributeNames.SelectedShippingOption, null);

            bool shoppingCartRequiresShipping = cart.RequiresShipping();

            if (shoppingCartRequiresShipping)
            {
                var      paymentDetails    = checkoutDetails.PaymentDetails.FirstOrDefault();
                string[] shippingFullname  = paymentDetails.ShipToAddress.Name.Trim().Split(new char[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
                string   shippingFirstName = shippingFullname[0];
                string   shippingLastName  = string.Empty;
                if (shippingFullname.Length > 1)
                {
                    shippingLastName = shippingFullname[1];
                }
                string shippingEmail           = checkoutDetails.PayerInfo.Payer;
                string shippingAddress1        = paymentDetails.ShipToAddress.Street1;
                string shippingAddress2        = paymentDetails.ShipToAddress.Street2;
                string shippingPhoneNumber     = paymentDetails.ShipToAddress.Phone;
                string shippingCity            = paymentDetails.ShipToAddress.CityName;
                int?   shippingStateProvinceId = null;
                var    shippingStateProvince   = _stateProvinceService.GetStateProvinceByAbbreviation(paymentDetails.ShipToAddress.StateOrProvince);
                if (shippingStateProvince != null)
                {
                    shippingStateProvinceId = shippingStateProvince.Id;
                }
                int?   shippingCountryId     = null;
                string shippingZipPostalCode = paymentDetails.ShipToAddress.PostalCode;
                var    shippingCountry       = _countryService.GetCountryByTwoLetterIsoCode(paymentDetails.ShipToAddress.Country.ToString());
                if (shippingCountry != null)
                {
                    shippingCountryId = shippingCountry.Id;
                }

                var shippingAddress = customer.Addresses.FindAddress(
                    shippingFirstName, shippingLastName, shippingPhoneNumber,
                    shippingEmail, string.Empty, string.Empty,
                    shippingAddress1, shippingAddress2, shippingCity,
                    shippingStateProvinceId, shippingZipPostalCode, shippingCountryId);

                if (shippingAddress == null)
                {
                    shippingAddress = new Core.Domain.Common.Address()
                    {
                        FirstName       = shippingFirstName,
                        LastName        = shippingLastName,
                        PhoneNumber     = shippingPhoneNumber,
                        Email           = shippingEmail,
                        FaxNumber       = string.Empty,
                        Company         = string.Empty,
                        Address1        = shippingAddress1,
                        Address2        = shippingAddress2,
                        City            = shippingCity,
                        StateProvinceId = shippingStateProvinceId,
                        ZipPostalCode   = shippingZipPostalCode,
                        CountryId       = shippingCountryId,
                        CreatedOnUtc    = DateTime.UtcNow,
                    };
                    customer.Addresses.Add(shippingAddress);
                }

                customer.ShippingAddress = shippingAddress;
                _customerService.UpdateCustomer(customer);
            }

            bool isShippingSet = false;
            GetShippingOptionResponse getShippingOptionResponse = _shippingService.GetShippingOptions(cart, customer.ShippingAddress);

            if (checkoutDetails.UserSelectedOptions != null)
            {
                if (getShippingOptionResponse.Success && getShippingOptionResponse.ShippingOptions.Count > 0)
                {
                    foreach (var shippingOption in getShippingOptionResponse.ShippingOptions)
                    {
                        if (checkoutDetails.UserSelectedOptions.ShippingOptionName.Contains(shippingOption.Name) &&
                            checkoutDetails.UserSelectedOptions.ShippingOptionName.Contains(shippingOption.Description))
                        {
                            _genericAttributeService.SaveAttribute(Services.WorkContext.CurrentCustomer, SystemCustomerAttributeNames.SelectedShippingOption, shippingOption);
                            isShippingSet = true;
                            break;
                        }
                    }
                }

                if (!isShippingSet)
                {
                    var shippingOption = new ShippingOption();
                    shippingOption.Name = checkoutDetails.UserSelectedOptions.ShippingOptionName;
                    decimal shippingPrice = settings.DefaultShippingPrice;
                    decimal.TryParse(checkoutDetails.UserSelectedOptions.ShippingOptionAmount.Value, out shippingPrice);
                    shippingOption.Rate = shippingPrice;
                    _genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.SelectedShippingOption, shippingOption);
                }
            }

            processPaymentRequest.PaypalPayerId = checkoutDetails.PayerInfo.PayerID;


            return(processPaymentRequest);
        }
        private List <ShippingOption> ParseResponse(string response, ref string error)
        {
            var shippingOptions = new List <ShippingOption>();

            string carrierServicesOffered = _upsSettings.CarrierServicesOffered;

            using (var sr = new StringReader(response))
                using (var tr = new XmlTextReader(sr))
                    while (tr.Read())
                    {
                        if ((tr.Name == "Error") && (tr.NodeType == XmlNodeType.Element))
                        {
                            string errorText = "";
                            while (tr.Read())
                            {
                                if ((tr.Name == "ErrorCode") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    errorText += "UPS Rating Error, Error Code: " + tr.ReadString() + ", ";
                                }
                                if ((tr.Name == "ErrorDescription") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    errorText += "Error Desc: " + tr.ReadString();
                                }
                            }
                            error = "UPS Error returned: " + errorText;
                        }
                        if ((tr.Name == "RatedShipment") && (tr.NodeType == XmlNodeType.Element))
                        {
                            string serviceCode   = "";
                            string monetaryValue = "";
                            while (tr.Read())
                            {
                                if ((tr.Name == "Service") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    while (tr.Read())
                                    {
                                        if ((tr.Name == "Code") && (tr.NodeType == XmlNodeType.Element))
                                        {
                                            serviceCode = tr.ReadString();
                                            tr.ReadEndElement();
                                        }
                                        if ((tr.Name == "Service") && (tr.NodeType == XmlNodeType.EndElement))
                                        {
                                            break;
                                        }
                                    }
                                }
                                if (((tr.Name == "RatedShipment") && (tr.NodeType == XmlNodeType.EndElement)) || ((tr.Name == "RatedPackage") && (tr.NodeType == XmlNodeType.Element)))
                                {
                                    break;
                                }
                                if ((tr.Name == "TotalCharges") && (tr.NodeType == XmlNodeType.Element))
                                {
                                    while (tr.Read())
                                    {
                                        if ((tr.Name == "MonetaryValue") && (tr.NodeType == XmlNodeType.Element))
                                        {
                                            monetaryValue = tr.ReadString();
                                            tr.ReadEndElement();
                                        }
                                        if ((tr.Name == "TotalCharges") && (tr.NodeType == XmlNodeType.EndElement))
                                        {
                                            break;
                                        }
                                    }
                                }
                            }
                            string service   = GetServiceName(serviceCode);
                            string serviceId = String.Format("[{0}]", serviceCode);

                            // Go to the next rate if the service ID is not in the list of services to offer
                            if (!String.IsNullOrEmpty(carrierServicesOffered) && !carrierServicesOffered.Contains(serviceId))
                            {
                                continue;
                            }

                            //Weed out unwanted or unkown service rates
                            if (service.ToUpper() != "UNKNOWN")
                            {
                                var shippingOption = new ShippingOption();
                                shippingOption.Rate = Convert.ToDecimal(monetaryValue, new CultureInfo("en-US"));
                                shippingOption.Name = service;
                                shippingOptions.Add(shippingOption);
                            }
                        }
                    }

            return(shippingOptions);
        }
Esempio n. 28
0
        /// <summary>
        ///  Gets available shipping options
        /// </summary>
        /// <param name="getShippingOptionRequest">A request for getting shipping options</param>
        /// <returns>Represents a response of getting shipping rate options</returns>
        public GetShippingOptionResponse GetShippingOptions(GetShippingOptionRequest getShippingOptionRequest)
        {
            if (getShippingOptionRequest == null)
            {
                throw new ArgumentNullException("getShippingOptionRequest");
            }

            var response = new GetShippingOptionResponse();

            if (getShippingOptionRequest.Items == null)
            {
                response.AddError(T("Admin.System.Warnings.NoShipmentItems"));
                return(response);
            }

            try
            {
                var profile = new Profile();
                profile.MerchantId = _canadaPostSettings.CustomerId;

                var adr = getShippingOptionRequest.ShippingAddress;

                if (adr != null && adr.Country != null && adr.StateProvince != null)
                {
                    var destination = new Destination()
                    {
                        City            = adr.City,
                        StateOrProvince = adr.StateProvince.Abbreviation,
                        Country         = adr.Country.TwoLetterIsoCode,
                        PostalCode      = adr.ZipPostalCode,
                    };

                    var items = CreateItems(getShippingOptionRequest);

                    var lang = CanadaPostLanguageEnum.English;
                    if (_workContext.WorkingLanguage.LanguageCulture.StartsWith("fr", StringComparison.InvariantCultureIgnoreCase))
                    {
                        lang = CanadaPostLanguageEnum.French;
                    }

                    var requestResult = GetShippingOptionsInternal(profile, destination, items, lang);
                    if (requestResult.IsError)
                    {
                        response.AddError(requestResult.StatusMessage);
                    }
                    else
                    {
                        foreach (var dr in requestResult.AvailableRates)
                        {
                            var so = new ShippingOption();
                            so.Name = dr.Name;
                            if (!string.IsNullOrEmpty(dr.DeliveryDate))
                            {
                                so.Name += string.Format(" - {0}", dr.DeliveryDate);
                            }
                            so.Rate = dr.Amount;
                            response.ShippingOptions.Add(so);
                        }
                    }

                    foreach (var shippingOption in response.ShippingOptions)
                    {
                        if (!shippingOption.Name.StartsWith("canada post", StringComparison.InvariantCultureIgnoreCase))
                        {
                            shippingOption.Name = string.Format("Canada Post {0}", shippingOption.Name);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                response.AddError(e.Message);
            }

            return(response);
        }
Esempio n. 29
0
        public virtual async Task <(Money Amount, Discount AppliedDiscount)> AdjustShippingRateAsync(
            IList <OrganizedShoppingCartItem> cart,
            Money shippingRate,
            ShippingOption shippingOption,
            IList <ShippingMethod> shippingMethods)
        {
            Guard.NotNull(cart, nameof(cart));
            Guard.NotNull(shippingRate, nameof(shippingRate));
            Guard.NotNull(shippingRate.Currency, nameof(shippingRate.Currency));

            if (await IsFreeShippingAsync(cart))
            {
                return(new(), null);
            }

            var customer = cart.GetCustomer();
            var ignoreAdditionalShippingCharge = false;
            var bundlePerItemShipping          = new Money(_primaryCurrency);
            var adjustedRate = new Money(_primaryCurrency);

            foreach (var cartItem in cart)
            {
                var item = cartItem.Item;

                if (item.Product != null && item.Product.ProductType == ProductType.BundledProduct && item.Product.BundlePerItemShipping)
                {
                    foreach (var childItem in cartItem.ChildItems.Where(x => x.Item.IsShippingEnabled && !x.Item.IsFreeShipping))
                    {
                        bundlePerItemShipping += shippingRate;
                    }
                }
                else if (adjustedRate == decimal.Zero)
                {
                    adjustedRate = shippingRate;
                }
            }

            adjustedRate += bundlePerItemShipping;

            if (shippingOption != null && shippingMethods != null)
            {
                var shippingMethod = shippingMethods.FirstOrDefault(x => x.Id == shippingOption.ShippingMethodId);
                if (shippingMethod != null)
                {
                    ignoreAdditionalShippingCharge = shippingMethod.IgnoreCharges;
                }
            }

            // Additional shipping charges.
            if (!ignoreAdditionalShippingCharge)
            {
                var additionalShippingCharge = await GetShoppingCartAdditionalShippingChargeAsync(cart);

                adjustedRate += additionalShippingCharge;
            }

            // Discount.
            var(discountAmount, discount) = await this.GetShippingDiscountAsync(adjustedRate, customer);

            var amount = _primaryCurrency.AsMoney(adjustedRate.Amount - discountAmount.Amount, true, true);

            return(amount, discount);
        }
 private void AddShippingOption(ShippingOption option, double cost)
 {
     ShippingOptionRadio.Items.Add(new ListItem(String.Format("{0} - {1}", option.Label, Helper.Dollar(cost)), option.ShippingOptionID.ToString()));
 }
        public void Can_run_activity_processshipment()
        {
            var orderGroup = CreateCart();

            orderGroup.OrderForms[0].Shipments[0].ShippingMethodId = "FlatRate";

            var gateway0 = new ShippingGateway
            {
                ClassType = "VirtoCommerce.Shipping.SimpleShippingGateway, VirtoCommerce.SimpleShippingGateway",
                Name      = "SimpleShippingGateway"
            };
            var option = new ShippingOption {
                Name = "default", Description = "Default", ShippingGateway = gateway0
            };
            var option2 = new ShippingOption {
                Name = "default2", Description = "Default2", ShippingGateway = gateway0
            };
            var shippingMethods = new List <ShippingMethod>
            {
                new ShippingMethod
                {
                    ShippingMethodId = "FreeShipping",
                    Name             = "FreeShipping",
                    DisplayName      = "Free Shipping",
                    Description      = "Free Shipping",
                    Currency         = "USD",
                    BasePrice        = 0,
                    IsActive         = true,
                    ShippingOption   = option
                },
                new ShippingMethod
                {
                    ShippingMethodId = "FlatRate",
                    Name             = "FlatRate",
                    DisplayName      = "Flat Rate",
                    Description      = "Flat Rate",
                    Currency         = "USD",
                    BasePrice        = 10,
                    IsActive         = true,
                    ShippingOption   = option2
                }
            };

            option.ShippingMethods.Add(shippingMethods[0]);
            option2.ShippingMethods.Add(shippingMethods[1]);

            var repository = new Mock <IShippingRepository>();

            repository.Setup(x => x.ShippingOptions).Returns(() => new[] { option, option2 }.AsQueryable());
            // initializing UnityContainer
            var initializedLocator = Locator;

            // mocking the IShippingRepository into UnityContainer as SimpleShippingGateway resolves it.
            _container.RegisterInstance(repository.Object);

            var activity = new ProcessShipmentActivity();
            var result   = InvokeActivity(activity, orderGroup);
            var order    = result.OrderGroup;

            foreach (var shipment in order.OrderForms[0].Shipments)
            {
                Assert.True(shipment.ShippingCost == 10m);
            }
        }
 /// <summary>
 /// Translates to shipping option.
 /// </summary>
 /// <param name="shippingOptionItem">The shipping option item.</param>
 /// <param name="shippingOption">The shipping option.</param>
 protected virtual void TranslateToShippingOption(Item shippingOptionItem, ShippingOption shippingOption)
 {
     shippingOption.ExternalId = shippingOptionItem.ID.Guid.ToString();
     shippingOption.Name = shippingOptionItem[CommerceServerStorefrontConstants.KnownFieldNames.Value];
     shippingOption.ShopName = this.GetShopName();
     shippingOption.ShippingOptionType = MainUtil.GetInt(shippingOptionItem[CommerceServerStorefrontConstants.KnownFieldNames.ShippingOptionValue], 0);
 }
        /// <summary>
        ///  Gets available shipping options
        /// </summary>
        /// <param name="shipmentPackage">Shipment package</param>
        /// <param name="error">Error</param>
        /// <returns>Shipping options</returns>
        public List <ShippingOption> GetShippingOptions(ShipmentPackage shipmentPackage, ref string error)
        {
            var shippingOptions = new List <ShippingOption>();

            if (shipmentPackage == null)
            {
                throw new ArgumentNullException("shipmentPackage");
            }
            if (shipmentPackage.Items == null)
            {
                throw new NopException("No shipment items");
            }
            if (shipmentPackage.ShippingAddress == null)
            {
                error = "Shipping address is not set";
                return(shippingOptions);
            }
            if (shipmentPackage.ShippingAddress.Country == null)
            {
                error = "Shipping country is not set";
                return(shippingOptions);
            }
            if (shipmentPackage.ShippingAddress.StateProvince == null)
            {
                error = "Shipping state is not set";
                return(shippingOptions);
            }

            try
            {
                var profile = new Profile();
                //use "CPC_DEMO_XML" merchant ID for testing
                profile.MerchantId = IoC.Resolve <ISettingManager>().GetSettingValue("ShippingRateComputationMethod.CanadaPost.CustomerID");

                var destination = new Destination();
                destination.City            = shipmentPackage.ShippingAddress.City;
                destination.StateOrProvince = shipmentPackage.ShippingAddress.StateProvince.Abbreviation;
                destination.Country         = shipmentPackage.ShippingAddress.Country.TwoLetterIsoCode;
                destination.PostalCode      = shipmentPackage.ShippingAddress.ZipPostalCode;

                var items = CreateItems(shipmentPackage);

                var lang = CanadaPostLanguageEnum.English;
                if (NopContext.Current.WorkingLanguage.LanguageCulture.ToLowerInvariant().StartsWith("fr"))
                {
                    lang = CanadaPostLanguageEnum.French;
                }

                var requestResult = GetShippingOptionsInternal(profile, destination, items, lang);
                if (requestResult.IsError)
                {
                    error = requestResult.StatusMessage;
                }
                else
                {
                    foreach (var dr in requestResult.AvailableRates)
                    {
                        var so = new ShippingOption();
                        so.Name = dr.Name;
                        if (!string.IsNullOrEmpty(dr.DeliveryDate))
                        {
                            so.Name += string.Format(" - {0}", dr.DeliveryDate);
                        }
                        so.Rate = dr.Amount;
                        shippingOptions.Add(so);
                    }
                }

                foreach (var shippingOption in shippingOptions)
                {
                    if (!shippingOption.Name.ToLower().StartsWith("canada post"))
                    {
                        shippingOption.Name = string.Format("Canada Post {0}", shippingOption.Name);
                    }
                }
            }
            catch (Exception e)
            {
                Debug.WriteLine(e.Message);
                error = e.Message;
            }

            return(shippingOptions);
        }
        private IEnumerable <ShippingOption> ParseResponse(string response, bool saturdayDelivery, ref string error)
        {
            var shippingOptions = new List <ShippingOption>();

            var carrierServicesOffered = _ontracSettings.CarrierServicesOffered;

            var serviceCode   = string.Empty;
            var monetaryValue = string.Empty;
            var doc           = new XmlDocument();

            doc.LoadXml(response);
            try
            {
                if (doc.SelectSingleNode("/OnTracRateResponse//Error").LastChild.Value.Length > 0)
                {
                    // return "";
                    //fail
                    error = "Ontrac Error returned: " + doc.SelectSingleNode("/OnTracRateResponse//Error").LastChild.Value;
                }
            }
            catch
            {
                //nothing wrong
            }

            try
            {
                if (doc.SelectSingleNode("/OnTracRateResponse//GlobalRate").LastChild.Value.Length > 0)
                {
                    monetaryValue = doc.SelectSingleNode("/OnTracRateResponse//GlobalRate").LastChild.Value;
                }
            }
            catch
            {
                //problem
                //  return "";
            }

            try
            {
                if (doc.SelectSingleNode("/OnTracRateResponse//Service").LastChild.Value.Length > 0)
                {
                    serviceCode = doc.SelectSingleNode("/OnTracRateResponse//Service").LastChild.Value;
                }
            }
            catch
            {
                //problem
                //  return "";
            }


            var service   = GetServiceName(serviceCode);
            var serviceId = $"[{serviceCode}]";

            // Go to the next rate if the service ID is not in the list of services to offer
            if (!saturdayDelivery && !string.IsNullOrEmpty(carrierServicesOffered) && !carrierServicesOffered.Contains(serviceId))
            {
            }
            else
            {
                //Weed out unwanted or unknown service rates
                if (service.ToUpper() != "UNKNOWN")
                {
                    var shippingOption = new ShippingOption
                    {
                        Rate = Convert.ToDecimal(monetaryValue, new CultureInfo("en-US")),
                        Name = service
                    };
                    shippingOptions.Add(shippingOption);
                }
            }

            return(shippingOptions);
        }