wgh/coreshoppro
1
0
Fork 0
mirror of http://git.coreshop.cn/jianweie/coreshoppro.git synced 2025-12-06 22:33:26 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
5494608f7a2797384cfefea0b05d76470392ceaa
coreshoppro/CoreCms.Net.IServices/IBaseServices.cs
大灰灰 7b68f352d7 ### 0.6.0 专业版（大版本升级，破坏性升级，请酌情处理）： 
【新增】弃用现在sku前端，启用全新sku组件，更加灵活，体验更好。
【新增】新增通过商品序列获取sku全新列表功能。
【新增】仓储层底层增加二级缓存功能，后面将逐步完善底层缓存中心模块。
【新增】0元购，积分兑换模式下，也去计算用户是否科技升级。
【新增】数据及业务仓储增加二级缓存功能。curd可自主控制是否缓存和清除。
【新增】订单导出excel数据增加商品名称+货品sku组合展示的方式。
【新增】自定义交易组件增加【获取商家信息】【更新商家信息】两个接口处理。
【新增】增加公告列表及公告详情页面，首页组件公告点击跳转列表展示。
【新增】个人中心增加【公告中心】入口。
【新增】后台余额变动增加说明录入。

【调整】将前端能进行分包的文件夹都进行分包，减少主包占用，方便进行二开。
【调整】因ckeditor5存在图片不可设置宽度，上传不支持mp4，排版不畅等情况，降级使用ckeditor4版本。
【修复】修复0.5.5版本售后积分返还机制积分模式判断异常的问题。
【修复】修复使用积分全额抵扣，或其他优惠政策导致的0元购，未进行短信提醒及小票打印机未打印的问题。
【修复】修复更换ckeditor4编辑器后接龙添加编辑调用失败的问题。
【修复】修复积分全额抵扣，金额0元购的情况下，进行售后执行完毕，订单未完结的情况。
【优化】去除分销申请面板按钮无用并失效报错的customStyle属性。
【优化】优化部分方法中使用手写字符串的遗留问题，统一采用enum方式。
【优化】优化前端及接口部分命名错误的问题。错将skill误写成seckill。
【优化】去除uniapp端多个客服代码。
【优化】商品详情底部完善购物车数量显示的问题。
【优化】优化团购列表，拼团列表，秒杀页面页面样式布局差异问题。
【优化】调整支付结果界面样式效果，仿微信支付结果界面。更加清晰明朗。
【优化】优化售后提交页面json计算，开放当用户下单后但未发货情况下，可以申请直接售后的操作需求。
【优化】后台商家手机号码支持设置多个，使用小写逗号分隔，方便多个商家管理员接收下单提醒。
【优化】后台售后单审核，调整售后商品为必选项。
2022-09-14 00:53:04 +08:00

987 lines
46 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/***********************************************************************
* Project: CoreCms
* ProjectName: 核心内容管理系统
* Web: https://www.corecms.net
* Author: 大灰灰
* Email: jianweie@163.com
* CreateTime: 2021/1/31 21:45:10
* Description: 暂无
***********************************************************************/
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq.Expressions;
using System.Threading.Tasks;
using CoreCms.Net.Model.ViewModels.Basics;
using SqlSugar;
namespace CoreCms.Net.IServices
{
/// <summary>
/// 服务仓储通用接口类
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IBaseServices<T> where T : class
{
#region 查询数据
/// <summary>
/// 根据主值查询单条数据
/// </summary>
/// <param name="pkValue">主键值</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>泛型实体</returns>
T QueryById(object pkValue, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据主值查询单条数据
/// </summary>
/// <param name="objId"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<T> QueryByIdAsync(object objId, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据主值列表查询单条数据
/// </summary>
/// <param name="lstIds"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
List<T> QueryByIDs(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据主值列表查询单条数据
/// </summary>
/// <param name="lstIds"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<List<T>> QueryByIDsAsync(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据主值列表查询单条数据
/// </summary>
/// <param name="lstIds"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
List<T> QueryByIDs(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据主值列表查询单条数据
/// </summary>
/// <param name="lstIds"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<List<T>> QueryByIDsAsync(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 查询所有数据(无分页,请慎用)
/// </summary>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
List<T> Query(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 查询所有数据(无分页,请慎用)
/// </summary>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<List<T>> QueryAsync(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="strWhere">条件</param>
/// <param name="orderBy">排序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>泛型实体集合</returns>
List<T> QueryListByClause(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="strWhere">条件</param>
/// <param name="orderBy">排序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>泛型实体集合</returns>
Task<List<T>> QueryListByClauseAsync(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="orderBy">排序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>泛型实体集合</returns>
List<T> QueryListByClause(Expression<Func<T, bool>> predicate, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="orderBy">排序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>泛型实体集合</returns>
Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, string orderBy = "",
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="orderByPredicate">排序字段</param>
/// <param name="orderByType">排序顺序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>泛型实体集合</returns>
List<T> QueryListByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate,
OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="orderByPredicate">排序字段</param>
/// <param name="orderByType">排序顺序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>泛型实体集合</returns>
Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate,
Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询一定数量数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="take">获取数量</param>
/// <param name="orderByPredicate">排序字段</param>
/// <param name="orderByType">排序顺序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take,
Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询一定数量数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="take">获取数量</param>
/// <param name="orderByPredicate">排序字段</param>
/// <param name="orderByType">排序顺序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take,
Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询一定数量数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="take">获取数量</param>
/// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take, string strOrderByFields = "",
bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询一定数量数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="take">获取数量</param>
/// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take,
string strOrderByFields = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
T QueryByClause(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="orderByPredicate">排序字段</param>
/// <param name="orderByType">排序顺序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
T QueryByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate,
OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="orderByPredicate">排序字段</param>
/// <param name="orderByType">排序顺序</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate,
OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询数据（悲观锁等待模式）
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="orderByPredicate">排序字段</param>
/// <param name="orderByType">排序顺序</param>
/// <param name="blUseTranLock">是否使用TranLock</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<T> QueryByClauseWithTranLockAsync(Expression<Func<T, bool>> predicate,
Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseTranLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
#endregion
#region 新闻数据
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
int Insert(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<int> InsertAsync(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="insertColumns"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
int Insert(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false);
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="insertColumns"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<int> InsertAsync(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false);
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="insertColumns"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool InsertGuid(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false);
/// <summary>
/// 写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="insertColumns"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> InsertGuidAsync(T entity, Expression<Func<T, object>> insertColumns, bool isRemoveDataCache = false);
/// <summary>
/// 批量写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
int Insert(List<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 批量写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<int> InsertAsync(List<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 批量写入实体数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<int> InsertCommandAsync(List<T> entity, bool isRemoveDataCache = false);
#endregion
#region 更新数据
/// <summary>
/// 批量更新实体数据
/// </summary>
/// <param name="entity"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Update(List<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 批量更新实体数据
/// </summary>
/// <param name="entity"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> UpdateAsync(List<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 更新实体数据
/// </summary>
/// <param name="entity"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Update(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 更新实体数据
/// </summary>
/// <param name="entity"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> UpdateAsync(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 根据手写条件更新
/// </summary>
/// <param name="entity"></param>
/// <param name="strWhere"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Update(T entity, string strWhere, bool isRemoveDataCache = false);
/// <summary>
/// 根据手写条件更新
/// </summary>
/// <param name="entity"></param>
/// <param name="strWhere"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> UpdateAsync(T entity, string strWhere, bool isRemoveDataCache = false);
/// <summary>
/// 根据手写sql语句更新数据
/// </summary>
/// <param name="strSql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
bool Update(string strSql, SugarParameter[] parameters = null);
/// <summary>
/// 根据手写sql语句更新数据
/// </summary>
/// <param name="strSql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
Task<bool> UpdateAsync(string strSql, SugarParameter[] parameters = null);
/// <summary>
/// 更新某个字段
/// </summary>
/// <param name="columns">lambda表达式,如it => new Student() { Name = "a", CreateTime = DateTime.Now }</param>
/// <param name="where">lambda判断</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Update(Expression<Func<T, T>> columns, Expression<Func<T, bool>> where, bool isRemoveDataCache = false);
/// <summary>
/// 更新某个字段
/// </summary>
/// <param name="columns">lambda表达式,如it => new Student() { Name = "a", CreateTime = DateTime.Now }</param>
/// <param name="where">lambda判断</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> UpdateAsync(Expression<Func<T, T>> columns, Expression<Func<T, bool>> where, bool isRemoveDataCache = false);
/// <summary>
/// 根据条件更新
/// </summary>
/// <param name="entity"></param>
/// <param name="lstColumns"></param>
/// <param name="lstIgnoreColumns"></param>
/// <param name="strWhere"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> UpdateAsync(T entity, List<string> lstColumns, List<string> lstIgnoreColumns,
string strWhere = "", bool isRemoveDataCache = false);
/// <summary>
/// 根据条件更新
/// </summary>
/// <param name="entity"></param>
/// <param name="lstColumns"></param>
/// <param name="lstIgnoreColumns"></param>
/// <param name="strWhere"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Update(T entity, List<string> lstColumns, List<string> lstIgnoreColumns, string strWhere = "", bool isRemoveDataCache = false);
#endregion
#region 删除数据
/// <summary>
/// 删除数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Delete(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 删除数据
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteAsync(T entity, bool isRemoveDataCache = false);
/// <summary>
/// 删除数据
/// </summary>
/// <param name="entity">实体类集合</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Delete(IEnumerable<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 删除数据
/// </summary>
/// <param name="entity">实体类集合</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteAsync(IEnumerable<T> entity, bool isRemoveDataCache = false);
/// <summary>
/// 删除数据
/// </summary>
/// <param name="where">过滤条件</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool Delete(Expression<Func<T, bool>> where, bool isRemoveDataCache = false);
/// <summary>
/// 删除数据
/// </summary>
/// <param name="where">过滤条件</param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteAsync(Expression<Func<T, bool>> where, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID的数据
/// </summary>
/// <param name="id"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteById(object id, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID的数据
/// </summary>
/// <param name="id"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdAsync(object id, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(int[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(int[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(long[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(long[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(Guid[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(Guid[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(string[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(string[] ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(List<int> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(List<int> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(List<string> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(List<string> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(List<Guid> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(List<Guid> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
bool DeleteByIds(List<long> ids, bool isRemoveDataCache = false);
/// <summary>
/// 删除指定ID集合的数据(批量删除)
/// </summary>
/// <param name="ids"></param>
/// <param name="isRemoveDataCache">是否清除缓存</param>
/// <returns></returns>
Task<bool> DeleteByIdsAsync(List<long> ids, bool isRemoveDataCache = false);
#endregion
#region 判断数据
/// <summary>
/// 判断数据是否存在
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
bool Exists(Expression<Func<T, bool>> predicate, bool blUseNoLock = false);
/// <summary>
/// 判断数据是否存在
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
Task<bool> ExistsAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false);
#endregion
#region 统计数据
/// <summary>
/// 获取数据总数
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
int GetCount(Expression<Func<T, bool>> predicate, bool blUseNoLock = false);
/// <summary>
/// 获取数据总数
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
Task<int> GetCountAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false);
/// <summary>
/// 获取数据某个字段的合计
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="field">字段</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
int GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false);
/// <summary>
/// 获取数据某个字段的合计
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="field">字段</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
Task<int> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false);
/// <summary>
/// 获取数据某个字段的合计
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="field">字段</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
decimal GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false);
/// <summary>
/// 获取数据某个字段的合计
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="field">字段</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
Task<decimal> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false);
/// <summary>
/// 获取数据某个字段的合计
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="field">字段</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
float GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false);
/// <summary>
/// 获取数据某个字段的合计
/// </summary>
/// <param name="predicate">条件表达式树</param>
/// <param name="field">字段</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <returns></returns>
Task<float> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false);
#endregion
#region 分页查询
/// <summary>
/// 根据条件查询分页数据
/// </summary>
/// <param name="predicate"></param>
/// <param name="orderBy"></param>
/// <param name="pageIndex">当前页面索引</param>
/// <param name="pageSize">分布大小</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
IPageList<T> QueryPage(Expression<Func<T, bool>> predicate, string orderBy = "", int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询分页数据
/// </summary>
/// <param name="predicate"></param>
/// <param name="orderBy"></param>
/// <param name="pageIndex">当前页面索引</param>
/// <param name="pageSize">分布大小</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate, string orderBy = "", int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询分页数据
/// </summary>
/// <param name="predicate">判断集合</param>
/// <param name="orderByType">排序方式</param>
/// <param name="pageIndex">当前页面索引</param>
/// <param name="pageSize">分布大小</param>
/// <param name="orderByExpression"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
IPageList<T> QueryPage(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 根据条件查询分页数据
/// </summary>
/// <param name="predicate">判断集合</param>
/// <param name="orderByType">排序方式</param>
/// <param name="pageIndex">当前页面索引</param>
/// <param name="pageSize">分布大小</param>
/// <param name="orderByExpression"></param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
#endregion
#region 联表查询
/// <summary>
/// 查询-多表查询
/// </summary>
/// <typeparam name="T1">实体1</typeparam>
/// <typeparam name="T2">实体2</typeparam>
/// <typeparam name="TResult">返回对象</typeparam>
/// <param name="joinExpression">关联表达式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表达式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>值</returns>
List<TResult> QueryMuch<T1, T2, TResult>(
Expression<Func<T1, T2, object[]>> joinExpression,
Expression<Func<T1, T2, TResult>> selectExpression,
Expression<Func<T1, T2, bool>> whereLambda = null, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new();
/// <summary>
/// 查询-多表查询
/// </summary>
/// <typeparam name="T1">实体1</typeparam>
/// <typeparam name="T2">实体2</typeparam>
/// <typeparam name="TResult">返回对象</typeparam>
/// <param name="joinExpression">关联表达式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表达式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>值</returns>
Task<List<TResult>> QueryMuchAsync<T1, T2, TResult>(
Expression<Func<T1, T2, object[]>> joinExpression,
Expression<Func<T1, T2, TResult>> selectExpression,
Expression<Func<T1, T2, bool>> whereLambda = null, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new();
/// <summary>
/// 查询-多表查询
/// </summary>
/// <typeparam name="T1">实体1</typeparam>
/// <typeparam name="T2">实体2</typeparam>
/// <typeparam name="TResult">返回对象</typeparam>
/// <param name="joinExpression">关联表达式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表达式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>值</returns>
TResult QueryMuchFirst<T1, T2, TResult>(
Expression<Func<T1, T2, object[]>> joinExpression,
Expression<Func<T1, T2, TResult>> selectExpression,
Expression<Func<T1, T2, bool>> whereLambda = null, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new();
/// <summary>
/// 查询-多表查询
/// </summary>
/// <typeparam name="T1">实体1</typeparam>
/// <typeparam name="T2">实体2</typeparam>
/// <typeparam name="TResult">返回对象</typeparam>
/// <param name="joinExpression">关联表达式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表达式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>值</returns>
Task<TResult> QueryMuchFirstAsync<T1, T2, TResult>(
Expression<Func<T1, T2, object[]>> joinExpression,
Expression<Func<T1, T2, TResult>> selectExpression,
Expression<Func<T1, T2, bool>> whereLambda = null, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new();
/// <summary>
/// 查询-三表查询
/// </summary>
/// <typeparam name="T2">实体2</typeparam>
/// <typeparam name="T3">实体3</typeparam>
/// <typeparam name="TResult">返回对象</typeparam>
/// <typeparam name="T1"></typeparam>
/// <param name="joinExpression">关联表达式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表达式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>值</returns>
List<TResult> QueryMuch<T1, T2, T3, TResult>(
Expression<Func<T1, T2, T3, object[]>> joinExpression,
Expression<Func<T1, T2, T3, TResult>> selectExpression,
Expression<Func<T1, T2, T3, bool>> whereLambda = null, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new();
/// <summary>
/// 查询-三表查询
/// </summary>
/// <typeparam name="T2">实体2</typeparam>
/// <typeparam name="T3">实体3</typeparam>
/// <typeparam name="TResult">返回对象</typeparam>
/// <typeparam name="T1"></typeparam>
/// <param name="joinExpression">关联表达式 (join1,join2) => new object[] {JoinType.Left,join1.UserNo==join2.UserNo}</param>
/// <param name="selectExpression">返回表达式 (s1, s2) => new { Id =s1.UserNo, Id1 = s2.UserNo}</param>
/// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
/// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns>值</returns>
Task<List<TResult>> QueryMuchAsync<T1, T2, T3, TResult>(
Expression<Func<T1, T2, T3, object[]>> joinExpression,
Expression<Func<T1, T2, T3, TResult>> selectExpression,
Expression<Func<T1, T2, T3, bool>> whereLambda = null, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue) where T1 : class, new();
#endregion
#region SQL查询
/// <summary>
/// 执行sql语句并返回List<T />
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
List<T> SqlQuery(string sql, List<SugarParameter> parameters);
/// <summary>
/// 执行sql语句并返回List<T />
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="isDataCache">是否启用缓存</param>
/// <param name="cacheTimes">缓存时长（秒）</param>
/// <returns></returns>
Task<List<T>> SqlQueryable(string sql, bool isDataCache = false, int cacheTimes = int.MaxValue);
/// <summary>
/// 执行调用存储过程（返回DataTable）
/// </summary>
/// <param name="useStoredProcedureName">存储过程名称</param>
/// <param name="parameters">参数</param>
/// <returns></returns>
Task<DataTable> SqlQueryDataTableByStoredProcedure(string useStoredProcedureName, List<SugarParameter> parameters);
/// <summary>
/// 执行调用存储过程（返回List<T>）
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="useStoredProcedureName">存储过程名称</param>
/// <param name="parameters">参数</param>
/// <returns></returns>
Task<List<T>> SqlQueryableByStoredProcedure(string useStoredProcedureName, List<SugarParameter> parameters);
#endregion
}
}
Reference in New Issue View Git Blame Copy Permalink