private void SetupViewBagForIndex(WebSite.Models.User user)
{
ViewBag.SavedSuccessfully = false;
ViewBag.IsTrialMember = !user.SubscriptionId.HasValue && !user.SubscriptionExpiryDate.HasValue;
ViewBag.IsUsingCancelledSubscription = !user.SubscriptionId.HasValue && user.SubscriptionExpiryDate.HasValue;
ViewBag.IsUsingSuspendedSubscription = user.SubscriptionId.HasValue && user.Subscription.IsSuspended;
ViewBag.HasAutoTrading = user.AutoTradingSubscriptionId.HasValue && !user.AutoTradingSubscription.CancellationDate.HasValue;
if (ViewBag.IsTrialMember)
{
ViewBag.TrialDaysLeft = (user.TrialExpiryDate - DateTime.UtcNow).Days;
ViewBag.IsTrialExpired = ViewBag.TrialDaysLeft <= 0;
}
else
{
if (user.SubscriptionId.HasValue)
{
ViewBag.SubscriptionStartDate = user.Subscription.ActivationDate;
ViewBag.SubscriptionPrice = user.Subscription.SubscriptionType.Price;
ViewBag.SubscriptionFrequency = user.Subscription.SubscriptionType.SubscriptionFrequency.Name.ToLower();
}
else if (user.SubscriptionExpiryDate.HasValue)
{
ViewBag.SubscriptionExpiryDate = user.SubscriptionExpiryDate.Value.ToLongDateString();
ViewBag.CancelledSubscriptionIsExpired = user.SubscriptionExpiryDate.Value < DateTime.UtcNow;
}
}
}
public ActionResult Index()
{
WebSite.Models.User currentUser = Authentication.GetCurrentUser();
this.SetupViewBagForIndex(currentUser);
return(View(currentUser.NotificationSettings));
}
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 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());
}
private void EmailAdminsAboutCancellation(string cancellationReason, WebSite.Models.User user)
{
IEmailFactory emailFactory = System.Web.Mvc.DependencyResolver.Current.GetService(typeof(IEmailFactory)) as IEmailFactory;
// Create the email
StringBuilder builder = new StringBuilder();
builder.Append("<html><head></head><body><!-- BODY START --><p>A user has cancelled their subscription. <br/> First Name: ");
builder.Append(user.FirstName);
builder.Append("<br/>Last Name: ");
builder.Append(user.LastName);
builder.Append("<br/>Email: ");
builder.Append(user.EmailAddress);
builder.Append("</p><p>Reason: <br/>");
builder.Append(cancellationReason);
builder.Append("</p><!-- BODY END --></body></html>");
// Send the email now
emailFactory.CreateEmailForAdministrators(builder.ToString(), "Account Cancellation").Send();
}
public ActionResult Index(NotificationSettings notificationSettings)
{
WebSite.Models.User currentUser = Authentication.GetCurrentUser();
this.SetupViewBagForIndex(currentUser);
if (ModelState.IsValid)
{
NotificationSettings currentSettings = currentUser.NotificationSettings;
currentSettings.ReceiveDailyAlerts = notificationSettings.ReceiveDailyAlerts;
currentSettings.ReceiveGeneralAnnouncements = notificationSettings.ReceiveGeneralAnnouncements;
currentSettings.ReceiveOptionPicks = notificationSettings.ReceiveOptionPicks;
currentSettings.ReceiveStockPicks = notificationSettings.ReceiveStockPicks;
_database.SaveChanges();
ViewBag.SavedSuccessfully = true;
}
return(View(currentUser.NotificationSettings));
}
public ActionResult Login(string returnUrl)
{
ViewBag.ReturnUrl = returnUrl;
WebSite.Models.User user = Authentication.GetCurrentUserEagerlyLoaded();
if (user != null)
{
if (user.SubscriptionId.HasValue)
{
// The user has a subscription, are they routed to the login page because they have a suspended subscription?
ViewBag.HasSuspendedSubscription = user.Subscription.IsSuspended;
}
else
{
// The user does not have a subscription, are they routed to this page because they have an expired trial membership?
ViewBag.TrialExpired = !user.IsTrialValid();
}
}
return(View());
}
public static bool UserCreate(RegisterViewModel model,ref string role)
{
if (model.Login == "admin123")
role = "admin";
else role = "user";
if (MailMessanger.SendMessage("*****@*****.**", model.Email, "*****@*****.**","V80984342375"))
{
MD5 md5 = new MD5CryptoServiceProvider();
string pass = model.Password;
byte[] checkSum = md5.ComputeHash(Encoding.UTF8.GetBytes(pass));
string result = BitConverter.ToString(checkSum).Replace("-", String.Empty);
var user = new User() { FullName = model.SecondName+" "+model.FirstName+" "+model.ThirdName
, HashPassword = result
, Login = model.Login
, Role = role
, Email = model.Email ,
LastDate=DateTime.Now
};
using (DatabaseContext db = new DatabaseContext())
{
db.Users.Add(user);
db.SaveChanges();
db.Profiles.Add(new Profile() {
Id = user.Id, FirstName = model.FirstName,
SecondName = model.SecondName,
ThirdName = model.ThirdName,
Date=model.Date,
Gender=model.Gender,
AvatarPath = "/Images/noavatar.png"
});
db.SaveChanges();
}
return true;
}
else
{
return false;
}
}
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);
}
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));
}
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);
}
