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