public void Create10000Players()
{
string baseEmail = "*****@*****.**";
string baseUserName = "******";
string basePlayerName = "stressTestPlayer";
CosmoMongerDbDataContext db = CosmoManager.GetDbContext();
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
Race skummRace = (from r in db.Races
where r.Name == "Skumm"
select r).SingleOrDefault();
for (int i = 0; i < 50000; i++)
{
CosmoMongerMembershipUser testUser = (CosmoMongerMembershipUser)provider.CreateUser(i + baseUserName, "test1000", i + baseEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser, "Test User was created. status = {0}", new object[] { status });
User testUserModel = testUser.GetUserModel();
Assert.IsNotNull(testUserModel, "Able to get model object for user");
Player testPlayer = testUserModel.CreatePlayer(i + basePlayerName, skummRace);
foreach (Good good in db.Goods)
{
ShipGood shipGood = new ShipGood();
shipGood.Ship = testPlayer.Ship;
shipGood.Good = good;
shipGood.Quantity = 0;
db.ShipGoods.InsertOnSubmit(shipGood);
}
db.SubmitChanges();
}
}
public void CreatePlayer()
{
CosmoMongerDbDataContext db = CosmoManager.GetDbContext();
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser = (CosmoMongerMembershipUser)provider.CreateUser(this.baseTestUsername, "test1000", this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser, "Test User is created");
Assert.AreEqual(this.baseTestUsername, testUser.UserName, "Test User has correct username");
Assert.AreEqual(this.baseTestEmail, testUser.Email, "Test User has correct e-mail");
testUser = (CosmoMongerMembershipUser)provider.GetUser(this.baseTestUsername, false);
Assert.IsNotNull(testUser, "Test User exists in the database");
Assert.AreEqual(this.baseTestUsername, testUser.UserName, "Test User has correct username");
Assert.AreEqual(this.baseTestEmail, testUser.Email, "Test User has correct e-mail");
Race humanRace = (from r in db.Races
where r.Name == "Human"
select r).SingleOrDefault();
Assert.IsNotNull(humanRace, "Human Race exists in database");
User testUserModel = testUser.GetUserModel();
Assert.IsNotNull(testUserModel, "Able to get model object for user");
Player testPlayer = testUserModel.CreatePlayer(this.baseTestUsername, humanRace);
Assert.IsNotNull(testPlayer, "Test Player is created");
Assert.AreEqual(true, testPlayer.Alive, "Test Player is alive");
Assert.AreEqual(this.baseTestUsername, testPlayer.Name, "Test Player has correct name");
}
/// <summary>
/// Sends the verification code to the users email.
/// </summary>
/// <param name="username">The username to send the verification code for.</param>
/// <returns>The SendVerificationCode view on error, redirects to SendVerificationCodeSuccess on success.</returns>
public ActionResult SendVerificationCode(string username)
{
if (!String.IsNullOrEmpty(username))
{
CosmoMongerMembershipUser verifyUser = (CosmoMongerMembershipUser)this.Provider.GetUser(username, false);
if (verifyUser != null)
{
string baseVerificationUrl = this.Request.Url.GetLeftPart(UriPartial.Authority) + this.Url.Action("VerifyEmail") + "?username="******"&verificationCode=";
try
{
verifyUser.SendVerificationCode(baseVerificationUrl);
return(RedirectToAction("SendVerificationCodeSuccess"));
}
catch (InvalidOperationException ex)
{
// Log this exception
ExceptionPolicy.HandleException(ex, "Controller Policy");
// Failed to send e-mail
ModelState.AddModelError("_FORM", ex.Message);
}
}
else
{
// Username is invalid
ModelState.AddModelError("username", "Invalid username", username);
}
}
// If we got this far, something failed
return(View());
}
public void AddBuddy()
{
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser1 = (CosmoMongerMembershipUser)provider.CreateUser("1" + this.baseTestUsername, "test1000", "1" + this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser1, "Test User 1 was created. status = {0}", new object[] { status });
User testUserModel1 = testUser1.GetUserModel();
Assert.IsNotNull(testUserModel1, "Able to get model object for user 1");
CosmoMongerMembershipUser testUser2 = (CosmoMongerMembershipUser)provider.CreateUser("2" + this.baseTestUsername, "test1000", "2" + this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser2, "Test User 2 was created. status = {0}", new object[] { status });
User testUserModel2 = testUser2.GetUserModel();
Assert.IsNotNull(testUserModel2, "Able to get model object for user 2");
testUserModel1.AddBuddy(testUserModel2);
BuddyList[] buddies = testUserModel1.GetBuddyList();
Assert.That(buddies.Where(b => b.FriendId == testUserModel2.UserId), Is.Not.Empty, "User 2 should be User 1's buddy list now");
}
public void RemoveIgnore()
{
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser1 = (CosmoMongerMembershipUser)provider.CreateUser("1" + this.baseTestUsername, "test1000", "1" + this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser1, "Test User 1 was created. status = {0}", new object[] { status });
User testUserModel1 = testUser1.GetUserModel();
Assert.IsNotNull(testUserModel1, "Able to get model object for user 1");
CosmoMongerMembershipUser testUser2 = (CosmoMongerMembershipUser)provider.CreateUser("2" + this.baseTestUsername, "test1000", "2" + this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser2, "Test User 2 was created. status = {0}", new object[] { status });
User testUserModel2 = testUser2.GetUserModel();
Assert.IsNotNull(testUserModel2, "Able to get model object for user 2");
testUserModel1.AddIgnore(testUserModel2);
testUserModel1.RemoveIgnore(testUserModel2);
IgnoreList[] antiFriends = testUserModel1.GetIgnoreList();
Assert.That(antiFriends, Is.Empty, "User 1's ignore list should be empty");
}
public ActionResult Login(string username, string password, string returnUrl)
{
// Basic parameter validation
if (String.IsNullOrEmpty(username))
{
ModelState.AddModelError("username", "You must specify a username.", username);
}
if (String.IsNullOrEmpty(password))
{
ModelState.AddModelError("password", "You must specify a password.", password);
}
if (ViewData.ModelState.IsValid)
{
// Attempt to login
CosmoMongerMembershipUser user = (CosmoMongerMembershipUser)this.Provider.GetUser(username, true);
if (user != null)
{
bool loginSuccessful = this.Provider.ValidateUser(username, password);
if (loginSuccessful)
{
if (this.Session != null)
{
// Store something in the session to make the SessionID static
this.Session["UserName"] = username;
user.UpdateSession(this.Session.SessionID);
}
return(new FormsLoginResult(username));
}
else if (!user.IsApproved)
{
ModelState.AddModelError("_FORM", "The username provided has not been verified. Check your e-mail for the verification e-mail.");
}
else if (user.IsLockedOut)
{
ModelState.AddModelError("_FORM", "The username provided has been locked. Contact the administrator.");
}
else
{
ModelState.AddModelError("_FORM", "The username or password provided is incorrect.");
}
}
else
{
ModelState.AddModelError("_FORM", "The username provided is incorrect.");
}
}
// If we got this far, something failed, redisplay form
return(View());
}
public void PasswordsAreSalted()
{
Player testPlayer = this.CreateTestPlayer();
User userModel = testPlayer.User;
CosmoMongerMembershipUser user = new CosmoMongerMembershipUser(userModel);
user.ChangePassword("test");
string currentPasswordHash = userModel.Password;
user.ChangePassword("test");
Assert.That(currentPasswordHash, Is.Not.EqualTo(userModel.Password), "Hashes for the same password should not match due to salting.");
}
public void CheckPassword()
{
Player testPlayer = this.CreateTestPlayer();
User userModel = testPlayer.User;
CosmoMongerMembershipUser user = new CosmoMongerMembershipUser(userModel);
user.ChangePassword("test");
// Verify user
Assert.That(user.VerifyEmail(userModel.VerificationCode), Is.True, "User should validate.");
Assert.That(user.ValidatePassword("test"), Is.True, "Password should check to be valid.");
}
public ActionResult ResetPassword(string username, string resetPasswordCode, string newPassword)
{
if (String.IsNullOrEmpty(username))
{
ModelState.AddModelError("username", "Invalid username.", username);
}
if (String.IsNullOrEmpty(resetPasswordCode))
{
ModelState.AddModelError("resetPasswordCode", "Invalid Password Reset Code.", resetPasswordCode);
}
if (ModelState.IsValid)
{
CosmoMongerMembershipUser user = (CosmoMongerMembershipUser)this.Provider.GetUser(username, false);
if (user != null)
{
if (user.CheckResetPasswordCode(resetPasswordCode))
{
newPassword = user.ResetPassword(resetPasswordCode);
if (!String.IsNullOrEmpty(newPassword))
{
// Clear out the reset password code so it cannot be used again
user.ClearResetPasswordCode();
// Display username
ViewData["username"] = username;
// Display new password
ViewData["newPassword"] = newPassword;
return(View("ResetPasswordSuccess"));
}
else
{
ModelState.AddModelError("resetPasswordCode", "Unable to reset password.", resetPasswordCode);
}
}
else
{
ModelState.AddModelError("resetPasswordCode", "Invalid/Expired Password Reset Code.", resetPasswordCode);
}
}
else
{
ModelState.AddModelError("username", "Invalid username.", username);
}
}
return(View("ResetPasswordError"));
}
public void RemoveIgnoreSelf()
{
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser1 = (CosmoMongerMembershipUser)provider.CreateUser("1" + this.baseTestUsername, "test1000", "1" + this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser1, "Test User 1 was created. status = {0}", new object[] { status });
User testUserModel1 = testUser1.GetUserModel();
Assert.IsNotNull(testUserModel1, "Able to get model object for user 1");
testUserModel1.RemoveIgnore(testUserModel1);
}
public ActionResult ForgotPassword(string email)
{
string username = String.Empty;
// Basic parameter validation
if (String.IsNullOrEmpty(email))
{
ModelState.AddModelError("email", "You must specify an email address.", email);
}
else
{
username = this.Provider.GetUserNameByEmail(email);
if (String.IsNullOrEmpty(username))
{
ModelState.AddModelError("email", "No user registered with that email address.", email);
}
}
if (ModelState.IsValid)
{
// Attempt to sent password reset email
try
{
CosmoMongerMembershipUser user = (CosmoMongerMembershipUser)this.Provider.GetUser(username, false);
string basePasswordResetUrl = this.Request.Url.GetLeftPart(UriPartial.Authority) + this.Url.Action("ResetPassword") + "?username="******"&resetPasswordCode=";
if (user != null)
{
user.SendForgotPasswordLink(basePasswordResetUrl);
return(RedirectToAction("ForgotPasswordSuccess"));
}
else
{
ModelState.AddModelError("email", "Unable to lookup user with matching email address.", email);
}
}
catch (ArgumentException ex)
{
// Log this exception
ExceptionPolicy.HandleException(ex, "Controller Policy");
// Display error
ModelState.AddModelError("email", ex.Message, email);
}
}
// If we got this far, something failed, redisplay form
return(View());
}
public void Ban()
{
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser1 = (CosmoMongerMembershipUser)provider.CreateUser("1" + this.baseTestUsername, "test1000", "1" + this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser1, "Test User 1 was created. status = {0}", new object[] { status });
User testUserModel1 = testUser1.GetUserModel();
Assert.IsNotNull(testUserModel1, "Able to get model object for user 1");
testUserModel1.Ban();
Assert.That(testUserModel1.Active, Is.False, "User should now be inactive");
}
private Player CreateTestPlayer(string baseTestUsername, string baseTestEmail, string baseTestPlayerName, Race playerRace)
{
CosmoMongerDbDataContext db = CosmoManager.GetDbContext();
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser = (CosmoMongerMembershipUser)provider.CreateUser(baseTestUsername, "test1000", baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser, "Test User was created. status = {0}", new object[] { status });
User testUserModel = testUser.GetUserModel();
Assert.IsNotNull(testUserModel, "Able to get model object for user");
return(testUserModel.CreatePlayer(baseTestUsername, playerRace));
}
public void DeleteUser()
{
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser = (CosmoMongerMembershipUser)provider.CreateUser(this.baseTestUsername, "test1000", this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser, "Test User was created. status = {0}", new object[] { status });
// Test the deleting of the user
bool deleted = provider.DeleteUser(this.baseTestUsername, true);
Assert.IsTrue(deleted, "The DeleteUser method should have returned true");
testUser = (CosmoMongerMembershipUser)provider.GetUser(this.baseTestUsername, false);
Assert.IsNull(testUser, "Test User has been deleted from the database");
}
/// <summary>
/// This action returns the users email and username to the UserProfile view.
/// </summary>
/// <returns>The UserProfile view</returns>
public ActionResult UserProfile()
{
CosmoMongerMembershipUser user = (CosmoMongerMembershipUser)this.Provider.GetUser(User.Identity.Name, true);
if (user != null)
{
ViewData["Email"] = user.Email;
ViewData["Name"] = user.UserName;
User userModel = user.GetUserModel();
ViewData["JoinDate"] = userModel.Joined;
return(View());
}
// Ran into an error, redirect to login
return(RedirectToAction("Login"));
}
public void UpdateProfile1()
{
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser = (CosmoMongerMembershipUser)provider.CreateUser(this.baseTestUsername, "test1000", this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser, "Test User was created. status = {0}", new object[] { status });
User testUserModel = testUser.GetUserModel();
Assert.IsNotNull(testUserModel, "Able to get model object for user");
// Test the updating of the e-mail
testUserModel.UpdateEmail("1" + this.baseTestEmail);
string usernameWithUpdatedEmail = provider.GetUserNameByEmail("1" + this.baseTestEmail);
Assert.AreEqual(this.baseTestUsername, usernameWithUpdatedEmail, "Test User actually has updated e-mail");
}
/// <summary>
/// Verifies the supplied email address for the supplied username.
/// </summary>
/// <param name="username">The username to verify the email of.</param>
/// <param name="verificationCode">The verification code.</param>
/// <returns>The VerifyEmail View on error, redirects to the VerifyEmailSuccess action if successful.</returns>
public ActionResult VerifyEmail(string username, string verificationCode)
{
CosmoMongerMembershipUser checkUser = (CosmoMongerMembershipUser)this.Provider.GetUser(username, false);
if (checkUser != null)
{
if (checkUser.VerifyEmail(verificationCode))
{
return(RedirectToAction("VerifyEmailSuccess", new RouteValueDictionary(new { email = checkUser.Email })));
}
else
{
ModelState.AddModelError("verificationCode", "Invalid verification code", verificationCode);
}
}
else
{
ModelState.AddModelError("username", "Invalid username", username);
}
return(View());
}
public void DeleteUserLeaveUserData()
{
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser = (CosmoMongerMembershipUser)provider.CreateUser(this.baseTestUsername, "test1000", this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser, "Test User was created. status = {0}", new object[] { status });
try
{
// Test the deleting of the user
provider.DeleteUser(this.baseTestUsername, false);
Assert.Fail("The DeleteUser method should have thrown an exception");
}
catch (ArgumentException ex)
{
Assert.AreEqual("deleteAllRelatedData", ex.ParamName, "Failed argument should be deleteAllRelatedData.");
}
testUser = (CosmoMongerMembershipUser)provider.GetUser(this.baseTestUsername, false);
Assert.IsNotNull(testUser, "Test User should still be in the database");
}
public void SendMessage()
{
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser1 = (CosmoMongerMembershipUser)provider.CreateUser("1" + this.baseTestUsername, "test1000", "1" + this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser1, "Test User 1 was created. status = {0}", new object[] { status });
User testUserModel1 = testUser1.GetUserModel();
Assert.IsNotNull(testUserModel1, "Able to get model object for user 1");
CosmoMongerMembershipUser testUser2 = (CosmoMongerMembershipUser)provider.CreateUser("2" + this.baseTestUsername, "test1000", "2" + this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser2, "Test User 2 was created. status = {0}", new object[] { status });
User testUserModel2 = testUser2.GetUserModel();
Assert.IsNotNull(testUserModel2, "Able to get model object for user 2");
for (int i = 0; i < 10; i++)
{
testUserModel1.SendMessage(testUserModel2, "Test Message", "Hello world!");
}
IEnumerable <Message> messages = testUserModel1.GetUnreadMessages();
foreach (Message msg in messages)
{
Assert.AreEqual(msg.RecipientUserId, testUserModel1.UserId, "Recipient user should match the user the message is stored under");
Assert.AreEqual(msg.SenderUserId, testUserModel2.UserId, "Sender user should match the user the message from");
Assert.AreEqual(msg.Content, "Hello world!", "Message should match what we sent");
Assert.IsFalse(msg.Received, "This message should not be read yet.");
msg.MarkAsReceived();
Assert.IsTrue(msg.Received, "This message should now be read.");
}
}
public void UpdateProfile2()
{
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser = (CosmoMongerMembershipUser)provider.CreateUser(this.baseTestUsername, "test1000", this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser, "Test User was created. status = {0}", new object[] { status });
User testUserModel = testUser.GetUserModel();
Assert.IsNotNull(testUserModel, "Able to get model object for user");
// Change both to something else
testUserModel.UpdateEmail("1" + this.baseTestEmail);
// Test updating with the orignal profile values
testUserModel.UpdateEmail(this.baseTestEmail);
testUser = (CosmoMongerMembershipUser)provider.GetUser(this.baseTestUsername, false);
Assert.IsNotNull(testUser, "Reverted Test User exists in the database");
Assert.AreEqual(this.baseTestUsername, testUser.UserName, "Test User actually has orignal username");
Assert.AreEqual(this.baseTestEmail, testUser.Email, "Test User actually has orignal e-mail");
}
public void AddBuddyTwice()
{
CosmoMongerMembershipProvider provider = new CosmoMongerMembershipProvider();
MembershipCreateStatus status;
CosmoMongerMembershipUser testUser1 = (CosmoMongerMembershipUser)provider.CreateUser("1" + this.baseTestUsername, "test1000", "1" + this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser1, "Test User 1 was created. status = {0}", new object[] { status });
User testUserModel1 = testUser1.GetUserModel();
Assert.IsNotNull(testUserModel1, "Able to get model object for user 1");
CosmoMongerMembershipUser testUser2 = (CosmoMongerMembershipUser)provider.CreateUser("2" + this.baseTestUsername, "test1000", "2" + this.baseTestEmail, null, null, true, null, out status);
Assert.IsNotNull(testUser2, "Test User 2 was created. status = {0}", new object[] { status });
User testUserModel2 = testUser2.GetUserModel();
Assert.IsNotNull(testUserModel2, "Able to get model object for user 2");
testUserModel1.AddBuddy(testUserModel2);
testUserModel1.AddBuddy(testUserModel2);
}
/// <summary>
/// Resets the password.
/// </summary>
/// <param name="username">The username.</param>
/// <param name="resetPasswordCode">The reset password code.</param>
/// <returns>The ResetPassword view when username/resetPasswordCode are valid. ResetPasswordError view when either is invalid.</returns>
public ActionResult ResetPassword(string username, string resetPasswordCode)
{
if (String.IsNullOrEmpty(username))
{
ModelState.AddModelError("username", "Invalid username.", username);
}
if (String.IsNullOrEmpty(resetPasswordCode))
{
ModelState.AddModelError("resetPasswordCode", "Invalid Password Reset Code.", resetPasswordCode);
}
if (ModelState.IsValid)
{
CosmoMongerMembershipUser user = (CosmoMongerMembershipUser)this.Provider.GetUser(username, false);
if (user != null)
{
if (user.CheckResetPasswordCode(resetPasswordCode))
{
// Display the username
ViewData["username"] = username;
return(View());
}
else
{
ModelState.AddModelError("resetPasswordCode", "Invalid/Expired Password Reset Code.", resetPasswordCode);
}
}
else
{
ModelState.AddModelError("username", "Invalid username.", username);
}
}
return(View("ResetPasswordError"));
}
public ActionResult Register(string username, string email, string password, string confirmPassword)
{
// Basic parameter validation
if (String.IsNullOrEmpty(username))
{
ModelState.AddModelError("username", "You must specify a username.", username);
}
if (String.IsNullOrEmpty(email))
{
ModelState.AddModelError("email", "You must specify an email address.", email);
}
if (password == null || password.Length < this.Provider.MinRequiredPasswordLength)
{
string passwordError = String.Format(CultureInfo.CurrentCulture, "You must specify a new password of {0} or more characters.", this.Provider.MinRequiredPasswordLength);
ModelState.AddModelError("password", passwordError, password);
}
if (!String.Equals(password, confirmPassword, StringComparison.Ordinal))
{
ModelState.AddModelError("_FORM", "The new password and confirmation password do not match.");
}
// We don't check the captcha if running localhost and no challenge was given
if (this.Request.UserHostAddress == "127.0.0.1" && this.Request.Form["recaptcha_challenge_field"] != null)
{
// Check the captcha response
RecaptchaValidator humanValidator = new RecaptchaValidator();
humanValidator.PrivateKey = ConfigurationManager.AppSettings["RecaptchaPrivateKey"];
humanValidator.RemoteIP = this.Request.UserHostAddress;
humanValidator.Challenge = this.Request.Form["recaptcha_challenge_field"];
humanValidator.Response = this.Request.Form["recaptcha_response_field"];
RecaptchaResponse humanResponse = humanValidator.Validate();
if (!humanResponse.IsValid)
{
Dictionary <string, object> props = new Dictionary <string, object>
{
{ "PrivateKey", humanValidator.PrivateKey },
{ "RemoteIP", humanValidator.RemoteIP },
{ "Challenge", humanValidator.Challenge },
{ "Response", humanValidator.Response },
{ "IsValid", humanResponse.IsValid },
{ "ErrorCode", humanResponse.ErrorCode }
};
Logger.Write("Failed reCAPTCHA attempt", "Controller", 200, 0, TraceEventType.Verbose, "Failed reCAPTCHA attempt", props);
ModelState.AddModelError("recaptcha", "reCAPTCHA failed to verify", humanValidator.Response);
}
}
if (ViewData.ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus;
CosmoMongerMembershipUser newUser = (CosmoMongerMembershipUser)this.Provider.CreateUser(username, password, email, null, null, false, null, out createStatus);
if (newUser != null)
{
return(RedirectToAction("SendVerificationCode", new RouteValueDictionary(new { username = username })));
}
else
{
ModelState.AddModelError("_FORM", ErrorCodeToString(createStatus));
}
}
// If we got this far, something failed, redisplay form
return(View());
}
