/// <summary> /// Create User Action Activity Log /// </summary> /// <param name=></param> /// <returns>bool</returns> public async Task <bool> AddEmployer(EmployerAddDTO EmployerAddDTO) { #region Declare a return type with initial value. bool isEmployerCreated = default(bool); #endregion try { #region Vars Employer Employer = null; UserPasswordDTO userPasswordDTO = null; #endregion Employer = EmployerMapping.MappingEmployerAddDTOToEmployer(EmployerAddDTO); userPasswordDTO = CreatePasswordHash(EmployerAddDTO.Password); Employer.PasswordHash = userPasswordDTO.PasswordHash; Employer.PasswordSalt = userPasswordDTO.PasswordSalt; if (Employer != null) { await UnitOfWork.EmployerRepository.Insert(Employer); isEmployerCreated = await UnitOfWork.Commit() > default(int); } } catch (Exception exception) { } return(isEmployerCreated); }
public static bool updateUserPassword(UserPasswordDTO pUserPassword) { using (SqlConnection connection = new SqlConnection(WebConfigurationManager.ConnectionStrings["connectionRRHHDatabase"].ConnectionString)) { SqlCommand command = new SqlCommand("usp_update_userPasssword", connection); command.CommandType = System.Data.CommandType.StoredProcedure; command.Parameters.Add("@password", SqlDbType.NVarChar); command.Parameters["@password"].Value = pUserPassword.password; command.Parameters.Add("@id_user", SqlDbType.Int); command.Parameters["@id_user"].Value = pUserPassword.id_user; command.Parameters.Add("@userLog", SqlDbType.Int); command.Parameters["@userLog"].Value = pUserPassword.userLog; command.Connection.Open(); int result = command.ExecuteNonQuery(); if (result != 0) { return(true); } }; return(false); }
public ActionResult Generate(UserPasswordDTO userPasswordDTO) { UserPassword userPassword = _passwordBL.GeneratePassword(_mapper.Map <UserPassword>(userPasswordDTO)); UserPasswordDTO upDTO = _mapper.Map <UserPasswordDTO>(userPassword); return(View("Validate", upDTO)); }
public IHttpActionResult updatePassword(UserPasswordDTO passwordDTO) { if (!UsersData.updateUserPassword(passwordDTO)) { return(BadRequest()); } return(Ok()); }
public ActionResult _ChangePassword(string password, string confirmPassword, string oldPassword, string user_id) { if (ModelState.IsValid) { UserPasswordDTO passwordDTO = new UserPasswordDTO(); passwordDTO.password = password; passwordDTO.id_user = user_id; passwordDTO.oldPassword = oldPassword; passwordDTO.confirmPassword = confirmPassword; passwordDTO.userLog = Request.Cookies["user_id"].Value; if (userProvider.putUserPassword(passwordDTO, Request.Cookies["token"].Value).Result) { return(new HttpStatusCodeResult(200)); } } return(new HttpStatusCodeResult(404, "Can't find that")); }
public async Task <bool> putUserPassword(UserPasswordDTO userPassword, string token) { using (var client = new HttpClient()) { client.BaseAddress = new Uri(_BaseAddress); var userJson = new JavaScriptSerializer().Serialize(userPassword); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", getToken()); HttpContent contentPost = new StringContent(userJson, Encoding.UTF8, "application/json"); HttpResponseMessage response = client.PutAsync("api/Account/ChangePassword", contentPost).Result; if (response.IsSuccessStatusCode) { return(true); } return(false); } }
public async Task <ActionResult> ChangePassword([FromRoute] string UserId, UserPasswordDTO userPasswordDTO) { var user = await userManager.FindByIdAsync(UserId); if (user == null) { return(NotFound()); } var result = await userManager.ChangePasswordAsync(user, userPasswordDTO.CurrentPassword, userPasswordDTO.NewPassword); if (result.Succeeded) { return(NoContent()); } return(BadRequest(result.Errors)); }
/// <summary> /// Create User /// </summary> /// <param name="createUserInputDTO"></param> /// <returns>bool</returns> public async Task <bool> AddAdmin(AdminAddDTO adminAddDTO) { #region Declare a return type with initial value. bool isUserCreated = default(bool); #endregion try { #region Vars UserPasswordDTO userPasswordDTO = null; Admin admin = null; #endregion #region Check user email not exsist if (!await IsEmailExist(adminAddDTO.Email)) { #region Create Hash Passowrd using password string userPasswordDTO = CreatePasswordHash(adminAddDTO.Password); #endregion #region Check if user password DTO not equal null if (userPasswordDTO != null) { #region Mapp user Add DTO and User Password DTO to User entity model admin = AdminMapping.MappingAdminAddDTOToAdmin(adminAddDTO, userPasswordDTO); #endregion #region Check if user not equal null if (admin != null) { #region insert user enity model to user repository if (await UnitOfWork.AdminRepository.Insert(admin)) { isUserCreated = await UnitOfWork.Commit() > default(int); } #endregion } #endregion } #endregion } #endregion } catch (Exception exception) { //Logger.Instance.LogException(exception, LogLevel.Medium); } return(isUserCreated); }
public async Task <IActionResult> UpdatePassword(UserPasswordDTO userPasswordDTO) { try { var resp = await _user.UpdatePassword(userPasswordDTO); if (resp) { return(StatusCode(StatusCodes.Status204NoContent, userPasswordDTO)); } return(StatusCode(StatusCodes.Status404NotFound, resp)); } catch (Exception e) { return(StatusCode(StatusCodes.Status500InternalServerError, new { message = e.Message })); } }
public IActionResult ChangePassword([FromBody] UserPasswordDTO userParam) { if (!ModelState.IsValid) { return(BadRequest("Invalid Request")); } User user = GetUserInToken(); if (user == null) { return(BadRequest(new { msg = "Invalid user" })); } bool validOldPassword = BCrypt.Net.BCrypt.Verify(userParam.oldPassword, user.password); if (!validOldPassword) { return(BadRequest(new { msg = "Incorrect old password" })); } bool validPassword = BCrypt.Net.BCrypt.Verify(userParam.password, user.password); if (validPassword) { return(BadRequest(new { msg = "Same old and new password" })); } var hashedPassword = BCrypt.Net.BCrypt.HashPassword(userParam.password); try { user.password = hashedPassword; db.SaveChanges(); user.password = null; return(Ok(user)); } catch { return(BadRequest(new { msg = "Database error" })); } }
public ActionResult ChangePassword(UserPasswordDTO model) { var id = int.Parse(Request.Cookies[CookieConst.USER].Value); var status = false; if (!ModelState.IsValid) { var errors = ModelState.Values.SelectMany(v => v.Errors); } if (ModelState.IsValid) { if (model.ConfirmNewPassword == model.NewPassword) { status = userService.ChangePass(id, MD5.CreateMD5(model.NewPassword), MD5.CreateMD5(model.Password)); } userService.Save(); } return(Json(status, JsonRequestBehavior.AllowGet)); }
public IActionResult Post([FromBody] UserPasswordDTO input) { var result = _userAccountService.CreateUserAndAccount(new UserDTO { Email = input.Email, FirstName = input.FirstName, LastName = input.LastName, PhoneNumber = input.PhoneNumber }, input.Password); if (result is UserSuccessResult) { //User and account successfully created. var user = (UserDTO)result.Item; //Return an OK and put the URL to the created user in the header. return(Created(Url.RouteUrl("GetUserById", new { id = result.Item.Id }), string.Format("User ID {0} created.", result.Item.Id))); } else { return(BadRequest(string.Format("Unable to create user. {0}", string.Join(",", result.Data.Cast <string>())))); } }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.oldPassword, model.password); if (result.Succeeded) { UserPasswordDTO userPassword = new UserPasswordDTO(); userPassword.id_user = model.id_user; userPassword.password = model.password; userPassword.userLog = model.userLog; if (UsersData.updateUserPassword(userPassword)) { return(Ok()); } } return(GetErrorResult(result)); }
/// <summary> ///User Create PasswordHash /// </summary> /// <param name="password"></param> /// <returns>bool</returns> private UserPasswordDTO CreatePasswordHash(string password) { #region Declare a return type with initial value. UserPasswordDTO userPasswordDTO = null; #endregion try { using (var hmac = new System.Security.Cryptography.HMACMD5()) { userPasswordDTO = new UserPasswordDTO() { PasswordSalt = hmac.Key, PasswordHash = hmac.ComputeHash(System.Text.Encoding.ASCII.GetBytes(password)) }; } } catch (Exception exception) { // Logger.Instance.LogException(exception, LogLevel.Medium); } return(userPasswordDTO); }
/// <summary> /// Mapping user Action Actitvity Log /// </summary> /// <param name=></ param > /// <returns>Task<Admin></returns> public Admin MappingAdminAddDTOToAdmin(AdminAddDTO AdminAddDTO, UserPasswordDTO userPasswordDTO) { #region Declare a return type with initial value. Admin Admin = null; #endregion try { Admin = new Admin { FullName = AdminAddDTO.FullName, Address = AdminAddDTO.Address, Phone = AdminAddDTO.Phone, Email = AdminAddDTO.Email, PasswordHash = userPasswordDTO.PasswordHash, PasswordSalt = userPasswordDTO.PasswordSalt, CreationDate = DateTime.Now, IsDeleted = (byte)DeleteStatusEnum.NotDeleted }; } catch (Exception exception) { } return(Admin); }
public async Task <bool> UpdatePassword(UserPasswordDTO userPasswordDTO) { try { var user = await _context.Usuarios.FirstOrDefaultAsync(x => x.CorreoElectronico == userPasswordDTO.Email); if (user != null) { user.Contrasena = userPasswordDTO.Password; _context.Update(user).State = EntityState.Modified; await _context.SaveChangesAsync(); return(true); } return(false); } catch (Exception e) { log.ErrorFormat("Error al Actualizar Contraseña UpdatePassword() {0} : {1} ", e.Source, e.Message); return(false); throw; } }
public void ChangePassword(UserPasswordDTO userPasswordDTO) { string companyName = ""; string username = ""; string newPassword = ""; string email = ""; User user = (from u in _unitOfWork.User.FindAll().Where(u => u.Username == userPasswordDTO.Username && u.Password == userPasswordDTO.OldPassword && u.Active == true) select u).FirstOrDefault(); if (user != null) { companyName = user.Company.Name; username = user.Username; email = user.Email; newPassword = userPasswordDTO.NewPassword; user.Password = newPassword; user.PasswordChangedDate = DateTime.Now; user.ModifiedBy = user.Username; user.ModifiedDate = DateTime.Now; _unitOfWork.User.Update(user); _unitOfWork.SaveChanges(); // Create Alert UserAlertDTO document = new UserAlertDTO(); document.Username = username; document.CompanyName = companyName; document.UserEmail = email; AlertMaster alert = (from a in _unitOfWork.AlertMaster.FindAll().Where(a => a.Code == "CP" && a.Active == true) select a).FirstOrDefault(); string emailFrom = alert.EmailFrom; string emailSubject = StringifyContent(document, alert.EmailSubject); string emailContent = StringifyContent(document, alert.EmailContent); string emailTo = StringifyContent(document, alert.EmailTo); Utility.SendEmail("192.168.1.20", emailFrom, emailTo, "", emailSubject, emailContent); } }
public ActionResult ValidatePassword(UserPasswordDTO userPasswordDTO) { userPasswordDTO.IsValid = _passwordBL.CheckValidity(userPasswordDTO.UserID, userPasswordDTO.Password); return(View("Index", userPasswordDTO)); }
public async Task <IActionResult> ChangePassword([FromBody] UserPasswordDTO userPasswordDTO) { _userService.ChangePassword(userPasswordDTO); return(Ok()); }