public override void HandleAuthorizationAmountNotification(
            string requestXml,
            AuthorizationAmountNotification notification)
        {
            GoogleCheckoutLog gLog = new GoogleCheckoutLog();
            gLog.ProviderName = "WebStoreGCheckoutNotificationHandlerProvider";
            gLog.NotificationType = "AuthorizationAmountNotification";
            gLog.RawResponse = requestXml;
            gLog.SerialNumber = notification.serialnumber;
            gLog.OrderNumber = notification.googleordernumber;
            gLog.GTimestamp = notification.timestamp;
            gLog.AuthAmt = notification.authorizationamount.Value;
            gLog.AuthExpDate = notification.authorizationexpirationdate;
            gLog.CvnResponse = notification.cvnresponse;
            gLog.AvsResponse = notification.avsresponse;

            gLog.Save();

            Guid orderGuid = GoogleCheckoutLog.GetCartGuidFromOrderNumber(notification.googleordernumber);

            if (orderGuid == Guid.Empty) return;

            Order order = new Order(orderGuid);
            if (order.OrderGuid != orderGuid) return;

            Store store = new Store(order.StoreGuid);
            if (store.Guid != order.StoreGuid) return;

            gLog.SiteGuid = store.SiteGuid;
            gLog.UserGuid = order.UserGuid;
            gLog.CartGuid = order.OrderGuid;
            gLog.StoreGuid = order.StoreGuid;
            gLog.Save();
        }
        public override bool HandleRequest(
            WorldPayPaymentResponse wpResponse,
            PayPalLog worldPayLog,
            Page page)
        {
            bool result = false;

            if (worldPayLog.SerializedObject.Length == 0) { return result; }

            Cart cart = (Cart)SerializationHelper.DeserializeFromString(typeof(Cart), worldPayLog.SerializedObject);

            Store store = new Store(cart.StoreGuid);
            //SiteSettings siteSettings = new SiteSettings(store.SiteGuid);
            config = SiteUtils.GetCommerceConfig();

            switch (wpResponse.TransStatus)
            {
                case "Y": //success
                    ProcessOrder(cart, store, wpResponse, worldPayLog, page);

                    result = true;
                    break;

                case "C": // cancelled
                default:
                    ProcessCancellation(cart, store, wpResponse, worldPayLog, page);
                    break;

            }

            return result;
        }
        private void ProcessCancellation(
            Cart cart,
            Store store,
            WorldPayPaymentResponse wpResponse,
            PayPalLog worldPayLog,
            Page page)
        {
            //string serializedResponse = SerializationHelper.SerializeToString(wpResponse);
            //log.Info("received cancellation worldpay postback, xml to follow");
            //log.Info(serializedResponse);

            // return an html order cancelled template for use at world pay
            if (config.WorldPayProduceShopperCancellationResponse)
            {
                string htmlTemplate = ResourceHelper.GetMessageTemplate(CultureInfo.CurrentUICulture, config.WorldPayShopperCancellationResponseTemplate);
                StringBuilder finalOutput = new StringBuilder();
                finalOutput.Append(htmlTemplate);
                finalOutput.Replace("#WorldPayBannerToken", "<WPDISPLAY ITEM=banner>"); //required by worldpay
                finalOutput.Replace("#CustomerName", wpResponse.Name);
                finalOutput.Replace("#StoreName", store.Name);

                string storePageUrl = worldPayLog.RawResponse;

                finalOutput.Replace("#StorePageLink", "<a href='" + storePageUrl + "'>" + storePageUrl + "</a>");

                page.Response.Write(finalOutput.ToString());
                page.Response.Flush();

            }
        }
Esempio n. 4
0
        public static bool ApplyDiscount(Store store, Cart cart, string discountCode, out string errorMessage)
        {
            if (cart == null)
            {
                errorMessage = WebStoreResources.DiscountInvalidCartError;
                return false;
            }

            if (store == null)
            {
                errorMessage = WebStoreResources.DiscountInvalidCartError;
                return false;
            }

            if (string.IsNullOrEmpty(discountCode))
            {
                errorMessage = WebStoreResources.DiscountCodeNotProvidedError;
                return false;
            }

            Discount discount = new Discount(store.ModuleGuid, discountCode);
            if (discount.DiscountGuid == Guid.Empty)
            {
                errorMessage = WebStoreResources.DiscountCodeNotFoundError;
                return false;
            }

            if (discount.ValidityEndDate < DateTime.UtcNow)
            {
                errorMessage = WebStoreResources.DiscountCodeExpiredError;
                return false;
            }

            if (discount.ValidityStartDate > DateTime.UtcNow)
            {
                errorMessage = WebStoreResources.DiscountCodeNotActiveError;
                return false;
            }

            if (!discount.AllowOtherDiscounts)
            {
                cart.DiscountCodesCsv = discount.DiscountCode;
            }

            if (cart.DiscountCodesCsv.Length == 0)
            {
                cart.DiscountCodesCsv = discount.DiscountCode;
            }
            else
            {
                if (!cart.DiscountCodesCsv.Contains(discount.DiscountCode))
                {
                    cart.DiscountCodesCsv += "," + discount.DiscountCode;
                }
            }

            return ValidateAndApplyDiscounts(store, cart, out errorMessage);
        }
        public override void ContentChangedHandler(
            object sender,
            ContentChangedEventArgs e)
        {
            if (WebConfigSettings.DisableSearchIndex) { return; }
            if (sender == null) return;
            if (!(sender is Product)) return;

            Product product = sender as Product;

            SiteSettings siteSettings = CacheHelper.GetCurrentSiteSettings();
            product.SiteId = siteSettings.SiteId;
            product.SearchIndexPath = mojoPortal.SearchIndex.IndexHelper.GetSearchIndexPath(siteSettings.SiteId);

            if (e.IsDeleted)
            {
                Store store = new Store(product.StoreGuid);
                // get list of pages where this module is published
                List<PageModule> pageModules
                    = PageModule.GetPageModulesByModule(store.ModuleId);

                foreach (PageModule pageModule in pageModules)
                {
                    mojoPortal.SearchIndex.IndexHelper.RemoveIndexItem(
                        pageModule.PageId,
                        store.ModuleId,
                        product.Guid.ToString());
                }
            }
            else
            {
                if (ThreadPool.QueueUserWorkItem(new WaitCallback(IndexItem), product))
                {
                    if (debugLog) log.Debug("ProductSearchIndexBuilder.IndexItem queued");
                }
                else
                {
                    log.Error("Failed to queue a thread for ProductSearchIndexBuilder.IndexItem");
                }

            }
        }
Esempio n. 6
0
        public static Store GetStore()
        {
            int pageId = WebUtils.ParseInt32FromQueryString("pageid", -1);
            int moduleId = WebUtils.ParseInt32FromQueryString("mid", -1);

            if (moduleId == -1)
            {
                PageSettings currentPage = CacheHelper.GetCurrentPage();
                if (currentPage != null)
                    moduleId = FindStoreModuleId(currentPage);

            }

            if (moduleId == -1) return null;
            if (pageId == -1) return null;

            string key = "WebStore" + moduleId.ToString(CultureInfo.InvariantCulture);

            if (HttpContext.Current.Items[key] != null)
            {
                return (Store)HttpContext.Current.Items[key];
            }

            SiteSettings siteSettings = CacheHelper.GetCurrentSiteSettings();

            if ((siteSettings == null) || (siteSettings.SiteGuid == Guid.Empty)) return null;

            Module module = new Module(moduleId, pageId);
            if (module.SiteId != siteSettings.SiteId) return null;

            if (module.FeatureGuid != new Guid("0cefbf18-56de-11dc-8f36-bac755d89593")) return null;

            Store store = new Store(siteSettings.SiteGuid, moduleId);
            if (store.Guid == Guid.Empty) // No store created yet
            {
                store = new Store();
                store.SiteGuid = siteSettings.SiteGuid;
                store.ModuleId = moduleId;
                store.Save();
            }

            HttpContext.Current.Items.Add(key, store);

            return store;
        }
Esempio n. 7
0
        public static bool ValidateAndApplyDiscounts(Store store, Cart cart, out string errorMessage)
        {
            if (cart == null)
            {
                errorMessage = WebStoreResources.DiscountInvalidCartError;
                return false;
            }

            if (store == null)
            {
                errorMessage = WebStoreResources.DiscountInvalidCartError;
                return false;
            }

            errorMessage = string.Empty;
            List<Discount> discountList = Discount.GetValidDiscounts(store.ModuleGuid, cart, cart.DiscountCodesCsv);
            cart.Discount = 0;
            cart.RefreshTotals();

            cart.DiscountCodesCsv = string.Empty;
            if (cart.SubTotal <= 0)
            {
                cart.Save();
                return false;
            }

            string comma = string.Empty;
            bool appliedDiscount = false;
            foreach (Discount d in discountList)
            {
                cart.DiscountCodesCsv += comma + d.DiscountCode;
                comma = ",";
                if (d.AbsoluteDiscount > 0)
                {
                    cart.Discount += d.AbsoluteDiscount;
                    appliedDiscount = true;
                }

                if (d.PercentageDiscount > 0)
                {
                    cart.Discount += (cart.SubTotal * d.PercentageDiscount);
                    appliedDiscount = true;
                }

            }

            cart.RefreshTotals();

            if (!appliedDiscount) { errorMessage = WebStoreResources.DiscountInvalidCartError; }

            return appliedDiscount;
        }
Esempio n. 8
0
        private void LoadSettings()
        {
            commerceConfig = SiteUtils.GetCommerceConfig();
            store = StoreHelper.GetStore();
            currencyCulture = ResourceHelper.GetCurrencyCulture(siteSettings.GetCurrency().Code);

            if((store != null)&&(offerGuid != Guid.Empty))
            {
                offer = new Offer(offerGuid);
                offerPrice = offer.Price;
            }

            teaserFileBaseUrl = WebUtils.GetSiteRoot() + "/Data/Sites/" + siteSettings.SiteId.ToInvariantString()
                + "/webstoreproductpreviewfiles/";

            AddClassToBody("webstore webstoreofferdetail");
        }
Esempio n. 9
0
        private static PayPalLog CreatePayPalStandardCheckoutLog(
            Cart cart,
            Store store,
            string siteRoot,
            int pageId,
            int moduleId)
        {
            PayPalLog payPalLog = new PayPalLog();

            payPalLog.ProviderName = "WebStorePayPalHandler";
            payPalLog.PDTProviderName = "WebStorePayPalPDTHandlerProvider";
            payPalLog.IPNProviderName = "WebStorePayPalIPNHandlerProvider";
            payPalLog.ReturnUrl = siteRoot +
                                "/WebStore/OrderDetail.aspx?pageid="
                                + pageId.ToInvariantString()
                                + "&mid=" + moduleId.ToInvariantString()
                                + "&orderid=" + cart.CartGuid.ToString();

            payPalLog.RequestType = "StandardCheckout";

            cart.SerializeCartOffers();
            payPalLog.SerializedObject = SerializationHelper.SerializeToString(cart);

            //Currency currency = new Currency(store.DefaultCurrencyId);

            payPalLog.CartGuid = cart.CartGuid;
            //Store store = new Store(cart.StoreGuid);
            payPalLog.SiteGuid = store.SiteGuid;
            payPalLog.StoreGuid = store.Guid;
            payPalLog.UserGuid = cart.UserGuid;
            payPalLog.CartTotal = cart.OrderTotal;
            //payPalLog.CurrencyCode = currency.Code;
            SiteSettings siteSettings = CacheHelper.GetCurrentSiteSettings();
            payPalLog.CurrencyCode = siteSettings.GetCurrency().Code;

            payPalLog.Save();

            return payPalLog;
        }
        private void LoadSettings()
        {
            pageId = WebUtils.ParseInt32FromQueryString("pageid", -1);
            moduleId = WebUtils.ParseInt32FromQueryString("mid", true, -1);

            currencyCulture = ResourceHelper.GetCurrencyCulture(siteSettings.GetCurrency().Code);

            store = StoreHelper.GetStore();
            if (store == null) { return; }

            siteUser = SiteUtils.GetCurrentSiteUser();

            productGuid = WebUtils.ParseGuidFromQueryString("prod", productGuid);

            virtualRoot = WebUtils.GetApplicationRoot();

            upLoadPath = "~/Data/Sites/" + siteSettings.SiteId.ToInvariantString()
                + "/webstoreproductfiles/";

            teaserFileBasePath = "~/Data/Sites/" + siteSettings.SiteId.ToInvariantString()
                + "/webstoreproductpreviewfiles/";

            AddClassToBody("webstore webstoreproductedit");

            FileSystemProvider p = FileSystemManager.Providers[WebConfigSettings.FileSystemProvider];
            if (p == null)
            {
                log.Error("Could not load file system provider " + WebConfigSettings.FileSystemProvider);
                return;
            }

            fileSystem = p.GetFileSystem();
            if (fileSystem == null)
            {
                log.Error("Could not load file system from provider " + WebConfigSettings.FileSystemProvider);
                return;
            }

            if (!fileSystem.FolderExists(upLoadPath))
            {
                fileSystem.CreateFolder(upLoadPath);
            }

            if (!fileSystem.FolderExists(teaserFileBasePath))
            {
                fileSystem.CreateFolder(teaserFileBasePath);
            }

            if (productGuid == Guid.Empty) { return; }

            productUploader.ServiceUrl = SiteRoot + "/WebStore/upload.ashx?pageid=" + pageId.ToInvariantString()
                + "&mid=" + moduleId.ToInvariantString()
                + "&prod=" + productGuid.ToString() ;

            productUploader.UploadButtonClientId = btnUpload.ClientID;

            productUploader.FormFieldClientId = hdnState.ClientID; // not really used but prevents submitting all the form

            string refreshFunction = "function refresh" + moduleId.ToInvariantString()
                    + " (data, errorsOccurred) { if(errorsOccurred === false) { $('#" + btnSave.ClientID + "').click(); } } ";

            productUploader.UploadCompleteCallback = "refresh" + moduleId.ToInvariantString();

            ScriptManager.RegisterClientScriptBlock(
                this,
                this.GetType(), "refresh" + moduleId.ToInvariantString(),
                refreshFunction,
                true);

            teaserUploader.ServiceUrl = SiteRoot + "/WebStore/upload.ashx?type=teaser&pageid=" + pageId.ToInvariantString()
                + "&mid=" + moduleId.ToInvariantString()
                + "&prod=" + productGuid.ToString();

            teaserUploader.UploadButtonClientId = btnUploadTeaser.ClientID;
            teaserUploader.FormFieldClientId = hdnState.ClientID; // not really used but prevents submitting all the form
            teaserUploader.UploadCompleteCallback = "refresh" + moduleId.ToInvariantString();
        }
        public override void HandleOrderStateChangeNotification(
            string requestXml,
            OrderStateChangeNotification notification)
        {
            GoogleCheckoutLog gLog = new GoogleCheckoutLog();

            Guid orderGuid = GoogleCheckoutLog.GetCartGuidFromOrderNumber(notification.googleordernumber);

            gLog.RawResponse = requestXml;
            gLog.NotificationType = "OrderStateChangeNotification";
            gLog.ProviderName = "WebStoreGCheckoutNotificationHandlerProvider";
            gLog.SerialNumber = notification.serialnumber;
            gLog.OrderNumber = notification.googleordernumber;
            gLog.FinanceState = notification.newfinancialorderstate.ToString();
            gLog.FullfillState = notification.newfulfillmentorderstate.ToString();
            gLog.GTimestamp = notification.timestamp;
            gLog.AvsResponse = notification.reason;
            gLog.CartGuid = orderGuid;
            gLog.Save();

            if (orderGuid == Guid.Empty) return;

            Order order = new Order(orderGuid);
            if (order.OrderGuid != orderGuid) return;

            Store store = new Store(order.StoreGuid);
            if (store.Guid != order.StoreGuid) return;

            gLog.SiteGuid = store.SiteGuid;
            gLog.UserGuid = order.UserGuid;
            gLog.CartGuid = order.OrderGuid;
            gLog.StoreGuid = order.StoreGuid;
            gLog.Save();

            if (notification.newfinancialorderstate == FinancialOrderState.CHARGED)
            {
                order.StatusGuid = OrderStatus.OrderStatusFulfillableGuid;
                order.Save();

                if (!order.HasShippingProducts())
                {
                    // order only has download products so tell google the order is fulfilled

                    try
                    {
                        CommerceConfiguration commerceConfig = SiteUtils.GetCommerceConfig();

                        string gEvironment;
                        if (commerceConfig.GoogleEnvironment == GCheckout.EnvironmentType.Sandbox)
                        {
                            gEvironment = "Sandbox";
                        }
                        else
                        {
                            gEvironment = "Production";
                        }

                        GCheckout.OrderProcessing.DeliverOrderRequest fulfillNotification
                            = new GCheckout.OrderProcessing.DeliverOrderRequest(
                                commerceConfig.GoogleMerchantID,
                                commerceConfig.GoogleMerchantKey,
                                gEvironment,
                                notification.googleordernumber);

                        fulfillNotification.Send();

                        StoreHelper.ConfirmOrder(store, order);
                        PayPalLog.DeleteByCart(order.OrderGuid);

                        log.Info("Sent DeliverOrderRequest to google api for google order " + notification.googleordernumber);
                    }
                    catch (Exception ex)
                    {
                        log.Error(ex);
                    }
                }

            }
        }
Esempio n. 12
0
 public static void EnsureValidDiscounts(Store store, Cart cart)
 {
     string errorMessage = string.Empty;
     ValidateAndApplyDiscounts(store, cart, out errorMessage);
 }
        private void LoadSettings()
        {
            PageId = WebUtils.ParseInt32FromQueryString("pageid", -1);
            ModuleId = WebUtils.ParseInt32FromQueryString("mid", -1);
            payPalGetExpressCheckoutLogGuid = WebUtils.ParseGuidFromQueryString("plog", payPalGetExpressCheckoutLogGuid);

            if (payPalGetExpressCheckoutLogGuid == Guid.Empty)
            {
                Response.Redirect(SiteUtils.GetCurrentPageUrl());
            }

            checkoutDetailsLog = new PayPalLog(payPalGetExpressCheckoutLogGuid);

            if (checkoutDetailsLog.RowGuid == Guid.Empty)
            {
                Response.Redirect(SiteUtils.GetCurrentPageUrl());
            }

            cart = (Cart)SerializationHelper.DeserializeFromString(typeof(Cart), checkoutDetailsLog.SerializedObject);

            if (cart == null)
            {
                Response.Redirect(SiteUtils.GetCurrentPageUrl());
            }
            cart.DeSerializeCartOffers();

            cart.RefreshTotals();

            if ((cart.LastModified < DateTime.UtcNow.AddDays(-1)) && (cart.DiscountCodesCsv.Length > 0))
            {
                StoreHelper.EnsureValidDiscounts(store, cart);
            }

            siteUser = SiteUtils.GetCurrentSiteUser();
            //if (siteUser == null)
            //{
            //    Response.Redirect(SiteUtils.GetCurrentPageUrl());
            //}

            if ((siteUser != null)&&(cart.UserGuid == Guid.Empty))
            {
                // user wasn't logged in when express checkout was called
                cart.UserGuid = siteUser.UserGuid;
                cart.Save();
                //if (checkoutDetailsLog.UserGuid == Guid.Empty)
                //{
                //    // we need to make sure we have the user in the log and serialized cart
                //    checkoutDetailsLog.UserGuid = siteUser.UserGuid;
                //    cart.SerializeCartOffers();
                //    checkoutDetailsLog.SerializedObject = SerializationHelper.SerializeToSoap(cart);
                //    checkoutDetailsLog.Save();

                //}
            }

            if ((siteUser != null)&&(cart.UserGuid != siteUser.UserGuid))
            {
                Response.Redirect(SiteUtils.GetCurrentPageUrl());
            }

            if (ModuleId == -1)
            {
                ModuleId = StoreHelper.FindStoreModuleId(CurrentPage);
            }

            store = StoreHelper.GetStore();

            commerceConfig = SiteUtils.GetCommerceConfig();
            currencyCulture = ResourceHelper.GetCurrencyCulture(siteSettings.GetCurrency().Code);

            if (siteUser != null)
            {
                pnlRequireLogin.Visible = false;
            }
            else
            {
                btnMakePayment.Visible = false;
            }

            AddClassToBody("webstore webstoreexpresscheckout");
        }
Esempio n. 14
0
 /// <summary>
 /// This method sends confirmation that the order was received and is being processed by the payment processor, ie PayPal or Google Checkout, but payment has not yet cleared
 /// </summary>
 /// <param name="store"></param>
 /// <param name="order"></param>
 public static void ConfirmOrderReceived(Store store, Order order)
 {
     ConfirmOrderReceived(store, order, false);
 }
Esempio n. 15
0
        public static void ConfirmOrderReceived(Store store, Order order, bool isEcheck)
        {
            CommerceConfiguration commerceConfig = SiteUtils.GetCommerceConfig();
            CultureInfo defaultCulture = SiteUtils.GetDefaultUICulture();
            SiteSettings siteSettings = CacheHelper.GetCurrentSiteSettings();
            CultureInfo currencyCulture = ResourceHelper.GetCurrencyCulture(siteSettings.GetCurrency().Code);

            string subjectTemplate
                        = ResourceHelper.GetMessageTemplate(defaultCulture,
                        commerceConfig.DefaultOrderReceivedEmailSubjectTemplate);

            string textBodyTemplate;

            if (isEcheck)
            {
                textBodyTemplate
                        = ResourceHelper.GetMessageTemplate(defaultCulture,
                        commerceConfig.DefaultEcheckOrderReceivedEmailTextBodyTemplate);
            }
            else
            {
                textBodyTemplate
                        = ResourceHelper.GetMessageTemplate(defaultCulture,
                        commerceConfig.DefaultOrderReceivedEmailTextBodyTemplate);
            }

            int pageId = -1;

            List<PageModule> pageModules = PageModule.GetPageModulesByModule(store.ModuleId);
            foreach (PageModule pm in pageModules)
            {
                // use first pageid found, really a store should only
                // be on one page
                pageId = pm.PageId;
                break;

            }

            SendConfirmEmail(
                defaultCulture,
                currencyCulture,
                siteSettings,
                pageId,
                commerceConfig,
                store,
                order,
                subjectTemplate,
                textBodyTemplate);
        }
Esempio n. 16
0
        public static void ConfirmOrder(Store store, Order order)
        {
            if (store == null) { return; }
            if (order == null) { return; }

            CommerceConfiguration commerceConfig = SiteUtils.GetCommerceConfig();
            CultureInfo defaultCulture = SiteUtils.GetDefaultUICulture();

            string subjectTemplate
                        = ResourceHelper.GetMessageTemplate(defaultCulture,
                        commerceConfig.DefaultConfirmationEmailSubjectTemplate);

            string textBodyTemplate
                        = ResourceHelper.GetMessageTemplate(defaultCulture,
                        commerceConfig.DefaultConfirmationEmailTextBodyTemplate);

            int pageId = -1;

            List<PageModule> pageModules = PageModule.GetPageModulesByModule(store.ModuleId);
            foreach (PageModule pm in pageModules)
            {
                // use first pageid found, really a store should only
                // be on one page
                pageId = pm.PageId;
                break;

            }

            Module m = new Module(store.ModuleId);

            Order.EnsureSalesReportData(order.OrderGuid, m.ModuleGuid, pageId, store.ModuleId);

            SiteUser.UpdateTotalRevenue(order.UserGuid);

            SiteSettings siteSettings = CacheHelper.GetCurrentSiteSettings();
            CultureInfo currencyCulture = ResourceHelper.GetCurrencyCulture(siteSettings.GetCurrency().Code);
            OrderCompletedEventArgs e = new OrderCompletedEventArgs(order, currencyCulture);

            foreach (OrderCompletedHandlerProvider p in OrderCompletedHandlerProviderManager.Providers)
            {

                try
                {
                    p.HandelOrderCompleted(e);
                }
                catch (Exception ex)
                {
                    log.Error(ex);
                }
            }

            //TODO: make this asynchronous so if it takes a long time or has a timeout error it does
            //not prevent the redirect
            SendConfirmEmail(
                defaultCulture,
                currencyCulture,
                siteSettings,
                pageId,
                commerceConfig,
                store,
                order,
                subjectTemplate,
                textBodyTemplate);
        }
Esempio n. 17
0
        private static void SendConfirmEmail(
            CultureInfo defaultCulture,
            CultureInfo currencyCulture,
            SiteSettings siteSettings,
            int pageId,
            CommerceConfiguration commerceConfig, 
            Store store, 
            Order order,
            string subjectTemplate,
            string textBodyTemplate)
        {
            if (store == null) { return; }
            if (order == null) { return; }
            if(siteSettings == null) { return; }

            if (!ShouldSendConfirmation(siteSettings.SiteId, order))
            {
                log.Info("confirmation email for order " + order.OrderGuid.ToString() + " not sent due to disabled by configuration");
                return;
            }

            //SiteSettings siteSettings = CacheHelper.GetCurrentSiteSettings();
            //CultureInfo currencyCulture = ResourceHelper.GetCurrencyCulture(siteSettings.GetCurrency().Code);

            //EmailMessageTask messageTask = new EmailMessageTask(SiteUtils.GetSmtpSettings());
            //messageTask.EmailFrom = store.SalesEmail;
            // TODO: implement from alias for store
            //messageTask.EmailFromAlias = siteSettings.DefaultFromEmailAlias;
            string email;
            if (order.CustomerEmail.Length > 0)
            {
                //messageTask.EmailTo = order.CustomerEmail;
                email = order.CustomerEmail;
            }
            else
            {
                SiteUser siteUser = new SiteUser(siteSettings, order.UserGuid);
                //messageTask.EmailTo = siteUser.Email;

                email = siteUser.Email;

            }

            //if (store.OrderBccEmail.Length > 0)
            //{
            //    messageTask.EmailBcc = store.OrderBccEmail;
            //}

            PageSettings page = new PageSettings(siteSettings.SiteId, pageId);

            string siteRoot = SiteUtils.GetNavigationSiteRoot();
            string storeLink = string.Empty;

            if (page.Url.StartsWith("~/"))
            {
                storeLink = siteRoot + page.Url.Replace("~/", "/");
            }
            else
            {
                storeLink = siteRoot;
            }

            string orderLink = siteRoot +
                "/WebStore/OrderDetail.aspx?pageid="
                + pageId.ToInvariantString()
                + "&mid=" + store.ModuleId.ToInvariantString()
                + "&orderid=" + order.OrderGuid.ToString();

            StringBuilder orderDetails = new StringBuilder();
            DataSet dsOffers = Order.GetOrderOffersAndProducts(store.Guid, order.OrderGuid);

            foreach (DataRow row in dsOffers.Tables["Offers"].Rows)
            {
                string og = row["OfferGuid"].ToString();
                orderDetails.Append(row["Name"].ToString() + " ");
                orderDetails.Append(row["Quantity"].ToString() + " @ ");
                orderDetails.Append(string.Format(currencyCulture, "{0:c}", Convert.ToDecimal(row["OfferPrice"])));
                orderDetails.Append("\r\n");

                string whereClause = string.Format("OfferGuid = '{0}'", og);
                DataView dv = new DataView(dsOffers.Tables["Products"], whereClause, "", DataViewRowState.CurrentRows);

                if (dv.Count > 1)
                {
                    foreach (DataRow r in dsOffers.Tables["Products"].Rows)
                    {
                        string pog = r["OfferGuid"].ToString();
                        if (og == pog)
                        {
                            orderDetails.Append(r["Name"].ToString() + " ");
                            orderDetails.Append(r["Quantity"].ToString() + "  \r\n");

                        }

                    }
                }

            }

            //messageTask.Subject = string.Format(
            //    defaultCulture,
            //    subjectTemplate,
            //    store.Name,
            //    order.OrderGuid.ToString()
            //    );

            //messageTask.TextBody = string.Format(
            //    defaultCulture,
            //    textBodyTemplate,
            //    order.CustomerFirstName + " " + order.CustomerLastName,
            //    store.Name,
            //    order.OrderGuid.ToString(),
            //    storeLink,
            //    orderLink,
            //    orderDetails.ToString(),
            //    order.OrderTotal.ToString("c", currencyCulture),
            //    order.ShippingTotal.ToString("c", currencyCulture),
            //    order.TaxTotal.ToString("c", currencyCulture),
            //    order.SubTotal.ToString("c", currencyCulture),
            //    order.Discount.ToString("c", currencyCulture)
            //    ).ToAscii();

            //messageTask.SiteGuid = siteSettings.SiteGuid;
            //messageTask.QueueTask();

            //WebTaskManager.StartOrResumeTasks();

            string fromAddress = store.EmailFrom;
            if (fromAddress.Length == 0) { fromAddress = siteSettings.DefaultEmailFromAddress; }

            Email.Send(
                        SiteUtils.GetSmtpSettings(),
                        fromAddress,
                        string.Empty,
                        string.Empty,
                        email,
                        string.Empty,
                        store.OrderBccEmail,
                        string.Format(defaultCulture, subjectTemplate, store.Name, order.OrderGuid.ToString()),
                        string.Format(
                                defaultCulture,
                                textBodyTemplate,
                                order.CustomerFirstName + " " + order.CustomerLastName,
                                store.Name,
                                order.OrderGuid.ToString(),
                                storeLink,
                                orderLink,
                                orderDetails.ToString(),
                                order.OrderTotal.ToString("c", currencyCulture),
                                order.ShippingTotal.ToString("c", currencyCulture),
                                order.TaxTotal.ToString("c", currencyCulture),
                                order.SubTotal.ToString("c", currencyCulture),
                                order.Discount.ToString("c", currencyCulture)
                                ),
                        false,
                        Email.PriorityNormal);
        }
Esempio n. 18
0
        // we are using the paypal log with a different request type rather than making a new log specifically for WorldPay
        private static PayPalLog CreateWorldPayCheckoutLog(
            Cart cart,
            Store store,
            string siteRoot,
            string storePageUrl,
            int pageId,
            int moduleId)
        {
            PayPalLog worldPayLog = new PayPalLog();

            worldPayLog.ProviderName = "WebStoreWorldPayResponseHandler";
            worldPayLog.RequestType = "WorldPay";
            worldPayLog.RawResponse = storePageUrl;

            worldPayLog.ReturnUrl = siteRoot +
                                "/WebStore/OrderDetail.aspx?pageid="
                                + pageId.ToInvariantString()
                                + "&mid=" + moduleId.ToInvariantString()
                                + "&orderid=" + cart.CartGuid.ToString();

            cart.SerializeCartOffers();
            worldPayLog.SerializedObject = SerializationHelper.SerializeToString(cart);

            worldPayLog.CartGuid = cart.CartGuid;

            worldPayLog.SiteGuid = store.SiteGuid;
            worldPayLog.StoreGuid = store.Guid;
            worldPayLog.UserGuid = cart.UserGuid;
            worldPayLog.CartTotal = cart.OrderTotal;

            SiteSettings siteSettings = CacheHelper.GetCurrentSiteSettings();
            worldPayLog.CurrencyCode = siteSettings.GetCurrency().Code;

            worldPayLog.Save();

            return worldPayLog;
        }
Esempio n. 19
0
        private static Cart CreateCartAndSetCookie(Store store)
        {
            if (store == null) return null;
            if (store.Guid == Guid.Empty) return null;

            string cartKey = "cart" + store.Guid.ToString();
            Cart cart = new Cart();
            cart.StoreGuid = store.Guid;
            cart.CreatedFromIP = SiteUtils.GetIP4Address();

            if (
                (HttpContext.Current != null)
                && (HttpContext.Current.Request.IsAuthenticated)
                )
            {
                SiteUser siteUser = SiteUtils.GetCurrentSiteUser();
                cart.UserGuid = siteUser.UserGuid;
                cart.LoadExistingUserCartIfExists();

            }
            cart.Save();

            SetCartCookie(store.Guid, cart.CartGuid);
            HttpContext.Current.Items[cartKey] = cart;

            return cart;
        }
Esempio n. 20
0
        /// <summary>
        /// we are using the paypal log with a different request type rather than making a new log specifically for WorldPay
        /// 
        /// The goal here is to make sure we always have a PayPalLog with current cart serialized.
        /// We need to do this because we could transfer the user to WorldPay, then they add more items to the cart,
        /// then complete the checkout at WorldPay for the previous version of the cart.
        /// If we were to just use the current cart from the db we might give them more or less than they actually
        /// bought. By keeping a copy of the cart as it was at time of transfer, we can be sure
        /// we only give them the products they had at checkout time.
        /// </summary>
        public static PayPalLog EnsureWorldPayCheckoutLog(
            Cart cart,
            Store store,
            string siteRoot,
            string storePageUrl,
            int pageId,
            int moduleId)
        {
            if (cart == null) return null;
            if (store == null) return null;

            PayPalLog worldPayLog = PayPalLog.GetMostRecent(cart.CartGuid, "WorldPay");
            if ((worldPayLog == null) || (worldPayLog.SerializedObject.Length == 0))
            {
                return CreateWorldPayCheckoutLog(cart, store, siteRoot, storePageUrl, pageId, moduleId);
            }

            Cart worldPayCart = (Cart)SerializationHelper.DeserializeFromString(typeof(Cart), worldPayLog.SerializedObject);

            if (worldPayCart.LastModified < cart.LastModified)
            {
                // cart has been modified since we last serialized it so create a new one
                return CreateWorldPayCheckoutLog(cart, store, siteRoot, storePageUrl, pageId, moduleId);
            }

            return worldPayLog;
        }
Esempio n. 21
0
        private static Cart CreateClerkCartAndSetCookie(Store store, string cartKey)
        {
            if (store == null) return null;
            if (store.Guid == Guid.Empty) return null;

            Cart cart = new Cart();
            cart.StoreGuid = store.Guid;
            cart.CreatedFromIP = SiteUtils.GetIP4Address();

            if (
                (HttpContext.Current != null)
                && (HttpContext.Current.Request.IsAuthenticated)
                )
            {
                SiteUser siteUser = SiteUtils.GetCurrentSiteUser();
                cart.ClerkGuid = siteUser.UserGuid;

            }
            cart.Save();

            CookieHelper.SetPersistentCookie(cartKey, cart.CartGuid.ToString());

            HttpContext.Current.Items[cartKey] = cart;

            return cart;
        }
Esempio n. 22
0
        /// <summary>
        /// Creates the URL for PayPal Standard BuyNow button
        /// </summary>
        /// <returns></returns>
        public static string GetBuyNowUrl(
            Guid payPalLogGuid,
            Cart cart, 
            Store store,
            CommerceConfiguration commerceConfig)
        {
            //PayPalStandardPaymentGateway gateway = new PayPalStandardPaymentGateway();
            //gateway.PayPalStandardUrl = commerceConfig.PayPalStandardUrl;
            //gateway.BusinessEmail = commerceConfig.PayPalStandardEmailAddress;
            //gateway.PDTId = commerceConfig.PayPalStandardPDTId;

            PayPalStandardPaymentGateway gateway
                = new PayPalStandardPaymentGateway(
                    commerceConfig.PayPalStandardUrl,
                    commerceConfig.PayPalStandardEmailAddress,
                    commerceConfig.PayPalStandardPDTId);

            gateway.Amount = cart.OrderTotal;
            gateway.Tax = cart.TaxTotal;
            gateway.Shipping = cart.ShippingTotal;

            //Currency currency = new Currency(cart.CurrencyGuid);
            //gateway.CurrencyCode = store.DefaultCurrency;

            SiteSettings siteSettings = CacheHelper.GetCurrentSiteSettings();
            gateway.CurrencyCode = siteSettings.GetCurrency().Code;

            gateway.OrderHasShippableProducts = cart.HasShippingProducts();

            // TODO: guess we need to split this into first and last
            gateway.ShippingFirstName =  cart.OrderInfo.DeliveryFirstName;
            gateway.ShippingLastName = cart.OrderInfo.DeliveryLastName;

            gateway.ShippingAddress1 = cart.OrderInfo.DeliveryAddress1;
            gateway.ShippingAddress2 = cart.OrderInfo.DeliveryAddress2;
            gateway.ShippingCity = cart.OrderInfo.DeliveryCity;
            gateway.ShippingState = cart.OrderInfo.DeliveryState;
            gateway.ShippingPostalCode = cart.OrderInfo.DeliveryPostalCode;

            //add the items
            //foreach (CartOffer offer in cart.CartOffers)
            //{
            //    PayPalOrderItem item = new PayPalOrderItem();
            //    item.Amount = offer.OfferPrice;
            //    item.ItemName = offer.Name;
            //    item.ItemNumber = offer.OfferGuid.ToString();
            //    item.Quantity = offer.Quantity;

            //    gateway.Items.Add(item);

            //}

            gateway.OrderDescription = store.Name + " " + WebStoreResources.OrderHeading;

            gateway.Custom = payPalLogGuid.ToString();

            string siteRoot = SiteUtils.GetNavigationSiteRoot();
            string storePageUrl = SiteUtils.GetCurrentPageUrl();

            gateway.ReturnUrl = siteRoot + "/Services/PayPalPDTHandler.aspx";
            gateway.NotificationUrl = siteRoot + "/Services/PayPalIPNHandler.aspx";
            gateway.CancelUrl = storePageUrl;

            return gateway.GetBuyNowButtonUrl();
        }
Esempio n. 23
0
        private void LoadSettings()
        {
            store = StoreHelper.GetStore();
            if (store == null) { return; }

            commerceConfig = SiteUtils.GetCommerceConfig();
            currencyCulture = ResourceHelper.GetCurrencyCulture(siteSettings.GetCurrency().Code);

            if (Request.IsAuthenticated)
            {
                siteUser = SiteUtils.GetCurrentSiteUser();
            }

            if (StoreHelper.UserHasCartCookie(store.Guid))
            {
                cart = StoreHelper.GetCart();
                if (cart != null)
                {
                    cartOffers = cart.GetOffers();

                    canCheckoutWithoutAuthentication = store.CanCheckoutWithoutAuthentication(cart);

                    if ((cart.LastModified < DateTime.UtcNow.AddDays(-1)) && (cart.DiscountCodesCsv.Length > 0))
                    {
                        StoreHelper.EnsureValidDiscounts(store, cart);
                    }

                    if ((cart.UserGuid == Guid.Empty)&&(siteUser != null))
                    {
                        cart.UserGuid = siteUser.UserGuid;
                        cart.Save();
                    }
                    cart.RefreshTotals();
                }
            }

            ConfigureCheckoutButtons();

            AddClassToBody("webstore webstorecheckout");
        }
        public override string HandleRequestAndReturnUrlForRedirect(
            HttpContext context,
            string payPalToken,
            string payPalPayerId,
            PayPalLog setExpressCheckoutLog)
        {
            string redirectUrl = string.Empty;

            if ((payPalToken == null) || (payPalToken.Length == 0))
            {
                log.Error("WebStorePayPalReturnHandler received empty payPalToken");
                return redirectUrl;

            }

            if (setExpressCheckoutLog == null)
            {
                log.Error("WebStorePayPalReturnHandler received null setExpressCheckoutLog for payPalToken " + payPalToken);
                return redirectUrl;

            }

            if (setExpressCheckoutLog.SerializedObject.Length == 0)
            {
                log.Error("WebStorePayPalReturnHandler cart was not previously serialized for payPalToken " + payPalToken);
                return redirectUrl;

            }

            if (setExpressCheckoutLog.CreatedUtc.AddHours(4) < DateTime.UtcNow)
            {
                log.Error("payPalToken " + payPalToken + " was more than 4 hours old, it should expire after 3 hours ");
                return redirectUrl;

            }

            CommerceConfiguration commerceConfig = SiteUtils.GetCommerceConfig();

            PayPalExpressGateway gateway
                = new PayPalExpressGateway(
                    commerceConfig.PayPalAPIUsername,
                    commerceConfig.PayPalAPIPassword,
                    commerceConfig.PayPalAPISignature,
                    commerceConfig.PayPalStandardEmailAddress);

            gateway.UseTestMode = commerceConfig.PaymentGatewayUseTestMode;
            gateway.PayPalToken = payPalToken;
            gateway.PayPalPayerId = payPalPayerId;

            Cart savedCart = (Cart)SerializationHelper.DeserializeFromString(typeof(Cart), setExpressCheckoutLog.SerializedObject);
            savedCart.DeSerializeCartOffers();

            string siteRoot = SiteUtils.GetNavigationSiteRoot();

            gateway.MerchantCartId = savedCart.CartGuid.ToString();
            gateway.ChargeTotal = savedCart.OrderTotal;
            gateway.ReturnUrl = siteRoot + "/Services/PayPalReturnHandler.ashx";
            gateway.CancelUrl = siteRoot;
            //gateway.PayPalPayerId = payPalPayerId;

            gateway.CallGetExpressCheckoutDetails();

            PayPalLog payPalLog = new PayPalLog();
            payPalLog.ProviderName = WebStorePayPalReturnHandler.ProviderName;
            payPalLog.SerializedObject = setExpressCheckoutLog.SerializedObject;
            payPalLog.ReturnUrl = setExpressCheckoutLog.ReturnUrl;
            payPalLog.RawResponse = gateway.RawResponse;
            payPalLog.TransactionId = gateway.TransactionId;
            payPalLog.CurrencyCode = gateway.CurrencyCode;
            // TODO: add versions to gateways
            //log.ApiVersion = gateway.
            payPalLog.CartGuid = savedCart.CartGuid;

            Store store = new Store(savedCart.StoreGuid);
            payPalLog.Token = payPalToken;
            payPalLog.PayerId = payPalPayerId;
            payPalLog.RequestType = "GetExpressCheckoutDetails";
            payPalLog.SiteGuid = store.SiteGuid;
            payPalLog.StoreGuid = store.Guid;
            payPalLog.UserGuid = savedCart.UserGuid;

            // update the order with customer shipping info
            savedCart.OrderInfo.DeliveryCompany = gateway.ShipToCompanyName;
            savedCart.OrderInfo.DeliveryAddress1 = gateway.ShipToAddress;
            savedCart.OrderInfo.DeliveryAddress2 = gateway.ShipToAddress2;
            savedCart.OrderInfo.DeliveryCity = gateway.ShipToCity;
            savedCart.OrderInfo.DeliveryFirstName = gateway.ShipToFirstName;
            savedCart.OrderInfo.DeliveryLastName = gateway.ShipToLastName;
            savedCart.OrderInfo.DeliveryPostalCode = gateway.ShipToPostalCode;
            savedCart.OrderInfo.DeliveryState = gateway.ShipToState;
            savedCart.OrderInfo.DeliveryCountry = gateway.ShipToCountry;

            //Note that PayPal only returns a phone number if your Merchant accounts is configured to require the
            // buyer to provide it.
            if (gateway.ShipToPhone.Length > 0)
            {
                savedCart.OrderInfo.CustomerTelephoneDay = gateway.ShipToPhone;
            }

            if (gateway.BuyerEmail.Length > 0)
            {
                savedCart.OrderInfo.CustomerEmail = gateway.BuyerEmail;
            }

            // if customer and billing aren't populated already, user was anonymous when checkout began, make them the same as shipping
            //if (savedCart.UserGuid == Guid.Empty)
            //{
            //2013-12-23 since all we get is shipping address this can be considered as the same thing as billing address for paypal purposes so always use it
            // especially because we may need to calculate tax for express checkout
            // based on the address provided by paypal
                savedCart.CopyShippingToBilling();
                savedCart.CopyShippingToCustomer();
            //}

            GeoCountry country = new GeoCountry(savedCart.OrderInfo.DeliveryCountry);
            GeoZone taxZone = GeoZone.GetByCode(country.Guid, savedCart.OrderInfo.DeliveryState);
            savedCart.OrderInfo.TaxZoneGuid = taxZone.Guid;

            savedCart.OrderInfo.Save();

            // refresh totals to calculate tax or shipping now that we have an address
            savedCart.RefreshTotals();
            savedCart.Save();

            savedCart.SerializeCartOffers();
            payPalLog.SerializedObject = SerializationHelper.SerializeToString(savedCart);

            payPalLog.Save();

            if (gateway.Response == PaymentGatewayResponse.Error)
            {
                redirectUrl = siteRoot + "/WebStore/PayPalGatewayError.aspx?plog=" + payPalLog.RowGuid.ToString();
                return redirectUrl;
            }

            if (gateway.PayPalPayerId.Length == 0)
            {
                redirectUrl = siteRoot + "/WebStore/PayPalGatewayError.aspx?plog=" + payPalLog.RowGuid.ToString();
                return redirectUrl;
            }

            int pageId = -1;

            List<PageModule> pageModules = PageModule.GetPageModulesByModule(store.ModuleId);
            foreach (PageModule pm in pageModules)
            {
                // use first pageid found, really a store should only
                // be on one page
                pageId = pm.PageId;
                break;

            }

            // after the CallGetExpressCheckoutDetails
            // we have the option of directing to a final review page before
            // calling CallDoExpressCheckoutPayment

            redirectUrl = siteRoot +
                "/WebStore/PayPalExpressCheckout.aspx?pageid="
                + pageId.ToString(CultureInfo.InvariantCulture)
                + "&mid=" + store.ModuleId.ToString(CultureInfo.InvariantCulture)
                + "&plog=" + payPalLog.RowGuid.ToString();

            return redirectUrl;
        }
        public override void HandleNewOrderNotificationExtended(
            string requestXml,
            NewOrderNotificationExtended newOrder, 
            MerchantData merchantData)
        {
            //NotificationSerialNumber = newOrder.serialnumber;

            GoogleCheckoutLog gLog = new GoogleCheckoutLog();
            gLog.ProviderName = "WebStoreGCheckoutNotificationHandlerProvider";
            gLog.RawResponse = requestXml;
            gLog.NotificationType = "NewOrderNotification";
            gLog.SerialNumber = newOrder.serialnumber;
            gLog.OrderNumber = newOrder.googleordernumber;
            gLog.OrderTotal = newOrder.ordertotal.Value;
            gLog.BuyerId = newOrder.buyerid.ToString(CultureInfo.InvariantCulture);
            gLog.FullfillState = newOrder.fulfillmentorderstate.ToString();
            gLog.FinanceState = newOrder.financialorderstate.ToString();
            gLog.ShippingTotal = newOrder.ShippingCost;
            gLog.TaxTotal = newOrder.orderadjustment.totaltax.Value;
            //gLog.DiscountTotal = ext.orderadjustment.adjustmenttotal.Value;
            gLog.EmailListOptIn = newOrder.buyermarketingpreferences.emailallowed;
            gLog.GTimestamp = newOrder.timestamp;
            gLog.CartXml = SerializationHelper.RestoreXmlDeclaration(merchantData.SerializedObject);
            gLog.Save();

            Cart gCart = DeserializeCart(merchantData);

            Guid cartGuid = Guid.Empty;
            if (gCart != null)
                cartGuid = gCart.CartGuid;

            if (cartGuid == Guid.Empty) return;

            Cart cart = new Cart(cartGuid);
            if (cart.CartGuid != cartGuid) return;

            Store store = new Store(gCart.StoreGuid);
            if (store.Guid != cart.StoreGuid) return;

            gCart.DeSerializeCartOffers();

            gLog.SiteGuid = store.SiteGuid;
            gLog.UserGuid = gCart.UserGuid;
            gLog.CartGuid = gCart.CartGuid;
            gLog.StoreGuid = gCart.StoreGuid;
            gLog.Save();

            gCart.OrderInfo.CompletedFromIP = SiteUtils.GetIP4Address();

            gCart.OrderInfo.Completed = DateTime.UtcNow;
            if (newOrder.buyerbillingaddress.structuredname != null)
            {
                gCart.OrderInfo.CustomerFirstName = newOrder.buyerbillingaddress.structuredname.firstname;
                gCart.OrderInfo.CustomerLastName = newOrder.buyerbillingaddress.structuredname.lastname;
            }
            else
            {
                gCart.OrderInfo.CustomerFirstName = newOrder.buyerbillingaddress.contactname;
                gCart.OrderInfo.CustomerLastName = newOrder.buyerbillingaddress.contactname;
            }
            gCart.OrderInfo.CustomerEmail = newOrder.buyerbillingaddress.email;
            gCart.OrderInfo.CustomerCompany = newOrder.buyerbillingaddress.companyname;
            gCart.OrderInfo.CustomerAddressLine1 = newOrder.buyerbillingaddress.address1;
            gCart.OrderInfo.CustomerAddressLine2 = newOrder.buyerbillingaddress.address2;
            gCart.OrderInfo.CustomerCity = newOrder.buyerbillingaddress.city;
            gCart.OrderInfo.CustomerState = newOrder.buyerbillingaddress.region;
            gCart.OrderInfo.CustomerCountry = newOrder.buyerbillingaddress.countrycode;
            gCart.OrderInfo.CustomerPostalCode = newOrder.buyerbillingaddress.postalcode;
            gCart.OrderInfo.CustomerTelephoneDay = newOrder.buyerbillingaddress.phone;

            gCart.CopyCustomerToBilling();

            if (newOrder.buyershippingaddress.structuredname != null)
            {
                gCart.OrderInfo.DeliveryFirstName = newOrder.buyershippingaddress.structuredname.firstname;
                gCart.OrderInfo.DeliveryLastName = newOrder.buyershippingaddress.structuredname.lastname;
            }
            else
            {
                gCart.OrderInfo.DeliveryFirstName = newOrder.buyershippingaddress.contactname;
                gCart.OrderInfo.DeliveryLastName = newOrder.buyershippingaddress.contactname;
            }
            gCart.OrderInfo.DeliveryCompany = newOrder.buyershippingaddress.companyname;
            gCart.OrderInfo.DeliveryAddress1 = newOrder.buyershippingaddress.address1;
            gCart.OrderInfo.DeliveryAddress2 = newOrder.buyershippingaddress.address2;
            gCart.OrderInfo.DeliveryCity = newOrder.buyershippingaddress.city;
            gCart.OrderInfo.DeliveryState = newOrder.buyershippingaddress.region;
            gCart.OrderInfo.DeliveryCountry = newOrder.buyershippingaddress.countrycode;
            gCart.OrderInfo.DeliveryPostalCode = newOrder.buyershippingaddress.postalcode;

            gCart.TaxTotal = newOrder.orderadjustment.totaltax.Value;
            if (newOrder.ShippingCost > 0)
            {
                gCart.ShippingTotal = newOrder.ShippingCost;
            }
            gCart.OrderTotal = newOrder.ordertotal.Value;

            Guid orderStatusGuid = OrderStatus.OrderStatusReceivedGuid;

            if (
                (newOrder.financialorderstate == FinancialOrderState.CHARGEABLE)
                || (newOrder.financialorderstate == FinancialOrderState.CHARGED)
                || (newOrder.financialorderstate == FinancialOrderState.CHARGING)
                )
            {
                orderStatusGuid = OrderStatus.OrderStatusFulfillableGuid;

            }

            StoreHelper.EnsureUserForOrder(gCart);

            gCart.Save();

            //Currency currency = new Currency(store.DefaultCurrencyId);
            SiteSettings siteSettings = new SiteSettings(store.SiteGuid);

            Order order = Order.CreateOrder(
                store,
                gCart,
                gLog.RawResponse,
                gLog.OrderNumber,
                string.Empty,
                siteSettings.GetCurrency().Code,
                "GoogleCheckout",
                orderStatusGuid);

            //StoreHelper.ClearCartCookie(cart.StoreGuid);
            if (orderStatusGuid == OrderStatus.OrderStatusFulfillableGuid)
            {
                StoreHelper.ConfirmOrder(store, order);
                PayPalLog.DeleteByCart(order.OrderGuid);

            }

            if (orderStatusGuid == OrderStatus.OrderStatusReceivedGuid)
            {
                StoreHelper.ConfirmOrderReceived(store, order);
            }
        }
Esempio n. 26
0
        /// <summary>
        /// Creates hidden form fields for PayPal Standard Cart upload
        /// </summary>
        /// <returns></returns>
        public static string GetCartUploadFormFields(
            Guid payPalLogGuid,
            Cart cart,
            Store store,
            CommerceConfiguration commerceConfig)
        {
            //TODO: PayPal is not seeing discounts?

            PayPalStandardPaymentGateway gateway
                = new PayPalStandardPaymentGateway(
                    commerceConfig.PayPalStandardUrl,
                    commerceConfig.PayPalStandardEmailAddress,
                    commerceConfig.PayPalStandardPDTId);

            gateway.Amount = cart.OrderTotal;
            gateway.Tax = cart.TaxTotal;
            gateway.Shipping = cart.ShippingTotal;
            gateway.CartDiscount = cart.Discount;

            //Currency currency = new Currency(cart.CurrencyGuid);
            //if (currency.Guid != Guid.Empty)
            //{
            //    gateway.CurrencyCode = currency.Code;
            //}
            //gateway.CurrencyCode = store.DefaultCurrency;
            SiteSettings siteSettings = CacheHelper.GetCurrentSiteSettings();
            gateway.CurrencyCode = siteSettings.GetCurrency().Code;

            gateway.OrderHasShippableProducts = cart.HasShippingProducts();
            gateway.ShippingFirstName = cart.OrderInfo.DeliveryFirstName;
            gateway.ShippingLastName = cart.OrderInfo.DeliveryLastName;

            gateway.ShippingAddress1 = cart.OrderInfo.DeliveryAddress1;
            gateway.ShippingAddress2 = cart.OrderInfo.DeliveryAddress2;
            gateway.ShippingCity = cart.OrderInfo.DeliveryCity;
            gateway.ShippingState = cart.OrderInfo.DeliveryState;
            gateway.ShippingPostalCode = cart.OrderInfo.DeliveryPostalCode;

            //add the items
            foreach (CartOffer offer in cart.CartOffers)
            {
                PayPalOrderItem item = new PayPalOrderItem();
                item.Amount = offer.OfferPrice;
                item.ItemName = offer.Name;
                item.ItemNumber = offer.OfferGuid.ToString();
                item.Quantity = offer.Quantity;
                item.Tax = offer.Tax;

                gateway.Items.Add(item);

            }

            gateway.OrderDescription = store.Name + " " + WebStoreResources.OrderHeading;

            gateway.Custom = payPalLogGuid.ToString();

            string siteRoot = SiteUtils.GetNavigationSiteRoot();
            string storePageUrl = SiteUtils.GetCurrentPageUrl();

            gateway.ReturnUrl = siteRoot + "/Services/PayPalPDTHandler.aspx";
            gateway.NotificationUrl = siteRoot + "/Services/PayPalIPNHandler.aspx";
            gateway.CancelUrl = storePageUrl;

            return gateway.GetCartUploadFormFields();
        }
        public override void HandleRiskInformationNotification(
            string requestXml,
            RiskInformationNotification notification)
        {
            GoogleCheckoutLog gLog = new GoogleCheckoutLog();
            gLog.ProviderName = "WebStoreGCheckoutNotificationHandlerProvider";
            gLog.RawResponse = requestXml;
            gLog.NotificationType = "RiskInformationNotification";
            gLog.SerialNumber = notification.serialnumber;
            gLog.OrderNumber = notification.googleordernumber;
            gLog.GTimestamp = notification.timestamp;
            gLog.AvsResponse = notification.riskinformation.avsresponse;
            gLog.CvnResponse = notification.riskinformation.cvnresponse;
            gLog.BuyerId = notification.riskinformation.ipaddress;
            gLog.Save();

            Guid orderGuid = GoogleCheckoutLog.GetCartGuidFromOrderNumber(notification.googleordernumber);

            if (orderGuid == Guid.Empty) return;

            Order order = new Order(orderGuid);
            if (order.OrderGuid != orderGuid) return;

            Store store = new Store(order.StoreGuid);
            if (store.Guid != order.StoreGuid) return;

            gLog.SiteGuid = store.SiteGuid;
            gLog.UserGuid = order.UserGuid;
            gLog.CartGuid = order.OrderGuid;
            gLog.StoreGuid = order.StoreGuid;
            gLog.Save();
        }
Esempio n. 28
0
        public static Cart GetClerkCart(Store store)
        {
            if (HttpContext.Current == null) return null;
            if (store == null) return null;

            string cartKey = "clerkcart" + store.Guid.ToString();
            if (HttpContext.Current.Items[cartKey] != null)
            {
                return (Cart)HttpContext.Current.Items[cartKey];
            }

            if (CookieHelper.CookieExists(cartKey))
            {
                string cartCookie = CookieHelper.GetCookieValue(cartKey);
                if (cartCookie.Length == 36)
                {
                    Guid cartGuid = new Guid(cartCookie);
                    Cart cart = new Cart(cartGuid);
                    if (!cart.Exists)
                    {
                        return CreateClerkCartAndSetCookie(store, cartKey);
                    }

                    HttpContext.Current.Items[cartKey] = cart;
                    return cart;

                }
                else
                {
                    // cookie is invalid
                    return CreateClerkCartAndSetCookie(store, cartKey);
                }
            }
            else
            {

                return CreateClerkCartAndSetCookie(store, cartKey);

            }
        }
        public override void HandleChargeAmountNotification(
            string requestXml,
            ChargeAmountNotification notification)
        {
            GoogleCheckoutLog gLog = new GoogleCheckoutLog();
            gLog.ProviderName = "WebStoreGCheckoutNotificationHandlerProvider";
            gLog.RawResponse = requestXml;
            gLog.NotificationType = "ChargeAmountNotification";
            gLog.SerialNumber = notification.serialnumber;
            gLog.OrderNumber = notification.googleordernumber;
            gLog.GTimestamp = notification.timestamp;
            gLog.TotalChgAmt = notification.totalchargeamount.Value;
            gLog.LatestChgAmt = notification.latestchargeamount.Value;

            gLog.Save();

            Guid orderGuid = GoogleCheckoutLog.GetCartGuidFromOrderNumber(notification.googleordernumber);

            if (orderGuid == Guid.Empty) return;

            Order order = new Order(orderGuid);
            if (order.OrderGuid != orderGuid) return;

            Store store = new Store(order.StoreGuid);
            if (store.Guid != order.StoreGuid) return;

            gLog.SiteGuid = store.SiteGuid;
            gLog.UserGuid = order.UserGuid;
            gLog.CartGuid = order.OrderGuid;
            gLog.StoreGuid = order.StoreGuid;
            gLog.Save();
        }
Esempio n. 30
0
        private void LoadSettings()
        {
            siteSettings = CacheHelper.GetCurrentSiteSettings();
            store = new Store(siteSettings.SiteGuid, moduleId);
            Settings = ModuleSettings.GetModuleSettings(moduleId);
            module = GetModule(moduleId);

            lnkCart.PageID = pageId;
            lnkCart.ModuleID = moduleId;

            enableRatingsInProductList = WebUtils.ParseBoolFromHashtable(
                Settings, "EnableContentRatingInProductListSetting", enableRatingsInProductList);

            enableRatingComments = WebUtils.ParseBoolFromHashtable(
                Settings, "EnableRatingCommentsSetting", enableRatingComments);

            productList1.Store = store;
            productList1.PageId = pageId;
            productList1.ModuleId = moduleId;
            productList1.SiteRoot = SiteRoot;
            productList1.CurrencyCulture = currencyCulture;
            productList1.EnableRatings = enableRatingsInProductList;
            productList1.EnableRatingComments = enableRatingComments;
            productList1.Settings = Settings;

            AddClassToBody("webstore webstoreproductlist");

            if (WebStoreConfiguration.UseNoIndexFollowMetaOnLists)
            {
                SiteUtils.AddNoIndexFollowMeta(Page);
            }
        }