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);
}
