public Task <List <User> > HandleAsync(GetUsersQuery query, CancellationToken cancellationToken = default)
{
var db = _userRepository.Get(new UserQueryOptions
{
IncludeClaims = query.IncludeClaims,
IncludeUserRoles = query.IncludeUserRoles,
IncludeRoles = query.IncludeRoles,
AsNoTracking = query.AsNoTracking,
});
return(_userRepository.ToListAsync(db));
}
public List <User> Handle(GetUsersQuery query)
{
var db = _userRepository.Get(new UserQueryOptions
{
IncludeClaims = query.IncludeClaims,
IncludeUserRoles = query.IncludeUserRoles,
IncludeRoles = query.IncludeRoles,
AsNoTracking = query.AsNoTracking,
});
return(db.ToList());
}
public async Task <IReadOnlyCollection <UserResponse> > Handle(GetUsersQuery query, CancellationToken cancellationToken)
{
var paginationSpec = new PaginatedSpecification(query.PageIndex, query.PageSize);
var users = await _userRepository.GetAllAsync(paginationSpec);
if (users.Count == 0)
{
throw new NotFoundException();
}
return(_mapper.Map <IReadOnlyCollection <UserResponse> >(users));
}
public async Task <IPagedList <User> > Handle(GetUsersQuery query, CancellationToken ct)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var getOptions = _mapper.Map <GetOptions>(query);
var pageOfUsers = await _unitOfWork.UserRepository.Get(getOptions);
return(pageOfUsers);
}
public async Task GetUser()
{
string expectedUser = "******";
var query = new GetUsersQuery();
query.UserNames.Add(expectedUser);
var users = await sut.GetUsers(query);
Assert.NotNull(users);
Assert.NotEmpty(users);
Assert.Equal(expectedUser, users[0].DisplayName, StringComparer.OrdinalIgnoreCase);
}
public IActionResult GetUsers()
{
var query = new GetUsersQuery();
var result = queryProcessor.Process(query);
if (!result.Any())
{
return(NotFound());
}
return(Ok(result));
}
public async Task <IEnumerable <LookupDto> > Handle(GetUsersQuery request, CancellationToken cancellationToken)
{
return(await _db.User.Select(u => new LookupDto()
{
Id = u.Id,
Name = u.Name,
IsActive = u.IsActive,
CreatedBy = u.CreatedBy,
CreatedDate = u.CreatedDate,
LastModifiedBy = u.LastModifiedBy,
LastModifiedDate = u.LastModifiedDate,
}).ToListAsync(cancellationToken: cancellationToken));
}
public UserListVm GetUsers(GetUsersQuery query)
{
if (query == null)
{
throw new ArgumentNullException(string.Format(MessagesModel.NullValueError, "query"));
}
GetUsersQueryResult results = this.queryDispatcher.Dispatch <GetUsersQuery, GetUsersQueryResult, User>(query);
UserListVm vm = UserModelHelper.ResultToUserListVm(results, this.config);
return(vm);
}
private string BuildToken(GetUsersQuery user)
{
IdentityModelEventSource.ShowPII = true;
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("hsfhs i thi si sfs fsjlk ljsf jsfl ljsfl sdfj jksfk s sf j ld"));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(Configuration["JWT:ISSUER"],
Configuration["JWT:ISSUER"],
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public async Task <IActionResult> GetUsers([FromQuery] GetUsersQuery query)
{
//var query = new GetUsersQuery();
var user = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
query.UserID = user;
var result = await _mediator.Send(query);
Response.AddPagination(result.CurrentPage, result.PageSize, result.TotalCount, result.TotalPages);
return(Ok(result));
}
public async Task <PagedResults <UserDto> > Handle(GetUsersQuery request, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(request.Search))
{
return(await _userRepository.GetListPageAsync(request, null));
}
else
{
return(await _userRepository.GetListPageAsync(request,
u =>
u.Email.ToLower().StartsWith(request.Search)));
}
}
public async Task <IEnumerable <ApplicationUser> > Handle(GetUsersQuery request, CancellationToken cancellationToken)
{
var usersResult = await _usersRepository.GetUsers();
if (usersResult.Success)
{
return(usersResult.GetData());
}
else
{
return(new List <ApplicationUser>());
}
}
public async Task <List <UserListDTO> > Handle(GetUsersQuery request, CancellationToken cancellationToken)
{
var usersList = await _userRepository.GetList();
if (usersList == null)
{
throw new Exception("No user found. Failed to get list.");
}
var userDTOList = _mapper.Map <List <User>, List <UserListDTO> >(usersList);
return(userDTOList);
}
public List <AppUserVm> GetUsersAsync(GetUsersQuery query)
{
var users = _userManager.Users.Where(u => u.IsDeleted == false).ToList();
List <AppUserVm> usersVm = new();
foreach (var item in users)
{
usersVm.Add(new AppUserVm {
Id = item.Id, Email = item.Email, FirstName = item.FirstName, LastName = item.LastName
});
}
return(usersVm);
}
public void Should_Be_Valid(int take, int skip)
{
// Arrange
var query = new GetUsersQuery()
{
Take = take, Skip = skip
};
// Act
var result = Target.TestValidate(query);
// Assert
Assert.True(result.IsValid);
}
public async Task <IActionResult> GetStaffAllocation(GetUsersQuery query)
{
var request = await Mediator.Send(query);
if (request != null)
{
return(Json(new
{
users = request.Users
}));
}
return(BadRequest());
}
public UsersController(
GetUsersQuery getUsersQuery,
GetUserTodoListsQuery getUserTodoListsQuery,
CreateUserCommand createUserCommand,
UpdateUserCommand updateUserCommand,
RemoveUserCommand removeUserCommand
)
{
this.getUsersQuery = getUsersQuery;
this.getUserTodoListsQuery = getUserTodoListsQuery;
this.createUserCommand = createUserCommand;
this.updateUserCommand = updateUserCommand;
this.removeUserCommand = removeUserCommand;
}
public void GetUsersQueryHandler_Returns_All_Active_Users()
{
for (var i = 0; i < 9; i++)
{
_context.Users.Add(GetUser(i + 1, (UserStatus)(i % 3 + 1), $"test{i}@test.com", null, null, false, new DateTime(2019, 1, 1)));
}
var handler = new GetUsersQueryHandler(_context);
var query = new GetUsersQuery();
var results = handler.Execute(query);
results.Should().HaveCount(3);
}
public async Task <ActionResult> Index(GetUsersQuery query)
{
if (!await this.Authorizer.AuthorizeAsync(UserPermissions.View))
{
return(new UnauthorizedResult());
}
this.ViewBag.SuperAdmin =
(await this.CommandFactory.Create <GetCurrentGeneralSettingsCommand>().GetAsync()).AdminId;
var vm = await this.CommandFactory.Create <PageUsersCommand>().Setup(query).AsPagingResultAsync();
return(this.View(vm));
}
public async Task <ActionResult <IEnumerable <UserDto> > > GetUsers(
[FromQuery]
GetUsersQuery query,
[DefaultValue(0)]
[Range(0, int.MaxValue)]
int skip,
[DefaultValue(50)]
[Range(1, 100)]
int take)
{
var result = await usersSvc.GetUsers(query, skip, take);
return(Ok(result));
}
public void Arrange()
{
_users = new[] { new User(), new User() };
_query = new GetUsersQuery {
PageSize = 200, PageNumber = 2
};
_userRepository = new Mock <IUserRepository>();
_userRepository.Setup(r => r.GetUsers(_query.PageSize, _query.PageNumber)).ReturnsAsync(_users);
_userRepository.Setup(r => r.GetUserCount()).ReturnsAsync(_users.Length);
_handler = new GetUsersQueryHandler(_userRepository.Object);
}
public async Task <IEnumerable <UserDto> > Handle(GetUsersQuery request, CancellationToken cancellationToken)
{
return(await _context.Users
.AsNoTracking()
.Select(_ => new UserDto
{
Email = _.Email,
Id = _.Id,
Name = _.Name,
City = _.City.Name,
Country = _.City.Country.Name,
PostalCode = _.City.PostCode
}).ToListAsync(cancellationToken: cancellationToken));
}
public async Task <ICollection <User> > GetByQueryAsync(GetUsersQuery query, CancellationToken ct = default)
{
IQueryable <User> dbQuery = DbContext.Users
.Where(t => t.Id != query.UserId);
if (!string.IsNullOrEmpty(query.Term))
{
dbQuery = dbQuery.Where(t => (EntityFrameworkHelper.Functions.Like(t.Email, query.Term) ||
EntityFrameworkHelper.Functions.Like(t.FirstName, query.Term) ||
EntityFrameworkHelper.Functions.Like(t.LastName, query.Term)));
}
return(await dbQuery.ToListAsync(ct));
}
public UserTeamsController(TeamCommunicationDbContext context)
{
_context = context;
this.factory = new DbContextFactory();
this.repo = new UserTeamRepository(factory);
this.query = new GetUserTeamsQuery(factory.CreateDbContext);
this.facade = new UserTeamFacade(repo, query);
this.teamRepo = new TeamRepository(factory);
this.teamQuery = new GetTeamsQuery(factory.CreateDbContext);
this.teamFacade = new TeamFacade(teamRepo, teamQuery);
this.userRepo = new UserRepository(factory);
this.usersQuery = new GetUsersQuery(factory.CreateDbContext);
this.userFacade = new UserFacade(userRepo, usersQuery);
}
public async Task <IEnumerable <User> > GetUsers(GetUsersQuery queryParams, int skip, int take)
{
var query = MakeGetUsersQuery(queryParams);
if (!string.IsNullOrEmpty(queryParams.Name))
{
query.OrderByDesc("score");
}
return(await query
.OrderBy("id")
.Skip(skip)
.Take(take)
.GetAsync <User>());
}
public async Task <IEnumerable <UserDto> > GetUsersAsync(GetUsersQuery query)
{
var sqlQuery = $@"
DECLARE @Ids TABLE(Id UNIQUEIDENTIFIER);
{declareStatement}
;WITH UsersWithDistance AS ({sqlWithStatement})
INSERT INTO @Ids
SELECT U.Id FROM UsersWithDistance AS U
/**where**/
;WITH UsersWithDistance AS ({sqlWithStatement})
SELECT * FROM UsersWithDistance AS U
/**where**/
SELECT P.Id
,P.No AS FileNo
,P.Name AS FileName
,@BaseUrl + '/' + P.Path AS FileUrl
FROM dbo.UserPhotos P
INNER JOIN @Ids AS Ids ON Ids.Id = P.Id
WHERE P.IsArchived = 0";
var currentUser = await _userRepository.GetAsync(_correlationContext.CurrentUser.UserId.Value);
var sqlBuilder = new SqlBuilder();
var template = sqlBuilder.AddTemplate(sqlQuery, new
{
CurrentLongitude = currentUser.Coordinate.Longitude.ToString().Replace(",", "."),
CurrentLatitude = currentUser.Coordinate.Latitude.ToString().Replace(",", "."),
BaseUrl = query.BaseAppUrl
});
ApplyUsersWhereStatement(sqlBuilder, query);
await using var connection = new SqlConnection(_sqlConnectionConfiguration.MainConnectionString);
using var multi = await connection.QueryMultipleAsync(template.RawSql, template.Parameters);
var users = multi.Read <UserDto>().ToList();
var photos = multi.Read <UserPhotoDto>().ToList();
foreach (var userDto in users)
{
userDto.Photos = photos.Where(x => x.Id == userDto.Id).ToList();
}
return(users);
}
public async Task GetUsers_ValidQuery_UsersHaveRoles()
{
// Arrange
var userRoles = new Dictionary <string, string[]>()
{
[Guid.NewGuid().ToString()] = new string[] { Constants.ROLE_AMIN, Constants.ROLE_USER },
[Guid.NewGuid().ToString()] = new string[] { Constants.ROLE_AMIN },
[Guid.NewGuid().ToString()] = new string[] { Constants.ROLE_USER },
[Guid.NewGuid().ToString()] = new string[] { Constants.ROLE_USER_MANGER },
[Guid.NewGuid().ToString()] = new string[] { Constants.ROLE_USER_MANGER, Constants.ROLE_USER }
};
var users = userRoles
.Select(r => new User()
{
Id = r.Key
})
.AsQueryable();
var userRepoMock = new Mock <IUserRepository>();
userRepoMock.Setup(r => r.GetUsers())
.Returns(users);
var userManagerMock = new Mock <IUserManager>();
foreach (var userRole in userRoles)
{
userManagerMock.Setup(um => um.GetRoles(userRole.Key))
.ReturnsAsync(userRole.Value);
}
var userService = InstantiateUserService(
new Tuple <Type, object>(typeof(IUserManager), userManagerMock.Object),
new Tuple <Type, object>(typeof(IUserRepository), userRepoMock.Object)
);
var query = new GetUsersQuery();
// Act
var result = await userService.GetUsersWithRoles(query);
// Assert
Assert.All(result.Results, r =>
{
Assert.NotNull(r.Roles);
Assert.NotEmpty(r.Roles);
});
}
protected override IEnumerable <UserDto> Handle(GetUsersQuery request)
{
var users = _dbContext.Users
.Include(u => u.Hobbies)
.ThenInclude(h => h.Category)
.Where(u => u.Id != request.Id);
var contacts = _dbContext.Contacts.Where(c => c.MatchedUserId == request.Id || c.UserId == request.Id);
var currentUser = _dbContext.Users.Include(u => u.Hobbies).Where(u => u.Id == request.Id).SingleOrDefault();
var dictionary = new List <GetUsersDto>();
foreach (var user in users)
{
foreach (var contact in contacts)
{
if (user.Id == contact.UserId || user.Id == contact.MatchedUserId)
{
users = users.Where(u => u.Id != user.Id);
}
}
}
foreach (var user in users)
{
var points = 0;
foreach (var hobby in user.Hobbies)
{
foreach (var currentHobby in currentUser.Hobbies)
{
if (hobby.CategoryId == currentHobby.CategoryId)
{
points = points + 2;
}
if (hobby.Level == currentHobby.Level)
{
points = points + 1;
}
}
}
dictionary.Add(new GetUsersDto(points, user));
}
var sorted = dictionary.OrderByDescending(d => d.Key).ToList();
return(sorted == null ? null : Mapper.Map <IEnumerable <UserDto> >(sorted));
}
public async Task <IImmutableList <GetUserDto> > GetByQueryAsync(GetUsersQueryDto query, CancellationToken ct = default)
{
_logger.LogInformation("Get users by query {@UserQuery}", query);
GetUsersQuery dbQuery = _mapper.Map <GetUsersQuery>(query);
ICollection <User> users = await _unitOfWork.UserRepository.GetByQueryAsync(dbQuery, ct);
ICollection <UserContact> userContacts =
await _unitOfWork.UserContactRepository.GetUserContactsAsync(query.UserId, ct);
users = users.Where(t => userContacts.All(c => c.ContactId != t.Id)).ToList();
return(_mapper.Map <ICollection <GetUserDto> >(users).ToImmutableList());
}
public IList <UserViewModel> Execute(GetUsersQuery query)
{
return(_context.Users
.Where(u => u.Status == UserStatus.Active)
.OrderBy(u => u.Id)
.Select(u => new UserViewModel()
{
Id = u.Id,
DisplayName = u.DisplayName ?? "Anonymous",
Email = u.ShowEmail ? u.Email : "Private",
Description = u.Description,
StartDate = u.UserEvents.Min(e => (DateTime?)e.Date)
})
.ToList());
}
