/// <summary> /// /// </summary> /// <param name="userDTO"></param> public void UpdatePasswordByMail(UserDTO userDTO) { if (userDTO.Password == userDTO.confirmPassword) { utilisateurEngine.UpdatePasswordByMail(SecurePasswordHasherHelper.Hash(userDTO.Password), userDTO.Email); } }
public async Task CreateTenant(CreateTenantDto input) { var hashedPassword = SecurePasswordHasherHelper.Hash(input.Password); var user = new Tenant { TenantName = input.TenantName, Address = input.Address, IsPremium = input.IsPremium, PhoneNumber = input.PhoneNumber, PhoneNumber2 = input.PhoneNumber2, Password = hashedPassword, Email = input.Email, AboutUs = input.AboutUs, Title = input.Title, LocationId = input.LocationId, }; if (input.LogoFile != null) { var logoPath = await _blobService.InsertFile(input.LogoFile); user.LogoPath = logoPath; } await _tenantRepository.AddAsync(user); }
public async Task <IActionResult> Register([FromBody] CreateUserDto user) { try { if (await IsAnotherUserHasMyEmail(user.Email)) { return(BadRequest($"{user.Email} is already used!")); } var userMapped = _mapper.Map <User>(user); userMapped.Role = GetDefaultUserRole(); userMapped.Password = SecurePasswordHasherHelper.Hash(userMapped.Password); await _cinemaDbContext.User.AddAsync(userMapped); await _cinemaDbContext.SaveChangesAsync(); return(Created(HttpContext.Request.Path, user)); } catch (Exception x) { return(BadRequest(x.InnerException?.Message ?? x.Message)); } }
public IActionResult Registro([FromBody] Usuario usuario) { var userWithSameEmail = _dashboardDbContext.Usuarios.Where(u => u.Email == usuario.Email).SingleOrDefault(); if (userWithSameEmail != null) { return(BadRequest("Um usuário com o mesmo email já existe")); } if (usuario.Senha != usuario.ConfirmarSenha) { return(BadRequest("Senhas não são iguais.")); } var usuarioObj = new Usuario() { Nome = usuario.Nome, Sobrenome = usuario.Sobrenome, Telefone = usuario.Telefone, Endereco = usuario.Endereco, Email = usuario.Email, DataNascimento = usuario.DataNascimento, DataInclusao = DateTime.Now, Senha = SecurePasswordHasherHelper.Hash(usuario.Senha), ConfirmarSenha = SecurePasswordHasherHelper.Hash(usuario.ConfirmarSenha), Status = '1' }; _dashboardDbContext.Usuarios.Add(usuarioObj); _dashboardDbContext.SaveChanges(); return(StatusCode(StatusCodes.Status201Created)); }
public IActionResult ChangePassword(ChangePasswordModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var userEmail = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value; var user = _dbContext.Users.FirstOrDefault(u => u.Email == userEmail); if (user == null) { return(NotFound()); } var hashedPassword = user.Password; if (!SecurePasswordHasherHelper.Verify(model.OldPassword, hashedPassword)) { return(BadRequest("You can't change the password")); } user.Password = SecurePasswordHasherHelper.Hash(model.NewPassword); _dbContext.SaveChanges(); return(Ok("Your password has been changed")); }
public static async Task <object> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequestMessage req, ILogger log) { log.LogInformation("C# HTTP trigger function processed a request."); string token = req.Headers.Authorization.ToString(); if (!AuthorizationHelper.Authorized(token, new string[] { Role.Manager })) { return(req.CreateResponse(HttpStatusCode.BadRequest, "Unauthorized!")); } //We retrieve the userName field, which comes as a parameter to the function, by deserializing req.Content. string jsonContent = await req.Content.ReadAsStringAsync(); dynamic data = JsonConvert.DeserializeObject(jsonContent); string email = data.email; string Firstname = data.Firstname; string Lastname = data.Lastname; string Position = data.Position; string Password = data.Password; string branchID = data.branchID; string CompanyID = data.CompanyID; Password = SecurePasswordHasherHelper.Hash(Password); //If there is no username, we return the error message. try { //We get the Connection String in the Function App Settings section we defined. var str = Environment.GetEnvironmentVariable("sqldb_connection"); int modified; using (SqlConnection connection = new SqlConnection(str)) { string text = @"INSERT INTO Users (email, Firstname, Lastname, Position, branchID, PasswordHash, Role, CompanyID) " + "OUTPUT INSERTED.UserID " + "VALUES (@email, @Firstname, @Lastname, @Position, @branchID, @PasswordHash, @Role, @CompanyID);"; SqlCommand command = new SqlCommand(text, connection); command.Parameters.AddWithValue("@email", email); command.Parameters.AddWithValue("@Firstname", Firstname); command.Parameters.AddWithValue("@Lastname", Lastname); command.Parameters.AddWithValue("@Position", Position); command.Parameters.AddWithValue("@branchID", branchID); command.Parameters.AddWithValue("@PasswordHash", Password); command.Parameters.AddWithValue("@Role", Role.Employee); command.Parameters.AddWithValue("@CompanyID", CompanyID); connection.Open(); modified = (int)command.ExecuteScalar(); connection.Close(); } return(req.CreateResponse(HttpStatusCode.OK, modified)); } catch { return(req.CreateResponse(HttpStatusCode.BadRequest, "Something went wrong!")); } }
public void SecurePasswordHasherHelper_Hash_PasswordHashed_Success() { const string password = "******"; var hash = SecurePasswordHasherHelper.Hash(password); Assert.NotEqual(password, hash); }
public Account(string email, string password) { Id = Guid.NewGuid(); Email = email; HashedPassword = SecurePasswordHasherHelper.Hash(password); CreatedAt = DateTime.UtcNow; UpdatedAt = DateTime.UtcNow; }
public IActionResult Put(int id, [FromBody] User user) { var entity = _dbContext.Users.Find(id); if (entity == null) { return(NotFound("Usuário não enconrado !")); } entity.Name = user.Name; entity.Email = user.Email; entity.Password = SecurePasswordHasherHelper.Hash(user.Password); //Atualiza e salva o novo usuário ao banco de dados e retorna o StatusCode201Created. _dbContext.SaveChanges(); return(Ok("Usuário atualizado com sucesso !")); }
public IActionResult Register([FromBody] User user) { var userWithSameEmail = _dbContext.Users.FirstOrDefault(x => x.Email == user.Email); if (userWithSameEmail != null) { return(BadRequest("User with same email already exists")); } user.Password = SecurePasswordHasherHelper.Hash(user.Password); user.Role = "Users"; _dbContext.Users.Add(user); _dbContext.SaveChanges(); return(StatusCode(StatusCodes.Status201Created)); }
public IActionResult RegisterMember([Bind("UserId", "Email", "FullName", "Password", "Role")]UserModel register) { if (/* ModelState.IsValid && */!UserModel.EmailExists(register.Email, _db)) { //create string hashed_password = SecurePasswordHasherHelper.Hash(register.Password); register.Password = hashed_password; _db.Users.Add(register); _db.SaveChanges(); return Redirect("../Home/"); } return View(register); }
public ActionResult UpdateUser( int id, string lastname, string firstname, string idCompany, string mail, string phone, string[] selectRole, string job ) { if (id != -1) { UserDTO user = new UserDTO(); user.Id = id; user.Lastname = lastname; user.Firstname = firstname; int resCompany = 0; Int32.TryParse(idCompany, out resCompany); user.Id_Company = resCompany; user.Email = mail; int resRole = 0; user.Phone_Number = phone; user.Job = job; user.Password = SecurePasswordHasherHelper.Hash("Motdepasse1"); user.Is_Active = 1; user.Note = ""; user.Is_Address_Private = 1; Tuple <Boolean, String> res = this.isFormValid(lastname, firstname, idCompany, mail, phone, selectRole.GetValue(0).ToString(), job); if (res.Item1) { userLogic.Update(user); userLogic.RemoveAllUserRole(userLogic.Get(user.Id)); foreach (string idRole in selectRole) { Int32.TryParse(idRole, out resRole); roleLogic.Add_User_Role(userLogic.GetUserByMail(user.Email).Id, resRole); } TempData["SuccessModal"] = "Utilisateur " + user.Lastname + " " + user.Firstname + " modifié avec succès"; } else { TempData["userToEdit"] = id; TempData["FormError"] = res.Item2; } } return(RedirectToAction("Index")); }
public async Task <IActionResult> CompanyRegister(CompanyRegisterModel model) { if (ModelState.IsValid) { var name = model.CompanyEmail; var pass = model.CompanyPassword; var confirmPass = model.CompanyConfirmPassword; string hashed_password = SecurePasswordHasherHelper.Hash(pass); connect = new ConnDatabase(); connect.sqlQuery("INSERT INTO Company (CompanyEmail, CompanyPassword) Values('" + name + "', '" + hashed_password + "')"); connect.NonExecute(); } return(View(model)); }
public IActionResult Register([Bind("UserId", "Email", "FullName", "Password", "Admin")] UserModel register) { if (ModelState.IsValid) //&& !UserModel.EmailExists(register.Email, _db)) { //create string hashed_password = SecurePasswordHasherHelper.Hash(register.Password); register.Password = hashed_password; new_db.addUser(register); /* _db.Users.Add(register); * _db.SaveChanges(); */ return(Redirect("Login")); } return(View("Register", register)); }
public async Task <bool> ResetPassword(ResetPasswordDto input) { var user = await _userRepository.GetAll().Where(x => x.EmailAddress == input.EmailAddress && x.ResetPasswordCode == input.ResetCode) .FirstOrDefaultAsync(); if (user == null) { throw new Exception("Böyle bir işlem yok"); } var hashedPassword = SecurePasswordHasherHelper.Hash(input.NewPassword); user.Password = hashedPassword; await _userRepository.UpdateAsync(user); return(true); }
public IActionResult ChangePassword([FromBody] ChangePasswordModel changePasswordModel) { var userEmail = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Email).Value; var user = _cWheelsDbContext.Users.FirstOrDefault(u => u.Email == userEmail); if (user == null) { return(NotFound()); } if (!SecurePasswordHasherHelper.Verify(changePasswordModel.OldPassword, user.Password)) { return(Unauthorized("Sorry you can't change the password")); } user.Password = SecurePasswordHasherHelper.Hash(changePasswordModel.NewPassword); _cWheelsDbContext.SaveChanges(); return(Ok("Your password has been changed")); }
public IActionResult TrocarSenha([FromBody] ChangePasswordModel changepasswordModel) { var userEmail = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Email).Value; var user = _dashboardDbContext.Usuarios.FirstOrDefault(u => u.Email == userEmail); if (user == null) { return(NotFound()); } if (!SecurePasswordHasherHelper.Verify(changepasswordModel.OldPassword, user.Senha)) { return(Unauthorized("Me desculpe você não pode alterar sua senha")); } user.Senha = SecurePasswordHasherHelper.Hash(changepasswordModel.NewPassword); _dashboardDbContext.SaveChanges(); return(Ok("Sua senha foi alterada com sucesso!")); }
public IActionResult TrocarSenha([FromBody] TrocarSenha trocarSenha) { var usuarioEmail = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Email).Value; var usuario = _svtaDbContext.Usuarios.FirstOrDefault(u => u.Email == usuarioEmail); if (usuario == null) { return(NotFound("Usuario não encontrado")); } if (!SecurePasswordHasherHelper.Verify(trocarSenha.SenhaAntiga, usuario.Senha)) { return(Unauthorized("Desculpe, mas você não pode trocar sua senha")); } usuario.Senha = SecurePasswordHasherHelper.Hash(trocarSenha.NovaSenha); _svtaDbContext.SaveChanges(); return(Ok("Sua senha foi alterada com sucesso")); }
public async Task <IActionResult> Create([Bind("id,name,username,encrypted_password")] User user) { if (ModelState.IsValid) { user.id = Guid.NewGuid(); user.encrypted_password = SecurePasswordHasherHelper.Hash(user.encrypted_password); if (!use_test_repository) { _context.Add(user); await _context.SaveChangesAsync(); } else { _repository.AddItem(user); } return(RedirectToAction(nameof(Index))); } return(View(user)); }
public async Task <Educator> CreateEducator(CreateEducatorDto input) { var logoPath = await _blobService.InsertFile(input.File); var hashedPassword = SecurePasswordHasherHelper.Hash(input.Password); var educator = new Educator { Name = input.Name, Surname = input.Surname, Email = input.Email, Password = hashedPassword, Profession = input.Profession, Resume = input.Resume, ProfileImagePath = logoPath }; await _educatorRepository.AddAsync(educator); return(educator); }
public IActionResult Register([FromBody] User user) { var userWithSameEmail = _cWheelsDbContext.Users.Where(u => u.Email == user.Email).SingleOrDefault(); if (userWithSameEmail != null) { return(BadRequest("User with same email already exists")); } var userObj = new User() { Name = user.Name, Email = user.Email, Password = SecurePasswordHasherHelper.Hash(user.Password), }; _cWheelsDbContext.Users.Add(userObj); _cWheelsDbContext.SaveChanges(); return(StatusCode(StatusCodes.Status201Created)); }
public async Task <IActionResult> Create(Staff staff) { StaffCreateViewModel model = GetStaffCreateViewModel(); model.Staff = staff; if (!ModelState.IsValid) { return(View(model) .WithWarning("Something's Not Right", "Check the form")); } // Create hashed pw from user input string hashed_pw = SecurePasswordHasherHelper.Hash(staff.Password); // prepare output parameters for SQL query CreateOutputParams( staff, hashed_pw, out SqlParameter messageParam, out SqlParameter staffCreatedParam, out Staff _staff); // attempt registration of new user with UserManager IdentityResult result = await UserManager.CreateAsync(_staff, hashed_pw).ConfigureAwait(false); if (result.Succeeded) { // link role and staffType to newly created user await createStaffLink(staff, _staff).ConfigureAwait(false); staffCreatedParam.Value = 1; // set staff creation success flag } else { // executes stpAssignStaff Stored Procedure as fallback linking method ExecStpAssignStaff(staff, hashed_pw, messageParam, staffCreatedParam); } // determine redirect action return(await ReturnRedirectCreate(staff, messageParam, staffCreatedParam)); }
public async Task <User> CreateUser(CreateUserDto input) { var isUsernameTaken = await _userRepository.GetAll().FirstOrDefaultAsync(x => x.Username == input.Username); if (isUsernameTaken != null) { var model = new User(); model.Username = "******"; return(model); } var isEmailTaken = await _userRepository.GetAll().FirstOrDefaultAsync(x => x.EmailAddress == input.EmailAddress); if (isEmailTaken != null) { var model = new User(); model.EmailAddress = "Bu E-Posta adresi daha önce alınmış"; return(model); } var user = new User { Username = input.Username, EmailAddress = input.EmailAddress, Gender = input.Gender, Bio = input.Bio, VerificationCode = RandomString.GenerateString(35) }; if (input.ProfileImage != null) { var imgPath = await _blobService.InsertFile(input.ProfileImage); user.ProfileImagePath = imgPath; } var hashedPassword = SecurePasswordHasherHelper.Hash(input.Password); user.Password = hashedPassword; await _userRepository.AddAsync(user); return(user); }
//rota api/contas/registro //Método de registro de usuários public IActionResult Registro([FromBody] Usuario usuario) { var userSameEmail = _svtaDbContext.Usuarios.Where(u => u.Email == usuario.Email).SingleOrDefault(); if (userSameEmail != null) { return(BadRequest("Um usuário com o mesmo e-mail já existe")); } var objetoUsuario = new Usuario() { Nome = usuario.Nome, Email = usuario.Email, Senha = SecurePasswordHasherHelper.Hash(usuario.Senha), DataInclusao = DateTime.Now }; _svtaDbContext.Usuarios.Add(objetoUsuario); _svtaDbContext.SaveChanges(); return(StatusCode(StatusCodes.Status201Created)); }
public IActionResult Register([FromBody] User user) { var userWithSameEmail = _dashboardDbContext.User.Where(u => u.Email == user.Email).SingleOrDefault(); if (userWithSameEmail != null) { return(BadRequest("Um usuário com o mesmo email já existe")); } var userObj = new User() { Name = user.Name, Email = user.Email, Password = SecurePasswordHasherHelper.Hash(user.Password), }; _dashboardDbContext.User.Add(userObj); _dashboardDbContext.SaveChanges(); return(StatusCode(StatusCodes.Status201Created)); }
public async Task <IActionResult> RegisterAdmin(User user) { var userWithSameEmail = _dbContext.Users.SingleOrDefault(u => u.Email == user.Email); if (userWithSameEmail != null) { return(BadRequest("User with this email already exists")); } var userObj = new User { Name = user.Name, Email = user.Email, Password = SecurePasswordHasherHelper.Hash(user.Password), Role = "Admin" }; _dbContext.Users.Add(userObj); await _dbContext.SaveChangesAsync(); return(StatusCode(StatusCodes.Status201Created)); }
public async Task <User> CreateUser(CreateUserDto input) { var user = new User { Name = input.Name, Surname = input.Surname, EmailAddress = input.EmailAddress, Profession = input.Profession, Gender = input.Gender, Username = input.Username, Age = input.Age, PhoneNumber = input.PhoneNumber }; var hashedPassword = SecurePasswordHasherHelper.Hash(input.Password); user.Password = hashedPassword; await _userRepository.AddAsync(user); return(user); }
public IActionResult Register([FromBody] User user) { var userWithSameEmail = _dbContext.Users.Where(u => u.Email == user.Email).SingleOrDefault(); if (userWithSameEmail != null) { return(BadRequest("User with this e-mail address already exist")); } var newUser = new User { Name = user.Name, Email = user.Email, Password = SecurePasswordHasherHelper.Hash(user.Password), Role = "Users" }; _dbContext.Users.Add(newUser); _dbContext.SaveChanges(); return(StatusCode(StatusCodes.Status201Created)); }
public IActionResult Register([FromBody] User user) { User userWithSameEmail = _dbContext.Users.Where(u => u.Email == user.Email).SingleOrDefault(); if (userWithSameEmail != null) { BadRequest("User with the same email exists."); } User userObj = new User { Name = user.Name, Email = user.Email, Password = SecurePasswordHasherHelper.Hash(user.Password), Role = "Users" }; _dbContext.Users.Add(userObj); _dbContext.SaveChanges(); return(StatusCode(StatusCodes.Status201Created)); }
public async Task <bool> ChangePassword(ChangePasswordDto input) { var user = await _userRepository.GetByIdAsync(input.UserId); if (user == null) { throw new Exception("Kullanici bulunamadi"); } var decodedPassword = SecurePasswordHasherHelper.Verify(input.OldPassword, user.Password); if (!decodedPassword) { throw new Exception("Eski sifre yanlis"); } var hashedPassword = SecurePasswordHasherHelper.Hash(input.NewPassword); user.Password = hashedPassword; await _userRepository.UpdateAsync(user); return(true); }