using Microsoft.Data.SqlClient; 
 | 
using SqlSugar; 
 | 
using System; 
 | 
using System.Collections.Generic; 
 | 
using System.Data; 
 | 
using System.Linq; 
 | 
using System.Linq.Expressions; 
 | 
using System.Text; 
 | 
using System.Threading.Tasks; 
 | 
using WIDESEA_Core.Enums; 
 | 
  
 | 
namespace WIDESEA_Core.BaseRepository 
 | 
{ 
 | 
    public interface IRepository<TEntity> : IDependency where TEntity : class, new() 
 | 
    { 
 | 
        /// <summary> 
 | 
        /// SqlsugarClient实体 
 | 
        /// </summary> 
 | 
        ISqlSugarClient Db { get; } 
 | 
        /// <summary> 
 | 
        /// 通过主键查询数据 
 | 
        /// </summary> 
 | 
        /// <param name="id">主键</param> 
 | 
        /// <returns>查询结果</returns> 
 | 
        TEntity QureyDataById(object id); 
 | 
  
 | 
        Task<TEntity> QureyDataByIdAsync(object id); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 通过主键数组查询数据 
 | 
        /// </summary> 
 | 
        /// <param name="lstIds">主键数组</param> 
 | 
        /// <returns>查询结果集合</returns> 
 | 
        List<TEntity> QureyDataByIds(object[] lstIds); 
 | 
  
 | 
        Task<List<TEntity>> QureyDataByIdsAsync(object[] lstIds); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 通过主键集合查询数据 
 | 
        /// </summary> 
 | 
        /// <param name="lstIds">主键集合</param> 
 | 
        /// <returns>查询结果集合</returns> 
 | 
        List<TEntity> QureyDataByIds(List<object> lstIds); 
 | 
  
 | 
        Task<List<TEntity>> QureyDataByIdsAsync(List<object> lstIds); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 添加单条数据 
 | 
        /// </summary> 
 | 
        /// <param name="entity"></param> 
 | 
        /// <returns>影响行数</returns> 
 | 
        int AddData(TEntity entity); 
 | 
  
 | 
        bool AddData<TChild>(TEntity entity, Expression<Func<TEntity, List<TChild>>> expression) where TChild : class, new(); 
 | 
  
 | 
        Task<int> AddDataAsync(TEntity entity); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 添加多条数据 
 | 
        /// </summary> 
 | 
        /// <param name="listEntity"></param> 
 | 
        /// <returns>影响行数</returns> 
 | 
        int AddData(List<TEntity> listEntity); 
 | 
  
 | 
        Task<int> AddDataAsync(List<TEntity> listEntity); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 通过主键删除数据 
 | 
        /// </summary> 
 | 
        /// <param name="id">主键</param> 
 | 
        /// <returns>删除结果</returns> 
 | 
        bool DeleteDataById(object id); 
 | 
  
 | 
        Task<bool> DeleteDataByIdAsync(object id); 
 | 
  
 | 
        bool DeleteAndMoveIntoHty(TEntity entity, OperateTypeEnum operateType); 
 | 
  
 | 
        bool DeleteAndMoveIntoHty(List<TEntity> entities, OperateTypeEnum operateType); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 通过主键数据删除多条数据 
 | 
        /// </summary> 
 | 
        /// <param name="ids">主键数组</param> 
 | 
        /// <returns>删除结果</returns> 
 | 
        bool DeleteDataByIds(object[] ids); 
 | 
  
 | 
        Task<bool> DeleteDataByIdsAsync(object[] ids); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 通过实体数据删除数据 
 | 
        /// </summary> 
 | 
        /// <param name="ids">主键数组</param> 
 | 
        /// <returns>删除结果</returns> 
 | 
        bool DeleteData(TEntity entity); 
 | 
  
 | 
        Task<bool> DeleteDataAsync(TEntity entity); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 通过实体集合数据删除数据 
 | 
        /// </summary> 
 | 
        /// <param name="ids">主键数组</param> 
 | 
        /// <returns>删除结果</returns> 
 | 
        bool DeleteData(List<TEntity> listEntity); 
 | 
  
 | 
        Task<bool> DeleteDataAsync(List<TEntity> listEntity); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 更新单条数据 
 | 
        /// </summary> 
 | 
        /// <param name="entity"></param> 
 | 
        /// <returns></returns> 
 | 
        bool UpdateData(TEntity entity); 
 | 
  
 | 
        Task<bool> UpdateDataAsync(TEntity entity); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 更新多条数据 
 | 
        /// </summary> 
 | 
        /// <param name="listEntity"></param> 
 | 
        /// <returns></returns> 
 | 
        bool UpdateData(List<TEntity> listEntity); 
 | 
  
 | 
        Task<bool> UpdateDataAsync(List<TEntity> listEntity); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 指定列更新数据 
 | 
        /// </summary> 
 | 
        /// <param name="entity"></param> 
 | 
        /// <param name="lstColumns"></param> 
 | 
        /// <param name="lstIgnoreColumns"></param> 
 | 
        /// <returns></returns> 
 | 
        bool UpdateData(TEntity entity, List<string> lstColumns, List<string>? lstIgnoreColumns = null); 
 | 
  
 | 
        Task<bool> UpdateDataAsync(TEntity entity, List<string> lstColumns, List<string>? lstIgnoreColumns = null); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 查询所有数据 
 | 
        /// </summary> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryData(); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataAsync(); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 条件查询数据 
 | 
        /// </summary> 
 | 
        /// <param name="where"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryData(string where); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataAsync(string where); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 条件查询数据 
 | 
        /// </summary> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryData(Expression<Func<TEntity, bool>> whereExpression); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataAsync(Expression<Func<TEntity, bool>> whereExpression); 
 | 
  
 | 
        TEntity QueryFirst(Expression<Func<TEntity, bool>> whereExpression); 
 | 
  
 | 
        Task<TEntity> QueryFirstAsync(Expression<Func<TEntity, bool>> whereExpression); 
 | 
  
 | 
        TResult QueryFirst<TResult>(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, TResult>> expression); 
 | 
  
 | 
        Task<TResult> QueryFirstAsync<TResult>(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, TResult>> expression); 
 | 
  
 | 
        TResult QueryFirst<TResult>(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, TResult>> expression, Dictionary<string, OrderByType> orderBy); 
 | 
  
 | 
        Task<TResult> QueryFirstAsync<TResult>(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, TResult>> expression, Dictionary<string, OrderByType> orderBy); 
 | 
  
 | 
        TEntity QueryFirst(Expression<Func<TEntity, bool>> whereExpression, Dictionary<string, OrderByType> orderBy); 
 | 
  
 | 
        Task<TEntity> QueryFirstAsync(Expression<Func<TEntity, bool>> whereExpression, Dictionary<string, OrderByType> orderBy); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 条件查询数据并排序 
 | 
        /// </summary> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <param name="orderByFields"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryData(Expression<Func<TEntity, bool>> whereExpression, Dictionary<string, OrderByType> orderBy); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataAsync(Expression<Func<TEntity, bool>> whereExpression, string orderByFields); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 条件查询数据并排序 
 | 
        /// </summary> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <param name="where"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryData(string where, Dictionary<string, OrderByType> orderBy); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataAsync(string where, Dictionary<string, OrderByType> orderBy); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 查询指定数据对象 
 | 
        /// </summary> 
 | 
        /// <typeparam name="TResult"></typeparam> 
 | 
        /// <param name="expression"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TResult> QueryData<TResult>(Expression<Func<TEntity, TResult>> expression); 
 | 
  
 | 
        Task<List<TResult>> QueryDataAsync<TResult>(Expression<Func<TEntity, TResult>> expression); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 条件查询指定数据对象 
 | 
        /// </summary> 
 | 
        /// <typeparam name="TResult"></typeparam> 
 | 
        /// <param name="expression"></param> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <param name="orderByFields"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TResult> QueryData<TResult>(Expression<Func<TEntity, TResult>> expression, Expression<Func<TEntity, bool>> whereExpression, string orderByFields = ""); 
 | 
  
 | 
        Task<List<TResult>> QueryDataAsync<TResult>(Expression<Func<TEntity, TResult>> expression, Expression<Func<TEntity, bool>> whereExpression, string orderByFields); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 条件查询数据并排序 
 | 
        /// </summary> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <param name="orderByExpression"></param> 
 | 
        /// <param name="isAsc"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryData(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression, bool isAsc = true); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataAsync(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression, bool isAsc = true); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 条件查询数据并排序 
 | 
        /// </summary> 
 | 
        /// <param name="where"></param> 
 | 
        /// <param name="orderByFields"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryData(string where, string orderByFields); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataAsync(string where, string orderByFields); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 原生Sql语句查询数据 
 | 
        /// </summary> 
 | 
        /// <param name="sql"></param> 
 | 
        /// <param name="parameters"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryDataBySql(string sql, SugarParameter[]? parameters = null); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataBySqlAsync(string sql, SugarParameter[]? parameters = null); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 原生Sql语句查询数据 
 | 
        /// </summary> 
 | 
        /// <param name="sql"></param> 
 | 
        /// <param name="parameters"></param> 
 | 
        /// <returns></returns> 
 | 
        List<dynamic> QueryDynamicDataBySql(string sql, SugarParameter[]? parameters = null); 
 | 
  
 | 
        Task<List<dynamic>> QueryDynamicDataBySqlAsync(string sql, SugarParameter[]? parameters = null); 
 | 
  
 | 
        List<object> QueryObjectDataBySql(string sql, SugarParameter[]? parameters = null); 
 | 
  
 | 
        Task<List<object>> QueryObjectDataBySqlAsync(string sql, SugarParameter[]? parameters = null); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 原生Sql语句执行操作 
 | 
        /// </summary> 
 | 
        /// <param name="sql"></param> 
 | 
        /// <param name="sqlParameters"></param> 
 | 
        /// <returns></returns> 
 | 
        int ExecuteSqlCommand(string sql, params SqlParameter[] sqlParameters); 
 | 
  
 | 
        Task<int> ExecuteSqlCommandAsync(string sql, params SqlParameter[] sqlParameters); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 原生Sql语句查询数据 
 | 
        /// </summary> 
 | 
        /// <param name="sql"></param> 
 | 
        /// <param name="parameters"></param> 
 | 
        /// <returns></returns> 
 | 
        DataTable QueryTable(string sql, SugarParameter[]? parameters = null); 
 | 
  
 | 
        Task<DataTable> QueryTableAsync(string sql, SugarParameter[]? parameters = null); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 条件查询数据指定数量的行 
 | 
        /// </summary> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <param name="top"></param> 
 | 
        /// <param name="orderByFields"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryData(Expression<Func<TEntity, bool>> whereExpression, int top, string orderByFields); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataAsync(Expression<Func<TEntity, bool>> whereExpression, int top, string orderByFields); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 条件查询指定数量的行 
 | 
        /// </summary> 
 | 
        /// <param name="where"></param> 
 | 
        /// <param name="top"></param> 
 | 
        /// <param name="orderByFields"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryData(string where, int top, string orderByFields); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataAsync(string where, int top, string orderByFields); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 分页查询 
 | 
        /// </summary> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <param name="pageIndex"></param> 
 | 
        /// <param name="pageSize"></param> 
 | 
        /// <param name="orderByFields"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryData(Expression<Func<TEntity, bool>> whereExpression, int pageIndex, int pageSize, string orderByFields); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataAsync(Expression<Func<TEntity, bool>> whereExpression, int pageIndex, int pageSize, string orderByFields); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 分页查询 
 | 
        /// </summary> 
 | 
        /// <param name="where"></param> 
 | 
        /// <param name="pageIndex"></param> 
 | 
        /// <param name="pageSize"></param> 
 | 
        /// <param name="orderByFields"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TEntity> QueryData(string where, int pageIndex, int pageSize, string orderByFields); 
 | 
  
 | 
        Task<List<TEntity>> QueryDataAsync(string where, int pageIndex, int pageSize, string orderByFields); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 分页查询 
 | 
        /// </summary> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <param name="pageIndex"></param> 
 | 
        /// <param name="pageSize"></param> 
 | 
        /// <param name="orderByFields"></param> 
 | 
        /// <returns></returns> 
 | 
        PageGridData<TEntity> QueryPage(Expression<Func<TEntity, bool>> whereExpression, int pageIndex, int pageSize, string? orderByFields = null); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 分页查询 
 | 
        /// </summary> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <param name="pageIndex"></param> 
 | 
        /// <param name="pagesize"></param> 
 | 
        /// <param name="orderBy"></param> 
 | 
        /// <returns></returns> 
 | 
        PageGridData<TEntity> QueryPage(Expression<Func<TEntity, bool>> whereExpression, int pageIndex, int pagesize, Dictionary<string, OrderByType> orderBy); 
 | 
  
 | 
        PageGridData<TEntity> QueryPage(string where, int pageIndex, int pageSize, Dictionary<string, OrderByType> orderBy); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 两表联查 
 | 
        /// </summary> 
 | 
        /// <typeparam name="T"></typeparam> 
 | 
        /// <typeparam name="T2"></typeparam> 
 | 
        /// <typeparam name="TResult"></typeparam> 
 | 
        /// <param name="joinExpression"></param> 
 | 
        /// <param name="selectExpression"></param> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <returns></returns> 
 | 
        List<TResult> QueryTabs<T, T2, TResult>( 
 | 
            Expression<Func<T, T2, object[]>> joinExpression, 
 | 
            Expression<Func<T, T2, TResult>> selectExpression, 
 | 
           Expression<Func<T, T2, bool>> whereExpressionT1, 
 | 
            Expression<Func<TResult, bool>> whereExpression); 
 | 
  
 | 
        List<TResult> QueryTabs<T, T2, TResult>( 
 | 
         Expression<Func<T, T2, bool>> joinExpression, 
 | 
         Expression<Func<T, T2, TResult>> selectExpression, 
 | 
         Expression<Func<T, bool>> whereExpressionT1, 
 | 
         Expression<Func<T2, bool>> whereExpressionT2, 
 | 
         Expression<Func<TResult, bool>> whereExpression); 
 | 
  
 | 
  
 | 
        Task<List<TResult>> QueryTabsAsync<T, T2, TResult>( 
 | 
            Expression<Func<T, T2, object[]>> joinExpression, 
 | 
            Expression<Func<T, T2, TResult>> selectExpression, 
 | 
            Expression<Func<TResult, bool>> whereExpression); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 两表联查-分页 
 | 
        /// </summary> 
 | 
        /// <typeparam name="T"></typeparam> 
 | 
        /// <typeparam name="T2"></typeparam> 
 | 
        /// <typeparam name="TResult"></typeparam> 
 | 
        /// <param name="joinExpression"></param> 
 | 
        /// <param name="selectExpression"></param> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <param name="pageIndex"></param> 
 | 
        /// <param name="pageSize"></param> 
 | 
        /// <param name="orderByFields"></param> 
 | 
        /// <returns></returns> 
 | 
        PageGridData<TResult> QueryTabsPage<T, T2, TResult>( 
 | 
            Expression<Func<T, T2, object[]>> joinExpression, 
 | 
            Expression<Func<T, T2, TResult>> selectExpression, 
 | 
            Expression<Func<TResult, bool>> whereExpression, 
 | 
            int pageIndex = 1, 
 | 
            int pageSize = 20, 
 | 
            string? orderByFields = null); 
 | 
  
 | 
        /// <summary> 
 | 
        /// 两表联合查询-分页-分组 
 | 
        /// </summary> 
 | 
        /// <typeparam name="T"></typeparam> 
 | 
        /// <typeparam name="T2"></typeparam> 
 | 
        /// <typeparam name="TResult"></typeparam> 
 | 
        /// <param name="joinExpression"></param> 
 | 
        /// <param name="selectExpression"></param> 
 | 
        /// <param name="whereExpression"></param> 
 | 
        /// <param name="groupExpression"></param> 
 | 
        /// <param name="pageIndex"></param> 
 | 
        /// <param name="pageSize"></param> 
 | 
        /// <param name="orderByFields"></param> 
 | 
        /// <returns></returns> 
 | 
        PageGridData<TResult> QueryTabsPage<T, T2, TResult>( 
 | 
            Expression<Func<T, T2, object[]>> joinExpression, 
 | 
            Expression<Func<T, T2, TResult>> selectExpression, 
 | 
            Expression<Func<TResult, bool>> whereExpression, 
 | 
            Expression<Func<T, object>> groupExpression, 
 | 
            int pageIndex = 1, 
 | 
            int pageSize = 20, 
 | 
            string? orderByFields = null); 
 | 
  
 | 
        //List<TResult> QueryMuch<T, T2, T3, TResult>( 
 | 
        //    Expression<Func<T, T2, T3, object[]>> joinExpression, 
 | 
        //    Expression<Func<T, T2, T3, TResult>> selectExpression, 
 | 
        //    Expression<Func<T, T2, T3, bool>> whereLambda = null) where T : class, new(); 
 | 
        //Task<PageModel<TEntity>> QueryPage(PaginationModel pagination); 
 | 
    } 
 | 
} 
 |