public async Task <RequestResult> Register(AspNetUserVM model)
{
if (!ModelState.IsValid)
{
return(new RequestResult {
Message = "All fields are required", Status = false
});
}
var user = usersBL.GetUserByEmail(model.Email);
if (user == null)
{
AspNetUserDVM usern = new AspNetUserDVM
{
AccessFailedCount = model.AccessFailedCount,
ConcurrencyStamp = model.ConcurrencyStamp,
Email = model.Email,
UserName = model.UserName,
Password = model.Password
};
bool result = await usersBL.AddUser(usern, "App User");
if (result)
{
return(new RequestResult {
Message = "Password has been changed.", Status = true
});
}
}
return(new RequestResult {
Message = "Unable to change your password. Please try again.", Status = false
});
}
public async Task <string> ForgotPassword(AspNetUserDVM dvm)
{
string password = string.Empty;
if (dvm != null)
{
var user = await userManager.FindByEmailAsync(dvm.Email);
if (user != null)
{
string token = await userManager.GeneratePasswordResetTokenAsync(user);
if (!string.IsNullOrEmpty(token))
{
var result = await userManager.ResetPasswordAsync(user, token, dvm.NewPassword);
if (result.Succeeded)
{
return(dvm.NewPassword);
}
}
}
}
return(password);
}
/// <summary>
/// This method gets a user that has logged in
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
public AspNetUserDVM GetLoggedInUser(string email)
{
AspNetUserDVM ndvm = new AspNetUserDVM();
if (!string.IsNullOrEmpty(email))
{
ndvm = mapper.Map <AspNetUserDVM>(userManager.FindByEmailAsync(email).Result);
}
return(ndvm);
}
/// <summary>
/// This method logs a user in
/// </summary>
/// <param name="dvm"></param>
/// <returns></returns>
public AspNetUserDVM Login(AspNetUserDVM dvm)
{
AspNetUserDVM ndvm = new AspNetUserDVM();
if (dvm != null)
{
if (signInManager.PasswordSignInAsync(dvm.Email, dvm.PasswordHash, dvm.RememberMe, false).Result.Succeeded)
{
ndvm = mapper.Map <AspNetUserDVM>(userManager.FindByEmailAsync(dvm.Email).Result);
}
ndvm.Roles = userManager.GetRolesAsync(userManager.FindByEmailAsync(dvm.Email).Result).Result.ToList();
}
return(ndvm);
}
/// <summary>
/// This method gets a user by email
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public AspNetUserDVM GetUserByEmail(string email)
{
AspNetUserDVM dvm = new AspNetUserDVM();
if (!string.IsNullOrEmpty(email))
{
var m = userManager.FindByEmailAsync(email).Result;
if (m != null)
{
dvm = mapper.Map <AspNetUserDVM>(m);
}
}
return(dvm);
}
/// <summary>
/// This method gets a user by user id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public AspNetUserDVM GetUserByUserId(string id)
{
AspNetUserDVM dvm = new AspNetUserDVM();
if (!string.IsNullOrEmpty(id))
{
var m = userManager.FindByIdAsync(id).Result;
if (m != null)
{
dvm = mapper.Map <AspNetUserDVM>(m);
}
}
return(dvm);
}
/// <summary>
/// This method adds a new user
/// </summary>
/// <param name="dvm"></param>
/// <returns></returns>
public async Task <bool> AddUser(AspNetUserDVM dvm, string role)
{
bool status = false;
if (dvm != null && !string.IsNullOrEmpty(role))
{
AspNetUser a = mapper.Map <AspNetUser>(dvm);
try
{
var roleD = roleManager.FindByNameAsync(role);
if (roleD != null)
{
var d = userManager.CreateAsync(a);
if (d.Result.Succeeded)
{
await userManager.AddToRoleAsync(a, role);
status = true;
}
}
else
{
var roleDVM = new AspNetRoleDVM
{
Name = role
};
if (await AddRole(roleDVM))
{
var d = userManager.CreateAsync(a);
if (d.Result.Succeeded)
{
await userManager.AddToRoleAsync(a, role);
status = true;
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
return(status);
}
public async Task <bool> ChangePassword(AspNetUserDVM dvm)
{
if (dvm != null)
{
var user = await userManager.FindByEmailAsync(dvm.Email);
if (user != null)
{
var result = await userManager.ChangePasswordAsync(user, dvm.OldPassword, dvm.NewPassword);
if (result.Succeeded)
{
return(result.Succeeded);
}
}
}
return(false);
}
/// <summary>
/// This method updates user
/// </summary>
/// <param name="dvm"></param>
/// <returns></returns>
public bool UpdateUser(AspNetUserDVM dvm)
{
bool status = false;
if (dvm != null)
{
var m = userManager.FindByIdAsync(dvm.Id).Result;
if (m != null)
{
m.PhoneNumber = dvm.PhoneNumber;
m.UserName = dvm.UserName;
if (userManager.UpdateAsync(m).Result.Succeeded)
{
status = true;
}
}
}
return(status);
}
/// <summary>
/// This method adds a user to a role
/// </summary>
/// <param name="dvm"></param>
/// <returns></returns>
public async Task <bool> AddUserToRoles(AspNetUserDVM dvm)
{
bool status = false;
if (dvm != null)
{
AspNetUser a = mapper.Map <AspNetUser>(dvm);
try
{
var result = await userManager.AddToRolesAsync(a, dvm.Roles);
if (result.Succeeded)
{
status = true;
}
}
catch (Exception ex)
{
throw ex;
}
}
return(status);
}
/// <summary>
/// This method adds a new user
/// </summary>
/// <param name="dvm"></param>
/// <returns></returns>
public async Task <bool> AddUserAndSignIn(AspNetUserDVM dvm, string role)
{
bool status = false;
if (dvm != null && !string.IsNullOrEmpty(role))
{
AspNetUser a = mapper.Map <AspNetUser>(dvm);
a.UserName = dvm.Email;
try
{
var roleD = roleManager.FindByNameAsync(role).Result;
AspNetUser chk = userManager.FindByEmailAsync(dvm.Email).Result;
if (roleD != null && chk != null)
{
var rolechk = userManager.GetRolesAsync(chk).Result;
if (rolechk.Count() > 0)
{
if (signInManager.PasswordSignInAsync(chk, dvm.PasswordHash, true, false).Result.Succeeded)
{
status = true;
}
}
else
{
var rdvm = new AspNetUserRoleDVM
{
RoleId = roleD.Id,
UserId = chk.Id
};
if (AddUserToRole(rdvm))
{
if (signInManager.PasswordSignInAsync(a, dvm.PasswordHash, true, false).Result.Succeeded)
{
status = true;
}
}
}
}
else if (roleD != null && chk == null)
{
var d = userManager.CreateAsync(a, dvm.PasswordHash);
if (d.Result.Succeeded)
{
var luser = userManager.FindByEmailAsync(dvm.Email).Result;
var rdvm = new AspNetUserRoleDVM
{
RoleId = roleD.Id,
UserId = luser.Id
};
if (AddUserToRole(rdvm))
{
if (signInManager.PasswordSignInAsync(a, dvm.PasswordHash, false, false).Result.Succeeded)
{
status = true;
}
}
}
}
else if (roleD == null && chk == null)
{
var roleDVM = new AspNetRoleDVM
{
Name = role
};
if (await AddRole(roleDVM))
{
var d = userManager.CreateAsync(a, dvm.PasswordHash);
if (d.Result.Succeeded)
{
await userManager.AddToRoleAsync(a, role);
if (signInManager.PasswordSignInAsync(a, dvm.PasswordHash, true, false).Result.Succeeded)
{
status = true;
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
return(status);
}
