private async void Button_Click(object sender, RoutedEventArgs e)
{
UserQueryDto queryDto = new UserQueryDto()
{
Date = DateTime.Now,
Path = path.Text,
UserId = currentUser.Id
};
service.AddQuery(queryDto);
ProgressBar.Value = 0;
List <Models.Item> items = new List <Models.Item>();
var itemProvider = new ItemProvider();
try
{
items = await itemProvider.GetItemsAsync(path.Text);
ProgressBar.Value = 100;
}
catch (Exception)
{
// TODO : add logic
}
DataContext = items;
}
public async Task <QueryResultDto <UserDto> > GetUsersAsync(UserQueryDto queryDto)
{
var result = new QueryResult <DomainUser>();
var users = await _userRepository.GetUsersAsync();
var query = users.AsQueryable();
var filterColumnsMap = new Dictionary <string, Expression <Func <DomainUser, bool> > >()
{
["IsActive"] = u => u.IsActive == queryDto.IsActive,
["RoleId"] = u => u.UserRoles.Select(ur => ur.RoleId).Contains(queryDto.RoleId)
};
query = query.ApplyFiltering(queryDto, filterColumnsMap);
var orderoColumnsMap = new Dictionary <string, Expression <Func <DomainUser, object> > >()
{
["fisrtName"] = u => u.FirstName,
["lastName"] = u => u.LastName,
["email"] = u => u.Email,
["createdAt"] = u => u.CreatedAt
};
query = query.ApplyOrdering(queryDto, orderoColumnsMap);
result.TotalItems = query.Count();
query = query.ApplyPaging(queryDto);
result.Items = query.ToList();
return(_mapper.Map <QueryResult <DomainUser>, QueryResultDto <UserDto> >(result));
}
[DontWrapResult] //不需要AbpJsonResult
public async Task <ActionResult> GetUsers(UserQueryDto input)
{
//var tempPageNumber = Request.Query["pageNumber"].ToString();
//var tempPageSize = Request.Query["pageSize"].ToString();
////HttpContextAccessorIns.HttpContext.Request
//string pageNumber = string.IsNullOrWhiteSpace(tempPageNumber) ? "0" : tempPageNumber;
//string pageSize = string.IsNullOrWhiteSpace(tempPageSize) ? "20" : tempPageSize;
var users = (await _userAppService.GetAll(new PagedResultRequestDto {
MaxResultCount = int.MaxValue
})).Items; // Paging not implemented yet
//users=await _userAppService.get
var userlist = users;
if (!string.IsNullOrEmpty(input.departmentname))
{
userlist = users.Where(x => x.FullName.Contains(input.departmentname)).Skip(input.offset * input.limit).Take(input.limit).ToList();
}
//var roles = (await _userAppService.GetRoles()).Items;
//var model = new UserListViewModel
//{
// Users = users,
// Roles = roles
//};
var result = new { total = userlist.Count(), rows = userlist };
return(Json(result));
}
public async Task <QueryResultDto <UserDto> > GetUsers(UserQueryDto userQueryDto)
{
var userQuery = mapper.Map <UserQueryDto, UserQuery>(userQueryDto);
var queryResult = await repository.GetUsers(userQuery);
return(mapper.Map <QueryResult <User>, QueryResultDto <UserDto> >(queryResult));
}
public async Task <ListResultDto <UserListDto> > GetAllAsync(UserQueryDto request)
{
var query =
_userRepository.GetAll()
.WhereIf(!string.IsNullOrWhiteSpace(request.UserName), r => r.UserName.Contains(request.UserName))
.WhereIf(!string.IsNullOrWhiteSpace(request.Name), r => r.Name.Contains(request.Name))
.WhereIf(request.RoleId != 0, r => r.Roles.Any(m => m.RoleId == request.RoleId));
query = !string.IsNullOrWhiteSpace(request.Sorting)
? query.OrderBy(request.Sorting)
: query.OrderBy(r => r.Name);
var count = query.Count();
var list = QueryableExtensions.PageBy(query.AsQueryable(), request).ToList();
var userDtos = list.MapTo <List <UserListDto> >();
foreach (var item in userDtos)
{
var roles = await this.UserManager.GetRolesAsync(item.Id);
var roleNames = this._roleManager.Roles.Where(r => roles.Contains(r.Name)).Select(r => r.DisplayName);
item.Roles = string.Join(",", roleNames.ToArray());
}
return(new PagedResultDto <UserListDto>(count, userDtos));
}
public Expression <Func <User, bool> > GetQueryExpression(UserQueryDto query, Expression <Func <User, bool> > queryExp = null)
{
var isComplete = IsQueryExpressionComplete(query, ref queryExp);
if (isComplete)
{
return(queryExp);
}
var rights = new List <Expression <Func <User, bool> > >();
if (query.UserName.IsNotNullAndEmpty())
{
rights.Add(u => u.UserName.Contains(query.UserName));
}
if (query.Name.IsNotNullAndEmpty())
{
rights.Add(u => u.Name.Contains(query.Name));
}
if (query.StartCreationTime.HasValue)
{
rights.Add(u => u.CreationTime >= query.StartCreationTime);
}
if (query.StopCreateionTime.HasValue)
{
rights.Add(u => u.CreationTime <= query.StopCreateionTime);
}
return(queryExp.AndAlso(rights));
}
protected internal virtual CountResultDto getUserCount(UserQueryDto queryDto)
{
UserQuery query = queryDto.toQuery(ProcessEngine);
long count = query.count();
return(new CountResultDto(count));
}
public async Task <ResultModel> GetUsers(UserQueryDto userQueryDto)
{
return(await Task.Run(() =>
{
try
{
var query = _userDatabaseContext.Users.Where(x => 1 == 1);
if (userQueryDto.Enabled != null)
{
query = query.Where(x => x.Enabled == userQueryDto.Enabled);
}
if (!string.IsNullOrWhiteSpace(userQueryDto.Username))
{
query = query.Where(x => x.Username.Contains(userQueryDto.Username));
}
//后面要做根据条件排序
query = query.OrderBy(x => x.Username);
var list = query.Select(x => new UserDto
{
UserId = x.Id.ToString(),
Username = x.Username,
Enabled = x.Enabled
});
var page = PagedList <UserDto> .ToPagedList(list, userQueryDto.CurrentPage, userQueryDto.PageSize);
return new ResultModel(ResultCode.Success, page);
}
catch (Exception ex)
{
return new ResultModel(ResultCode.Fail, ex.Message);
}
}));
}
public async Task <IActionResult> GetUsers([FromQuery] UserQueryDto query)
{
var usersFromDb = await _repo.GetUsersAsync(_mapper.Map <UserQuery>(query));
var usersToReturn = _mapper.Map <UserResultDto>(usersFromDb);
return(Ok(usersToReturn));
}
public IEnumerable <UserDto> GetPagedByQuery([FromBody] UserQueryDto query, [FromQuery] int page = 1, [FromQuery] int size = 20)
{
var queryExp = GetQueryExpression(query);
return(_userAppService.Get(queryExp)
.Skip((page - 1) * size)
.Take(size)
.ProjectTo <UserDto>(_mapper.ConfigurationProvider));
}
public IEnumerable <UserDto> Get([FromBody] UserQueryDto query, [FromQuery] int page = 1, [FromQuery] int size = 20)
{
var queryExp = GetQueryExpression(query);
return(_userAppService.Get(queryExp)
.Skip((page - 1) * size)
.Take(size)
.Select(u => (UserDto)u));
}
public async Task <ResultModel <PagedList <UserDto> > > GetUserPage(UserQueryDto dto)
{
var userJson = new StringContent(JsonConvert.SerializeObject(dto), Encoding.UTF8, "application/json");
var response = await _httpClient.PostAsync($"/api/Users/GetUsers", userJson);
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <ResultModel <PagedList <UserDto> > >(await response.Content.ReadAsStringAsync()));
}
return(null);
}
public async Task <IHttpActionResult> GetAllAsync([FromUri] UserQueryDto model, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (model == null)
{
model = new UserQueryDto();
}
return(Ok(await _manager.FindAllAsync(model.Name, model.OrderBy, model.Page, model.Limit, model.Fields, cancellationToken)));
}
public List <User> Get(UserQueryDto queryDto)
{
IQueryable <User> query = _repository.Query();
if (queryDto.UserName != null && queryDto.UserName != "")
{
query = query.Where(User => User.UserName.Contains(queryDto.UserName));
}
return(query.ToList());
}
public async Task <IActionResult> SearchAccountByName([FromRoute] string searchKey, [FromQuery] int page, [FromQuery] byte pageSize)
{
var queryDto = new UserQueryDto()
{
Page = page, PageSize = pageSize
};
var isAdmin = User.IsInRole("Admin");
var users = await _userService.SearchByNameAsync(searchKey, queryDto, isAdmin : isAdmin);
var response = _mapper.Map <QueryResultDto <UserDto>, QueryResultResource <UserReducedResource> >(users);
return(new OkObjectResult(response));
}
public async Task <QueryResultDto <ManageUserDto> > GetQueryManageUsers([FromQuery] UserQueryDto filterResource)
{
var filter = mapper.Map <UserQueryDto, UserQuery>(filterResource);
var queryResult = await userService.GetUsersAsync(filter);
var resultDto = mapper.Map <QueryResult <ApplicationUser>, QueryResultDto <ManageUserDto> >(queryResult);
foreach (var userDto in resultDto.Items)
{
userDto.Roles = await userManager.GetRolesAsync(await userManager.FindByIdAsync(userDto.UserId));
}
return(resultDto);
}
public virtual IList <UserProfileDto> queryUsers(UserQueryDto queryDto, int?firstResult, int?maxResults)
{
queryDto.ObjectMapper = ObjectMapper;
UserQuery query = queryDto.toQuery(ProcessEngine);
IList <User> resultList;
if (firstResult != null || maxResults != null)
{
resultList = executePaginatedQuery(query, firstResult, maxResults);
}
else
{
resultList = query.list();
}
return(UserProfileDto.fromUserList(resultList));
}
public async Task <JsonResult> GetAsync([FromQuery] UserQueryDto condition)
{
if (condition.UserName != null)
{
var list = _service.Search(condition);
return(new JsonResult(new
{
code = 20000,
list
}));
}
var items = await _service.GetAll();
return(new JsonResult(new
{
code = 20000,
items
}));
}
public void AddQuery(UserQueryDto queryDto)
{
User user = Database.Users.Get(queryDto.UserId);
// валидация
if (user == null)
{
throw new Exception("User not found");
}
// применяем скидку
UserQuery query = new UserQuery
{
Date = DateTime.Now,
UserId = queryDto.UserId,
Path = queryDto.Path,
};
Database.UserQueries.Create(query);
Database.Save();
}
public IEnumerable <UserDto> Get([FromBody] UserQueryDto query)
{
var queryExp = GetQueryExpression(query);
return(_userAppService.Get(queryExp).Select(u => (UserDto)u));
}
public async Task <IActionResult> GetUsers([FromBody] UserQueryDto dto)
{
return(Json(await _userService.GetUsers(dto)));
}
public List <User> Search(UserQueryDto condition)
{
return(_domain.Get(condition));
}
public async Task <QueryResultDto <UserDto> > SearchByNameAsync(string searchKey, UserQueryDto queryDto, bool isAdmin = false)
{
var result = new QueryResult <DomainUser>();
var users = await _userRepository.GetUsersAsync(isAdmin : isAdmin);
if (!isAdmin)
{
users = users.Where(u => u.IsActive == true).AsQueryable();
}
var query = users.AsQueryable();
query = query.ApplySearch(searchKey);
result.TotalItems = query.Count();
query = query.ApplyPaging(queryDto);
var items = query.ToList();
result.Items = items.OrderBy(q => q.Similarity);
return(_mapper.Map <QueryResult <DomainUser>, QueryResultDto <UserDto> >(result));
}
public ListResultDto <UserListDto> GetAll(UserQueryDto request)
{
throw new System.NotImplementedException();
}
public IEnumerable <UserDto> GetByQuery([FromBody] UserQueryDto query)
{
var queryExp = GetQueryExpression(query);
return(_userAppService.Get(queryExp).ProjectTo <UserDto>(_mapper.ConfigurationProvider));
}
public virtual IList <UserProfileDto> queryUsers(UriInfo uriInfo, int?firstResult, int?maxResults)
{
UserQueryDto queryDto = new UserQueryDto(ObjectMapper, uriInfo.QueryParameters);
return(queryUsers(queryDto, firstResult, maxResults));
}
public virtual CountResultDto getUserCount(UriInfo uriInfo)
{
UserQueryDto queryDto = new UserQueryDto(ObjectMapper, uriInfo.QueryParameters);
return(getUserCount(queryDto));
}
