/// <summary>
/// 查找分页列表
/// </summary>
/// <param name="pageSize">每页记录数。</param>
/// <param name="pageIndex">页码。首页从1开始</param>
/// <param name="totalNumber">总记录数</param>
/// <param name="where">查询表达式</param>
/// <param name="orderParam">排序【null-不设置】</param>
/// <returns></returns>
public IQueryable <T> FindPageList(int pageSize, int pageIndex, out int totalNumber, Expression <Func <T, bool> > where, OrderParam orderParam)
{
OrderParam[] _orderParams = null;
if (orderParam != null)
{
_orderParams = new OrderParam[] { orderParam }
}
;
return(FindPageList(pageSize, pageIndex, out totalNumber, where, _orderParams));
}
/// <summary>
/// 查找实体列表
/// </summary>
/// <param name="where">查询Lambda表达式</param>
/// <param name="orderParam">排序参数</param>
/// <param name="number">获取的记录数量【0-不启用】</param>
public IQueryable <T> FindList(Expression <Func <T, bool> > where, OrderParam orderParam, int number)
{
OrderParam[] _orderParams = null;
if (orderParam != null)
{
_orderParams = new OrderParam[] { orderParam }
}
;
return(FindList(where, _orderParams, number));
}
public async Task <IActionResult> GetUserLatestOrder(OrderParam orderParam)
{
try
{
return(new JsonResult(await _orderApi.GetLatestOrderAsync(orderParam)));
}
catch
{
return(new BadRequestResult());
}
}
public async Task Test_Build_Order()
{
//arrange
var provider = new TestClientProvider();
var client = provider.Client;
var price = 100000;
var use = "gaming";
var importance = "price";
var email = "juan@gmail";
var response = await provider.Client.GetAsync($"api/computer?price={price}&use={use}&importance={importance}");
var result = await response.Content.ReadAsStringAsync();
var computers = JsonConvert.DeserializeObject <ComputerMockResult>(result);
var computer = computers.Computers[0];
var order = new Order()
{
Client = new Client()
{
Email = email
},
Commentary = "maincra"
};
var json = JsonConvert.SerializeObject(new AddOrderParam()
{
Order = order,
Computer = computer,
Quantity = 2
});
var responseAdd = await client.PutAsync("api/order/submit/add", new StringContent(json, Encoding.UTF8, "application/json"));
var resultAdd = await responseAdd.Content.ReadAsStringAsync();
var orderAdded = JsonConvert.DeserializeObject <OrderMockResult>(resultAdd);
var param = new OrderParam()
{
Order = orderAdded.Order, Email = email
};
var paramJson = JsonConvert.SerializeObject(param);
await client.PostAsync("api/order/submit", new StringContent(paramJson, Encoding.UTF8, "application/json"));
//act
var id = provider.GetLastId("Order");
var responseSubmit = await client.PostAsync("api/order/build", new StringContent(id.ToString(), Encoding.UTF8, "application/json"));
responseSubmit.EnsureSuccessStatusCode();
//assert
responseSubmit.StatusCode.Should().Be(HttpStatusCode.OK);
id = provider.GetLastId("Order");
await provider.Client.DeleteAsync($"api/order/delete/{id}");
}
public ActionResult FindDeviceList(int?pageSize, int?pageIndex,
string sortOrder, string sortName,
string warehouse, string code)
{
CWDevice cwdevice = new CWDevice();
Page <Device> page = new Page <Device>();
if (pageSize != null)
{
page.PageSize = (int)pageSize;
}
if (pageIndex != null)
{
page.PageIndex = (int)pageIndex;
}
OrderParam orderParam = null;
if (!string.IsNullOrEmpty(sortName))
{
orderParam = new OrderParam();
orderParam.PropertyName = sortName;
if (!string.IsNullOrEmpty(sortOrder))
{
orderParam.Method = sortOrder.ToLower() == "asc" ? OrderMethod.Asc : OrderMethod.Desc;
}
else
{
orderParam.Method = OrderMethod.Asc;
}
}
if (warehouse != "0" && code != "0")
{
int wh = Convert.ToInt32(warehouse);
int smg = Convert.ToInt32(code);
page = cwdevice.FindPageList(page, (dev => dev.Warehouse == wh && dev.DeviceCode == smg), orderParam);
var data = new
{
total = page.TotalNumber,
rows = page.ItemLists
};
return(Json(data));
}
page = cwdevice.FindPageList(page, (dev => true), orderParam);
var value = new
{
total = page.TotalNumber,
rows = page.ItemLists
};
return(Json(value));
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
OrderParam op = obj as OrderParam;
if (op == null)
{
return(false);
}
return(string.Equals(this.Name, op.Name));
}
/// <summary>
/// 查询，分页显示
/// </summary>
/// <param name="pageWork"></param>
/// <param name="where"></param>
/// <param name="param"></param>
/// <returns></returns>
public Page <Device> FindPageList(Page <Device> pageWork, Expression <Func <Device, bool> > where, OrderParam param)
{
if (param == null)
{
param = new OrderParam()
{
PropertyName = "ID",
Method = OrderMethod.Asc
};
}
Page <Device> page = manager.FindPageList(pageWork, where, param);
return(page);
}
/// <summary>
/// 分页数据
/// </summary>
/// <param name="paging"></param>
/// <returns></returns>
public Page <TEntity> FindPageList(Page <TEntity> paging, OrderParam param)
{
int Num = 0;
IQueryable <TEntity> iqueryLst = _repository.FindPageList(paging.PageSize, paging.PageIndex, out Num, param);
List <TEntity> checkLst = new List <TEntity>();
foreach (TEntity en in iqueryLst)
{
checkLst.Add(en);
}
paging.ItemLists = checkLst;
paging.TotalNumber = Num;
return(paging);
}
/// <summary>
/// 分页查询
/// </summary>
public Page <FixChargingRule> FindPageFixRuleLst(int pageSize, int pageNumber)
{
Page <FixChargingRule> page = new Page <FixChargingRule>();
page.PageIndex = pageNumber;
page.PageSize = pageSize;
OrderParam orderParam = new OrderParam();
orderParam.PropertyName = "ID";
orderParam.Method = OrderMethod.Asc;
page = fixManager.FindPageList(page, orderParam);
return(page);
}
/// <summary>
/// 分页查询时间段
/// </summary>
public Page <HourSectionInfo> FindPageHourRuleList(int pageSize, int pageNumber)
{
Page <HourSectionInfo> page = new Page <HourSectionInfo>();
page.PageIndex = pageNumber;
page.PageSize = pageSize;
OrderParam orderParam = new OrderParam();
orderParam.PropertyName = "ID";
orderParam.Method = OrderMethod.Asc;
page = hourSectionManager.FindPageList(page, orderParam);
return(page);
}
public IActionResult Submit(OrderParam order)
{
if (!order.Order.Computers.Any())
{
return(BadRequest());
}
try
{
var result = submit.Submit(order.Order, order.Email);
return(Ok(new ApiResponse <SubmitResult>(result)));
}
catch (AddStockException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <string> QueryPagedAsync([FromQuery] OrderParam param)
{
var filter = param.SearchLambda <Orders, OrderParam>();
var result = await _ordersRepository.QueryPagedAsync(param.PageNum, param.PageSize, null, filter);
var pageData = new PagedDto <Orders>
{
Code = 200,
Msg = "获取数据成功",
Total = result.TotalResults,
PageSize = param.PageSize,
Data = result.Items.ToList()
};
var json = pageData.ToString();
return(json);
}
public JsonResult GetTaskList(int?pageSize, int?pageIndex, string sortOrder, string sortName)
{
Page <ImplementTask> page = new Page <ImplementTask>();
if (pageSize != null)
{
page.PageSize = (int)pageSize;
}
if (pageIndex != null)
{
page.PageIndex = (int)pageIndex;
}
OrderParam orderParam = null;
if (!string.IsNullOrEmpty(sortName))
{
orderParam = new OrderParam();
orderParam.PropertyName = sortName;
if (!string.IsNullOrEmpty(sortOrder))
{
orderParam.Method = sortOrder.ToLower() == "asc" ? OrderMethod.Asc : OrderMethod.Desc;
}
else
{
orderParam.Method = OrderMethod.Asc;
}
}
Page <ImplementTask> pageTask = new CWTask().FindPageList(page, orderParam);
List <DisplayITask> dispTaskLst = new List <DisplayITask>();
foreach (ImplementTask itask in pageTask.ItemLists)
{
DisplayITask dtask = new DisplayITask
{
ID = itask.ID,
Warehouse = itask.Warehouse,
DeviceCode = itask.DeviceCode,
Type = PlusCvt.ConvertTaskType(itask.Type),
Status = PlusCvt.ConvertTaskStatus(itask.Status, itask.SendStatusDetail),
SendStatusDetail = PlusCvt.ConvertSendStateDetail(itask.SendStatusDetail),
CreateDate = itask.CreateDate.ToString(),
SendDtime = itask.SendDtime.ToString(),
HallCode = itask.HallCode,
FromLctAddress = itask.FromLctAddress,
ToLctAddress = itask.ToLctAddress,
ICCardCode = itask.ICCardCode,
Distance = itask.Distance,
CarSize = itask.CarSize,
CarWeight = itask.CarWeight
};
dispTaskLst.Add(dtask);
}
int rcdNum = pageTask.TotalNumber;
var data = new
{
total = pageTask.TotalNumber,
rows = dispTaskLst
};
return(Json(data));
}
public IQueryable <TEntity> FindPageList(int pageSize, int pageIndex, out int totalNumber, OrderParam param)
{
return(FindPageList(pageSize, pageIndex, out totalNumber, (TEntity) => true, new OrderParam[] { param }));
}
public IQueryable <TEntity> FindList(Expression <Func <TEntity, bool> > where, OrderParam param)
{
return(FindList(where, param, 0));
}
public Page <Device> FindPageList(Page <Device> workPage, Expression <Func <Device, bool> > where, OrderParam oparam)
{
int totalNum = 0;
List <Device> allLst = _repository.FindPageList(workPage.PageSize, workPage.PageIndex, out totalNum, where, new OrderParam[] { oparam }).ToList <Device>();
workPage.ItemLists = allLst;
workPage.TotalNumber = totalNum;
return(workPage);
}
/// <summary>
/// 分页列表
/// </summary>
/// <param name="pagingUser">分页数据</param>
/// <param name="roleID">角色ID</param>
/// <param name="username">用户名</param>
/// <param name="name">名称</param>
/// <param name="sex">性别</param>
/// <param name="email">Email</param>
/// <param name="order">排序【null（默认）-ID降序，0-ID升序，1-ID降序，2-注册时间降序，3-注册时间升序，4-最后登录时间升序，5-最后登录时间降序】</param>
/// <returns></returns>
public Paging <User> FindPageList(Paging <User> pagingUser, int?roleID, string username, string name, int?sex, string email, int?order)
{
//查询表达式
#pragma warning disable CS0618 // 类型或成员已过时
var _where = PredicateBuilder.True <User>();
#pragma warning restore CS0618 // 类型或成员已过时
if (roleID != null && roleID > 0)
{
_where = _where.And(u => u.RoleID == roleID);
}
if (!string.IsNullOrEmpty(username))
{
_where = _where.And(u => u.Username.Contains(username));
}
if (!string.IsNullOrEmpty(name))
{
_where = _where.And(u => u.Name.Contains(name));
}
if (sex != null && sex >= 0 && sex <= 2)
{
_where = _where.And(u => u.Sex == sex);
}
if (!string.IsNullOrEmpty(email))
{
_where = _where.And(u => u.Email.Contains(email));
}
//排序
OrderParam _orderParam;
switch (order)
{
case 0: //ID升序
_orderParam = new OrderParam()
{
PropertyName = "UserID", Method = OrderMethod.ASC
};
break;
case 1: //ID降序
_orderParam = new OrderParam()
{
PropertyName = "UserID", Method = OrderMethod.DESC
};
break;
case 2: //注册时间降序
_orderParam = new OrderParam()
{
PropertyName = "RegTime", Method = OrderMethod.ASC
};
break;
case 3: //注册时间升序
_orderParam = new OrderParam()
{
PropertyName = "RegTime", Method = OrderMethod.DESC
};
break;
case 4: //最后登录时间升序
_orderParam = new OrderParam()
{
PropertyName = "LastLoginTime", Method = OrderMethod.ASC
};
break;
case 5: //最后登录时间降序
_orderParam = new OrderParam()
{
PropertyName = "LastLoginTime", Method = OrderMethod.DESC
};
break;
default: //ID降序
_orderParam = new OrderParam()
{
PropertyName = "UserID", Method = OrderMethod.DESC
};
break;
}
pagingUser.Items = Repository.FindPageList(pagingUser.PageSize, pagingUser.PageIndex, out pagingUser.TotalNumber, _where.Expand(), _orderParam).ToList();
return(pagingUser);
}
/// <summary>
/// 查找分页列表
/// </summary>
/// <param name="pageSize">每页记录数。必须大于1</param>
/// <param name="pageIndex">页码。首页从1开始，页码必须大于1</param>
/// <param name="totalNumber">总记录数</param>
/// <param name="where">查询表达式</param>
public IQueryable <T> FindPageList(int pageSize, int pageIndex, out int totalNumber, Expression <Func <T, bool> > where)
{
OrderParam _param = null;
return(FindPageList(pageSize, pageIndex, out totalNumber, where, _param));
}
//查找实体分页列表
#region FindPageList
/// <summary>
/// 查找分页列表
/// </summary>
/// <param name="pageSize">每页记录数。必须大于1</param>
/// <param name="pageIndex">页码。首页从1开始，页码必须大于1</param>
/// <param name="totalNumber">总记录数</param>
/// <returns></returns>
public IQueryable <T> FindPageList(int pageSize, int pageIndex, out int totalNumber)
{
OrderParam _orderParam = null;
return(FindPageList(pageSize, pageIndex, out totalNumber, _orderParam));
}
public Paging <T> FindPageList(Paging <T> paging, Expression <Func <T, bool> > where, OrderParam order)
{
paging.Items = Repository.FindPageList(paging.PageSize, paging.PageIndex, out paging.TotalNumber, where, order).ToList();
return(paging);
}
public List <Device> FindList(Expression <Func <Device, bool> > where, OrderParam param)
{
return(manager.FindList(where, param));
}
/// <summary>
/// Insert or Update the sals order
/// </summary>
/// <param name="orderInfo"></param>
/// /// <param name="products"></param>
/// <returns></returns>
public async Task <int> InsertSalesOrderByOrderIdAsync(OrderParam orderInfo, List <ProductParam> products)
{
string orderId = orderInfo.title;
var oldOrder = await context.Pomst.Where(p => p.PonbPo == orderId).FirstOrDefaultAsync();
try
{
if (oldOrder != null)
{
oldOrder.DatePo = orderInfo.date.Value.Date;
oldOrder.TnamPo = orderInfo.receiver;
oldOrder.TcpyPo = context.Loctb.Where(p => p.LocnLtb == orderInfo.deptId).Select(p => p.DescLtb).FirstOrDefault();
oldOrder.TfaxPo = orderInfo.faxReceiver;
oldOrder.TtelPo = orderInfo.telReceiver;
oldOrder.FnamPo = orderInfo.sender;
oldOrder.FtelPo = orderInfo.telSender;
oldOrder.FfaxPo = orderInfo.faxSender;
oldOrder.Rmk1Po = orderInfo.descript;
oldOrder.RvmkPo = orderInfo.remarkfeedback;
oldOrder.CstmPo = orderInfo.deptId;
oldOrder.CreaPo = orderInfo.userId;
oldOrder.FqryjPo = orderInfo.messageForAuditor;
oldOrder.StatPo = orderInfo.statusCode.ToString();
oldOrder.TypePo = orderInfo.type;
oldOrder.CachetPo = orderInfo.seal; //todo
oldOrder.CtovPo = orderInfo.copyAfterCheck;
oldOrder.MrmkPo = orderInfo.remarkCorrige;
oldOrder.RvmkPo = orderInfo.remarkfeedback;
oldOrder.LdatPo = DateTime.Now;
oldOrder.FcpyPo = orderInfo.entrepriseName;
context.Pomst.Update(oldOrder);
var productOld = await context.Popart.Where(p => p.PonbPp == orderId).ToListAsync();
foreach (Popart p in productOld)
{
context.Popart.Remove(p);
}
}
else
{
var recordCreator = await context.PoCntIssue.Where(p => p.TypePci == "PO").FirstOrDefaultAsync();
// TODO
// orderId = recordCreator.PrfxPci + DateTime.Now.ToString("yyyy") + "-" + context.Popart.Count().ToString("0000");//recordCreator.MaxnPci++
recordCreator.YearPci = DateTime.Now.ToString("yyyy");
recordCreator.MaxnPci = recordCreator.MaxnPci + 1;
context.PoCntIssue.Update(recordCreator);
orderId = recordCreator.PrfxPci + recordCreator.YearPci + "-" + Convert.ToInt32(recordCreator.MaxnPci).ToString("0000");
Pomst newOrder = new Pomst
{
PonbPo = orderId,
DatePo = orderInfo.date.Value.Date,
LdatPo = DateTime.Now,
TnamPo = orderInfo.receiver,
TcpyPo = context.Loctb.Where(p => p.LocnLtb == orderInfo.deptId).Select(p => p.DescLtb).FirstOrDefault(),
TfaxPo = orderInfo.faxReceiver,
TtelPo = orderInfo.telReceiver,
FnamPo = orderInfo.sender,
FtelPo = orderInfo.telSender,
FfaxPo = orderInfo.faxSender,
Rmk1Po = orderInfo.descript,
RvmkPo = orderInfo.remarkfeedback,
CstmPo = orderInfo.deptId,
CreaPo = orderInfo.userId,
FqryjPo = orderInfo.messageForAuditor,
StatPo = orderInfo.statusCode.ToString(),
TypePo = orderInfo.type,
CtovPo = orderInfo.copyAfterCheck,
LedtPo = orderInfo.userId,
MrmkPo = orderInfo.remarkCorrige,
CachetPo = orderInfo.seal,// todo: change to the id
FcpyPo = orderInfo.entrepriseName,
SpyjPo = "",
FqrPo = "",
CwPo = "",
CwyjPo = "",
JlPo = "",
JlyjPo = "",
CrtdPo = DateTime.Now,
PlntPo = orderInfo.entrepriseType,
CmplPo = false
};
context.Pomst.Add(newOrder);
}
int index = 1;
foreach (var product in products)
{
Popart newCargo = new Popart // Take into the cargo repository
{
PonbPp = orderId,
OrdrPp = index.ToString("00"),
PartPp = product.idProduct,
DescPp = await context.Itemmst.Where(p => p.PartIt == product.idProduct).Select(p => p.DescIt).FirstOrDefaultAsync(),//Get from the table data
TqtyPp = product.numberProduct,
UnitPp = product.unitProduct,
PricPp = product.priceProduct,
SchdPp = product.datePayProduct,
SumPp = product.totalPrice,
RemkPp = product.descriptProduct,
Desc3Pp = product.nameOffical,
PtypPp = product.unitPriceType,
SpecPp = product.adresseProduct,
PlntPp = product.entrepriseType,
LdatPp = DateTime.Now,
LedtPp = orderInfo.userId,
EquivPp = product.equivalenceValue
};
index++;
context.Popart.Add(newCargo);
}
await context.SaveChangesAsync();
}
catch (Exception e)
{
return(1);
}
return(0);
/*productOld.DescPp = product.nameProduct;
* productOld.TqtyPp = product.numberProduct;
* productOld.UnitPp = product.unitProduct; 更新模板是使用
* productOld.PricPp = product.priceProduct;
* productOld.SchdPp = product.datePayProduct;*/
}
/// <summary>
/// 分页列表
/// </summary>
/// <param name="pagingUser">分页数据</param>
/// <param name="roleID">角色ID</param>
/// <param name="username">用户名</param>
/// <param name="name">名称</param>
/// <param name="sex">性别</param>
/// <param name="email">Email</param>
/// <param name="order">排序【null（默认）-ID降序，0-ID升序，1-ID降序，2-注册时间降序，3-注册时间升序，4-最后登录时间升序，5-最后登录时间降序】</param>
/// <returns></returns>
public Paging <User> FindPageList(Paging <User> pagingUser, int?roleID, string username, string name, int?sex, string email, int?order)
{
var _where = PredicateBuilder.True <User>();
if (roleID != null && roleID > 0)
{
_where = _where.And(u => u.RoleID == roleID);
}
if (!string.IsNullOrEmpty(username))
{
_where = _where.And(u => u.Username.Contains(username));
}
if (!string.IsNullOrEmpty(name))
{
_where = _where.And(u => u.Name == name);
}
if (sex != null && sex >= 0 && sex <= 2)
{
_where = _where.And(u => u.Sex == sex);
}
if (!string.IsNullOrEmpty(email))
{
_where = _where.And(u => u.Email.Contains(email));
}
OrderParam _orderParam;
switch (order)
{
case 0:
_orderParam = new OrderParam()
{
PropertyName = "UserID", Method = OrderMethod.ASC
};
break;
case 1:
_orderParam = new OrderParam()
{
PropertyName = "UserID", Method = OrderMethod.DESC
};
break;
case 2:
_orderParam = new OrderParam()
{
PropertyName = "RegTime", Method = OrderMethod.ASC
};
break;
case 3:
_orderParam = new OrderParam()
{
PropertyName = "RegTime", Method = OrderMethod.DESC
};
break;
case 4:
_orderParam = new OrderParam()
{
PropertyName = "LastLoginTime", Method = OrderMethod.ASC
};
break;
case 5:
_orderParam = new OrderParam()
{
PropertyName = "LastLoginTime", Method = OrderMethod.DESC
};
break;
default:
_orderParam = new OrderParam()
{
PropertyName = "UserID", Method = OrderMethod.DESC
};
break;
}
pagingUser.Items = Repository.FindPageList(pagingUser.PageSize, pagingUser.PageIndex, out pagingUser.TotalNumber, _where.Expand(), _orderParam).ToList();
return(pagingUser);
}
public async Task <PagedList <MenuOrder> > GetRoomOrders(OrderParam orderParam, int HotelID)
{
var orders = _context.MenuOrders.Where(h => h.HotelId == HotelID && h.IsDeleted == false)
.OrderBy(b => b.Id).AsQueryable();
if (!string.IsNullOrEmpty(orderParam.OrderNo))
{
orders = orders.Where(b => b.Id == int.Parse(orderParam.OrderNo));
}
else
{
if (!string.IsNullOrEmpty(orderParam.RoomNumber))
{
orders = orders.Where(b => b.RoomNumber == orderParam.RoomNumber);
}
if (!string.IsNullOrEmpty(orderParam.Fullname))
{
orders = orders.Where(b => b.GuestName.Contains(orderParam.Fullname));
}
if (!string.IsNullOrEmpty(orderParam.Email))
{
orders = orders.Where(b => b.Email.Contains(orderParam.Email));
}
if (!string.IsNullOrEmpty(orderParam.Phone))
{
orders = orders.Where(b => b.Phone.Contains(orderParam.Phone));
}
if (!string.IsNullOrEmpty(orderParam.OrderStatus))
{
if (orderParam.OrderStatus == "Pending,Processing")
{
orders = orders.Where(b => b.OrderStatus == "Pending" || b.OrderStatus == "Processing");
}
else
{
orders = orders.Where(b => b.OrderStatus == orderParam.OrderStatus);
}
}
if (!string.IsNullOrEmpty(orderParam.StartDate))
{
DateTime dt;
if (DateTime.TryParse(orderParam.StartDate, out dt))
{
orders = orders.Where(b => b.CreatedOn >= dt);
}
}
else
{
orders = orders.Where(b => b.CreatedOn >= DateTime.Now.AddDays(-180));
}
if (!string.IsNullOrEmpty(orderParam.EndDate))
{
DateTime dt;
if (DateTime.TryParse(orderParam.EndDate, out dt))
{
dt = dt.AddHours(23).AddMinutes(59).AddSeconds(59);
orders = orders.Where(b => b.CreatedOn.Date <= dt);
}
}
}
if (!string.IsNullOrEmpty(orderParam.OrderBy))
{
switch (orderParam.OrderBy)
{
case "Created":
orders = orders.OrderBy(b => b.CreatedOn);
break;
default:
orders = orders.OrderBy(b => (DateTime.Parse(b.OrderDate + " " + b.OrderTime)));
break;
}
}
return(await PagedList <MenuOrder> .CreateAsync(orders, orderParam.PageNumber, orderParam.PageSize));
}
/// <summary>
/// 查找分页列表
/// </summary>
/// <param name="pageSize">每页记录数。必须大于1</param>
/// <param name="pageIndex">页码。首页从1开始，页码必须大于1</param>
/// <param name="totalNumber">总记录数</param>
/// <param name="order">排序键</param>
/// <param name="asc">是否正序</param>
/// <returns></returns>
public IQueryable <T> FindPageList(int pageSize, int pageIndex, out int totalNumber, OrderParam orderParam)
{
return(FindPageList(pageSize, pageIndex, out totalNumber, (T) => true, orderParam));
}
public IQueryable <T> FindList(Expression <Func <T, bool> > where, OrderParam orderParam, int number)
{
return(Repository.FindList(where, orderParam, number));
}
/// <summary>
/// 查找实体列表
/// </summary>
/// <param name="where">查询Lambda表达式</param>
/// <param name="orderParam">排序参数</param>
/// <returns></returns>
public IQueryable <T> FindList(Expression <Func <T, bool> > where, OrderParam orderParam)
{
return(FindList(where, orderParam, 0));
}
/// <summary>
///
/// </summary>
/// <param name="where"></param>
/// <param name="param"></param>
/// <returns></returns>
public List <Device> FindList(Expression <Func <Device, bool> > where, OrderParam param)
{
List <Device> allLst = _repository.FindList(where, param).ToList <Device>();
return(allLst);
}
