public void SetUp()
{
_service = new Mock <IGetUserService>();
_sut = new GetUserQueryHandler(_service.Object);
_query = new GetUserQuery("userId");
}
public async Task <List <GoodFoodUserDto> > Handle(GetUserQuery request,
CancellationToken cancellationToken)
{
var users = await _userAuth.GetAllUser();
return(users);
}
public async Task <ActionResult> Get(int id)
{
var command = new GetUserQuery(id);
var result = await _mediatr.Send(command);
return(result != null ? (ActionResult)Ok(new { Message = "success", data = result }) : NotFound(new { Message = "not found" }));
}
public async Task GetUserQuery_does_not_return_a_user_when_not_available()
{
//Arrange
var userId1 = Guid.NewGuid();
var userId2 = Guid.NewGuid();
GetUserResponse response;
using (var db = MockDbContext())
{
db.Users.RemoveRange(db.Users);
db.Users.Add(new User {
Id = userId1, Name = "Tester1", Email = "*****@*****.**"
});
db.Users.Add(new User {
Id = userId2, Name = "Tester2", Email = "*****@*****.**"
});
db.SaveChanges();
}
using (var db = MockDbContext())
{
// run your test here
var request = new GetUserQuery(Guid.NewGuid());
var handler = new GetUserQueryHandler(db);
//Act
response = await handler.Handle(request, CancellationToken.None);
}
//Assert
response.Should().Be(null);
}
public async Task <DeleteUserByIdResponse> Handle(DeleteUserByIdRequest request, CancellationToken cancellationToken)
{
var query = new GetUserQuery()
{
Id = request.Id
};
var id = await queryExecutor.Execute(query);
if (id == null)
{
return(new DeleteUserByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var user = this.mapper.Map <User>(request);
var command = new DeleteUserByIdCommand()
{
Parameter = user
};
var userFromDB = await this.commandExecutor.Execute(command);
return(new DeleteUserByIdResponse()
{
Data = userFromDB
});
}
public async Task <AddEmployeeResponse> Handle(AddEmployeeRequest request, CancellationToken cancellationToken)
{
if (request.AuthenticatorRole == AppRole.Employee)
{
return(new AddEmployeeResponse()
{
Error = new ErrorModel(ErrorType.Unauthorized)
});
}
var employeeQuery = new GetUserQuery <Employee>()
{
Login = request.Login
};
var availableManager = await queryExecutor.Execute(employeeQuery);
if (availableManager != null)
{
return(new AddEmployeeResponse()
{
Error = new ErrorModel(ErrorType.Conflict)
});
}
var query = new GetCompanyQuery()
{
Id = request.CompanyId,
CompanyId = request.AuthenticatorCompanyId
};
var company = await queryExecutor.Execute(query);
if (company == null)
{
return(new AddEmployeeResponse
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var auth = passwordHasher.Hash(request.Password);
request.Password = auth[0];
request.Salt = auth[1];
var employee = mapper.Map <Employee>(request);
employee.Board = new Board();
var command = new AddEmployeeCommand()
{
Parameter = employee
};
var employeeFromDb = await commandExecutor.Execute(command);
employeeFromDb.Company.EmployeesList = null;
employeeFromDb.Company.Manager = null;
return(new AddEmployeeResponse()
{
Data = mapper.Map <EmployeeDto>(employeeFromDb)
});
}
public async Task Handle_ReturnsNull_WhenUserDoesntExist()
{
//arrange
DbContext.Users.AddRange(
new User {
Username = "******"
},
new User {
Username = "******"
},
new User {
Username = "******"
},
new User {
Username = "******"
});
await DbContext.SaveChangesAsync();
var query = new GetUserQuery(int.MaxValue);
//act
GetUserViewModel?actual = await _handler.Handle(query);
//assert
Assert.Null(actual);
}
public async Task <ActionResult <UserReadDTO> > Get()
{
var request = new GetUserQuery(User.Identity?.Name);
var response = await _mediator.Send(request);
return(Ok(response));
}
public async Task <IActionResult> GetUser(int id)
{
if (_memoryCache.TryGetValue(string.Format(GET_USER_CACHE, id), out GetUserViewModel user))
{
return(Ok(user));
}
var query = new GetUserQuery(id);
var result = await _mediator.Send(query);
if (result == null)
{
return(NotFound());
}
var memoryCacheOptions = new MemoryCacheEntryOptions
{
//Daqui a 1h, irei invalidar a cache
AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(3600),
//Tempo decorrido sem requisições => Passa 20 minutos seguidos sem nenhuma requisição
SlidingExpiration = TimeSpan.FromSeconds(1200)
};
_memoryCache.Set(string.Format(GET_USER_CACHE, id), result, memoryCacheOptions);
return(Ok(result));
}
public async Task <BaseDto <UserOutput> > Handle(GetUserQuery request, CancellationToken cancellationToken)
{
try
{
var result = await _context.users.FindAsync(request.id);
return(new BaseDto <UserOutput>
{
message = "Success Retrieve User Data",
success = true,
data = new UserOutput
{
id = result.id,
name = result.name,
username = result.username,
email = result.email,
address = result.address
}
});
}
catch (Exception)
{
return(new BaseDto <UserOutput>
{
message = "Failed Retrieve User Data",
success = false,
data = null
});
}
}
public async Task Handle_ReturnsUser(int amount, int index)
{
//arrange
const string expectedUsername = "******";
var user = new User();
for (var i = 0; i < amount; i++)
{
if (i == index)
{
user = new User {
Username = expectedUsername
};
DbContext.Users.Add(user);
await DbContext.SaveChangesAsync();
}
else
{
DbContext.Users.Add(new User {
Username = i.ToString()
});
}
}
await DbContext.SaveChangesAsync();
var query = new GetUserQuery(user.Id);
//act
GetUserViewModel?actual = await _handler.Handle(query);
//assert
Assert.Equal(user.Id, actual.Id);
Assert.Equal(expectedUsername, actual.Username);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)]
GetUserQuery getUserQuery,
ILogger log)
{
try
{
var users = await _mediator.Send(getUserQuery);
return(new OkObjectResult(users));
}
catch (ValidationException validationException)
{
var result = new
{
message = "Validation failed.",
errors = validationException.Errors.Select(x => new
{
x.PropertyName,
x.ErrorMessage,
x.ErrorCode
})
};
return(new BadRequestObjectResult(result));
}
}
public IHttpActionResult SignUp([FromBody] NewUser newUser)
{
if (newUser == null)
{
return(BadRequest());
}
var command = new RegisterNewUserCommand(newUser);
if (!command.IsValidCommand())
{
return(BadRequest());
}
_registerUserUseCase.Handle(command);
var query = new GetUserQuery(command.Login);
var createdUser = _getUserUseCase.Handle(query);
if (createdUser == null)
{
return(NotFound());
}
var newUserUrl = createdUser.Links.Single(x => x.Rel == "self").Href;
return(Created(newUserUrl, createdUser));
}
public async Task Should_ThrowException_When_UserStatusDisabled()
{
// Arrange
IRepository <User> repository = new Repository <User>(_fixture.Context);
var user = new User
{
UserId = 5,
CompanyId = 1,
UserName = "******",
FullName = "Test User",
Status = Domain.Enums.UserStatus.Disabled,
CreatedAt = DateTime.Now,
CreatedBy = -1
};
_fixture.Context.Users.Add(user);
_fixture.Context.SaveChanges();
var handler = new GetUserHandler(repository, _mapper, _logger);
var query = new GetUserQuery(companyId: 1, userId: 5);
// Act
var tcs = new CancellationToken();
var exception = await Assert.ThrowsAsync <VacationTrackingException>(async() =>
{
await handler.Handle(query, tcs);
});
// Assert
Assert.NotNull(exception);
Assert.Equal(404, exception.Code);
Assert.Equal(ExceptionMessages.ItemNotFound, exception.Message);
}
public async Task <UpdateUserByIdResponse> Handle(UpdateUserByIdRequest request, CancellationToken cancellationToken)
{
var query = new GetUserQuery()
{
Id = request.Id
};
var user = await this.queryExecutor.Execute(query);
if (user == null)
{
return(new UpdateUserByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var auth = passwordHasher.Hash(request.Password);
request.Password = auth[0];
request.Salt = auth[1];
var mappedUser = this.mapper.Map <User>(request);
var command = new UpdateUserCommand()
{
Parameter = mappedUser
};
var createdUser = await this.commandExecutor.Execute(command);
return(new UpdateUserByIdResponse()
{
Data = this.mapper.Map <Domain.Models.User>(createdUser)
});
}
public async Task <IActionResult> Get(Guid id)
{
var baseUrl = $"{Request.Scheme}://{Request.Host}{Request.PathBase}";
var query = new GetUserQuery(id, baseUrl);
return(Ok(await _commandQueryDispatcherDecorator.DispatchAsync <GetUserQuery, UserDto>(query)));
}
public async Task <IActionResult> Get(long id, CancellationToken cancellationToken)
{
var getUserQuery = new GetUserQuery(id);
var result = await Mediator.Send(getUserQuery, cancellationToken);
return(Json(result));
}
public ClaimsPrincipal ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)
{
try
{
var validateTokenCommand = new ValidateTokenCommand
{
Value = securityToken
};
var token = _mediator.Send(validateTokenCommand).GetAwaiter().GetResult();
var getUserQuery = new GetUserQuery
{
Id = token.UserId
};
var user = _mediator.Send(getUserQuery).GetAwaiter().GetResult();
var identity = new ClaimsIdentity("Custom");
identity.AddClaim(new Claim(ClaimTypes.Name, user.Name));
identity.AddClaim(new Claim("Id", user.Id.ToString()));
var result = new ClaimsPrincipal(identity);
validatedToken = new AuthenticationToken(token.Id.ToString(), token.ValidFrom, token.ValidTo);
return(result);
}
catch (AuthenticationApplicationException ex)
{
}
validatedToken = null;
return(null);
}
public async Task <GetUserMeResponse> Handle(GetUserMeRequest request, CancellationToken cancellationToken)
{
if (request.Me == "Me" || request.Me == "me")
{
var query = new GetUserQuery()
{
Username = request.AuthenticationName
};
var user = await this.queryExecutor.Execute(query);
if (user == null)
{
return(new GetUserMeResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var mappedUser = this.mapper.Map <User>(user);
return(new GetUserMeResponse()
{
Data = mappedUser
});
}
return(new GetUserMeResponse()
{
Error = new ErrorModel(ErrorType.UnsupportedMethod)
});
}
public async Task <ActionResult> ShareTask(Guid id, string username)
{
var taskDetailsQuery = new TaskDetailsQuery(id);
var task = await Mediator.Send(taskDetailsQuery);
if (task == null)
{
return(NotFound("Task not found"));
}
var loggedUserQuery = new LoggedUserQuery();
User loggedUser = await Mediator.Send(loggedUserQuery);
var getUserQuery = new GetUserQuery(username);
User sharedWithUser = await Mediator.Send(getUserQuery);
if (sharedWithUser == null)
{
return(NotFound("User to share the task with not found."));
}
else if (task.UserTask.SharedWithId != null)
{
return(BadRequest("The task is shared already."));
}
var shareTaskCommand = new ShareTaskCommand(task, loggedUser.Id, sharedWithUser);
await Mediator.Send(shareTaskCommand);
return(NoContent());
}
public async Task <IActionResult> GetById(int id)
{
var getUser = new GetUserQuery(id);
var user = await _mediator.Send(getUser);
return(Ok(user));
}
public async Task <Result <UserForDetailDto> > Handle(GetUserQuery request, CancellationToken cancellationToken)
{
var user = await _repo.GetUser(request.UserId);
var userForDetailDto = _mapper.Map <UserForDetailDto>(user);
return(Result <UserForDetailDto> .Success(userForDetailDto));
}
protected override async Task <AuthenticateResult> HandleAuthenticateAsync()
{
var endpoint = Context.GetEndpoint();
if (endpoint?.Metadata?.GetMetadata <IAllowAnonymous>() != null)
{
return(AuthenticateResult.NoResult());
}
if (!Request.Headers.ContainsKey("Authorization"))
{
return(AuthenticateResult.Fail("Missing Authorization Header"));
}
User user = null;
try
{
var authHeader = AuthenticationHeaderValue.Parse(Request.Headers["Authorization"]);
var credentialBytes = Convert.FromBase64String(authHeader.Parameter);
var credentials = Encoding.UTF8.GetString(credentialBytes).Split(new[] { ':' }, 2);
var username = credentials[0];
//var password = credentials[1];
var query = new GetUserQuery()
{
Username = username
};
user = await this.queryExecutor.Execute(query);
if (user == null)
{
return(AuthenticateResult.Fail("Resource does not exist"));
}
var password = passwordHasher.HashToCheck(credentials[1], user.Salt);
if (user.Password != password)
{
return(AuthenticateResult.Fail("Wrong password"));
}
}
catch
{
return(AuthenticateResult.Fail("Invalid Authorization Header"));
}
var claims = new[] {
new Claim(ClaimTypes.NameIdentifier, user.CompanyId.ToString()),
new Claim(ClaimTypes.Name, user.Username),
new Claim(ClaimTypes.Role, user.Permission.ToString())
};
var identity = new ClaimsIdentity(claims, Scheme.Name);
var principal = new ClaimsPrincipal(identity);
var ticket = new AuthenticationTicket(principal, Scheme.Name);
return(AuthenticateResult.Success(ticket));
}
public async Task <IActionResult> GetUserAsync(Guid id)
{
var query = new GetUserQuery {
Id = id
};
var user = await DispatchQueryAsync <GetUserQuery, UserDto>(query);
return(Ok(user));
}
public async Task <ActionResult <UserDto> > GetById()
{
var getUserQuery = new GetUserQuery
{
UserId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value
};
return(await Mediator.Send(getUserQuery));
}
public async Task <UserDto> GetUser(Guid userId)
{
var query = new GetUserQuery {
Id = userId
};
var user = await _mediator.SendQuery(query);
return(user);
}
public async Task <IActionResult> Get()
{
var query = new GetUserQuery
{
UserId = CurrentUserId
};
return(Ok(await _mediator.Send(query)));
}
public ActionResult Get(GetUserQuery query)
{
var user = new User();
user.Id = Guid.NewGuid().ToString();
user.Email = query.Email;
user.Name = "tien huat";
return(Json(user));
}
public async Task <IActionResult> Get(string id)
{
var getQuery = new GetUserQuery(_context);
var user = await getQuery.Execute(id);
return(user == null
? new NotFoundResult() as ActionResult
: new ObjectResult(user));
}
public async Task <IActionResult> GetUser(int id)
{
var query = new GetUserQuery(id);
var result = await _mediator.Send(query);
return(result != null
? (IActionResult)Ok(result)
: NotFound(string.Format(ModelConstants.PropertyNotFoundFromController, "იუზერი")));
}
