public virtual int Delete(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));
}, AccessMode.MASTER);
return(result);
}
ExecTransaction((cId) =>
{
DbConnectionManager.BrainpowerExecute(cId, this, (connId, dbConn) =>
{
result = Delete(dbConn, GetDbTransaction(connId, AccessMode.MASTER));
foreach (KeyValuePair <string, string> slTable in slaveTables)
{
DeleteSlaveTable(slTable.Key, dbConn, GetDbTransaction(connId, AccessMode.MASTER));
}
}, AccessMode.MASTER);
}, AccessMode.MASTER, connectionId: connectionId);
return(result);
}
/// <summary>
/// 根据菜单编码、功能编码集合和用户ID统计个数
/// </summary>
/// <param name="menuCode">菜单编码</param>
/// <param name="functionCodes">功能编码集合</param>
/// <param name="userId">用户ID</param>
/// <param name="connectionId">连接ID</param>
/// <returns>个数</returns>
public int CountByMenuCodeAndFunctionCodesAndUserId(string menuCode, string[] functionCodes, int userId, string connectionId = null)
{
int result = 0;
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@MenuCode", menuCode);
parameters.Add("@UserId", userId);
StringBuilder functionSql = new StringBuilder();
for (var i = 0; i < functionCodes.Length; i++)
{
string name = $"@FunctionCode{i}";
functionSql.AppendFormat("{0},", name);
parameters.Add(name, functionCodes[i]);;
}
functionSql.Remove(functionSql.Length - 1, 1);
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = "SELECT COUNT(*) FROM menu M"
+ " INNER JOIN menu_function MF ON M.`id`= MF.`menu_id`"
+ $" INNER JOIN `function` F ON F.`id`= MF.`function_id` AND F.`code` IN({functionSql.ToString()})"
+ $" INNER JOIN {Table} RMF ON RMF.`menu_function_id`=MF.`id` AND RMF.`user_id`=@UserId"
+ " WHERE M.`code`=@MenuCode";
Log.TraceAsync(sql, source: this.GetType().Name, tags: "CountByMenuCodeAndFunctionCodesAndUserId");
result = dbConn.ExecuteScalar <int>(sql, parameters);
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据用户ID集合查询用户角色列表，包含角色信息
/// </summary>
/// <param name="userIds">用户ID集合</param>
/// <param name="connectionId">连接ID</param>
/// <returns>用户角色列表</returns>
public IList <UserRoleInfo> SelectContainsRoleByUserIds(int[] userIds, string connectionId = null)
{
IList <UserRoleInfo> result = null;
DynamicParameters parameters = new DynamicParameters();
StringBuilder userIdSql = new StringBuilder();
for (int i = 0; i < userIds.Length; i++)
{
string name = $"@UserId{i}";
parameters.Add(name, userIds[i]);
userIdSql.AppendFormat("{0},", name);
}
userIdSql.Remove(userIdSql.Length - 1, 1);
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"SELECT UR.user_id UserId,{RolePersistence.AllFieldMapProps().JoinSelectPropMapFields("R.")} FROM {Table} UR"
+ $" INNER JOIN `{RolePersistence.Table}` R ON R.id=UR.role_id AND UR.user_id IN({userIdSql.ToString()})";
result = dbConn.Query <UserRoleInfo, RoleInfo, UserRoleInfo>(sql, (ur, r) =>
{
ur.Role = r;
return(ur);
}, parameters).AsList();
}, AccessMode.SLAVE);
return(result);
}
public virtual int DeleteByIds(IdT[] ids, CommonUseData comData = null, string connectionId = null)
{
int result = 0;
IDictionary <string, string> slaveTables = SlaveTables();
if (slaveTables.IsNullOrCount0())
{
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = DeleteByIds(ids, 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 = DeleteByIds(ids, dbConn, trans, comData: comData);
foreach (KeyValuePair <string, string> slTable in slaveTables)
{
DeleteSlaveTableByForeignKeys(slTable.Key, slTable.Value, ids, dbConn, trans, comData: comData);
}
}, AccessMode.MASTER);
}, AccessMode.MASTER, connectionId: connectionId);
return(result);
}
/// <summary>
/// 插入模型列表
/// </summary>
/// <param name="models">模型列表</param>
/// <param name="propertyNames">属性名称集合</param>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public virtual int Insert(IList <ModelT> models, string[] propertyNames = null, CommonUseData comData = null, string connectionId = null)
{
int result = 0;
IdT TenantId = default(IdT);
foreach (var m in models)
{
if (ModelIsSetTenantId(m))
{
continue;
}
if (!Identity.IsEmpty(TenantId) && IsExistsTenantId(out TenantId, comData))
{
SetTenantId(m, TenantId);
}
}
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = Insert(models, dbConn, propertyNames, GetDbTransaction(connId, AccessMode.MASTER), comData: comData);
}, AccessMode.MASTER);
return(result);
}
/// <summary>
/// 根据菜单编码和角色ID集合查询功能信息列表
/// </summary>
/// <param name="menuCode">菜单编码</param>
/// <param name="roleIds">角色ID集合</param>
/// <param name="connectionId">连接ID</param>
/// <returns>功能信息列表</returns>
public IList <FunctionInfo> SelectFunctionsByMenuCodeAndRoleIds(string menuCode, int[] roleIds, string connectionId = null)
{
IList <FunctionInfo> result = null;
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@MenuCode", menuCode);
StringBuilder roleSql = new StringBuilder();
for (var i = 0; i < roleIds.Length; i++)
{
string name = $"@RoleId{i}";
roleSql.AppendFormat("{0},", name);
parameters.Add(name, roleIds[i]);;
}
roleSql.Remove(roleSql.Length - 1, 1);
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = "SELECT F.* FROM `function` F"
+ " INNER JOIN menu_function MF ON MF.`function_id`= F.`id`"
+ " INNER JOIN menu M ON M.`id`= MF.`menu_id` AND M.`code`=@MenuCode"
+ $" INNER JOIN {Table} RMF ON RMF.`menu_function_id`= MF.`id` AND RMF.`role_id` IN({roleSql.ToString()})";
Log.TraceAsync(sql, source: this.GetType().Name, tags: "SelectFunctionsByMenuCodeAndRoleIds");
result = dbConn.Query <FunctionInfo>(sql, parameters).AsList();
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 查询已审核的工作流列表并分页
/// </summary>
/// <param name="pageIndex">页码</param>
/// <param name="pageSize">每页记录数</param>
/// <param name="filter">筛选</param>
/// <param name="connectionId">连接ID</param>
/// <returns>分页信息</returns>
public PagingInfo <WorkflowInfo> SelectAuditedHandlePage(int pageIndex, int pageSize, AuditFlowFilterInfo filter, string connectionId = null)
{
PagingInfo <WorkflowInfo> result = null;
DynamicParameters parameters;
StringBuilder whereSql = MergeWhereSql(filter, out parameters);
whereSql.Append(" AND wh.handler_id=@HandlerId AND (wh.handle_status=@HandleStatus1 || wh.handle_status=@HandleStatus2) && handle_type=@HandleType");
parameters.Add("HandlerId", filter.HandlerId);
parameters.Add("HandleStatus1", (byte)HandleStatusEnum.SENDED);
parameters.Add("HandleStatus2", (byte)HandleStatusEnum.RETURNED);
parameters.Add("HandleType", (byte)HandleTypeEnum.AUDIT);
if (filter.FlowStatus != null)
{
whereSql.Append(" AND flow_status=@FlowStatus");
parameters.Add("FlowStatus", filter.FlowStatus);
}
string sortSql = GetSelectPageSortSql(filter, GetSelectSortNamePfx(filter));
if (string.IsNullOrWhiteSpace(sortSql))
{
sortSql = $" ORDER BY wh.handle_time DESC";
}
string formatSql = $"SELECT {{0}} FROM {Table}"
+ $" INNER JOIN workflow_handle wh ON {Table}.`id`=wh.`workflow_id`"
+ whereSql.ToString();
string countSql = string.Format(formatSql, "COUNT(1)");
string pageSql = string.Format(formatSql, $"{JoinSelectPropMapFields(pfx: Table + ".")},wh.`id`,wh.`is_readed` IsReaded")
+ " " + sortSql + " " + GetPartPageSql(pageIndex, pageSize);
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = PagingUtil.ExecPage <WorkflowInfo>(pageIndex, pageSize, () =>
{
return(dbConn.ExecuteScalar <int>(countSql, parameters, GetDbTransaction(connId)));
}, () =>
{
return(dbConn.Query <WorkflowInfo, WorkflowHandleInfo, WorkflowInfo>(pageSql, (wf, wh) =>
{
if (wf.Handles == null)
{
wf.Handles = new List <WorkflowHandleInfo>()
{
wh
};
}
return wf;
}, parameters, GetDbTransaction(connId), splitOn: "id").AsList());
});
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据ID查询模型
/// </summary>
/// <param name="id">ID</param>
/// <param name="propertyNames">属性名称集合</param>
/// <param name="connectionId">连接ID</param>
/// <returns>模型</returns>
public virtual ModelT Select(IdT id, string[] propertyNames, string connectionId = null)
{
ModelT result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = Select(id, dbConn, GetDbTransaction(connId, AccessMode.SLAVE), propertyNames);
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据ID更新模型
/// </summary>
/// <param name="model">模型</param>
/// <param name="propertyNames">属性名称集合</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public virtual int UpdateById(ModelT model, string[] propertyNames, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = UpdateById(model, dbConn, GetDbTransaction(connId, AccessMode.MASTER), propertyNames);
}, AccessMode.MASTER);
return(result);
}
/// <summary>
/// 统计模型数
/// </summary>
/// <param name="connectionId">连接ID</param>
/// <returns>模型数</returns>
public virtual int Count(string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = Count(dbConn, GetDbTransaction(connId, AccessMode.SLAVE));
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据用户ID删除
/// </summary>
/// <param name="roleId">角色ID</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public int DeleteByRoleId(int roleId, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = dbConn.Execute($"{DeleteSql()} WHERE role_id=@RoleId", new { RoleId = roleId }, GetDbTransaction(connId));
});
return(result);
}
/// <summary>
/// 根据ID更新模型
/// </summary>
/// <param name="model">模型</param>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public virtual int UpdateById(ModelT model, CommonUseData comData = null, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = UpdateById(model, dbConn, GetDbTransaction(connId, AccessMode.MASTER), comData: comData);
}, AccessMode.MASTER);
return(result);
}
/// <summary>
/// 根据ID和大于修改时间查询修改信息列表（多用于乐观锁的判断，以修改时间为判断）
/// </summary>
/// <param name="models">模型数组</param>
/// <param name="mode">访问模式，默认为主库</param>
/// <param name="comData">通用数据</param>
/// <param name="connectionId">连接ID</param>
/// <returns>只有修改信息的模型列表</returns>
public virtual IList <ModelT> SelectModifyInfosByIdAndGeModifyTime(ModelT[] models, AccessMode mode = AccessMode.MASTER, CommonUseData comData = null, string connectionId = null)
{
IList <ModelT> result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = SelectModifyInfosByIdAndGeModifyTime(models, dbConn, GetDbTransaction(connId, mode), comData: comData);
}, mode);
return(result);
}
/// <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 int Count(IdT id, CommonUseData comData = null, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = Count(id, dbConn, GetDbTransaction(connId, AccessMode.SLAVE), comData: comData);
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据ID集合查询模型列表
/// </summary>
/// <param name="ids">ID集合</param>
/// <param name="connectionId">连接ID</param>
/// <returns>模型列表</returns>
public virtual IList <ModelT> Select(IdT[] ids, string connectionId = null)
{
IList <ModelT> result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = Select(ids, dbConn, GetDbTransaction(connId, AccessMode.SLAVE));
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 插入模型列表
/// </summary>
/// <param name="models">模型列表</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public virtual int Insert(IList <ModelT> models, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = Insert(models, dbConn, GetDbTransaction(connId, AccessMode.MASTER));
}, AccessMode.MASTER);
return(result);
}
/// <summary>
/// 根据登录ID或编码或名称查询用户信息，但排除ID
/// </summary>
/// <param name="notId">排除ID</param>
/// <param name="loginId">登录ID</param>
/// <param name="code">编码</param>
/// <param name="name">名称</param>
/// <param name="connectionId">连接ID</param>
/// <returns>用户信息</returns>
public UserInfo SelectByLoginIdOrCodeOrNameNotId(int notId, string loginId, string code, string name, string connectionId = null)
{
UserInfo result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"{SelectSql()} WHERE [{GetFieldByProp("Id")}]!=@Id AND ([{GetFieldByProp("LoginId")}]=@LoginId OR [{GetFieldByProp("Code")}]=@Code OR [{GetFieldByProp("Name")}]=@Name)";
result = dbConn.QueryFirstOrDefault <UserInfo>(sql, new { Id = notId, LoginId = loginId, Code = code, Name = name });
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据归属删除
/// </summary>
/// <param name="ownerType">归属类型</param>
/// <param name="ownerId">归属ID</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public int DeleteByOwner(short ownerType, int ownerId, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"{DeleteSql()} WHERE owner_type=@OwnerType AND owner_id=@OwnerId";
result = dbConn.Execute(sql, new { OwnerType = ownerType, OwnerId = ownerId }, GetDbTransaction(connId));
});
return(result);
}
/// <summary>
/// 根据登录ID和密码查询用户信息
/// </summary>
/// <param name="loginId">登录ID</param>
/// <param name="password">密码</param>
/// <param name="connectionId">连接ID</param>
/// <returns>用户信息</returns>
public UserInfo SelectByLoginIdAndPassword(string loginId, string password, string connectionId = null)
{
UserInfo result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"{SelectSql()} WHERE {GetFieldByProp("LoginId")}=@LoginId AND [{GetFieldByProp("Password")}]=@Password";
result = dbConn.QueryFirstOrDefault <UserInfo>(sql, new { LoginId = loginId, Password = password });
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据ID更新密码
/// </summary>
/// <param name="user">用户</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public int UpdatePasswordById(UserInfo user, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"UPDATE [{Table}] SET [{GetFieldByProp("Password")}]=@Password{GetModifyInfoSql(user)} WHERE {GetFieldByProp("Id") }=@Id";
result = dbConn.Execute(sql, user, GetDbTransaction(connId));
});
return(result);
}
/// <summary>
/// 根据用户ID删除
/// </summary>
/// <param name="userId">用户ID</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public int DeleteByUserId(int userId, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"{DeleteSql()} WHERE {GetFieldByProp("UserId")}=@UserId";
result = dbConn.Execute(sql, new { UserId = userId }, GetDbTransaction(connId));
});
return(result);
}
/// <summary>
/// 根据流程关卡ID查询退件流程路线列表
/// </summary>
/// <param name="flowCensorshipId">流程关卡ID</param>
/// <param name="connectionId">连接ID</param>
/// <returns>退件流程路线列表</returns>
public IList <ReturnFlowRouteInfo> SelectByFlowCensorshipId(int flowCensorshipId, string connectionId = null)
{
IList <ReturnFlowRouteInfo> result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"{SelectSql()} WHERE {GetFieldByProp("FlowCensorshipId")}=@FlowCensorshipId";
result = dbConn.Query <ReturnFlowRouteInfo>(sql, new { FlowCensorshipId = flowCensorshipId }).AsList();
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据数据字典ID和文本统计个数，但排除ID
/// </summary>
/// <param name="notId">排除ID</param>
/// <param name="dataDictionaryId">数据字典ID</param>
/// <param name="text">文本</param>
/// <param name="connectionId">连接ID</param>
/// <returns>个数</returns>
public int CountByDataItemIdAndTextNotId(int notId, int dataDictionaryId, string text, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"{CountSql()} WHERE `{GetFieldByProp("Id")}`!=@Id AND {GetFieldByProp("DataDictionaryId")}=@DataDictionaryId AND `{GetFieldByProp("Text")}`=@Text";
result = dbConn.ExecuteScalar <int>(sql, new { Id = notId, DataDictionaryId = dataDictionaryId, Text = text });
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 查询模型列表并分页
/// </summary>
/// <param name="pageIndex">页码</param>
/// <param name="pageSize">每页记录数</param>
/// <param name="propertyNames">属性名称集合</param>
/// <param name="filter">筛选</param>
/// <param name="connectionId">连接ID</param>
/// <returns>分页信息</returns>
public virtual PagingInfo <ModelT> SelectPage(int pageIndex, int pageSize, string[] propertyNames, FilterInfo filter = null, string connectionId = null)
{
BeforeFilterInfo(filter);
PagingInfo <ModelT> result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
result = SelectPage(pageIndex, pageSize, dbConn, filter, GetDbTransaction(connId, AccessMode.SLAVE), propertyNames);
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据工作流ID查询测试表单信息
/// </summary>
/// <param name="workflowId">工作流ID</param>
/// <param name="connectionId">连接ID</param>
/// <returns>测试表单信息</returns>
public TestFormInfo SelectByWorkflowId(int workflowId, string connectionId = null)
{
TestFormInfo result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"{SelectSql()} WHERE {GetFieldByProp("WorkflowId")}=@WorkflowId";
result = dbConn.QueryFirstOrDefault <TestFormInfo>(sql, new { WorkflowId = workflowId }, GetDbTransaction(connId));
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据流程ID更新流程状态
/// </summary>
/// <param name="testForm">测试表单</param>
/// <param name="connectionId">连接ID</param>
/// <returns>影响行数</returns>
public int UpdateFlowStatusByWorkflowId(TestFormInfo testForm, string connectionId = null)
{
int result = 0;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"UPDATE `{Table}` SET {GetFieldByProp("FlowStatus")}=@FlowStatus{GetModifyInfoSql(testForm)} WHERE {GetFieldByProp("WorkflowId")}=@WorkflowId";
result = dbConn.Execute(sql, testForm, GetDbTransaction(connId));
});
return(result);
}
/// <summary>
/// 查询角色列表并去掉系统隐藏
/// </summary>
/// <param name="connectionId">连接ID</param>
/// <returns>角色列表</returns>
public IList <RoleInfo> SelectAndNotSystemHide(string connectionId = null)
{
IList <RoleInfo> result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"{SelectSql()} WHERE {GetFieldByProp("SystemHide")}=@SystemHide";
result = dbConn.Query <RoleInfo>(sql, new { SystemHide = false }).AsList();
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据编码或名称查询角色列表，但排除ID
/// </summary>
/// <param name="role">编码</param>
/// <param name="notId">名称</param>
/// <param name="notId">排除ID</param>
/// <param name="connectionId">连接ID</param>
/// <returns>角色列表</returns>
public IList <RoleInfo> SelelctByCodeOrNameNotId(string code, string name, int notId, string connectionId = null)
{
IList <RoleInfo> result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"{SelectSql()} WHERE Id!=@Id AND (`{GetFieldByProp("Code")}`=@Code OR `{GetFieldByProp("Name")}`=@Name)";
result = dbConn.Query <RoleInfo>(sql, new { Id = notId, Code = code, Name = name }).AsList();
}, AccessMode.SLAVE);
return(result);
}
/// <summary>
/// 根据数据字典ID查询数据字典子项列表
/// </summary>
/// <param name="dataDictionaryId">数据字典ID</param>
/// <param name="connectionId">连接ID</param>
/// <returns>数据字典子项列表</returns>
public IList <DataDictionaryItemInfo> SelectByDataDictionaryId(int dataDictionaryId, string connectionId = null)
{
IList <DataDictionaryItemInfo> result = null;
DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
{
string sql = $"{SelectSql()} WHERE {GetFieldByProp("DataDictionaryId")}=@DataDictionaryId";
result = dbConn.Query <DataDictionaryItemInfo>(sql, new { DataDictionaryId = dataDictionaryId }).AsList();
}, AccessMode.SLAVE);
return(result);
}
