public async Task <IActionResult> Employee(UserFilterDto filterParams) { var employeeRole = await _roleManager .FindByNameAsync("employee") ?? throw new Exception("Не удалось найти роль"); var employeeIdsQuery = _dbContext.UserRoles .Where(x => x.RoleId == employeeRole.Id) .Select(x => x.UserId); var employees = _dbContext.ProfileInfos .Where(x => employeeIdsQuery.Contains(x.User.Id)) .Select(x => new UserDto() { Email = x.User.Email, PhoneNumber = x.User.PhoneNumber, Name = x.Name ?? string.Empty, MiddleName = x.MiddleName ?? string.Empty, Surname = x.SurName ?? string.Empty, Education = x.Education ?? string.Empty, HistoryOfWork = x.HistoryOfWork ?? string.Empty, }) .FilterEmployees(filterParams) .ToList(); return(View(employees)); }
private CompositePredicate CreateCompositePredicateFromFilter(UserFilterDto filter) { List <IPredicate> predicates = new List <IPredicate>(); if (filter.Username != null) { predicates.Add(new SimplePredicate(nameof(User.Username), ValueComparingOperator.Equal, filter.Username)); } if (filter.Email != null) { predicates.Add(new SimplePredicate(nameof(User.Email), ValueComparingOperator.Equal, filter.Email)); } if (filter.Gender != Gender.NoInformation) { predicates.Add(new SimplePredicate(nameof(User.Gender), ValueComparingOperator.Equal, filter.Gender)); } if (filter.BornBefore != DateTime.MinValue) { predicates.Add(new SimplePredicate(nameof(User.Birthdate), ValueComparingOperator.LessThan, filter.BornBefore)); } if (filter.BornAfter != DateTime.MinValue) { predicates.Add(new SimplePredicate(nameof(User.Birthdate), ValueComparingOperator.GreaterThan, filter.BornAfter)); } return(new CompositePredicate(predicates, LogicalOperator.AND)); }
public List <ReferenceDto> GetByPrefix(UserFilterDto userFilterDto) { return(_userDao.FindByPrefix(userFilterDto.Surname, x => new ReferenceDto() { Id = x.Id, Label = x.FirstName + " " + x.Surname })); }
// GET: InviteUsersToGroup public async Task <ActionResult> Index([FromUri] string subname = "", int?groupId = null) { var filter = new UserFilterDto { SubName = subname }; var user = await BasicUserFacade.GetUserByNickNameAsync(User.Identity.Name); var users = await BasicUserFacade.GetUsersBySubnameAsync(subname); var basicUserDtos = users as IList <BasicUserDto> ?? users.ToList(); foreach (var u in basicUserDtos) { await BasicUserFacade.AssignGroupsToUserAsync(u); } var basicUserWithFriends = await BasicUserFacade.GetBasicUserWithGroups(user.Id); return(View("InviteUsersToGroupView", new InviteUsersToGroupModel { Filter = filter, Users = basicUserDtos, User = basicUserWithFriends, GroupId = groupId })); }
public ActionResult EditUser(UserViewModel user) { if (IsPost) { user.UserType = UserType.Management; UserDto userDto = user.MapTo <UserDto>(); SaveUserDto saveUserDto = new SaveUserDto() { User = userDto }; var result = userAppService.SaveUser(saveUserDto); return(Json(result)); } else if (user.Id > 0) { UserFilterDto filter = new UserFilterDto() { Ids = new List <long>() { user.Id } }; user = userAppService.GetUser(filter).MapTo <UserViewModel>(); } return(View(user)); }
public async Task <object> GetUsersToAdmin(UserFilterDto userFilterDto) { var shopUsers = await _shopUserRepository.GetUsers(userFilterDto.Start, userFilterDto.Length, userFilterDto.Cpf, userFilterDto.Name, userFilterDto.Email, userFilterDto.Office, userFilterDto.UserStatus, userFilterDto.cnpj, userFilterDto.network); var userWithNetwork = shopUsers.Users.GroupBy(x => new { x.User.Cpf, x.User.Name, x.User.Email, UserStatus = x.User.UserStatus.Description, Office = x.User.Office.Description, Network = x.Shop.Network.Name, x.User.Id }).Select(x => new[] { x.Key.Cpf, x.Key.Name, x.Key.Email, x.Key.UserStatus, x.Key.Office, x.Key.Network, x.Key.Id.ToString() }).ToList(); return(new { data = userWithNetwork, recordsTotal = shopUsers.Count, recordsFiltered = shopUsers.Count }); }
public async Task <QueryResultDto <UserDto, UserFilterDto> > GetUserForFilter( UserFilterDto userFilterDto) { using (UnitOfWorkProvider.Create()) { return(await userService.GetFiltered(userFilterDto)); } }
private void ValidateUser(UserDto user, UserFilterDto filter) { if (filter == null) { throw new ArgumentNullException(); } ValidateUser(user); }
public List <UserDto> AllSubscribersOfMatching(UserDto publisher, UserFilterDto filter) { ValidateUser(publisher, filter); return(ExecuteSelectQuery(unitOfWork => unitOfWork .UserRepository .GetAllSubscribersOfMatching(publisher.MapToDbEntity(), filter.MapToDbEntity()))); }
public List <UserDto> AllSubscriptionsOfMatching(UserDto subscriber, UserFilterDto filter) { ValidateUser(subscriber, filter); return(ExecuteSelectQuery(uow => uow .UserRepository .GetAllSubscriptionsOfMatching(subscriber.MapToDbEntity(), filter.MapToDbEntity()))); }
protected override IQuery <User> ApplyWhereClause(IQuery <User> query, UserFilterDto filter) { var simplePredicate = new SimplePredicate(nameof(User.NickName), ValueComparingOperator.Equal, filter.NickName); return(string.IsNullOrEmpty(filter.NickName) ? query : query.Where(simplePredicate)); }
protected override IQuery <User> ApplyWhereClause(IQuery <User> query, UserFilterDto filter) { var simplePredicate = new SimplePredicate(nameof(User.NickName), ValueComparingOperator.StringContains, filter.SubName); return(filter.Equals(null) ? query : query.Where(simplePredicate)); }
protected override IQuery <User> ApplyWhereClause(IQuery <User> query, UserFilterDto filter) { if (string.IsNullOrEmpty(filter.Email)) { return(query); } return(query.Where(new SimplePredicate(nameof(User.Email), ValueComparingOperator.Equal, filter.Email))); }
protected override IQuery <User> ApplyWhereClause(IQuery <User> query, UserFilterDto filter) { return(filter.Username != null && filter.Email != null && filter.Gender == Gender.NoInformation && filter.BornBefore == DateTime.MinValue && filter.BornAfter == DateTime.MinValue ? query : query.Where(CreateCompositePredicateFromFilter(filter))); }
private static SimplePredicate FilterUserName(UserFilterDto filter) { if (string.IsNullOrWhiteSpace(filter.UserName)) { return(null); } return(new SimplePredicate(nameof(User.UserName), ValueComparingOperator.Equal, filter.UserName)); }
public List <UserDto> AllUsersMatching(UserFilterDto filter) { if (filter == null) { throw new ArgumentNullException(); } return(ExecuteSelectQuery(uow => uow .UserRepository .GetAllUsersMatching(filter.MapToDbEntity()))); }
public async Task <IEnumerable <UserDto> > GetUsers(UserFilterDto filterDto) { var users = await _userService.FindUsersAsync( filterDto.LoginFilter, filterDto.FullNameFilter, filterDto.IsAdminFilter); var usersDto = _mapper.Map <IEnumerable <UserDto> >(users); return(usersDto); }
public IHttpActionResult Count([FromUri] UserFilterDto userFilterDto) { if (userFilterDto == null) { userFilterDto = new UserFilterDto(); } var count = userFilterDto.ApplyTo(shoppingEntities.Users).Count(); return(Ok(count)); }
public IActionResult GetPageUser([FromQuery] UserFilterDto param) { var result = _userService.GetPageUser(param); if (!result.IsSuccess) { return(BadRequest(result)); } return(Ok(result.Response)); }
/// <summary> /// Finds paged users. /// </summary> /// <param name="userFilterDto">The filtering DTO</param> /// <returns>The User DTO page</returns> internal IPagedList <UserDto> FindPaged(UserFilterDto userFilterDto) { return(_modelContext.Set <User>() .Where(ExpressionQueryBuilder.BuildWhere <User>(userFilterDto)) .OrderBy(x => x.Surname) .Select(x => new UserDto() { Id = x.Id, BujinkanTitle = x.BujinkanTitle, FirstName = x.FirstName, Surname = x.Surname }) .ToPagedList(userFilterDto.Page, userFilterDto.PageSize)); }
public UserWithRolesFilterPaginatedSpecification(UserFilterDto userFilter) : base(x => (string.IsNullOrWhiteSpace(userFilter.Name) || x.FirstName.ToLower().Contains(userFilter.Name.ToLower()) || x.LastName.ToLower().Contains(userFilter.Name.ToLower()) || x.Username.ToLower().Contains(userFilter.Name.ToLower()) || (x.FirstName + " " + x.LastName).ToLower().Contains(userFilter.Name.ToLower())) && (userFilter.ExcludeUserId == 0 || x.Id != userFilter.ExcludeUserId)) { ApplyPaging(userFilter.Skip, userFilter.Take, userFilter.PageNumber); AddInclude($"{nameof(Domain.Entities.User.Roles)}.{nameof(Domain.Entities.UserRole.Role)}"); }
public async Task ApplyWhereClause_EmptyFilter_ReturnsNull() { var mockManager = new QueryMockManager(); var mapperMock = mockManager.ConfigureMapperMock <User, UserDto, UserFilterDto>(); var queryMock = mockManager.ConfigureQueryMock <User>(); var userQueryObject = new UserQueryObject(mapperMock.Object, queryMock.Object); var filter = new UserFilterDto(); var temp = await userQueryObject.ExecuteQuery(filter); Assert.AreEqual(null, mockManager.CapturedPredicate); }
public async Task <IHttpActionResult> AutoCompleteList([FromUri] UserFilterDto model, Guid?id = null, string text = null) { var result = await userService.AutoCompleteList(model, id, text); if (result == null) { return(Content(HttpStatusCode.OK, new string[0])); } return(Ok(result)); }
public async Task <IHttpActionResult> Get([FromUri] UserFilterDto model, string sortField, bool sortOrder) { var result = await userService.Get(model, sortField, sortOrder); if (result == null || result.Count <= 0) { result = new List <UserListDto>(); } return(Ok(result)); }
public async Task <IEnumerable <UserForListDto> > GetAll(UserFilterDto userFilter) { userFilter.ExcludeUserId = (int)_currentUserService.UserId; var users = await _uow.Repository <Domain.Entities.User>().FindAsyncWithPagination(new UserWithRolesFilterPaginatedSpecification(userFilter)); _context.HttpContext.Response.AddPagination(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalPages); var usersToReturn = _mapper.Map <IEnumerable <UserForListDto> >(users); await _photoService.IncludeMainPhoto(usersToReturn, (int)EntityTypes.User); return(usersToReturn); }
public async Task <IHttpActionResult> GetAsync([FromUri] UserFilterDto userFilterDto) { if (userFilterDto == null) { userFilterDto = new UserFilterDto(); } var users = await userFilterDto.SkipAndTake(userFilterDto.ApplyTo(shoppingEntities.Users.AsNoTracking().Include(t => t.Role))).ToListAsync(); var userDtos = users.ConvertAll(t => new UserDto(t)); return(Ok(userDtos)); }
public async Task <IEnumerable <UserDto> > GetFilteredUsersAsync(UserFilterDto filter) { using (UnitOfWorkProvider.Create()) { if (filter == null) { var temp = await userService.ListAllAsync(); return(temp.Items); } return(await userService.ListFilteredUsers(filter)); } }
public async Task <IActionResult> Employer(UserFilterDto filterParams) { var employerRole = await _roleManager .FindByNameAsync("employer") ?? throw new Exception("Не удалось найти роль"); var employerIdsQuery = _dbContext.UserRoles .Where(x => x.RoleId == employerRole.Id) .Select(x => x.UserId); /*var employers = _dbContext.Users * .Where(x => employerIdsQuery.Any(id => id == x.Id)) * .ToList(); */ var employers = _dbContext.ProfileInfos .Where(x => employerIdsQuery.Contains(x.User.Id)) .Select(x => new UserDto() { Email = x.User.Email, PhoneNumber = x.User.PhoneNumber, Name = x.Name ?? string.Empty, MiddleName = x.MiddleName ?? string.Empty, Surname = x.SurName ?? string.Empty, Education = x.Education ?? string.Empty, HistoryOfWork = x.HistoryOfWork ?? string.Empty, }) .FilterEmployers(filterParams) .ToList(); //var employerViewModels = employers // .Select(x => new // { // x, // Profile =_dbContext.ProfileInfos.FirstOrDefault(y => y.UserId == x.Id) // }) // .Select(x => new UserDto() // { // Email = x.x.Email, // PhoneNumber = x.x.PhoneNumber, // Name = x.Profile?.Name ?? "", // MiddleName = x.Profile?.MiddleName?? "", // Surname = x.Profile?.SurName ?? "", // Education = x.Profile?.Education ?? "", // HistoryOfWork = x.Profile?.HistoryOfWork ?? "" // }) // .ToList(); return(View(employers)); }
/// <summary> /// Finds paged users. /// </summary> /// <param name="userFilterDto">The filtering DTO</param> /// <returns>The User DTO page</returns> internal IPagedList <UserDto> FindPaged(UserFilterDto userFilterDto) { return(_modelContext.Set <User>() .Where(ExpressionBuilder.BuildWhere <User>(userFilterDto)) .OrderBy(x => x.Surname) .Select(x => new UserDto() { Id = x.Id, FirstName = x.FirstName, Surname = x.Surname, Email = x.Email, PaintingsCount = x.Paintings.Count }) .ToPagedList(userFilterDto.Page, userFilterDto.PageSize)); }
public ActionResult CheckUserName(string userName) { bool allowUse = true; if (!userName.IsNullOrEmpty()) { UserFilterDto filter = new UserFilterDto() { UserName = userName }; var user = userService.GetUser(filter); allowUse = user == null; } return(Content(allowUse ? "true" : "false")); }