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()); }