WMS系统添加PDA权限，PDA程序

dengjunjie

2025-03-12 f43b7df8400f4fcffc9f19dca0888d61e2b33d5f

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_Core/BaseRepository/IRepository.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,430 @@
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);

        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, OperateType operateType);

        bool DeleteAndMoveIntoHty(List<TEntity> entities, OperateType 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);
    }
}