/// <summary>
/// Altera a senha de um usuário
/// </summary>
/// <param name="userId"></param>
/// <param name="currentPwd"></param>
/// <param name="newPwd"></param>
/// <returns></returns>
public static AuthResult ChangePassword(int userId, string currentPwd, string newPwd)
{
AuthResult authResult = new AuthResult();
UserAccountEntity user = AccountRepository.Instance.GetById(userId);
if (user == null)
{
authResult.AuthStatus = AuthStatus.USER_NOT_EXISTS;
return(authResult);
}
//Valida senha
bool isValidPassword = PasswordUtils.ValidatePassword(currentPwd, user.SecurityStamp, user.PasswordHash);
//Senha inválida
if (!isValidPassword)
{
authResult.AuthStatus = AuthStatus.INVALID_CREDENTIALS;
return(authResult);
}
var security = PasswordUtils.CreateHash(newPwd);
user.PasswordHash = security.Item2;
user.SecurityStamp = security.Item1;
AccountRepository.Instance.Update(user);
authResult.UserRoles = AccountRepository.Instance.GetUserRoles(user.Id);
return(authResult);
}
/// <summary>
/// Atualiza um usuário.
/// </summary>
/// <param name="newUserRequest"></param>
/// <returns>Token de autenticação em caso de sucesso.</returns>
public static AuthResult UpdateUser(NewRequest newUserRequest)
{
AuthResult authResult = ValidateRequest(newUserRequest, true);
if (authResult.AuthStatus == AuthStatus.OK)
{
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
{
UserAccountEntity user = AccountRepository.Instance.FindByUserName(newUserRequest.Username);
if (!String.IsNullOrWhiteSpace(newUserRequest.Password))
{
var security = PasswordUtils.CreateHash(newUserRequest.Password);
user.PasswordHash = security.Item2;
user.SecurityStamp = security.Item1;
}
else
{
user.PasswordHash = user.PasswordHash;
user.SecurityStamp = user.SecurityStamp;
}
if (!String.IsNullOrWhiteSpace(newUserRequest.Email))
{
user.UserName = newUserRequest.Email;
}
AccountRepository.Instance.Update(user);
scope.Complete();
}
}
return(authResult);
}
/// <summary>
/// criaçao de um novo usuário com um perfil
/// </summary>
/// <param name="newUserRequest"></param>
/// <param name="role"></param>
/// <returns></returns>
public static AuthResult CreateFirmUser(NewRequest newUserRequest, Roles role)
{
AuthResult authResult = ValidateRequest(newUserRequest, true);
if (authResult.AuthStatus == AuthStatus.OK)
{
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required))
{
if (!string.IsNullOrWhiteSpace(newUserRequest.Cpf))
{
newUserRequest.Cpf = newUserRequest.Cpf.Replace(".", "").Replace("-", "");
}
UserAccountEntity user = AccountRepository.Instance.FindByUserName(newUserRequest.Username);
if (user != null)
{
authResult.AuthStatus = AuthStatus.USER_ALREADY_EXISTS;
}
else
{
var security = PasswordUtils.CreateHash(newUserRequest.Password);
var userAccount = AccountRepository.Instance.Create(new UserAccountEntity()
{
UserName = newUserRequest.Username.ToLower(),
PasswordHash = security.Item2,
SecurityStamp = security.Item1,
});
if (userAccount.Id > 0)
{
UserProfileEntity profileData = new UserProfileEntity()
{
CPF = newUserRequest.Cpf,
Name = newUserRequest.Name,
Phone = newUserRequest.Phone,
Id = userAccount.Id,
Email = newUserRequest.Email,
};
UserProfileEntity userProfile = AccountRepository.Instance.CreateProfile(profileData);
AccountRepository.Instance.CreateUserRole(userAccount.Id, role);
authResult.UserId = userAccount.Id;
}
scope.Complete();
}
}
}
return(authResult);
}
public IActionResult Initialize([FromBody] Request <Initialize> request)
{
var hasOwner = _userRepository.GetOwner() != null;
if (hasOwner)
{
throw new RequestException(HttpStatusCode.NotFound);
}
if (request.Data.Alias?.Length < 5)
{
throw new InvalidOperationException($"\"{nameof(request.Data.Alias)}\" length must be at least 5 characters long.");
}
if (request.Data.Login?.Length < 5)
{
throw new InvalidOperationException($"\"{nameof(request.Data.Login)}\" length must be at least 5 characters long.");
}
if (request.Data.Password?.Length < 6)
{
throw new InvalidOperationException($"\"{nameof(request.Data.Password)}\" length must be at least 5 characters long.");
}
_userService.Save(new User
{
Alias = request.Data.Alias,
Login = request.Data.Login,
PasswordHash = PasswordUtils.CreateHash(request.Data.Password),
HierarchyLevel = 0,
Permissions = UserPermissions.Owner
});
foreach (var watchService in _watches)
{
watchService.EnsureRegistered();
}
_unitOfWork.Commit();
var isLoggedIn = _authenticationService.TryLogIn(request.Data.Login, request.Data.Password, false, HttpContext);
if (!isLoggedIn)
{
throw new InvalidOperationException("Unable to perform Authentication for Owner.");
}
return(this.ApiSuccessResult(request));
}
public bool TryLogIn(string login, string password, bool persistent, HttpContext context)
{
var passwordHash = PasswordUtils.CreateHash(password);
var userId = _userRepository.FirstOrDefault(u => u.Login == login && u.PasswordHash == passwordHash, u => u.Id);
if (userId == 0)
{
return(false);
}
var remoteIpAddress = context.GetRemoteIpAddress();
var session = _sessionService.CreateSession(userId, remoteIpAddress, persistent);
context.Response.Cookies.Append(SessionCookieName, session.Hash, new CookieOptions
{
Expires = new DateTimeOffset(session.ExpirationTime)
});
return(true);
}
/// <summary>
/// Altera a senha de um usuário
/// </summary>
/// <param name="email"></param
/// <param name="newPwd"></param>
/// <returns></returns>
public static AuthResult ChangePassword(string email, string newPwd)
{
AuthResult authResult = new AuthResult();
UserAccountEntity user = AccountRepository.Instance.GetByEmail(email);
if (user == null)
{
authResult.AuthStatus = AuthStatus.USER_NOT_EXISTS;
return(authResult);
}
var security = PasswordUtils.CreateHash(newPwd);
user.PasswordHash = security.Item2;
user.SecurityStamp = security.Item1;
AccountRepository.Instance.Update(user);
authResult.UserRoles = AccountRepository.Instance.GetUserRoles(user.Id);
return(authResult);
}
