/// <summary>
/// 异步清空所有模型
/// </summary>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>返回信息任务</returns>
public virtual async Task <ReturnInfo <bool> > ClearAsync(CommonUseData comData = null, string connectionId = null)
{
return(await Task.Run <ReturnInfo <bool> >(() =>
{
return Clear(comData, connectionId);
}));
}
/// <summary>
/// 初始化缓存
/// </summary>
/// <param name="tenantId">租戶ID</param>
/// <param name="userId">用户ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public BasicReturnInfo InitCache(IdT tenantId, IdT userId, CommonUseData comData = null)
{
var key = GetKey(tenantId, userId);
var result = Get(key);
if (result == null)
{
var reMenuFunCodes = TenantIdUserMenuReader.GetHavePermissionMenuFunCodes(tenantId, userId, comData);
if (reMenuFunCodes.Failure())
{
return(reMenuFunCodes);
}
if (reMenuFunCodes.Data == null)
{
Add(key, new Dictionary <string, string[]>(0));
}
else
{
Add(key, reMenuFunCodes.Data);
}
return(reMenuFunCodes);
}
return(new BasicReturnInfo());
}
/// <summary>
/// 根据归属移除
/// </summary>
/// <param name="ownerType">归属类型</param>
/// <param name="ownerId">归属ID</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <bool> RemoveByOwner(short ownerType, int ownerId, CommonUseData comData = null, string connectionId = null)
{
ReturnInfo <bool> returnInfo = new ReturnInfo <bool>();
ReturnInfo <IList <AttachmentInfo> > ownerReturnInfo = QueryByOwner(ownerType, ownerId, connectionId: connectionId, comData: comData);
if (returnInfo.Failure() || ownerReturnInfo.Data.IsNullOrCount0())
{
returnInfo.FromBasic(ownerReturnInfo);
return(returnInfo);
}
Persistence.DeleteByOwner(ownerType, ownerId, connectionId);
// 查找所有的文件地址
string[] fileAddress = new string[ownerReturnInfo.Data.Count];
for (var i = 0; i < fileAddress.Length; i++)
{
fileAddress[i] = ownerReturnInfo.Data[i].FileAddress;
}
AttachmentUploadStore.Remove(comData, fileAddress);
return(returnInfo);
}
/// <summary>
/// 异步根据ID修改模型
/// </summary>
/// <param name="model">模型</param>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>返回信息任务</returns>
public virtual async Task <ReturnInfo <bool> > ModifyByIdAsync(ModelT model, CommonUseData comData = null, string connectionId = null)
{
return(await Task.Run <ReturnInfo <bool> >(() =>
{
return ModifyById(model, comData, connectionId);
}));
}
/// <summary>
/// 创建基本的通用数据
/// </summary>
/// <param name="context">上下文</param>
/// <param name="key">键</param>
/// <param name="menuCode">菜单编码</param>
/// <param name="authToken">授权票据</param>
/// <param name="functionCodes">功能编码数组</param>
/// <returns>基本的通用数据</returns>
public static CommonUseData CreateBasicCommonUseData(this HttpContext context, string key = null, string menuCode = null, IAuthToken authToken = null, params string[] functionCodes)
{
var result = new CommonUseData()
{
Key = key,
MenuCode = menuCode,
FunctionCodes = functionCodes
};
if (context != null && context.Request != null)
{
result.Path = context.Request.Path.Value.ToLower();
var routeValue = context.Request.RouteValues;
var routes = routeValue.GetControllerAction();
if (routes != null && routes.Length > 1)
{
result.Controller = routes[0];
result.Action = routes[1];
}
result.Token = authToken == null?context.Request.GetBearerOriginTokenFromHeader() : authToken.GetToken();
if (context.Request.Headers != null && context.Request.Headers.ContainsKey(App.EVENT_ID_KEY))
{
result.EventId = context.Request.Headers[App.EVENT_ID_KEY];
}
result.CommMode = GRpcChannelUtil.IsRequestGRpc(context.Request.ContentType) ? CommunicationMode.GRPC : CommunicationMode.HTTP;
}
return(result);
}
/// <summary>
/// 异步根据ID集合移除模型
/// </summary>
/// <param name="ids">ID集合</param>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>返回信息任务</returns>
public virtual async Task <ReturnInfo <bool> > RemoveByIdsAsync(IdT[] ids, CommonUseData comData = null, string connectionId = null)
{
return(await Task.Run <ReturnInfo <bool> >(() =>
{
return RemoveByIds(ids, comData, connectionId);
}));
}
/// <summary>
/// 异步根据ID判断模型是否存在
/// </summary>
/// <param name="id">ID</param>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>返回信息任务</returns>
public virtual async Task <ReturnInfo <bool> > ExistsAsync(IdT id, CommonUseData comData = null, string connectionId = null)
{
return(await Task.Run <ReturnInfo <bool> >(() =>
{
return Exists(id, comData, connectionId);
}));
}
/// <summary>
/// 根据ID修改模型
/// </summary>
/// <param name="model">模型</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public override ReturnInfo <bool> ModifyById([Model] UserInfo model, CommonUseData comData = null, string connectionId = null)
{
SetModifyInfo(model, comData);
bool isClose = false;
if (string.IsNullOrWhiteSpace(connectionId))
{
isClose = true;
}
ReturnInfo <bool> returnInfo = new ReturnInfo <bool>();
BeforeModifyById(returnInfo, model, ref connectionId);
if (returnInfo.Failure())
{
return(returnInfo);
}
ExecModifyById(returnInfo, model, connectionId: connectionId, comData: comData);
AfterModifyById(returnInfo, model, ref connectionId);
if (isClose)
{
Persistence.Release(connectionId);
}
return(returnInfo);
}
public virtual ReturnInfo <IList <string> > Upload(CommonUseData comData = null, params AttachmentStreamInfo[] attachmentStream)
{
// 以当前年月为目录
string yearMonthDic = $"{DateTime.Now.ToCompactShortYM()}/";
string dic = $"{FileRoot}{yearMonthDic}";
lock (syncCreateRoot)
{
dic.CreateNotExistsDirectory();
}
ReturnInfo <IList <string> > returnInfo = new ReturnInfo <IList <string> >();
returnInfo.Data = new List <string>(attachmentStream.Length);
try
{
foreach (var attStream in attachmentStream)
{
string expandName = attStream.FileName.FileExpandName();
string newFileName = $"{StringUtil.NewShortGuid()}{expandName}";
$"{dic}{newFileName}".WriteFile(attStream.Stream);
returnInfo.Data.Add($"{Config["Attachment:DownloadRoot"]}{yearMonthDic}{newFileName}");
}
}
catch (Exception ex)
{
Log.ErrorAsync(ex.Message, ex, this.GetType().FullName);
returnInfo.SetFailureMsg(ex.Message, ex.StackTrace, ex);
}
return(returnInfo);
}
/// <summary>
/// 根据ID移除模型
/// </summary>
/// <param name="id">ID</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public override ReturnInfo <bool> RemoveById([Id] int id, CommonUseData comData = null, string connectionId = null)
{
ReturnInfo <bool> re = new ReturnInfo <bool>();
// 先取出当前ID的文件地址
ReturnInfo <AttachmentInfo> returnInfo = Find(id, connectionId: connectionId, comData: comData);
if (returnInfo.Failure() || returnInfo.Data == null)
{
re.FromBasic(returnInfo);
return(re);
}
re = base.RemoveById(id, connectionId: connectionId, comData: comData);
if (re.Failure())
{
return(re);
}
if (!string.IsNullOrWhiteSpace(returnInfo.Data.FileAddress))
{
AttachmentUploadStore.Remove(comData, returnInfo.Data.FileAddress);
}
return(re);
}
/// <summary>
/// 查询角色列表并去掉系统隐藏
/// </summary>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <IList <RoleInfo> > QueryAndNotSystemHide(CommonUseData comData = null, string connectionId = null)
{
return(ExecReturnFunc <IList <RoleInfo> >((reInfo) =>
{
return Persistence.SelectAndNotSystemHide(connectionId);
}));
}
/// <summary>
/// 异步根据ID查找模型
/// </summary>
/// <param name="id">ID</param>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>返回信息任务</returns>
public virtual async Task <ReturnInfo <ModelT> > FindAsync(IdT id, CommonUseData comData = null, string connectionId = null)
{
return(await Task.Run <ReturnInfo <ModelT> >(() =>
{
return Find(id, comData, connectionId);
}));
}
/// <summary>
/// 异步查询模型列表
/// </summary>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>返回信息任务</returns>
public virtual async Task <ReturnInfo <IList <ModelT> > > QueryAsync(CommonUseData comData = null, string connectionId = null)
{
return(await Task.Run <ReturnInfo <IList <ModelT> > >(() =>
{
return Query(comData, connectionId);
}));
}
public virtual int Delete(CommonUseData comData = null, string connectionId = null)
{
int result = 0;
IDictionary <string, string> slaveTables = SlaveTables();
if (slaveTables.IsNullOrCount0())
{
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = Delete(dbConn, GetDbTransaction(connId, AccessMode.MASTER), comData: comData);
}, AccessMode.MASTER);
return(result);
}
ExecTransaction((cId) =>
{
DbConnectionManager.BrainpowerExecute(cId, this, (connId, dbConn) =>
{
var trans = GetDbTransaction(connId, AccessMode.MASTER);
result = Delete(dbConn, trans, comData: comData);
foreach (KeyValuePair <string, string> slTable in slaveTables)
{
DeleteSlaveTable(slTable.Key, dbConn, trans, comData: comData);
}
}, AccessMode.MASTER);
}, AccessMode.MASTER, connectionId: connectionId);
return(result);
}
/// <summary>
/// 添加用户角色
/// </summary>
/// <param name="model">模型</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>影响行数</returns>
private int AddUserRoles(UserInfo model, CommonUseData comData = null, string connectionId = null)
{
if (model.OwnRoles.IsNullOrCount0())
{
return(0);
}
IList <UserRoleInfo> userRoles = new List <UserRoleInfo>(model.OwnRoles.Count);
foreach (RoleInfo r in model.OwnRoles)
{
UserRoleInfo ur = new UserRoleInfo()
{
UserId = model.Id,
RoleId = r.Id
};
ur.SetCreateInfo(UserTool <int> .GetCurrUser(comData));
userRoles.Add(ur);
}
if (userRoles.IsNullOrCount0())
{
return(0);
}
return(UserRolePersistence.Insert(userRoles, connectionId: connectionId, comData: comData));
}
/// <summary>
/// 查询菜单树列表
/// </summary>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <IList <MenuTreeInfo> > QueryMenuTrees(CommonUseData comData = null, string connectionId = null)
{
return(ExecReturnFunc <IList <MenuTreeInfo> >((reInfo) =>
{
IList <MenuInfo> menus = Persistence.SelectContainsFunctions(connectionId);
return menus.ToOrigAndSort().ToMenuTrees();
}));
}
protected virtual void ExecAdd(ReturnInfo <bool> returnInfo, UserInfo model, CommonUseData comData = null, string connectionId = null)
{
returnInfo.Data = Persistence.Insert(model, connectionId: connectionId, comData: comData) > 0;
if (returnInfo.Data)
{
AddUserRoles(model, connectionId: connectionId, comData: comData);
}
}
/// <summary>
/// 填充页面数据，包含当前用户所拥有的权限功能列表
/// </summary>
/// <param name="returnInfo">返回信息</param>
/// <param name="comData">通用数据</param>
protected override void FillPageData(ReturnInfo <PageInfo> returnInfo, CommonUseData comData = null)
{
var re = UserService.QueryPageData <PageInfo>(MenuCode(), () =>
{
return(returnInfo.Data);
}, comData: comData);
returnInfo.FromBasic(re);
}
/// <summary>
/// 查询模型列表
/// </summary>
/// <param name="propertyNames">属性名称集合</param>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>模型列表</returns>
public virtual IList <ModelT> Select(string[] propertyNames, CommonUseData comData = null, string connectionId = null)
{
IList <ModelT> result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = Select(dbConn, GetDbTransaction(connId, AccessMode.SLAVE), propertyNames, comData: comData);
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据ID查询模型
/// </summary>
/// <param name="id">ID</param>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>模型</returns>
public virtual ModelT Select(IdT id, CommonUseData comData = null, string connectionId = null)
{
ModelT result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = Select(id, dbConn, GetDbTransaction(connId, AccessMode.SLAVE), comData: comData);
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据ID更新模型
/// </summary>
/// <param name="model">模型</param>
/// <param name="propertyNames">属性名称集合</param>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public virtual int UpdateById(ModelT model, string[] propertyNames, CommonUseData comData = null, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = UpdateById(model, dbConn, GetDbTransaction(connId, AccessMode.MASTER), propertyNames, comData: comData);
}, AccessMode.MASTER);
return(result);
}
/// <summary>
/// 统计模型数
/// </summary>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>模型数</returns>
public virtual int Count(CommonUseData comData = null, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = Count(dbConn, GetDbTransaction(connId, AccessMode.SLAVE), comData: comData);
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 去分页
/// </summary>
/// <param name="comData">通用数据</param>
/// <returns>返回信息任务</returns>
protected virtual ReturnInfo <PagingInfo <ModelT> > DoPage(CommonUseData comData = null)
{
int pageIndex, pageSize;
PageFilterT filter = PagingParseFilter.ToFilterObjectFromHttp <PageFilterT>(Request, out pageIndex, out pageSize);
AppendFilterParams(filter, comData);
ReturnInfo <PagingInfo <ModelT> > returnInfo = QueryPageFromService(pageIndex, pageSize, filter, comData);
AfterPage(returnInfo, pageIndex, pageSize, filter, comData);
return(returnInfo);
}
/// <summary>
/// 异步根据ID查询模型
/// </summary>
/// <param name="id">ID</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>模型任务</returns>
public virtual Task <ModelT> SelectAsync(IdT id, ref string connectionId, CommonUseData comData = null)
{
Task <ModelT> task = null;
DbConnectionManager.BrainpowerExecuteAsync(ref connectionId, this, (connId, isClose, dbConn) =>
{
task = ExecAsync <ModelT>(connId, isClose, dbConn, (dbTrans) =>
{
return(Select(id, dbConn, dbTrans, comData: comData));
}, AccessMode.SLAVE);
}, accessMode: AccessMode.SLAVE);
return(task);
}
/// <summary>
/// 异步统计模型数
/// </summary>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>模型数任务</returns>
public virtual Task <int> CountAsync(ref string connectionId, CommonUseData comData = null)
{
Task <int> task = null;
DbConnectionManager.BrainpowerExecuteAsync(ref connectionId, this, (connId, isClose, dbConn) =>
{
task = ExecAsync <int>(connId, isClose, dbConn, (dbTrans) =>
{
return(Count(dbConn, dbTransaction: dbTrans, comData: comData));
}, AccessMode.SLAVE);
}, accessMode: AccessMode.SLAVE);
return(task);
}
/// <summary>
/// 异步删除所有模型
/// </summary>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>影响行数任务</returns>
public virtual Task <int> DeleteAsync(ref string connectionId, CommonUseData comData = null)
{
Task <int> task = null;
DbConnectionManager.BrainpowerExecuteAsync(ref connectionId, this, (connId, isClose, dbConn) =>
{
task = ExecAsync <int>(connId, isClose, dbConn, (dbTrans) =>
{
return(Delete(dbConn, dbTransaction: dbTrans, comData: comData));
});
});
return(task);
}
/// <summary>
/// 生成序列号
/// </summary>
/// <param name="seqType">序列类型</param>
/// <param name="noLength">序列号长度</param>
/// <param name="increment">增量</param>
/// <param name="comData">通用数据</param>
/// <returns>序列号</returns>
public string BuilderNo(string seqType, byte noLength, int increment, CommonUseData comData = null)
{
string dateStr = DateTime.Now.ToCompactFixedShortDate();
StringBuilder result = new StringBuilder($"{seqType}{dateStr}");
int existsLength = result.Length;
int length = noLength - existsLength - increment.ToString().Length;
for (var i = 0; i < length; i++)
{
result.Append("0");
}
result.Append(increment.ToString());
return(result.ToString());
}
/// <summary>
/// 执行
/// </summary>
/// <param name="flowIn">流程输入</param>
/// <param name="connectionId">连接ID</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public virtual ReturnInfo <bool> Execute(int flowIn, CommonUseData comData = null, string connectionId = null)
{
return(ExecReturnFuncAndConnectionId <bool>((reInfo, connId) =>
{
var workflow = WorkflowPersistence.Select(flowIn, connectionId: connId, comData: comData);
if (workflow == null)
{
reInfo.SetFailureMsg($"找不到ID[{flowIn}]的工作流");
return false;
}
workflow.WorkflowDefine = WorkflowDefinePersistence.Select(workflow.WorkflowDefineId, connectionId: connId, comData: comData);
if (workflow.WorkflowDefine == null)
{
reInfo.SetFailureMsg($"找不到ID[{flowIn}]的工作流定义");
return false;
}
workflow.Handles = WorkflowHandlePersistence.SelectByWorkflowId(flowIn, connId);
Vali(reInfo, workflow, comData);
if (reInfo.Failure())
{
return false;
}
ReturnInfo <bool> reTrans = ExecTransaction(reInfo, workflow, connectionId: connId, comData: comData);
reInfo.FromBasic(reTrans);
if (reTrans.Failure())
{
return false;
}
var descAttr = typeof(RemoveType).GetAttributeForEnum <DescriptionAttribute>(GetRemoveType().ToString());
if (descAttr != null)
{
reInfo.SetSuccessMsg($"此工作流已{descAttr.Description}");
}
return true;
}));
}
/// <summary>
/// 授权
/// </summary>
/// <param name="user">用户</param>
/// <param name="password">密码</param>
/// <param name="comData">通用数据</param>
/// <returns>返回信息</returns>
public ReturnInfo <UserT> Accredit(string user, string password, CommonUseData comData = null)
{
if (userVali == null)
{
throw new NullReferenceException("用户验证不能为null");
}
ReturnInfo <UserT> returnInfo = userVali.Vali(user, password, comData);
if (returnInfo.Failure())
{
return(returnInfo);
}
SaveUserInfo(returnInfo.Data);
return(returnInfo);
}
/// <summary>
/// 根据归属类型读取附件归属信息
/// </summary>
/// <param name="type">归属类型</param>
/// <param name="comData">通用数据</param>
/// <returns>附件归属信息</returns>
public AttachmentOwnerInfo ReaderByOwnerType(short type, CommonUseData comData = null)
{
if (dicCache.ContainsKey(type))
{
return(dicCache[type]);
}
AttachmentOwnerInfo AttachmentOwnerInfo = ProtoAttachmentOwnerReader.ReaderByOwnerType(type, comData);
if (AttachmentOwnerInfo == null)
{
return(null);
}
Add(type, AttachmentOwnerInfo);
return(AttachmentOwnerInfo);
}
