// GET: Home public async Task<ActionResult> Index() { var context = new ApplicationDbContext(); // DefaultConnection var store = new UserStore<CustomUser>(context); var manager = new UserManager<CustomUser>(store); var email = "*****@*****.**"; var password = "******"; var user = await manager.FindByEmailAsync(email); if (user == null) { user = new CustomUser { UserName = email, Email = email, FirstName = "Super", LastName = "Admin" }; await manager.CreateAsync(user, password); } else { user.FirstName = "Super"; user.LastName = "Admin"; await manager.UpdateAsync(user); } return Content("Hello, Index"); }
public async Task<IdentityResult> UpdateUser(IdentityUser user) { IdentityResult user1 = null; try { _ctx = new AuthContext(); _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx)); user1 = await _userManager.UpdateAsync(user); } catch (Exception ex) { } return user1; }
public async Task<WikiDownUser> Save(IPrincipal principal, UserManager<WikiDownUser> userManager) { var user = await userManager.FindByNameAsync(this.UserName); var roles = this.GetRoles(principal, user); if (user != null) { if (user.UserName == principal.Identity.Name) { var userAccessLevel = ArticleAccessHelper.GetAccessLevel(user.Roles); if (userAccessLevel < ArticleAccessLevel.Admin) { throw new HttpResponseException(HttpStatusCode.BadRequest); } } user.SetRoles(roles); user.SetDisplayName(this.DisplayName); user.SetEmail(this.Email); if (!string.IsNullOrWhiteSpace(this.Password)) { await userManager.RemovePasswordAsync(user.Id); await userManager.AddPasswordAsync(user.Id, this.Password); } await userManager.UpdateAsync(user); WikiDownUserCacheHelper.Clear(user.UserName); } else { user = new WikiDownUser(this.UserName) { Roles = roles }; user.SetDisplayName(this.DisplayName); user.SetEmail(this.Email); await userManager.CreateAsync(user, this.Password); } return user; }
private async Task <IdentityResult> UpdateUserAsync(AppUser user) { IdentityResult identityResult = await userManager.UpdateAsync(user); return(identityResult); }
public async Task <ActionResult> Update(UpdateAccountDto updateAccountDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState.Values.SelectMany(x => x.Errors))); } var user = await GetAuthenticatedUserAccount(); if (user == null) { return(NotFound(new { Message = "User account not found" })); } if (!string.IsNullOrEmpty(updateAccountDto.Email) && user.Email != updateAccountDto.Email && await _userManager.Users.FirstOrDefaultAsync(u => u.Email == updateAccountDto.Email) == null) { user.EmailConfirmed = false; user.Email = updateAccountDto.Email; var mailToken = await _userManager.GenerateEmailConfirmationTokenAsync(user); var confirmationUrl = Url.Link("ConfirmEmail", new { token = mailToken, email = user.Email }); await _mailService.SendMailAsync( user.Email, "Agree - Confirmation", $"<html><body>Hello, {user.DisplayName}#{user.Tag.ToString().PadLeft(4, '0')}. Please click <a href=\"{confirmationUrl}\">HERE</a> to confirm your new email.</body></html>"); } if (!string.IsNullOrEmpty(updateAccountDto.UserName) && user.DisplayName != updateAccountDto.UserName) { var userWithSameTagAndName = await _userManager.Users.FirstOrDefaultAsync( u => u.DisplayName == updateAccountDto.UserName && u.Tag == user.Tag); if (userWithSameTagAndName == null) { user.DisplayName = updateAccountDto.UserName; } } if (user.Tag != updateAccountDto.Tag) { var userWithSameTagAndName = await _userManager.Users.FirstOrDefaultAsync( u => u.DisplayName == user.DisplayName && u.Tag == updateAccountDto.Tag); if (userWithSameTagAndName == null) { user.Tag = updateAccountDto.Tag; if (!string.IsNullOrEmpty(updateAccountDto.UserName) && user.DisplayName != updateAccountDto.UserName) { userWithSameTagAndName = await _userManager.Users.FirstOrDefaultAsync( u => u.DisplayName == updateAccountDto.UserName && u.Tag == user.Tag); if (userWithSameTagAndName == null) { user.DisplayName = updateAccountDto.UserName; } } } } var result = await _userManager.UpdateAsync(user); if (!result.Succeeded) { return(BadRequest(new { result.Errors })); } var userViewModel = _mapper.Map <ApplicationUserViewModel>(user); Response.Cookies.Append("agreeallow_accesstoken", await _tokenService.GenerateToken(user.Email), new CookieOptions { HttpOnly = true, SameSite = SameSiteMode.Strict }); return(Ok(new UserResponse(userViewModel))); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var user = await _userManager.GetUserAsync(User); if (user == null) { return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'.")); } user.Qualification = Input.QualificationType; var qualificationName = user.QualificationName; if (Input.QualificationName != qualificationName) { user.QualificationName = Input.QualificationName; // Error checking will need to be added here to ensure in the event something fails it updates. } var qulificationCompletionYear = user.QulificationCompletionYear; if (Input.QualificationCompletionYear != qulificationCompletionYear) { user.QulificationCompletionYear = Input.QualificationCompletionYear; // Error checking will need to be added here to ensure in the event something fails it updates. } var currentStudyingQualification = user.CurrentStudyingQualification; if (Input.CurrentStudyingQualification != user.CurrentStudyingQualification) { user.CurrentStudyingQualification = Input.CurrentStudyingQualification; // Error checking will need to be added here to ensure in the event something fails it updates. } var currentQualificationType = user.CurrentQualificationType; if (Input.CurrentQualificationType != user.CurrentQualificationType) { user.CurrentQualificationType = Input.CurrentQualificationType; // Error checking will need to be added here to ensure in the event something fails it updates. } var citizenshipStudyStatus = user.CitizenshipStudyStatus; if (Input.isStudyasInternationalStudent != user.CitizenshipStudyStatus) { user.CitizenshipStudyStatus = Input.isStudyasInternationalStudent; // Error checking will need to be added here to ensure in the event something fails it updates. } var studyingAtSwinburne = user.StudyingAtSwinburne; if (Input.StudyingAtSwinburne != user.StudyingAtSwinburne) { user.StudyingAtSwinburne = Input.StudyingAtSwinburne; // Error checking will need to be added here to ensure in the event something fails it updates. } var areYouStudying = user.AreYouStudying; if (Input.AreYouStudying != user.AreYouStudying) { user.AreYouStudying = Input.AreYouStudying; // Error checking will need to be added here to ensure in the event something fails it updates. } if (Input.YouTubeURL != user.YoutubeUrl) { user.YoutubeUrl = Input.YouTubeURL; } await _userManager.UpdateAsync(user); await _signInManager.RefreshSignInAsync(user); var result = await FullRegistrationAsync(); user.UserFullyRegistered = result; await _userManager.UpdateAsync(user); StatusMessage = "Your Qualification Details have been updated"; return(RedirectToPage()); }
public async Task <ActionResult> Register(RegisterViewModel model) { model.ListaEstados = ListarEstados(); model.ListaTipoPessoas = ListarTipoPessoas(); model.ListaSexo = ListarSexo(); model.Roles = this.RoleManager.Roles.Where(i => i.Name != Config.Roles.Administrador && i.Name != Config.Roles.Gerente).Select(r => new SelectListItem { Value = r.Name, Text = r.Name }).ToList(); if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email, Nome = model.Nome, TipoPessoa = model.TipoPessoa, CpfCnpj = model.CpfCnpj, Rg = model.Rg, DataNascimento = model.DataNascimento, EstadoCivil = model.EstadoCivil, Nascionalidade = model.Nascionalidade, Profissao = model.Profissao, Sexo = model.Sexo, Cep = model.Cep, Logradouro = model.Logradouro, Numero = model.Numero, Complemento = model.Complemento, Bairro = model.Bairro, Cidade = model.Cidade, Uf = model.Uf, TelefoneResidencial = model.TelefoneResidencial, TelefoneCelular = model.TelefoneCelular, TelefoneComercial = model.TelefoneComercial, }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await this.UserManager.AddToRoleAsync(user.Id, model.Role); await UserManager.UpdateAsync(user); //await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser: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, "Valide seu Cadastro", "Por favor, valide seu cadastro clicando " + String.Format("<a href=\"{0}\">{1}</a>", callbackUrl, "aqui")); ViewBag.Message = "Verifique o seu email e confirme a sua conta, você tem que confirmar a sua conta antes de fazer o login "; return(View("Info")); //return RedirectToAction("Index", "Home"); } AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <IActionResult> SubmitTokenInput(TokenInputViewModel model) { if (!ModelState.IsValid || String.IsNullOrWhiteSpace(model.Email) || String.IsNullOrWhiteSpace(model.Purpose) || String.IsNullOrWhiteSpace(model.Token)) { return(View(model)); } var email = _userManager.NormalizeKey(model.Email); model.Token = model.Token.Replace(" ", ""); var userWithConfirmedEmail = await _userManager.FindByLoginAsync("Email", email); var userCurrentlySignedIn = await _userManager.GetUserAsync(User); var userEmpty = new ApplicationUser() { Id = email, Email = email, SecurityStamp = TemporarySecurityStamp }; var isTokenValid = false; if (model.Purpose == "RegisterOrLogin") // Trying to register or login { await _signInManager.SignOutAsync(); isTokenValid = await _userManager.VerifyUserTokenAsync( userWithConfirmedEmail // Case: logging-in ?? userEmpty, // Case: registering, "Email", model.Purpose, model.Token); } else // Trying to add email { if (userCurrentlySignedIn == null) // If the user is not signed in, prompt them to, with the return url leading back here { return(RedirectToAction(nameof(Login), new { returnUrl = Request.Path + Request.QueryString })); } isTokenValid = await _userManager.VerifyUserTokenAsync( userCurrentlySignedIn, "Email", model.Purpose, model.Token); } if (!isTokenValid) { _notice.AddErrors(ModelState, "Error validating code, it might have expired. Please try again!"); return(View(model)); } // Invalidates all tokens for user when trying to login or add login // Note: this also invalidates any attempts to add more logins than allowed if ((userCurrentlySignedIn ?? userWithConfirmedEmail) != null) { var updateSecStampResult = await _userManager.UpdateSecurityStampAsync(userCurrentlySignedIn ?? userWithConfirmedEmail); if (!updateSecStampResult.Succeeded) { _notice.AddErrors(ModelState); return(View(model)); } } // Valid {token + email (user) + purpose} supplied if (model.Purpose == "RegisterOrLogin") // Trying to register or login { if (userWithConfirmedEmail == null) // Success trying to register { var token = await _userManager.GenerateUserTokenAsync(userEmpty, "Default", "Register"); return(View(nameof(Register), new RegisterViewModel { RememberMe = model.RememberMe, Email = email, UserName = GenerateUserName(email), Token = token, ReturnUrl = model.ReturnUrl })); } else // Success trying to login { await _events.AddEvent(AuthEventType.Login, JsonConvert.SerializeObject(new { LoginProvider = "Email", ProviderKey = model.Email }), userWithConfirmedEmail); await _signInManager.SignInAsync(userWithConfirmedEmail, isPersistent : model.RememberMe); } } else // Trying to add email { var userWithConfirmedEmailToAdd = await _userManager.FindByLoginAsync("Email", email); if (userWithConfirmedEmailToAdd == null) // Email to be added never seen before, add email to userCurrentlySignedIn { var addLoginResult = await _userManager.AddLoginAsync(userCurrentlySignedIn, new UserLoginInfo("Email", email, "Email")); if (!addLoginResult.Succeeded) { _notice.AddErrors(ModelState, addLoginResult); return(View(model)); } userCurrentlySignedIn.Email = email; userCurrentlySignedIn.EmailConfirmed = true; var updateUserResult = await _userManager.UpdateAsync(userCurrentlySignedIn); if (!updateUserResult.Succeeded) { _notice.AddErrors(ModelState, updateUserResult); return(View(model)); } await _events.AddEvent(AuthEventType.AddLogin, JsonConvert.SerializeObject(new { LoginProvider = "Email", ProviderKey = model.Email }), userCurrentlySignedIn); } else // Email to be added is in use { // Note: this area is unlikely to be reached since security stamp is changed once a login is added if (userWithConfirmedEmailToAdd.Id == userCurrentlySignedIn.Id) // Email is already in user's account { _notice.AddErrors(ModelState, "This email is already in your account."); return(View(model)); } else // Email associated with another account (same user since both verified!) { _notice.AddErrors(ModelState, "This email is in another user's account. Try logging in using that email instead."); return(View(model)); } } } // Success return(RedirectToLocal(model.ReturnUrl)); }
public async Task<ActionResult> updateGoalFitBit(string updateGoal) { var userStore = new UserStore<ApplicationUser>(context); var userManager = new UserManager<ApplicationUser>(userStore); var currentUser = userManager.FindById(User.Identity.GetUserId()); var fitBitUpdateGoal = Convert.ToInt32(updateGoal); currentUser.FitBitGoal = fitBitUpdateGoal; try { await userManager.UpdateAsync(currentUser); var saveUser = userStore.Context; await saveUser.SaveChangesAsync(); TempData["ValidationMessage"] = "Goal Updated To: " + " " + fitBitUpdateGoal; } catch { TempData["ValidationMessage"] = "Error: Goal Not Updated!"; } return RedirectToAction("Index"); }
void DisableLockout(UserManager<IdentityUser> manager, IdentityUser identityUser) { if (identityUser != null) { identityUser.LockoutEnabled = true; identityUser.LockoutEndDateUtc = null; manager.UpdateAsync(identityUser); } }
public async Task <IdentityResult> UpdateUserAsync(UserDto userDto) => await _userManager.UpdateAsync(userDto);
public Task <IActionResult> UpdateProfile(ChangeProfileModel model) { return(MakeChangeAsync(user => userManager.UpdateAsync(user, model.Email, model.DisplayName), "Account updated successfully.")); }
public async Task <IdentityResult> UpdateUserAsync(AppUser entity) { return(await _userManager.UpdateAsync(entity)); }
public async Task<ActionResult> AddPhoneNumber(AddPhoneNumberViewModel model) { if (!ModelState.IsValid) { return View(model); } ApplicationDbContext db = new ApplicationDbContext(); var userStore = new UserStore<ApplicationUser>(db); var userManager = new UserManager<ApplicationUser>(userStore); var user = await userManager.FindByIdAsync(User.Identity.GetUserId()); if (user != null) { user.PhoneNumber = model.Number; } var result = await userManager.UpdateAsync(user); var ctx = userStore.Context; var result1 = await ctx.SaveChangesAsync(); // However, it always succeeds inspite of not updating the database if (!result.Succeeded) { AddErrors(result); } return RedirectToAction("Index", "Manage"); }
public async Task<ActionResult> Create() { FitBit fitbit = new FitBit(); var userStore = new UserStore<ApplicationUser>(context); var userManager = new UserManager<ApplicationUser>(userStore); try { var currentUser = userManager.FindById(User.Identity.GetUserId()); var progress = Convert.ToDouble(currentUser.FitBitProgress); var goal = Convert.ToDouble(currentUser.FitBitGoal); var dateStart = Convert.ToDateTime(currentUser.dateStartFitBit.ToString()); var dateEnd = Convert.ToDateTime(currentUser.dateEndFitBit.ToString()); var percentEarned = (progress / goal) * 100; int percentEarnedShort = Convert.ToInt32(percentEarned); dateStart.ToShortDateString(); dateEnd.ToShortDateString(); fitbit.User = currentUser.UserName; fitbit.Progress = progress.ToString(); fitbit.Goal = goal.ToString(); fitbit.dateStart = dateStart; fitbit.dateEnd = dateEnd; fitbit.percentageEarned = percentEarnedShort.ToString(); db.FitBits.Add(fitbit); db.SaveChanges(); TempData["ValidationMessage"] = "Stats Submitted for " + " " + dateStart + " - " + dateEnd; var fitBitProgressNew = 0; currentUser.FitBitProgress = fitBitProgressNew; try { await userManager.UpdateAsync(currentUser); var saveUser = userStore.Context; await saveUser.SaveChangesAsync(); } catch { TempData["ValidationMessage"] = "Error: Stats Not Submitted!"; return RedirectToAction("Index", "Fitbit"); } return RedirectToAction("Manage", "Fitbit"); } catch { TempData["ValidationMessage"] = "Error: Stats Not Submitted!"; return RedirectToAction("Index", "Fitbit"); } }
public async Task<ActionResult> updateDateFitBit(DateTime dateStart) { var userStore = new UserStore<ApplicationUser>(context); var userManager = new UserManager<ApplicationUser>(userStore); var currentUser = userManager.FindById(User.Identity.GetUserId()); var dateStartUpdate = dateStart.Date; //dateEnd is automatically 7 days after date start var dateEndUpdate = dateStartUpdate.Date.AddDays(7); currentUser.dateStartFitBit = dateStartUpdate.ToShortDateString(); currentUser.dateEndFitBit = dateEndUpdate.ToShortDateString(); try { await userManager.UpdateAsync(currentUser); var saveUser = userStore.Context; await saveUser.SaveChangesAsync(); TempData["ValidationMessage"] = "Date Start Set To: " + " " + dateStartUpdate.ToShortDateString(); } catch { TempData["ValidationMessage"] = "Error: Date Start Not Set!"; } return RedirectToAction("Index"); }
/// <summary> /// Updates the user's information /// </summary> /// <returns></returns> public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } CheckUserRolesExist(); // Get signed in user var user = await _userManager.GetUserAsync(User); // Remove all associated claims from current user's identity await _userManager.RemoveClaimsAsync(user, User.Claims); // Add newly updated claims and sign user back in if (ModelState.IsValid) { // update user's info user.UserName = UserProfile.Email; user.FirstName = UserProfile.FirstName; user.LastName = UserProfile.LastName; user.Email = UserProfile.Email; user.Address = UserProfile.Address; user.Birthday = UserProfile.Birthday; user.LovesCats = UserProfile.LovesCats; // Reset password of user string resetToken = await _userManager.GeneratePasswordResetTokenAsync(user); await _userManager.ResetPasswordAsync(user, resetToken, UserProfile.Password); var updatedResult = await _userManager.UpdateAsync(user); if (updatedResult.Succeeded) {// Custom Claim type for full name Claim fullNameClaim = new Claim("FullName", $"{user.FirstName} {user.LastName}"); // Custom claim type for loves cats Claim lovesCatsClaim = new Claim("LovesCats", user.LovesCats.ToString().ToLower()); // claim type for birthday Claim birthdayClaim = new Claim( ClaimTypes.DateOfBirth, new DateTime(user.Birthday.Year, user.Birthday.Month, user.Birthday.Day).ToString("u"), ClaimValueTypes.DateTime); // claim type for email Claim emailClaim = new Claim(ClaimTypes.Email, user.Email, ClaimValueTypes.Email); // claim for type address Claim addressClaim = new Claim(ClaimTypes.StreetAddress, user.Address); List <Claim> myclaims = new List <Claim>() { fullNameClaim, birthdayClaim, emailClaim, addressClaim, lovesCatsClaim }; // adds the claims await _userManager.AddClaimsAsync(user, myclaims); // make admins if emails are these if (UserProfile.Email.ToLower() == "*****@*****.**" || UserProfile.Email.ToLower() == "*****@*****.**" || UserProfile.Email.ToLower() == "*****@*****.**") { await _userManager.AddToRoleAsync(user, UserRoles.Admin); } else { await _userManager.RemoveFromRoleAsync(user, UserRoles.Admin); } await _userManager.AddToRoleAsync(user, UserRoles.Member); await _signInManager.RefreshSignInAsync(user); } try { await _userContext.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UserProfileExists()) { return(NotFound()); } else { throw; } } } return(RedirectToPage("./Index")); }
public async Task SeedAsync() { //_dbContext.Database.Migrate(); #region Fill Auth Db if (!_dbContext.Roles.Any()) { var roles = new List <ApplicationRole>() { new ApplicationRole() { Name = "admin", NormalizedName = "Administrator", ConcurrencyStamp = Guid.NewGuid().ToString() }, new ApplicationRole() { Name = "User", NormalizedName = "User", ConcurrencyStamp = Guid.NewGuid().ToString() } }; foreach (var role in roles) { await _roleManager.CreateAsync(role); } } if (!_dbContext.Users.Any()) { //Add new test administrator var admin = new ApplicationUser() { Email = "*****@*****.**", UserName = "******", FullName = "Test Admin", JoinDate = DateTime.Now }; var result = await _userManager.CreateAsync(admin, "Password1!"); if (result.Succeeded) { admin.EmailConfirmed = true; await _userManager.UpdateAsync(admin); var roleName = "Admin"; if (await _roleManager.RoleExistsAsync(roleName)) { await _userManager.AddToRoleAsync(admin, roleName); } } //Add new test user var user = new ApplicationUser() { Email = "*****@*****.**", UserName = "******", FullName = "Test user", JoinDate = DateTime.Now }; result = await _userManager.CreateAsync(admin, "Password2!"); if (result.Succeeded) { admin.EmailConfirmed = true; await _userManager.UpdateAsync(admin); var roleName = "User"; if (await _roleManager.RoleExistsAsync(roleName)) { await _userManager.AddToRoleAsync(admin, roleName); } } } #endregion await CountryDbConfiguration.SeedDefaultValues(_dbContext); await CityDbConfiguration.SeedDefaultValues(_dbContext); await ProductCategoryDbConfiguration.SeedDefaultValues(_dbContext); await ProductCategoryDbConfiguration.SeedDefaultValues(_dbContext); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var user = await _userManager.GetUserAsync(User); if (user == null) { return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'.")); } var email = await _userManager.GetEmailAsync(user); if (Input.Email != email) { var setEmailResult = await _userManager.SetEmailAsync(user, Input.Email); if (!setEmailResult.Succeeded) { var userId = await _userManager.GetUserIdAsync(user); throw new InvalidOperationException($"Unexpected error occurred setting email for user with ID '{userId}'."); } } var phoneNumber = await _userManager.GetPhoneNumberAsync(user); if (Input.PhoneNumber != phoneNumber) { var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber); if (!setPhoneResult.Succeeded) { var userId = await _userManager.GetUserIdAsync(user); throw new InvalidOperationException($"Unexpected error occurred setting phone number for user with ID '{userId}'."); } } if (Input.Patronymic != user.Patronymic) { user.Patronymic = Input.Patronymic; await _userManager.UpdateAsync(user); } if (Input.FirstName != user.FirstName) { user.FirstName = Input.FirstName; await _userManager.UpdateAsync(user); } if (Input.SecondName != user.SecondName) { user.SecondName = Input.SecondName; await _userManager.UpdateAsync(user); } if (Input.Bio != user.Bio) { user.Bio = Input.Bio; await _userManager.UpdateAsync(user); } if (Input.File != null) { var logoPath = await ImageHelper.UploadLogo(Input.File, user.Id, _hostingEnvironment); user.Logo = logoPath; await _userManager.UpdateAsync(user); } await _signInManager.RefreshSignInAsync(user); StatusMessage = "Your profile has been updated"; return(RedirectToPage()); }
public async Task <IActionResult> OnPostAsync() { var user = await _userManager.GetUserAsync(User); if (user == null) { return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'.")); } if (!ModelState.IsValid) { await LoadAsync(user); return(Page()); } var phoneNumber = await _userManager.GetPhoneNumberAsync(user); var firstname = user.FirstName; var lastname = user.LastName; if (Input.FirstName != firstname) { user.FirstName = Input.FirstName; await _userManager.UpdateAsync(user); } if (Input.LastName != lastname) { user.LastName = Input.LastName; await _userManager.UpdateAsync(user); } if (Request.Form.Files.Count > 0) { var file = Request.Form.Files.FirstOrDefault(); using (var fs = new MemoryStream()) { if (fs.Length < 2097152) { await file.CopyToAsync(fs); user.ProfilePic = fs.ToArray(); } else { ModelState.AddModelError("File", "The file is too large."); } } await _userManager.UpdateAsync(user); } if (Input.PhoneNumber != phoneNumber) { var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber); if (!setPhoneResult.Succeeded) { StatusMessage = "Unexpected error when trying to set phone number."; return(RedirectToPage()); } } await _signInManager.RefreshSignInAsync(user); StatusMessage = "Your profile has been updated"; return(RedirectToPage()); }
public async Task <IActionResult> UpdateAccountAdmin(List <AdminRequest> adminList) { var dict = new Dictionary <String, object>(); var response = new List <AdminInfoResponse>(); var errors = new List <Error>(); foreach (var req in adminList) { var user = await _userManager.FindByIdAsync(req.Id); if (user == null) { continue; } try { if (await _userManager.IsInRoleAsync(user, "academic management") || await _userManager.IsInRoleAsync(user, "quality assurance")) { if (!(user.UserName == req.Code && user.RealName == req.RealName && user.Email == req.Email && DateTime.Compare(user.DOB, Convert.ToDateTime(req.Dob)) == 0 && await _userManager.IsInRoleAsync(user, req.Role))) { //Update Profile if (await _userManager.FindByEmailAsync(req.Email) != null && user.Email != req.Email) { errors.Add(new Error { Type = 1, Message = "Email " + req.Email + " already exists", }); continue; } if (await _userManager.FindByNameAsync(req.Code) != null && user.UserName != req.Code) { errors.Add(new Error { Type = 2, Message = "Employee Code " + req.Code + " already exists", }); continue; } user.UserName = req.Code; user.RealName = req.RealName; user.Email = req.Email; user.DOB = Convert.ToDateTime(req.Dob); if (!await _userManager.IsInRoleAsync(user, req.Role) && req.Role != null) { await _userManager.RemoveFromRoleAsync(user, (await _userManager.GetRolesAsync(user))[0]); await _userManager.AddToRoleAsync(user, req.Role); } var resultUpdate = await _userManager.UpdateAsync(user); if (resultUpdate.Succeeded) { response.Add(new AdminInfoResponse { Id = user.Id, Code = user.UserName, RealName = user.RealName, Email = user.Email, Dob = user.DOB.ToString("yyyy-MM-dd"), Role = req.Role }); } else { return(new ObjectResult(new { type = 3, code = resultUpdate.Errors.ToList()[0].Code, message = resultUpdate.Errors.ToList()[0].Description }) { StatusCode = 500 }); } } } } catch (Exception ex) { return(new ObjectResult(new { type = 4, message = ex.Message }) { StatusCode = 500 }); } } dict.Add("success", response); dict.Add("failed", errors); return(new OkObjectResult(dict)); }
public async Task <IActionResult> Put(string id, [FromBody] string value) { string databaseInnerExceptionMessage = ""; var userChangeInput = JsonConvert.DeserializeObject <dynamic>(value); List <object> messages = new List <object>(); bool status = true; //This variable is used to track the overall success of all the database operations object response; //http://stackoverflow.com/questions/20444022/updating-user-data-asp-net-identity //Database is our database context set in this controller. //I used the following 2 lines of command to create a userStore which represents AspNetUser table in the DB. var userStore = new UserStore <ApplicationUser>(Database); //Then, I created a userManager instance that operates on the userStore. var userManager = new UserManager <ApplicationUser>(userStore, null, null, null, null, null, null, null, null); //To obtain the full name information, use student.FullName.value //To obtain the email information, use student.Email.value var oneUser = Database.Users .Where(item => item.Id == id).Include(p => p.Roles).FirstOrDefault(); //The following code to obtain the role name are asynchronous and not reliable. //Doing a bypass by leveraging on the client-side JavaScript. // var newRoleNameToAdd = identityRoleManager.FindByIdAsync(user.RoleId.Value).Result; // var existingRoleNameToRemove = identityRoleManager.FindByIdAsync(oneUser.Roles.First().RoleId).Result; oneUser.UserName = userChangeInput.userName; oneUser.FullName = userChangeInput.fullName.Value; oneUser.Email = userChangeInput.email.Value; try { //Although the command below correct but violated foreign key constraint //Must let the UserManager instance, userManager do the job. //oneUser.Roles.FirstOrDefault().RoleId = user.roleId.Value; //All the following 3 method calls are asynchronous. Notice that I delcared the Put method as Asynchronous method too. //http://stackoverflow.com/questions/20444022/updating-user-data-asp-net-identity has some hints how to define the return //type of this Put method here. Also, notice that I applied a technique to make these 3 asynchronous calls to become synchronous. //Remove existing role from the user var removeRoleFromUserResult = userManager.RemoveFromRoleAsync(oneUser, userChangeInput.originalRoleName.Value).Result; //Add the new role to the user. var addRoleToUserResult = userManager.AddToRoleAsync(oneUser, userChangeInput.selectedRoleName.Value).Result; //Update the var updateUserResult = userManager.UpdateAsync(oneUser).Result; try { //Changes are not persisted in the database until //I use the following command. userStore.Context.SaveChanges(); } catch (DbUpdateException ex) { databaseInnerExceptionMessage = ex.InnerException.Message; status = false; messages.Add(databaseInnerExceptionMessage); } if (removeRoleFromUserResult.Succeeded != true) { status = false; messages.Add(removeRoleFromUserResult); } if (addRoleToUserResult.Succeeded != true) { status = false; messages.Add(addRoleToUserResult); } if (updateUserResult.Succeeded != true) { status = false; messages.Add(updateUserResult); } if (status == true) { response = new { status = "success", message = "Saved user record." }; } else { response = new { status = "fail", message = messages }; } } catch (Exception outerException) { response = new { status = "fail", message = outerException.InnerException.Message }; } return(new JsonResult(response)); }//End of Put()
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var user = await _userManager.GetUserAsync(User); if (user == null) { throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'."); } if (Input.AccountType != user.AccountType) { user.AccountType = Input.AccountType; var updateAccountTypeResult = await _userManager.UpdateAsync(user); if (!updateAccountTypeResult.Succeeded) { throw new ApplicationException($"Unexpected error occurred while updating the account type for user with ID '{user.Id}'."); } } if (Input.CompanyName != user.CompanyName) { user.CompanyName = Input.CompanyName; var updateCompanyNameResult = await _userManager.UpdateAsync(user); if (!updateCompanyNameResult.Succeeded) { throw new ApplicationException($"Unexpected error occurred while updating the company name for user with ID '{user.Id}'."); } } if (Input.FirstName != user.FirstName) { user.FirstName = Input.FirstName; var updateFirstNameResult = await _userManager.UpdateAsync(user); if (!updateFirstNameResult.Succeeded) { throw new ApplicationException($"Unexpected error occurred while updating the first name for user with ID '{user.Id}'."); } } if (Input.LastName != user.LastName) { user.LastName = Input.LastName; var updateLastNameResult = await _userManager.UpdateAsync(user); if (!updateLastNameResult.Succeeded) { throw new ApplicationException($"Unexpected error occurred while updating the last name for user with ID '{user.Id}'."); } } if (Input.ProfileImage != null) { using (var memoryStream = new MemoryStream()) { await Input.ProfileImage.CopyToAsync(memoryStream); var profileImage = memoryStream.ToArray(); if (profileImage != user.ProfileImage) { user.ProfileImage = profileImage; var updateProfileImageResult = await _userManager.UpdateAsync(user); if (!updateProfileImageResult.Succeeded) { throw new ApplicationException($"Unexpected error occurred while updating the profile image for user with ID '{user.Id}'."); } } } } if (Input.DateOfBirth != user.DateOfBirth) { user.DateOfBirth = Input.DateOfBirth; var updateDateOfBirthResult = await _userManager.UpdateAsync(user); if (!updateDateOfBirthResult.Succeeded) { throw new ApplicationException($"Unexpected error occurred while updating the date of birth for user with ID '{user.Id}'."); } } if (Input.Email != user.Email) { var setEmailResult = await _userManager.SetEmailAsync(user, Input.Email); if (!setEmailResult.Succeeded) { throw new ApplicationException($"Unexpected error occurred setting email for user with ID '{user.Id}'."); } } if (Input.PhoneNumber != user.PhoneNumber) { var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber); if (!setPhoneResult.Succeeded) { throw new ApplicationException($"Unexpected error occurred setting phone number for user with ID '{user.Id}'."); } } StatusMessage = "Your profile has been updated"; return(RedirectToPage()); }
public async Task <IActionResult> OnPostAsync() { var user = await _userManager.GetUserAsync(User); if (user == null) { return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'.")); } if (!ModelState.IsValid) { await LoadAsync(user); return(Page()); } var phoneNumber = await _userManager.GetPhoneNumberAsync(user); if (Input.PhoneNumber != phoneNumber) { var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber); if (!setPhoneResult.Succeeded) { StatusMessage = "Unexpected error when trying to set phone number."; return(RedirectToPage()); } } var firstName = user.FirstName; var lastName = user.LastName; if (Input.FirstName != firstName) { user.FirstName = Input.FirstName; await _userManager.UpdateAsync(user); } if (Input.LastName != lastName) { user.LastName = Input.LastName; await _userManager.UpdateAsync(user); } if (user.UsernameChangeLimit > 0) { if (Input.Username != user.UserName) { var userNameExists = await _userManager.FindByNameAsync(Input.Username); if (userNameExists != null) { StatusMessage = "User name already taken. Select a different username."; return(RedirectToPage()); } var setUserName = await _userManager.SetUserNameAsync(user, Input.Username); if (!setUserName.Succeeded) { StatusMessage = "Unexpected error when trying to set user name."; return(RedirectToPage()); } else { user.UsernameChangeLimit -= 1; await _userManager.UpdateAsync(user); } } } if (Request.Form.Files.Count > 0) { IFormFile file = Request.Form.Files.FirstOrDefault(); user.ProfilePicture = file.OptimizeImageSize(720, 720); await _userManager.UpdateAsync(user); } await _signInManager.RefreshSignInAsync(user); StatusMessage = "Your profile has been updated"; return(RedirectToPage()); }
public async Task <IdentityResult> SaveUser(ApplicationUser user) { return(await _userManager.UpdateAsync(user)); }
public async Task <UsuarioData> Handle(Ejecuta request, CancellationToken cancellationToken) { var usuario = await userManager.FindByNameAsync(request.UserName); if (usuario == null) { throw new ManejadorExcepcion(HttpStatusCode.NotFound, new { mensaje = "No se encuentra el usuario con este UserName" }); } var correoUsado = await context.Users.Where(x => x.Email == request.Email && x.UserName != usuario.UserName).AnyAsync(); if (correoUsado) { throw new ManejadorExcepcion(HttpStatusCode.InternalServerError, new { mensaje = "No este email ya está usado por otro usuario." }); } if (request.ImagenPerfil != null) { var imagenPerfilActual = await context.Documento.Where(x => x.ObjetoReferencia == new Guid(usuario.Id)).FirstOrDefaultAsync(); if (imagenPerfilActual == null) { var imagen = new Documento { Contenido = Convert.FromBase64String(request.ImagenPerfil.Data), Nombre = request.ImagenPerfil.Nombre, Extension = request.ImagenPerfil.Extension, ObjetoReferencia = new Guid(usuario.Id), DocumentoId = Guid.NewGuid(), FechaCreacion = DateTime.UtcNow }; context.Documento.Add(imagen); } else { imagenPerfilActual.Contenido = Convert.FromBase64String(request.ImagenPerfil.Data); imagenPerfilActual.Nombre = request.ImagenPerfil.Nombre; imagenPerfilActual.Extension = request.ImagenPerfil.Extension; } } usuario.NombreCompleto = request.NombreCompleto; usuario.PasswordHash = passwordHasher.HashPassword(usuario, request.Password); usuario.Email = request.Email; var resultado = await userManager.UpdateAsync(usuario); var roles = await userManager.GetRolesAsync(usuario); var listaRoles = new List <string>(roles); var imagenPerfil = await context.Documento.Where(x => x.ObjetoReferencia == new Guid(usuario.Id)).FirstOrDefaultAsync(); ImagenGeneral imagenGeneral = null; if (imagenPerfil != null) { imagenGeneral = new ImagenGeneral { Data = Convert.ToBase64String(imagenPerfil.Contenido), Nombre = imagenPerfil.Nombre, Extension = imagenPerfil.Extension }; } if (!resultado.Succeeded) { throw new Exception("No se puedo actualizar el usuario"); } return(new UsuarioData { NombreCompleto = usuario.NombreCompleto, Token = jwtGenerador.CrearToken(usuario, listaRoles), Email = usuario.Email, UserName = usuario.UserName, ImagenPerfil = imagenGeneral }); }
public async Task <bool> UpdateAsync(UserDbModel model) { var result = await _userManager.UpdateAsync(model); return(result.Succeeded); }
public async Task <ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { model.OtpCreated = true; var otpValidationResult = await _otpBusinessService.IsValidOtp(Convert.ToInt32(model.OTP), Convert.ToDecimal(model.MobileNumber), (int)OtpReason.Login, DateTime.UtcNow); if (!otpValidationResult.Succeeded) { model.HasError = true; ModelState.AddModelError("", otpValidationResult.Message); return(View(model)); } var user = new ApplicationUser { UserName = model.MobileNumber, Email = model.Email }; var role = model.IsDrivingSchool? Role.DrivingSchool.ToString() : Role.Personnel.ToString(); var roleId = RoleManager.Roles.FirstOrDefault(r => r.Name == role).Id; user.Roles.Add(new IdentityUserRole { UserId = user.Id, RoleId = roleId }); var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { model.AspNetUserId = user.Id; var personnelResult = await CreatePersonnel(model); if (!personnelResult.Succeeded) { model.HasError = true; foreach (var error in personnelResult.Errors) { ModelState.AddModelError("", error); } return(View(model)); } model.PersonnelId = personnelResult.Entity.PersonnelId; user.PersonnelId = personnelResult.Entity.PersonnelId; await UserManager.UpdateAsync(user); if (model.IsDrivingSchool) { model.DrivingSchool.Mobile = Convert.ToInt64(model.MobileNumber); model.DrivingSchool.EmailId = model.Email; model.DrivingSchool.PersonnelId = model.PersonnelId; var drivingSchool = await _drivingSchoolBusinessService.CreateDrivingSchool(model.DrivingSchool); if (drivingSchool.Succeeded) { return(RedirectToAction("Login", "Account")); } ModelState.AddModelError("", drivingSchool.Exception); foreach (var error in result.Errors) { ModelState.AddModelError("", error); } } //await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: 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 // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>"); return(RedirectToAction("Login", "Account")); } model.HasError = true; AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <IActionResult> OnPostAsync() { var user = await _userManager.GetUserAsync(User); if (user == null) { return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'.")); } if (!ModelState.IsValid) { await LoadAsync(user); return(Page()); } if (Request.Form.Files.Count > 0) { IFormFile file = Request.Form.Files.FirstOrDefault(); using (var dataStream = new MemoryStream()) { await file.CopyToAsync(dataStream); user.ProfilePicture = dataStream.ToArray(); } await _userManager.UpdateAsync(user); } var phoneNumber = await _userManager.GetPhoneNumberAsync(user); if (Input.PhoneNumber != phoneNumber) { var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber); if (!setPhoneResult.Succeeded) { StatusMessage = "Unexpected error when trying to set phone number."; return(RedirectToPage()); } } var name = user.Name; if (Input.Name != name) { user.Name = Input.Name; await _userManager.UpdateAsync(user); } var address = user.Address; if (Input.Address != address) { user.Address = Input.Address; await _userManager.UpdateAsync(user); } var job = user.Job; if (Input.Job != job) { user.Job = Input.Job; await _userManager.UpdateAsync(user); } var birthdate = "2017-06-01"; if (Input.BirthDate != birthdate) { //user.BirthDate = Input.BirthDate; await _userManager.UpdateAsync(user); } var sex = user.Sex; if (Input.Sex != sex) { user.Sex = Input.Sex; await _userManager.UpdateAsync(user); } var week = user.Week; if (Input.Week != week) { user.Week = Input.Week; await _userManager.UpdateAsync(user); } await _signInManager.RefreshSignInAsync(user); StatusMessage = "Cập nhật thành công"; return(RedirectToPage()); }
public async Task <IActionResult> Edit(string id, [FromBody] UserEditM data) { var user = await _userManager.FindByIdAsync(id); if (user == null) { return(NotFound(data)); } if (user.Name != data.Name && _userManager.Users.Any(u => u.Name == data.Name)) { ModelState.AddModelError(nameof(data.Name), nameof(Resource.NameError)); return(BadRequest(ModelState)); } if (user.Login != data.Login && (await _userManager.FindByNameAsync(data.Login)) != null) { ModelState.AddModelError(nameof(data.Login), nameof(Resource.LoginError)); return(BadRequest(ModelState)); } if (data.NewPassword.HasValue()) { var removePasswordResult = await _userManager.RemovePasswordAsync(user); if (!removePasswordResult.Succeeded) { ModelState.AddModelError(nameof(data.NewPassword), nameof(Resource.PasswordUpdateError)); removePasswordResult.Errors.ForEach(err => ModelState.AddModelError(nameof(data.NewPassword), $"Code {err.Code}: {err.Description}")); return(BadRequest(ModelState)); } var addPasswordResult = await _userManager.AddPasswordAsync(user, data.NewPassword); if (!addPasswordResult.Succeeded) { ModelState.AddModelError(nameof(data.NewPassword), nameof(Resource.PasswordUpdateError)); addPasswordResult.Errors.ForEach(err => ModelState.AddModelError(nameof(data.NewPassword), $"Code {err.Code}: {err.Description}")); return(BadRequest(ModelState)); } } var oldRole = (await _userManager.GetRolesAsync(user)).Single(); if (oldRole != data.AssignedRole) { if (!(await _userManager.AddToRoleAsync(user, data.AssignedRole)).Succeeded || !(await _userManager.RemoveFromRoleAsync(user, oldRole)).Succeeded) { ModelState.AddModelError(nameof(data.AssignedRole), nameof(Resource.RoleUpdateError)); return(BadRequest(ModelState)); } } user.Name = data.Name; user.Login = data.Login; user.Email = data.Email; user.PhoneNumber = data.Phone; user.Description = data.Description; user.DataAccessArray = data.DataAccess.ToStringCollection(); user.Status = data.Status.Value; if (!(await _userManager.UpdateAsync(user)).Succeeded) { ModelState.AddModelError(string.Empty, nameof(Resource.UserUpdateError)); return(BadRequest(ModelState)); } await _userService.RelateUserRegionsAsync(user, data); await _userService.RelateUserActivityCategoriesAsync(user, data); return(NoContent()); }
public async Task <IHttpActionResult> InsertSkills(List <RegisterBindingModel> userl) { //if (!ModelState.IsValid) //{ //string messages = string.Join("; ", ModelState.Values // .SelectMany(x => x.Errors) // .Select(x => x.ErrorMessage)); //return Json(new { success = false, issue = "", errors = messages }); //} ZonaFl.Business.SubSystems.SUser usern = new Business.SubSystems.SUser(); ZonaFl.Business.SubSystems.SCategory usersk = new Business.SubSystems.SCategory(); ZonaFl.Business.SubSystems.SSkill sskill = new Business.SubSystems.SSkill(); RegisterBindingModel user = userl[0]; if (user.Empresa == null) { user.Empresa = false; } if (user.Freelance == null) { user.Freelance = false; } RegisterBindingModel rmb = new RegisterBindingModel(); rmb.Skills = user.Skills; rmb.Company = user.Company; Persistence.Entities.Company company = new Persistence.Entities.Company(); if (user.Company != null) { company.InjectFrom(user.Company.FirstOrDefault()); } List <Persistence.Entities.Skill> skills = rmb.Skills.Select(e => new Persistence.Entities.Skill().InjectFrom(e)).Cast <Persistence.Entities.Skill>().ToList(); AspNetUsers aspuser = new AspNetUsers(); var useru = UserManager.FindByEmail(user.Email); for (int i = 0; i < skills.Count(); i++) { ZonaFl.Persistence.Entities.Category category = null; var skill = sskill.FindSkillByName(user.Skills[i].Name); string[] stringSeparators = new string[] { "\n" }; string result = user.Skills[i].CategorySkill.Split(stringSeparators, StringSplitOptions.None)[0]; category = usersk.FindCategoryByName(result); if (category == null) { try { category = usersk.InsertCategory(result); } catch (Exception er) { return(Json(new { success = false, issue = user, errors = er.Message, tipo = user, UserEmail = useru.Email })); } } skills[i].IdHtml = user.Skills[i].IdHtml; skills[i].Category = category; skills[i].CategoryId = category.Id; } useru.City = user.City; useru.Country = user.Country; useru.UserName = user.UserName; useru.DescUser = user.DescUser; useru.PhoneNumber = user.PhoneNumber.ToString(); useru.FirstMiddleName = user.FirstMiddleName; useru.Image = user.Image; useru.Empresa = user.Empresa; aspuser.InjectFrom(useru); aspuser.NoTrabajadores = user.NumeroEmp; try { Business.Log4NetLogger logger2 = new Business.Log4NetLogger(); if (!useru.Empresa) { if (skills.Count > 0) { skills = usern.InsertSkillsByUser(skills, aspuser); logger2.Info("Inserción Usuario Categoria:" + useru.Id + "," + "UsuarioCategoria:" + skills.FirstOrDefault().CategoryId + ",Email:" + aspuser.Email); } } } catch (Exception er) { return(Json(new { success = false, issue = user, errors = er.Message, tipo = aspuser, UserEmail = useru.Email })); } try { SUser suser = new SUser(); aspuser.Empresa = useru.Empresa; aspuser.Freelance = useru.Freelance; IdentityResult result = await UserManager.UpdateAsync(useru); var userupdate = suser.UpdateUser(aspuser); if (useru.Empresa) { company.IdUser = useru.Id; company.Name = userl[0].Company.Last().Name; company.Mail = userl[0].Company.Last().Mail; company.Site = user.UrlEmpresa; company.Sector = userl[0].Company.Last().Sector; company.RazonSocial = userl[0].Company.Last().RazonSocial; company.Telefono = userl[0].Company.Last().Telefono; company.Nit = userl[0].Company.Last().Nit; company.NumeroEmp = aspuser.NoTrabajadores == null ? 0 : (int)aspuser.NoTrabajadores; company.Description = userl[0].Company.Last().Description; Persistence.Entities.Company companyp = usern.InsertCompany(company); } if (!result.Succeeded) { return(GetErrorResult(result)); } } catch (Exception er) { return(Json(new { success = false, issue = user, errors = er.Message, tipo = user, UserEmail = useru.Email })); //return InternalServerError(er); } aspuser.Empresa = useru.Empresa; aspuser.Freelance = useru.Freelance; aspuser.Id = useru.Id; return(Json(new { success = true, issue = user, errors = "", tipo = aspuser, UserEmail = useru.Email })); //return Ok(); }
public async System.Threading.Tasks.Task <ActionResult> Edit(ModifyStaffViewModel staffviewmodel) { //checks if model is valid if (ModelState.IsValid) { //checks legal working age, 16 and above if (!(staffviewmodel.DOB.Year < DateTime.Now.Year - 16)) { ViewBag.RoleNo = new SelectList(db.Roles, "Id", "Name"); ViewBag.ErrorMessage = "Not legal age to work"; staffviewmodel.Roles = db.Roles.Select(r => new SelectListItem { Text = r.Name, Value = r.Name }).ToList(); return(View(staffviewmodel)); } //scans all instances of staff to check for pre existing staff by these details foreach (Staff s in db.ApplicationUsers.ToList()) { if (s.Id == staffviewmodel.tempid) { continue; } if (s.Email == staffviewmodel.Email || (s.Forename == staffviewmodel.Forename && s.Surname == staffviewmodel.Surname) || s.PhoneNumber == staffviewmodel.Telnum) { ViewBag.RoleNo = new SelectList(db.Roles, "Id", "Name"); ViewBag.ErrorMessage = "Staff Member Already Exists By These Details"; staffviewmodel.Roles = db.Roles.Select(r => new SelectListItem { Text = r.Name, Value = r.Name }).ToList(); return(View(staffviewmodel)); } } //finds user and previous role var staff = UserManager.FindById(staffviewmodel.tempid); string oldRole = (await UserManager.GetRolesAsync(staffviewmodel.tempid)).Single(); //updates details of staff staff.Forename = staffviewmodel.Forename; staff.Surname = staffviewmodel.Surname; staff.DOB = staffviewmodel.DOB; staff.Email = staffviewmodel.Email; staff.City = staffviewmodel.City; staff.PhoneNumber = staffviewmodel.Telnum; staff.UserName = staff.Email; staff.Town = staffviewmodel.Town; staff.Street = staffviewmodel.Street; //saves changes made await UserManager.UpdateAsync(staff); //removes from oldrole defined above, replaces with new role defined in staffviewmodel await UserManager.RemoveFromRoleAsync(staffviewmodel.tempid, oldRole); await UserManager.AddToRoleAsync(staffviewmodel.tempid, staffviewmodel.Role); //if a password is enter into the modifyviewmodel the password is then hashed, removes previous password and add the new one to user if (staffviewmodel.Password != null) { IPasswordHasher passwordHasher = new PasswordHasher(); string hashedpassword = passwordHasher.HashPassword(staffviewmodel.Password); UserManager.RemovePassword(staffviewmodel.tempid); await UserManager.AddPasswordAsync(staffviewmodel.tempid, staffviewmodel.Password); db.SaveChanges(); } //overall savechanges if password is empty db.SaveChanges(); return(RedirectToAction("Index")); } //if model is not valid returns viewmodel confirming error ViewBag.RoleNo = new SelectList(db.Roles, "Id", "Name"); ViewBag.ErrorMessage = "Submission not valid, please fill all fields"; staffviewmodel.Roles = db.Roles.Select(r => new SelectListItem { Text = r.Name, Value = r.Name }).ToList(); return(View(staffviewmodel)); }
public async Task AddEditEmployeesToStore(Store store, ICollection <EmployeeDto> employees) { var employeeRole = await _roleManager.Roles.SingleAsync(role => role.Name == "Employee"); var dbStore = await _dbLjepotaServisContext.Stores.FindAsync(store.Id); var owner = await _userManager.GetUsersForClaimAsync(new Claim(ClaimTypes.Role, RoleHelper.Owner)); var dbEmployees = await _userManager.GetUsersForClaimAsync(new Claim("Store", dbStore.Id.ToString())); dbEmployees = dbEmployees.Except(owner).ToList(); var newEmployees = employees.Where(employee => employee.Id == null).ToList(); employees = employees.Except(newEmployees).ToList(); foreach (var newEmployee in newEmployees) { var employee = newEmployee.ProjectEmployeeDtoToUser(); await _userManager.CreateAsync(employee, newEmployee.Password); await _userManager.AddToRoleAsync(employee, employeeRole.Name); await _userManager.AddClaimAsync(employee, new Claim("Store", store.Id.ToString())); await _userManager.AddClaimAsync(employee, new Claim(ClaimTypes.Role, employeeRole.Name)); var userStore = new UserStore { Store = store, StoreId = store.Id, User = employee, UserId = employee.Id, StartOfShift = newEmployee.StartOfShift, EndOfShift = newEmployee.EndOfShift }; await _dbLjepotaServisContext.AddAsync(userStore); } foreach (var dbEmployee in dbEmployees) { var isEdit = employees.All(employee => employee.Id != dbEmployee.Id); if (employees.Count == 0 && newEmployees.Count == 0) { isEdit = false; } var employeeStore = _dbLjepotaServisContext.UserStores.Single(userStore => userStore.UserId == dbEmployee.Id); if (!isEdit) { _dbLjepotaServisContext.UserStores.Remove(employeeStore); await _userManager.DeleteAsync(dbEmployee); continue; } var employeeDto = employees.Single(employee => employee.Id == dbEmployee.Id); var employeeOrNull = await _userManager.FindByIdAsync(employeeDto.Id); if (employeeOrNull == null) { throw new Exception("User has ID which cannot be found in database"); } employeeOrNull.Email = employeeDto.Email; employeeOrNull.Firstname = employeeDto.FirstName; employeeOrNull.Lastname = employeeDto.LastName; employeeOrNull.Email = employeeDto.Email; employeeOrNull.UserName = employeeDto.Username; employeeOrNull.ImageName = employeeDto.ImageName; employeeStore.EndOfShift = employeeDto.EndOfShift; employeeStore.StartOfShift = employeeDto.EndOfShift; await _userManager.UpdateAsync(employeeOrNull); } await _dbLjepotaServisContext.SaveChangesAsync(); }
public async Task <IdentityResult> UpdateUserAsync(UserEntity user) { return(await _userManager.UpdateAsync(user)); }
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) { //We don't have any users yet. First should be admin. const string AdminRole = "Administrator"; var shouldAddAdminRole = !await userManager.Users.AnyAsync(); if (shouldAddAdminRole) { if (!await roleManager.RoleExistsAsync(AdminRole)) { await roleManager.CreateAsync(new IdentityRole(AdminRole)); logger.LogInformation($"Created new '{AdminRole}' role."); } } var user = new XenialIdentityUser { UserName = Input.Email, Email = Input.Email }; var result = await userManager.CreateAsync(user); if (result.Succeeded) { if (shouldAddAdminRole) { var roleResult = await userManager.AddToRoleAsync(user, AdminRole); if (roleResult.Succeeded) { roleResult = await userManager.UpdateAsync(user); if (roleResult.Succeeded) { logger.LogInformation("Added '{User}' to the '{AdminRole}' role.", user, AdminRole); } } } 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()); }
public async Task <IActionResult> OnPostAsync() { var user = await _userManager.GetUserAsync(User); if (user == null) { return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'.")); } if (!ModelState.IsValid) { await LoadAsync(user); return(Page()); } var phoneNumber = await _userManager.GetPhoneNumberAsync(user); if (Input.PhoneNumber != phoneNumber) { var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber); if (!setPhoneResult.Succeeded) { StatusMessage = "Unexpected error when trying to set phone number."; return(RedirectToPage()); } } #region AddPersonalDetails // Begin adding personal details TODO: Extract to method if (Input.FirstName != user.FirstName) { user.FirstName = Input.FirstName; } if (Input.LastName != user.LastName) { user.LastName = Input.LastName; } if (Input.AddressLine1 != user.AddressLine1) { user.AddressLine1 = Input.AddressLine1; } if (Input.AddressLine2 != user.AddressLine2) { user.AddressLine2 = Input.AddressLine2; } if (Input.City != user.City) { user.City = Input.City; } if (Input.State != user.State) { user.State = Input.State; } if (Input.Zip != user.Zip) { user.Zip = Input.Zip; } if (Input.DateOfBirth != user.DateOfBirth) { user.DateOfBirth = Input.DateOfBirth; } if ((int)Input.Gender != (int)user.Gender) { user.Gender = (TroydonFitnessWebsiteUser.GenderType)Input.Gender; } if (Input.Height != user.Height) { user.Height = Input.Height; } if (Input.Weight != user.Weight) { user.Weight = Input.Weight; } if ((int)Input.ActivityType != (int)user.ActivityType) { user.ActivityType = (TroydonFitnessWebsiteUser.ActivityTypeOptions)Input.ActivityType; } if (Input.Bodyfat != user.Bodyfat) { user.Bodyfat = Input.Bodyfat; } #endregion await _userManager.UpdateAsync(user); await _signInManager.RefreshSignInAsync(user); StatusMessage = "Your profile has been updated"; return(RedirectToPage()); }
public async Task<ActionResult> UpdateUser(string FirstName, string LastName, HttpPostedFileBase file) { var userId = User.Identity.GetUserId(); var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext())); var currentUser = manager.FindById(User.Identity.GetUserId()); if (file != null) { using (MemoryStream ms = new MemoryStream()) { file.InputStream.CopyTo(ms); byte[] array = ms.GetBuffer(); currentUser.Cover = array; currentUser.CoverType = file.ContentType; } } currentUser.LastName = LastName; currentUser.FirstName = FirstName; await manager.UpdateAsync(currentUser); return View("Index"); }
void LockoutUntilYear3015(UserManager<IdentityUser> manager, IdentityUser identityUser) { if (identityUser != null) { identityUser.LockoutEnabled = true; identityUser.LockoutEndDateUtc = DateTime.UtcNow.AddYears(999); manager.UpdateAsync(identityUser); } }
public static async void ConfigureUsers(IEnumerable<InMemoryUser> users, EntityFrameworkServiceOptions options, UserManager userManager) { using(var db = new Contexto(options.ConnectionString)) { if(!db.Users.Any()) { foreach(var u in users) { var entity = new Usuario { Email = u.Claims.First(x=>x.Type==Constants.ClaimTypes.Email).Value , UserName = u.Username }; var response = await userManager.CreateAsync(entity, u.Password); if(!response.Succeeded) { throw new Exception("Não foi possível criar o usuario" + u.Username + response.Errors.ToString()); } else { var user = await userManager.FindAsync(u.Username,u.Password); foreach(var c in u.Claims) { await userManager.AddClaimAsync(user.Id,c); } await userManager.UpdateAsync(user); } } db.SaveChanges(); } } }
public async Task <IActionResult> DeleteSureAsync(int id) { // TODO Defensive and check if admin is from current company. try { var company = _companyRepository.GetById(id); var currentuser = await _userManager.GetUserAsync(HttpContext.User); company.IsDeleted = true; company.UpdatedBy = User.Identity.Name; company.UpdatedDate = DateTime.Now; var response = _companyRepository.Delete(company); if (User.IsInRole("SuperAdmin") || company.Id == currentuser.CompanyId) { if (response != null && response.Id != 0) { var BoardsInDeletedCompany = _boardRepository.GetAllBoardsfromcompany(id).ToList(); foreach (var user in company.Employees) { user.IsDeleted = true; user.UpdatedBy = User.Identity.Name; user.UpdatedDate = DateTime.Now; await _userManager.UpdateAsync(user); } foreach (var board in BoardsInDeletedCompany) { var listoftasksinboard = board.BoardTasks.ToList(); board.IsDeleted = true; board.UpdatedBy = User.Identity.Name; board.UpdatedDate = DateTime.Now; foreach (var task in listoftasksinboard) { task.IsDeleted = true; task.UpdatedBy = User.Identity.Name; task.UpdatedDate = DateTime.Now; _taskRepository.Delete(task); } _boardRepository.Delete(board); } if (User.IsInRole("Admin")) { return(RedirectToAction("Logout", "Account")); } return(RedirectToAction("CompanyList")); } return(View("Delete", company)); } return(View("NotAuthorized")); } catch (Exception ex) { _logger.LogError(ex, $"When deleting a company."); throw; } }
public async Task<ActionResult> addProgressFitBit(string addProgress) { var userStore = new UserStore<ApplicationUser>(context); var userManager = new UserManager<ApplicationUser>(userStore); var currentUser = userManager.FindById(User.Identity.GetUserId()); var fitBitProgressOriginal = currentUser.FitBitProgress; var fitBitAdd = Convert.ToInt32(addProgress); var fitBitProgressNew = (fitBitProgressOriginal += fitBitAdd); currentUser.FitBitProgress = fitBitProgressNew; try { await userManager.UpdateAsync(currentUser); var saveUser = userStore.Context; await saveUser.SaveChangesAsync(); TempData["ValidationMessage"] = "Progress Added!"; } catch { TempData["ValidationMessage"] = "Error: Progress Not Added!"; } return RedirectToAction("Index"); }
public async Task <IActionResult> KullaniciDuzenle(string uyeDetayId, string uyeId, string kayitTarihi, string kullaniciAdi, string sifre, string mail, int durum, int rol, string uyeAd, string uyeSoyad) { try { if (uyeAd == null || uyeSoyad == null) { throw new RequiredFieldsException("Üye bilgileri boş bırakılamaz!"); } else if (kullaniciAdi == null || sifre == null || mail == null) { throw new RequiredFieldsException("Kullanıcı bilgileri boş bırakılamaz!"); } var kullanici = _uyedetayService.GetAll().Where(k => k.kullanici_adi == kullaniciAdi || k.kullanici_mail == mail).ToList(); if (kullanici.Count > 1) { throw new Exception("Bu kullanıcı adı / mail zaten mevcut!"); } else { using (StudyCheckContext context = new StudyCheckContext()) { using (var transaction = context.Database.BeginTransaction()) { try { var oldUser = _uyedetayService.GetById(Convert.ToInt32(uyeDetayId)); var updatedUser = await _userManager.FindByNameAsync(oldUser.kullanici_adi); if (oldUser.kullanici_sifre != sifre) { IdentityResult passResult = await _userManager.ChangePasswordAsync(updatedUser, oldUser.kullanici_sifre, sifre); if (!passResult.Succeeded) { throw new Exception(passResult.Errors.First().Description); } } updatedUser.UserName = kullaniciAdi; updatedUser.NormalizedUserName = kullaniciAdi.ToUpper(); updatedUser.Email = mail; updatedUser.NormalizedEmail = mail.ToUpper(); updatedUser.uyeAdi = uyeAd; updatedUser.uyeSoyadi = uyeSoyad; updatedUser.kullaniciAdi = kullaniciAdi; updatedUser.kullaniciSifre = sifre; updatedUser.kullaniciMail = mail; updatedUser.rolId = rol; IdentityResult result = await _userManager.UpdateAsync(updatedUser); if (!result.Succeeded) { throw new Exception(result.Errors.First().Description); } else { Uye updatedUye = new Uye { id = Convert.ToInt32(uyeId), uye_ad = uyeAd, uye_soyad = uyeSoyad }; context.Uyeler.Update(updatedUye); context.SaveChanges(); var identityUser = await _userManager.GetUserAsync(HttpContext.User); Uyedetay updatedKullanici = new Uyedetay { id = Convert.ToInt32(uyeDetayId), kullanici_adi = kullaniciAdi, kullanici_sifre = sifre, kullanici_mail = mail, kayit_tarihi = Convert.ToDateTime(kayitTarihi), guncelleyen_id = identityUser.uyeDetayId, guncelleme_tarihi = DateTime.Now, uye_id = Convert.ToInt32(uyeId), rol_id = rol, tema_id = 1, sil_id = durum }; context.UyeDetay.Update(updatedKullanici); context.SaveChanges(); } } catch (Exception transException) { transaction.Rollback(); throw new Exception(transException.Message); } TempData["Sonuc"] = "Kullanıcı güncellendi"; transaction.Commit(); } } } } catch (Exception ex) { TempData["Exception"] = ex.Message; } return(RedirectToAction("KullaniciListesi")); }
public async Task<ActionResult> Edit(EditViewModel model) { if (ModelState.IsValid) { var store = new UserStore<ApplicationUser>(new ApplicationDbContext()); var manager = new UserManager<ApplicationUser>(store); // Get the current application user var user = UserManager.FindById(User.Identity.GetUserId());; // Update the details user.FirstName = model.FirstName; user.LastName = model.LastName; user.EMail = model.EMail; user.City = model.City; user.Age = model.Age; // This is the part that doesn't work var result = await manager.UpdateAsync(user); var ctx = store.Context; ctx.SaveChanges(); // However, it always succeeds inspite of not updating the database if (!result.Succeeded) { AddErrors(result); } } return RedirectToAction("Manage"); }