Beispiel #1
0
        /// <summary>
        /// 获取AD组内的人员在安全中心中的人员信息
        /// </summary>
        /// <param name="groupEntry"></param>
        /// <returns></returns>
        private static IEnumerable <DataRow> CollectGroupUserRows(DirectoryEntry groupEntry)
        {
            InSqlClauseBuilder builder = new InSqlClauseBuilder();

            ADHelper helper = ADHelper.GetInstance();

            helper.EnumGroupMembers(groupEntry, sr =>
            {
                builder.AppendItem(helper.GetSearchResultPropertyStrValue("samAccountName", sr));
            });

            List <DataRow> result = new List <DataRow>(256);

            if (builder.Count > 0)
            {
                string sql = string.Format("SELECT OU_USERS.* FROM OU_USERS INNER JOIN USERS ON USER_GUID = GUID WHERE SIDELINE = 0 AND LOGON_NAME {0} ORDER BY GLOBAL_SORT",
                                           builder.ToSqlStringWithInOperator(TSqlBuilder.Instance));

                DataTable table = null;

                DbHelper.ExecSql(db => table = db.ExecuteDataSet(CommandType.Text, sql).Tables[0]);

                foreach (DataRow row in table.Rows)
                {
                    result.Add(row);
                }
            }

            return(result);
        }
        /// <summary>
        /// 根据XPath查询SchemaObject
        /// </summary>
        /// <param name="xPath">符合条件的xPath语句</param>
        /// <param name="schemaTypes">SchemaType。如果为空数组,则查询所有类型的对象</param>
        /// <param name="includingDeleted">为true时,包含已删除的对象。</param>
        /// <param name="timePoint"></param>
        /// <returns></returns>
        public SchemaObjectCollection LoadByXPath(string xPath, string[] schemaTypes, bool includingDeleted, DateTime timePoint)
        {
            schemaTypes.NullCheck("schemaTypes");

            SchemaObjectCollection result = new SchemaObjectCollection();

            if (xPath.IsNotEmpty())
            {
                InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("SchemaType");

                inBuilder.AppendItem(schemaTypes);

                WhereSqlClauseBuilder pathBuilder = new WhereSqlClauseBuilder();

                pathBuilder.AppendItem("Data", xPath, string.Empty, "Data.exist(${Data}$) > 0");

                if (includingDeleted == false)
                {
                    pathBuilder.AppendItem("Status", (int)SchemaObjectStatus.Normal);
                }

                ConnectiveSqlClauseCollection builder = new ConnectiveSqlClauseCollection(inBuilder, pathBuilder);

                result = Load(builder, timePoint);
            }
            else
            {
                result = new SchemaObjectCollection();
            }

            return(result);
        }
        /// <summary>
        /// 删除某个事件下的频道(UI上用于频道列表)
        /// </summary>
        /// <param name="eventID"></param>
        /// <param name="channelIDs"></param>
        /// <param name="includeDefault">是否包含默认频道</param>
        public int DeleteChannels(string eventID, IEnumerable <string> channelIDs, bool includeDefault = false)
        {
            eventID.CheckStringIsNullOrEmpty("eventID");
            channelIDs.NullCheck("channelIDs");

            InSqlClauseBuilder builder = new InSqlClauseBuilder("ChannelID");

            channelIDs.ForEach(channelID => builder.AppendItem(channelID));

            ORMappingItemCollection mappings = ORMapping.GetMappingInfo(typeof(AMSEventChannel));

            string sql = string.Format("DELETE {0} WHERE {1}", mappings.TableName, builder.ToSqlStringWithInOperator(TSqlBuilder.Instance));

            int result = 0;

            if (builder.IsEmpty == false)
            {
                if (includeDefault == false)
                {
                    sql += " AND IsDefault <> 1";
                }

                result = DbHelper.RunSql(sql, this.GetConnectionName());
            }

            return(result);
        }
        /// <summary>
        /// 根据TaskGuid得到UserAccomplishedTask
        /// </summary>
        /// <param name="strTaskGuid"></param>
        /// <returns></returns>
        public UserTaskCollection GetUserAccomplishedTasks(params string[] strTaskGuid)
        {
            UserTaskCollection utc = new UserTaskCollection();

            if (strTaskGuid.Length > 0)
            {
                InSqlClauseBuilder builder = new InSqlClauseBuilder();
                builder.AppendItem(strTaskGuid);

                string strSql = "SELECT * FROM WF.USER_ACCOMPLISHED_TASK WHERE (TASK_GUID " + builder.ToSqlStringWithInOperator(TSqlBuilder.Instance) + ")";
                using (DbContext dbi = DbHelper.GetDBContext(GetConnectionName()))
                {
                    Database db = DatabaseFactory.Create(dbi);

                    using (IDataReader dr = db.ExecuteReader(CommandType.Text, strSql))
                    {
                        while (dr.Read())
                        {
                            UserTask ut = new UserTask();

                            ORMapping.DataReaderToObject(dr, ut);

                            utc.Add(ut);
                        }
                    }
                }
            }

            return(utc);
        }
        public UserTaskCollection LoadUserTasksByActivity(string activityID, Action <InSqlClauseBuilder> action)
        {
            action.NullCheck("action");

            InSqlClauseBuilder builder = new InSqlClauseBuilder();

            action(builder);

            string sql = string.Format("SELECT * FROM WF.USER_TASK WHERE ACTIVITY_ID = {0}",
                                       TSqlBuilder.Instance.CheckUnicodeQuotationMark(activityID));

            if (builder.Count > 0)
            {
                sql += " AND " + builder.ToSqlStringWithInOperator(TSqlBuilder.Instance);
            }

            UserTaskCollection result = new UserTaskCollection();

            DataTable table = DbHelper.RunSqlReturnDS(sql, GetConnectionName()).Tables[0];

            foreach (DataRow row in table.Rows)
            {
                UserTask task = new UserTask();

                ORMapping.DataRowToObject(row, task);

                result.Add(task);
            }

            return(result);
        }
        public int GetMaxInnerSort(string id, string[] childSchemaTypes, DateTime timePoint)
        {
            IConnectiveSqlClause timeBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint);

            WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
            where.AppendItem("ParentID", id);

            InSqlClauseBuilder inSql = null;

            if (childSchemaTypes != null && childSchemaTypes.Length > 0)
            {
                inSql = new InSqlClauseBuilder("ChildSchemaType").AppendItem(childSchemaTypes);
            }

            ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(where, timeBuilder);

            if (inSql != null)
            {
                connectiveBuilder.Add(inSql);
            }


            string sql = "SELECT ISNULL(MAX(InnerSort), 0) AS C FROM " + GetMappingInfo().TableName + " WHERE " + connectiveBuilder.ToSqlString(TSqlBuilder.Instance);

            int result = (int)DbHelper.RunSqlReturnScalar(sql, this.GetConnectionName());

            return(result);
        }
        /// <summary>
        /// 加载流程运行时的信息
        /// </summary>
        /// <param name="processIDs"></param>
        /// <returns></returns>
        public WfProcessCurrentInfoCollection Load(bool fillAssignees, params string[] processIDs)
        {
            processIDs.NullCheck("processIDs");

            WfProcessCurrentInfoCollection result = new WfProcessCurrentInfoCollection();

            InSqlClauseBuilder builder = new InSqlClauseBuilder();

            builder.AppendItem(processIDs);

            if (builder.Count > 0)
            {
                string fieldNames = ORMapping.GetSelectFieldsNameSql <WfProcessInstanceData>("Data");

                string sql = string.Format("SELECT {0} FROM WF.PROCESS_INSTANCES WHERE INSTANCE_ID {1}",
                                           fieldNames,
                                           builder.ToSqlStringWithInOperator(TSqlBuilder.Instance));

                DataTable table = DbHelper.RunSqlReturnDS(sql, GetConnectionName()).Tables[0];

                result.LoadFromDataView(table.DefaultView);

                if (fillAssignees)
                {
                    FillAssignees(result);
                }
            }

            return(result);
        }
        /// <summary>
        /// 加载流程运行时的信息
        /// </summary>
        /// <param name="processIDs"></param>
        /// <returns></returns>
        public WfProcessCurrentInfoCollection Load(bool fillAssignees, params string[] processIDs)
        {
            processIDs.NullCheck("processIDs");

            WfProcessCurrentInfoCollection result = new WfProcessCurrentInfoCollection();

            InSqlClauseBuilder builder = new InSqlClauseBuilder();
            builder.AppendItem(processIDs);

            if (builder.Count > 0)
            {
                string fieldNames = ORMapping.GetSelectFieldsNameSql<WfProcessInstanceData>("Data");

                string sql = string.Format("SELECT {0} FROM WF.PROCESS_INSTANCES WHERE INSTANCE_ID {1}",
                    fieldNames,
                    builder.ToSqlStringWithInOperator(TSqlBuilder.Instance));

                DataTable table = DbHelper.RunSqlReturnDS(sql, GetConnectionName()).Tables[0];

                result.LoadFromDataView(table.DefaultView);

                if (fillAssignees)
                    FillAssignees(result);
            }

            return result;
        }
        /// <summary>
        /// 读取用户对于各应用的管理权限,不通过缓存
        /// </summary>
        /// <param name="user"></param>
        /// <returns></returns>
        public WfApplicationAuthCollection LoadUserApplicationAuthInfo(IUser user)
        {
            user.NullCheck("user");

            List <IRole> roles = user.Roles.GetAllRoles();

            List <string> roleIDs = new List <string>();

            foreach (IRole role in roles)
            {
                roleIDs.Add(role.ID);
            }

            string sql = "SELECT * FROM WF.UNION_APP_AUTH_WITH_ALIAS WHERE {0}";

            WfApplicationAuthCollection result = new WfApplicationAuthCollection();

            if (roleIDs.Count > 0)
            {
                InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("ROLE_ID");

                inBuilder.AppendItem(roleIDs.ToArray());

                ConnectiveSqlClauseCollection builder = new ConnectiveSqlClauseCollection(LogicOperatorDefine.And,
                                                                                          inBuilder, new WhereSqlClauseBuilder().AppendTenantCode(typeof(WfApplicationAuth)));

                sql = string.Format(sql, inBuilder.ToSqlStringWithInOperator(TSqlBuilder.Instance));

                DataView view = DbHelper.RunSqlReturnDS(sql, GetConnectionName()).Tables[0].DefaultView;

                ORMapping.DataViewToCollection(result, view);
            }

            return(result);
        }
Beispiel #10
0
        public SchemaObjectCollection QueryApplications(string[] schemaTypes, bool includingDeleted, DateTime timePoint)
        {
            SchemaObjectCollection result = new SchemaObjectCollection();

            ConnectiveSqlClauseCollection timeConditionC = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "SC.");

            InSqlClauseBuilder schemaBuilder = new InSqlClauseBuilder("SC.SchemaType");

            schemaBuilder.AppendItem(schemaTypes);

            WhereSqlClauseBuilder builderC = new WhereSqlClauseBuilder();

            if (includingDeleted == false)
            {
                builderC.AppendItem("SC.Status", (int)SchemaObjectStatus.Normal);
            }

            ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(schemaBuilder, builderC, timeConditionC);

            string sql = string.Format("SELECT SC.*" +
                                       "\nFROM SC.SchemaObject SC" +
                                       "\nWHERE {0}", connectiveBuilder.ToSqlString(TSqlBuilder.Instance));

            DataTable table = DbHelper.RunSqlReturnDS(sql, this.GetConnectionName()).Tables[0];

            result.LoadFromDataView(table.DefaultView);

            return(result);
        }
Beispiel #11
0
        /// <summary>
        /// 根据AppCodeName和Permission的CodeName查询出对应的角色
        /// </summary>
        /// <param name="schemaTypes"></param>
        /// <param name="appCodeName"></param>
        /// <param name="permissionCodeNames"></param>
        /// <param name="includingDeleted"></param>
        /// <param name="timePoint"></param>
        /// <returns></returns>
        public SchemaObjectCollection QueryPermissionRolesByCodeName(string[] schemaTypes, string appCodeName, string[] permissionCodeNames, bool includingDeleted, DateTime timePoint)
        {
            SchemaObjectCollection result = null;

            if (appCodeName.IsNotEmpty() && permissionCodeNames != null && permissionCodeNames.Length > 0)
            {
                InSqlClauseBuilder schemaTypeBuilder = new InSqlClauseBuilder("M.MemberSchemaType");

                schemaTypeBuilder.AppendItem(schemaTypes);

                WhereSqlClauseBuilder codeBuilder = new WhereSqlClauseBuilder();

                codeBuilder.AppendItem("A.CodeName", appCodeName);

                InSqlClauseBuilder permissionCodeTypeBuilder = new InSqlClauseBuilder("P.CodeName");

                permissionCodeTypeBuilder.AppendItem(permissionCodeNames);

                result = QueryPermissionRolesByBuilder(new ConnectiveSqlClauseCollection(schemaTypeBuilder, codeBuilder, permissionCodeTypeBuilder), includingDeleted, timePoint);
            }
            else
            {
                result = new SchemaObjectCollection();
            }

            return(result);
        }
		public bool ValidateGroups(DateTime timePoint)
		{
			InSqlClauseBuilder inSql1 = new InSqlClauseBuilder("ChildSchemaType");
			inSql1.AppendItem(SchemaInfo.FilterByCategory("Groups").ToSchemaNames());

			InSqlClauseBuilder inSql2 = new InSqlClauseBuilder("ParentSchemaType");
			inSql2.AppendItem(SchemaInfo.FilterByCategory("Organizations").ToSchemaNames());


			var all = new ConnectiveSqlClauseCollection(inSql1, inSql2, VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint));

			string sql = string.Format(@"SELECT TOP 1 1 from SC.SchemaRelationObjects WHERE ObjectID IN(
SELECT ObjectID FROM SC.SchemaRelationObjects WHERE {0} AND STATUS =1
GROUP by ObjectID
HAVING COUNT(ParentID) <>1 
)", all.ToSqlString(TSqlBuilder.Instance));

			using (DbContext context = DbContext.GetContext(this.GetConnectionName()))
			{
				Database db = DatabaseFactory.Create(context);
				using (var dr = db.ExecuteReader(CommandType.Text, sql))
				{
					if (dr.Read())
					{
						return false;
					}
					else
					{
						return true;
					}
				}
			}

		}
Beispiel #13
0
        protected override void AfterLoad(WfMatrixDefinitionCollection data)
        {
            if (data.Count == 0)
            {
                return;
            }

            InSqlClauseBuilder builder = new InSqlClauseBuilder("MATRIX_DEF_KEY");

            data.ForEach(md => builder.AppendItem(md.Key));

            string sql = string.Format("SELECT * FROM WF.MATRIX_DIMENSION_DEFINITION WHERE {0} ORDER BY MATRIX_DEF_KEY, SORT_ORDER",
                                       builder.AppendTenantCodeSqlClause(typeof(WfMatrixDefinition)).ToSqlString(TSqlBuilder.Instance));

            DataTable table = DbHelper.RunSqlReturnDS(sql, GetConnectionName()).Tables[0];

            foreach (DataRow row in table.Rows)
            {
                WfMatrixDimensionDefinition dd = new WfMatrixDimensionDefinition();

                ORMapping.DataRowToObject(row, dd);

                WfMatrixDefinition matrixDefinition = data.Find(md => string.Compare(md.Key, dd.MatrixKey, true) == 0);

                if (matrixDefinition != null)
                {
                    matrixDefinition.Dimensions.Add(dd);
                }
            }
        }
Beispiel #14
0
        public int Delete(string[] ids)
        {
            InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("JOB_ID");

            inBuilder.AppendItem(ids);

            int result = 0;

            if (inBuilder.Count > 0)
            {
                string where = inBuilder.ToSqlString(TSqlBuilder.Instance);

                StringBuilder sqlString = new StringBuilder();

                sqlString.AppendFormat("DELETE FROM WF.JOB_SCHEDULES WHERE {0} ", where);
                sqlString.Append(TSqlBuilder.Instance.DBStatementSeperator);

                sqlString.AppendFormat("DELETE FROM WF.JOB_INVOKE_SERVICE WHERE {0} ", where);
                sqlString.Append(TSqlBuilder.Instance.DBStatementSeperator);

                sqlString.AppendFormat("DELETE FROM WF.JOB_START_WORKFLOW WHERE {0} ", where);
                sqlString.Append(TSqlBuilder.Instance.DBStatementSeperator);

                sqlString.AppendFormat("DELETE WF.JOBS WHERE {0} ", where);

                result = DbHelper.RunSqlWithTransaction(sqlString.ToString(), this.GetConnectionName());
            }

            return(result);
        }
        /// <summary>
        /// 获取一个或多个终端节点的父机构
        /// </summary>
        /// <param name="timePoint">时间点</param>
        /// <param name="terminalIds">终结点ID的数组</param>
        /// <returns>表示对象ID,和容器ID的关系。</returns>
        public IEnumerable <System.Collections.Generic.KeyValuePair <string, string> > GetOwnerships(DateTime timePoint, string[] terminalIds)
        {
            string             sql       = @"SELECT R.ObjectID,R.ParentID FROM 
SC.SchemaRelationObjectsSnapshot R
WHERE ";
            InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("R.ObjectID");

            inBuilder.AppendItem(terminalIds);

            WhereSqlClauseBuilder whereBuilder = new WhereSqlClauseBuilder();

            var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "R.");

            whereBuilder.AppendItem("R.Status", (int)SchemaObjectStatus.Normal);
            whereBuilder.AppendItem("R.ParentSchemaType", "Organizations");

            ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(inBuilder, whereBuilder, timeCondition);

            sql += connectiveBuilder.ToSqlString(TSqlBuilder.Instance) + " ORDER BY R.ObjectID ASC";
            var ds = DbHelper.RunSqlReturnDS(sql, this.GetConnectionName());

            foreach (System.Data.DataRow row in ds.Tables[0].Rows)
            {
                yield return(new System.Collections.Generic.KeyValuePair <string, string>(row["ObjectID"] as string, row["ParentID"] as string));
            }
        }
        /// <summary>
        /// 根据代码名称,<see cref="IConnectiveSqlClause"/>指定的条件和时间点载入对象
        /// </summary>
        /// <param name="conditionAction">要在构造条件时执行的操作</param>
        /// <param name="timePoint">时间点</param>
        /// <param name="codeNames">代码名称</param>
        /// <returns>一个<see cref="SchemaObjectCollection"/>,包含条件指定的对象。</returns>
        public SchemaObjectCollection LoadByCodeName(Action <ConnectiveSqlClauseCollection> conditionAction, DateTime timePoint, params string[] codeNames)
        {
            var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "O.");

            var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "S.");

            InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("S.CodeName");

            inBuilder.AppendItem(codeNames);

            SchemaObjectCollection result = null;

            if (inBuilder.IsEmpty == false)
            {
                var conditions = new ConnectiveSqlClauseCollection(inBuilder, timeCondition, timeCondition2);

                if (conditionAction != null)
                {
                    conditionAction(conditions);
                }

                result = this.LoadByCodeNameInner(conditions);
            }
            else
            {
                result = new SchemaObjectCollection();
            }

            return(result);
        }
        /// <summary>
        /// 检查数据的状态
        /// </summary>
        /// <param name="objsToCheck"></param>
        protected void CheckObjectStatus(params DEEntityInstanceBase[] objsToCheck)
        {
            List <DEEntityInstanceBase> normalizedObjsToCheck = new List <DEEntityInstanceBase>();

            InSqlClauseBuilder idBuilder = new InSqlClauseBuilder("ID");

            normalizedObjsToCheck.ForEach(o => idBuilder.AppendItem(o.ID));

            if (idBuilder.IsEmpty == false)
            {
                DEEntityInstanceBaseCollection originalDataList = DEInstanceAdapter.Instance.Load(idBuilder);

                string opName = EnumItemDescriptionAttribute.GetDescription(this.OperationType);

                foreach (DEEntityInstanceBase objToCheck in normalizedObjsToCheck)
                {
                    if (originalDataList.ContainsKey(objToCheck.ID) == false)
                    {
                        throw new DEStatusCheckException(string.Format("ID为\"{0}\"的对象不存在,不能执行{1}操作", objToCheck.ID, opName));
                    }

                    DEEntityInstanceBase originalData = originalDataList[objToCheck.ID];

                    if (originalData.Status != SchemaObjectStatus.Normal)
                    {
                        throw new DEStatusCheckException(string.Format("ID为\"{0}\"动态实体对象状态不正常,不能执行{1}操作", objToCheck.ID, opName));
                    }
                }
            }
        }
        /// <summary>
        /// 根据ID载入对象
        /// </summary>
        /// <param name="ids">对象的ID</param>
        /// <param name="schemaType">不为<see langword="null"/>时,限定对象的类型</param>
        /// <param name="normalOnly">如果为true,仅包含正常对象</param>
        /// <returns></returns>
        public static SchemaObjectCollection LoadObjects(string[] ids, string schemaType, bool normalOnly)
        {
            if (ids.Length > 0)
            {
                WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
                if (normalOnly)
                {
                    where.AppendItem("Status", (int)SchemaObjectStatus.Normal);
                }

                if (schemaType != null)
                {
                    where.AppendItem("SchemaType", schemaType);
                }

                InSqlClauseBuilder idIn = new InSqlClauseBuilder("ID");
                idIn.AppendItem(ids);

                return(Adapters.SchemaObjectAdapter.Instance.Load(new ConnectiveSqlClauseCollection(where, idIn), DateTime.MinValue));
            }
            else
            {
                return(new SchemaObjectCollection());
            }
        }
        public void ClearDbErrors()
        {
            var schemaUsers = SchemaInfo.FilterByCategory("Users").ToSchemaNames();

            InSqlClauseBuilder containerSchemaInSql = new InSqlClauseBuilder("ContainerSchemaType");

            containerSchemaInSql.AppendItem(schemaUsers);

            InSqlClauseBuilder memberSchemaInSql = new InSqlClauseBuilder("MemberSchemaType");

            containerSchemaInSql.AppendItem(schemaUsers);

            string sql = string.Format(@"
DELETE FROM SC.SchemaMembers
WHERE ContainerID = MemberID
AND {0}

DELETE FROM SC.SchemaMembersSnapshot
WHERE ContainerID = MemberID
AND {0}

DELETE FROM SC.SchemaMembersSnapshot_Current
WHERE ContainerID = MemberID
AND {0}

", new ConnectiveSqlClauseCollection(containerSchemaInSql, memberSchemaInSql).ToSqlString(TSqlBuilder.Instance));

            DbHelper.RunSql(sql, this.GetConnectionName());
        }
        /// <summary>
        /// 载入指定ID对象的成员关系
        /// </summary>
        /// <param name="containerIDs">对象的ID,其成员的关系将被获取。</param>
        /// <param name="containerSchemaType">当不为<see langword="null"/>时,限定容器的模式类型</param>
        /// <param name="memberSchemaType">当不为<see langword="null"/>时,限定容器成员的模式类型</param>
        /// <param name="normalOnly">当为true时,仅筛选关系正常的对象</param>
        /// <returns></returns>
        public static SCMemberRelationCollection LoadMembershipOf(string[] containerIDs, string containerSchemaType, string memberSchemaType, bool normalOnly)
        {
            if (containerIDs.Length > 0)
            {
                var mInsql = new InSqlClauseBuilder("ContainerID");
                mInsql.AppendItem(containerIDs);

                var mWhere = new WhereSqlClauseBuilder();
                mWhere.AppendItem("Status", (int)SchemaObjectStatus.Normal);

                if (containerSchemaType != null)
                {
                    mWhere.AppendItem("ContainerSchemaType", containerSchemaType);
                }

                if (memberSchemaType != null)
                {
                    mWhere.AppendItem("MemberSchemaType", memberSchemaType);
                }

                var mAllConditions = new ConnectiveSqlClauseCollection(mInsql, mWhere);

                return(Adapters.SCMemberRelationAdapter.Instance.Load(mAllConditions, DateTime.MinValue));
            }
            else
            {
                return(new SCMemberRelationCollection());
            }
        }
		protected void CheckObjectStatus(params SchemaObjectBase[] objsToCheck)
		{
			List<SchemaObjectBase> normalizedObjsToCheck = new List<SchemaObjectBase>();

			foreach (SchemaObjectBase obj in objsToCheck)
			{
				if (obj.ID != SCOrganization.RootOrganizationID)
					normalizedObjsToCheck.Add(obj);
			}

			InSqlClauseBuilder idBuilder = new InSqlClauseBuilder("ID");

			normalizedObjsToCheck.ForEach(o => idBuilder.AppendItem(o.ID));

			if (idBuilder.IsEmpty == false)
			{
				SchemaObjectCollection originalDataList = SchemaObjectAdapter.Instance.Load(idBuilder);

				string opName = EnumItemDescriptionAttribute.GetDescription(this.OperationType);

				foreach (SchemaObjectBase objToCheck in normalizedObjsToCheck)
				{
					if (originalDataList.ContainsKey(objToCheck.ID) == false)
						throw new SCStatusCheckException(string.Format("ID为\"{0}\"的对象不存在,不能执行{1}操作", objToCheck.ID, opName));

					SchemaObjectBase originalData = originalDataList[objToCheck.ID];

					if (originalData.Status != SchemaObjectStatus.Normal)
						throw new SCStatusCheckException(originalData, this.OperationType);
				}
			}
		}
        public static SCMemberRelationCollection LoadFullMemberships(string[] ids, bool normalOnly)
        {
            if (ids == null)
            {
                throw new ArgumentNullException("ids");
            }

            if (ids.Length > 0)
            {
                var idsParent = new InSqlClauseBuilder("ContainerID");
                idsParent.AppendItem(ids);

                var idsChild = new InSqlClauseBuilder("MemberID");
                idsChild.AppendItem(ids);

                var idConditions = new ConnectiveSqlClauseCollection(LogicOperatorDefine.Or, idsParent, idsChild);

                var builder = new WhereSqlClauseBuilder();
                if (normalOnly)
                {
                    builder.AppendItem("Status", (int)SchemaObjectStatus.Normal);
                }

                return(Adapters.SCMemberRelationAdapter.Instance.Load(new ConnectiveSqlClauseCollection(idConditions, builder), DateTime.MinValue));
            }
            else
            {
                return(new SCMemberRelationCollection());
            }
        }
        private void FillAllChildrenRelationsRecursively(SCSimpleRelationObjectCollection relations, InSqlClauseBuilder builder, LoadingRelationsRecursivelyHandler handler, object context)
        {
            if (builder.Count > 0)
            {
                string sql = string.Format("SELECT ParentID, ObjectID FROM {0} WHERE {1} AND VersionStartTime <= GETDATE() AND VersionEndTime > GETDATE() AND STATUS = 1",
                                           GetMappingInfo().TableName, builder.ToSqlStringWithInOperator(TSqlBuilder.Instance));

                DataTable table = DbHelper.RunSqlReturnDS(sql, this.GetConnectionName()).Tables[0];

                SCSimpleRelationObjectCollection tempRelations = new SCSimpleRelationObjectCollection();

                ORMapping.DataViewToCollection(tempRelations, table.DefaultView);

                InSqlClauseBuilder subBuilder = new InSqlClauseBuilder("ParentID");

                foreach (SCSimpleRelationObject r in tempRelations)
                {
                    subBuilder.AppendItem(r.ID);
                    relations.Add(r);
                }

                if (handler != null)
                {
                    handler(tempRelations, context);
                }

                FillAllChildrenRelationsRecursively(relations, subBuilder, handler, context);
            }
        }
Beispiel #24
0
        public JobScheduleWithJobIDCollection LoadByJobID(params string[] jobIDs)
        {
            jobIDs.NullCheck("jobIDs");

            InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("JOB_ID");

            inBuilder.AppendItem(jobIDs);

            JobScheduleWithJobIDCollection result = null;

            if (inBuilder.Count > 0)
            {
                ConnectiveSqlClauseCollection builder = new ConnectiveSqlClauseCollection(inBuilder,
                                                                                          new WhereSqlClauseBuilder().AppendTenantCode(typeof(JobSchedule)));

                string sql = string.Format(QUERY_SCHEDULE_DEF_BY_JOB_ID_SQL_CLAUSE,
                                           builder.ToSqlString(TSqlBuilder.Instance));

                result = QueryData <JobScheduleWithJobID, JobScheduleWithJobIDCollection>(
                    ORMapping.GetMappingInfo <JobScheduleWithJobID>(), sql);
            }
            else
            {
                result = new JobScheduleWithJobIDCollection();
            }

            return(result);
        }
        private static void FillAssignees(WfProcessCurrentInfoCollection result)
        {
            InSqlClauseBuilder inBuilder = new InSqlClauseBuilder();

            result.ForEach(currentInfo => inBuilder.AppendItem(currentInfo.CurrentActivityID));

            if (inBuilder.Count > 0)
            {
                string sql = string.Format("SELECT * FROM WF.PROCESS_CURRENT_ASSIGNEES WHERE ACTIVITY_ID {0} ORDER BY ID",
                                           inBuilder.ToSqlStringWithInOperator(TSqlBuilder.Instance));

                DataTable table = DbHelper.RunSqlReturnDS(sql, GetConnectionName()).Tables[0];

                DataView assigneeView = new DataView(table);

                assigneeView.Sort = "ACTIVITY_ID";

                foreach (var currentInfo in result)
                {
                    DataRowView[] rows = assigneeView.FindRows(currentInfo.CurrentActivityID);

                    Array.ForEach(rows, drv =>
                    {
                        currentInfo.Assignees.Add(DataRowToAssignee(drv.Row));
                    });
                }
            }
        }
        public bool ValidateGroups(DateTime timePoint)
        {
            InSqlClauseBuilder inSql1 = new InSqlClauseBuilder("ChildSchemaType");

            inSql1.AppendItem(SchemaInfo.FilterByCategory("Groups").ToSchemaNames());

            InSqlClauseBuilder inSql2 = new InSqlClauseBuilder("ParentSchemaType");

            inSql2.AppendItem(SchemaInfo.FilterByCategory("Organizations").ToSchemaNames());


            var all = new ConnectiveSqlClauseCollection(inSql1, inSql2, VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint));

            string sql = string.Format(@"SELECT TOP 1 1 from SC.SchemaRelationObjects WHERE ObjectID IN(
SELECT ObjectID FROM SC.SchemaRelationObjects WHERE {0} AND STATUS =1
GROUP by ObjectID
HAVING COUNT(ParentID) <>1 
)", all.ToSqlString(TSqlBuilder.Instance));

            using (DbContext context = DbContext.GetContext(this.GetConnectionName()))
            {
                Database db = DatabaseFactory.Create(context);
                using (var dr = db.ExecuteReader(CommandType.Text, sql))
                {
                    if (dr.Read())
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }
                }
            }
        }
Beispiel #27
0
        /// <summary>
        /// 按照In条件加载对象
        /// </summary>
        /// <param name="inAction"></param>
        /// <param name="orderByAction"></param>
        /// <returns></returns>
        public TCollection LoadByInBuilder(Action <InSqlClauseBuilder> inAction, Action <OrderBySqlClauseBuilder> orderByAction)
        {
            inAction.NullCheck("whereAction");

            InSqlClauseBuilder builder = new InSqlClauseBuilder();

            inAction(builder);

            string condition = string.Empty;

            if (builder.Count > 0)
            {
                condition = builder.ToSqlStringWithInOperator(TSqlBuilder.Instance);
            }

            OrderBySqlClauseBuilder orderByBuilder = null;

            if (orderByAction != null)
            {
                orderByBuilder = new OrderBySqlClauseBuilder();

                orderByAction(orderByBuilder);
            }

            return(InnerLoadByBuilder(condition, orderByBuilder));
        }
		public UserTaskCollection LoadUserTasksByActivity(string activityID, Action<InSqlClauseBuilder> action)
		{
			action.NullCheck("action");

			InSqlClauseBuilder builder = new InSqlClauseBuilder();

			action(builder);

			string sql = string.Format("SELECT * FROM WF.USER_TASK WHERE ACTIVITY_ID = {0}",
				TSqlBuilder.Instance.CheckUnicodeQuotationMark(activityID));

			if (builder.Count > 0)
				sql += " AND " + builder.ToSqlStringWithInOperator(TSqlBuilder.Instance);

			UserTaskCollection result = new UserTaskCollection();

			DataTable table = DbHelper.RunSqlReturnDS(sql, GetConnectionName()).Tables[0];

			foreach (DataRow row in table.Rows)
			{
				UserTask task = new UserTask();

				ORMapping.DataRowToObject(row, task);

				result.Add(task);
			}

			return result;
		}
Beispiel #29
0
        public DataSet GetUserRoles2(string userValue, string appCodeName, UserValueType userValueType, RightMaskType rightMask, DelegationMaskType delegationMask, bool includeMatrixUsers)
        {
            string[] schemaTypes = SchemaInfo.FilterByCategory("Roles").ToSchemaNames();
            string[] userIDs     = OGUReaderService.SplitObjectValues(userValue);

            SCObjectAndRelationCollection users = OGUReaderService.GetSearchAdapter(GetSearchOUIDType(userValueType), SchemaInfo.FilterByCategory("Users").ToSchemaNames(), userIDs, false).QueryObjectsAndRelations();

            SchemaObjectCollection roles = SCSnapshotAdapter.Instance.QueryUserBelongToRoles(schemaTypes, appCodeName, users.ToIDArray(), false, DateTime.MinValue);

            if (includeMatrixUsers)
            {
                List <string> matachedRoleIDs = GetUserRoleIDsInMatrix(users.ToIDArray(), appCodeName);

                //过滤掉已经在之前查询过的角色
                matachedRoleIDs = matachedRoleIDs.FindAll(rID => roles.ContainsKey(rID) == false);

                if (matachedRoleIDs.Count > 0)
                {
                    InSqlClauseBuilder matrixRoleBuilder = new InSqlClauseBuilder("ID");

                    matrixRoleBuilder.AppendItem(matachedRoleIDs.ToArray());
                    SchemaObjectCollection rolesInMatrix = SchemaObjectAdapter.Instance.Load(matrixRoleBuilder, DateTime.MinValue);

                    rolesInMatrix.ForEach(rMatrix => roles.AddNotExistsItem(rMatrix, (r) => string.Compare(r.ID, rMatrix.ID, true) == 0));
                }
            }

            DataSet ds = new DataSet();

            ds.Tables.Add(QueryHelper.GetAppObjectTableBuilder(schemaTypes).Convert(roles));

            return(ds);
        }
Beispiel #30
0
        public SchemaObjectCollection LoadScopeItems(string[] ids, string scopeType, bool normalOnly, DateTime timePoint)
        {
            ids.NullCheck("ids");

            string sql = "SELECT * FROM SC.SchemaObject WHERE ";

            if (ids.Length > 0)
            {
                InSqlClauseBuilder inSql = new InSqlClauseBuilder("ID").AppendItem(ids);;
                WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
                if (normalOnly)
                {
                    where.NormalFor("Status");
                }

                where.AppendItem("SchemaType", scopeType);
                var timeBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint);
                sql += new ConnectiveSqlClauseCollection(inSql, timeBuilder, where).ToSqlString(TSqlBuilder.Instance);

                return(LoadSchemaObjects(sql));
            }
            else
            {
                return(new SchemaObjectCollection());
            }
        }
        public SchemaObjectCollection QueryApplications(string[] schemaTypes, bool includingDeleted, DateTime timePoint)
        {
            SchemaObjectCollection result = new SchemaObjectCollection();

            ConnectiveSqlClauseCollection timeConditionC = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "SC.");

            InSqlClauseBuilder schemaBuilder = new InSqlClauseBuilder("SC.SchemaType");

            schemaBuilder.AppendItem(schemaTypes);

            WhereSqlClauseBuilder builderC = new WhereSqlClauseBuilder();

            if (includingDeleted == false)
                builderC.AppendItem("SC.Status", (int)SchemaObjectStatus.Normal);

            ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(schemaBuilder, builderC, timeConditionC);

            string sql = string.Format("SELECT SC.*" +
                "\nFROM SC.SchemaObject SC" +
                "\nWHERE {0}", connectiveBuilder.ToSqlString(TSqlBuilder.Instance));

            DataTable table = DbHelper.RunSqlReturnDS(sql, this.GetConnectionName()).Tables[0];

            result.LoadFromDataView(table.DefaultView);

            return result;
        }
		public SchemaObjectCollection LoadAUScope(string auID, string[] scopes, bool normalOnly, DateTime timePoint)
		{
			auID.NullCheck("auID");
			scopes.NullCheck("scopes");

			if (scopes.Length > 0)
			{
				WhereSqlClauseBuilder where = new WhereSqlClauseBuilder().NormalFor("O.Status").NormalFor("S.Status");
				where.AppendCondition("R.ContainerID", auID);
				where.NormalFor("R.Status");

				InSqlClauseBuilder inSql = new InSqlClauseBuilder("S.ScopeSchemaType");
				inSql.AppendItem(scopes);

				if (normalOnly)
				{
					where.NormalFor("O.Status");
				}

				return LoadAUScope(new ConnectiveSqlClauseCollection(where, inSql), timePoint);
			}
			else
			{
				return new SchemaObjectCollection();
			}
		}
Beispiel #33
0
        internal static SCRelationObjectCollection LoadCurrentParentRelations(string[] objectIDs, string[] parentSchemaTypes)
        {
            InSqlClauseBuilder insql = new InSqlClauseBuilder("ParentSchemaType");

            insql.AppendItem(parentSchemaTypes);

            WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
            where.AppendItem("Status", (int)SchemaObjectStatus.Normal);
            ConnectiveSqlClauseCollection conditions;

            if (objectIDs.Length == 1)
            {
                where.AppendItem("ObjectID", objectIDs[0]);
                conditions = new ConnectiveSqlClauseCollection(where, insql);
            }
            else
            {
                InSqlClauseBuilder insql2 = new InSqlClauseBuilder("ObjectID");
                insql2.AppendItem(objectIDs);

                conditions = new ConnectiveSqlClauseCollection(where, insql, insql2);
            }

            return(PC.Adapters.SchemaRelationObjectAdapter.Instance.Load(conditions, DateTime.MinValue));
        }
        public int Delete(string[] ids)
        {
            InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("JOB_ID");

            inBuilder.AppendItem(ids);

            int result = 0;

            if (inBuilder.Count > 0)
            {
                ConnectiveSqlClauseCollection builder = new ConnectiveSqlClauseCollection(inBuilder,
                                                                                          new WhereSqlClauseBuilder().AppendTenantCode(typeof(InvokeWebServiceJob)));

                string where = builder.ToSqlString(TSqlBuilder.Instance);

                StringBuilder sqlString = new StringBuilder();

                sqlString.AppendFormat("DELETE FROM WF.JOB_SCHEDULES WHERE {0} ", where);
                sqlString.Append(TSqlBuilder.Instance.DBStatementSeperator);

                sqlString.AppendFormat("DELETE FROM WF.JOB_INVOKE_SERVICE WHERE {0} ", where);
                sqlString.Append(TSqlBuilder.Instance.DBStatementSeperator);

                sqlString.AppendFormat("DELETE FROM WF.JOB_START_WORKFLOW WHERE {0} ", where);
                sqlString.Append(TSqlBuilder.Instance.DBStatementSeperator);

                sqlString.AppendFormat("DELETE WF.JOBS WHERE {0} ", where);

                result = DbHelper.RunSqlWithTransaction(sqlString.ToString());
            }

            return(result);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="inCondition"></param>
        /// <param name="action"></param>
        /// <param name="tableName"></param>
        /// <param name="mappings"></param>
        public void LoadByInBuilderInContext(InLoadingCondition inCondition, Action <TCollection> action, string tableName = null, ORMappingItemCollection mappings = null)
        {
            inCondition.NullCheck("inCondition");
            inCondition.BuilderAction.NullCheck("BuilderAction");

            InSqlClauseBuilder inBuilder = new InSqlClauseBuilder(inCondition.DataField);

            inCondition.BuilderAction(inBuilder);

            string condition = string.Empty;

            if (inBuilder.IsEmpty == false)
            {
                ConnectiveSqlClauseCollection builder = new ConnectiveSqlClauseCollection(LogicOperatorDefine.And,
                                                                                          inBuilder, new WhereSqlClauseBuilder().AppendTenantCode(typeof(T)));

                condition = builder.ToSqlString(TSqlBuilder.Instance);

                OrderBySqlClauseBuilder orderByBuilder = null;

                if (inCondition.OrderByAction != null)
                {
                    orderByBuilder = new OrderBySqlClauseBuilder();

                    inCondition.OrderByAction(orderByBuilder);
                }

                this.RegisterLoadByBuilderInContext(condition, orderByBuilder, action, tableName, mappings);
            }
        }
		public SCOperationLog Load(int id)
		{
			InSqlClauseBuilder builder = new InSqlClauseBuilder("ID");

			builder.AppendItem(id);

			return Load(builder).FirstOrDefault();
		}
Beispiel #37
0
		/// <summary>
		/// 根据userID和一组ContainerID,加载该Member所拥有的权限
		/// </summary>
		/// <param name="userID"></param>
		/// <param name="containerIDs"></param>
		/// <returns></returns>
		public SCContainerAndPermissionCollection LoadCurrentContainerAndPermissions(string userID, IEnumerable<string> containerIDs)
		{
			var ids = containerIDs.ToArray();
			SCContainerAndPermissionCollection result = null;

			var roleIDs = (from r in new OguUser(userID).Roles.GetAllRoles() select r.ID).ToArray();

			if (ids.Length > 0 && roleIDs.Length > 0)
			{
				var timeConditon1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("A.");
				var condition = new WhereSqlClauseBuilder();
				condition.AppendItem("A.Status", (int)SchemaObjectStatus.Normal);

				InSqlClauseBuilder inSql = new InSqlClauseBuilder("A.ContainerID");
				inSql.AppendItem(ids);

				InSqlClauseBuilder inSqlRole = new InSqlClauseBuilder("A.MemberID");
				inSqlRole.AppendItem(roleIDs);

				var sql = string.Format(
					"SELECT A.* FROM SC.Acl_Current A WHERE {0} ORDER BY SortID ",
					new ConnectiveSqlClauseCollection(timeConditon1, condition, inSql, inSqlRole).ToSqlString(TSqlBuilder.Instance));

				result = new SCContainerAndPermissionCollection();

				AUCommon.DoDbAction(() =>
				{
					using (DbContext context = DbContext.GetContext(this.GetConnectionName()))
					{
						using (IDataReader reader = DbHelper.RunSqlReturnDR(sql, this.GetConnectionName()))
						{
							while (reader.Read())
							{
								string containerID = (string)reader["ContainerID"];
								string permission = (string)reader["ContainerPermission"];

								if (result.ContainsKey(containerID, permission) == false)
								{
									result.Add(new SCContainerAndPermission()
									{
										ContainerID = containerID,
										ContainerPermission = permission
									});
								}
							}
						}
					}
				});

				return result;
			}
			else
			{
				result = new SCContainerAndPermissionCollection();
			}

			return result;
		}
        /// <summary>
        /// 查询应用中的角色
        /// </summary>
        /// <param name="schemaTypes"></param>
        /// <param name="appCodeName"></param>
        /// <param name="includingDeleted"></param>
        /// <param name="timePoint"></param>
        /// <returns></returns>
        public SchemaObjectCollection QueryApplicationObjectsByCodeName(string[] schemaTypes, string appCodeName, bool includingDeleted, DateTime timePoint)
        {
            InSqlClauseBuilder schemaTypeBuilder = new InSqlClauseBuilder("M.MemberSchemaType");

            schemaTypeBuilder.AppendItem(schemaTypes);

            WhereSqlClauseBuilder codeBuilder = new WhereSqlClauseBuilder();

            codeBuilder.AppendItem("A.CodeName", appCodeName);

            return QueryApplicationObjectsByBuilder(new ConnectiveSqlClauseCollection(schemaTypeBuilder, codeBuilder), includingDeleted, timePoint);
        }
		private void InitAllUsers()
		{
			InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("SchemaType");

			SchemaDefineCollection schemas = SchemaExtensions.CreateSchemasDefineFromConfiguration();

			schemas.ForEach(schema =>
			{
				if (string.Compare(schema.Category, "Users", true) == 0)
					inBuilder.AppendItem(schema.Name);
			});

			this._AllUsers = SchemaObjectAdapter.Instance.Load(inBuilder);
		}
        private static void eventContainer_SetUserTasksAccomplished(UserTaskCollection tasks, Dictionary<object, object> context)
        {
            ExceptionHelper.FalseThrow<ArgumentNullException>(tasks != null, "tasks");

            //需要删除的待办的ID
            InSqlClauseBuilder deleteTaskIDs = new InSqlClauseBuilder();

            StringBuilder strB = new StringBuilder();

            ORMappingItemCollection mapping = ORMapping.GetMappingInfo<UserTask>().Clone();

            string userTaskTableName = mapping.TableName;

            mapping.TableName = "WF.USER_ACCOMPLISHED_TASK";

            foreach (UserTask task in tasks)
            {
                UserTask clonedUserTask = GetClonedAccomplishedUserTask(task);

                if (strB.Length > 0)
                    strB.Append(TSqlBuilder.Instance.DBStatementSeperator);

                WhereSqlClauseBuilder builder = GetDeleteAccomplishedUserTaskWhereBuilder(task);

                //删除已办
                strB.AppendFormat("DELETE {0} WHERE {1}",
                    mapping.TableName,
                    builder.ToSqlString(TSqlBuilder.Instance));

                strB.Append(TSqlBuilder.Instance.DBStatementSeperator);

                strB.Append(GetUserTaskInsertSql(clonedUserTask, mapping, "Category", "TopFlag"));

                strB.Append(TSqlBuilder.Instance.DBStatementSeperator);

                deleteTaskIDs.AppendItem(task.TaskID);
            }

            if (strB.Length > 0 && deleteTaskIDs.IsEmpty == false)
            {
                //删除待办
                strB.AppendFormat("DELETE {0} WHERE TASK_GUID {1}",
                    userTaskTableName,
                    deleteTaskIDs.ToSqlStringWithInOperator(TSqlBuilder.Instance));
            }

            if (strB.Length > 0)
                DbHelper.RunSqlWithTransaction(strB.ToString(), GetConnectionName());
        }
        private static void eventContainer_DeleteUserTasks(UserTaskCollection tasks, Dictionary<object, object> context)
        {
            ExceptionHelper.FalseThrow<ArgumentNullException>(tasks != null, "tasks");

            InSqlClauseBuilder builder = new InSqlClauseBuilder();

            tasks.ForEach(u => builder.AppendItem(u.TaskID));

            if (builder.Count > 0)
            {
                string sql = string.Format("DELETE WF.USER_TASK WHERE TASK_GUID {0}", builder.ToSqlStringWithInOperator(TSqlBuilder.Instance));

                DbHelper.RunSql(sql, GetConnectionName());
            }
        }
		/// <summary>
		/// 根据ID和时间点载入所有父级关系
		/// </summary>
		/// <param name="ids">子级ID</param>
		/// <param name="includingSelf">结果中是否包含自己</param>
		/// <param name="timePoint"></param>
		/// <returns></returns>
		public Dictionary<string, SCSimpleObjectCollection> LoadAllParentsInfo(string[] ids, bool includingSelf, DateTime timePoint)
		{
			ids.NullCheck("ids");

			Dictionary<string, SCSimpleObjectCollection> result = new Dictionary<string, SCSimpleObjectCollection>(ids.Length, StringComparer.OrdinalIgnoreCase);

			if (ids.Length > 0)
			{
				string sqlTemplate = ResourceHelper.LoadStringFromResource(Assembly.GetExecutingAssembly(),
					"MCS.Library.SOA.DataObjects.Security.Adapters.Templates.LoadAllParentInfo.sql");

				string timeString = TSqlBuilder.Instance.DBCurrentTimeFunction;

				if (timePoint != DateTime.MinValue)
					timeString = TSqlBuilder.Instance.FormatDateTime(timePoint);

				InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("ID");

				inBuilder.AppendItem(ids);

				string sql = string.Format(sqlTemplate, timeString, inBuilder.ToSqlStringWithInOperator(TSqlBuilder.Instance));

				DataTable table = DbHelper.RunSqlReturnDS(sql, this.GetConnectionName()).Tables[0];
				DataView view = new DataView(table);

				view.Sort = "ID";

				foreach (string id in ids)
				{
					if (result.ContainsKey(id) == false)
					{
						SCSimpleObjectCollection tempParents = new SCSimpleObjectCollection();

						FillAllParents(id, view, includingSelf, tempParents);

						SCSimpleObjectCollection parents = new SCSimpleObjectCollection();

						//转换次序
						for (int i = tempParents.Count - 1; i >= 0; i--)
							parents.Add(tempParents[i]);

						result.Add(id, parents);
					}
				}
			}

			return result;
		}
		protected override void OnBuildQueryCondition(QueryCondition qc)
		{
			qc.FromClause = (TimePointContext.Current.UseCurrentTime ?
				"SC.SchemaGroupSnapshot_Current G INNER JOIN SC.SchemaRelationObjectsSnapshot_Current R ON G.ID = R.ObjectID "
				: "SC.SchemaGroupSnapshot G INNER JOIN SC.SchemaRelationObjectsSnapshot R ON G.ID = R.ObjectID ");

			if (this.fileterRole)
			{
				qc.FromClause += TimePointContext.Current.UseCurrentTime ?
					" LEFT JOIN SC.Acl_Current AC ON AC.ContainerID = R.ParentID INNER JOIN SC.SchemaRoleSnapshot_Current RS ON RS.ID = AC.MemberID INNER JOIN SC.UserAndContainerSnapshot_Current UC ON RS.ID = UC.ContainerID " :
					" LEFT JOIN SC.Acl AC ON AC.ContainerID = R.ParentID INNER JOIN SC.SchemaRoleSnapshot RS ON RS.ID = AC.MemberID INNER JOIN SC.UserAndContainerSnapshot UC ON RS.ID = UC.ContainerID ";
			}

			qc.SelectFields = "G.*,R.ParentID";
			if (qc.OrderByClause.IsNullOrEmpty())
				qc.OrderByClause = "R.InnerSort DESC";

			qc.WhereClause.IsNotEmpty((s) => qc.WhereClause += " AND ");

			var timeConditionS = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("G.");

			var timeConditionR = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("R.");

			WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();

			builder.AppendItem("R.Status", (int)SchemaObjectStatus.Normal);
			builder.AppendItem("G.Status", (int)SchemaObjectStatus.Normal);

			var allConditions = new ConnectiveSqlClauseCollection(timeConditionS, timeConditionR, builder);

			if (this.fileterRole)
			{
				allConditions.Add(VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("AC."));
				allConditions.Add(VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("RS."));
				allConditions.Add(VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("UC."));
				builder.AppendItem("AC.Status", (int)SchemaObjectStatus.Normal);
				builder.AppendItem("RS.Status", (int)SchemaObjectStatus.Normal);
				builder.AppendItem("UC.Status", (int)SchemaObjectStatus.Normal);
				builder.AppendItem("UC.UserID", this.userID);

				InSqlClauseBuilder inSql1 = new InSqlClauseBuilder("AC.ContainerPermission");
				inSql1.AppendItem(this.parentPermissions);
				allConditions.Add(inSql1);
			}

			qc.WhereClause += allConditions.ToSqlString(TSqlBuilder.Instance);
		}
		public static Conditions.SCConditionCollection LoadConditions(string[] ids)
		{
			if (ids.Length > 0)
			{
				var mIdIn = new InSqlClauseBuilder("OwnerID");
				mIdIn.AppendItem(ids);

				WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
				where.AppendItem("Status", (int)SchemaObjectStatus.Normal);

				return Adapters.SCConditionAdapter.Instance.Load(new ConnectiveSqlClauseCollection(mIdIn, where), DateTime.MinValue);
			}
			else
			{
				return new Conditions.SCConditionCollection();
			}
		}
		/// <summary>
		/// 载入指定对象的双向关系
		/// </summary>
		/// <param name="ids">对象的ID</param>
		/// <returns></returns>
		public static SCRelationObjectCollection LoadFullRelations(string[] ids)
		{
			if (ids == null || ids.Length == 0)
				throw new ArgumentNullException("ids");

			var idsParent = new InSqlClauseBuilder("ParentID");
			idsParent.AppendItem(ids);

			var idsChild = new InSqlClauseBuilder("ObjectID");
			idsChild.AppendItem(ids);

			var idConditions = new ConnectiveSqlClauseCollection(LogicOperatorDefine.Or, idsParent, idsChild);

			var builder = new WhereSqlClauseBuilder();
			builder.AppendItem("Status", (int)SchemaObjectStatus.Normal);

			return Adapters.SchemaRelationObjectAdapter.Instance.Load(new ConnectiveSqlClauseCollection(idConditions, builder), DateTime.MinValue);
		}
		internal static IConnectiveSqlClause SchemaTypeCondition(string fieldName, params string[] categories)
		{
			if (fieldName == null)
				throw new ArgumentNullException("field");

			if (categories != null && categories.Length == 1)
			{
				WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
				where.AppendItem(fieldName, categories[0]);
				return where;
			}
			else
			{
				InSqlClauseBuilder inSql = new InSqlClauseBuilder(fieldName);
				inSql.AppendItem(categories);
				return inSql;
			}
		}
		public void CheckUserInAcl(IUser user, IWfProcess process, ref bool continueCheck)
		{
			InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("RESOURCE_ID");

			inBuilder.AppendItem(process.ResourceID, process.ID);

			WhereSqlClauseBuilder whereBuilder = new WhereSqlClauseBuilder();

			whereBuilder.AppendItem("OBJECT_TYPE", "Users");
			whereBuilder.AppendItem("OBJECT_ID", user.ID);

			ConnectiveSqlClauseCollection connective = new ConnectiveSqlClauseCollection(inBuilder, whereBuilder);

			WfAclItemCollection aclItems = WfAclAdapter.Instance.LoadByBuilder(connective);

			(aclItems.Count > 0).FalseThrow(
							Translator.Translate(Define.DefaultCulture, "用户没有权限打开此文件"));
		}
        private void ExecuteQuery()
        {
            WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
            string appName = string.IsNullOrEmpty(txtApplicationName.Text) == true ? "全部" : txtApplicationName.Text;
            if (appName.IsNotEmpty())
            {
                if ("全部" == appName)
                {
                    if (!RolesDefineConfig.GetConfig().IsCurrentUserInRoles("ProcessAdmin"))
                    {
                        InSqlClauseBuilder inBuilder = new InSqlClauseBuilder();
                        inBuilder.AppendItem(AllApplicationNames());
                        builder.AppendItem("APPLICATION_NAME", inBuilder.ToSqlStringWithInOperator(TSqlBuilder.Instance), "", true);
                    }
                }
                else
                {
                    if ("其它" == appName)
                    {
                        builder.AppendItem("APPLICATION_NAME", " ");
                    }
                    else
                    {
                        builder.AppendItem("APPLICATION_NAME", appName);
                    }
                }
            }

            if (!string.IsNullOrEmpty(txtProgramName.Text))
                builder.AppendItem("PROGRAM_NAME", "%" + TSqlBuilder.Instance.CheckQuotationMark(txtProgramName.Text, false) + "%", "like");

            if (!string.IsNullOrEmpty(txtProcessKey.Text))
                builder.AppendItem("PROCESS_KEY", "%" + TSqlBuilder.Instance.CheckQuotationMark(txtProcessKey.Text, false) + "%", "like");

            if (!string.IsNullOrEmpty(txtProcessName.Text))
                builder.AppendItem("PROCESS_NAME", "%" + TSqlBuilder.Instance.CheckQuotationMark(txtProcessName.Text, false) + "%", "like");

            if (!string.IsNullOrEmpty(ddlEnabled.SelectedValue))
                builder.AppendItem("ENABLED", TSqlBuilder.Instance.CheckQuotationMark(ddlEnabled.SelectedValue, false));

            builder.AppendTenantCode();

            this.BindGrid(builder);
        }
		protected override void OnBuildQueryCondition(QueryCondition qc)
		{
			qc.FromClause = TimePointContext.Current.UseCurrentTime ? "SC.SchemaOrganizationSnapshot_Current O INNER JOIN SC.SchemaRelationObjectsSnapshot_Current R ON O.ID = R.ObjectID" : "SC.SchemaOrganizationSnapshot O INNER JOIN SC.SchemaRelationObjectsSnapshot R ON O.ID = R.ObjectID";

			if (this.fileterRole)
			{
				qc.FromClause += TimePointContext.Current.UseCurrentTime ?
					" INNER JOIN SC.Acl_Current AC ON AC.ContainerID = O.ID INNER JOIN SC.SchemaRoleSnapshot_Current RS ON RS.ID = AC.MemberID INNER JOIN SC.UserAndContainerSnapshot_Current UC ON RS.ID = UC.ContainerID "
					: " INNER JOIN SC.Acl AC ON AC.ContainerID = O.ID INNER JOIN SC.SchemaRoleSnapshot RS ON RS.ID = AC.MemberID INNER JOIN SC.UserAndContainerSnapshot UC ON RS.ID = UC.ContainerID ";
			}

			qc.SelectFields = "DISTINCT O.*,R.FullPath";

			if (string.IsNullOrEmpty(qc.OrderByClause))
				qc.OrderByClause = "R.InnerSort ASC";

			qc.WhereClause.IsNotEmpty((s) => qc.WhereClause += " AND ");

			WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
			builder.AppendItem("R.Status", (int)SchemaObjectStatus.Normal);
			builder.AppendItem("O.Status", (int)SchemaObjectStatus.Normal);
			var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("R.");
			var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("O.");
			var schemaCondition = DataSourceUtil.SchemaTypeCondition("R.ChildSchemaType", "Organizations");
			var allConditions = new ConnectiveSqlClauseCollection(builder, timeCondition, timeCondition2, schemaCondition);

			if (this.fileterRole && this.userID != null && this.permissions != null)
			{
				allConditions.Add(VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("AC."));
				allConditions.Add(VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("RS."));
				allConditions.Add(VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("UC."));
				builder.AppendItem("AC.Status", (int)SchemaObjectStatus.Normal);
				builder.AppendItem("RS.Status", (int)SchemaObjectStatus.Normal);
				builder.AppendItem("UC.Status", (int)SchemaObjectStatus.Normal);
				builder.AppendItem("UC.UserID", this.userID);

				InSqlClauseBuilder inSql1 = new InSqlClauseBuilder("AC.ContainerPermission");
				inSql1.AppendItem(this.permissions);
				allConditions.Add(inSql1);
			}

			qc.WhereClause += allConditions.ToSqlString(TSqlBuilder.Instance);
		}
		/// <summary>
		/// 将缺省组织ID添加到查询结果
		/// </summary>
		/// <param name="result"></param>
		/// <param name="userIdField">源表中用户ID的列名</param>
		/// <param name="parentIdField">用于添加到源表中缺省组织的ID的列名</param>
		/// <param name="connectionName">连接名</param>
		public static void FillUserDefaultParent(DataView result, string userIdField, string parentIdField, string connectionName)
		{
			if (result.Table.Columns.Contains(parentIdField) == false)
			{
				result.Table.Columns.Add(parentIdField, typeof(string));
			}

			var rows = result.Table.Rows;
			string[] ids = new string[rows.Count];
			for (int i = 0; i < rows.Count; i++)
			{
				ids[i] = (string)rows[i][userIdField];
			}

			if (ids.Length > 0)
			{
				InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("K.ObjectID");
				inBuilder.AppendItem(ids);

				var defaultParentTimeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("K.");
				var defaultParentWhere = new WhereSqlClauseBuilder();
				defaultParentWhere.AppendItem("K.Status", (int)SchemaObjectStatus.Normal);
				defaultParentWhere.AppendItem("K.IsDefault", 1);

				var defaultParentAllConditions = new ConnectiveSqlClauseCollection(inBuilder, defaultParentWhere, defaultParentTimeCondition);

				string parentIDSql = TimePointContext.Current.UseCurrentTime ? "SELECT K.ObjectID, K.ParentID FROM SC.SchemaRelationObjectsSnapshot_Current K WHERE " + defaultParentAllConditions.ToSqlString(TSqlBuilder.Instance) : "SELECT K.ObjectID, K.ParentID FROM SC.SchemaRelationObjectsSnapshot K WHERE " + defaultParentAllConditions.ToSqlString(TSqlBuilder.Instance);

				DataSet ds = DbHelper.RunSqlReturnDS(parentIDSql, connectionName);

				var rows2 = ds.Tables[0].Rows;
				rows.ForEach<DataRow>(r =>
				{
					rows2.ForEach<DataRow>(r2 =>
					{
						if (r2["ObjectID"].Equals(r[userIdField]))
						{
							r[parentIdField] = r2["ParentID"];
						}
					});
				});
			}
		}
		internal static bool ValidateCodeNameWithContainer(string codeName, string[] schemaNames, string objectID, string parentID, bool normalOnly, bool ignoreVersions, DateTime timePoint)
		{
			var objects = SchemaObjectAdapter.Instance.LoadByCodeNameAndSchema(schemaNames.ToArray(), new string[] { codeName }, true, false, DateTime.MinValue);

			bool result = false;
			if (objects.Count == 0)
			{
				result = true;
			}
			else
			{
				WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();

				where.AppendItem("ContainerID", parentID);

				if (normalOnly)
					where.AppendItem("Status", (int)SchemaObjectStatus.Normal);

				InSqlClauseBuilder inSql = new InSqlClauseBuilder("MemberID");
				inSql.AppendItem((from o in objects select o.ID).ToArray());

				// 只取当前关系
				var relations = SCMemberRelationAdapter.Instance.Load(new ConnectiveSqlClauseCollection(where, inSql), timePoint);

				bool exist = false;

				foreach (string schemaName in schemaNames)
				{
					foreach (SCMemberRelation o in relations)
					{
						if (o.ID != objectID && o.MemberSchemaType == schemaName)
						{
							exist = true;
							break;
						}
					}
				}

				result = exist == false;
			}

			return result;
		}
		public IList<RoleDisplayItem> LoadByRoleIds(string[] ids)
		{
			IList<RoleDisplayItem> result = null;
			if (ids.Length > 0 && ids.Length > 0)
			{
				string sql = @"SELECT O.*, A.ID AS AppID, A.Name As AppName, A.DisplayName AS AppDisplayName FROM  
 SC.SchemaObjectSnapshot O INNER JOIN SC.SchemaMembersSnapshot R ON R.MemberID = O.ID
 INNER JOIN SC.SchemaObjectSnapshot_Current A ON R.ContainerID = A.ID
 WHERE ";

				InSqlClauseBuilder inBuilder1 = new InSqlClauseBuilder("O.SchemaType");
				inBuilder1.AppendItem(SchemaInfo.FilterByCategory("Roles").ToSchemaNames());

				InSqlClauseBuilder inBuilder2 = new InSqlClauseBuilder("O.ID");
				inBuilder2.AppendItem(ids);

				var timeLimit1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("O.");
				var timeLimit2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("R.");

				WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
				builder.AppendItem("O.Status", (int)SchemaObjectStatus.Normal);
				builder.AppendItem("R.Status", (int)SchemaObjectStatus.Normal);

				sql += new ConnectiveSqlClauseCollection(inBuilder1, inBuilder2, timeLimit1, timeLimit2, builder).ToSqlString(TSqlBuilder.Instance);

				DataTable table = DbHelper.RunSqlReturnDS(sql, this.GetConnectionName()).Tables[0];

				result = new List<RoleDisplayItem>(table.Rows.Count);
				foreach (DataRow row in table.Rows)
				{
					var obj = new RoleDisplayItem();
					ORMapping.DataRowToObject(row, obj);
					result.Add(obj);
				}
			}
			else
			{
				result = new List<RoleDisplayItem>();
			}

			return result;
		}
		/// <summary>
		/// 获取组织和父组织ID
		/// </summary>
		/// <param name="timePoint">时间点 或 <see cref="DateTime.MinValue"/>表示取当前时间</param>
		/// <param name="orgIds">组织的ID</param>
		/// <returns></returns>
		public IEnumerable<SCWrappedSchemaOwnership> GetDirectParents(DateTime timePoint, params string[] orgIds)
		{
			string sql = @"SELECT O.*,R.ParentID AS QCHID FROM 
SC.SchemaOrganizationSnapshot O
INNER JOIN SC.SchemaRelationObjectsSnapshot R
ON O.ID = R.ObjectID
WHERE ";
			InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("R.ObjectID");
			inBuilder.AppendItem(orgIds);

			WhereSqlClauseBuilder whereBuilder = new WhereSqlClauseBuilder();

			var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "O.");

			var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "R.");
			whereBuilder.AppendItem("O.Status", (int)SchemaObjectStatus.Normal);
			whereBuilder.AppendItem("R.Status", (int)SchemaObjectStatus.Normal);
			whereBuilder.AppendItem("R.ParentSchemaType", "Organizations");

			ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(inBuilder, whereBuilder, timeCondition, timeCondition2);

			sql += connectiveBuilder.ToSqlString(TSqlBuilder.Instance) + " ORDER BY R.ParentID ASC";
			var ds = DbHelper.RunSqlReturnDS(sql, this.GetConnectionName());
			SCSimpleObject lastObj = null;
			foreach (System.Data.DataRow row in ds.Tables[0].Rows)
			{
				SCSimpleObject obj;
				if (lastObj != null && lastObj.ID == (string)row["ID"])
				{
					obj = lastObj;
				}
				else
				{
					obj = new SCSimpleObject();
					MCS.Library.Data.Mapping.ORMapping.DataRowToObject(row, obj);
					lastObj = obj;
				}

				yield return new SCWrappedSchemaOwnership(obj, (string)row["QCHID"]);
			}
		}
		private static ClientSchemaObjectBase[] GetObjectByIDInner(string[] ids, string[] objectSchemaTypes, bool normalOnly)
		{
			objectSchemaTypes.NullCheck("objectSchemaTypes");

			ClientSchemaObjectBase[] result;

			bool noIDMatch = ids != null && ids.Length == 0;

			if (noIDMatch)
			{
				result = new ClientSchemaObjectBase[0];
			}
			else
			{
				ConnectiveSqlClauseCollection builder = new ConnectiveSqlClauseCollection();
				if (ids != null)
				{
					InSqlClauseBuilder idInBuilder = new InSqlClauseBuilder("ID");
					idInBuilder.AppendItem(ids);

					builder.Add(idInBuilder);
				}

				if (objectSchemaTypes != null)
				{
					InSqlClauseBuilder typeInBuilder = new InSqlClauseBuilder("SchemaType");
					typeInBuilder.AppendItem(objectSchemaTypes);
					builder.Add(typeInBuilder);
				}

				if (normalOnly)
					builder.Add((IConnectiveSqlClause)new WhereSqlClauseBuilder().AppendItem("Status", (int)SchemaObjectStatus.Normal));

				if (builder.IsEmpty == false)
					result = SchemaObjectAdapter.Instance.Load(builder, SimpleRequestSoapMessage.Current.TimePoint).ToClientSCBaseObjectArray();
				else
					result = new ClientSchemaObjectBase[0];
			}

			return result;
		}
		public DataView Query(string userID, string where, int startRowIndex, int maximumRows, string orderBy, ref int totalCount)
		{
			List<string> operatorIDs = new List<string>();

			SchemaObjectCollection userRoles =
				SCSnapshotAdapter.Instance.QueryUserBelongToRoles(new string[] { "Roles" }, string.Empty, new string[] { userID }, false, DBTimePointActionContext.Current.TimePoint);

			userRoles.ForEach(r => operatorIDs.Add(r.ID));

			operatorIDs.Add(userID);

			List<string> roleMatrixIDs = SOARolePropertiesAdapter.Instance.OperatorBelongToRoleIDsDirectly(operatorIDs.ToArray());

			InSqlClauseBuilder roleInSql = new InSqlClauseBuilder("R.ID");
			roleInSql.AppendItem(roleMatrixIDs.ToArray());

			DataView view = this.innerSource.Query(startRowIndex, maximumRows, roleInSql.ToSqlString(TSqlBuilder.Instance), orderBy, ref totalCount);

			this.lastQueryCount = totalCount;

			return view;
		}
		public void Update(string processID, WfProcessCurrentActivityCollection pcas)
		{
			processID.CheckStringIsNullOrEmpty("processID");
			pcas.NullCheck("pcas");

			StringBuilder strB = new StringBuilder();
			InSqlClauseBuilder deleteActivityIDs = new InSqlClauseBuilder("ACTIVITY_ID");

			foreach (WfProcessCurrentActivity pca in pcas)
			{
				if (strB.Length > 0)
					strB.Append(TSqlBuilder.Instance.DBStatementSeperator);

				strB.Append(ORMapping.GetInsertSql(pca, TSqlBuilder.Instance));

				deleteActivityIDs.AppendItem(pca.ActivityID);
			}

            WhereSqlClauseBuilder wBuilder = new WhereSqlClauseBuilder();

            wBuilder.AppendItem("PROCESS_ID", processID);
            wBuilder.AppendTenantCodeSqlClause(typeof(WfProcessCurrentActivity));

			string sqlDelete = string.Format("DELETE WF.PROCESS_CURRENT_ACTIVITIES WHERE {0}",
                wBuilder.ToSqlString(TSqlBuilder.Instance));

			if (deleteActivityIDs.Count > 0)
				sqlDelete += string.Format(" AND {0}", deleteActivityIDs.ToSqlString(TSqlBuilder.Instance));

			string sql = sqlDelete;

			if (strB.Length > 0)
				sql += TSqlBuilder.Instance.DBStatementSeperator + strB.ToString();

			DbHelper.RunSqlWithTransaction(sql, GetConnectionName());
		}
		/// <summary>
		/// 获取一个或多个终端节点的父机构
		/// </summary>
		/// <param name="timePoint">时间点</param>
		/// <param name="terminalIds">终结点ID的数组</param>
		/// <returns>表示对象ID,和容器ID的关系。</returns>
		public IEnumerable<System.Collections.Generic.KeyValuePair<string, string>> GetOwnerships(DateTime timePoint, string[] terminalIds)
		{
			string sql = @"SELECT R.ObjectID,R.ParentID FROM 
SC.SchemaRelationObjectsSnapshot R
WHERE ";
			InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("R.ObjectID");
			inBuilder.AppendItem(terminalIds);

			WhereSqlClauseBuilder whereBuilder = new WhereSqlClauseBuilder();

			var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "R.");

			whereBuilder.AppendItem("R.Status", (int)SchemaObjectStatus.Normal);
			whereBuilder.AppendItem("R.ParentSchemaType", "Organizations");

			ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(inBuilder, whereBuilder, timeCondition);

			sql += connectiveBuilder.ToSqlString(TSqlBuilder.Instance) + " ORDER BY R.ObjectID ASC";
			var ds = DbHelper.RunSqlReturnDS(sql, this.GetConnectionName());
			foreach (System.Data.DataRow row in ds.Tables[0].Rows)
			{
				yield return new System.Collections.Generic.KeyValuePair<string, string>(row["ObjectID"] as string, row["ParentID"] as string);
			}
		}
		public static SCMemberRelationCollection LoadMembershipFor(string[] memberIds, string containerId)
		{
			if (memberIds.Length > 0)
			{
				WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();

				where.AppendItem("Status", (int)SchemaObjectStatus.Normal);

				if (containerId != null)
				{
					where.AppendItem("ContainerID", containerId);
				}

				InSqlClauseBuilder idIn = new InSqlClauseBuilder("MemberID");

				idIn.AppendItem(memberIds);

				return Adapters.SCMemberRelationAdapter.Instance.Load(new ConnectiveSqlClauseCollection(where, idIn), DateTime.MinValue);
			}
			else
			{
				return new SCMemberRelationCollection();
			}
		}
		protected override void OnBuildQueryCondition(QueryCondition qc)
		{
			qc.FromClause = TimePointContext.Current.UseCurrentTime ? "SC.SchemaObjectSnapshot_Current O INNER JOIN SC.SchemaRelationObjectsSnapshot_Current R ON O.ID = R.ObjectID" : "SC.SchemaObjectSnapshot O INNER JOIN SC.SchemaRelationObjectsSnapshot R ON O.ID = R.ObjectID";
			qc.SelectFields = "O.*,R.ParentID,R.FullPath";
			if (string.IsNullOrEmpty(qc.OrderByClause))
				qc.OrderByClause = "R.InnerSort ASC";

			qc.WhereClause.IsNotEmpty((s) => qc.WhereClause += " AND ");
			InSqlClauseBuilder inSql = new InSqlClauseBuilder("O.SchemaType");
			if (this.schemaTypes != null && this.schemaTypes.Length > 0)
			{
				inSql.AppendItem(this.schemaTypes);
			}
			else
			{
				var config = ObjectSchemaSettings.GetConfig();
				inSql.AppendItem(SchemaInfo.FilterByCategory("Users", "Groups", "Organizations").ToSchemaNames());
				if (inSql.IsEmpty)
					throw new ApplicationException("配置中不存在任何可用的Schema");
			}

			var timeCondition1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("R.");
			var where = new WhereSqlClauseBuilder();
			where.AppendItem("R.Status", (int)SchemaObjectStatus.Normal);
			where.AppendItem("R.ParentSchemaType", "Organizations");

			if (startPath.IsNotEmpty())
			{
				where.AppendItem("R.FullPath", TSqlBuilder.Instance.EscapeLikeString(startPath) + "%", "LIKE");
			}

			var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("O.");
			where.AppendItem("O.Status", (int)SchemaObjectStatus.Normal);

			qc.WhereClause += new ConnectiveSqlClauseCollection(timeCondition1, timeCondition2, where, inSql).ToSqlString(TSqlBuilder.Instance);
		}
        /// <summary>
        /// 用户是否在Acl中
        /// </summary>
        /// <param name="process"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public static bool IsUserInAcl(this IWfProcess process, IUser user)
        {
            bool result = false;

            if (OguUser.IsNotNullOrEmpty(user))
            {
                InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("RESOURCE_ID");

                inBuilder.AppendItem(process.ResourceID, process.ID);

                WhereSqlClauseBuilder whereBuilder = new WhereSqlClauseBuilder();

                whereBuilder.AppendItem("OBJECT_TYPE", "Users");
                whereBuilder.AppendItem("OBJECT_ID", user.ID);

                ConnectiveSqlClauseCollection connective = new ConnectiveSqlClauseCollection(inBuilder, whereBuilder);

                WfAclItemCollection aclItems = WfAclAdapter.Instance.LoadByBuilder(connective);

                result = aclItems.Count > 0;
            }

            return result;
        }