public async Task <AuthenticationResult> RegisterAsync(string email, string password, string userName) { var existingUser = await _userManager.FindByEmailAsync(email); if (existingUser != null) { return(new AuthenticationResult { Errors = new[] { "User with this email address already exists" } }); } var newUserId = Guid.NewGuid(); var newUser = new ExtendedIdentityUser { Id = newUserId.ToString(), Email = email, UserName = userName, }; var createdUser = await _userManager.CreateAsync(newUser, password); if (!createdUser.Succeeded) { return new AuthenticationResult { Errors = createdUser.Errors.Select(x => x.Description) } } ; await _userManager.AddClaimAsync(newUser, new Claim("tags.view", "true")); return(await GenerateAuthenticationResultForUserAsync(newUser)); }
public async Task <IActionResult> Register(RegistrationVIewModel model) { if (ModelState.IsValid) { var user = new ExtendedIdentityUser() { UserName = model.Email, Email = model.Email, City = model.City, Zip = model.Zip }; var result = await _user.CreateAsync(user, model.Password); if (result.Succeeded) { _signInManager.SignInAsync(user, true); return(RedirectToAction("List", "Home")); } foreach (var errors in result.Errors) { ModelState.AddModelError("", errors.Description); } } return(View()); }
public Result BulkDeleteUser(List <string> id) { int count = 0; Result result = new Result(); foreach (string tempId in id) { ExtendedIdentityUser user = _repo.GetById <ExtendedIdentityUser>(Convert.ToInt32(tempId)); try { _repo.Delete(user); _repo.Save(); count++; result.Message = count.ToString() + " " + (count > 1 ? "users" : "user") + " " + (count > 1 ? "have" : "has") + " been successfully deleted."; result.Success = true; } catch (Exception e) { result.Message = "Error deleting user."; result.ErrorCode = ErrorCode.EXCEPTION; _logger.LogError("Error calling BulkDeleteUser: {0}", e.Message); } } return(result); }
public async Task <IdentityResult> AddNewUser(ExtendedIdentityUser user) { try { var result = await _userManager.CreateAsync(user, this.Password); if (result.Succeeded) { var role = await _roleManager.FindByIdAsync(this.Role); var roleResult = await _userManager.AddToRoleAsync(user, role.Name); if (roleResult.Succeeded) { Notification = new NotificationModel("Success !!", "Successfully Added User", NotificationType.Success); return(result); } } } catch (Exception e) { Notification = new NotificationModel("Failed !!", "Failed to Add User", NotificationType.Fail); throw e; } return(null); }
public void BeforeEachTestAfterBase() { var users = Database.GetCollection <ExtendedIdentityUser>("users"); var userStore = new IdentityStore <ExtendedIdentityUser>(users); _Manager = new UserManager <ExtendedIdentityUser>(userStore); _User = new ExtendedIdentityUser("bob"); }
public void BeforeEachTestAfterBase() { _Manager = CreateServiceProvider <ExtendedIdentityUser, IdentityRole>() .GetService <UserManager <ExtendedIdentityUser> >(); _User = new ExtendedIdentityUser { UserName = "******" }; }
public void BeforeEachTestAfterBase() { var users = DatabaseNewApi.GetCollection<ExtendedIdentityUser>("users"); UserStore<ExtendedIdentityUser> userStore = new UserStore<ExtendedIdentityUser>(users); _Manager = new UserManager<ExtendedIdentityUser>(userStore); _User = new ExtendedIdentityUser { UserName = "******" }; }
public void BeforeEachTestAfterBase() { var context = new IdentityContext(Users); var userStore = new UserStore<ExtendedIdentityUser>(context); _Manager = new UserManager<ExtendedIdentityUser>(userStore); _User = new ExtendedIdentityUser { UserName = "******" }; }
public void BeforeEachTestAfterBase() { var context = new IdentityContext(DatabaseConnection, DB); var userStore = new UserStore <ExtendedIdentityUser>(context); _Manager = new UserManager <ExtendedIdentityUser>(userStore); _User = new ExtendedIdentityUser { UserName = "******" }; }
public async Task <IActionResult> Register(RegisterModel model) { model.ReturnUrl = model.ReturnUrl ?? Url.Content("~/admin"); if (ModelState.IsValid) { var user = new ExtendedIdentityUser { Name = model.Name, UserName = model.Email, Email = model.Email, Address = model.Address, City = model.City, Country = model.Country, PhoneNumber = model.PhoneNumber }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { _logger.LogInformation("User created a new account with password."); var role = await _roleManager.FindByIdAsync(model.Role); var roleResult = await _userManager.AddToRoleAsync(user, role.Name); if (roleResult.Succeeded) { var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.Action( "ConfirmEmail", "Account", values: new { userId = user.Id, code = code }, protocol: Request.Scheme); await _emailSender.SendEmailAsync(model.Email, "Confirm your email", $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>."); await _signInManager.SignInAsync(user, isPersistent : false); return(LocalRedirect(model.ReturnUrl)); } } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } // If we got this far, something failed, redisplay form return(View(model)); }
public void BeforeEachTestAfterBase() { var context = new UsersContext <IdentityUser>(Users); var userStore = new UserStore <IdentityUser>(context); manager = new UserManager <IdentityUser>(userStore); user = new ExtendedIdentityUser { UserName = "******" }; }
protected void Application_Start() { GlobalConfiguration.Configure(WebApiConfig.Register); ApplicationDbContext db = new ApplicationDbContext(); RoleStore <IdentityRole> rolestore = new RoleStore <IdentityRole>(db); RoleManager <IdentityRole> rolemanage = new RoleManager <IdentityRole>(rolestore); UserStore <ExtendedIdentityUser> userStore = new UserStore <ExtendedIdentityUser>(db); UserManager <ExtendedIdentityUser> userManager = new UserManager <ExtendedIdentityUser>(userStore); string adminRole = nameof(Role.ADMINISTRATOR); string seRole = nameof(Role.SERVICEENGINEER); string wcRole = nameof(Role.WORKCONTROLLER); if (!rolemanage.RoleExists(adminRole)) { rolemanage.Create(new IdentityRole() { Name = adminRole }); } if (!rolemanage.RoleExists(wcRole)) { rolemanage.Create(new IdentityRole() { Name = seRole }); } if (!rolemanage.RoleExists(seRole)) { rolemanage.Create(new IdentityRole() { Name = wcRole }); } if (userManager.FindByName("Administrator") == null) { var user = new ExtendedIdentityUser { UserName = "******", Email = "*****@*****.**", FirstName = "admin", LastName = "admin" }; userManager.Create(user, "it$$001"); userManager.AddToRole(user.Id, "Administrator"); } }
public Result DeleteUser(string id) { Result result = new Result(); ExtendedIdentityUser user = _repo.GetById <ExtendedIdentityUser>(Convert.ToInt32(id)); try { _repo.Delete(user); _repo.Save(); result.Message = "User has been successfully deleted."; result.Success = true; } catch (Exception) { throw; } return(result); }
public async Task <IActionResult> Add(UserUpdateModel model) { model.ReturnUrl = model.ReturnUrl ?? Url.Content("~/"); if (ModelState.IsValid) { var user = new ExtendedIdentityUser { UserName = model.Email, Email = model.Email }; var result = await model.AddNewUser(user); if (result.Succeeded) { var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.Action( "ConfirmEmail", "Account", values: new { userId = user.Id, code = code }, protocol: Request.Scheme); await _emailSender.SendEmailAsync(model.Email, "Confirm your email", $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>."); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); new NotificationModel("Failed !!", "Failed to Add User", NotificationType.Fail); } } } ViewBag.RoleList = (from r in _roleManager.Roles select new SelectListItem { Text = r.Id, Value = r.Name }).ToList(); // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <IActionResult> OnPostAsync(string returnUrl = null) { returnUrl = returnUrl ?? Url.Content("~/"); if (ModelState.IsValid) { var user = new ExtendedIdentityUser { UserName = Input.Email, Email = Input.Email }; var result = await _userManager.CreateAsync(user, Input.Password); if (result.Succeeded) { _logger.LogInformation("User created a new account with password."); var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.Page( "/Account/ConfirmEmail", pageHandler: null, values: new { userId = user.Id, 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>."); 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 async Task <AuthenticationResult> GenerateAuthenticationResultForUserAsync(ExtendedIdentityUser user) { var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(_jwtSettings.Secret); var claims = new List <Claim> { new Claim(JwtRegisteredClaimNames.Sub, user.Email), new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()), new Claim(JwtRegisteredClaimNames.Email, user.Email), new Claim("id", user.Id) }; var userClaims = await _userManager.GetClaimsAsync(user); claims.AddRange(userClaims); var userRoles = await _userManager.GetRolesAsync(user); foreach (var userRole in userRoles) { claims.Add(new Claim(ClaimTypes.Role, userRole)); var role = await _roleManager.FindByNameAsync(userRole); if (role == null) { continue; } var roleClaims = await _roleManager.GetClaimsAsync(role); foreach (var roleClaim in roleClaims) { if (claims.Contains(roleClaim)) { continue; } claims.Add(roleClaim); } } var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(claims), Expires = DateTime.UtcNow.Add(_jwtSettings.TokenLifeTime), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature) }; var token = tokenHandler.CreateToken(tokenDescriptor); var refreshToken = new RefreshToken { JwtId = token.Id, UserId = user.Id, CreationDate = DateTime.UtcNow, ExpireDate = DateTime.UtcNow.AddMonths(6) }; var result = await _identityRepository.AddRefreshTokenAsync(refreshToken); return(new AuthenticationResult { Success = true, Token = tokenHandler.WriteToken(token), RefreshToken = result }); }
public async Task <Result> CreateUser(AddUserDTO dto) { var response = new Result(); try { var valResult = await _validationService.IsValidAccountInfo(dto.UserName, dto.Email, dto.Password, dto.ConfirmPassword); if (!valResult.IsValid) { response.Message = valResult.Message; response.ErrorCode = ErrorCode.INVALID_INPUT; return(response); } if (string.IsNullOrEmpty(dto.DepartmentId)) { response.Message = "Please fill in the required fields."; response.ErrorCode = ErrorCode.INVALID_INPUT; return(response); } if (!Enum.IsDefined(typeof(TypeOfNotification), dto.TypeOfNotification)) { response.Message = "Please fill in the required fields."; response.ErrorCode = ErrorCode.INVALID_INPUT; return(response); } ExtendedIdentityUser user = new ExtendedIdentityUser { FirstName = dto.FirstName, LastName = dto.LastName, Email = dto.Email, UserName = dto.UserName, DepartmentId = dto.DepartmentId, CreatedBy = dto.CreatedBy, EmailConfirmed = true, TypeOfNotification = dto.TypeOfNotification, HasPasswordChanged = false }; var result = await _userManager.CreateAsync(user, dto.Password); if (result.Succeeded) { var addrole = await _userManager.AddToRoleAsync(user, dto.Role); //Default Module Access Rights var modules = _repo.GetAll <Module>(); foreach (var item in modules) { var rights = new UserRights(); rights.UserId = user.Id; rights.ModuleId = item.Id; rights.View = true; rights.Add = true; rights.Edit = true; if (dto.Role == "USER") { if (item.Name == "Maintenance") { rights.Add = false; rights.Edit = false; } else if (item.Name == "Approval") { rights.View = true; rights.Add = false; rights.Edit = false; } } rights.Delete = false; _repo.Create(rights); await _repo.SaveAsync(); } ; response.Success = true; response.Message = "User has been successfully added."; response.ErrorCode = ErrorCode.DEFAULT; } } catch (Exception e) { response.Message = "Error adding company"; response.ErrorCode = ErrorCode.EXCEPTION; _logger.LogError("Error calling AddCompany: {0}", e.Message); } return(response); }
public static async Task Seed(ApplicationDbContext context, RoleManager <IdentityRole <int> > roleManager, UserManager <ExtendedIdentityUser> userManager, IHostingEnvironment env, IAdminService adminService, IMaintenanceService maintenanceService) { context.Database.EnsureCreated(); string adminRole = nameof(Role.ADMINISTRATOR); string dpoRole = nameof(Role.DPO); string userRole = nameof(Role.USER); string deptHeadRole = nameof(Role.DEPTHEAD); if (await roleManager.FindByNameAsync(adminRole) == null) { var ir = await roleManager.CreateAsync(new IdentityRole <int>(adminRole)); } if (await roleManager.FindByNameAsync(dpoRole) == null) { var ir = await roleManager.CreateAsync(new IdentityRole <int>(dpoRole)); } if (await roleManager.FindByNameAsync(userRole) == null) { var ir = await roleManager.CreateAsync(new IdentityRole <int>(userRole)); } if (await roleManager.FindByNameAsync(deptHeadRole) == null) { var ir = await roleManager.CreateAsync(new IdentityRole <int>(deptHeadRole)); } var admin = await userManager.GetUsersInRoleAsync(adminRole); var adminUser = string.Empty; var x = (context.GetService <IDatabaseCreator>() as RelationalDatabaseCreator).Exists(); //validation if database was already seeded if (!context.Users.Any()) { var dataPath = Path.Combine(env.ContentRootPath, "Data", "seed"); if (Directory.Exists(dataPath)) { var adminSettings = Path.Combine(dataPath, "adminSettings.json"); if (File.Exists(adminSettings)) { UserDTO sa = JsonConvert.DeserializeObject <UserDTO>(System.IO.File.ReadAllText(adminSettings)); if (admin.Count() == 0) { var addAdmin = new ExtendedIdentityUser { UserName = sa.UserName, Email = sa.Email, FirstName = sa.FirstName, LastName = sa.LastName, EmailConfirmed = sa.EmailConfirmed }; var result = await userManager.CreateAsync(addAdmin, sa.Password); if (result.Succeeded) { var addrole = await userManager.AddToRoleAsync(addAdmin, adminRole); //File.Delete(adminSettings); } adminUser = addAdmin.Id.ToString(); } else { adminUser = admin.FirstOrDefault().Id.ToString(); } } var dpoSettings = Path.Combine(dataPath, "dposettings.json"); if (File.Exists(dpoSettings)) { UserDTO sa = JsonConvert.DeserializeObject <UserDTO>(System.IO.File.ReadAllText(dpoSettings)); if (admin.Count() == 0) { var addDpo = new ExtendedIdentityUser { UserName = sa.UserName, Email = sa.Email, FirstName = sa.FirstName, LastName = sa.LastName, EmailConfirmed = sa.EmailConfirmed }; var result = await userManager.CreateAsync(addDpo, sa.Password); if (result.Succeeded) { var addrole = await userManager.AddToRoleAsync(addDpo, dpoRole); //File.Delete(adminSettings); } } } var fields = Path.Combine(dataPath, "default-fields.json"); if (File.Exists(fields)) { List <AddFieldDTO> dto = JsonConvert.DeserializeObject <List <AddFieldDTO> >(System.IO.File.ReadAllText(fields)); var addresult = await adminService.AddFields(dto, adminUser); if (addresult.Success) { //File.Delete(fields); } } var departments = Path.Combine(dataPath, "default-departments.json"); if (File.Exists(departments)) { List <AddDepartmentDTO> dto = JsonConvert.DeserializeObject <List <AddDepartmentDTO> >(System.IO.File.ReadAllText(departments)); foreach (AddDepartmentDTO item in dto) { await maintenanceService.CreateDepartment(item, adminUser); } } var modules = Path.Combine(dataPath, "modules.json"); if (File.Exists(modules)) { List <AddModuleDTO> dto = JsonConvert.DeserializeObject <List <AddModuleDTO> >(System.IO.File.ReadAllText(modules)); var addresult = await adminService.AddModules(dto, adminUser); if (addresult.Success) { //File.Delete(modules); } } var datasets = Path.Combine(dataPath, "dataset.json"); if (File.Exists(datasets)) { List <AddDatasetDTO> dto = JsonConvert.DeserializeObject <List <AddDatasetDTO> >(System.IO.File.ReadAllText(datasets)); var addresult = await adminService.AddDatasets(dto, adminUser); if (addresult.Success) { //File.Delete(modules); } } var userGuide = Path.Combine(dataPath, "user-guide.json"); if (File.Exists(datasets)) { AddResourceDTO dto = JsonConvert.DeserializeObject <AddResourceDTO>(System.IO.File.ReadAllText(userGuide)); var addresult = await adminService.CreateUserGuideResource(dto, adminUser); if (addresult.Success) { //File.Delete(modules); } } } } }
public async Task <Result> CreateUser(AddUserDTO dto) { var response = new Result(); try { var valResult = await _validationService.IsValidAccountInfo(dto.UserName, dto.Email, dto.Password, dto.ConfirmPassword); if (!valResult.IsValid) { response.Message = valResult.Message; response.ErrorCode = ErrorCode.INVALID_INPUT; return(response); } if (String.IsNullOrEmpty(dto.DepartmentId)) { response.Message = "Please fill in the required fields."; response.ErrorCode = ErrorCode.INVALID_INPUT; return(response); } if (Enum.IsDefined(typeof(TypeOfNotification), dto.TypeOfNotification)) { response.Message = "Please fill in the required fields."; response.ErrorCode = ErrorCode.INVALID_INPUT; return(response); } ExtendedIdentityUser user = new ExtendedIdentityUser { FirstName = dto.FirstName, LastName = dto.LastName, Email = dto.Email, UserName = dto.UserName, DepartmentId = dto.DepartmentId, CreatedBy = dto.CreatedBy, EmailConfirmed = true, TypeOfNotification = dto.TypeOfNotification }; var result = await _userManager.CreateAsync(user, dto.Password); if (result.Succeeded) { var addrole = await _userManager.AddToRoleAsync(user, dto.Role); response.Success = true; response.Message = "User has been successfully added."; response.ErrorCode = ErrorCode.DEFAULT; } } catch (Exception e) { response.Message = "Error adding user"; response.ErrorCode = ErrorCode.EXCEPTION; _logger.LogError("Error calling CreateUser: {0}", e.Message); } return(response); }
public async Task <ValidationResult> IsPasswordValid(ChangePasswordUserDTO dto, ExtendedIdentityUser user) { ValidationResult result = new ValidationResult(); if (dto.NewPassword != dto.ConfirmPassword) { result.Message = "New and confirm password did not match."; return(result); } else if (!Commons.Helper.Validation.IsValidPassword(dto.NewPassword)) { result.Message = "Invalid password. Password must be at least 8 characters long, contain a number and an uppercase letter."; return(result); } //see if user filled old password is same as current password var hasSameOldPassword = await _userManager.CheckPasswordAsync(user, dto.OldPassword); //if filled old pass and current pass did not match if (!hasSameOldPassword) { result.Message = "Invalid old password."; return(result); } else if (hasSameOldPassword && dto.OldPassword == dto.NewPassword) { result.Message = "New password must be different."; return(result); } // Its valid if reached here result.IsValid = true; return(result); }