public async Task <IResultModel> PageAsync(RoleListInput input)
{
StringBuilder sb = new StringBuilder();
sb.Append("where IsDeleted=0 ");
if (input.Name.NotNull())
{
sb.Append(" and Name=@Name ");
}
if (input.Enabled != null)
{
sb.Append(" and Enabled=@Enabled ");
}
var list = await _roleRepository.GetListPagedAsync(input.Page, input.Limit, sb.ToString(), $"{input.Field} {input.Order}", new { input.Enabled, input.Name });
var total = await _roleRepository.RecordCountAsync(sb.ToString(), new { input.Enabled, input.Name });
var data = new PageOutput <RoleListOutput>()
{
Data = _mapper.Map <List <RoleListOutput> >(list),
Count = total
};
return(ResultModel.Success(data));
}
/// <summary>
/// 获取用户列表
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public async Task <IResponseOutput> GetUserListAsync(PageInput param)
{
var userQurey = _userRepo.Query.Count(out int count).PageBy(param);
var data = await(from u in userQurey
join r in _roleRepo.Query
on u.RoleId equals r.Id into ur
from r2 in ur.DefaultIfEmpty()
select new UserListOutput
{
Id = u.Id,
CreatedTime = u.CreatedTime,
Name = u.NickName,
UserName = u.UserName,
NickName = u.NickName,
Remark = u.Remark,
RoleNames = new string[] { r2.Name },
Status = u.Status
}).ToListAsync();
var result = new PageOutput <UserListOutput>()
{
List = data,
Total = count
};
return(ResponseOutput.Ok(result));
}
public async Task <IResultModel> PageAsync(PermissionPageInput input)
{
StringBuilder sb = new StringBuilder();
sb.Append("where IsDeleted=0 ");
if (input.Label.NotNull())
{
sb.Append(" and Label like @Label ");
}
input.Page = 1;
input.Limit = 999999;
input.Field = "sort";
input.Order = "asc";
var list = await _permissionRepository.GetListPagedAsync(input.Page, input.Limit, sb.ToString(), $"{input.Field} {input.Order}", new { input.Label });
var total = await _permissionRepository.RecordCountAsync(sb.ToString(), new { input.Label });
var data = new PageOutput <PermissionPageOutput>()
{
Data = _mapper.Map <List <PermissionPageOutput> >(list),
Count = total
};
return(ResultModel.Success(data));
}
public PageOutput <Average3D> GetPage(int pageSize, int pageIndex, out int total)
{
var result = new PageOutput <Average3D>();
var list = _service.GetPage(pageSize, pageIndex, out total);
result.PageList = list;
result.Total = total;
return(result);
}
/// <summary>
/// 条件查询
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <PageOutput <TView> > QueryAsync(ObjFilterInput input)
{
var query = _repository.Select <TView>().QueryByGroupInput(input.Condition);
var total = await query.CountAsync();
var page = PageInput.Convert(total, input.Page, _orderMap);
var data = await query.QueryByPageInput(page).ToArrayAsync();
return(PageOutput.Convert(total, page, data));
}
public async Task <IActionResult> GetPage(PermissionPageInput input)
{
PageOutput <PermissionPageOutput> output = new PageOutput <PermissionPageOutput>();
var result = await _permissionService.PageAsync(input) as ResultModel <PageOutput <PermissionPageOutput> >;
if (result.Success)
{
output = result.Data;
}
return(Json(output));
}
public async Task <IResultModel> PageAsync(PageInput <LoginLogEntity> input)
{
var userName = input.Filter?.CreatedUserName;
var list = await _loginLogRepository.GetListPagedAsync(input.Page, input.Limit, "", input.OrderBy);
var total = await _loginLogRepository.RecordCountAsync("", input.Filter);
var data = new PageOutput <LoginLogListOutput>()
{
Data = _mapper.Map <List <LoginLogListOutput> >(list),
Count = total
};
return(ResultModel.Success());
}
public async Task<IResponseOutput> PageAsync(PageInput<UserEntity> input)
{
var list = await _userRepository.Select
.WhereDynamicFilter(input.DynamicFilter)
.Count(out var total)
.OrderByDescending(true, a => a.Id)
.IncludeMany(a => a.Roles.Select(b => new RoleEntity{ Name = b.Name }))
.Page(input.CurrentPage, input.PageSize)
.ToListAsync();
var data = new PageOutput<UserListOutput>()
{
List = _mapper.Map<List<UserListOutput>>(list),
Total = total
};
return ResponseOutput.Ok(data);
}
public async Task <IResponseOutput> PageAsync(PageInput <RoleEntity> input)
{
var key = input.Filter?.Name;
var list = await _roleRepository.Select
.WhereIf(key.NotNull(), a => a.Name.Contains(key))
.Count(out var total)
.OrderByDescending(true, c => c.Id)
.Page(input.CurrentPage, input.PageSize)
.ToListAsync <RoleListOutput>();
var data = new PageOutput <RoleListOutput>()
{
List = list,
Total = total
};
return(ResponseOutput.Ok(data));
}
public async Task <IResponseOutput> PageAsync(PageInput <OprationLogEntity> input)
{
var userName = input.Filter?.CreatedUserName;
var list = await _oprationLogRepository.Select
.WhereIf(userName.NotNull(), a => a.CreatedUserName.Contains(userName))
.Count(out var total)
.OrderByDescending(true, c => c.Id)
.Page(input.CurrentPage, input.PageSize)
.ToListAsync <OprationLogListOutput>();
var data = new PageOutput <OprationLogListOutput>()
{
List = list,
Total = total
};
return(ResponseOutput.Ok(data));
}
public async Task <IResponseOutput> PageAsync(PageInput <LoginLogEntity> input)
{
var userName = input.Filter?.CreatedUserName;
var list = _loginLogRepository.Query
.Where(a => a.CreatedUserName.Contains(userName))
.OrderByDescending(c => c.Id)
.Skip((input.CurrentPage.GetValueOrDefault() - 1) * input.PageSize.GetValueOrDefault()).Take(input.PageSize.GetValueOrDefault());
var data = new PageOutput <LoginLogListOutput>()
{
List = ObjectMapper.MapList <LoginLogEntity, LoginLogListOutput>(list.ToList()), //list.ToList().MapTo<List<LoginLogEntity>, List<LoginLogListOutput>>(),
Total = list.Count()
};
return(ResponseOutput.Ok(data));
}
public async Task <IResponseOutput> PageAsync(PageInput <ViewEntity> input)
{
var key = input.Filter?.Label;
long total;
var list = await _viewRepository.Select
.WhereIf(key.NotNull(), a => a.Path.Contains(key) || a.Label.Contains(key))
.Count(out total)
.OrderByDescending(true, c => c.Id)
.Page(input.CurrentPage, input.PageSize)
.ToListAsync();
var data = new PageOutput <ViewEntity>()
{
List = list,
Total = total
};
return(ResponseOutput.Ok(data));
}
public async Task <IResultModel> PageAsync(PageInput <UserListInput> input)
{
var _conditions = "";
if (input.Filter != null)
{
_conditions = input.Filter.ModelToWhere();
}
var list = await _userRepository.GetListPagedAsync(input.Page, input.Limit, _conditions, input.OrderBy, input.Filter);
var total = await _userRepository.RecordCountAsync(_conditions, input.Filter);
var data = new PageOutput <UserListOutput>()
{
Data = _mapper.Map <List <UserListOutput> >(list),
Count = total
};
return(ResultModel.Success(data));
}
public async Task <IResponseOutput> PageAsync(PageInput <UserEntity> input)
{
var key = input.Filter?.Name;
var list = await _userRepository.Select
.WhereIf(key.NotNull(), a => a.Status >= 0 && (a.UserName.Contains(key) || a.NickName.Contains(key) || a.Name.Contains(key)))
.Count(out var total)
.OrderByDescending(true, a => a.Id)
.IncludeMany(a => a.Roles.Select(b => new RoleEntity {
Name = b.Name
}))
.Page(input.CurrentPage, input.PageSize)
.ToListAsync();
var data = new PageOutput <UserListOutput>()
{
List = _mapper.Map <List <UserListOutput> >(list),
Total = total
};
return(ResponseOutput.Ok(data));
}
public async Task <PageOutput <object> > SQLQueryAsync([FromBody] SQLFilterInput input)
{
var page = await _userinfoService.SQLQueryAsync(input);
return(PageOutput.Convert(page, _filterProvider.FilterRange(page.DataList)));
}
