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