public ActionResult Cancel(int userId)
{
WebSite.Models.User user = _db.Users.Find(userId);
DateTime subscriptionExpiryDate = DateTime.UtcNow;
DateTime cancellationDate = DateTime.UtcNow;
// TODO: Assert the return value
if (user.Subscription != null)
{
// Cancel the subscription at Authorize.NET
ISubscriptionGateway gateway = this.GetSubscriptionGateway();
try
{
gateway.CancelSubscription(user.Subscription.AuthorizeNETSubscriptionId);
}
catch
{
// The subscription may have expired or manually cancelled in which case an exception will be thrown here
}
// Determine the user's last day based on how much they have paid so far
DateTime activationDate = user.Subscription.ActivationDate;
int moduloAmount = 1;
ViewBag.SubscriptionFrequency = user.Subscription.SubscriptionType.SubscriptionFrequency.Name.ToLower();
if (user.Subscription.SubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Monthly)
{
moduloAmount = 30;
}
else if (user.Subscription.SubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Quarterly)
{
moduloAmount = 365 / 4;
}
else if (user.Subscription.SubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Yearly)
{
moduloAmount = 365;
}
else
{
// TODO: Log Error
}
subscriptionExpiryDate = cancellationDate.AddDays(moduloAmount - ((cancellationDate - activationDate).Days % moduloAmount));
// Mark the day the subscription is cancelled
user.Subscription.CancellationDate = cancellationDate;
}
user.SubscriptionExpiryDate = subscriptionExpiryDate;
user.Subscription = null;
_db.SaveChanges();
return(this.RedirectToAction("CancelledMembers"));
}
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));
}
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));
}
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));
}
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());
}
public ActionResult CancelAutoTrading()
{
WebSite.Models.User currentUser = Authentication.GetCurrentUser();
Subscription autoTradingSubscription = currentUser.AutoTradingSubscription;
ISubscriptionGateway gateway = GetSubscriptionGateway();
gateway.CancelSubscription(autoTradingSubscription.AuthorizeNETSubscriptionId);
autoTradingSubscription.CancellationDate = DateTime.UtcNow;
_database.SaveChanges();
return(View());
}
public ActionResult CancelSubscription(CancelSubscription model)
{
// If the user has not provided a reason for cancellation, then don't do anything
if (!ModelState.IsValid)
{
return(this.View(model));
}
WebSite.Models.User currentUser = Authentication.GetCurrentUser();
// Email the admins and let them know the reason
this.EmailAdminsAboutCancellation(model.Reason, currentUser);
// Cancel the subscription at Authorize.NET
ISubscriptionGateway gateway = GetSubscriptionGateway();
// TODO: Assert the return value
gateway.CancelSubscription(currentUser.Subscription.AuthorizeNETSubscriptionId);
// Determine the user's last day based on how much they have paid so far
DateTime subscriptionExpiryDate = DateTime.UtcNow;
DateTime cancellationDate = DateTime.UtcNow;
DateTime activationDate = currentUser.Subscription.ActivationDate;
int moduloAmount = 1;
ViewBag.SubscriptionFrequency = currentUser.Subscription.SubscriptionType.SubscriptionFrequency.Name.ToLower();
if (currentUser.Subscription.SubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Monthly)
{
moduloAmount = 30;
}
else if (currentUser.Subscription.SubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Quarterly)
{
moduloAmount = 365 / 4;
}
else if (currentUser.Subscription.SubscriptionType.SubscriptionFrequency.Name == PredefinedSubscriptionFrequencies.Yearly)
{
moduloAmount = 365;
}
else
{
// TODO: Log Error
}
subscriptionExpiryDate = cancellationDate.AddDays(moduloAmount - ((cancellationDate - activationDate).Days % moduloAmount));
// Mark the cancellation date of the user's subscription
currentUser.Subscription.CancellationDate = DateTime.UtcNow;
currentUser.SubscriptionExpiryDate = subscriptionExpiryDate;
currentUser.Subscription = null;
// Cancel any auto trading if the user has some
Subscription autoTradingSubscription = currentUser.AutoTradingSubscription;
if (autoTradingSubscription != null)
{
gateway.CancelSubscription(autoTradingSubscription.AuthorizeNETSubscriptionId);
autoTradingSubscription.CancellationDate = DateTime.UtcNow;
}
_database.SaveChanges();
ViewBag.SubscriptionExpiryDate = subscriptionExpiryDate.ToLongDateString();
ViewBag.ActivationDate = activationDate.ToLongDateString();
// Mark the subscription as cancelled
model.Cancelled = true;
return(this.View(model));
}
/// <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"));
}
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;
}
