public async Task <IList <MenuEntity> > Query(MenuQueryModel model)
{
var paging = model.Paging();
var query = Db.Find();
query.WhereNotNull(model.Name, m => m.Name.Contains(model.Name));
query.WhereNotNull(model.RouteName, m => m.RouteName.Contains(model.RouteName));
if (model.ParentId == null)
{
model.ParentId = Guid.Empty;
}
query.Where(m => m.ParentId == model.ParentId);
var joinQuery = query.LeftJoin <AccountEntity>((x, y) => x.CreatedBy == y.Id);
if (!paging.OrderBy.Any())
{
joinQuery.OrderBy((x, y) => x.Sort);
}
joinQuery.Select((x, y) => new { x, CreatorName = y.Name });
var list = await joinQuery.PaginationAsync(paging);
model.TotalCount = paging.TotalCount;
return(list);
}
public async Task <IResultModel <QueryResultModel <MenuEntity> > > Query(MenuQueryModel model)
{
var result = new ResultModel <QueryResultModel <MenuEntity> >();
var data = await _repository.Query(model);
return(result.Success(data));
}
public async Task <IResultModel> Query(MenuQueryModel model)
{
var queryResult = new QueryResultModel <MenuEntity>
{
Rows = await _menuRepository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(queryResult));
}
public async Task <IResultModel> Query(MenuQueryModel model)
{
var queryResult = new QueryResultModel <Menu>();
var paging = model.Paging();
queryResult.Rows = await _menuRepository.Query(paging, model.Name, model.RouteName, model.ParentId);
queryResult.Total = paging.TotalCount;
return(ResultModel.Success(queryResult));
}
public IPagedList <MenuDTO> FindBy(MenuQueryModel query)
{
var list = _Repository.FindBy(query);
var result = list.OrderBy(x => x.SortOrder).ToList();
return(new StaticPagedList <MenuDTO>(
result.Select(x => x.ToDto()),
query.page.Value,
query.rows.Value,
list.TotalItemCount));
}
private async Task GetMenus(SqlConnection connection1, SearchQueryModel model, List <MenuQueryModel> lst)
{
SqlCommand cmd = new SqlCommand();
string cmdString = "SELECT top " + rowsQuery.ToString() + " id, menu, status FROM menu ";
SqlParameter parameter = null;
if (model.status != 2)
{
cmdString += "where status = @status ";
parameter = new SqlParameter("@status", SqlDbType.Int);
parameter.Value = model.status;
cmd.Parameters.Add(parameter);
}
if (model.filter != "")
{
if (model.status == 2)
{
cmdString += "where menu like @search ";
}
else
{
cmdString += "and menu like @search ";
}
parameter = new SqlParameter("@search", SqlDbType.VarChar);
parameter.Value = "%" + model.filter + "%";
cmd.Parameters.Add(parameter);
}
cmdString += "order by menu";
cmd.CommandText = cmdString;
cmd.Connection = connection1;
SqlDataReader reader = await cmd.ExecuteReaderAsync();
while (await reader.ReadAsync())
{
MenuQueryModel menuModel = new MenuQueryModel();
menuModel.id = reader.GetString(0);
menuModel.menu = reader.GetString(1);
menuModel.status = reader.GetInt32(2);
lst.Add(menuModel);
}
reader.Close();
}
public async Task <IList <MenuEntity> > Query(MenuQueryModel model)
{
var conditions = await _filter.GetConditions <MenuEntity, MenuQueryModel>(model);
var query = _dbContext.Db.Queryable <MenuEntity>()
.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 ActionResult GetMenu(MenuQueryModel menu)
{
var result = _unitOfWork.GetRepository <Menu>().GetEntities();
if (!string.IsNullOrEmpty(menu.MenuName))
{
result = result.Where(i => i.MenuName.Contains(menu.MenuName));
}
var w1 = result.OrderByDescending(x => x.Id).Skip((menu.page - 1) * menu.limit).Take(menu.limit);
return(Json(new
{
code = 0,
msg = "ok",
count = result.Count(),
data = w1.ToList()
}));
}
public IPagedList <Menu> FindBy(MenuQueryModel query)
{
IQueryable <Menu> 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 <Menu>(
result,
query.page.Value,
query.rows.Value,
totalCount));
}
public Task <IResultModel> Query([FromQuery] MenuQueryModel model)
{
return(_service.Query(model));
}
public async Task <IResultModel <QueryResultModel <MenuEntity> > > Query(MenuQueryModel model)
{
return(await _service.Query(model));
}
public static MenuJsonModel ToJsonModel(this MenuQueryModel entity)
{
return(entity.MapTo <MenuQueryModel, MenuJsonModel>());
}
