public async Task <ActionResult> Get([FromQuery] RoleQueryModel query,
[FromServices] IGetRolesQuery getRolesQuery)
{
try
{
if (query == null)
{
return(BadRequest());
}
IPage <RoleCreateModel> roles = await getRolesQuery.Execute(query);
return(Ok(roles));
}
catch (Exception ex)
{
//Log error
_logger.LogError("RoleController.Get", "Exception was thrown.", new
{
RoleQuery = query,
Exception = ex
});
return(BadRequest(new Message("Something bad happened. Try again.")));
}
}
public IPagedList <Role> FindBy(RoleQueryModel query)
{
IQueryable <Role> entities = Table;
if (query.Name.NotNullOrBlank())
{
entities =
entities.Where(x => x.Name.Contains(query.Name));
}
var totalCountQuery = entities.FutureCount();
var resultQuery = entities
.OrderBy(x => x.SortOrder)
.Skip((query.page.Value - 1) * query.rows.Value)
.Take(query.rows.Value)
.Future();
var totalCount = totalCountQuery.Value;
var result = resultQuery.ToList();
return(new StaticPagedList <Role>(
result,
query.page.Value,
query.rows.Value,
totalCount));
}
/// <summary>
///
/// </summary>
/// <param name="qModel"></param>
/// <returns></returns>
public async Task <ResultDto <RoleDto> > GetPageDataAsync(RoleQueryModel qModel)
{
var result = new ResultDto <RoleDto>();
try
{
var query = _liveShowDB.Role.AsNoTracking().Where(x => !x.IsDeleted);
var queryData = query.Select(s => new RoleDto()
{
Id = s.Id,
Name = s.Name,
Status = s.Status,
CreateTime = s.CreateTime
});
queryData = queryData.OrderBy(o => o.Id);
queryData = queryData.Skip((qModel.Page - 1) * qModel.PageSize).Take(qModel.PageSize);
result.ActionResult = true;
result.Message = "Success";
result.List = await queryData.ToListAsync();
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return(result);
}
public async Task<IResultModel> Query(RoleQueryModel model)
{
var result = new QueryResultModel<RoleEntity>
{
Rows = await _repository.Query(model),
Total = model.TotalCount
};
return ResultModel.Success(result);
}
public async Task <IResultModel> Query(RoleQueryModel model)
{
var result = new QueryResultModel <Role>();
var paging = model.Paging();
result.Rows = await _repository.Query(paging, model.Name);
result.Total = paging.TotalCount;
return(ResultModel.Success(result));
}
public async Task <IList <RoleEntity> > Query(RoleQueryModel model)
{
var paging = model.Paging();
var query = Db.Find(m => m.Deleted == false);
var list = await query.PaginationAsync(paging);
model.TotalCount = paging.TotalCount;
return(list);
}
public IPagedList <RoleDTO> FindBy(RoleQueryModel query)
{
var list = _Repository.FindBy(query);
return(new StaticPagedList <RoleDTO>(
list.ToList().Select(x => x.ToDto()),
query.page.Value,
query.rows.Value,
list.TotalItemCount));
}
public JsonResult InitGrid(RoleQueryModel query)
{
var grid = _roleServiceApp.FindBy(query);
return(Json(new
{
rows = grid,
total = grid.GetMetaData().PageCount,
page = query.page,
records = grid.GetMetaData().TotalItemCount
}, JsonRequestBehavior.AllowGet));
}
public async Task <IList <RoleEntity> > Query(RoleQueryModel model)
{
var paging = model.Paging();
var query = Db.Find().LeftJoin <AccountEntity>((x, y) => x.CreatedBy == y.Id);
query.WhereIf(model.Name.NotNull(), (x, y) => x.Name.Contains(model.Name));
query.Select((x, y) => new { x, Creator = y.Name });
var list = await query.PaginationAsync(paging);
model.TotalCount = paging.TotalCount;
return(list);
}
public async Task <IList <RoleEntity> > Query(RoleQueryModel model)
{
var conditions = await _filter.GetConditions <RoleEntity, RoleQueryModel>(model);
var query = _dbContext.Db.Queryable <RoleEntity>()
.Where(conditions)
.OrderBy(model.OrderFileds);
RefAsync <int> totalCount = 0;
var data = await query.ToPageListAsync(model.PageIndex, model.PageSize, totalCount);
model.TotalCount = totalCount;
return(data);
}
public async Task <Pagination <Role> > GetFilterAsync(RoleQueryModel queryModel)
{
queryModel.PageSize = queryModel.PageSize.HasValue ? queryModel.PageSize.Value : 20;
queryModel.CurrentPage = queryModel.CurrentPage.HasValue ? queryModel.CurrentPage.Value : 1;
var query = _dataContext.AppRoles.AsNoTracking();
if (queryModel.ListTextSearch != null && queryModel.ListTextSearch.Count > 0)
{
foreach (var ts in queryModel.ListTextSearch)
{
query = query.Where(q =>
q.Name.Contains(ts) ||
q.Code.Contains(ts)
);
}
}
return(await query.GetPagedAsync(queryModel.CurrentPage.Value, queryModel.PageSize.Value, queryModel.Sort));
}
public async Task <IResultModel> Query([FromQuery] RoleQueryModel model)
{
return(await _service.Query(model));
}
public async Task <JsonResult> GetPageAsync(RoleQueryModel qModel)
{
var resultTask = _roleSvc.GetPageDataAsync(qModel);
return(Json(await resultTask));
}
public async Task <IPage <RoleCreateModel> > Execute(RoleQueryModel queryModel)
{
try
{
if (queryModel == null)
{
throw new ArgumentNullException("queryModel");
}
ValidateAndCorrectListQueryModel(queryModel);
//Create filters list
List <FilterDefinition <Role> > filterDefList = new List <FilterDefinition <Role> >();
filterDefList.Add(Builders <Role> .Filter.Empty);
if (queryModel.Name != null)
{
filterDefList.Add(Builders <Role> .Filter.Eq(r => r.Name, queryModel.Name));
}
if (queryModel.Consumer != null)
{
filterDefList.Add(Builders <Role> .Filter.Eq(r => r.Consumer, queryModel.Consumer));
}
if (queryModel.Status != RoleStatus.NotSet)
{
filterDefList.Add(Builders <Role> .Filter.Eq(r => r.Status, queryModel.Status));
}
var filterDef = Builders <Role> .Filter.And(filterDefList);
// Create query using the filters.
IFindFluent <Role, Role> query = _roleRepo.Find(filterDef);
// Add sorting.
AddSortingToQuery(query, _sortDictionary, queryModel.Order, queryModel.IsDesc);
// Add paging.
AddPagingToQuery(query, queryModel.Page, queryModel.PageSize);
var list = await query.ToListAsync();
var roles = from r in list
select new RoleCreateModel()
{
Id = r.Id,
Name = r.Name,
Consumer = r.Consumer,
Description = r.Description,
Status = r.Status
};
long totalItems = await _roleRepo.CountDocumentsAsync(filterDef);
return(new Page <RoleCreateModel>(roles, totalItems));
}
catch (Exception ex)
{
//Log error
_logger.LogError("GetRolesQuery.Execute", "Exception was thrown", new
{
RoleQueryModel = queryModel,
Exception = ex
});
throw;
}
}
public IEnumerable <RoleTableModel> SearchRole(RoleQueryModel query)
{
return(Context.Connection.Query <RoleTableModel>("admdata.search_role", query));
}
public IEnumerable <RoleTableModel> SearchRole(RoleQueryModel model)
{
return(roleRepository.SearchRole(model));
}
