From 7281004dc3854ed59e9164dcd27a59c8c2cf6667 Mon Sep 17 00:00:00 2001
From: qinchulong <qinchulong@hnkhzn.com>
Date: 星期六, 12 十月 2024 15:16:55 +0800
Subject: [PATCH] 初始化
---
项目代码/WMS/WIDESEA_WMSServer/WIDESEA_Core/BaseRepository/RepositoryBase.cs | 290 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 286 insertions(+), 4 deletions(-)
diff --git "a/\351\241\271\347\233\256\344\273\243\347\240\201/WMS/WIDESEA_WMSServer/WIDESEA_Core/BaseRepository/RepositoryBase.cs" "b/\351\241\271\347\233\256\344\273\243\347\240\201/WMS/WIDESEA_WMSServer/WIDESEA_Core/BaseRepository/RepositoryBase.cs"
index 46695de..539c96b 100644
--- "a/\351\241\271\347\233\256\344\273\243\347\240\201/WMS/WIDESEA_WMSServer/WIDESEA_Core/BaseRepository/RepositoryBase.cs"
+++ "b/\351\241\271\347\233\256\344\273\243\347\240\201/WMS/WIDESEA_WMSServer/WIDESEA_Core/BaseRepository/RepositoryBase.cs"
@@ -521,11 +521,12 @@
/// <param name="whereExpression"></param>
/// <returns></returns>
public virtual List<TResult> QueryTabs<T, T2, TResult>(
- Expression<Func<T, T2, object[]>> joinExpression,
- Expression<Func<T, T2, TResult>> selectExpression,
- Expression<Func<TResult, bool>> whereExpression)
+ 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> list = _db.Queryable(joinExpression)
+ List<TResult> list = _db.Queryable(joinExpression).WhereIF(whereExpressionT1 != null, whereExpressionT1)
.Select(selectExpression)
.WhereIF(whereExpression != null, whereExpression).ToList();
return list;
@@ -584,5 +585,286 @@
// Expression<Func<T, T2, T3, TResult>> selectExpression,
// Expression<Func<T, T2, T3, bool>> whereLambda = null) where T : class, new(){throw new NotImplementedException();}
//Task<PageModel<TEntity>> QueryPage(PaginationModel pagination){throw new NotImplementedException();}
+
+
+ public Task<TEntity> QureyDataByIdAsync(object id)
+ {
+ return _db.Queryable<TEntity>().In(id).SingleAsync();
+ }
+
+ public Task<List<TEntity>> QureyDataByIdsAsync(object[] lstIds)
+ {
+ return _db.Queryable<TEntity>().In(lstIds).ToListAsync();
+ }
+
+ public Task<List<TEntity>> QureyDataByIdsAsync(List<object> lstIds)
+ {
+ return _db.Queryable<TEntity>().In(lstIds).ToListAsync();
+ }
+
+ public Task<int> AddDataAsync(TEntity entity)
+ {
+ IInsertable<TEntity> insert = _db.Insertable(entity);
+ return insert.ExecuteReturnIdentityAsync();
+ }
+
+ public Task<int> AddDataAsync(List<TEntity> listEntity)
+ {
+ IInsertable<TEntity> insert = _db.Insertable(listEntity);
+ return insert.ExecuteReturnIdentityAsync();
+ }
+
+ public Task<bool> DeleteDataByIdAsync(object id)
+ {
+ return _db.Deleteable<TEntity>().In(id).ExecuteCommandHasChangeAsync();
+ }
+
+ public Task<bool> DeleteDataByIdsAsync(object[] ids)
+ {
+ return _db.Deleteable<TEntity>().In(ids).ExecuteCommandHasChangeAsync();
+ }
+
+ public Task<bool> DeleteDataAsync(TEntity entity)
+ {
+ return _db.Deleteable(entity).ExecuteCommandHasChangeAsync();
+ }
+
+ public Task<bool> DeleteDataAsync(List<TEntity> listEntity)
+ {
+ return _db.Deleteable(listEntity).ExecuteCommandHasChangeAsync();
+ }
+
+ public Task<bool> UpdateDataAsync(TEntity entity)
+ {
+ return _db.Updateable(entity).ExecuteCommandHasChangeAsync();
+ }
+
+ public Task<bool> UpdateDataAsync(List<TEntity> listEntity)
+ {
+ return _db.Updateable(listEntity).ExecuteCommandHasChangeAsync();
+ }
+
+ public Task<bool> UpdateDataAsync(TEntity entity, List<string> lstColumns, List<string>? lstIgnoreColumns = null)
+ {
+ IUpdateable<TEntity> update = _db.Updateable(entity);
+
+ if (lstIgnoreColumns != null && lstIgnoreColumns.Count > 0)
+ {
+ update = update.IgnoreColumns(lstIgnoreColumns.ToArray());
+ }
+
+ if (lstColumns != null && lstColumns.Count > 0)
+ {
+ update = update.UpdateColumns(lstColumns.ToArray());
+ }
+
+ return update.ExecuteCommandHasChangeAsync();
+ }
+
+ public Task<List<TEntity>> QueryDataAsync()
+ {
+ return _db.Queryable<TEntity>().ToListAsync();
+ }
+
+ public Task<List<TEntity>> QueryDataAsync(string where)
+ {
+ return _db.Queryable<TEntity>().WhereIF(!string.IsNullOrEmpty(where), where).ToListAsync();
+ }
+
+ public Task<List<TEntity>> QueryDataAsync(Expression<Func<TEntity, bool>> whereExpression)
+ {
+ return _db.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).ToListAsync();
+ }
+
+ public Task<TEntity> QueryFirstAsync(Expression<Func<TEntity, bool>> whereExpression)
+ {
+ return _db.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).FirstAsync();
+ }
+
+ public Task<TResult> QueryFirstAsync<TResult>(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, TResult>> expression)
+ {
+ return _db.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).Select(expression).FirstAsync();
+ }
+
+ public TResult QueryFirst<TResult>(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, TResult>> expression, Dictionary<string, OrderByType> orderBy)
+ {
+ List<OrderByModel> orderByModels = new List<OrderByModel>();
+ foreach (var item in orderBy)
+ {
+ OrderByModel orderByModel = new OrderByModel()
+ {
+ FieldName = item.Key,
+ OrderByType = item.Value
+ };
+ orderByModels.Add(orderByModel);
+ }
+ return _db.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).OrderBy(orderByModels).Select(expression).First();
+ }
+
+ public Task<TResult> QueryFirstAsync<TResult>(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, TResult>> expression, Dictionary<string, OrderByType> orderBy)
+ {
+ List<OrderByModel> orderByModels = new List<OrderByModel>();
+ foreach (var item in orderBy)
+ {
+ OrderByModel orderByModel = new OrderByModel()
+ {
+ FieldName = item.Key,
+ OrderByType = item.Value
+ };
+ orderByModels.Add(orderByModel);
+ }
+ return _db.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).OrderBy(orderByModels).Select(expression).FirstAsync();
+ }
+
+ public TEntity QueryFirst(Expression<Func<TEntity, bool>> whereExpression, Dictionary<string, OrderByType> orderBy)
+ {
+ List<OrderByModel> orderByModels = new List<OrderByModel>();
+ foreach (var item in orderBy)
+ {
+ OrderByModel orderByModel = new OrderByModel()
+ {
+ FieldName = item.Key,
+ OrderByType = item.Value
+ };
+ orderByModels.Add(orderByModel);
+ }
+ return _db.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).OrderBy(orderByModels).First();
+ }
+
+ public Task<TEntity> QueryFirstAsync(Expression<Func<TEntity, bool>> whereExpression, Dictionary<string, OrderByType> orderBy)
+ {
+ List<OrderByModel> orderByModels = new List<OrderByModel>();
+ foreach (var item in orderBy)
+ {
+ OrderByModel orderByModel = new OrderByModel()
+ {
+ FieldName = item.Key,
+ OrderByType = item.Value
+ };
+ orderByModels.Add(orderByModel);
+ }
+ return _db.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).OrderBy(orderByModels).FirstAsync();
+ }
+
+ public Task<List<TEntity>> QueryDataAsync(Expression<Func<TEntity, bool>> whereExpression, string orderByFields)
+ {
+ return _db.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).OrderByIF(!string.IsNullOrEmpty(orderByFields), orderByFields).ToListAsync();
+ }
+
+ public Task<List<TEntity>> QueryDataAsync(string where, Dictionary<string, OrderByType> orderBy)
+ {
+ List<OrderByModel> orderByModels = new List<OrderByModel>();
+ foreach (var item in orderBy)
+ {
+ OrderByModel orderByModel = new OrderByModel()
+ {
+ FieldName = item.Key,
+ OrderByType = item.Value
+ };
+ orderByModels.Add(orderByModel);
+ }
+ return _db.Queryable<TEntity>().WhereIF(!string.IsNullOrEmpty(where), where).OrderBy(orderByModels).ToListAsync();
+ }
+
+ public Task<List<TResult>> QueryDataAsync<TResult>(Expression<Func<TEntity, TResult>> expression)
+ {
+ return _db.Queryable<TEntity>().Select(expression).ToListAsync();
+ }
+
+ public Task<List<TResult>> QueryDataAsync<TResult>(Expression<Func<TEntity, TResult>> expression, Expression<Func<TEntity, bool>> whereExpression, string orderByFields)
+ {
+ return _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(orderByFields), orderByFields).WhereIF(whereExpression != null, whereExpression).Select(expression).ToListAsync();
+ }
+
+ public Task<List<TEntity>> QueryDataAsync(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression, bool isAsc = true)
+ {
+ return _db.Queryable<TEntity>().OrderByIF(orderByExpression != null, orderByExpression, isAsc ? OrderByType.Asc : OrderByType.Desc).WhereIF(whereExpression != null, whereExpression).ToListAsync();
+ }
+
+ public Task<List<TEntity>> QueryDataAsync(string where, string orderByFields)
+ {
+ return _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(orderByFields), orderByFields).WhereIF(!string.IsNullOrEmpty(where), where).ToListAsync();
+ }
+
+ public Task<List<TEntity>> QueryDataBySqlAsync(string sql, SugarParameter[]? parameters = null)
+ {
+ return _db.Ado.SqlQueryAsync<TEntity>(sql, parameters);
+ }
+
+ public Task<List<dynamic>> QueryDynamicDataBySqlAsync(string sql, SugarParameter[]? parameters = null)
+ {
+ return _db.Ado.SqlQueryAsync<dynamic>(sql, parameters);
+ }
+
+ public Task<List<object>> QueryObjectDataBySqlAsync(string sql, SugarParameter[]? parameters = null)
+ {
+ return _db.Ado.SqlQueryAsync<object>(sql, parameters);
+ }
+
+ public Task<int> ExecuteSqlCommandAsync(string sql, params SqlParameter[] sqlParameters)
+ {
+ return _db.Ado.ExecuteCommandAsync(sql, sqlParameters);
+ }
+
+ public Task<DataTable> QueryTableAsync(string sql, SugarParameter[]? parameters = null)
+ {
+ return _db.Ado.GetDataTableAsync(sql, parameters);
+ }
+
+ public Task<List<TEntity>> QueryDataAsync(Expression<Func<TEntity, bool>> whereExpression, int top, string orderByFields)
+ {
+ return _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(orderByFields), orderByFields).WhereIF(whereExpression != null, whereExpression).Take(top).ToListAsync();
+ }
+
+ public Task<List<TEntity>> QueryDataAsync(string where, int top, string orderByFields)
+ {
+ return _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(orderByFields), orderByFields).WhereIF(!string.IsNullOrEmpty(where), where).Take(top).ToListAsync();
+ }
+
+ public Task<List<TEntity>> QueryDataAsync(Expression<Func<TEntity, bool>> whereExpression, int pageIndex, int pageSize, string orderByFields)
+ {
+ return _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(orderByFields), orderByFields)
+ .WhereIF(whereExpression != null, whereExpression).ToPageListAsync(pageIndex, pageSize);
+ }
+
+ public Task<List<TEntity>> QueryDataAsync(string where, int pageIndex, int pageSize, string orderByFields)
+ {
+ return _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(orderByFields), orderByFields)
+ .WhereIF(!string.IsNullOrEmpty(where), where).ToPageListAsync(pageIndex, pageSize);
+ }
+
+ public Task<List<TResult>> QueryTabsAsync<T, T2, TResult>(Expression<Func<T, T2, object[]>> joinExpression, Expression<Func<T, T2, TResult>> selectExpression, Expression<Func<TResult, bool>> whereExpression)
+ {
+ return _db.Queryable(joinExpression)
+ .Select(selectExpression)
+ .WhereIF(whereExpression != null, whereExpression).ToListAsync();
+ }
+
+ /// <summary>
+ /// 鏉′欢鏌ヨ鏁版嵁骞舵帓搴�
+ /// </summary>
+ /// <param name="whereExpression"></param>
+ /// <param name="orderByFields"></param>
+ /// <returns></returns>
+ public virtual List<TEntity> QueryData(Expression<Func<TEntity, bool>> whereExpression, Dictionary<string, OrderByType> orderBy)
+ {
+ List<OrderByModel> orderByModels = new List<OrderByModel>();
+ foreach (var item in orderBy)
+ {
+ OrderByModel orderByModel = new OrderByModel()
+ {
+ FieldName = item.Key,
+ OrderByType = item.Value
+ };
+ orderByModels.Add(orderByModel);
+ }
+ return _db.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).OrderBy(orderByModels).ToList();
+ }
+
+ //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(){throw new NotImplementedException();}
+ //Task<PageModel<TEntity>> QueryPage(PaginationModel pagination){throw new NotImplementedException();}
}
}
--
Gitblit v1.9.3