示例#1
0
 private static void SetSubscriptionCreditCardInformation(ISubscriptionRequest subscriptionRequest, CreditCard creditCard)
 {
     subscriptionRequest.CardCode            = creditCard.CVV;
     subscriptionRequest.CardExpirationMonth = creditCard.ExpirationMonth;
     subscriptionRequest.CardExpirationYear  = creditCard.ExpirationYear;
     subscriptionRequest.CardNumber          = creditCard.Number;
 }
示例#2
0
        public void UpdateSubscriptionTest()
        {
            //check login / password
            string sError = CheckLoginPassword();

            Assert.IsTrue(sError == "", sError);

            string responseString =
                "<?xml version=\"1.0\" encoding=\"utf-8\"?><ARBUpdateSubscriptionResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"AnetApi/xml/v1/schema/AnetApiSchema.xsd\"><messages><resultCode>Ok</resultCode><message><code>I00001</code><text>Successful.</text></message></messages></ARBUpdateSubscriptionResponse>";

            LocalRequestObject.ResponseString = responseString;

            SubscriptionGateway target = new SubscriptionGateway(ApiLogin, TransactionKey);

            ISubscriptionRequest subscription = SubscriptionRequest.CreateMonthly("*****@*****.**",
                                                                                  "ARB Update Subscription Test",
                                                                                  (decimal)1.32, 12);

            subscription.SubscriptionID = "2010573";

            bool actual = false;

            // if choose "USELOCAL", the test should pass with no exception
            // Otherwise, the test might fail for error, i.e. duplicated request.
            try
            {
                actual = target.UpdateSubscription(subscription);
            }
            catch (Exception e)
            {
                string s = e.Message;
            }

            Assert.IsTrue(actual);
        }
示例#3
0
        public void AuthorizeNet_ARBCallTest()
        {
            var target = new SubscriptionGateway("77pmw32Vh7LS", "73629XQgg28GW2tp", ServiceMode.Test);

            ISubscriptionRequest subscription = SubscriptionRequest
                                                .CreateMonthly("*****@*****.**", "ARB Test" + Guid.NewGuid(), (decimal)5.60, 12);

            subscription.CardNumber          = "4111111111111111";
            subscription.CardExpirationMonth = 1;
            subscription.CardExpirationYear  = 20;

            var billToAddress = new Address();

            billToAddress.First         = "John";
            billToAddress.Last          = "Doe";
            subscription.BillingAddress = billToAddress;

            ISubscriptionRequest actual = null;

            try
            {
                actual = target.CreateSubscription(subscription);
            }
            catch (Exception e)
            {
                var s = e.Message;
                Console.WriteLine("Failed to create SUB: " + e);
            }
        }
示例#4
0
        private static void SetSubscriptionBasics(ISubscriptionRequest subscriptionRequest, SubscriptionType subscriptionType)
        {
            subscriptionRequest.StartsOn         = DateTime.UtcNow;
            subscriptionRequest.Amount           = subscriptionType.Price;
            subscriptionRequest.SubscriptionName = subscriptionType.SubscriptionFrequency.Name + " Membership";

            // Subscription interval
            if (subscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Monthly)
            {
                subscriptionRequest.BillingInterval      = 1;
                subscriptionRequest.BillingIntervalUnits = BillingIntervalUnits.Months;
            }
            else if (subscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Quarterly)
            {
                subscriptionRequest.BillingInterval      = 365 / 4;
                subscriptionRequest.BillingIntervalUnits = BillingIntervalUnits.Days;
            }
            else if (subscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Yearly)
            {
                subscriptionRequest.BillingInterval      = 365;
                subscriptionRequest.BillingIntervalUnits = BillingIntervalUnits.Days;
            }
            else
            {
                // TODO: Log Error! We should never hit this case.
            }
        }
        public void CreateSubscriptionTest_zeroTrial()
        {
            var random  = new AnetRandom();
            var counter = random.Next(1, (int)(Math.Pow(2, 24)));
            var amount  = ComputeRandomAmount();
            var email   = string.Format("user.{0}@authorize.net", counter);

            const string responseString = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ARBCreateSubscriptionResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"AnetApi/xml/v1/schema/AnetApiSchema.xsd\"><messages><resultCode>Ok</resultCode><message><code>I00001</code><text>Successful.</text></message></messages><subscriptionId>2074569</subscriptionId></ARBCreateSubscriptionResponse>";

            LocalRequestObject.ResponseString = responseString;

            var target = new SubscriptionGateway(ApiLogin, TransactionKey);

            var billToAddress = new Address {
                First = "SomeOneCool", Last = "MoreCoolPerson"
            };
            ISubscriptionRequest subscription = SubscriptionRequest.CreateMonthly(email, "ARB Subscription Test", amount, 10);

            subscription.CardNumber          = "4111111111111111";
            subscription.CardExpirationMonth = 3;
            subscription.CardExpirationYear  = 16;
            subscription.BillingAddress      = billToAddress;

            //setting Trial amount/ Trial Ocurances to 0
            subscription.SetTrialPeriod(3, 0M);

            ISubscriptionRequest actual = null;

            actual = target.CreateSubscription(subscription);
            Assert.NotNull(actual);
        }
        /// <summary>
        /// Updates the subscription.
        /// </summary>
        /// <param name="subscription">The subscription to update. Can't change billing intervals however.</param>
        /// <returns></returns>
        public bool UpdateSubscription(ISubscriptionRequest subscription) {
            var sub = subscription.ToUpdateableAPI();
            var req = new ARBUpdateSubscriptionRequest();
            req.subscription = sub;
            req.subscriptionId = subscription.SubscriptionID;
            var response = (ARBUpdateSubscriptionResponse)_gateway.Send(req);
            return true;

        }
        /// <summary>
        /// Creates a new subscription
        /// </summary>
        /// <param name="subscription">The subscription to create - requires that you add a credit card and billing first and last.</param>
        public ISubscriptionRequest CreateSubscription(ISubscriptionRequest subscription) {
            var sub = subscription.ToAPI();
            var req = new ARBCreateSubscriptionRequest();
            req.subscription = sub;
            var response = (ARBCreateSubscriptionResponse)_gateway.Send(req);
            subscription.SubscriptionID = response.subscriptionId;
            return subscription;

        }
示例#8
0
        public ActionResult Subscribe(SubscriptionRegistration registrationInformation)
        {
            registrationInformation.AvailableSubscriptionTypes = _database.SubscriptionTypes.Include(st => st.SubscriptionFrequency).Where(st => st.IsAvailableToUsers && !st.IsAddOn);
            registrationInformation.Countries = _database.Countries.AsEnumerable();

            if (registrationInformation.SelectedSubscriptionTypeId == 0)
            {
                ModelState.AddModelError(string.Empty, "Please choose a subscription to continue.");
            }

            // If all credit card information has been supplied, then try to validate the request with Authorize.NET
            if (ModelState.IsValid)
            {
                ISubscriptionGateway gateway = GetSubscriptionGateway();

                ISubscriptionRequest subscriptionRequest  = MembersController.CreateAuthorizeDotNetSubscriptionRequest(registrationInformation);
                ISubscriptionRequest subscriptionResponse = null;

                try
                {
                    subscriptionResponse = gateway.CreateSubscription(subscriptionRequest);
                }
                catch (InvalidOperationException exception)
                {
                    ModelState.AddModelError(string.Empty, exception.Message);

                    return(View(registrationInformation));
                }

                // If we reach this part of the code, we have successfully scheduled a subscription, make a note of it in our system
                WebSite.Models.User currentUser = Authentication.GetCurrentUser();
                DatabaseContext     db          = _database;

                // Encrypt the credit card information of the user
                registrationInformation.CreditCard.Encrypt();

                // Construct a subscription for the user
                Subscription userSubscription = new Subscription()
                {
                    ActivationDate             = DateTime.UtcNow,
                    AuthorizeNETSubscriptionId = subscriptionResponse.SubscriptionID,
                    CancellationDate           = null,
                    SubscriptionTypeId         = registrationInformation.SelectedSubscriptionTypeId,
                    CreditCard = registrationInformation.CreditCard
                };

                // Associate the subscription with the user
                currentUser.AddSubscription(userSubscription);

                db.SaveChanges();

                return(this.RedirectToAction("Index"));
            }

            return(View(registrationInformation));
        }
示例#9
0
        public ActionResult AddAutoTrading(AddonRegistration registrationInformation)
        {
            if (ModelState.IsValid)
            {
                SubscriptionType autoTradingAddOn = _database.SubscriptionTypes.Include(st => st.SubscriptionFrequency).Where(st => st.IsAvailableToUsers && st.IsAddOn).FirstOrDefault();

                if (autoTradingAddOn != null)
                {
                    ISubscriptionGateway gateway             = GetSubscriptionGateway();
                    ISubscriptionRequest subscriptionRequest = MembersController.CreateAuthorizeDotNetSubscriptionRequest(registrationInformation.CreditCard, autoTradingAddOn);

                    ISubscriptionRequest subscriptionResponse = null;

                    try
                    {
                        subscriptionResponse = gateway.CreateSubscription(subscriptionRequest);
                    }
                    catch (InvalidOperationException exception)
                    {
                        ModelState.AddModelError(string.Empty, exception.Message);

                        return(View(registrationInformation));
                    }

                    // If the code reaches here then the payment went through
                    WebSite.Models.User currentUser = Authentication.GetCurrentUser();

                    // Encrypt the credit card information of the user
                    registrationInformation.CreditCard.Encrypt();

                    // Construct a subscription for the user
                    Subscription userSubscription = new Subscription()
                    {
                        ActivationDate             = DateTime.UtcNow,
                        AuthorizeNETSubscriptionId = subscriptionResponse.SubscriptionID,
                        CancellationDate           = null,
                        SubscriptionTypeId         = autoTradingAddOn.SubscriptionTypeId,
                        CreditCard = registrationInformation.CreditCard
                    };

                    // Associate the subscription with the user
                    currentUser.AddAddOnSubscription(userSubscription);

                    _database.SaveChanges();

                    return(this.RedirectToAction("Index"));
                }
                else
                {
                    this.ModelState.AddModelError(string.Empty, "Can't locate auto-trading add-on in server");
                }
            }

            return(View(registrationInformation));
        }
示例#10
0
        public ActionResult Subscribe(SubscriptionRegistration registrationInformation, int userId, int day, int month, int year)
        {
            ViewBag.UserId = userId;
            registrationInformation.AvailableSubscriptionTypes = _db.SubscriptionTypes.Include(o => o.SubscriptionFrequency);
            registrationInformation.Countries = _db.Countries.AsEnumerable();

            if (registrationInformation.SelectedSubscriptionTypeId == 0)
            {
                ModelState.AddModelError(string.Empty, "Please choose a subscription to continue.");
            }

            // If all credit card information has been supplied, then try to validate the request with Authorize.NET
            if (ModelState.IsValid)
            {
                WebSite.Models.User  user    = _db.Users.Find(userId);
                ISubscriptionGateway gateway = this.GetSubscriptionGateway();

                ISubscriptionRequest subscriptionRequest  = this.CreateAuthorizeDotNetSubscriptionRequest(registrationInformation, user, new DateTime(year, month, day));
                ISubscriptionRequest subscriptionResponse = null;

                try
                {
                    subscriptionResponse = gateway.CreateSubscription(subscriptionRequest);
                }
                catch (InvalidOperationException exception)
                {
                    ModelState.AddModelError(string.Empty, exception.Message);

                    return(View(registrationInformation));
                }

                // Encrypt the credit card information of the user
                registrationInformation.CreditCard.Encrypt();

                // Construct a subscription for the user
                Subscription userSubscription = new Subscription()
                {
                    ActivationDate             = DateTime.UtcNow,
                    AuthorizeNETSubscriptionId = subscriptionResponse.SubscriptionID,
                    CancellationDate           = null,
                    SubscriptionTypeId         = registrationInformation.SelectedSubscriptionTypeId,
                    CreditCard = registrationInformation.CreditCard
                };

                // Associate the subscription with the user
                user.AddSubscription(userSubscription);

                _db.SaveChanges();

                return(this.RedirectToAction("Index"));
            }

            return(View(registrationInformation));
        }
示例#11
0
        public ActionResult UpdateSubscription(CreditCard newCreditCard)
        {
            if (ModelState.IsValid)
            {
                User currentUser = Authentication.GetCurrentUserEagerlyLoaded();

                // Create a new subscription with the old settings
                ISubscriptionRequest subscriptionRequest  = CreateAuthorizeDotNetSubscriptionRequest(newCreditCard, currentUser.Subscription.SubscriptionType);
                ISubscriptionRequest subscriptionResponse = null;

                ISubscriptionGateway subscriptionGateway = GetSubscriptionGateway();

                try
                {
                    // Add the new subscription now
                    subscriptionResponse = subscriptionGateway.CreateSubscription(subscriptionRequest);

                    // Cancel the current subscription
                    subscriptionGateway.CancelSubscription(currentUser.Subscription.AuthorizeNETSubscriptionId);

                    // Subscription was updated successfully

                    // Encrypt the card's number
                    newCreditCard.Encrypt();

                    DatabaseContext db = _database;

                    // Construct a subscription for the user
                    Subscription userSubscription = new Subscription()
                    {
                        ActivationDate             = DateTime.UtcNow,
                        AuthorizeNETSubscriptionId = subscriptionResponse.SubscriptionID,
                        CancellationDate           = null,
                        SubscriptionTypeId         = currentUser.Subscription.SubscriptionTypeId,
                        CreditCard = newCreditCard
                    };

                    // Associate the subscription with the user
                    currentUser.AddSubscription(userSubscription);

                    db.SaveChanges();

                    return(this.RedirectToAction("Index"));
                }
                catch (Exception exception)
                {
                    ModelState.AddModelError(string.Empty, exception.Message);
                }
            }

            ViewBag.Countries = _database.Countries;

            return(this.View());
        }
示例#12
0
        public void CreateSubscriptionTest_eCheck()
        {
            //check login / password
            string sError = CheckLoginPassword();

            Assert.IsTrue(sError == "", sError);

            string responseString = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ARBCreateSubscriptionResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"AnetApi/xml/v1/schema/AnetApiSchema.xsd\"><messages><resultCode>Ok</resultCode><message><code>I00001</code><text>Successful.</text></message></messages><subscriptionId>2074569</subscriptionId></ARBCreateSubscriptionResponse>";

            LocalRequestObject.ResponseString = responseString;

            SubscriptionGateway target = new SubscriptionGateway(ApiLogin, TransactionKey);

            ISubscriptionRequest subscription = SubscriptionRequest.CreateMonthly("*****@*****.**",
                                                                                  "ARB Subscription Test eCheck", (decimal)1.31,
                                                                                  12);

            subscription.eCheckBankAccount = new BankAccount()
            {
                accountTypeSpecified = true,
                accountType          = BankAccountType.Checking,
                routingNumber        = "125000024",
                accountNumber        = "123456",
                nameOnAccount        = "Sue Zhu",
                echeckTypeSpecified  = true,
                echeckType           = EcheckType.WEB
            };

            Address billToAddress = new Address();

            billToAddress.First         = "Sue";
            billToAddress.Last          = "Zhu";
            subscription.BillingAddress = billToAddress;

            ISubscriptionRequest actual = null;

            // if choose "USELOCAL", the test should pass with no exception
            // Otherwise, the test might fail for error, i.e. duplicated request.
            try
            {
                actual = target.CreateSubscription(subscription);
            }
            catch (Exception e)
            {
                string s = e.Message;
            }

            Assert.AreEqual(subscription.Amount, actual.Amount);
            Assert.AreEqual(subscription.eCheckBankAccount.accountNumber, actual.eCheckBankAccount.accountNumber);
            Assert.AreEqual(subscription.SubscriptionName, actual.SubscriptionName);

            Assert.IsTrue(actual.SubscriptionID.Trim().Length > 0);
            Assert.IsTrue(long.Parse(actual.SubscriptionID) == 2074569);
        }
        /// <summary>
        /// Updates the subscription.
        /// </summary>
        /// <param name="subscription">The subscription to update. Can't change billing intervals however.</param>
        /// <returns></returns>
        public bool UpdateSubscription(ISubscriptionRequest subscription)
        {
            var sub = subscription.ToUpdateableAPI();
            var req = new ARBUpdateSubscriptionRequest();

            req.subscription   = sub;
            req.subscriptionId = subscription.SubscriptionID;
            var response = (ARBUpdateSubscriptionResponse)_gateway.Send(req);

            return(true);
        }
        /// <summary>
        /// Creates a new subscription
        /// </summary>
        /// <param name="subscription">The subscription to create - requires that you add a credit card and billing first and last.</param>
        public ISubscriptionRequest CreateSubscription(ISubscriptionRequest subscription)
        {
            var sub = subscription.ToAPI();
            var req = new ARBCreateSubscriptionRequest();

            req.subscription = sub;
            var response = (ARBCreateSubscriptionResponse)_gateway.Send(req);

            subscription.SubscriptionID = response.subscriptionId;
            return(subscription);
        }
示例#15
0
        public void UpdateSubscriptionTest()
        {
            ISubscriptionRequest subscription = SubscriptionRequest.CreateMonthly("*****@*****.**",
                                                                                  "ARB Update Subscription Test",
                                                                                  _mAmount, 12);

            subscription.SubscriptionID = _sMonthlySubscriptionId;

            bool actual = _mTarget.UpdateSubscription(subscription);

            Assert.IsTrue(actual);
        }
示例#16
0
        public void UpdateSubscriptionTest_Description_Invoice()
        {
            ISubscriptionRequest subscription = SubscriptionRequest.CreateMonthly("*****@*****.**",
                                                                                  "ARB Update Subscription Test Descriptn and Invoice",
                                                                                  _mAmount, 12);

            subscription.SubscriptionID = _sMonthlySubscriptionId;
            subscription.Invoice        = "INV12345";
            subscription.Description    = "update Description and Invoice";

            bool actual = _mTarget.UpdateSubscription(subscription);

            Assert.IsTrue(actual);
        }
示例#17
0
        public void CreateSubscriptionTest()
        {
            var       random  = new Random();
            var       counter = random.Next(1, (int)(Math.Pow(2, 24)));
            const int maxSubscriptionAmount = 1000; //214747;
            var       amount = new decimal(counter > maxSubscriptionAmount ? (counter % maxSubscriptionAmount) : counter);
            var       email  = string.Format("user.{0}@authorize.net", counter);

            //check login / password
            var sError = CheckLoginPassword();

            Assert.IsTrue(sError == "", sError);

            string responseString = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ARBCreateSubscriptionResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"AnetApi/xml/v1/schema/AnetApiSchema.xsd\"><messages><resultCode>Ok</resultCode><message><code>I00001</code><text>Successful.</text></message></messages><subscriptionId>2010573</subscriptionId></ARBCreateSubscriptionResponse>";

            LocalRequestObject.ResponseString = responseString;

            var target = new SubscriptionGateway(ApiLogin, TransactionKey);

            var billToAddress = new Address {
                First = "SomeOneCool", Last = "MoreCoolPerson"
            };
            ISubscriptionRequest subscription = SubscriptionRequest.CreateMonthly(email, "ARB Subscription Test", amount, 1);

            subscription.CardNumber          = "4111111111111111";
            subscription.CardExpirationMonth = 3;
            subscription.CardExpirationYear  = 16;
            subscription.BillingAddress      = billToAddress;

            ISubscriptionRequest actual = null;

            try
            {
                actual = target.CreateSubscription(subscription);
            }
            catch (Exception e)
            {
                string s = e.Message;
                Assert.Fail("Exception in processing");
            }

            Assert.NotNull(actual);
            Assert.AreEqual(subscription.Amount, actual.Amount);
            Assert.AreEqual(subscription.CardNumber, actual.CardNumber);
            Assert.AreEqual(subscription.SubscriptionName, actual.SubscriptionName);

            Assert.IsTrue(0 < actual.SubscriptionID.Trim().Length);
            Assert.IsTrue(0 < Int64.Parse(actual.SubscriptionID));
        }
示例#18
0
        public void UpdateSubscriptionTest_SingleDigitMonth()
        {
            ISubscriptionRequest subscription = SubscriptionRequest.CreateMonthly("*****@*****.**",
                                                                                  "ARB Update Subscription Test",
                                                                                  _mAmount, 12);

            subscription.SubscriptionID = _sMonthlySubscriptionId;

            subscription.CardNumber          = "4111111111111111";
            subscription.CardExpirationMonth = 4;
            subscription.CardExpirationYear  = 16;

            bool actual = _mTarget.UpdateSubscription(subscription);

            Assert.IsTrue(actual);
        }
        public void UpdateSubscriptionTest_SingleDigitMonth()
        {
            ISubscriptionRequest subscription = SubscriptionRequest.CreateMonthly("*****@*****.**",
                                                                                  "ARB Update Subscription Test",
                                                                                  _mAmount, 12);

            subscription.SubscriptionID = _sMonthlySubscriptionId;

            subscription.CardNumber          = "4111111111111111";
            subscription.CardExpirationMonth = 4;
            subscription.CardExpirationYear  = Convert.ToInt32(DateTime.Now.AddYears(3).ToString("yyyy"));

            bool actual = _mTarget.UpdateSubscription(subscription);

            Assert.IsTrue(actual);
        }
示例#20
0
 private static void SetSubscriptionBillingAddress(ISubscriptionRequest subscriptionRequest, CreditCard creditCard, string countryName)
 {
     subscriptionRequest.BillingAddress = new AuthorizeNet.Address()
     {
         City    = creditCard.BillingAddress.City,
         Country = countryName,
         First   = creditCard.CardholderFirstName,
         Last    = creditCard.CardholderLastName,
         Phone   = creditCard.BillingAddress.PhoneNumber,
         State   = creditCard.BillingAddress.ProvinceOrState,
         Street  =
             creditCard.BillingAddress.AddressLine1 +
             (!string.IsNullOrEmpty(creditCard.BillingAddress.AddressLine2) ?
              (Environment.NewLine + creditCard.BillingAddress.AddressLine2) :
              string.Empty)
         ,
         Zip = creditCard.BillingAddress.PostalCode
     };
 }
示例#21
0
        public static ISubscriptionRequest CreateAuthorizeDotNetSubscriptionRequest(CreditCard creditCard, SubscriptionType subscriptionType, WebSite.Models.User user)
        {
            ISubscriptionRequest request = SubscriptionRequest.CreateNew();

            // Billing address information
            DatabaseContext db          = System.Web.Mvc.DependencyResolver.Current.GetService(typeof(DatabaseContext)) as DatabaseContext;
            string          countryName = db.Countries.Find(creditCard.BillingAddress.CountryId).Name;

            SetSubscriptionBillingAddress(request, creditCard, countryName);

            // Subscription information
            SetSubscriptionBasics(request, subscriptionType);

            // Credit card information
            SetSubscriptionCreditCardInformation(request, creditCard);

            // Customer information
            request.CustomerEmail = user.EmailAddress;
            request.CustomerID    = user.UserId.ToString();

            return(request);
        }
        public void CreateSubscription()
        {
            var random  = new AnetRandom();
            var counter = random.Next(1, (int)(Math.Pow(2, 24)));
            var amount  = ComputeRandomAmount();
            var email   = string.Format("user.{0}@authorize.net", counter);

            //check ApiLoginid / TransactionKey
            var sError = CheckApiLoginTransactionKey();

            Assert.IsTrue(sError == "", sError);

            const string responseString = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ARBCreateSubscriptionResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"AnetApi/xml/v1/schema/AnetApiSchema.xsd\"><messages><resultCode>Ok</resultCode><message><code>I00001</code><text>Successful.</text></message></messages><subscriptionId>2010573</subscriptionId></ARBCreateSubscriptionResponse>";

            LocalRequestObject.ResponseString = responseString;

            var target = new SubscriptionGateway(ApiLogin, TransactionKey);

            var billToAddress = new Address {
                First = "SomeOneCool", Last = "MoreCoolPerson"
            };
            ISubscriptionRequest subscription = SubscriptionRequest.CreateMonthly(email, "ARB Subscription Test", amount, 1);

            subscription.CardNumber          = "4111111111111111";
            subscription.CardExpirationMonth = 3;
            subscription.CardExpirationYear  = 16;
            subscription.BillingAddress      = billToAddress;

            ISubscriptionRequest actual = target.CreateSubscription(subscription);

            Assert.NotNull(actual);
            Assert.AreEqual(subscription.Amount, actual.Amount);
            Assert.AreEqual(subscription.CardNumber, actual.CardNumber);
            Assert.AreEqual(subscription.SubscriptionName, actual.SubscriptionName);

            _sMonthlySubscriptionId = actual.SubscriptionID;
            Assert.IsTrue(0 < _sMonthlySubscriptionId.Trim().Length);
            Assert.IsTrue(0 < long.Parse(_sMonthlySubscriptionId));
        }
示例#23
0
        public void CreateSubscriptionTest_eCheck()
        {
            const string responseString = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ARBCreateSubscriptionResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"AnetApi/xml/v1/schema/AnetApiSchema.xsd\"><messages><resultCode>Ok</resultCode><message><code>I00001</code><text>Successful.</text></message></messages><subscriptionId>2074569</subscriptionId></ARBCreateSubscriptionResponse>";

            LocalRequestObject.ResponseString = responseString;

            var target = new SubscriptionGateway(ApiLogin, TransactionKey);

            ISubscriptionRequest subscription = SubscriptionRequest.CreateMonthly("*****@*****.**",
                                                                                  "ARB Subscription Test eCheck", _mAmount,
                                                                                  12);

            subscription.eCheckBankAccount = new BankAccount
            {
                accountTypeSpecified = true,
                accountType          = BankAccountType.Checking,
                routingNumber        = "125000024",
                accountNumber        = "123456",
                nameOnAccount        = "Sue Zhu",
                echeckTypeSpecified  = true,
                echeckType           = EcheckType.WEB
            };

            var billToAddress = new Address {
                First = "Sue", Last = "Zhu"
            };

            subscription.BillingAddress = billToAddress;

            ISubscriptionRequest actual = target.CreateSubscription(subscription);

            Assert.AreEqual(subscription.Amount, actual.Amount);
            Assert.AreEqual(subscription.eCheckBankAccount.accountNumber, actual.eCheckBankAccount.accountNumber);
            Assert.AreEqual(subscription.SubscriptionName, actual.SubscriptionName);

            Assert.IsTrue(actual.SubscriptionID.Trim().Length > 0);
            Assert.IsTrue(0 < long.Parse(actual.SubscriptionID));
        }
示例#24
0
        public void Subscribe(ISubscriptionRequest subscriptionRequest, OnSuccess successCallback, OnFailure failureCallback)
        {
            Handler handler = (Handler) new DefaultHandler();

            this.SendRequest((IRequest)subscriptionRequest, handler, (Session.OnSucessfulRequest)(() => successCallback()), failureCallback);
        }
示例#25
0
        /// <summary>
        /// Tries to enable the auto-trading add-on using an existing credit card from the user
        /// </summary>
        /// <returns></returns>
        private ActionResult TryAddingAutoTradingFromExistingCreditCard()
        {
            User       currentUser          = Authentication.GetCurrentUser();
            CreditCard successfulCreditCard = null;

            foreach (CreditCard card in currentUser.CreditCards)
            {
                try
                {
                    card.Decrypt();
                }
                catch
                {
                    continue;
                }

                successfulCreditCard = card;
                break;
            }

            // If we could not find any credit cards then bail
            if (successfulCreditCard == null)
            {
                return(null);
            }

            SubscriptionType autoTradingAddOn = _database.SubscriptionTypes.Include(st => st.SubscriptionFrequency).Where(st => st.IsAvailableToUsers && st.IsAddOn).FirstOrDefault();

            if (autoTradingAddOn == null)
            {
                return(null);
            }

            ISubscriptionGateway gateway              = GetSubscriptionGateway();
            ISubscriptionRequest subscriptionRequest  = MembersController.CreateAuthorizeDotNetSubscriptionRequest(successfulCreditCard, autoTradingAddOn);
            ISubscriptionRequest subscriptionResponse = null;

            try
            {
                subscriptionResponse = gateway.CreateSubscription(subscriptionRequest);
            }
            catch (InvalidOperationException)
            {
                return(null);
            }

            // Encrypt the credit card information of the user
            successfulCreditCard.Encrypt();

            // Construct a subscription for the user
            Subscription userSubscription = new Subscription()
            {
                ActivationDate             = DateTime.UtcNow,
                AuthorizeNETSubscriptionId = subscriptionResponse.SubscriptionID,
                CancellationDate           = null,
                SubscriptionTypeId         = autoTradingAddOn.SubscriptionTypeId,
                CreditCard = successfulCreditCard
            };

            // Associate the subscription with the user
            currentUser.AddAddOnSubscription(userSubscription);

            _database.SaveChanges();

            return(this.RedirectToAction("Index"));
        }
示例#26
0
        private ISubscriptionRequest CreateAuthorizeDotNetSubscriptionRequest(SubscriptionRegistration registrationInformation, WebSite.Models.User user, DateTime startsOn)
        {
            ISubscriptionRequest subscriptionRequest = SubscriptionRequest.CreateNew();

            // Billing address information
            string countryName = _db.Countries.Find(registrationInformation.CreditCard.BillingAddress.CountryId).Name;

            subscriptionRequest.BillingAddress = new AuthorizeNet.Address()
            {
                City    = registrationInformation.CreditCard.BillingAddress.City,
                Country = countryName,
                First   = registrationInformation.CreditCard.CardholderFirstName,
                Last    = registrationInformation.CreditCard.CardholderLastName,
                Phone   = registrationInformation.CreditCard.BillingAddress.PhoneNumber,
                State   = registrationInformation.CreditCard.BillingAddress.ProvinceOrState,
                Street  =
                    registrationInformation.CreditCard.BillingAddress.AddressLine1 +
                    (!string.IsNullOrEmpty(registrationInformation.CreditCard.BillingAddress.AddressLine2) ?
                     (Environment.NewLine + registrationInformation.CreditCard.BillingAddress.AddressLine2) :
                     string.Empty)
                ,
                Zip = registrationInformation.CreditCard.BillingAddress.PostalCode
            };

            // Subscription information
            SubscriptionType selectedSubscriptionType = registrationInformation.AvailableSubscriptionTypes.First(st => st.SubscriptionTypeId == registrationInformation.SelectedSubscriptionTypeId);

            subscriptionRequest.StartsOn         = startsOn;
            subscriptionRequest.Amount           = selectedSubscriptionType.Price;
            subscriptionRequest.SubscriptionName = selectedSubscriptionType.SubscriptionFrequency.Name + " Membership";

            // Subscription interval
            if (selectedSubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Monthly)
            {
                subscriptionRequest.BillingInterval      = 1;
                subscriptionRequest.BillingIntervalUnits = BillingIntervalUnits.Months;
            }
            else if (selectedSubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Quarterly)
            {
                subscriptionRequest.BillingInterval      = 365 / 4;
                subscriptionRequest.BillingIntervalUnits = BillingIntervalUnits.Days;
            }
            else if (selectedSubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Yearly)
            {
                subscriptionRequest.BillingInterval      = 365;
                subscriptionRequest.BillingIntervalUnits = BillingIntervalUnits.Days;
            }
            else
            {
                // TODO: Log Error! We should never hit this case.
            }

            // Credit card information
            subscriptionRequest.CardCode            = registrationInformation.CreditCard.CVV;
            subscriptionRequest.CardExpirationMonth = registrationInformation.CreditCard.ExpirationMonth;
            subscriptionRequest.CardExpirationYear  = registrationInformation.CreditCard.ExpirationYear;
            subscriptionRequest.CardNumber          = registrationInformation.CreditCard.Number;

            // Customer information
            subscriptionRequest.CustomerEmail = user.EmailAddress;
            subscriptionRequest.CustomerID    = user.UserId.ToString();
            return(subscriptionRequest);
        }
示例#27
0
 public void Subscribe(ISubscriptionRequest subscriptionRequest, OnSuccess successCallback, OnFailure failureCallback)
 {
     DefaultHandler handler = new DefaultHandler();
     SendRequest(subscriptionRequest, handler, delegate() { successCallback(); }, failureCallback);
 }
示例#28
0
        public void Subscribe(ISubscriptionRequest subscriptionRequest, OnSuccess successCallback, OnFailure failureCallback)
        {
            DefaultHandler handler = new DefaultHandler();

            SendRequest(subscriptionRequest, handler, delegate() { successCallback(); }, failureCallback);
        }
        public void PostBack()
        {
            // If the post back is about a recurring payment, it'll have a subscription ID field in the request
            if (string.IsNullOrEmpty(Request.Form["x_subscription_id"]))
            {
                return;
            }

            // We can't handle a request if there is no response code sent to us
            if (string.IsNullOrEmpty(Request.Form["x_response_code"]))
            {
                return;
            }

            // If the payment was successful, we don't really care to do anything
            if (string.CompareOrdinal(Request.Form["x_response_code"], "1") == 0)
            {
                return;
            }

            // For any other response code the payment has failed, we need to set the subscription of the user to suspended and send them an email
            // letting them know something is wrong
            string subscriptionId = Request.Form["x_subscription_id"];

            DatabaseContext db = _database;

            // Load the subscription and figure out which user it belongs to
            Subscription subscription = db.Subscriptions.Include(s => s.CreditCard).FirstOrDefault(s => s.AuthorizeNETSubscriptionId == subscriptionId);

            // Could we successfully load the subscription Authorize.NET is talking about?
            if (subscription == null)
            {
                // TODO: Log Error
                return;
            }

            User affectedUser = (from user in db.Users.Include(u => u.Subscription)
                                 where user.SubscriptionId.HasValue && user.Subscription.SubscriptionId == subscription.SubscriptionId
                                 select user).FirstOrDefault();

            // Could we locate a user with an active subscription?
            if (affectedUser == null)
            {
                // TODO: Log Error
                return;
            }

            bool successfulRenewal = false;

            // Mark the subscription as suspended
            subscription.IsSuspended = true;

            // Check to see whether the card is expired, if so, try to renew the subscription with a new year
            if (subscription.CreditCard.IsExpired())
            {
                // Decrypt to get the card information again
                bool successfulDecryption = true;
                try
                {
                    subscription.CreditCard.Decrypt();
                }
                catch (Exception)
                {
                    successfulDecryption = false;
                }

                if (successfulDecryption)
                {
                    // Bump up the expiry by 2 years
                    CreditCard newCard = new CreditCard()
                    {
                        AddressId           = subscription.CreditCard.AddressId,
                        BillingAddress      = subscription.CreditCard.BillingAddress,
                        CardholderFirstName = subscription.CreditCard.CardholderFirstName,
                        CardholderLastName  = subscription.CreditCard.CardholderLastName,
                        CVV             = subscription.CreditCard.CVV,
                        ExpirationMonth = subscription.CreditCard.ExpirationMonth,
                        ExpirationYear  = (short)(subscription.CreditCard.ExpirationYear + 2),
                        Number          = subscription.CreditCard.Number
                    };

                    ISubscriptionGateway gateway = MembersController.GetSubscriptionGateway();

                    ISubscriptionRequest subscriptionRequest  = MembersController.CreateAuthorizeDotNetSubscriptionRequest(newCard, subscription.SubscriptionType, affectedUser);
                    ISubscriptionRequest subscriptionResponse = null;

                    bool successfulTry = true;

                    try
                    {
                        subscriptionResponse = gateway.CreateSubscription(subscriptionRequest);
                    }
                    catch (InvalidOperationException)
                    {
                        // Payment failed again
                        successfulTry = false;
                    }

                    successfulRenewal = successfulTry;

                    if (successfulTry)
                    {
                        // Encrypt the credit card information of the user
                        newCard.Encrypt();

                        // Construct a subscription for the user
                        Subscription userSubscription = new Subscription()
                        {
                            ActivationDate             = DateTime.UtcNow,
                            AuthorizeNETSubscriptionId = subscriptionResponse.SubscriptionID,
                            CancellationDate           = null,
                            SubscriptionTypeId         = subscription.SubscriptionTypeId,
                            CreditCard = newCard
                        };

                        // Associate the new subscription with the user
                        affectedUser.AddSubscription(userSubscription);
                    }
                }
            }

            db.SaveChanges();

            if (!successfulRenewal)
            {
                // If we could not automatically renew the payment, then notify the user
                EmailResult email = new WebSite.Mailers.Account().PaymentSuspendedEmail(affectedUser);

                WebSite.Helpers.Email.SendEmail(email, new List <Models.User>()
                {
                    affectedUser
                });
            }

            return;
        }