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