public void Subscription_Can_Reactivate_With_Trial()
{
// Arrange
var trialingProduct = Chargify.GetProductList().Values.FirstOrDefault(p => p.TrialInterval > 0);
var referenceId = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes(Faker.Name.First(), Faker.Name.Last(), Faker.Internet.Email(), Faker.Phone.Number(), Faker.Company.Name(), referenceId);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
var createdSubscription = Chargify.CreateSubscription(trialingProduct.Handle, newCustomer, newPaymentInfo);
Assert.IsNotNull(createdSubscription);
var deletedSubscription = Chargify.DeleteSubscription(createdSubscription.SubscriptionID, "Delete for test Subscription_Can_Reactivate_With_Trial");
Assert.IsNotNull(deletedSubscription);
var foundSubscription = Chargify.Find <Subscription>(createdSubscription.SubscriptionID);
Assert.IsTrue(foundSubscription.State == SubscriptionState.Canceled, "Expected cancelled subscription on a trial product");
// Act
var result = Chargify.ReactivateSubscription(foundSubscription.SubscriptionID, true, null, null);
// Assert
Assert.IsNotNull(result);
#if !NUNIT
Assert.IsInstanceOfType(result, typeof(ISubscription));
#endif
Assert.IsTrue(result.State != foundSubscription.State);
Assert.IsTrue(result.State == SubscriptionState.Trialing);
}
public void Can_Create_Invoice_Subscription()
{
// Arrange
var product = Chargify.GetProductList().Values.DefaultIfEmpty(null).FirstOrDefault(p => p.PriceInCents > 0 && p.RequireCreditCard == false);
if (product == null) { Assert.Inconclusive("No product to test"); return; }
var referenceID = Guid.NewGuid().ToString();
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "123-456-7890", "Chargify", referenceID);
// Act
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, PaymentCollectionMethod.Invoice);
// Assert
//Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.FirstName == newCustomer.FirstName);
Assert.IsTrue(newSubscription.Customer.LastName == newCustomer.LastName);
Assert.IsTrue(newSubscription.Customer.Email == newCustomer.Email);
Assert.IsTrue(newSubscription.Customer.Phone == newCustomer.Phone);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceID);
Assert.IsTrue(newSubscription.ProductPriceInCents == product.PriceInCents);
Assert.IsTrue(newSubscription.ProductPrice == product.Price);
Assert.IsTrue(newSubscription.PaymentCollectionMethod == PaymentCollectionMethod.Invoice);
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
public void Subscription_Reactivation()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceID = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "123-456-7890", "Chargify", referenceID);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
// Act
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo);
var result = Chargify.DeleteSubscription(newSubscription.SubscriptionID, "testing");
var foundSubscription = Chargify.Find <Subscription>(newSubscription.SubscriptionID);
var resultSubscription = Chargify.ReactivateSubscription(foundSubscription.SubscriptionID);
// Assert
#if !NUNIT
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
Assert.IsInstanceOfType(foundSubscription, typeof(Subscription));
Assert.IsInstanceOfType(resultSubscription, typeof(Subscription));
#endif
Assert.IsNotNull(newSubscription);
Assert.IsTrue(result);
Assert.IsNotNull(foundSubscription);
Assert.IsTrue(foundSubscription.State == SubscriptionState.Canceled);
Assert.IsNotNull(newSubscription);
Assert.IsTrue(resultSubscription.State == SubscriptionState.Active);
}
public void Subscription_Can_Reactivate_Without_Trial()
{
// Arrange
var trialingProduct = Chargify.GetProductList().Values.FirstOrDefault(p => p.TrialInterval > 0);
var referenceID = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "123-456-7890", "Chargify", referenceID);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
var createdSubscription = Chargify.CreateSubscription(trialingProduct.Handle, newCustomer, newPaymentInfo);
Assert.IsNotNull(createdSubscription);
var deletedSubscription = Chargify.DeleteSubscription(createdSubscription.SubscriptionID, "Delete for test Subscription_Can_Reactivate_With_Trial");
Assert.IsNotNull(deletedSubscription);
var foundSubscription = Chargify.Find <Subscription>(createdSubscription.SubscriptionID);
Assert.IsTrue(foundSubscription.State == SubscriptionState.Canceled, "Expected cancelled subscription on a trial product");
// Act
var result = Chargify.ReactivateSubscription(foundSubscription.SubscriptionID, false);
// Assert
Assert.IsNotNull(result);
#if !NUNIT
Assert.IsInstanceOfType(result, typeof(ISubscription));
#endif
Assert.IsTrue(result.State != foundSubscription.State);
Assert.IsTrue(result.State == SubscriptionState.Active);
}
public void Can_Create_Invoice_Subscription()
{
// Arrange
var product = Chargify.GetProductList().Values.DefaultIfEmpty(null).FirstOrDefault(p => p.PriceInCents > 0 && p.RequireCreditCard == false);
if (product == null)
{
Assert.Inconclusive("No product to test"); return;
}
var referenceID = Guid.NewGuid().ToString();
var newCustomer = new CustomerAttributes(Faker.Name.First(), Faker.Name.Last(), Faker.Internet.Email(), Faker.Phone.Number(), Faker.Company.Name(), referenceID);
// Act
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, PaymentCollectionMethod.Invoice);
// Assert
//Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.FirstName == newCustomer.FirstName);
Assert.IsTrue(newSubscription.Customer.LastName == newCustomer.LastName);
Assert.IsTrue(newSubscription.Customer.Email == newCustomer.Email);
Assert.IsTrue(newSubscription.Customer.Phone == newCustomer.Phone);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceID);
Assert.IsTrue(newSubscription.ProductPriceInCents == product.PriceInCents);
Assert.IsTrue(newSubscription.ProductPrice == product.Price);
Assert.IsTrue(newSubscription.PaymentCollectionMethod == PaymentCollectionMethod.Invoice);
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
public void Subscription_Reactivation()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceId = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes(Faker.Name.First(), Faker.Name.Last(), Faker.Internet.Email(), Faker.Phone.Number(), Faker.Company.Name(), referenceId);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
// Act
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo);
var result = Chargify.DeleteSubscription(newSubscription.SubscriptionID, "testing");
var foundSubscription = Chargify.Find <Subscription>(newSubscription.SubscriptionID);
var resultSubscription = Chargify.ReactivateSubscription(foundSubscription.SubscriptionID);
// Assert
#if !NUNIT
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
Assert.IsInstanceOfType(foundSubscription, typeof(Subscription));
Assert.IsInstanceOfType(resultSubscription, typeof(Subscription));
#endif
Assert.IsNotNull(newSubscription);
Assert.IsTrue(result);
Assert.IsNotNull(foundSubscription);
Assert.IsTrue(foundSubscription.State == SubscriptionState.Canceled);
Assert.IsNotNull(newSubscription);
Assert.IsTrue(resultSubscription.State == SubscriptionState.Active);
}
public void Subscription_Create()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceId = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes(Faker.Name.First(), Faker.Name.Last(), Faker.Internet.Email(), Faker.Phone.Number(), Faker.Company.Name(), referenceId);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
// Act
string data = string.Empty;
Chargify.LogRequest = (requestMethod, address, postedData) => {
data = postedData;
};
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo);
// Assert
#if !NUNIT
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
#endif
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNotNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.AreEqual(newCustomer.FirstName, newSubscription.Customer.FirstName);
Assert.AreEqual(newCustomer.LastName, newSubscription.Customer.LastName);
Assert.AreEqual(newCustomer.Email, newSubscription.Customer.Email);
Assert.AreEqual(newCustomer.Phone, newSubscription.Customer.Phone);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceId);
Assert.IsTrue(newSubscription.PaymentProfile.FirstName == newPaymentInfo.FirstName);
Assert.IsTrue(newSubscription.PaymentProfile.LastName == newPaymentInfo.LastName);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationMonth == newPaymentInfo.ExpirationMonth);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationYear == newPaymentInfo.ExpirationYear);
Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress == newPaymentInfo.BillingAddress);
//Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress2 == newPaymentInfo.BillingAddress2);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCity == newPaymentInfo.BillingCity);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCountry == newPaymentInfo.BillingCountry);
Assert.IsTrue(newSubscription.PaymentProfile.BillingState == newPaymentInfo.BillingState);
Assert.IsTrue(newSubscription.PaymentProfile.BillingZip == newPaymentInfo.BillingZip);
Assert.IsTrue(newSubscription.ProductPriceInCents == product.PriceInCents);
Assert.IsTrue(newSubscription.ProductPrice == product.Price);
Assert.AreEqual(product.TrialInterval > 0 ? SubscriptionState.Trialing : SubscriptionState.Active, newSubscription.State);
if (Chargify.UseJSON)
{
Assert.AreEqual(true, data.IsJSON());
Assert.AreEqual(false, data.IsXml());
}
else
{
Assert.AreEqual(true, data.IsXml());
Assert.AreEqual(false, data.IsJSON());
}
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
public void Subscription_Create_IsFullNumberMasked()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceId = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes(Faker.Name.FirstName(), Faker.Name.LastName(), Faker.Internet.Email(), Faker.Phone.PhoneNumber(), Faker.Company.CompanyName(), referenceId);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
newPaymentInfo.FullNumber = "4444444444444444";
// Act
try
{
string data = string.Empty;
Chargify.LogRequest = (requestMethod, address, postedData) =>
{
data = postedData;
};
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo);
Assert.Fail("Subscription should not have been created, since credit card number is not 1, 2 or 3 ending");
}
catch (ChargifyException chEx)
{
Assert.IsFalse(chEx.LastDataPosted.Contains(newPaymentInfo.FullNumber), chEx.LastDataPosted);
Assert.IsTrue(chEx.LastDataPosted.Contains(newPaymentInfo.FullNumber.Mask('X', 4)));
}
}
public void Subscription_Create_WithCouponAfterSignup()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "Chargify", Guid.NewGuid().ToString());
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
const string couponCode = "68C8FDBA";
// Act
var createdSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo);
// Assert
Assert.IsNotNull(createdSubscription);
#if !NUNIT
Assert.IsInstanceOfType(createdSubscription, typeof(ISubscription));
#endif
Assert.IsTrue(createdSubscription.CouponCode == string.Empty);
// Act Again
var updatedSubscription = Chargify.AddCoupon(createdSubscription.SubscriptionID, couponCode);
// Assert Again
Assert.IsNotNull(updatedSubscription);
#if !NUNIT
Assert.IsInstanceOfType(updatedSubscription, typeof(ISubscription));
#endif
Assert.IsTrue(updatedSubscription.CouponCode == couponCode);
}
public void Subscription_Create_WithCouponAfterSignup()
{
// Arrange
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "Chargify", Guid.NewGuid().ToString());
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
// Act
var createdSubscription = Chargify.CreateSubscription("premium", newCustomer, newPaymentInfo);
// Assert
Assert.IsNotNull(createdSubscription);
#if !NUNIT
Assert.IsInstanceOfType(createdSubscription, typeof(ISubscription));
#endif
Assert.IsTrue(createdSubscription.CouponCode == string.Empty);
// Act Again
var updatedSubscription = Chargify.AddCoupon(createdSubscription.SubscriptionID, "AC511");
// Assert Again
Assert.IsNotNull(updatedSubscription);
#if !NUNIT
Assert.IsInstanceOfType(updatedSubscription, typeof(ISubscription));
#endif
Assert.IsTrue(updatedSubscription.CouponCode == "AC511");
}
public void Subscription_Can_Reactivate_Without_Trial()
{
// Arrange
var trialingProduct = Chargify.GetProductList().Values.FirstOrDefault(p => p.TrialInterval > 0);
var referenceID = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "123-456-7890", "Chargify", referenceID);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
var createdSubscription = Chargify.CreateSubscription(trialingProduct.Handle, newCustomer, newPaymentInfo);
Assert.IsNotNull(createdSubscription);
var deletedSubscription = Chargify.DeleteSubscription(createdSubscription.SubscriptionID, "Delete for test Subscription_Can_Reactivate_With_Trial");
Assert.IsNotNull(deletedSubscription);
var foundSubscription = Chargify.Find<Subscription>(createdSubscription.SubscriptionID);
Assert.IsTrue(foundSubscription.State == SubscriptionState.Canceled, "Expected cancelled subscription on a trial product");
// Act
var result = Chargify.ReactivateSubscription(foundSubscription.SubscriptionID, false);
// Assert
Assert.IsNotNull(result);
#if !NUNIT
Assert.IsInstanceOfType(result, typeof(ISubscription));
#endif
Assert.IsTrue(result.State != foundSubscription.State);
Assert.IsTrue(result.State == SubscriptionState.Active);
}
public void Subscription_Create_WithTwoComponents()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceID = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "Chargify", referenceID);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
Dictionary <int, string> componentsToUse = new Dictionary <int, string>()
{
{ 998, "5" },
{ 6776, "1" }
};
// Act
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo, componentsToUse);
var subComponents = Chargify.GetComponentsForSubscription(newSubscription.SubscriptionID);
var usedComponents = from c in subComponents
where componentsToUse.ContainsKey(c.Value.ComponentID)
select c;
// Assert
#if !NUNIT
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
#endif
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNotNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.FirstName == newCustomer.FirstName);
Assert.IsTrue(newSubscription.Customer.LastName == newCustomer.LastName);
Assert.IsTrue(newSubscription.Customer.Email == newCustomer.Email);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceID);
Assert.IsTrue(newSubscription.PaymentProfile.FirstName == newPaymentInfo.FirstName);
Assert.IsTrue(newSubscription.PaymentProfile.LastName == newPaymentInfo.LastName);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationMonth == newPaymentInfo.ExpirationMonth);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationYear == newPaymentInfo.ExpirationYear);
Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress == newPaymentInfo.BillingAddress);
//Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress2 == newPaymentInfo.BillingAddress2);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCity == newPaymentInfo.BillingCity);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCountry == newPaymentInfo.BillingCountry);
Assert.IsTrue(newSubscription.PaymentProfile.BillingState == newPaymentInfo.BillingState);
Assert.IsTrue(newSubscription.PaymentProfile.BillingZip == newPaymentInfo.BillingZip);
Assert.IsTrue(usedComponents.Count() == 2);
Assert.IsTrue(usedComponents.FirstOrDefault().Value.AllocatedQuantity == 5);
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
public void Subscription_Create_WithTwoComponents()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceId = Guid.NewGuid().ToString();
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "Chargify", referenceId);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
var components = Chargify.GetComponentsForProductFamily(product.ProductFamily.ID);
var componentsToUse = components.Take(2).ToDictionary(v => v.Key, v => "1");
// Act
Assert.IsNotNull(product, "Product couldn't be found");
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo, componentsToUse);
var subComponents = Chargify.GetComponentsForSubscription(newSubscription.SubscriptionID);
var usedComponents = from c in subComponents
where componentsToUse.ContainsKey(c.Value.ComponentID)
select c;
// Assert
#if !NUNIT
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
#endif
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNotNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.FirstName == newCustomer.FirstName);
Assert.IsTrue(newSubscription.Customer.LastName == newCustomer.LastName);
Assert.IsTrue(newSubscription.Customer.Email == newCustomer.Email);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceId);
Assert.IsTrue(newSubscription.PaymentProfile.FirstName == newPaymentInfo.FirstName);
Assert.IsTrue(newSubscription.PaymentProfile.LastName == newPaymentInfo.LastName);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationMonth == newPaymentInfo.ExpirationMonth);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationYear == newPaymentInfo.ExpirationYear);
Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress == newPaymentInfo.BillingAddress);
//Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress2 == newPaymentInfo.BillingAddress2);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCity == newPaymentInfo.BillingCity);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCountry == newPaymentInfo.BillingCountry);
Assert.IsTrue(newSubscription.PaymentProfile.BillingState == newPaymentInfo.BillingState);
Assert.IsTrue(newSubscription.PaymentProfile.BillingZip == newPaymentInfo.BillingZip);
Assert.IsTrue(usedComponents.Count() == componentsToUse.Count);
foreach (var component in usedComponents)
{
Assert.IsTrue(componentsToUse.ContainsKey(component.Key));
//Assert.AreEqual(decimal.Parse(componentsToUse[component.Key]), component.Value.AllocatedQuantity);
}
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
public void Subscription_Create_WithComponent()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var productFamily = Chargify.GetProductFamilyList().Values.FirstOrDefault();
var referenceId = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "Chargify", referenceId);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
var component = Chargify.GetComponentsForProductFamily(productFamily.ID).FirstOrDefault(d => d.Value.Kind == ComponentType.Quantity_Based_Component && d.Value.Prices.Any(p => p.UnitPrice > 0m)).Value;
Assert.IsNotNull(component, "Couldn't find any usable component.");
// Act
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo, component.ID, 5);
var subComponents = Chargify.GetComponentsForSubscription(newSubscription.SubscriptionID);
var usedComponents = from c in subComponents
where c.Value.ComponentID == component.ID
select c;
// Assert
#if !NUNIT
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
#endif
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNotNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.FirstName == newCustomer.FirstName);
Assert.IsTrue(newSubscription.Customer.LastName == newCustomer.LastName);
Assert.IsTrue(newSubscription.Customer.Email == newCustomer.Email);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceId);
Assert.IsTrue(newSubscription.PaymentProfile.FirstName == newPaymentInfo.FirstName);
Assert.IsTrue(newSubscription.PaymentProfile.LastName == newPaymentInfo.LastName);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationMonth == newPaymentInfo.ExpirationMonth);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationYear == newPaymentInfo.ExpirationYear);
Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress == newPaymentInfo.BillingAddress);
//Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress2 == newPaymentInfo.BillingAddress2);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCity == newPaymentInfo.BillingCity);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCountry == newPaymentInfo.BillingCountry);
Assert.IsTrue(newSubscription.PaymentProfile.BillingState == newPaymentInfo.BillingState);
Assert.IsTrue(newSubscription.PaymentProfile.BillingZip == newPaymentInfo.BillingZip);
Assert.IsTrue(usedComponents.Count() == 1);
Assert.IsTrue(usedComponents.FirstOrDefault().Value.AllocatedQuantity == 5);
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
public void DoSampleCode()
{
ChargifyConnect chargify = new ChargifyConnect();
chargify.apiKey = ConfigurationManager.AppSettings["CHARGIFY_API_KEY"];
chargify.Password = ConfigurationManager.AppSettings["CHARGIFY_API_PASSWORD"];
chargify.URL = ConfigurationManager.AppSettings["CHARGIFY_URL"];
chargify.UseJSON = true;
// This could perhaps be read from the gateway?
ICustomerAttributes charlie = new CustomerAttributes("Charlie", "Guy", "*****@*****.**", "YourCompany", Guid.NewGuid().ToString());
// This as well, I'm assuming ...
IPaymentProfileAttributes existingProfile = new PaymentProfileAttributes("12345", "67890", VaultType.AuthorizeNET, 2020, 12, CardType.Visa, "1111");
// Now create the subscription importing from the vault
ISubscription charlieSubscription = chargify.CreateSubscription("basic", charlie, DateTime.Now, existingProfile);
}
public void DoSampleCode()
{
ChargifyConnect chargify = new ChargifyConnect();
chargify.apiKey = ConfigurationManager.AppSettings["CHARGIFY_API_KEY"];
chargify.Password = ConfigurationManager.AppSettings["CHARGIFY_API_PASSWORD"];
chargify.URL = ConfigurationManager.AppSettings["CHARGIFY_URL"];
chargify.UseJSON = true;
// This could perhaps be read from the gateway?
ICustomerAttributes charlie = new CustomerAttributes("Charlie", "Guy", "*****@*****.**", "YourCompany", Guid.NewGuid().ToString());
// This as well, I'm assuming ...
IPaymentProfileAttributes existingProfile = new PaymentProfileAttributes("12345", "67890", VaultType.AuthorizeNET, 2020, 12, CardType.Visa, "1111");
// Now create the subscription importing from the vault
ISubscription charlieSubscription = chargify.CreateSubscription("basic", charlie, DateTime.Now, existingProfile);
}
public void Subscription_Create_With_SpecialChars()
{
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceId = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes("Scott!", "Pilgrim@", "*****@*****.**", "+1 (123) 456-7890", "@Chargify#$%^&@", referenceId);
newCustomer.ShippingAddress = @"123 Main St.*()-=_+`~";
newCustomer.ShippingCity = @"Kingston{}[]|;':";
newCustomer.ShippingState = @"ON<>,.?/";
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
// Act
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo);
// Assert
#if !NUNIT
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
#endif
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNotNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.FirstName == newCustomer.FirstName);
Assert.IsTrue(newSubscription.Customer.LastName == newCustomer.LastName);
Assert.IsTrue(newSubscription.Customer.Email == newCustomer.Email);
Assert.IsTrue(newSubscription.Customer.Phone == newCustomer.Phone);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceId);
Assert.IsTrue(newSubscription.PaymentProfile.FirstName == newPaymentInfo.FirstName);
Assert.IsTrue(newSubscription.PaymentProfile.LastName == newPaymentInfo.LastName);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationMonth == newPaymentInfo.ExpirationMonth);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationYear == newPaymentInfo.ExpirationYear);
Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress == newPaymentInfo.BillingAddress);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCity == newPaymentInfo.BillingCity);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCountry == newPaymentInfo.BillingCountry);
Assert.IsTrue(newSubscription.PaymentProfile.BillingState == newPaymentInfo.BillingState);
Assert.IsTrue(newSubscription.PaymentProfile.BillingZip == newPaymentInfo.BillingZip);
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
private CreditCardAttributes GetTestPaymentMethod(CustomerAttributes customer)
{
var retVal = new CreditCardAttributes()
{
FirstName = customer.FirstName,
LastName = customer.LastName,
ExpirationMonth = 1,
ExpirationYear = 2020,
FullNumber = "1",
CVV = "123",
BillingAddress = "123 Main St.",
BillingCity = "New York",
BillingCountry = "US",
BillingState = "New York",
BillingZip = "10001"
};
return(retVal);
}
public void Subscription_Can_Be_Purged()
{
// Arrange
var trialingProduct = Chargify.GetProductList().Values.FirstOrDefault(p => p.TrialInterval > 0);
var referenceId = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes(Faker.Name.FirstName(), Faker.Name.LastName(), Faker.Internet.Email(), Faker.Phone.PhoneNumber(), Faker.Company.CompanyName(), referenceId);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
var createdSubscription = Chargify.CreateSubscription(trialingProduct.Handle, newCustomer, newPaymentInfo);
Assert.IsNotNull(createdSubscription);
Chargify.PurgeSubscription(createdSubscription.SubscriptionID);
var purgedSubscription = Chargify.Find <Subscription>(createdSubscription.SubscriptionID);
Assert.IsNull(purgedSubscription);
}
private CreditCardAttributes GetTestPaymentMethod(CustomerAttributes customer)
{
var retVal = new CreditCardAttributes()
{
FirstName = customer.FirstName,
LastName = customer.LastName,
ExpirationMonth = 1,
ExpirationYear = 2020,
FullNumber = "1",
CVV = "123",
BillingAddress = Faker.Address.StreetAddress(false),
BillingCity = Faker.Address.City(),
BillingCountry = "US",
BillingState = Faker.Address.StateAbbr(),
BillingZip = Faker.Address.ZipCode()
};
return(retVal);
}
public ISubscription SubscribeChargifyTrial(Lead leadDto)
{
string subscriptionType = "trial";
//// This determines if the _CreditCard partial gets rendered
IProduct productResult = (from a in Chargify.GetProductList().Values
where a.Handle == subscriptionType
select a).SingleOrDefault();
if (productResult == null)
{
return(null);
}
ICustomer customerResult = (from c in Chargify.GetCustomerList().Values
where c.Email == leadDto.Email
select c).FirstOrDefault();
if (customerResult == null)
{
// Now that the user is created, attempt to create the corresponding subscription
CustomerAttributes cInfo = new CustomerAttributes();
cInfo.FirstName = leadDto.FirstName;
cInfo.LastName = leadDto.LastName;
cInfo.Email = leadDto.Email;
cInfo.SystemID = Guid.NewGuid().ToString(); ///Convert.ToInt32(Session["userId"]).ToString();
ISubscription newSubscription = Chargify.CreateSubscription(subscriptionType, cInfo);
return(newSubscription); //newSubscription.Customer.ChargifyID.ToString() + "," + newSubscription.SubscriptionID.ToString();
}
else
{
// Will be used to test suscription type
//ISubscription subscriptionResult = (from s in Chargify.GetSubscriptionList().Values
// where s.Customer.ChargifyID == customerResult.ChargifyID
// select s).FirstOrDefault();
ISubscription newSubscription = Chargify.CreateSubscription(subscriptionType, customerResult.ChargifyID);
return(newSubscription);//customerResult.ChargifyID.ToString() + "," + newSubscription.SubscriptionID.ToString(); ;
}
}
public void Subscription_Create()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceID = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "123-456-7890", "Chargify", referenceID);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
// Act
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo);
// Assert
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNotNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.FirstName == newCustomer.FirstName);
Assert.IsTrue(newSubscription.Customer.LastName == newCustomer.LastName);
Assert.IsTrue(newSubscription.Customer.Email == newCustomer.Email);
Assert.IsTrue(newSubscription.Customer.Phone == newCustomer.Phone);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceID);
Assert.IsTrue(newSubscription.PaymentProfile.FirstName == newPaymentInfo.FirstName);
Assert.IsTrue(newSubscription.PaymentProfile.LastName == newPaymentInfo.LastName);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationMonth == newPaymentInfo.ExpirationMonth);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationYear == newPaymentInfo.ExpirationYear);
Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress == newPaymentInfo.BillingAddress);
//Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress2 == newPaymentInfo.BillingAddress2);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCity == newPaymentInfo.BillingCity);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCountry == newPaymentInfo.BillingCountry);
Assert.IsTrue(newSubscription.PaymentProfile.BillingState == newPaymentInfo.BillingState);
Assert.IsTrue(newSubscription.PaymentProfile.BillingZip == newPaymentInfo.BillingZip);
Assert.IsTrue(newSubscription.ProductPriceInCents == product.PriceInCents);
Assert.IsTrue(newSubscription.ProductPrice == product.Price);
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
public void Components_Create_Subscription_Multiple_Components()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
Assert.IsNotNull(product, "Product couldn't be found");
var referenceId = Guid.NewGuid().ToString();
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "Chargify", referenceId);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
// Find components that allow for a simple allocated_quantity = 1 to work for this simple test
var components = Chargify.GetComponentsForProductFamily(product.ProductFamily.ID).Values.Where(c => c.Kind == ComponentType.Quantity_Based_Component || c.Kind == ComponentType.On_Off_Component);
var componentsToUse = components.Take(2).ToList();
var options = new SubscriptionCreateOptions()
{
CustomerAttributes = newCustomer,
CreditCardAttributes = newPaymentInfo,
ProductHandle = product.Handle,
Components = new System.Collections.Generic.List <ComponentDetails>
{
new ComponentDetails()
{
ComponentID = componentsToUse.First().ID, AllocatedQuantity = 1
},
new ComponentDetails()
{
ComponentID = componentsToUse.Last().ID, AllocatedQuantity = 1
}
}
};
// Act
var newSubscription = Chargify.CreateSubscription(options);
var subComponents = Chargify.GetComponentsForSubscription(newSubscription.SubscriptionID);
var usedComponents = from c in subComponents
where componentsToUse.Any(x => x.ID == c.Value.ComponentID)
select c;
// Assert
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNotNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.FirstName == newCustomer.FirstName);
Assert.IsTrue(newSubscription.Customer.LastName == newCustomer.LastName);
Assert.IsTrue(newSubscription.Customer.Email == newCustomer.Email);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceId);
Assert.IsTrue(newSubscription.PaymentProfile.FirstName == newPaymentInfo.FirstName);
Assert.IsTrue(newSubscription.PaymentProfile.LastName == newPaymentInfo.LastName);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationMonth == newPaymentInfo.ExpirationMonth);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationYear == newPaymentInfo.ExpirationYear);
Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress == newPaymentInfo.BillingAddress);
//Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress2 == newPaymentInfo.BillingAddress2);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCity == newPaymentInfo.BillingCity);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCountry == newPaymentInfo.BillingCountry);
Assert.IsTrue(newSubscription.PaymentProfile.BillingState == newPaymentInfo.BillingState);
Assert.IsTrue(newSubscription.PaymentProfile.BillingZip == newPaymentInfo.BillingZip);
Assert.IsTrue(usedComponents.Count() == componentsToUse.Count);
foreach (var component in usedComponents)
{
Assert.IsTrue(componentsToUse.Any(x => x.ID == component.Key));
//Assert.AreEqual(decimal.Parse(componentsToUse[component.Key]), component.Value.AllocatedQuantity);
}
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
public void DoSampleCode()
{
ChargifyConnect chargify = new ChargifyConnect();
chargify.apiKey = ConfigurationManager.AppSettings["CHARGIFY_API_KEY"];
chargify.Password = ConfigurationManager.AppSettings["CHARGIFY_API_PASSWORD"];
chargify.URL = ConfigurationManager.AppSettings["CHARGIFY_URL"];
// Create a new customer and a subscription for him
ICustomerAttributes scottPilgrim = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "Chargify", Guid.NewGuid().ToString());
ICreditCardAttributes scottsPaymentInfo = new CreditCardAttributes();
scottsPaymentInfo.FirstName = scottPilgrim.FirstName;
scottsPaymentInfo.LastName = scottPilgrim.LastName;
scottsPaymentInfo.ExpirationMonth = 1;
scottsPaymentInfo.ExpirationYear = 2020;
scottsPaymentInfo.FullNumber = "1";
scottsPaymentInfo.CVV = "123";
scottsPaymentInfo.BillingAddress = "123 Main St.";
scottsPaymentInfo.BillingCity = "New York";
scottsPaymentInfo.BillingCountry = "US";
scottsPaymentInfo.BillingState = "New York";
scottsPaymentInfo.BillingZip = "10001";
ISubscription newSubscription = chargify.CreateSubscription("basic", scottPilgrim, scottsPaymentInfo);
if (newSubscription != null)
{
// subscription success.
Console.WriteLine("Subscription succeeded.");
}
else
{
// subscription failure.
Console.WriteLine("Update customer failed with response: ", chargify.LastResponse.ToString());
}
ICharge oneTimeChargeResults = chargify.CreateCharge(newSubscription.SubscriptionID, 123.45m, "Testing One-Time Charge");
if (oneTimeChargeResults != null)
{
// one-time charge success.
Console.WriteLine(string.Format("Charge succeeded: {0}", oneTimeChargeResults.Success.ToString()));
}
else
{
// one time charge failure.
Console.WriteLine("One-time charge failed with response: ", chargify.LastResponse.ToString());
}
IDictionary <int, ITransaction> transactions = chargify.GetTransactionsForSubscription(newSubscription.SubscriptionID, new List <TransactionType>()
{
TransactionType.Payment
});
// Grab the last payment transaction, which we will refund (will be the one-time charge we just assessed)
ITransaction firstTransaction = transactions.First().Value;
IRefund chargeRefund = chargify.CreateRefund(newSubscription.SubscriptionID, firstTransaction.ID, firstTransaction.AmountInCents, "Test Refund");
if (chargeRefund != null)
{
Console.WriteLine("Refund was: " + (chargeRefund.Success ? "successful" : "unsuccessful"));
}
bool result = chargify.DeleteSubscription(newSubscription.SubscriptionID, "Testing Reactivation");
if (result)
{
ISubscription reactivatedSubscription = chargify.ReactivateSubscription(newSubscription.SubscriptionID);
if (reactivatedSubscription != null)
{
Console.WriteLine("Reactivation succeeded!");
}
else
{
Console.WriteLine("Reactivation failed with response: ", chargify.LastResponse.ToString());
}
// Currently a bug if you say "true" for the last two parameters. Being worked on.
reactivatedSubscription = chargify.MigrateSubscriptionProduct(reactivatedSubscription.SubscriptionID, "ultimate", true, true);
if (reactivatedSubscription != null)
{
Console.WriteLine("Migration succeeded!");
}
else
{
}
}
else
{
Console.WriteLine("Cancellation failed with response: ", chargify.LastResponse.ToString());
}
//IDictionary<int, ITransaction> transactions = chargify.GetTransactionsForSubscription(newSubscription.SubscriptionID);
//if ((transactions != null) && (transactions.Count > 0))
//{
// foreach (ITransaction transaction in transactions.Values)
// {
// Console.WriteLine(string.Format("Date: {0}, Who: {1}, Type: {2}, Memo: {3}, Amount: {4}", transaction.CreatedAt, transaction.SubscriptionID, transaction.ProductID, transaction.Memo, transaction.Amount));
// }
//}
}
public ActionResult Local(LocalSignup model, string id)
{
try
{
if (ModelState.IsValid)
{
// Attempt to register the user
Guid userId = Guid.NewGuid();
var newUser = WebSecurity.CreateUserAndAccount(model.User.UserName, model.User.Password, new { Email = model.UserContact.EmailAddress, UserId = userId });
if (newUser != null)
{
if (!Roles.RoleExists("user"))
{
Roles.CreateRole("user");
}
Roles.AddUsersToRoles(new string[] { model.User.UserName }, new string[] { "User" });
// Now that the user is created, attempt to create the corresponding subscription
var customerInfo = new CustomerAttributes()
{
FirstName = model.UserContact.FirstName,
LastName = model.UserContact.LastName,
Email = model.UserContact.EmailAddress,
SystemID = userId.ToString()
};
var paymentAttributes = new CreditCardAttributes()
{
FullNumber = model.UserPayment.CardNumber.Trim(),
CVV = model.UserPayment.CVV,
ExpirationMonth = model.UserPayment.ExpirationMonth,
ExpirationYear = model.UserPayment.ExpirationYear,
BillingAddress = model.UserAddress.Address,
BillingCity = model.UserAddress.City,
BillingZip = model.UserAddress.Zip,
BillingState = model.UserAddress.State,
BillingCountry = model.UserAddress.Country
};
try
{
var newSubscription = Chargify.CreateSubscription(id, customerInfo, paymentAttributes);
WebSecurity.Login(model.User.UserName, model.User.Password, false);
return RedirectToAction("Index", "Site");
}
catch (ChargifyException ex)
{
if (ex.ErrorMessages.Count > 0)
{
ModelState.AddModelError("", ex.ErrorMessages.FirstOrDefault().Message);
}
else
{
ModelState.AddModelError("", ex.ToString());
}
}
}
else
{
//ModelState.AddModelError("", AccountValidation.ErrorCodeToString(createStatus));
}
}
return RedirectToAction("Index");
}
catch
{
return View();
}
}
private CreditCardAttributes GetTestPaymentMethod(CustomerAttributes customer)
{
var retVal = new CreditCardAttributes()
{
FirstName = customer.FirstName,
LastName = customer.LastName,
ExpirationMonth = 1,
ExpirationYear = 2020,
FullNumber = "1",
CVV = "123",
BillingAddress = "123 Main St.",
BillingCity = "New York",
BillingCountry = "US",
BillingState = "New York",
BillingZip = "10001"
};
return retVal;
}
public ActionResult Subscribe(string id, LocalSubscriptionViewModel model)
{
// if (ModelState.IsValid)
//{
// Attempt to register the user
//MembershipCreateStatus createStatus;
//MembershipUser user = MembershipService.CreateUser(model.Username, model.Password, model.Email, model.Question, model.Answer, out createStatus);
//if (createStatus == MembershipCreateStatus.Success)
if (true)
{
//if (!RoleService.RoleExists("user"))
//{
// RoleService.CreateRole("user");
//}
//RoleService.AddUsersToRoles(new string[] { user.UserName }, new string[] { "User" });
// Now that the user is created, attempt to create the corresponding subscription
CustomerAttributes cInfo = new CustomerAttributes();
cInfo.FirstName = model.FirstName;
cInfo.LastName = model.LastName;
cInfo.Email = model.Email;
cInfo.SystemID = Guid.NewGuid().ToString(); ///Convert.ToInt32(Session["userId"]).ToString();
if (Convert.ToBoolean(Session["RequireCreditCard"]))
{
CreditCardAttributes ccAttr = new CreditCardAttributes();
ccAttr.FullNumber = model.CardNumber.Trim();
ccAttr.CVV = model.CVV;
ccAttr.ExpirationMonth = model.ExpMonth;
ccAttr.ExpirationYear = model.ExpYear;
ccAttr.BillingAddress = model.Address;
ccAttr.BillingCity = model.City;
ccAttr.BillingZip = model.PostalCode;
ccAttr.BillingState = model.Province;
ccAttr.BillingCountry = "CA";
ISubscription newSubscription = Chargify.CreateSubscription(id, cInfo, ccAttr);
}
else
{
ISubscription newSubscription = Chargify.CreateSubscription(id, cInfo);
}
try
{
//FormsService.SignIn(model.Username, false /* createPersistentCookie */);
return(RedirectToAction("Index", "Chargify"));
}
catch (ChargifyException ex)
{
if (ex.ErrorMessages.Count > 0)
{
ModelState.AddModelError("", ex.ErrorMessages.FirstOrDefault().Message);
}
else
{
ModelState.AddModelError("", ex.ToString());
}
}
}
else
{
//ModelState.AddModelError("", AccountValidation.ErrorCodeToString(createStatus));
}
return(RedirectToAction("Subscribe"));
}
public void Subscription_Create_With_SpecialChars()
{
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceID = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes("Scott!", "Pilgrim@", "*****@*****.**", "+1 (123) 456-7890", "@Chargify#$%^&@", referenceID);
newCustomer.ShippingAddress = @"123 Main St.*()-=_+`~";
newCustomer.ShippingCity = @"Kingston{}[]|;':";
newCustomer.ShippingState = @"ON<>,.?/";
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
// Act
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo);
// Assert
#if !NUNIT
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
#endif
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNotNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.FirstName == newCustomer.FirstName);
Assert.IsTrue(newSubscription.Customer.LastName == newCustomer.LastName);
Assert.IsTrue(newSubscription.Customer.Email == newCustomer.Email);
Assert.IsTrue(newSubscription.Customer.Phone == newCustomer.Phone);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceID);
Assert.IsTrue(newSubscription.PaymentProfile.FirstName == newPaymentInfo.FirstName);
Assert.IsTrue(newSubscription.PaymentProfile.LastName == newPaymentInfo.LastName);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationMonth == newPaymentInfo.ExpirationMonth);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationYear == newPaymentInfo.ExpirationYear);
Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress == newPaymentInfo.BillingAddress);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCity == newPaymentInfo.BillingCity);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCountry == newPaymentInfo.BillingCountry);
Assert.IsTrue(newSubscription.PaymentProfile.BillingState == newPaymentInfo.BillingState);
Assert.IsTrue(newSubscription.PaymentProfile.BillingZip == newPaymentInfo.BillingZip);
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
public void Subscription_Reactivation()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceID = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "123-456-7890", "Chargify", referenceID);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
// Act
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo);
var result = Chargify.DeleteSubscription(newSubscription.SubscriptionID, "testing");
var foundSubscription = Chargify.Find<Subscription>(newSubscription.SubscriptionID);
var resultSubscription = Chargify.ReactivateSubscription(foundSubscription.SubscriptionID);
// Assert
#if !NUNIT
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
Assert.IsInstanceOfType(foundSubscription, typeof(Subscription));
Assert.IsInstanceOfType(resultSubscription, typeof(Subscription));
#endif
Assert.IsNotNull(newSubscription);
Assert.IsTrue(result);
Assert.IsNotNull(foundSubscription);
Assert.IsTrue(foundSubscription.State == SubscriptionState.Canceled);
Assert.IsNotNull(newSubscription);
Assert.IsTrue(resultSubscription.State == SubscriptionState.Active);
}
public void Subscription_Create_WithCouponAfterSignup()
{
// Arrange
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "Chargify", Guid.NewGuid().ToString());
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
// Act
var createdSubscription = Chargify.CreateSubscription("premium", newCustomer, newPaymentInfo);
// Assert
Assert.IsNotNull(createdSubscription);
#if !NUNIT
Assert.IsInstanceOfType(createdSubscription, typeof(ISubscription));
#endif
Assert.IsTrue(createdSubscription.CouponCode == string.Empty);
// Act Again
var updatedSubscription = Chargify.AddCoupon(createdSubscription.SubscriptionID, "AC511");
// Assert Again
Assert.IsNotNull(updatedSubscription);
#if !NUNIT
Assert.IsInstanceOfType(updatedSubscription, typeof(ISubscription));
#endif
Assert.IsTrue(updatedSubscription.CouponCode == "AC511");
}
public void Subscription_Create_WithTwoComponents()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceID = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "Chargify", referenceID);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
Dictionary<int, string> componentsToUse = new Dictionary<int, string>()
{
{998, "5"},
{6776, "1"}
};
// Act
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo, componentsToUse);
var subComponents = Chargify.GetComponentsForSubscription(newSubscription.SubscriptionID);
var usedComponents = from c in subComponents
where componentsToUse.ContainsKey(c.Value.ComponentID)
select c;
// Assert
#if !NUNIT
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
#endif
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNotNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.FirstName == newCustomer.FirstName);
Assert.IsTrue(newSubscription.Customer.LastName == newCustomer.LastName);
Assert.IsTrue(newSubscription.Customer.Email == newCustomer.Email);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceID);
Assert.IsTrue(newSubscription.PaymentProfile.FirstName == newPaymentInfo.FirstName);
Assert.IsTrue(newSubscription.PaymentProfile.LastName == newPaymentInfo.LastName);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationMonth == newPaymentInfo.ExpirationMonth);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationYear == newPaymentInfo.ExpirationYear);
Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress == newPaymentInfo.BillingAddress);
//Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress2 == newPaymentInfo.BillingAddress2);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCity == newPaymentInfo.BillingCity);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCountry == newPaymentInfo.BillingCountry);
Assert.IsTrue(newSubscription.PaymentProfile.BillingState == newPaymentInfo.BillingState);
Assert.IsTrue(newSubscription.PaymentProfile.BillingZip == newPaymentInfo.BillingZip);
Assert.IsTrue(usedComponents.Count() == 2);
Assert.IsTrue(usedComponents.FirstOrDefault().Value.AllocatedQuantity == 5);
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
public void Subscription_Create()
{
// Arrange
var product = Chargify.GetProductList().Values.FirstOrDefault();
var referenceID = Guid.NewGuid().ToString();
var expMonth = DateTime.Now.AddMonths(1).Month;
var expYear = DateTime.Now.AddMonths(12).Year;
var newCustomer = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "123-456-7890", "Chargify", referenceID);
var newPaymentInfo = GetTestPaymentMethod(newCustomer);
// Act
string data = string.Empty;
Chargify.LogRequest = (requestMethod, address, postedData) => {
data = postedData;
};
var newSubscription = Chargify.CreateSubscription(product.Handle, newCustomer, newPaymentInfo);
// Assert
#if !NUNIT
Assert.IsInstanceOfType(newSubscription, typeof(Subscription));
#endif
Assert.IsNotNull(newSubscription);
Assert.IsNotNull(newSubscription.Customer);
Assert.IsNotNull(newSubscription.PaymentProfile);
Assert.IsTrue(newSubscription.SubscriptionID > int.MinValue);
Assert.IsTrue(newSubscription.Customer.ChargifyID > int.MinValue);
Assert.AreEqual(newCustomer.FirstName, newSubscription.Customer.FirstName);
Assert.AreEqual(newCustomer.LastName, newSubscription.Customer.LastName);
Assert.AreEqual(newCustomer.Email, newSubscription.Customer.Email);
Assert.AreEqual(newCustomer.Phone, newSubscription.Customer.Phone);
Assert.IsTrue(newSubscription.Customer.Organization == newCustomer.Organization);
Assert.IsTrue(newSubscription.Customer.SystemID == referenceID);
Assert.IsTrue(newSubscription.PaymentProfile.FirstName == newPaymentInfo.FirstName);
Assert.IsTrue(newSubscription.PaymentProfile.LastName == newPaymentInfo.LastName);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationMonth == newPaymentInfo.ExpirationMonth);
Assert.IsTrue(newSubscription.PaymentProfile.ExpirationYear == newPaymentInfo.ExpirationYear);
Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress == newPaymentInfo.BillingAddress);
//Assert.IsTrue(newSubscription.PaymentProfile.BillingAddress2 == newPaymentInfo.BillingAddress2);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCity == newPaymentInfo.BillingCity);
Assert.IsTrue(newSubscription.PaymentProfile.BillingCountry == newPaymentInfo.BillingCountry);
Assert.IsTrue(newSubscription.PaymentProfile.BillingState == newPaymentInfo.BillingState);
Assert.IsTrue(newSubscription.PaymentProfile.BillingZip == newPaymentInfo.BillingZip);
Assert.IsTrue(newSubscription.ProductPriceInCents == product.PriceInCents);
Assert.IsTrue(newSubscription.ProductPrice == product.Price);
Assert.AreEqual(product.TrialInterval > int.MinValue ? SubscriptionState.Trialing : SubscriptionState.Active, newSubscription.State);
Assert.AreEqual(Chargify.UseJSON, Chargify.UseJSON ? data.IsJSON() : data.IsXml());
// Cleanup
Assert.IsTrue(Chargify.DeleteSubscription(newSubscription.SubscriptionID, "Automatic cancel due to test"));
}
public void DoSampleCode()
{
ChargifyConnect chargify = new ChargifyConnect();
chargify.apiKey = ConfigurationManager.AppSettings["CHARGIFY_API_KEY"];
chargify.Password = ConfigurationManager.AppSettings["CHARGIFY_API_PASSWORD"];
chargify.URL = ConfigurationManager.AppSettings["CHARGIFY_URL"];
// Create a new customer and a subscription for him
ICustomerAttributes scottPilgrim = new CustomerAttributes("Scott", "Pilgrim", "*****@*****.**", "Chargify", Guid.NewGuid().ToString());
ICreditCardAttributes scottsPaymentInfo = new CreditCardAttributes();
scottsPaymentInfo.FirstName = scottPilgrim.FirstName;
scottsPaymentInfo.LastName = scottPilgrim.LastName;
scottsPaymentInfo.ExpirationMonth = 1;
scottsPaymentInfo.ExpirationYear = 2020;
scottsPaymentInfo.FullNumber = "1";
scottsPaymentInfo.CVV = "123";
scottsPaymentInfo.BillingAddress = "123 Main St.";
scottsPaymentInfo.BillingCity = "New York";
scottsPaymentInfo.BillingCountry = "US";
scottsPaymentInfo.BillingState = "New York";
scottsPaymentInfo.BillingZip = "10001";
ISubscription newSubscription = chargify.CreateSubscription("basic", scottPilgrim, scottsPaymentInfo);
if (newSubscription != null)
{
// subscription success.
Console.WriteLine("Subscription succeeded.");
}
else
{
// subscription failure.
Console.WriteLine("Update customer failed with response: ", chargify.LastResponse.ToString());
}
ICharge oneTimeChargeResults = chargify.CreateCharge(newSubscription.SubscriptionID, 123.45m, "Testing One-Time Charge");
if (oneTimeChargeResults != null)
{
// one-time charge success.
Console.WriteLine(string.Format("Charge succeeded: {0}", oneTimeChargeResults.Success.ToString()));
}
else
{
// one time charge failure.
Console.WriteLine("One-time charge failed with response: ", chargify.LastResponse.ToString());
}
IDictionary<int, ITransaction> transactions = chargify.GetTransactionsForSubscription(newSubscription.SubscriptionID, new List<TransactionType>() { TransactionType.Payment });
// Grab the last payment transaction, which we will refund (will be the one-time charge we just assessed)
ITransaction firstTransaction = transactions.First().Value;
IRefund chargeRefund = chargify.CreateRefund(newSubscription.SubscriptionID, firstTransaction.ID, firstTransaction.AmountInCents, "Test Refund");
if (chargeRefund != null)
{
Console.WriteLine("Refund was: " + (chargeRefund.Success ? "successful" : "unsuccessful"));
}
bool result = chargify.DeleteSubscription(newSubscription.SubscriptionID, "Testing Reactivation");
if (result)
{
ISubscription reactivatedSubscription = chargify.ReactivateSubscription(newSubscription.SubscriptionID);
if (reactivatedSubscription != null)
{
Console.WriteLine("Reactivation succeeded!");
}
else
{
Console.WriteLine("Reactivation failed with response: ", chargify.LastResponse.ToString());
}
// Currently a bug if you say "true" for the last two parameters. Being worked on.
reactivatedSubscription = chargify.MigrateSubscriptionProduct(reactivatedSubscription.SubscriptionID, "ultimate", true, true);
if (reactivatedSubscription != null)
{
Console.WriteLine("Migration succeeded!");
}
else
{
}
}
else
{
Console.WriteLine("Cancellation failed with response: ", chargify.LastResponse.ToString());
}
//IDictionary<int, ITransaction> transactions = chargify.GetTransactionsForSubscription(newSubscription.SubscriptionID);
//if ((transactions != null) && (transactions.Count > 0))
//{
// foreach (ITransaction transaction in transactions.Values)
// {
// Console.WriteLine(string.Format("Date: {0}, Who: {1}, Type: {2}, Memo: {3}, Amount: {4}", transaction.CreatedAt, transaction.SubscriptionID, transaction.ProductID, transaction.Memo, transaction.Amount));
// }
//}
}
public ActionResult Subscribe(TestProject.Models.Subscribe subscribe, string confirmKey)
{
ChargifyConnect chargify = ChargifyTools.Chargify;
string plan = subscribe.plan;
bool isCredit = subscribe.hasCreditCard || subscribe.creditcard.requireCredit;//ChargifyTools.RequireCreditCard(subscribe.plan);
try
{
if (ChargifyTools.IsChargifyProduct(subscribe.plan))
{
ViewBag.confirmKey = confirmKey;
ViewBag.plan = subscribe.plan;
if (ValidatePassword(subscribe.password) == false)
{
//ViewBag.contactGenderId = new SelectList(db.contactGender.ToList(), "contactGenderId", "name");
ViewBag.Message = "Error password, you need a format that contains capital letters and numbers, example: Michael7.";
ViewBag.plan = subscribe.plan;
return(View(subscribe));
}
userLogin user = new userLogin();
contact cont = new contact();
tenant tnt = new tenant();
//----------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------
tnt.tenantSubscriptionPlanId = (from pl in db.tenantSubscriptionPlan
where pl.code.ToLower().Equals(plan.ToLower())
select pl.tenantSubscriptionPlanId).FirstOrDefault();
tnt.active = true;
tnt.allocatedUsers = 1; //cantidad de usuarios asignados
tnt.billingRefNumber = Guid.NewGuid().ToString();
tnt.companyName = subscribe.company;
tnt.companyURL = "N/A";
tnt.database = "TestProject";
tnt.tenantStatusId = 2;
tnt.tenantSourceId = 2;
if (isCredit)
{
tnt.tenentBillingTypeId = 1;
}
else
{
tnt.tenentBillingTypeId = 2;
}
/****** Valores quemados de campos auditoria*****/
tnt.updatedById = 0;
tnt.createdById = TntIdTestProject; // Id tenant TestProject
tnt.modifyDateTime = new DateTime(1900, 1, 1, 0, 0, 0);
tnt.insertDateTime = DateTime.Now;
/****** Valores quemados de campos auditoria*****/
db.tenant.Add(tnt);
db.SaveChanges();
var city = db.genCity
.Include(x => x.genState.genContry)
.SingleOrDefault(x => x.genCityId == Convert.ToInt32(subscribe.genCityId));
if (isCredit)
{
contactPhone phone = new contactPhone
{
active = true,
number = subscribe.phoneNumber,
contactId = cont.contactId,
contactPhoneTypeId = 1,
tenantId = tnt.tenantId,
updatedById = 0,
createdById = TntIdTestProject, // Id tenant TestProject
modifyDateTime = new DateTime(1900, 1, 1, 0, 0, 0),
insertDateTime = DateTime.Now
};
db.contactPhone.Add(phone);
db.SaveChanges();
cont.preferredBillAddressId = address.contactAddressId;
cont.preferredPhoneId = phone.contactPhoneId;
db.Entry(cont).State = EntityState.Modified;
db.SaveChanges();
}
/*** cosas de chargify!!!*/
CustomerAttributes customerInformation = new CustomerAttributes();
customerInformation.FirstName = subscribe.firstName;
customerInformation.LastName = subscribe.lastName;
customerInformation.Organization = subscribe.company;
customerInformation.Email = subscribe.email;
// Create a new guid, this would be the Membership UserID if we were creating a new user simultaneously
customerInformation.SystemID = tnt.billingRefNumber;
ISubscription newSubscription = null;
string productHandle = plan;
if (isCredit)
{
CreditCardAttributes creditCardInfo = new CreditCardAttributes();
creditCardInfo.FullNumber = subscribe.creditcard.creditCardNumber;
creditCardInfo.CVV = subscribe.creditcard.cvv;
creditCardInfo.ExpirationMonth = subscribe.creditcard.ExpireMonth;
creditCardInfo.ExpirationYear = subscribe.creditcard.ExpireYear;
creditCardInfo.BillingAddress = subscribe.street;
creditCardInfo.BillingCity = city.City;//subscribe.city;
creditCardInfo.BillingState = city.genState.State;
creditCardInfo.BillingZip = subscribe.postalCode;
creditCardInfo.BillingCountry = city.genState.genContry.contry;
newSubscription = chargify.CreateSubscription(productHandle, customerInformation, creditCardInfo);
}
else
{
newSubscription = chargify.CreateSubscription(productHandle, customerInformation);
}
}
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
System.Diagnostics.Debug.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
System.Diagnostics.Debug.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
catch (Exception e)
{
return(View(subscribe));
}
return(View(subscribe));
}
public ActionResult Local(LocalSignup model, string id)
{
try
{
if (ModelState.IsValid)
{
// Attempt to register the user
Guid userId = Guid.NewGuid();
var newUser = WebSecurity.CreateUserAndAccount(model.User.UserName, model.User.Password, new { Email = model.UserContact.EmailAddress, UserId = userId });
if (newUser != null)
{
if (!Roles.RoleExists("user"))
{
Roles.CreateRole("user");
}
Roles.AddUsersToRoles(new string[] { model.User.UserName }, new string[] { "User" });
// Now that the user is created, attempt to create the corresponding subscription
var customerInfo = new CustomerAttributes()
{
FirstName = model.UserContact.FirstName,
LastName = model.UserContact.LastName,
Email = model.UserContact.EmailAddress,
SystemID = userId.ToString()
};
var paymentAttributes = new CreditCardAttributes()
{
FullNumber = model.UserPayment.CardNumber.Trim(),
CVV = model.UserPayment.CVV,
ExpirationMonth = model.UserPayment.ExpirationMonth,
ExpirationYear = model.UserPayment.ExpirationYear,
BillingAddress = model.UserAddress.Address,
BillingCity = model.UserAddress.City,
BillingZip = model.UserAddress.Zip,
BillingState = model.UserAddress.State,
BillingCountry = model.UserAddress.Country
};
try
{
var newSubscription = Chargify.CreateSubscription(id, customerInfo, paymentAttributes);
WebSecurity.Login(model.User.UserName, model.User.Password, false);
return(RedirectToAction("Index", "Site"));
}
catch (ChargifyException ex)
{
if (ex.ErrorMessages.Count > 0)
{
ModelState.AddModelError("", ex.ErrorMessages.FirstOrDefault().Message);
}
else
{
ModelState.AddModelError("", ex.ToString());
}
}
}
else
{
//ModelState.AddModelError("", AccountValidation.ErrorCodeToString(createStatus));
}
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Subscribe(string id, LocalSubscriptionViewModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus;
MembershipUser user = MembershipService.CreateUser(model.Username, model.Password, model.Email, model.Question, model.Answer, out createStatus);
if (createStatus == MembershipCreateStatus.Success)
{
if (!RoleService.RoleExists("user")) {
RoleService.CreateRole("user");
}
RoleService.AddUsersToRoles(new string[] {user.UserName }, new string[] {"User"});
// Now that the user is created, attempt to create the corresponding subscription
CustomerAttributes cInfo = new CustomerAttributes();
cInfo.FirstName = model.FirstName;
cInfo.LastName = model.LastName;
cInfo.Email = model.Email;
cInfo.SystemID = user.ProviderUserKey.ToString();
CreditCardAttributes ccAttr = new CreditCardAttributes();
ccAttr.FullNumber = model.CardNumber.Trim();
ccAttr.CVV = model.CVV;
ccAttr.ExpirationMonth = model.ExpMonth;
ccAttr.ExpirationYear = model.ExpYear;
ccAttr.BillingAddress = model.Address;
ccAttr.BillingCity = model.City;
ccAttr.BillingZip = model.PostalCode;
ccAttr.BillingState = model.Province;
ccAttr.BillingCountry = "CA";
try
{
ISubscription newSubscription = Chargify.CreateSubscription(id, cInfo, ccAttr);
FormsService.SignIn(model.Username, false /* createPersistentCookie */);
return RedirectToAction("Index", "Site");
}
catch (ChargifyException ex)
{
if (ex.ErrorMessages.Count > 0)
{
ModelState.AddModelError("", ex.ErrorMessages.FirstOrDefault().Message);
}
else
{
ModelState.AddModelError("", ex.ToString());
}
}
}
else
{
ModelState.AddModelError("", AccountValidation.ErrorCodeToString(createStatus));
}
return RedirectToAction("Subscribe");
}
else
{
return RedirectToAction("Subscribe", new { id = id });
}
}
