//
// GET: /Manage/ManageLogins
public async Task <ActionResult> ManageLogins(ManageMessageId?message)
{
ViewBag.StatusMessage =
message == ManageMessageId.RemoveLoginSuccess
? "The external login was removed."
: message == ManageMessageId.Error
? "An error has occurred."
: "";
SchedulerUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user == null)
{
return(View("Error"));
}
IList <UserLoginInfo> userLogins = await UserManager.GetLoginsAsync(User.Identity.GetUserId());
List <AuthenticationDescription> otherLogins =
AuthenticationManager.GetExternalAuthenticationTypes()
.Where(auth => userLogins.All(ul => auth.AuthenticationType != ul.LoginProvider))
.ToList();
ViewBag.ShowRemoveButton = user.PasswordHash != null || userLogins.Count > 1;
return(View(new ManageLoginsViewModel
{
CurrentLogins = userLogins,
OtherLogins = otherLogins
}));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
//Lowercase for email and username. TitleCase for first and last names.
TextInfo caseSwitch = new CultureInfo("en-US", false).TextInfo;
var user = new SchedulerUser
{
UserName = Input.Email.ToLower(),
Email = Input.Email.ToLower(),
FirstName = caseSwitch.ToTitleCase(Input.FirstName.ToLower()),
LastName = caseSwitch.ToTitleCase(Input.LastName.ToLower())
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
await _userManager.AddClaimAsync(user, new Claim("FirstName", user.FirstName));
await _userManager.AddClaimAsync(user, new Claim("LastName", user.LastName));
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
private bool HasPhoneNumber()
{
SchedulerUser user = UserManager.FindById(User.Identity.GetUserId());
if (user != null)
{
return(user.PhoneNumber != null);
}
return(false);
}
private bool HasPassword()
{
SchedulerUser user = UserManager.FindById(User.Identity.GetUserId());
if (user != null)
{
return(user.PasswordHash != null);
}
return(false);
}
public async Task <ActionResult> DisableTwoFactorAuthentication()
{
await UserManager.SetTwoFactorEnabledAsync(User.Identity.GetUserId(), false);
SchedulerUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, false, false);
}
return(RedirectToAction("Index", "Manage"));
}
private async Task LoadAsync(SchedulerUser user)
{
var userName = await _userManager.GetUserNameAsync(user);
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
Username = userName;
Input = new InputModel
{
PhoneNumber = phoneNumber
};
}
private async Task LoadAsync(SchedulerUser user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = email,
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
//
// GET: /Manage/RemovePhoneNumber
public async Task <ActionResult> RemovePhoneNumber()
{
IdentityResult result = await UserManager.SetPhoneNumberAsync(User.Identity.GetUserId(), null);
if (!result.Succeeded)
{
return(RedirectToAction("Index", new { Message = ManageMessageId.Error }));
}
SchedulerUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, false, false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.RemovePhoneSuccess }));
}
private async Task LoadSharedKeyAndQrCodeUriAsync(SchedulerUser user)
{
// Load the authenticator key & QR code URI to display on the form
var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
if (string.IsNullOrEmpty(unformattedKey))
{
await _userManager.ResetAuthenticatorKeyAsync(user);
unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
}
SharedKey = FormatKey(unformattedKey);
var email = await _userManager.GetEmailAsync(user);
AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new SchedulerUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
// Todo: this will throw an error if the password isn't correct.. hence ViewModel password regex validation
if (result.Errors.Any())
{
AddErrors(result);
return(View(model));
}
UserManager.AddClaim(user.Id, new Claim(ClaimTypes.GivenName, user.FirstName));
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, false, false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model,
string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
ExternalLoginInfo info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new SchedulerUser {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName
};
IdentityResult result = await UserManager.CreateAsync(user);
UserManager.AddClaim(user.Id, new Claim(ClaimTypes.GivenName, user.FirstName));
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, false, false);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
SchedulerUser user = await UserManager.FindByNameAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction("ResetPasswordConfirmation", "Account"));
}
IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("ResetPasswordConfirmation", "Account"));
}
AddErrors(result);
return(View());
}
public async Task <ActionResult> ForgotPassword(ForgotPasswordViewModel model)
{
if (ModelState.IsValid)
{
SchedulerUser user = await UserManager.FindByNameAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist or is not confirmed
return(View("ForgotPasswordConfirmation"));
}
string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
//await UserManager.SendEmailAsync(user.Id, "Reset Password", "Please reset your password by clicking <a href=\"" + callbackUrl + "\">here</a>");
#region create and send email with postal instead usermanager
var email = new PasswordResetEmail
{
ReceiverEmail = user.Email,
ReceiverName = user.FirstName,
AdminEmail = "*****@*****.**",
EmailSubject = "Reset password",
PassWordRestLink = callbackUrl
};
PostalEmailManager.SendResetPassword(email);
#endregion
return(RedirectToAction("ForgotPasswordConfirmation", "Account", new { userEmail = model.Email }));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public EventsController Arrange_Event_Controller()
{
var testEvent1 = new Event {
Id = 1
};
var testEvent2 = new Event {
Id = 2
};
var testUser = new SchedulerUser {
Id = "99fd20b8-7194-31e1-945b-e6736c732499", Events = new List <Event> {
testEvent1, testEvent2
}
};
var users = new List <SchedulerUser> {
testUser
}.AsQueryable();
var service = new Service();
var mockSet = new Mock <DbSet <SchedulerUser> >();
mockSet.As <IQueryable <SchedulerUser> >().Setup(m => m.Provider).Returns(users.Provider);
mockSet.As <IQueryable <SchedulerUser> >().Setup(m => m.Expression).Returns(users.Expression);
mockSet.As <IQueryable <SchedulerUser> >().Setup(m => m.ElementType).Returns(users.ElementType);
mockSet.As <IQueryable <SchedulerUser> >().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator);
var context = new Mock <SchedulerDbContext>();
context.Setup(c => c.Users).Returns(mockSet.Object);
var controller = new EventsController(context.Object, service)
{
ControllerContext = MockContext()
};
return(controller);
}
public async Task <ActionResult> ChangePassword(ChangePasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
IdentityResult result =
await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
SchedulerUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, false, false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
AddErrors(result);
return(View(model));
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
SchedulerUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, false, false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> VerifyPhoneNumber(VerifyPhoneNumberViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
IdentityResult result =
await UserManager.ChangePhoneNumberAsync(User.Identity.GetUserId(), model.PhoneNumber, model.Code);
if (result.Succeeded)
{
SchedulerUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, false, false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.AddPhoneSuccess }));
}
// If we got this far, something failed, redisplay form
ModelState.AddModelError("", "Failed to verify phone");
return(View(model));
}
public async Task <ActionResult> RemoveLogin(string loginProvider, string providerKey)
{
ManageMessageId?message;
IdentityResult result =
await
UserManager.RemoveLoginAsync(User.Identity.GetUserId(),
new UserLoginInfo(loginProvider, providerKey));
if (result.Succeeded)
{
SchedulerUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, false, false);
}
message = ManageMessageId.RemoveLoginSuccess;
}
else
{
message = ManageMessageId.Error;
}
return(RedirectToAction("ManageLogins", new { Message = message }));
}
protected override void Seed(SchedulerDbContext context)
{
#region Seed User
var admin = new SchedulerUser
{
FirstName = "Administrator",
LastName = "Web Admin",
Email = "*****@*****.**",
UserName = "******"
};
var firstUser = new SchedulerUser
{
FirstName = "FirstUser-Name",
LastName = "User",
Email = "*****@*****.**",
UserName = "******"
};
var secondUser = new SchedulerUser
{
FirstName = "SecondUser-Name",
LastName = "User",
Email = "*****@*****.**",
UserName = "******"
};
#endregion
//some events
#region Seed Events
var footballTournament = new Event
{
Title = "Football tournament",
Description = "Winter indoor tournament is around the conner. Please let us know if you will take part this year!",
StartDate = new DateTime(2016, 10, 27),
//EndDate = new DateTime(2016, 10, 28),
ReminderDate = new DateTime(2016, 10, 25),
ListDate = new DateTime(2016, 10, 26),
Location = "Some football hall"
};
var newYearParty = new Event
{
Title = "New year party",
Description = "Please join us for new year part at my house",
StartDate = new DateTime(2016, 12, 31),
//EndDate = new DateTime(2016, 01, 01),
ReminderDate = new DateTime(2016, 12, 25),
ListDate = new DateTime(2016, 12, 28),
Location = "Street 123, City"
};
var aspNetCoding = new Event
{
Title = "ASP.NET Coding",
Description = "Do you have knowledge or want to learn on asp.net? " +
"asp.net developers will be meeting to exchange ideas, " +
"Let us know if you will be joining us",
StartDate = new DateTime(2016, 10, 20),
//EndDate = new DateTime(2015, 10, 20),
ReminderDate = new DateTime(2016, 10, 10),
ListDate = new DateTime(2016, 10, 13),
Location = "Developers Hall"
};
#endregion
if (!context.Users.Any(u => u.UserName == "*****@*****.**"))
{
var userStore = new UserStore <SchedulerUser>(context);
var userManager = new UserManager <SchedulerUser>(userStore);
var roleStore = new RoleStore <IdentityRole>(context);
var roleManager = new RoleManager <IdentityRole>(roleStore);
userManager.Create(admin, "passW0rd!");
roleManager.Create(new IdentityRole {
Name = "Admin"
});
userManager.AddToRole(admin.Id, "Admin");
userManager.AddClaim(admin.Id, new Claim(ClaimTypes.GivenName, admin.FirstName));
userManager.Create(firstUser, "passW0rd!");
userManager.AddClaim(firstUser.Id, new Claim(ClaimTypes.GivenName, firstUser.FirstName));
userManager.Create(secondUser, "passW0rd!");
userManager.AddClaim(secondUser.Id, new Claim(ClaimTypes.GivenName, secondUser.FirstName));
}
#region seed Contacts
var firstContact = new Contact()
{
ContactId = 1,
FirstName = "Hans",
LastName = "Muster",
Email = "*****@*****.**",
PhoneNumber = "0761234567",
SchedulerUserId = admin.Id
};
var secondContact = new Contact
{
ContactId = 2,
FirstName = "TestUser",
LastName = "LastName",
Email = "*****@*****.**",
PhoneNumber = "0761234567",
SchedulerUserId = admin.Id
};
#endregion
footballTournament.SchedulerUserId = firstUser.Id;
newYearParty.SchedulerUserId = firstUser.Id;
aspNetCoding.SchedulerUserId = secondUser.Id;
context.Events.Add(newYearParty);
context.Events.Add(footballTournament);
context.Events.Add(aspNetCoding);
context.Contacts.Add(firstContact);
context.Contacts.Add(secondContact);
context.SaveChanges();
base.Seed(context);
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new SchedulerUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
// If account confirmation is required, we need to show the link if we don't have a real email sender
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("./RegisterConfirmation", new { Email = Input.Email }));
}
await _signInManager.SignInAsync(user, isPersistent : false, info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
ProviderDisplayName = info.ProviderDisplayName;
ReturnUrl = returnUrl;
return(Page());
}
