public async Task <UserOutput> Execute(ClaimsPrincipal RequestUser, string id, string userName, string password, int jobId, int sectorId, int plantId, string name, string surname, List <string> roles, string address, string phoneNumber, string Base64Profile, bool active)
{
var identity = (ClaimsIdentity)RequestUser.Identity;
var claims = (List <System.Security.Claims.Claim>)identity.Claims;
string idRequestUser = claims.Find(i => i.Type == "id").Value;
bool canEdit = false;
var permissions = claims.FindAll(i => i.Type == "module/permission" && (i.Value == UserClaim.EditUser || i.Value == UserClaim.ActivateUser || i.Value == UserClaim.DeactivateUser));
if (permissions.Count >= 3)
{
canEdit = true;
}
if (idRequestUser == id || canEdit)
{
var userToUpdate = new Domain.Users.User(id, userName, password, jobId, sectorId, plantId, name, surname, address, phoneNumber, Base64Profile, active);
var userUpdated = await _userRepository.Update(userToUpdate, roles);
return(_mapper.Map <Domain.Users.User, UserOutput>(userUpdated));
}
else
{
throw new UnauthorizedException(userName, "No tiene permisos para editar");
}
}
public async Task <IActionResult> Register([FromBody] UserRegistrationDto data)
{
if (ModelState.IsValid)
{
var user = new Domain.Users.User
{
UserName = data.Email,
Email = data.Email,
FirstName = data.FirstName,
LastName = data.LastName,
FacilityId = data.FacilityId,
DoctorId = data.DoctorId,
DateOfBirthsday = data.DateOfBirthsday,
Role = data.Role
};
var result = await _userManager.CreateAsync(user, data.Password);
if (result.Succeeded)
{
return(Json(JsonResultData.Success()));
}
}
return(Json(JsonResultData.Error("User already exists.")));
}
public async void ExecuteWithCorrectUserTest()
{
//Arrange
Domain.Users.User usRet = new Domain.Users.User("hola", "password", true)
{
Id = "id"
};
var mockUserRepository = new Mock <IUserRepository>();
var mockJwtService = new Mock <IJwtService>();
var mockStorage = new Mock <IStorage>();
var mockUserService = new Mock <IUserService>();
mockUserRepository.Setup(b => b.CheckUser(It.IsAny <Domain.Users.User>())).ReturnsAsync(usRet);
mockJwtService.Setup(b => b.GenerateJWT("hola", "id", 1, 1, 1)).Returns(Task.FromResult("jwt"));
LoginUserUseCase useCase = new LoginUserUseCase(mockUserRepository.Object, mockJwtService.Object, mockUserService.Object, mockStorage.Object);
//Act
var result = await useCase.Execute("hola", "password");
//Assert
Assert.IsType <UserOutput>(result);
}
public async Task UpdatePassword(Domain.Users.User user, string newPassword)
{
var managementApiClient = await tokenGenerator.GetManagementApiClient();
await managementApiClient.Users.UpdateAsync(user.Auth0Id, new UserUpdateRequest()
{
Password = newPassword,
Connection = Config.Connection
});
}
public async Task <UserOutput> Execute(string userName, string password, int jobId, int sectorId, int plantId, string name, string surname, List <string> roles, bool active)
{
if (await _userRepository.CheckUsernameExists(userName))
{
throw new DuplicateEntityException(userName, "Ya existe un usuario con ese nombre");
}
var userToCreate = new Domain.Users.User(userName, password, jobId, sectorId, plantId, name, surname, active);
var userCreated = await _userRepository.Add(userToCreate, roles);
return(_mapper.Map <Domain.Users.User, UserOutput>(userCreated));
}
public async Task <Domain.Users.User> Save(Domain.Users.User user)
{
if (user == null)
{
return(null);
}
var dbUser = user.ToDalOrNull(UserConverter.ToDalNew);
await _users.InsertOneAsync(dbUser).ConfigureAwait(false);
return(user);
}
public void Handle(UserCreateInputData inputData)
{
var username = inputData.UserName;
var duplicateUser = userRepository.FindByUserName(username);
if (duplicateUser != null)
{
throw new Exception("duplicated");
}
var user = new Domain.Users.User(username);
userRepository.Save(user);
var outputData = new UserCreateOutputData(user.Id, DateTime.Now);
presenter.Complete(outputData);
}
public DisplayUserViewModel(Domain.Users.User user, IEncryptor encryptor)
{
UserId = user.Id;
Email = user.Email;
DisplayName = user.DisplayName;
Roles = string.Join(", ", user.Roles);
IsActive = user.IsActive;
GravatarHash = encryptor.Md5Encrypt(Email).Trim().ToLower();
AllRoles =
(
from object role in Enum.GetValues(typeof(Domain.Users.Role))
select new RoleViewModel {
RoleId = (int)role, RoleName = role.ToString(), IsSelected = user.IsInRole(role.ToString())
}
)
.ToList();
}
public async Task <Domain.Users.User> Update(Domain.Users.User user)
{
if (user == null)
{
return(null);
}
var dbUser = user.ToDalOrNull(UserConverter.ToDal);
var filter = Builders <DbEntities.User> .Filter.Where(u => u.Id == user.Id);
var update = Builders <DbEntities.User> .Update
.Set(u => u.Phone.Value, user.Phone.Value)
.Set(u => u.Phone.Confirmed, user.Phone.Confirmed)
.Set(u => u.UserFullName, user.UserFullName)
.Set(u => u.Address.Zip, user.Address.Zip)
.Set(u => u.Address.City, user.Address.City)
.Set(u => u.Address.Street, user.Address.Street)
.Set(u => u.Address.CountryCode, user.Address.CountryCode);
await _users.UpdateOneAsync(filter, update).ConfigureAwait(false);
return(user);
}
public UserOutput(Domain.Users.User user)
{
UserId = user.Id;
Name = user.Name;
AssociatedTodos = user.AssignedTodo;
}
