public async Task SendVerificationEmail(IdentityUserViewModel model)
{
try
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
throw new Exception($"Unable to load user");
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = UrlHelperExtensions.EmailConfirmationLink(user.Id, code);
var email = user.Email;
await _emailSender.SendEmailAsync(email, "Confirm email", callbackUrl);
_logger.LogInformation($"Verification email sent to {user.Id}.");
}
catch (Exception ex)
{
_logger.LogError(ex);
}
}
public async Task <IActionResult> Register([FromBody] RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
model.Password = "******";
var user = new IdentityUserViewModel()
{
UserName = model.Email,
Email = model.Email,
DateOfBirth = model.DateOfBirth,
Gender = model.Gender,
CityId = model.CityId,
CountryId = model.CountryId,
AboutInfo = model.AboutInfo
};
IdentityResult result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
result = await userManager.AddToRoleAsync(user, UserRoles.User.ToString());
}
IActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(errorResult);
}
return(Ok(result.Succeeded));
}
public async Task <IHttpActionResult> Register(RegisterBindingModel bindingModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new IdentityUserViewModel {
UserName = bindingModel.Email, Email = bindingModel.Email, NewsLetterIds = bindingModel.NewsLetterIds
};
try
{
IdentityResult result = await UserManager.CreateAsync(user, bindingModel.Password);
IHttpActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(errorResult);
}
return(Ok(new { message = AppMessages.SIGNUP_SUCCESS_REDIRECT_TIMEOUT_MESSAGE }));
} catch (Exception ex)
{
if (CheckUniqueKeyException(ex))
{
return(BadRequest(AppMessages.SIGNUP_ERROR_DUPLICATE_KEY_MESSAGE));
}
return(InternalServerError(ex));
}
}
public async Task <IOperationResult> UpdateIdentityUser(string userId, IdentityUserViewModel model)
{
try
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
throw new Exception($"Unable to load user");
}
if (model.Email != user.Email)
{
await _userManager.SetEmailAsync(user, model.Email);
}
if (model.PhoneNumber != user.PhoneNumber)
{
await _userManager.SetPhoneNumberAsync(user, model.PhoneNumber);
}
return(OperationResult.Success);
}
catch (Exception ex)
{
_logger.LogError(ex);
return(OperationResult.Failed(ex.Message));
}
}
public static IdentityUserViewModel ToIdentityUserViewModel(this ApplicationUser model)
{
var i = new IdentityUserViewModel();
i.Assign(model);
return i;
}
public async Task <IHttpActionResult> Register(RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new IdentityUserViewModel()
{
UserName = "******" + DateTime.Now.Ticks,
Email = model.Email,
AgeRange = model.AgeRange,
Gender = model.Gender
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
IHttpActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(errorResult);
}
return(Ok(new { message = AppMessages.SIGNUP_SUCCESS_REDIRECT_TIMEOUT_MESSAGE }));
}
public BaseResponseResult SendUserRegistrationMail(IdentityUserViewModel viewModel)
{
BaseResponseResult result = new BaseResponseResult();
try
{
if (string.IsNullOrEmpty(viewModel.Email) == false)
{
var maiTemplate = new UserRegistrationMail(viewModel.Email, viewModel.InputPassword);
//var queueViewModel = maiTemplate.CreateEmailQueueViewModel(viewModel.Email);
//var entity = queueViewModel.ToEntityModel<EmailQueue, EmailQueueViewModel>();
//result.IsSucceed = AddEmailIntoQueue(entity);
if (result.IsSucceed)
{
result.Message = AppMessages.Email_Succeed_Message;
}
else
{
result.Message = AppMessages.Email_Failed_Message;
}
}
}
catch (ApplicationException)
{
result.IsSucceed = false;
result.Message = AppMessages.Email_Failed_Message;
}
return(result);
}
public static async Task<IdentityUserViewModel> ToIdentityUserViewModelAsync(this ApplicationUser model, IdentityManagerService service)
{
var i = new IdentityUserViewModel();
i.Assign(model);
if (service != null) i.Role = await service.GetMainRoleForUserAsync(model.Id) ?? "";
return i;
}
public async Task <IHttpActionResult> RegisterExternal(RegisterExternalBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
model.UserName = "******" + DateTime.Now.Ticks;
var verifiedAccessToken = await VerifyExternalAccessToken(model.Provider, model.ExternalAccessToken);
if (verifiedAccessToken == null)
{
return(BadRequest("Invalid Provider or External Access Token"));
}
var user = await UserManager.FindAsync(new UserLoginInfo(model.Provider, verifiedAccessToken.user_id));
bool hasRegistered = user != null;
if (hasRegistered)
{
return(BadRequest("External user is already registered"));
}
user = new IdentityUserViewModel()
{
UserName = model.UserName, AgeRange = model.AgeRange, Email = model.Email
};
IdentityResult result = await UserManager.CreateAsync(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
var info = new ExternalLoginInfo()
{
DefaultUserName = model.UserName,
Login = new UserLoginInfo(model.Provider, verifiedAccessToken.user_id)
};
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
//generate access token response
var accessTokenResponse = GenerateLocalAccessTokenResponse(model.UserName);
return(Ok(accessTokenResponse));
}
public IActionResult Create()
{
var userModel = new IdentityUserViewModel()
{
profile = new ProfileViewModel()
};
var model = new IdentityUserEditViewModel {
user = userModel, roleOptions = GetRoleOptions()
};
model.roles = new string[] { "Staff" };
return(Ok(model));
}
public async Task <IActionResult> Edit(string id, [Bind("Id,UserName,Role")] IdentityUserViewModel userVM)
{
if (string.IsNullOrWhiteSpace(id))
{
return(NotFound());
}
var newRole = userVM.Role;
var role = await _roleManager.FindByNameAsync(newRole);
if (role != null)
{
var user = await _userManager.FindByIdAsync(id);
// wez role usera tego powyzej
var prevRoleList = await _userManager.GetRolesAsync(user);
string prevRole = prevRoleList.FirstOrDefault();
// usun z tego usera stara role
await _userManager.RemoveFromRoleAsync(user, prevRole);
// mozwile ze tu bedzie trzeba savechanges ale jak nie to gituwa
// przypisz nowa role do usera
await _userManager.AddToRolesAsync(user, new List <string> {
role.Name
});
//update i elo
//_context.Update(user);
await _context.SaveChangesAsync();
}
//if (await _userManager.IsInRoleAsync(user, "Customer"))
//{
// await _userManager.RemoveFromRoleAsync(user, "Customer");
// //await _context.saveChangesAsync()
// await _userManager.AddToRoleAsync(user, newRole);
//}
//_context.Update(user);
//await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
//return View(user);
}
// GET /Me
public async Task <IdentityUserViewModel> Me()
{
var u = await ApplicationUserManager.FindByIdAsync(this.TokenId.Id);
var displayUser = new IdentityUserViewModel()
{
Id = u.Id,
UserName = u.UserName,
Email = u.Email,
LocalNumber = u.LocalNumber,
Role = u.Role,
FirstName = u.FirstName,
LastName = u.LastName,
PhoneNumber = u.PhoneNumber
};
return(displayUser);
}
public async Task <IActionResult> Index()
{
var allUsers = _userManager.Users.ToList();
var allUsersVM = new List <IdentityUserViewModel>();
foreach (var user in allUsers)
{
var roles = await _userManager.GetRolesAsync(user);
var role = roles.FirstOrDefault();
IdentityUserViewModel identityUserVM = new IdentityUserViewModel
{
Id = user.Id,
UserName = Ceasar.Decipher(user.UserName, CipherKey),
Role = role
};
allUsersVM.Add(identityUserVM);
}
return(View(allUsersVM));
}
public static IdentityUserViewModel MapIdentityUserViewModel(ApplicationUser user, IEnumerable <IdentityRole> roles = null)
{
var model = new IdentityUserViewModel
{
id = user.Id,
name = user.UserName,
email = user.Email,
};
if (user.Profile != null)
{
model.profile = MapProfileViewModel(user.Profile);
}
if (!roles.IsNullOrEmpty())
{
model.roles = String.Join(",", roles.Select(r => r.Name));
}
return(model);
}
//[AllowAnonymous]
//[ValidateAntiForgeryToken]
public async Task <IActionResult> LoginConfirmation([FromBody] ExternalLoginViewModel registration)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
//var info = await signInManager.GetExternalLoginInfoAsync();
//if (info == null)
//{
// throw new ApplicationException("Error loading external login information during confirmation.");
//}
var info = new UserLoginInfo(registration.LoginProvider, registration.ProviderKey, registration.ProviderDisplayName);
var user = new IdentityUserViewModel {
UserName = AppMethods.GenerateUserName(registration.Email), Email = registration.Email
};
var response = await userManager.CreateAsync(user);
if (response.Succeeded)
{
response = await userManager.AddToRoleAsync(user, UserRoles.User.ToString());
}
if (response.Succeeded)
{
user.RoleName = UserRoles.User.ToString();
response = await userManager.AddLoginAsync(user, info);
if (response.Succeeded)
{
await signInManager.SignInAsync(user, isPersistent : false);
//_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(Ok(new { UserInfo = user, IsAuth = true }));
}
}
AddErrors(response);
}
return(BadRequest(ModelState));
}
public ActionResult Edit(string id, IdentityUserViewModel editModel)
{
if (!ModelState.IsValid)
{
return(View(editModel));
}
var contact = _aspNetUsersService.GetUser(id);
if (contact != null)
{
var isAuthorized = true;
if (!isAuthorized)
{
return(View());
}
contact = _mapper.Map <AspNetUser>(editModel);
bool result = _aspNetUsersService.UpdateUser(contact);
}
return(RedirectToAction("Index"));
}
public UserPdfResultsMail(IdentityUserViewModel user)
{
this.Subject = AppMessages.Email_PdfResult_Subject;
this.Email = user.Email;
this.UserName = user.UserName;
}
public UserPdfResultsMail(IdentityUserViewModel user)
{
this.Subject = AppMessages.EMAIL_PDFRESULT_SUBJECT;
this.Email = user.Email;
this.UserName = user.UserName;
}
public async Task<ActionResult> UpdateApplicationUser(IdentityUserViewModel model)
{
if (ModelState.IsValid)
{
await IdentityManagerService.InsertOrUpdate(model, UserManager);
//await CenterRepository.UpdateEmployeeCenter(model.Id, model.CenterId,new Guid(User.Identity.GetUserId()));
return RedirectToAction("AccountMangement");
}
ViewBag.Roles = new SelectList(await IdentityManagerService.GetRolesAsync());
return View("~/Views/Account/EditApplicationUser", model);
}
// PUT api/Users/{uuid:guid}
public async Task <IHttpActionResult> Put(string uuid, IdentityUserViewModel userVM)
{
if (userVM == null)
{
return(BadRequest("Argument Null"));
}
if (string.IsNullOrEmpty(userVM.LocalNumber))
{
return(BadRequest("Local Number cannot be empty!!!"));
}
if (userVM.UserName.Length < 4)
{
return(BadRequest("Username cannot be less than 4 characters"));
}
var user = await ApplicationUserManager.FindByIdAsync(uuid);
if (user == null)
{
return(NotFound());
}
if (!(this.TokenId.IsSuperAdmin || this.TokenId.IsLocalAdmin))
{
return(BadRequest("Insufficient permissions to update. Must be Super Admin or Local Admin."));
}
if (this.TokenId.IsLocalAdmin && user.LocalNumber != this.TokenId.LocalNumber)
{
return(BadRequest("Local Admin can only update the users belonging to the local !!"));
}
user.Email = userVM.Email;
user.FirstName = userVM.FirstName;
user.LastName = userVM.LastName;
user.UserName = userVM.UserName;
user.PhoneNumber = userVM.PhoneNumber;
user.LocalNumber = userVM.LocalNumber;
user.Role = userVM.Role;
//Sanitize the role
string role = "Basic_User";
switch (user.Role.ToLower())
{
case "super_admin":
role = "Super_Admin";
break;
case "local_admin":
role = "Local_Admin";
break;
case "cashier":
role = "Cashier";
break;
default: role = "Basic_User"; break;
}
user.Role = role;
IdentityResult result = await ApplicationUserManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public async Task<bool> InsertOrUpdate(IdentityUserViewModel model, ApplicationUserManager userManager)
{
var user = await userManager.FindByIdAsync(model.Id);
if (user == null)
{
user = new ApplicationUser();
user.Assign(model);
var result = await userManager.CreateAsync(user, "1234567");
if (!result.Succeeded) return false;
model.Id = user.Id;
}
else
{
user.Email = model.Email;
user.UserName = model.UserName;
user.DUI = model.DUI;
user.PhoneNumber = model.PHONE_2;
user.ADDRESS = model.ADDRESS;
user.Category = model.Category;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.DUI = model.DUI;
user.PHONE_2 = model.PHONE_2;
user.ProfilePicture = model.ProfilePicture;
user.CenterId = model.CenterId;
//user.Address = model.Address;
//user.FirstName = model.FirstName;
//user.LastName = model.LastName;
//user.DocumentNum = model.DocumentNum;
//user.ProfilePicture = model.ProfilePicture;
await userManager.UpdateAsync(user);
}
if (model.ForceChangePassword)
{
var tok = await userManager.GeneratePasswordResetTokenAsync(model.Id);
var result = await userManager.ResetPasswordAsync(model.Id, tok, model.Password);
if (!result.Succeeded) return false;
}
var roles = await userManager.GetRolesAsync(model.Id);
if (!roles.Any() && !string.IsNullOrEmpty(model.Role))
{
var res = await userManager.AddToRoleAsync(model.Id, model.Role);
}
if (roles.All(r => r != model.Role) && roles.Any())
{
var result = await userManager.AddToRoleAsync(model.Id, model.Role);
}
roles.Where(r => r != model.Role).ToList().ForEach(role => userManager.RemoveFromRole(model.Id, role));
if (model.CenterId != 0)
{
var claim = await Context.UserClaims.FirstOrDefaultAsync(c => c.UserId == user.Id && c.ClaimType == "CenterId");
var claims = await userManager.GetClaimsAsync(user.Id);
if (claim != null)
{
claim.ClaimValue = model.CenterId.Value.ToString();
await Context.SaveChangesAsync();
}
else
{
await userManager.AddClaimAsync(model.Id, new System.Security.Claims.Claim("CenterId", model.CenterId.ToString()));
}
}
return true;
}
public void TestMethod1()
{
//
// TODO: Add test logic here
//
var context = AccessContext.Create();
var identityContext = AccessContext.Create();
var service = new IdentityManagerService(identityContext);
var users = service.GetUsersAsync(new Access.Models.FilterOptionModel()).Result;
var center = context.Centers.FirstOrDefault();
var user = users[1];
user.CenterId = center.Id;
var userStore = new UserStore<ApplicationUser>(identityContext);
var manager = new ApplicationUserManager(userStore);
var model = new IdentityUserViewModel();
model.Assign(user);
var result = service.InsertOrUpdate(model,manager).Result;
Assert.IsNotNull(users);
}
