//
// GET: /Account/Manage
public ActionResult Manage(ManageMessageId?message)
{
ViewBag.StatusMessage =
message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
: message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
: message == ManageMessageId.RemoveLoginSuccess ? "The external login was removed."
: message == ManageMessageId.Error ? "An error has occurred."
: "";
ViewBag.HasLocalPassword = UserManager.HasPassword(User.Identity.GetUserId());
ViewBag.ReturnUrl = Url.Action("Manage");
return(View());
}
// Edit account
// Pass in account object in request body and email string in request url
public async Task <IHttpActionResult> Edit([FromBody] Account EditAccount, string email)
{
if (!ModelState.IsValid)
{
return(BadRequest("model state not valid"));
}
// Find user (account) in user manager
var userStore = new UserStore <IdentityUser>(new DataDbContext());
var userManager = new UserManager <IdentityUser>(userStore);
var user = userManager.Users.FirstOrDefault(u => u.UserName == email);
if (user == null)
{
return(BadRequest("no user found"));
}
if (userManager.HasPassword(user.Id))
{
userManager.RemovePassword(user.Id);
}
// convert password to hash
var newPasswordHash = userManager.PasswordHasher.HashPassword(EditAccount.Password);
// update user (account) and save changes
await userStore.SetPasswordHashAsync(user, newPasswordHash);
await userManager.UpdateAsync(user);
user.UserName = EditAccount.Email;
userStore.Context.SaveChanges();
return(Ok());
}
public async Task <ActionResult> ConfirmEmail(string Token, string Email)
{
UserManager <ApplicationUser> dbUsers = new UserManager <Models.ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
ApplicationUser user = dbUsers.FindById(Token);
if (user != null)
{
if (user.Email == Email && !dbUsers.HasPassword(user.Id))
{
ViewBag.Token = Token;
if (user.EmailConfirmed == false)
{
user.EmailConfirmed = true;
await dbUsers.UpdateAsync(user);
ViewBag.EmailConfirmed = true;
}
return(View(new ConfirmEmailViewModel {
TokenUser = Token
}));
}
}
return(RedirectToAction("Index", "User"));
}
protected override void Initialize(RequestContext requestContext)
{
base.Initialize(requestContext);
var isLocal = requestContext.HttpContext.IsDebuggingEnabled && requestContext.HttpContext.Request.IsLocal;
var website = requestContext.HttpContext.GetWebsite();
ViewBag.Website = website;
ViewBag.Settings = website.GetAuthenticationSettings(isLocal);
ViewBag.IdentityErrors = website.GetIdentityErrors(this.HttpContext.GetOwinContext());
ViewBag.AzureAdOrExternalLoginEnabled = ViewBag.Settings.ExternalLoginEnabled || StartupSettingsManager.AzureAdOptions != null;
var userId = User.Identity.GetUserId();
var user = !string.IsNullOrWhiteSpace(userId) ? UserManager.FindById(userId) : null;
ViewBag.Nav = user == null
? new ManageNavSettings()
: new ManageNavSettings
{
HasPassword = UserManager.HasPassword(user.Id),
IsEmailConfirmed = string.IsNullOrWhiteSpace(user.Email) || user.EmailConfirmed,
IsMobilePhoneConfirmed = string.IsNullOrWhiteSpace(user.PhoneNumber) || user.PhoneNumberConfirmed,
IsTwoFactorEnabled = user.TwoFactorEnabled,
};
var contextLanguageInfo = requestContext.HttpContext.GetContextLanguageInfo();
var region = contextLanguageInfo.IsCrmMultiLanguageEnabled ? contextLanguageInfo.ContextLanguage.Code : null;
ViewBag.Region = region;
}
public async Task <ActionResult> EditAsync(EditableUserView model)
{
if (ModelState.IsValid)
{
ApplicationUser user = await UserManager.FindByEmailAsync(model.Email);
if (user != null)
{
if (UserManager.HasPassword(user.Id))
{
if (!string.IsNullOrEmpty(model.Password))
{
UserManager.RemovePassword(user.Id);
UserManager.AddPassword(user.Id, model.Password);
}
user.Email = model.Email;
//user.UserName = model.UserName;
user.PhoneNumber = model.PhoneNumber;
UserManager.RemoveFromRole(model.Id, GetUserRoles(model.Email).FirstOrDefault());
UserManager.AddToRole(model.Id, model.SelectedRole);
}
else
{
ModelState.AddModelError("", "Произошла ошибка. Попробуйте ещё раз.");
}
UserManager.Update(user);
}
return(RedirectToAction("Index"));
}
return(RedirectToAction("Edit", new { id = model.Id }));
}
public User PutUser(string id, User model)
{
db.Entry(model).State = EntityState.Modified;
try{
db.SaveChanges();
var store = new UserStore <ApplicationUser>(new ApplicationDbContext());
var manager = new UserManager <ApplicationUser>(store);
if (manager.HasPassword(id))
{
manager.RemovePassword(id);
}
var newPasswordHash = manager.PasswordHasher.HashPassword(model.PasswordHash);
ApplicationUser user = manager.FindById(id);
store.SetPasswordHashAsync(user, newPasswordHash);
manager.UpdateAsync(user);
return(model);
}
catch (DbUpdateConcurrencyException) {
if (!UserExists(id))
{
model.Id = "";
return(model);
}
else
{
throw;
}
}
}
public bool HasPassword(UserContract user)
{
using (var dbConnector = new DBConnector())
{
UserManager userManager = new UserManager(dbConnector.DataContext);
var convertedUser = UsersTranslator.ConvertToUserEntity(user);
return(userManager.HasPassword(convertedUser));
}
}
public async Task <IHttpActionResult> Edit([FromBody] AccountEdit account)
{
if (!ModelState.IsValid)
{
return(BadRequest("Model state invalid"));
}
try
{
var userStore = new UserStore <IdentityUser>(new AccountDbContext());
var userManager = new UserManager <IdentityUser>(userStore);
var user = userManager.Users.First(x => x.UserName == account.Username);
if (user == null)
{
throw new ArgumentException("account");
}
if (!userManager.CheckPassword(user, account.Password))
{
return(Unauthorized());
}
if (userManager.HasPassword(user.Id))
{
userManager.RemovePassword(user.Id);
}
var hashedPw = userManager.PasswordHasher.HashPassword(account.newPassword);
await userStore.SetPasswordHashAsync(user, hashedPw);
await userManager.UpdateAsync(user);
user.UserName = account.newUsername ?? account.Username;
user.Email = account.newEmail;
userStore.Context.SaveChanges();
// Refresh
Request.GetOwinContext().Authentication.SignOut(WebApiConfig.AuthenticationType);
var authManager = Request.GetOwinContext().Authentication;
var claimsIdentity = userManager.CreateIdentity(user, WebApiConfig.AuthenticationType);
authManager.SignIn(new AuthenticationProperties {
IsPersistent = true
}, claimsIdentity);
return(Ok());
}
catch
{
return(BadRequest("Invalid user"));
}
}
public void HasPasswordShouldBeFalseWithoutPassword()
{
var user = new IdentityUser()
{
UserName = "******"
};
UserManager.Create(user);
var result = UserManager.HasPassword(user.Id);
result.ShouldBe(false);
}
public void HasPasswordShouldBeTrueWithPassword()
{
var user = new IdentityUser()
{
UserName = "******"
};
UserManager.Create(user);
UserManager.AddPassword(user.Id, "testing");
var result = UserManager.HasPassword(user.Id);
result.ShouldBe(true);
}
public UserInfoViewModel GetCurrentUser()
{
ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
Model.User user = userBusiness.GetUserByExternalId(User.Identity.GetUserId()).Data;
UserInfoViewModel retVal = !User.Identity.IsAuthenticated ? null :
new UserInfoViewModel
{
UserName = User.Identity.GetUserName(),
HasRegistered = user != null,
IsAdmin = UserManager.IsInRole(User.Identity.GetUserId(), Constants.RoleNames.Admin),
HasPassword = UserManager.HasPassword(User.Identity.GetUserId()),
LoginProvider = externalLogin != null ? externalLogin.LoginProvider : null
};
return(retVal);
}
public async Task <ActionResult> ConfirmEmail(ConfirmEmailViewModel model)
{
if (ModelState.IsValid)
{
UserManager <ApplicationUser> dbUsers = new UserManager <Models.ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
ApplicationUser user = await dbUsers.FindByIdAsync(model.TokenUser);
if (user == null || dbUsers.HasPassword(user.Id))
{
ModelState.AddModelError("", "Error.");
return(View(model));
}
user.FirstName = model.FirstName;
user.LastName = model.LastName;
var result = await dbUsers.UpdateAsync(user);
if (result.Succeeded)
{
result = await dbUsers.AddPasswordAsync(user.Id, model.Password);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Error passowrd not set.");
return(View(model));
}
result = await dbUsers.UpdateAsync(user);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Error save password.");
return(View(model));
}
var identity = await dbUsers.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(identity);
return(RedirectToAction("Index", "User"));
}
}
return(View(model));
}
public ActionResult ChangePassword()
{
bool requireCurrentPassword = true;
var userManager = new UserManager();
//allow user to set a new password without confirming old one if they haven't set a password yet
if (!userManager.HasPassword((int)UserID))
{
requireCurrentPassword = false;
}
if (TempData["IsCurrentPasswordRequired"] != null && (bool)TempData["IsCurrentPasswordRequired"] == false)
{
requireCurrentPassword = false;
}
return(View(new PasswordChangeModel {
IsCurrentPasswordRequired = requireCurrentPassword
}));
}
public ActionResult ResetUserPassword(ResetUserPasswordViewModel model)
{
if (ModelState.IsValid)
{
UserManager <IdentityUser> userManager = new UserManager <IdentityUser>(new UserStore <IdentityUser>());
if (userManager.HasPassword(model.UserId))
{
userManager.RemovePassword(model.UserId);
userManager.AddPassword(model.UserId, model.ConfirmPassword);
}
TempData["Message"] = "Password successfully reset to " + model.ConfirmPassword;
TempData["MessageValue"] = "1";
return(RedirectToAction("Index", "Korisnici"));
}
// If we got this far, something failed, redisplay form
TempData["Message"] = "Invalid User Details. Please try again in some minutes ";
TempData["MessageValue"] = "0";
return(RedirectToAction("Index", "Korisnici"));
}
protected override void Initialize(RequestContext requestContext)
{
base.Initialize(requestContext);
var isLocal = requestContext.HttpContext.IsDebuggingEnabled && requestContext.HttpContext.Request.IsLocal;
var website = WebsiteManager.Find(requestContext);
ViewBag.Settings = website.GetAuthenticationSettings <ApplicationWebsite, string>(isLocal);
ViewBag.IdentityErrors = website.GetIdentityErrors <ApplicationWebsite, string>();
var userId = User.Identity.GetUserId();
var user = !string.IsNullOrWhiteSpace(userId) ? UserManager.FindById(userId) : null;
ViewBag.Nav = user == null
? new ManageNavSettings()
: new ManageNavSettings
{
HasPassword = UserManager.HasPassword(user.Id),
IsEmailConfirmed = string.IsNullOrWhiteSpace(user.Email) || user.EmailConfirmed,
IsMobilePhoneConfirmed = string.IsNullOrWhiteSpace(user.PhoneNumber) || user.PhoneNumberConfirmed,
IsTwoFactorEnabled = user.TwoFactorEnabled,
};
}
/// <summary>
/// The has password.
/// </summary>
/// <param name="manager">
/// The manager.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
private bool HasPassword(UserManager manager)
{
return manager.HasPassword(this.User.Identity.GetUserId());
}
private bool HasPassword(UserManager manager)
{
return(manager.HasPassword(User.Identity.GetUserId()));
}
private bool HasPassword()
{
return(UserManager.HasPassword(
User.Identity.GetUserId().ToGuid()));
}
/// <summary>
/// Create New User
/// </summary>
/// <param name="userModel"></param>
/// <param name="isThirdParty"></param>
/// <returns></returns>
public Task <AuthenticationServiceResponse> CreateUser(UserModel userModel)
{
var existUser = UserManager.FindByEmail(userModel.Email);
var userType = Convert.ToInt32(UserType.BusinessUser);
IdentityResult result = new IdentityResult();
if (existUser == null)
{
int companyId = CreateCompany(userModel.CompanyModel.Name); // Creating Company and it returns Company Id
userModel.CompanyId = companyId;
ApplicationUser appUser = new ApplicationUser();
User user = new User();
Mapper.Map(userModel, appUser);
appUser.UserName = userModel.Email;
appUser.CreatedDate = DateTime.UtcNow;
appUser.ShipmentType = Convert.ToInt32(ShipmentType.BusinessShipments);
appUser.IsActive = true;
try
{
if (!string.IsNullOrEmpty(userModel.Password))
{
result = UserManager.Create(appUser, userModel.Password); // Creating User
}
if (result.Succeeded)
{
_unitOfWork.GetContext().CreateUserRole(appUser.Id, userType); //Add User Role
_unitOfWork.Save();
Company companyParam = new Company();
companyParam.CompanyId = companyId;
companyParam.OwnerId = appUser.Id;
companyParam.CreatedBy = appUser.Id;
companyParam.UpdatedBy = appUser.Id;
UpdateCompany(companyParam);
}
}
catch (Exception ex) // if error occurs then reverting database entries
{
if (!result.Succeeded)
{
DeleteCompany(companyId);
}
else
{
appUser.IsDeleted = true;
UserManager.Update(appUser);
}
throw;
}
Mapper.Map(appUser, userModel);
return(Task.FromResult(new AuthenticationServiceResponse()
{
Data = userModel, Success = result.Succeeded, Message = result.Errors.FirstOrDefault()
}));
}
else // If User is deleted or, already exists in database
{
if (!existUser.IsDeleted && UserManager.HasPassword(existUser.Id))// && passwordExist)
{
return(Task.FromResult(new AuthenticationServiceResponse()
{
Data = userModel, Success = false, Message = "Sorry, it looks like <b>" + userModel.Email + " </b> belongs to an existing account"
}));
}
int companyId = CreateCompany(userModel.CompanyModel.Name);
try
{
existUser.FirstName = userModel.FirstName;
existUser.LastName = userModel.LastName;
existUser.UpdatedDate = null;
existUser.CreatedDate = DateTime.UtcNow;
existUser.IsActive = true;
existUser.IsDeleted = false;
existUser.CompanyId = companyId;
result = UserManager.Update(existUser); // updating User
if (result.Succeeded)
{
_unitOfWork.GetContext().CreateUserRole(existUser.Id, userType); //Add User Role
_unitOfWork.Save();
//UserManager.AddToRole(existUser.Id,UserType.BusinessUser.ToString()); // Assigning Role Business because we are creatng a company account
Mapper.Map(existUser, userModel);
Company companyParam = new Company(); // Updating company again
companyParam.CompanyId = companyId;
companyParam.OwnerId = existUser.Id;
companyParam.CreatedBy = existUser.Id;
companyParam.UpdatedBy = existUser.Id;
UpdateCompany(companyParam);
}
return(Task.FromResult(new AuthenticationServiceResponse()
{
Data = userModel, Success = result.Succeeded
}));
}
catch (Exception ex) // if error occurs then reverting database entries
{
if (!result.Succeeded)
{
DeleteCompany(companyId);
}
else
{
existUser.IsDeleted = true;
UserManager.Update(existUser);
}
throw;
}
}
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
#region g-recaptcha-response
//model.g_recaptcha_response = Request.Form.Get("g-recaptcha-response");
//if(!string.IsNullOrEmpty(model.g_recaptcha_response))
//{
// var grecaptcha = new Grecaptcha().Result(model.g_recaptcha_response);
// if(grecaptcha.IsError)
// ModelState.AddModelError("LoginCustomErrors", grecaptcha.ErrorMsg);
//}
//else
//{
// ModelState.AddModelError("LoginCustomErrors", "CaptchaIsEmpty");
//}
#endregion
if (!ModelState.IsValid)
{
return(View(model));
}
IdentityResult result = null;
AppUser user = UserManager.FindByEmail(model.Email);
if (user != null && !UserManager.HasPassword(user.Id))
{
//Регистрируем ананима
result = await UserManager.AddPasswordAsync(user.Id, model.Password);
}
else
{
//Регистрируем нового пользователя
user = new AppUser
{
UserName = model.Email,
Email = model.Email,
};
result = await UserManager.CreateAsync(user, model.Password);
}
if (result.Succeeded)
{
//xthrow new NotImplementedException("Error!!!");
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, _getSubjectAccount(), _getBodyAccount(callbackUrl));
//scope.Complete();
return(View("DisplayEmail"));
}
foreach (var err in result.Errors)
{
ModelState.AddModelError("", err);
}
//Если не валидна отобразить данные в форме еще раз
return(View(model));
}
private bool HasPassword(UserManager<MyUser, long> manager)
{
return manager.HasPassword(long.Parse(User.Identity.GetUserId()));
}
