public async Task <User> GetById(int id)
{
var query = new GetUserByIdQuery(id);
var result = await _mediator.Send(query);
return(result);
}
public async Task <IActionResult> GetUserDetailById([FromQuery] long userId)
{
var query = new GetUserByIdQuery(userId);
var result = await _mediator.Send(query);
return(result);
}
public async Task <ClaimsPrincipal> CreateAsync(int userId)
{
var query = new GetUserByIdQuery
{
Id = userId
};
var result = await _mediator.Send(query);
if (result.Failure)
{
throw new InvalidOperationException(result.Error);
}
var permissionNames = result.Value.Roles.SelectMany(r => r.Permissions).Distinct();
var claims = new List <Claim>
{
new Claim(CustomClaimTypes.Identifier, userId.ToString()),
};
claims.AddRange(permissionNames.Select(name => new Claim(CustomClaimTypes.Permission, name)));
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var claimPrincipal = new ClaimsPrincipal(identity);
return(claimPrincipal);
}
public async Task <IActionResult> Get(Guid id)
{
var query = new GetUserByIdQuery(id);
var result = await QueryProcessor.ProcessAsync(query, CancellationToken.None);
return(Ok(new ApiResponse(result)));
}
public async Task <ActionResult <UserResponse> > GetById(int id)
{
var query = new GetUserByIdQuery(id);
var response = await _mediator.Send(query);
return(response != null ? (ActionResult)Ok(response) : NotFound());
}
UserDetailDto IQueryHandler <GetUserByIdQuery, UserDetailDto> .Handle(GetUserByIdQuery query)
{
const string sql = @"
select u.UserId as 'Id', u.FirstName, u.MiddleName, u.LastName, u.Email, u.Phone, u.Mobile
, u.DateCreated, u.DateUpdated, u.DateEnabled, u.DateDeleted
from core_vwUser u
where u.UserId = @Id
;
select r.RoleId as 'Id', r.Name, r.Description
, r.DateCreated, r.DateUpdated, r.DateEnabled, r.DateDeleted
from core_Role r
join core_MembershipRole mr on (mr.RoleId = r.RoleId)
where mr.MembershipId = @Id
;
";
using (var multi = DbConnection.QueryMultiple(sql, new
{
Id = query.UserId
}, DbTransaction))
{
var item = multi.Read <UserDetailDto>().SingleOrDefault();
if (item != null)
{
var roles = multi.Read <RoleDto>().ToList();
item.Roles = roles;
}
return(item);
}
}
public async Task <IActionResult> GetById(Guid id)
{
var query = new GetUserByIdQuery(id);
var result = await Mediator.Send(query);
return(await ResponseBase(result));
}
public async Task <IActionResult> SwitchRole(string role)
{
var query = new GetUserByIdQuery(User.Identity.Name);
var response = await _mediator.Send(query);
if (response == null)
{
return(Unauthorized());
}
var validRole = response.Roles.Contains(role);
if (!validRole)
{
return(Unauthorized());
}
var expiry = DateTime.UtcNow.AddDays(3);
var token = generateToken(response, expiry, role);
return(Ok(Result.Ok(new
{
Token = token,
Expiry = expiry
})));
}
public async Task <IActionResult> GetUserById(int userId)
{
var query = new GetUserByIdQuery(userId);
var result = await Mediator.Send(query);
return(result != null ? (IActionResult)Ok(result) : NotFound());
}
public async Task <ActionResult <UserDTO> > GetUser(Guid id)
{
var query = new GetUserByIdQuery(id);
var result = await _mediator.Send(query);
return(result);
}
public async Task IsActiveAsync(IsActiveContext context)
{
var sub = context.Subject?.GetSubjectId();
if (sub == null)
{
throw new Exception("No subject Id claim present");
}
if (!Guid.TryParse(sub, out Guid id))
{
throw new Exception("Invalid subject Id claim");
}
var getUserByIdQuery = new GetUserByIdQuery()
{
Id = id
};
var user = await _mediator.Send(getUserByIdQuery);
//if (user == null)
//{
// Logger?.LogWarning("No user found matching subject Id: {0}", sub);
//}
context.IsActive = user != null;
}
public async Task <ApiResponse> GetUser([FromRoute] AppUserId appUserId)
{
var request = new GetUserByIdQuery(appUserId);
var response = await _mediator.Send(request);
return(new ApiResponse(response));
}
public void GetUserByIdQuery_Ok()
{
//Arrenge
Guid id = Guid.NewGuid();
_userdataMock.Setup(p => p.GetUser(It.IsIn(id)))
.Returns(new User
{
Id = id,
Email = "*****@*****.**",
Username = "******"
});
User userExpectation = new User
{
Id = id,
Email = "*****@*****.**",
Username = "******"
};
//Act
User user = new GetUserByIdQuery(_userdataMock.Object).Execute(new GetUserByIdQueryRequest
{
Id = id
});
//Assert
_userdataMock.Verify(p => p.GetUser(It.IsIn(id)), Times.Once);
Assert.IsTrue(userExpectation.Id == user.Id);
Assert.IsTrue(userExpectation.Email == user.Email);
Assert.IsTrue(userExpectation.Username == user.Username);
}
public async Task <IActionResult> Edit(int userId)
{
var query = new GetUserByIdQuery(userId);
var result = await _mediator.Send(query);
return(View(result));
}
public async Task<IActionResult> GetUser([FromRoute] GetUserByIdQuery userId)
{
if (userId is null)
{
return BadRequest(CreateErrorResponse("Parâmetros inválidos ou nulos"));
}
var tokenEmail = User.GetUserEmail();
var tokenUserId = User.GetUserId();
var token = Request.Headers["Authorization"].ToString().Replace("Bearer ", "");
var response = await _mediator.Send(userId);
var user = response.Value?.User;
if (user is null)
{
return NoContent();
}
if(token != user.Token || user.Email != tokenEmail || user.Id != tokenUserId)
{
return Unauthorized();
}
if((DateTime.UtcNow - user.LastLogin).TotalMinutes >= 30)
{
return BadRequest(CreateErrorResponse("Sessão inválida"));
}
return Ok(user);
}
public async Task GivenGetUserByIdQuery_WithInvalidId_ReturnsNull()
{
// Arrange
var cancellationToken = new CancellationToken();
var getUserByIdQuery = new GetUserByIdQuery
{
Id = Guid.NewGuid()
};
var user = new UserEntity
{
Id = Guid.NewGuid(),
EmailAddress = "*****@*****.**",
Password = "******",
UserName = "******",
FriendlyName = "John Smith",
Roles = new List <UserRole> {
UserRole.Standard
}
};
await _userCollection.InsertOneAsync(user, null, cancellationToken);
// Act
var result = await _classUnderTests.Handle(getUserByIdQuery, cancellationToken);
// Assert
Assert.That(result, Is.Null);
}
private UserDto GetAuthorizedUser()
{
var userId = new Guid(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var query = new GetUserByIdQuery(userId);
var userDto = new UserDto(queryBus.Execute(query).User);
return(userDto);
}
public static UserDto GetUserById(int userId)
{
var queryObject = new GetUserByIdQuery(userId);
var handler = new GetUserByIdQueryHandler();
UserDto user = handler.Handle(queryObject).Result;
return(user);
}
public Task <SingleUserQueryResponse> Handle(GetUserByIdQuery request, CancellationToken cancellationToken)
{
TravelUser user = _repo.GetUserById(request.UserId);
var response = new SingleUserQueryResponse(user);
response.Status = GetResponseStatus(user);
return(Task.FromResult(response));
}
public async Task <IActionResult> Get(int id)
{
var query = new GetUserByIdQuery
{
Id = id
};
return(Ok(await Mediator.Send(query)));
}
public async Task <IActionResult> GetUserById(int userId)
{
var getUserByIdQuery = new GetUserByIdQuery(User, userId);
var getUserByIdResult = await _mediator.Send(getUserByIdQuery).ConfigureAwait(false);
return(getUserByIdResult.IsSuccess
? Ok(getUserByIdResult.Value)
: BadRequest(getUserByIdResult.Error));
}
public async Task <IActionResult> OnRead(Guid id)
{
var query = new GetUserByIdQuery()
{
Id = id
};
return(Ok(await mediator.Send(query)));
}
public async Task <UserModel> GetById(int id)
{
var queries = new GetUserByIdQuery
{
Id = id
};
return(await Mediator.Send(queries));
}
public async Task <User> ById(string id)
{
var getUserByIdQuery = new GetUserByIdQuery()
{
Id = id
};
return(await _mediator.Send(getUserByIdQuery));
}
public IActionResult Get([FromServices] IUnitOfWork unitOfWork,
[FromServices] IQueryHandlerDispatcher queryHandlerDispatcher,
string id)
{
var query = new GetUserByIdQuery("corrid", id);
var dto = queryHandlerDispatcher.Handle <GetUserByIdQuery, UserDetailDto>(query);
return(Ok(dto));
}
public IActionResult GetById([FromQuery] GetUserByIdQuery query)
{
var user = _mediator.Send(query);
if (user.Result == null)
{
return(BadRequest("Error"));
}
return(Ok(user));
}
public async Task <BaseResponse <UserResponse> > Handle(GetUserByIdQuery request, CancellationToken cancellationToken)
{
var users = await _applicationDbContext.Users.FindAsync(request.Id);
var userResponse = _mapper.Map <UserResponse>(users);
var response = new BaseResponse <UserResponse>();
response.SetIsOk(userResponse);
return(response);
}
public async Task <ActionResult <UserResource> > GetUserAsync([FromRoute] GetUserByIdQuery userQuery)
{
var user = await _mediator.Send(userQuery);
if (user == null)
{
return(NotFound());
}
return(user);
}
public async Task <UserDetail> HandleAsync(GetUserByIdQuery query)
{
var user = await _repository.GetById(query.Id);
if (user == null)
{
return(null);
}
return(_mapper.Map <UserDetail>(user));
}
public async Task <IActionResult> Get([FromRoute] GetUserByIdQuery request)
{
var resp = await _mediatr.Send(request);
if (resp == null)
{
return(NotFound());
}
return(Ok(resp));
}
