Esempio n. 1
0
        /// <summary>
        /// 根据数据字典编码查询数据字典子项列表
        /// </summary>
        /// <param name="dataDictionaryCode">数据字典编码</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>数据字典子项列表</returns>
        public IList <DataDictionaryItemInfo> SelectByDataDictionaryCode(string dataDictionaryCode, string connectionId = null)
        {
            IList <DataDictionaryItemInfo> result = null;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"{SelectSql("DDI.")} INNER JOIN data_dictionary DD" +
                             $" ON DD.id=DDI.data_dictionary_id AND DD.code=@DataDictionaryCode";
                result = dbConn.Query <DataDictionaryItemInfo>(sql, new { DataDictionaryCode = dataDictionaryCode }).AsList();
            }, AccessMode.SLAVE);

            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 = $"{BasicDeleteSql()} WHERE {GetFieldByProp("UserId")}=@UserId";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "DeleteByUserId");
                result = dbConn.Execute(sql, new { UserId = userId }, GetDbTransaction(connId));
            });

            return(result);
        }
Esempio n. 3
0
        /// <summary>
        /// 根据角色ID查询用户列表
        /// </summary>
        /// <param name="roleId">角色ID</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>用户列表</returns>
        public IList <UserInfo> SelectUsersByRoleId(int roleId, string connectionId = null)
        {
            IList <UserInfo> result = null;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"SELECT {UserPersistence.AllFieldMapProps().JoinSelectPropMapFields("U.")} FROM [{UserPersistence.Table}] U"
                             + $" INNER JOIN [{Table}] UR ON U.id=UR.user_id AND UR.role_id=@RoleId AND U.system_hide=@SystemHide";
                result = dbConn.Query <UserInfo>(sql, new { RoleId = roleId, SystemHide = false }).AsList();
            }, AccessMode.SLAVE);

            return(result);
        }
Esempio n. 4
0
        /// <summary>
        /// 根据工作流ID更新处理状态为已失效但排除ID
        /// </summary>
        /// <param name="workflowHandle">工作流处理</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>影响行数</returns>
        public int UpdateEfficacyedNotIdByWorkflowId(WorkflowHandleInfo workflowHandle, string connectionId = null)
        {
            int result = 0;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"UPDATE `{Table}` SET `{GetFieldByProp("HandleStatus")}`={(byte)HandleStatusEnum.EFFICACYED},`{GetFieldByProp("HandleTime")}`=@HandleTime" +
                             $"{GetModifyInfoSql(workflowHandle)} WHERE {GetFieldByProp("Id") }!=@Id AND {GetFieldByProp("WorkflowId") }=@WorkflowId AND {GetFieldByProp("HandleStatus") }={(byte)HandleStatusEnum.UN_HANDLE} AND {GetFieldByProp("HandleType")}={(byte)HandleTypeEnum.AUDIT}";
                result = dbConn.Execute(sql, workflowHandle, GetDbTransaction(connId));
            });

            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) =>
            {
                var sql = DeleteSql();
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "DeleteByRoleId");
                result = dbConn.Execute($"{sql} WHERE role_id=@RoleId", new { RoleId = roleId }, GetDbTransaction(connId));
            });

            return(result);
        }
Esempio n. 6
0
        /// <summary>
        /// 根据用户ID查询角色列表
        /// </summary>
        /// <param name="userId">用户ID</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>角色列表</returns>
        public IList <RoleInfo> SelectRolesByUserId(int userId, string connectionId = null)
        {
            IList <RoleInfo> result = null;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"SELECT {RolePersistence.AllFieldMapProps().JoinSelectPropMapFields("R.")} FROM [{RolePersistence.Table}] R"
                             + $" INNER JOIN [{Table}] UR ON R.id=UR.role_id AND UR.user_id=@UserId";
                result = dbConn.Query <RoleInfo>(sql, new { UserId = userId }).AsList();
            }, AccessMode.SLAVE);

            return(result);
        }
Esempio n. 7
0
        public object ExecuteScalar()
        {
            object result = null;

            using (var conn = DbConnectionManager.Clone())
            {
                conn.Open();
                QueryStart();
                result = conn.ExecuteScalar(Command, _Parameter);
                QueryFinish();
            }
            return(result);
        }
Esempio n. 8
0
        /// <summary>
        /// 根据ID更新增量
        /// </summary>
        /// <param name="sequenceInfo">序列信息</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>影响行数</returns>
        public int UpdateIncrementById(SequenceInfo sequenceInfo, string connectionId = null)
        {
            int result = 0;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"UPDATE `{Table}` SET `{GetFieldByProp("Increment")}`=@Increment,`{GetFieldByProp("UpdateDate")}`=@UpdateDate{GetModifyInfoSql(sequenceInfo)} WHERE {GetFieldByProp("Id") }=@Id";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "UpdateIncrementById");
                result = dbConn.Execute(sql, sequenceInfo, GetDbTransaction(connId));
            });

            return(result);
        }
Esempio n. 9
0
        /// <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 = $"{BasicSelectSql()} WHERE {GetFieldByProp("LoginId")}=@LoginId AND `{GetFieldByProp("Password")}`=@Password";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "SelectByLoginIdAndPassword");
                result = dbConn.QueryFirstOrDefault <UserInfo>(sql, new { LoginId = loginId, Password = password });
            }, AccessMode.SLAVE);

            return(result);
        }
Esempio n. 10
0
        /// <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 = $"{BasicSelectSql()} WHERE `{GetFieldByProp("Id")}`!=@Id AND (`{GetFieldByProp("LoginId")}`=@LoginId OR `{GetFieldByProp("Code")}`=@Code OR `{GetFieldByProp("Name")}`=@Name)";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "SelectByLoginIdOrCodeOrNameNotId");
                result = dbConn.QueryFirstOrDefault <UserInfo>(sql, new { Id = notId, LoginId = loginId, Code = code, Name = name });
            }, AccessMode.SLAVE);

            return(result);
        }
        /// <summary>
        /// 根据编码或名称查询角色列表,但排除ID
        /// </summary>
        /// <param name="code">编码</param>
        /// <param name="name">名称</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 = $"{BasicSelectSql()} WHERE Id!=@Id AND (`{GetFieldByProp("Code")}`=@Code OR `{GetFieldByProp("Name")}`=@Name)";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "SelelctByCodeOrNameNotId");
                result = dbConn.Query <RoleInfo>(sql, new { Id = notId, Code = code, Name = name }).AsList();
            }, AccessMode.SLAVE);

            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 = $"{BasicSelectSql()} WHERE {GetFieldByProp("SystemHide")}=@SystemHide";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "SelectAndNotSystemHide");
                result = dbConn.Query <RoleInfo>(sql, new { SystemHide = false }).AsList();
            }, AccessMode.SLAVE);

            return(result);
        }
Esempio n. 13
0
        /// <summary>
        /// 根据工作流ID和处理状态统计个数但排除流程关卡ID
        /// </summary>
        /// <param name="workflowId">工作流ID</param>
        /// <param name="handleStatus">处理状态</param>
        /// <param name="notFlowCensorshipId">排除流程关卡ID</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>个数</returns>
        public int CountNotFlowCensorshipIdByWorkflowIdAndHandleStatus(int workflowId, HandleStatusEnum handleStatus, int notFlowCensorshipId, string connectionId = null)
        {
            int result = 0;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"{BasicCountSql()} WHERE {GetFieldByProp("WorkflowId")}=@WorkflowId AND {GetFieldByProp("HandleStatus")}=@handleStatus AND {GetFieldByProp("FlowCensorshipId")}!=@NotFlowCensorshipId";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "CountNotFlowCensorshipIdByWorkflowIdAndHandleStatus");
                result = dbConn.ExecuteScalar <int>(sql, new { WorkflowId = workflowId, HandleStatus = (byte)handleStatus, NotFlowCensorshipId = notFlowCensorshipId }, GetDbTransaction(connId));
            }, 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 = $"{BasicCountSql()} WHERE `{GetFieldByProp("Id")}`!=@Id AND {GetFieldByProp("DataDictionaryId")}=@DataDictionaryId AND `{GetFieldByProp("Text")}`=@Text";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "CountByDataItemIdAndTextNotId");
                result = dbConn.ExecuteScalar <int>(sql, new { Id = notId, DataDictionaryId = dataDictionaryId, Text = text });
            }, AccessMode.SLAVE);

            return(result);
        }
Esempio n. 15
0
        /// <summary>
        /// 根据ID更新是否已读
        /// </summary>
        /// <param name="workflowHandle">工作流处理</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>影响行数</returns>
        public int UpdateIsReadedById(WorkflowHandleInfo workflowHandle, string connectionId = null)
        {
            int result = 0;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"UPDATE `{Table}` SET `{GetFieldByProp("IsReaded")}`=@IsReaded{GetModifyInfoSql(workflowHandle)} WHERE {GetFieldByProp("Id") }=@Id";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "UpdateIsReadedById");
                result = dbConn.Execute(sql, workflowHandle, GetDbTransaction(connId));
            });

            return(result);
        }
Esempio n. 16
0
        /// <summary>
        /// 根据处理人ID统计审核且未处理的个数
        /// </summary>
        /// <param name="handlerId">处理人ID</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>审核中且未处理的个数</returns>
        public int CountAuditAndUnhandleByHandleId(int handlerId, string connectionId = null)
        {
            int result = 0;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"{BasicCountSql()} WHERE {GetFieldByProp("HandlerId")}=@HandlerId AND {GetFieldByProp("HandleStatus")}=@handleStatus AND {GetFieldByProp("HandleType")}=@HandleType";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "CountAuditAndUnhandleByHandleId");
                result = dbConn.ExecuteScalar <int>(sql, new { HandlerId = handlerId, HandleStatus = (byte)HandleStatusEnum.UN_HANDLE, HandleType = (byte)HandleTypeEnum.AUDIT }, GetDbTransaction(connId));
            }, AccessMode.SLAVE);

            return(result);
        }
Esempio n. 17
0
        /// <summary>
        /// 根据ID更新处理状态
        /// </summary>
        /// <param name="workflowHandle">工作流处理</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>影响行数</returns>
        public int UpdateHandleStatusById(WorkflowHandleInfo workflowHandle, string connectionId = null)
        {
            int result = 0;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"UPDATE `{Table}` SET `{GetFieldByProp("HandleStatus")}`=@HandleStatus,`{GetFieldByProp("HandleTime")}`=@HandleTime,`{GetFieldByProp("Idea")}`=@Idea" +
                             $"{GetModifyInfoSql(workflowHandle)} WHERE {GetFieldByProp("Id") }=@Id";
                result = dbConn.Execute(sql, workflowHandle, GetDbTransaction(connId));
            });

            return(result);
        }
Esempio n. 18
0
        /// <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 = $"{BasicDeleteSql()} WHERE owner_type=@OwnerType AND owner_id=@OwnerId";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "DeleteByOwner");
                result = dbConn.Execute(sql, new { OwnerType = ownerType, OwnerId = ownerId }, GetDbTransaction(connId));
            });

            return(result);
        }
        /// <summary>
        /// 根据数据字典子项ID查询数据字典子项扩展列表
        /// </summary>
        /// <param name="dataDictionaryItemId">数据字典子项ID</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>数据字典子项扩展列表</returns>
        public IList <DataDictionaryItemExpandInfo> SelectByDataDictionaryItemId(int dataDictionaryItemId, string connectionId = null)
        {
            IList <DataDictionaryItemExpandInfo> result = null;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"{BasicSelectSql()} WHERE {GetFieldByProp("DataDictionaryItemId")}=@DataDictionaryItemId";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "SelectByDataDictionaryItemId");
                result = dbConn.Query <DataDictionaryItemExpandInfo>(sql, new { DataDictionaryItemId = dataDictionaryItemId }).AsList();
            }, AccessMode.SLAVE);

            return(result);
        }
        /// <summary>
        /// 异步执行
        /// </summary>
        /// <typeparam name="TResult">结果类型</typeparam>
        /// <param name="connectionId">连接ID</param>
        /// <param name="isClose">是否关闭</param>
        /// <param name="dbConnection">数据库连接</param>
        /// <param name="func">函数</param>
        /// <returns>结果任务</returns>
        protected async Task <TResult> ExecAsync <TResult>(string connectionId, bool isClose, IDbConnection dbConnection, Func <TResult> func)
        {
            return(await Task.Run <TResult>(() =>
            {
                TResult result = func();
                if (isClose)
                {
                    DbConnectionManager.Release(connectionId, dbConnection);
                }

                return result;
            }));
        }
Esempio n. 21
0
 public void BulkInsert(ITableData data, string tableName)
 {
     using (var conn = DbConnectionManager.Clone())
     {
         conn.Open();
         QueryStart(LogType.Bulk);
         conn.BeforeBulkInsert();
         conn.BulkInsert(data, tableName);
         conn.AfterBulkInsert();
         RowsAffected = data.RecordsAffected;
         QueryFinish(LogType.Rows);
     }
 }
Esempio n. 22
0
        /// <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";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "UpdatePasswordById");
                result = dbConn.Execute(sql, user, GetDbTransaction(connId));
            });

            return(result);
        }
Esempio n. 23
0
        /// <summary>
        /// 根据申请单号统计记录数
        /// </summary>
        /// <param name="applyNo">申请单号</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>记录数</returns>
        public int CountByApplyNo(string applyNo, string connectionId = null)
        {
            int result = 0;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"{BasicCountSql()} WHERE {GetFieldByProp("ApplyNo")}=@ApplyNo";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "CountByApplyNo");
                result = dbConn.ExecuteScalar <int>(sql, new { ApplyNo = applyNo });
            }, AccessMode.SLAVE);

            return(result);
        }
Esempio n. 24
0
        /// <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 = $"{BasicSelectSql()} WHERE {GetFieldByProp("FlowCensorshipId")}=@FlowCensorshipId";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "SelectByFlowCensorshipId");
                result = dbConn.Query <ReturnFlowRouteInfo>(sql, new { FlowCensorshipId = flowCensorshipId }).AsList();
            }, AccessMode.SLAVE);

            return(result);
        }
Esempio n. 25
0
        /// <summary>
        /// 根据编码查询工作流定义信息
        /// </summary>
        /// <param name="code">编码</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>工作流定义信息</returns>
        public WorkflowDefineInfo SelectByCode(string code, string connectionId = null)
        {
            WorkflowDefineInfo result = null;

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = $"{BasicSelectSql()} WHERE {GetFieldByProp("Code")}=@Code";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "SelectByCode");
                result = dbConn.QueryFirstOrDefault <WorkflowDefineInfo>(sql, new { Code = code });
            }, AccessMode.SLAVE);

            return(result);
        }
        /// <summary>
        /// 根据角色ID集合查询具有权限的菜单列表
        /// </summary>
        /// <param name="roleIds">角色ID集合</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>菜单列表</returns>
        public IList <MenuInfo> SelectByRoleIds(int[] roleIds, string connectionId = null)
        {
            string            menuFields = JoinSelectPropMapFields(pfx: "M.");
            DynamicParameters parameters = new DynamicParameters();
            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);

            List <MenuInfo> result = new List <MenuInfo>();

            DbConnectionManager.BrainpowerExecute(connectionId, this, (connId, dbConn) =>
            {
                string sql = "SELECT " + menuFields + ", F.id, F.[code], F.[name] FROM menu M"
                             + " INNER JOIN menu_function MF ON M.[Id]=MF.[menu_id]"
                             + " INNER JOIN [function] F ON MF.[function_id]=F.[Id]"
                             + $" INNER JOIN role_menu_function MFU ON MFU.[menu_function_id]= MF.[Id] AND MFU.[role_id] IN({roleSql.ToString()})";
                Log.TraceAsync(sql, source: this.GetType().Name, tags: "SelectByRoleIds");
                dbConn.Query <MenuInfo, FunctionInfo, MenuInfo>(sql, (x, y) =>
                {
                    MenuInfo existsMenu = result.Find(q => q.Id == x.Id);
                    if (existsMenu == null)
                    {
                        result.Add(x);

                        existsMenu           = x;
                        existsMenu.Functions = new List <FunctionInfo>();
                        existsMenu.Functions.Add(y);

                        return(existsMenu);
                    }

                    List <FunctionInfo> existsFuns = existsMenu.Functions as List <FunctionInfo>;
                    if (existsFuns.Exists(q => q.Id == y.Id))
                    {
                        return(null);
                    }

                    existsMenu.Functions.Add(y);

                    return(null);
                }, parameters, splitOn: "Id").AsList();
            }, AccessMode.SLAVE);

            return(result);
        }
Esempio n. 27
0
        static void TestDbContext()
        {
            try
            {
                WriteToDatabase();
            }
            catch (Exception ex)
            {
                var a = ex;
            }

            void WriteToDatabase()
            {
                var dbConnectionBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder();

                dbConnectionBuilder.DataSource     = "115.159.55.137,1999";
                dbConnectionBuilder.UserID         = "chenguangxu";
                dbConnectionBuilder.Password       = "******";
                dbConnectionBuilder.InitialCatalog = "Manager.Account";
                dbConnectionBuilder.ConnectTimeout = 10;

                DbConnectionManager.Register(dbConnectionBuilder.InitialCatalog, new MsSqlConnectionProvider(10, dbConnectionBuilder.ConnectionString));
                EntitySchemaManager.LoadEntity(typeof(Entity));
                var option = new DbContextOptions();

                option.ExceptionHandling = ExceptionHandling.Skip;
                using (var dbContext = new DbContext(option))
                {
                    var dbSet = dbContext.Set <Entity>();
                    dbSet.Add(new Entity()
                    {
                        ID = 2, Name = "a2"
                    });
                    dbSet.Add(new Entity()
                    {
                        ID = 3, Name = "a3"
                    });
                    try
                    {
                        dbContext.SaveChanges();
                    }
                    finally
                    {
                        foreach (var row in dbSet.RowEntries)
                        {
                            var a = row.State;
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 异步根据ID集合查询模型
        /// </summary>
        /// <param name="ids">ID集合</param>
        /// <param name="propertyNames">属性名称集合</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>模型任务</returns>
        public virtual Task <IList <ModelT> > SelectAsync(IdT[] ids, string[] propertyNames, ref string connectionId)
        {
            Task <IList <ModelT> > task = null;

            DbConnectionManager.BrainpowerExecuteAsync(ref connectionId, this, (connId, isClose, dbConn) =>
            {
                task = ExecAsync <IList <ModelT> >(connId, isClose, dbConn, () =>
                {
                    return(Select(ids, dbConn, propertyNames: propertyNames));
                });
            });

            return(task);
        }
        /// <summary>
        /// 异步删除所有模型
        /// </summary>
        /// <param name="connectionId">连接ID</param>
        /// <returns>影响行数任务</returns>
        public virtual Task <int> DeleteAsync(ref string connectionId)
        {
            Task <int> task = null;

            DbConnectionManager.BrainpowerExecuteAsync(ref connectionId, this, (connId, isClose, dbConn) =>
            {
                task = ExecAsync <int>(connId, isClose, dbConn, () =>
                {
                    return(Delete(dbConn));
                });
            });

            return(task);
        }
        /// <summary>
        /// 异步根据ID更新模型
        /// </summary>
        /// <param name="model">模型</param>
        /// <param name="propertyNames">属性名称集合</param>
        /// <param name="connectionId">连接ID</param>
        /// <returns>影响行数任务</returns>
        public virtual Task <int> UpdateByIdAsync(ModelT model, string[] propertyNames, ref string connectionId)
        {
            Task <int> task = null;

            DbConnectionManager.BrainpowerExecuteAsync(ref connectionId, this, (connId, isClose, dbConn) =>
            {
                task = ExecAsync <int>(connId, isClose, dbConn, () =>
                {
                    return(UpdateById(model, dbConn, propertyNames: propertyNames));
                });
            });

            return(task);
        }
 protected override IDisposableDbCommandBuilder GetDbCommandBuilder()
 {
     var connectionManager = new DbConnectionManager<SqlCeConnection>(DbConnections.SqlCeConnectionString);
     return new DisposableDbCommandBuilder<SqlCeConnection>(connectionManager, new SqlCeDbCommandBuilder(connectionManager));
 }
Esempio n. 32
0
 protected override IDbCommandBuilder CreateDbCommandBuilder(DbConnectionManager<SqlCeConnection> connectionManager )
 {
     return _mockDbCommandBuilder;
 }
 protected override IDisposableDbCommandBuilder GetDbCommandBuilder()
 {
     var connectionManager = new DbConnectionManager<NpgsqlConnection>(DbConnections.PostgresqlConnectionString);
     return new DisposableDbCommandBuilder<NpgsqlConnection>(connectionManager, new PostgresqlDbCommandBuilder(connectionManager));
 }
 protected override IDisposableDbCommandBuilder GetDbCommandBuilder()
 {
     var connectionManager = new DbConnectionManager<OracleConnection>(DbConnections.OracleClientConnectionString);
     return new DisposableDbCommandBuilder<OracleConnection>(connectionManager, new OracleClientDbCommandBuilder(connectionManager));
 }