Пример #1
0
        private void BindSubscriptions()
        {
            IList <Subscription> subscriptions = new List <Subscription>();

            if (_Order.IsSubscriptionGenerated)
            {
                IList <SubscriptionOrder> subOrders = SubscriptionOrderDataSource.LoadForOrder(_Order.Id);
                foreach (SubscriptionOrder subOrder in subOrders)
                {
                    if (subOrder.Subscription != null)
                    {
                        subscriptions.Add(subOrder.Subscription);
                    }
                }

                SubscriptionGrid.DataSource = subscriptions;
                SubscriptionGrid.DataBind();
            }
            else
            {
                subscriptions = SubscriptionDataSource.LoadForOrder(_Order.Id);
                SubscriptionGrid.DataSource = subscriptions;
                SubscriptionGrid.DataBind();
            }
        }
        protected void CompleteButton_Click(object sender, EventArgs e)
        {
            if (Page.IsValid)
            {
                bool checkOut = true;
                if (CheckingOut != null)
                {
                    CheckingOutEventArgs c = new CheckingOutEventArgs();
                    CheckingOut(this, c);
                    checkOut = !c.Cancel;
                }
                if (checkOut)
                {
                    Basket basket = AbleContext.Current.User.Basket;
                    //PROCESS THE CHECKOUT
                    ICheckoutService checkoutService  = AbleContext.Resolve <ICheckoutService>();
                    CheckoutRequest  checkoutRequest  = new CheckoutRequest(basket);
                    CheckoutResponse checkoutResponse = checkoutService.ExecuteCheckout(checkoutRequest);
                    if (checkoutResponse.Success)
                    {
                        GatewayPaymentProfile profile = null;
                        this.Visible = true;

                        if (ProfilesPH.Visible)
                        {
                            profile = GatewayPaymentProfileDataSource.Load(AlwaysConvert.ToInt(ProfilesList.SelectedValue));
                        }

                        if (CardPH.Visible)
                        {
                            AccountDataDictionary cardDetails = new AccountDataDictionary();
                            cardDetails["AccountName"]     = CardName.Text.Trim();
                            cardDetails["AccountNumber"]   = CardNumber.Text.Trim();
                            cardDetails["ExpirationMonth"] = ExpirationMonth.SelectedItem.Value;
                            cardDetails["ExpirationYear"]  = ExpirationYear.SelectedItem.Value;
                            cardDetails["SecurityCode"]    = SecurityCode.Text.Trim();
                            profile = CreateProfile(cardDetails);
                        }

                        if (profile != null)
                        {
                            IList <Subscription> subscriptions = SubscriptionDataSource.LoadForOrder(checkoutResponse.Order.Id);
                            foreach (Subscription subscription in subscriptions)
                            {
                                if (subscription.PaymentFrequency.HasValue && subscription.PaymentFrequencyUnit.HasValue)
                                {
                                    subscription.PaymentProfile        = profile;
                                    subscription.PaymentProcessingType = PaymentProcessingType.ArbProfileManaged;
                                    subscription.Save();
                                }
                            }
                        }

                        if (CheckedOut != null)
                        {
                            CheckedOut(this, new CheckedOutEventArgs(checkoutResponse));
                        }
                        Response.Redirect(AbleCommerce.Code.NavigationHelper.GetReceiptUrl(checkoutResponse.Order.OrderNumber));
                    }
                    else
                    {
                        IList <string> warningMessages = checkoutResponse.WarningMessages;
                        if (warningMessages.Count == 0)
                        {
                            warningMessages.Add("The order could not be submitted at this time.  Please try again later or contact us for assistance.");
                        }
                        if (CheckedOut != null)
                        {
                            CheckedOut(this, new CheckedOutEventArgs(checkoutResponse));
                        }
                    }
                }
            }
        }
        protected void CreditCardButton_Click(object sender, EventArgs e)
        {
            if (Page.IsValid && CustomValidation())
            {
                // CREATE THE PAYMENT OBJECT
                Payment payment = GetPayment();

                // PROCESS CHECKING OUT EVENT
                bool checkOut = true;
                if (CheckingOut != null)
                {
                    CheckingOutEventArgs c = new CheckingOutEventArgs(payment);
                    CheckingOut(this, c);
                    checkOut = !c.Cancel;
                }

                if (checkOut)
                {
                    // CONTINUE TO PROCESS THE CHECKOUT
                    Basket           basket           = AbleContext.Current.User.Basket;
                    ICheckoutService checkoutService  = AbleContext.Resolve <ICheckoutService>();
                    CheckoutRequest  checkoutRequest  = new CheckoutRequest(basket, payment);
                    CheckoutResponse checkoutResponse = checkoutService.ExecuteCheckout(checkoutRequest);
                    if (checkoutResponse.Success)
                    {
                        GatewayPaymentProfile profile = null;
                        if (trSaveCard.Visible && SaveCard.Checked)
                        {
                            AccountDataDictionary cardDetails = new AccountDataDictionary();
                            cardDetails["AccountName"]     = CardName.Text.Trim();
                            cardDetails["AccountNumber"]   = CardNumber.Text.Trim();
                            cardDetails["ExpirationMonth"] = ExpirationMonth.SelectedItem.Value;
                            cardDetails["ExpirationYear"]  = ExpirationYear.SelectedItem.Value;
                            cardDetails["SecurityCode"]    = SecurityCode.Text.Trim();
                            profile = CreateProfile(cardDetails);
                        }

                        if (AbleContext.Current.Store.Settings.ROCreateNewOrdersEnabled && OrderHelper.HasRecurringSubscriptions(checkoutResponse.Order))
                        {
                            IList <Subscription> subscriptions = SubscriptionDataSource.LoadForOrder(checkoutResponse.Order.Id);
                            foreach (Subscription subscription in subscriptions)
                            {
                                OrderItem oi = subscription.OrderItem;
                                if (oi != null && oi.Price == 0 && OrderHelper.HasRecurringSubscriptions(oi) && subscription.PaymentProfile == null)
                                {
                                    if (profile == null)
                                    {
                                        if (ProfilesPH.Visible)
                                        {
                                            profile = GatewayPaymentProfileDataSource.Load(AlwaysConvert.ToInt(ProfilesList.SelectedValue));
                                        }

                                        if (CardPH.Visible)
                                        {
                                            AccountDataDictionary cardDetails = new AccountDataDictionary();
                                            cardDetails["AccountName"]     = CardName.Text.Trim();
                                            cardDetails["AccountNumber"]   = CardNumber.Text.Trim();
                                            cardDetails["ExpirationMonth"] = ExpirationMonth.SelectedItem.Value;
                                            cardDetails["ExpirationYear"]  = ExpirationYear.SelectedItem.Value;
                                            cardDetails["SecurityCode"]    = SecurityCode.Text.Trim();
                                            profile = CreateProfile(cardDetails);
                                        }
                                    }

                                    subscription.PaymentProfile        = profile;
                                    subscription.PaymentProcessingType = PaymentProcessingType.ArbProfileManaged;
                                    subscription.Save();
                                }
                            }
                        }

                        if (profile != null && payment.PaymentProfile == null)
                        {
                            payment.PaymentProfile = profile;
                            payment.Save();
                        }

                        if (CheckedOut != null)
                        {
                            CheckedOut(this, new CheckedOutEventArgs(checkoutResponse));
                        }
                        Response.Redirect(AbleCommerce.Code.NavigationHelper.GetReceiptUrl(checkoutResponse.Order.OrderNumber));
                    }
                    else
                    {
                        IList <string> warningMessages = checkoutResponse.WarningMessages;
                        if (warningMessages.Count == 0)
                        {
                            warningMessages.Add("The order could not be submitted at this time.  Please try again later or contact us for assistance.");
                        }
                        if (CheckedOut != null)
                        {
                            CheckedOut(this, new CheckedOutEventArgs(checkoutResponse));
                        }
                    }
                }
            }
        }
Пример #4
0
        /// <summary>
        /// Performs operations that should be done when an order is paid or paid with credit balance.
        /// </summary>
        /// <param name="order">order that was paid</param>
        private static void ProcessPaidOrder(Order order)
        {
            //CHECK FOR SUBSCRIPTIONS
            try
            {
                //ANY SUBSCRIPTIONS THAT WERE "ONE TIME ONLY" CHARGES SHOULD BE ACTIVATED
                //THESE WILL NOT BE ACTIVATED BY REFERENCE TO PAYMENT, AND WILL NOT HAVE ANY PAYMENTS ASSOCIATED
                SubscriptionCollection subscriptions = SubscriptionDataSource.LoadForOrder(order.OrderId);
                foreach (Subscription s in subscriptions)
                {
                    if ((!s.IsActive) && (s.Payments.Count == 0))
                    {
                        s.Activate();
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Error("Error generating subscriptions for order #" + order.OrderId.ToString(), ex);
            }

            try
            {
                IGiftCertKeyProvider       provider = new DefaultGiftCertKeyProvider();
                GiftCertificateTransaction trans;
                foreach (OrderItem orderItem in order.Items)
                {
                    //IF THERE ARE ANY GIFT CERTS ATTACHED THEN ACTIVATE THOSE
                    if (orderItem.GiftCertificates != null && orderItem.GiftCertificates.Count > 0)
                    {
                        foreach (GiftCertificate gc in orderItem.GiftCertificates)
                        {
                            gc.SerialNumber       = provider.GenerateGiftCertificateKey();
                            trans                 = new GiftCertificateTransaction();
                            trans.Amount          = gc.Balance;
                            trans.Description     = "Gift certificate activated.";
                            trans.OrderId         = order.OrderId;
                            trans.TransactionDate = LocaleHelper.LocalNow;
                            gc.Transactions.Add(trans);
                            gc.Save();
                            // Trigger Gift Certificate Activated / Validate Event
                            StoreEventEngine.GiftCertificateValidated(gc, trans);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Error("Error activating gift certificates for order #" + order.OrderId.ToString(), ex);
            }


            foreach (OrderItem orderItem in order.Items)
            {
                //IF THERE ARE ANY DIGITAL GOODS ATTACHED THEN ACTIVATE/FULFILL THOSE
                if (orderItem.DigitalGoods != null && orderItem.DigitalGoods.Count > 0)
                {
                    foreach (OrderItemDigitalGood oidg in orderItem.DigitalGoods)
                    {
                        bool changed = false;
                        try
                        {
                            if (!oidg.IsActivated() && oidg.DigitalGood != null &&
                                oidg.DigitalGood.ActivationMode != ActivationMode.Manual)
                            {
                                oidg.Activate();
                                changed = true;
                            }
                        }
                        catch (Exception ex)
                        {
                            Logger.Error("Error activating digital good for order #" + order.OrderId.ToString(), ex);
                        }

                        try
                        {
                            if (!oidg.IsSerialKeyAcquired() && oidg.DigitalGood != null &&
                                oidg.DigitalGood.FulfillmentMode != FulfillmentMode.Manual)
                            {
                                oidg.AcquireSerialKey();
                                changed = true;
                            }
                        }
                        catch (Exception ex)
                        {
                            Logger.Error("Error fulfilling digital good for order #" + order.OrderId.ToString(), ex);
                        }

                        if (changed)
                        {
                            oidg.Save();
                        }
                    }
                }
            }
        }