///// <summary>
///// 判断一个用户是否存在于指定的多个部门之中
///// </summary>
///// <param name="strUserValue">用户的属性数据值</param>
/////
///// <param name="socu">用户的属性名称
///// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）
///// </param>
///// <param name="strUserParentGuid">指定用户所在的父部门标识（可空）</param>
///// <param name="objectXmlDoc">判断对象的属性数据值</param>
///// <param name="soco">机构的属性名称
///// （ＧＵＩＤ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）
///// </param>
///// <param name="lod">是否包含被逻辑删除的成员</param>
///// <param name="strHideType">查询中要求屏蔽的数据(对应于配置文件HideTypes.xml中的配置)</param>
///// <param name="bDirect">是否直接从属（无中间部门）</param>
///// <param name="bFitAll">是否要求完全匹配（存在于指定的每一个部门中）</param>
///// <returns>判断一个用户是否存在于指定的多个部门之中</returns>
//public static bool IsUserInObjects(string strUserValue, SearchObjectColumn socu, string strUserParentGuid, XmlDocument objectXmlDoc, SearchObjectColumn soco, ListObjectDelete lod, string strHideType, bool bDirect, bool bFitAll)
//{
// using (DbContext context = DbContext.GetContext(AccreditResource.ConnAlias))
// {
// return IsUserInObjects(strUserValue, socu, strUserParentGuid, objectXmlDoc, soco, lod, strHideType, bDirect, bFitAll, da);
// }
//}
/// <summary>
/// 判断一个用户是否存在于指定的多个部门之中
/// </summary>
/// <param name="strUserValue">用户的属性数据值</param>
///
/// <param name="socu">用户的属性名称
/// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）
/// </param>
/// <param name="strUserParentGuid">指定用户所在的父部门标识（可空）</param>
/// <param name="objectXmlDoc">判断对象的属性数据值</param>
/// <param name="soco">机构的属性名称
/// （ＧＵＩＤ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）
/// </param>
/// <param name="lod">是否包含被逻辑删除的成员</param>
/// <param name="bDirect">是否直接从属（无中间部门）</param>
/// <param name="bFitAll">是否要求完全匹配（存在于指定的每一个部门中）</param>
/// <returns>判断一个用户是否存在于指定的多个部门之中</returns>
public static bool IsUserInObjects(string strUserValue,
SearchObjectColumn socu,
string strUserParentGuid,
XmlDocument objectXmlDoc,
SearchObjectColumn soco,
ListObjectDelete lod,
bool bDirect,
bool bFitAll)
{
return IsUserInObjects(strUserValue, socu, strUserParentGuid, objectXmlDoc, soco, lod, string.Empty, bDirect, bFitAll);
}
/// <summary>
/// 判断用户群是否存在于指定的多个部门之中
/// </summary>
/// <param name="xmlUserDoc">用户群标识（多个之间采用","分隔）</param>
/// <param name="socu">用户的属性名称
/// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
/// <param name="xmlObjDoc">机构群（采用XML方式）</param>
/// <param name="soc">机构的属性名称
/// （ＧＵＩＤ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
/// <param name="lod">是否包含被逻辑删除的成员</param>
/// <param name="strHideType">查询中要求屏蔽的数据(对应于配置文件HideTypes.xml中的配置)</param>
/// <param name="bDirect">是否直接从属（无中间部门）</param>
/// <remarks>
/// <code>
/// xmlUserDoc的结构如下（说明oValue必填，与socu配合使用；parentGuid可不填）：
/// <USERS>
/// <USERS oValue="" parentGuid="" />
/// <USERS oValue="" parentGuid="" />
/// </USERS>
/// xmlObjDoc的结构如下（说明oValue必填，与soc配合使用；parentGuid可不填；rankCode可不填）：
/// <OBJECTS>
/// <ORGANIZATIONS oValue="" rankCode="" />
/// <GROUPS oValue="" rankCode="" />
/// <USERS oValue="" parentGuid="" />
/// </OBJECTS>
/// </code>
/// xmlObjDoc的返回结果（字节点方式嵌入返回）：
/// <OBJECTS>
/// <ORGANIZATIONS oValue="" rankCode="" >
/// <USERS oValue="" parentGuid=""/>
/// <USERS oValue="" parentGuid=""/>
/// </ORGANIZATIONS>
/// <GROUPS oValue="" rankCode="" >
/// <USERS oValue="" parentGuid=""/>
/// <USERS oValue="" parentGuid=""/>
/// </GROUPS>
/// <USERS oValue="" parentGuid="" >
/// <USERS oValue="" parentGuid=""/>
/// </USERS>
/// </OBJECTS>
/// </remarks>
public static void CheckUserInObjects(XmlDocument xmlUserDoc,
SearchObjectColumn socu,
XmlDocument xmlObjDoc,
SearchObjectColumn soc,
ListObjectDelete lod,
string strHideType,
bool bDirect)
{
string cacheKey = InnerCacheHelper.BuildCacheKey(xmlUserDoc.DocumentElement.OuterXml,
socu,
xmlObjDoc.DocumentElement.OuterXml,
soc,
lod,
strHideType,
bDirect);
XmlDocument result;
#if DEBUG
Debug.WriteLine(xmlObjDoc.OuterXml, "begin");
#endif
//if (false == CheckUserInObjectsQueue.Instance.TryGetValue(cacheKey, out result))
//{
// lock (typeof(CheckUserInObjectsQueue))
// {
if (false == CheckUserInObjectsQueue.Instance.TryGetValue(cacheKey, out result))
{
string strUserColName = OGUCommonDefine.GetSearchObjectColumn(socu);
string strObjColName = OGUCommonDefine.GetSearchObjectColumn(soc);
strHideType = OGUCommonDefine.GetHideType(strHideType);
string strHideList = GetHideTypeFromXmlForLike(strHideType, "OU_USERS");
string strDelUser = GetSqlSearchStatus("OU_USERS", lod);
string strDirect = "%";
if (bDirect)
strDirect = "______";
#region Db control
using (DbContext context = DbContext.GetContext(CommonResource.AccreditConnAlias))
{
string strUserLimit = GetUserLimitInCheckUserInOrganizations(xmlUserDoc, strUserColName);
/*****************************************************************************************************************/
string strExtraWhere = @"
AND (" + strDelUser + @")
AND " + strUserLimit + strHideList;
StringBuilder strB = GetSqlSearchForCheckUserInObjects(xmlObjDoc, strUserColName, strObjColName, strDirect, strExtraWhere);
if (strB.Length > 0)
{
Database database = DatabaseFactory.Create(context);
DataSet ds = database.ExecuteDataSet(CommandType.Text, strB.ToString());
foreach (DataTable oTable in ds.Tables)
{
foreach (DataRow row in oTable.Rows)
{
XmlNode uNode = xmlUserDoc.DocumentElement.SelectSingleNode("USERS[@oValue=\"" + OGUCommonDefine.DBValueToString(row["USER_VALUE"]) + "\"]");
if (uNode != null)
{
XmlElement oRoot = xmlObjDoc.DocumentElement;
string oClass = OGUCommonDefine.DBValueToString(row["OBJECTCLASS"]);
string oValue = OGUCommonDefine.DBValueToString(row["OBJ_VALUE"]);
foreach (XmlElement oElem in oRoot.SelectNodes(oClass + "[@oValue=\"" + oValue + "\"]"))
{
if (row["RANK_CODE"] is DBNull)
{
if (oElem.GetAttribute("rankCode") == string.Empty)
{
XmlElement uElem = (XmlElement)XmlHelper.AppendNode(oElem, uNode.LocalName);
foreach (XmlAttribute xAttr in uNode.Attributes)
uElem.SetAttribute(xAttr.LocalName, xAttr.InnerText);
}
}
else
{
if (oElem.GetAttribute("rankCode") == OGUCommonDefine.DBValueToString(row["RANK_CODE"]))
{
XmlElement uElem = (XmlElement)XmlHelper.AppendNode(oElem, uNode.LocalName);
foreach (XmlAttribute xAttr in uNode.Attributes)
uElem.SetAttribute(xAttr.LocalName, xAttr.InnerText);
}
}
}
}
}
}
}
}
#endregion
#region Deleted
/*****************************************************************************************************************/
/*******下面一段程序并没有错误，但是性能上有差异。以下程序针对每个OBJ对象产生一条SQL查询语句，********************/
/*******在对象多的情况下导致SQL查询语句的庞大，修改参阅GetSqlSearchForCheckUserInObjects**************************/
/*****************************************************************************************************************/
// foreach (XmlElement elem in xmlObjDoc.DocumentElement.ChildNodes)
// {
// string strRankLimit = elem.GetAttribute("rankCode");
// if (strRankLimit != null && strRankLimit.Length > 0)
// strRankLimit = " AND RANK_DEFINE.SORT_ID <= (SELECT SORT_ID FROM RANK_DEFINE WHERE CODE_NAME = " + TSqlBuilder.Instance.CheckQuotationMark(elem.GetAttribute("rankCode")) + ") ";
// else
// strRankLimit = string.Empty;
//
// string strSql = string.Empty;
// switch (elem.LocalName)
// {
// case "ORGANIZATIONS":
// strSql = @"
// SELECT DISTINCT " + GetTableColumns(strUserColName, da, "USERS", "OU_USERS") + " AS USER_VALUE, " + GetTableColumns(strObjColName, da, "ORGANIZATIONS") + @" AS OBJ_VALUE
// FROM ORGANIZATIONS, OU_USERS, USERS JOIN RANK_DEFINE ON USERS.RANK_CODE = RANK_DEFINE.CODE_NAME
// WHERE OU_USERS.USER_GUID = USERS.GUID
// AND OU_USERS.ORIGINAL_SORT LIKE ORGANIZATIONS.ORIGINAL_SORT + " + TSqlBuilder.Instance.CheckQuotationMark(strDirect) + @"
// AND (" + strDelUser + @")
// AND " + GetTableColumns(strObjColName, da, "ORGANIZATIONS") + " = " + TSqlBuilder.Instance.CheckQuotationMark(elem.GetAttribute("oValue")) + @"
// AND " + strUserLimit + @"
// " + strRankLimit + strHideList + @"
// ORDER BY OBJ_VALUE";
// break;
// case "GROUPS":
// strSql = @"
// SELECT DISTINCT " + GetTableColumns(strUserColName, da, "USERS", "OU_USERS") + " AS USER_VALUE, " + GetTableColumns(strObjColName, da, "GROUPS") + @" AS OBJ_VALUE
// FROM GROUPS, GROUP_USERS, OU_USERS, USERS JOIN RANK_DEFINE ON USERS.RANK_CODE = RANK_DEFINE.CODE_NAME
// WHERE GROUPS.GUID = GROUP_USERS.GROUP_GUID
// AND GROUP_USERS.USER_GUID = OU_USERS.USER_GUID
// AND GROUP_USERS.USER_PARENT_GUID = OU_USERS.PARENT_GUID
// AND OU_USERS.USER_GUID = USERS.GUID
// AND GROUPS." + strObjColName + " = " + TSqlBuilder.Instance.CheckQuotationMark(elem.GetAttribute("oValue")) + @"
// AND ( " + strDelUser + @" )
// AND " + strUserLimit + strHideList + @"
// " + strRankLimit + @"
// ORDER BY OBJ_VALUE";
// break;
// case "USERS":
// strSql = @"
// SELECT DISTINCT " + GetTableColumns(strUserColName, da, "USERS", "OU_USERS") + " AS USER_VALUE, " + GetTableColumns(strObjColName, da, "USERS", "OU_USERS") + @" AS OBJ_VALUE
// FROM OU_USERS, USERS
// WHERE OU_USERS.USER_GUID = USERS.GUID
// AND " + GetTableColumns(strObjColName, da, "USERS", "OU_USERS") + " = " + TSqlBuilder.Instance.CheckQuotationMark(elem.GetAttribute("oValue")) + @"
// AND ( " + strDelUser + @" )
// AND " + strUserLimit + strHideList + @"
// ORDER BY OBJ_VALUE ";
// break;
// default : ExceptionHelper.TrueThrow(true, "对不起,系统没有对应处理“" + elem.LocalName + "”的相应程序！");
// break;
// }
//
// strB.Append(strSql + ";\n");
// }
// if (strB.Length > 0)
// {
// DataSet ds = OGUCommonDefine.ExecuteDataset(strB.ToString(), da);
// for (int iTable = 0; iTable < ds.Tables.Count; iTable++)
// {
// foreach (DataRow row in ds.Tables[iTable].Rows)
// {
// XmlNode uNode = xmlUserDoc.DocumentElement.SelectSingleNode("USERS[@oValue=\"" + XmlHelper.DBValueToString(row["USER_VALUE"]) + "\"]");
// if (uNode != null)
// {
// XmlElement oElem = (XmlElement)XmlHelper.AppendNode(xmlObjDoc, xmlObjDoc.DocumentElement.ChildNodes[iTable], uNode.LocalName);
// foreach (XmlAttribute xAttr in uNode.Attributes)
// oElem.SetAttribute(xAttr.LocalName, xAttr.InnerText);
// }
// }
// }
// }
/*****************************************************************************************************************/
#endregion
result = xmlObjDoc;
CheckUserInObjectsQueue.Instance.Add(cacheKey, result, InnerCacheHelper.PrepareDependency());
}
// }
//}
xmlObjDoc = result;
#if DEBUG
Debug.WriteLine(xmlObjDoc.OuterXml, "result");
#endif
}
/// <summary>
/// 根据要求查询对象中是否展现被（逻辑）删除的对象生成数据查询条件
/// </summary>
/// <param name="strTableName">要求查询的数据表</param>
/// <param name="lod">要求展现的数据删除类型（默认都是数据删除上的普通对象）</param>
/// <returns>SQL中与数据删除相关的</returns>
private static string GetSqlSearchStatus(string strTableName, ListObjectDelete lod)
{
string strListDelete = string.Empty;
if ((lod & ListObjectDelete.COMMON) != ListObjectDelete.None)
strListDelete = " (" + strTableName + ".STATUS = " + ((int)ListObjectDelete.COMMON).ToString() + ") ";
if ((lod & ListObjectDelete.DIRECT_LOGIC) != ListObjectDelete.None)
{
if (strListDelete.Length > 0)
strListDelete += " OR ";
strListDelete += " (" + strTableName + ".STATUS & " + ((int)ListObjectDelete.DIRECT_LOGIC).ToString() + ") <> 0 ";
}
if ((lod & ListObjectDelete.CONJUNCT_ORG_LOGIC) != ListObjectDelete.None)
{
if (strListDelete.Length > 0)
strListDelete += " OR ";
strListDelete += " (" + strTableName + ".STATUS & " + ((int)ListObjectDelete.CONJUNCT_ORG_LOGIC).ToString() + ") <> 0 ";
}
if ((lod & ListObjectDelete.CONJUNCT_USER_LOGIC) != ListObjectDelete.None)
{
if (strListDelete.Length > 0)
strListDelete += " OR ";
strListDelete += " (" + strTableName + ".STATUS & " + ((int)ListObjectDelete.CONJUNCT_USER_LOGIC).ToString() + ") <> 0 ";
}
return strListDelete;
}
///// <summary>
///// 获取指定部门下的所有子对象
///// </summary>
///// <param name="strOrgValues">要求查询的部门对象(父部门标识,多个之间采用","分隔)</param>
///// <param name="soc">查询要求的查询列名称
///// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
///// <param name="iLot">要求查询的数据对象类型（机构、组、人员、兼职对象）</param>
///// <param name="iLod">是否包含被逻辑删除的成员</param>
///// <param name="iDepth">要求查询的层次（最少一层）（0代表全部子对象）</param>
///// <param name="strOrgRankCodeName">查询中要求的机构对象级别</param>
///// <param name="strUserRankCodeName">查询中要求的人员对象级别</param>
///// <param name="strHideType">查询中要求屏蔽的数据(对应于配置文件HideTypes.xml中的配置)</param>
///// <param name="strAttrs">查询中要求获取数据对象的属性类型</param>
///// <param name="iOrgClass">要求展现机构的类型</param>
///// <param name="iOrgType">要求展现机构的属性</param>
///// <param name="da">数据库操作对象</param>
///// <returns>获取指定部门下的所有子对象的查询结果</returns>
//public static DataSet GetOrganizationChildren(string strOrgValues, SearchObjectColumn soc, int iLot, int iLod, int iDepth, string strOrgRankCodeName, string strUserRankCodeName, string strHideType, string strAttrs, int iOrgClass, int iOrgType, DataAccess da)
//{
// strAttrs = OGUCommonDefine.CombinateAttr(strAttrs);
// SearchOrgChildrenCondition scc = new SearchOrgChildrenCondition(strOrgValues, soc, strAttrs, da);
// scc.ListObjDelete = (ListObjectDelete)iLod;
// scc.ListObjType = (ListObjectType)iLot;
// scc.Depth = iDepth;
// scc.OrgRankCN = strOrgRankCodeName;
// scc.UserRankCN = strUserRankCodeName;
// scc.HideType = strHideType;
// scc.OrgClass = iOrgClass;
// scc.OrgType = iOrgType;
// return GetOrganizationChildren(scc, da);
//}
///// <summary>
///// 获取指定部门下的所有子对象
///// </summary>
///// <param name="strOrgValues">要求查询的部门对象(父部门标识,多个之间采用","分隔)</param>
///// <param name="soc">查询要求的查询列名称
///// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
///// <param name="iLot">要求查询的数据对象类型（机构、组、人员、兼职对象）</param>
///// <param name="iLod">是否包含被逻辑删除的成员</param>
///// <param name="iDepth">要求查询的层次（最少一层）（0代表全部子对象）</param>
///// <param name="strOrgRankCodeName">查询中要求的机构对象级别</param>
///// <param name="strUserRankCodeName">查询中要求的人员对象级别</param>
///// <param name="strHideType">查询中要求屏蔽的数据(对应于配置文件HideTypes.xml中的配置)</param>
///// <param name="strAttrs">查询中要求获取数据对象的属性类型</param>
///// <param name="da">数据库操作对象</param>
///// <returns>获取指定部门下的所有子对象的查询结果</returns>
//public static DataSet GetOrganizationChildren(string strOrgValues, SearchObjectColumn soc, int iLot, int iLod, int iDepth, string strOrgRankCodeName, string strUserRankCodeName, string strHideType, string strAttrs, DataAccess da)
//{
// return GetOrganizationChildren(strOrgValues, soc, iLot, iLod, iDepth, strOrgRankCodeName, strUserRankCodeName, strHideType, strAttrs, 0, 0, da);
//}
///// <summary>
///// 按照一定的查询条件查询系统中的数据对象
///// </summary>
///// <param name="scc">系统的查询条件对象</param>
///// <param name="da">数据库操作对象</param>
///// <returns>按照一定的查询条件查询系统中的数据对象</returns>
//public static DataSet GetOrganizationChildren(SearchOrgChildrenCondition scc, DataAccess da)
//{
// StringBuilder strB = new StringBuilder(1024);
// if ((scc.ListObjType & ListObjectType.ORGANIZATIONS) != 0)
// {
// strB.Append(" ( " + GetOrganizationsSqlByScc(scc, da) + " \n )");
// }
// if ((scc.ListObjType & ListObjectType.GROUPS) != 0)
// {
// if (strB.Length > 0)
// strB.Append(" \n UNION \n ");
// strB.Append(" ( " + GetGroupsSqlByScc(scc, da) + " \n )");
// }
// if ((scc.ListObjType & ListObjectType.USERS) != 0)
// {
// if (strB.Length > 0)
// strB.Append(" \n UNION \n ");
// strB.Append(" ( " + GetUsersSqlByScc(scc, da) + " \n )");
// }
// string strSql = "SELECT * FROM ( " + strB.ToString() + " ) RESULT ORDER BY GLOBAL_SORT";
// return OGUCommonDefine.ExecuteDataset(strSql, da);
//}
/// <summary>
/// 判断一个用户是否存在于指定的多个部门之中
/// </summary>
/// <param name="strUserValue">用户的属性数据值</param>
/// <param name="socu">用户的属性名称
/// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）
/// </param>
/// <param name="strUserParentGuid">指定用户所在的父部门标识（可空）</param>
/// <param name="objectXmlDoc">判断对象的属性数据值</param>
/// <param name="soc">机构的属性名称
/// （ＧＵＩＤ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）
/// </param>
/// <param name="lod">是否包含被逻辑删除的成员</param>
/// <param name="strHideType">查询中要求屏蔽的数据(对应于配置文件HideTypes.xml中的配置)</param>
/// <param name="bDirect">是否直接从属（无中间部门）</param>
/// <param name="bFitAll">是否要求完全匹配（存在于指定的每一个部门中）</param>
/// <returns>判断一个用户是否存在于指定的多个部门之中</returns>
/// <remarks>
/// objectXmlDoc的结构如下：
/// <code>
/// <OBJECTS>
/// <ORGANIZATIONS oValue="" rankCode="" />
/// <GROUPS oValue="" rankCode="" />
/// <USERS oValue="" parentGuid="" />
/// </OBJECTS>
/// </code>
/// </remarks>
public static bool IsUserInObjects(string strUserValue,
SearchObjectColumn socu,
string strUserParentGuid,
XmlDocument objectXmlDoc,
SearchObjectColumn soc,
ListObjectDelete lod,
string strHideType,
bool bDirect,
bool bFitAll)
{
string cacheKey = Common.InnerCacheHelper.BuildCacheKey(strUserValue,
socu,
strUserParentGuid,
objectXmlDoc,
soc,
lod,
strHideType,
bDirect,
bFitAll);
bool result;
//if (false == IsUserInObjectsQueue.Instance.TryGetValue(cacheKey, out result))
//{
// lock (typeof(IsUserInObjectsQueue))
// {
if (false == IsUserInObjectsQueue.Instance.TryGetValue(cacheKey, out result))
{
string strUserColName = OGUCommonDefine.GetSearchObjectColumn(socu);
string strObjColName = OGUCommonDefine.GetSearchObjectColumn(soc);
strHideType = OGUCommonDefine.GetHideType(strHideType);
string strHideList = GetHideTypeFromXmlForLike(strHideType, "OU_USERS");
string strDirect = "%";
if (bDirect)
strDirect = "______";
string strUserLimit = " AND " + DatabaseSchema.Instence.GetTableColumns(strUserColName, "OU_USERS", "USERS")
+ " = " + TSqlBuilder.Instance.CheckQuotationMark(strUserValue, true);
if (strUserParentGuid.Length > 0)
strUserLimit += " AND OU_USERS.PARENT_GUID = " + TSqlBuilder.Instance.CheckQuotationMark(strUserParentGuid, true);
string strDelUser = GetSqlSearchStatus("OU_USERS", lod);
StringBuilder strB = new StringBuilder(1024);
#region 内部实现
XmlElement root = objectXmlDoc.DocumentElement;
foreach (XmlElement elem in root.ChildNodes)
{
string strRankLimit = string.Empty;
if (elem.GetAttribute("rankCode") != null && elem.GetAttribute("rankCode").Length > 0)
strRankLimit = " AND RANK_DEFINE.SORT_ID <= (SELECT SORT_ID FROM RANK_DEFINE WHERE CODE_NAME = "
+ TSqlBuilder.Instance.CheckQuotationMark(elem.GetAttribute("rankCode"), true) + ") ";
switch (elem.LocalName)
{
case "ORGANIZATIONS":
strB.Append(@"
SELECT DISTINCT ORGANIZATIONS.GUID, OU_USERS.USER_GUID
FROM OU_USERS, ORGANIZATIONS, USERS JOIN RANK_DEFINE
ON USERS.RANK_CODE = RANK_DEFINE.CODE_NAME
" + strRankLimit + @"
WHERE OU_USERS.USER_GUID = USERS.GUID
AND OU_USERS.ORIGINAL_SORT LIKE ORGANIZATIONS.ORIGINAL_SORT + "
+ TSqlBuilder.Instance.CheckQuotationMark(strDirect, true) + @"
AND " + DatabaseSchema.Instence.GetTableColumns(strObjColName, "ORGANIZATIONS") + @" = "
+ TSqlBuilder.Instance.CheckQuotationMark(elem.GetAttribute("oValue"), true) + @"
AND (" + strDelUser + @")
" + strUserLimit + strHideList + @";");
break;
case "GROUPS":
strB.Append(@"
SELECT DISTINCT GROUPS.GUID, OU_USERS.USER_GUID
FROM GROUPS, GROUP_USERS, OU_USERS, USERS JOIN RANK_DEFINE
ON USERS.RANK_CODE = RANK_DEFINE.CODE_NAME
" + strRankLimit + @"
WHERE GROUPS.GUID = GROUP_USERS.GROUP_GUID
AND OU_USERS.USER_GUID = GROUP_USERS.USER_GUID
AND OU_USERS.PARENT_GUID = GROUP_USERS.USER_PARENT_GUID
AND OU_USERS.USER_GUID = USERS.GUID
AND " + DatabaseSchema.Instence.GetTableColumns(strObjColName, "GROUPS") + @" = "
+ TSqlBuilder.Instance.CheckQuotationMark(elem.GetAttribute("oValue"), true) + @"
AND (" + strDelUser + @")
" + strUserLimit + strHideList + @";");
break;
case "USERS":
strB.Append(@"
SELECT DISTINCT USERS.GUID, OU_USERS.USER_GUID
FROM OU_USERS, USERS
WHERE OU_USERS.USER_GUID = USERS.GUID
AND " + DatabaseSchema.Instence.GetTableColumns(strObjColName, "OU_USERS", "USERS") + " = "
+ TSqlBuilder.Instance.CheckQuotationMark(elem.GetAttribute("oValue"), true) + @"
AND (" + strDelUser + @")" + strUserLimit + strHideList + @";");
break;
default: ExceptionHelper.TrueThrow(true, "对不起,系统没有对应处理“" + elem.LocalName + "”的相应程序！");
break;
}
}
#endregion
result = CheckIsUserInOrganizations(strB, bFitAll);
IsUserInObjectsQueue.Instance.Add(cacheKey, result, InnerCacheHelper.PrepareDependency());
}
// }
//}
return result;
}
/// <summary>
/// 形成根据指定条件查询“人员组”的SQL语句
/// </summary>
/// <param name="strOrgValues">指定的范围机构标识（多个之间采用","分隔）</param>
/// <param name="soc">用户的属性名称
/// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
/// <param name="strLikeName">“人员组”上的名称模糊匹配对象</param>
/// <param name="bLike">是否采用模糊匹配</param>
/// <param name="strAttr">要求获取的字段属性</param>
/// <param name="iLod">查询删除的对象策略</param>
/// <param name="iDep">要求查询的深度</param>
/// <param name="strHideType">要求屏蔽的类型设置</param>
/// <param name="rootPath">传入的ORIGINAL_SORT</param>
/// <returns>形成根据指定条件查询“人员组”的SQL语句</returns>
///
//2009-05-06 删除 RANK_DEFINE 约束，调整ORIGINAL_SORT约束
private static string QueryGroupsByCondition2(string strOrgValues,
SearchObjectColumn soc,
string strLikeName,
bool bLike,
string strAttr,
ListObjectDelete iLod,
int iDep,
string strHideType,
string rootPath)
{
string strColName = OGUCommonDefine.GetSearchObjectColumn(soc);
StringBuilder strB = new StringBuilder(1024);
strB.Append(@" SELECT 'GROUPS' AS OBJECTCLASS, " + DatabaseSchema.Instence.GetTableColumns(strAttr, "GROUPS") + @"
FROM GROUPS
WHERE ( " + GetSqlSearchParOriginal2("GROUPS", iDep, rootPath) + " )");
string strListDelete = GetSqlSearchStatus("GROUPS", iLod);
if (strListDelete.Length > 0)
strB.Append(" \n AND ( " + strListDelete + " ) ");
strB.Append(BuildSearchCondition("GROUPS.SEARCH_NAME", strLikeName, bLike));
if (strHideType.Length > 0)
strB.Append(GetHideTypeFromXmlForLike(strHideType, "GROUPS"));
return strB.ToString();
}
/// <summary>
/// 形成根据指定条件查询“人员”的SQL语句
/// </summary>
/// <param name="strOrgValues">指定的范围机构标识（多个之间采用","分隔）</param>
/// <param name="soc">用户的属性名称
/// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
/// <param name="strLikeName">“人员”上的名称模糊匹配对象</param>
/// <param name="bLike">是否采用模糊匹配</param>
/// <param name="strAttr">要求获取的字段属性</param>
/// <param name="iListObjType">用于是否查询兼职问题</param>
/// <param name="iLod">查询删除的对象策略</param>
/// <param name="iDep">要求查询的深度</param>
/// <param name="strHideType">要求屏蔽的类型设置</param>
/// <param name="rootPath">传入的ORIGINAL_SORT</param>
/// <returns>形成根据指定条件查询“人员”的SQL语句</returns>
///
//2009-05-06 删除 RANK_DEFINE 约束，调整ORIGINAL_SORT约束
private static string QueryUsersByCondition2(string strOrgValues,
SearchObjectColumn soc,
string strLikeName,
bool bLike,
string strAttr,
int iListObjType,
ListObjectDelete iLod,
int iDep,
string strHideType,
string rootPath)
{
string strColName = OGUCommonDefine.GetSearchObjectColumn(soc);
StringBuilder strB = new StringBuilder(1024);
strB.Append(@" SELECT 'USERS' AS OBJECTCLASS, "
+ DatabaseSchema.Instence.GetTableColumns(strAttr, "USERS", "OU_USERS") + @"
FROM USERS , OU_USERS
WHERE USERS.GUID = OU_USERS.USER_GUID
AND ( " + GetSqlSearchParOriginal2("OU_USERS", iDep, rootPath) + " )");
string strListDelete = GetSqlSearchStatus("OU_USERS", iLod);
if (strListDelete.Length > 0)
strB.Append(" \n AND ( " + strListDelete + " ) ");
if ((iListObjType & (int)ListObjectType.SIDELINE) == 0)
strB.Append(" \n AND OU_USERS.SIDELINE = 0 ");
if (strLikeName != SearchAllTerm)
strB.Append(string.Format(@" AND (OU_USERS.SEARCH_NAME like '%{0}%')", strLikeName));
else
strB.Append(BuildSearchCondition("OU_USERS.SEARCH_NAME", strLikeName, bLike));
//strB.Append(BuildSearchCondition("OU_USERS.SEARCH_NAME", strLikeName, bLike));
if (strHideType.Length > 0)
strB.Append(GetHideTypeFromXmlForLike(strHideType, "OU_USERS"));
return strB.ToString();
}
/// <summary>
///
/// </summary>
/// <param name="strGroupValues"></param>
/// <param name="socg"></param>
/// <param name="strNameLike"></param>
/// <param name="strSortColumn"></param>
/// <param name="strAttrs"></param>
/// <param name="strOrgValues"></param>
/// <param name="soco"></param>
/// <param name="strUserRankCodeName"></param>
/// <param name="lod"></param>
/// <param name="iPageNo"></param>
/// <param name="iPageSize"></param>
/// <returns></returns>
public static DataSet GetUsersInGroups(string strGroupValues,
SearchObjectColumn socg,
string strNameLike,
string strSortColumn,
string strAttrs,
string strOrgValues,
SearchObjectColumn soco,
string strUserRankCodeName,
ListObjectDelete lod,
int iPageNo,
int iPageSize)
{
string cacheKey = InnerCacheHelper.BuildCacheKey(strGroupValues,
socg,
strNameLike,
strSortColumn,
strAttrs,
strOrgValues,
soco,
strUserRankCodeName,
lod,
iPageNo,
iPageSize);
DataSet result;
//if (false == GetUsersInGroupsQueue.Instance.TryGetValue(cacheKey, out result))
//{
// lock (typeof(GetUsersInGroupsQueue))
// {
if (false == GetUsersInGroupsQueue.Instance.TryGetValue(cacheKey, out result))
{
using (DbContext context = DbContext.GetContext(CommonResource.AccreditConnAlias))
{
Database database = DatabaseFactory.Create(context);
strAttrs = OGUCommonDefine.CombinateAttr(strAttrs);
#region SQL Prepare
string strSql = @"
SELECT 'USERS' AS OBJECTCLASS, GROUP_USERS.GROUP_GUID, "
+ DatabaseSchema.Instence.GetTableColumns(strAttrs, "USERS", "OU_USERS", "RANK_DEFINE") + @"
FROM ORGANIZATIONS, GROUPS, GROUP_USERS, OU_USERS, USERS LEFT JOIN RANK_DEFINE
ON RANK_DEFINE.CODE_NAME = USERS.RANK_CODE
{2}
WHERE " + DatabaseSchema.Instence.GetTableColumns(OGUCommonDefine.GetSearchObjectColumn(socg), "GROUPS") + @" IN ({0})
AND GROUP_USERS.GROUP_GUID = GROUPS.GUID
AND GROUP_USERS.USER_GUID = OU_USERS.USER_GUID
AND GROUP_USERS.USER_PARENT_GUID = OU_USERS.PARENT_GUID
AND ({1})
AND USERS.GUID = GROUP_USERS.USER_GUID
AND OU_USERS.ORIGINAL_SORT LIKE ORGANIZATIONS.ORIGINAL_SORT + '%'
{3}
{4}
ORDER BY GROUPS.GLOBAL_SORT, "
+ TSqlBuilder.Instance.CheckQuotationMark(strSortColumn == string.Empty ? "GROUP_USERS.INNER_SORT" : strSortColumn, false);
string strOrgLimit = string.Empty;
if (strOrgValues.Length > 0)
strOrgLimit = " AND " + DatabaseSchema.Instence.GetTableColumns(OGUCommonDefine.GetSearchObjectColumn(soco), "ORGANIZATIONS")
+ " IN (" + OGUCommonDefine.AddMulitStrWithQuotationMark(strOrgValues) + ") ";
else
strOrgLimit = " AND ORGANIZATIONS.GUID = "
+ TSqlBuilder.Instance.CheckQuotationMark(OGUCommonDefine.DBValueToString(OGUReader.GetRootDSE().Tables[0].Rows[0]["GUID"]), true);
string strRankLimit = string.Empty;
if (strUserRankCodeName.Length > 0)
strRankLimit = " AND RANK_DEFINE.SORT_ID <= (SELECT SORT_ID FROM RANK_DEFINE WHERE CODE_NAME = "
+ TSqlBuilder.Instance.CheckQuotationMark(strUserRankCodeName, true) + ") ";
string strNameLikeWhere = string.Empty;
if (strNameLike != string.Empty)
{
strNameLike = strNameLike.Replace("*", "");
strNameLikeWhere = " AND (USERS.LOGON_NAME LIKE '%' + " + TSqlBuilder.Instance.CheckQuotationMark(strNameLike, true) + @" + '%'
OR OU_USERS.OBJ_NAME LIKE '%' + " + TSqlBuilder.Instance.CheckQuotationMark(strNameLike, true) + @" + '%'
OR OU_USERS.DISPLAY_NAME LIKE '%' + " + TSqlBuilder.Instance.CheckQuotationMark(strNameLike, true) + @" + '%') ";
}
#endregion
strSql = string.Format(strSql, OGUCommonDefine.AddMulitStrWithQuotationMark(strGroupValues), GetSqlSearchStatus("OU_USERS", lod), strRankLimit, strOrgLimit, strNameLikeWhere);
//if (iPageNo >= 0 && iPageSize > 0)
// result = database.ExecuteDataSet(Com, strSql, "GROUPS", iPageNo, iPageSize);
//else
result = database.ExecuteDataSet(CommandType.Text, strSql, iPageNo, iPageSize, "USERS");
}
GetUsersInGroupsQueue.Instance.Add(cacheKey, result, InnerCacheHelper.PrepareDependency());
}
// }
//}
return result;
}
/// <summary>
/// 按照不同的要求查询系统中的所有符合条件的数据
/// </summary>
/// <param name="strOrgValues">指定父机构（多个之间采用","分隔,空就采用默认）</param>
/// <param name="soc">查询要求的查询列名称
/// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）
/// </param>
/// <param name="strLikeName">名称中的（模糊匹配对象）</param>
/// <param name="bLike">是否采用模糊匹配</param>
/// <param name="strAttr">要求获取的字段</param>
/// <param name="iListObjType">要求查询的对象类型</param>
/// <param name="iLod">查询删除的对象策略</param>
/// <param name="iDep">查询深度</param>
/// <param name="strHideType">要求屏蔽的类型设置</param>
/// <param name="rtnRowLimit">返回行数限制</param>
/// <returns>按照不同的要求查询系统中的所有符合条件的数据</returns>
///
//2009-05-06 删除 RANK_DEFINE 约束，调整ORIGINAL_SORT约束，增加返回行数限制:-1(全部)
public static DataSet QueryOGUByCondition2(string strOrgValues,
SearchObjectColumn soc,
string strLikeName,
bool bLike,
string strAttr,
int iListObjType,
ListObjectDelete iLod,
int iDep,
string strHideType,
int rtnRowLimit)
{
string cacheKey = InnerCacheHelper.BuildCacheKey(strOrgValues,
soc,
strLikeName,
bLike,
strAttr,
iListObjType,
iDep,
strHideType,
rtnRowLimit);
DataSet result;
//得到All_Path_Name
DataSet dsRootOrg = OGUReader.GetObjectsDetail("ORGANIZATIONS",
strOrgValues,
SearchObjectColumn.SEARCH_GUID,
string.Empty,
SearchObjectColumn.SEARCH_GUID);
ExceptionHelper.FalseThrow(dsRootOrg.Tables[0].Rows.Count > 0, "不能找到ID为{0}的机构", strOrgValues);
string rootPath = dsRootOrg.Tables[0].Rows[0]["ORIGINAL_SORT"].ToString();
if (false == QueryOGUByConditionQueue.Instance.TryGetValue(cacheKey, out result))
{
using (DbContext context = DbContext.GetContext(CommonResource.AccreditConnAlias))
{
if (strOrgValues.Length == 0)
{
strOrgValues = OGUCommonDefine.DBValueToString(OGUReader.GetRootDSE().Tables[0].Rows[0]["GUID"]);
soc = SearchObjectColumn.SEARCH_GUID;
}
strAttr = OGUCommonDefine.CombinateAttr(strAttr);
strHideType = OGUCommonDefine.GetHideType(strHideType);
strLikeName = strLikeName.Replace("*", "%");
StringBuilder strB = new StringBuilder(1024);
if ((iListObjType & (int)ListObjectType.ORGANIZATIONS) != 0)
strB.Append(" ( " + QueryOrganizationsByCondition2(strOrgValues, soc, strLikeName, bLike, strAttr, iLod, iDep, strHideType, rootPath) + " \n )");
if ((iListObjType & (int)ListObjectType.GROUPS) != 0)
{
if (strB.Length > 0)
strB.Append(" \n UNION \n ");
strB.Append(" ( " + QueryGroupsByCondition2(strOrgValues, soc, strLikeName, bLike, strAttr, iLod, iDep, strHideType, rootPath) + " \n )");
}
if ((iListObjType & (int)ListObjectType.USERS) != 0)
{
if (strB.Length > 0)
strB.Append(" \n UNION \n ");
strB.Append(" ( " + QueryUsersByCondition2(strOrgValues, soc, strLikeName, bLike, strAttr, iListObjType, iLod, iDep, strHideType, rootPath) + " \n )");
}
string strSql = string.Empty;
if (rtnRowLimit >= 0)
{
strSql = "SELECT top " + rtnRowLimit + " * FROM ( " + strB.ToString() + " ) RESULT ORDER BY GLOBAL_SORT";
}
else
{
strSql = "SELECT * FROM ( " + strB.ToString() + " ) RESULT ORDER BY GLOBAL_SORT";
}
Database database = DatabaseFactory.Create(context);
result = database.ExecuteDataSet(CommandType.Text, strSql);
}
QueryOGUByConditionQueue.Instance.Add(cacheKey, result, InnerCacheHelper.PrepareDependency());
}
return result;
}
/// <summary>
/// 获取指定对象中的所有用户对象
/// </summary>
/// <param name="xmlObjDoc">要求被查询的数据对象</param>
/// <param name="soc">查询要求的查询列名称
/// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）
/// </param>
/// <param name="strOrgLimitValues">要求对象所在机构的范围内（如果没有将采用系统配置数据，可空）</param>
/// <param name="soco">要求所在机构的范围的查询列名称
/// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
/// <param name="lod">系统中被逻辑删除对象是否查询取出</param>
/// <param name="strAttrs">要求获得的数据属性</param>
/// <returns>获取指定对象中的所有用户对象</returns>
/// <remarks>
/// <code>
/// xmlObjDoc的结构：
/// <OBJECTS>
/// <ORGANIZATIONS oValue="" rankCode="" />
/// <GROUPS oValue="" rankCode="" />
/// <USERS oValue="" parentGuid="" />
/// </OBJECTS>
/// </code>
/// </remarks>
public static DataSet GetAllUsersInAllObjects(XmlDocument xmlObjDoc,
SearchObjectColumn soc,
string strOrgLimitValues,
SearchObjectColumn soco,
ListObjectDelete lod,
string strAttrs)
{
return GetAllUsersInAllObjects(xmlObjDoc, soc, strOrgLimitValues, soco, ListObjectType.ALL_TYPE, lod, strAttrs);
}
/// <summary>
/// 获取指定对象中的所有用户对象
/// </summary>
/// <param name="xmlObjDoc">要求被查询的数据对象</param>
/// <param name="soc">查询要求的查询列名称
/// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
/// <param name="strOrgLimitValues">要求对象所在机构的范围内（如果没有将采用系统配置数据，可空）</param>
/// <param name="soco">要求所在机构的范围的查询列名称
/// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
/// <param name="lot">要求被查询的数据对象类型（主要是用于辨别是否要求查询兼职人员）</param>
/// <param name="lod">系统中被逻辑删除对象是否查询取出</param>
/// <param name="strHideType">要求隐藏的设置类型</param>
/// <param name="strAttrs">要求获得的数据属性</param>
/// <returns>获取指定对象中的所有用户对象</returns>
/// <remarks>
/// <code>
/// xmlObjDoc的结构：
/// <OBJECTS>
/// <ORGANIZATIONS oValue="" rankCode="" />
/// <GROUPS oValue="" rankCode="" />
/// <USERS oValue="" parentGuid="" />
/// </OBJECTS>
/// </code>
/// </remarks>
public static DataSet GetAllUsersInAllObjects(XmlDocument xmlObjDoc,
SearchObjectColumn soc,
string strOrgLimitValues,
SearchObjectColumn soco,
ListObjectType lot,
ListObjectDelete lod,
string strHideType,
string strAttrs)
{
string cacheKey = InnerCacheHelper.BuildCacheKey(xmlObjDoc.DocumentElement.OuterXml,
soc,
strOrgLimitValues,
soco,
lot,
lod,
strHideType,
strAttrs);
DataSet result;
//if (false == GetAllUsersInAllObjectsQueue.Instance.TryGetValue(cacheKey, out result))
//{
// lock (typeof(GetAllUsersInAllObjectsQueue))
// {
if (false == GetAllUsersInAllObjectsQueue.Instance.TryGetValue(cacheKey, out result))
{
#region Prepare Db
ExceptionHelper.TrueThrow(xmlObjDoc.DocumentElement.ChildNodes.Count <= 0, "对不起，系统没有给定要求查询的数据对象！");
strAttrs = OGUCommonDefine.CombinateAttr(strAttrs);
string strObjColName = OGUCommonDefine.GetSearchObjectColumn(soc);
string strDelUser = GetSqlSearchStatus("OU_USERS", lod);
strHideType = OGUCommonDefine.GetHideType(strHideType);
string strHideList = GetHideTypeFromXmlForLike(strHideType, "OU_USERS");
string strListObjectType = string.Empty;
if ((lot & ListObjectType.SIDELINE) == 0)
strListObjectType = " AND OU_USERS.SIDELINE = 0 ";
if (strOrgLimitValues.Length == 0)
{
strOrgLimitValues = AccreditSection.GetConfig().AccreditSettings.OguRootName;// (new SysConfig()).GetDataFromConfig("OGURootName", string.Empty);
ExceptionHelper.TrueThrow<ApplicationException>(string.IsNullOrEmpty(strOrgLimitValues),
"对不起，您没有配置好系统默认指定的初始机构！请检查web.config中的configuration\\appSettings\\<add key=\"OGURootName\" value=\"\" />");
soco = SearchObjectColumn.SEARCH_ALL_PATH_NAME;
}
#endregion
StringBuilder strB = new StringBuilder(1024);
foreach (XmlElement elem in xmlObjDoc.DocumentElement.ChildNodes)
{
string strRankLimit = elem.GetAttribute("rankCode");
if (strRankLimit != null && strRankLimit.Length > 0)
strRankLimit = " AND RANK_DEFINE.SORT_ID <= (SELECT SORT_ID FROM RANK_DEFINE WHERE CODE_NAME = "
+ TSqlBuilder.Instance.CheckQuotationMark(strRankLimit, true) + " ) ";
else
strRankLimit = string.Empty;
string strSql = string.Empty;
switch (elem.LocalName)
{
case "ORGANIZATIONS":
#region ORGANIZATIONS
strSql = @"
SELECT 'USERS' AS OBJECTCLASS, " + DatabaseSchema.Instence.GetTableColumns(strAttrs, "USERS", "OU_USERS", "RANK_DEFINE") + @"
FROM ORGANIZATIONS, OU_USERS, USERS JOIN RANK_DEFINE
ON RANK_DEFINE.CODE_NAME = USERS.RANK_CODE
" + strRankLimit + @",
(
SELECT ORIGINAL_SORT
FROM ORGANIZATIONS
WHERE " + OGUCommonDefine.GetSearchObjectColumn(soco) + " IN ("
+ OGUCommonDefine.AddMulitStrWithQuotationMark(strOrgLimitValues) + @" )
) ORG_LIMIT
WHERE USERS.GUID = OU_USERS.USER_GUID
AND " + DatabaseSchema.Instence.GetTableColumns(strObjColName, "ORGANIZATIONS") + " = "
+ TSqlBuilder.Instance.CheckQuotationMark(elem.GetAttribute("oValue"), true) + @"
AND OU_USERS.ORIGINAL_SORT LIKE ORGANIZATIONS.ORIGINAL_SORT + '%'
AND OU_USERS.ORIGINAL_SORT LIKE ORG_LIMIT.ORIGINAL_SORT + '%'
AND (" + strDelUser + @")
" + strHideList + strListObjectType;
break;
#endregion
case "GROUPS":
#region GROUPS
strSql = @"
SELECT 'USERS' AS OBJECTCLASS, " + DatabaseSchema.Instence.GetTableColumns(strAttrs, "USERS", "OU_USERS", "RANK_DEFINE") + @"
FROM GROUPS, GROUP_USERS, OU_USERS, USERS JOIN RANK_DEFINE
ON RANK_DEFINE.CODE_NAME = USERS.RANK_CODE
" + strRankLimit + @",
(
SELECT ORIGINAL_SORT
FROM ORGANIZATIONS
WHERE " + OGUCommonDefine.GetSearchObjectColumn(soco) + " IN ("
+ OGUCommonDefine.AddMulitStrWithQuotationMark(strOrgLimitValues) + @" )
) ORG_LIMIT
WHERE GROUPS.GUID = GROUP_USERS.GROUP_GUID
AND GROUP_USERS.USER_PARENT_GUID = OU_USERS.PARENT_GUID
AND GROUP_USERS.USER_GUID = OU_USERS.USER_GUID
AND USERS.GUID = OU_USERS.USER_GUID
AND OU_USERS.ORIGINAL_SORT LIKE ORG_LIMIT.ORIGINAL_SORT + '%'
AND " + DatabaseSchema.Instence.GetTableColumns(strObjColName, "GROUPS") + " = "
+ TSqlBuilder.Instance.CheckQuotationMark(elem.GetAttribute("oValue"), true) + @"
AND (" + strDelUser + @")
" + strHideList + strListObjectType;
break;
#endregion
case "USERS":
#region USERS
strSql = @"
SELECT 'USERS' AS OBJECTCLASS, "
+ DatabaseSchema.Instence.GetTableColumns(strAttrs, "USERS", "OU_USERS", "RANK_DEFINE") + @"
FROM OU_USERS, USERS JOIN RANK_DEFINE
ON RANK_DEFINE.CODE_NAME = USERS.RANK_CODE
" + strRankLimit + @",
(
SELECT ORIGINAL_SORT
FROM ORGANIZATIONS
WHERE " + OGUCommonDefine.GetSearchObjectColumn(soco) + " IN ("
+ OGUCommonDefine.AddMulitStrWithQuotationMark(strOrgLimitValues) + @" )
) ORG_LIMIT
WHERE OU_USERS.USER_GUID = USERS.GUID
AND OU_USERS.ORIGINAL_SORT LIKE ORG_LIMIT.ORIGINAL_SORT + '%'
AND " + DatabaseSchema.Instence.GetTableColumns(strObjColName, "OU_USERS", "USERS") + " = "
+ TSqlBuilder.Instance.CheckQuotationMark(elem.GetAttribute("oValue"), true) + @"
AND (" + strDelUser + @")
" + strHideList + strListObjectType;
break;
#endregion
default: ExceptionHelper.TrueThrow(true, "对不起,系统没有对应处理“" + elem.LocalName + "”的相应程序！");
break;
}
if (strB.Length > 0)
strB.Append(Environment.NewLine + " UNION " + Environment.NewLine);
strB.Append("(" + strSql + ")");
}
using (DbContext context = DbContext.GetContext(CommonResource.AccreditConnAlias))
{
Database database = DatabaseFactory.Create(context);
string sql = "SELECT * FROM (" + strB.ToString() + ") A ORDER BY GLOBAL_SORT";
result = database.ExecuteDataSet(CommandType.Text, sql);
}
GetAllUsersInAllObjectsQueue.Instance.Add(cacheKey, result, InnerCacheHelper.PrepareDependency());
}
// }
//}
return result;
}
///// <summary>
///// 判断用户群是否存在于指定的多个部门之中
///// </summary>
///// <param name="xmlUserDoc">用户群标识（采用XML方式）</param>
///// <param name="socu">用户的属性名称
///// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
///// <param name="xmlObjDoc">机构群（采用XML方式）</param>
///// <param name="soc">机构的属性名称
///// （ＧＵＩＤ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
///// <param name="lod">是否包含被逻辑删除的成员</param>
///// <param name="strHideType">查询中要求屏蔽的数据(对应于配置文件HideTypes.xml中的配置)</param>
///// <param name="bDirect">是否直接从属（无中间部门）</param>
///// <remarks>
///// <code>
///// xmlUserDoc的结构如下（说明oValue必填，与socu配合使用；parentGuid可不填）：
///// <USERS>
///// <USERS oValue="" parentGuid="" />
///// <USERS oValue="" parentGuid="" />
///// </USERS>
///// xmlObjDoc的结构如下（说明oValue必填，与soc配合使用；parentGuid可不填；rankCode可不填）：
///// <OBJECTS>
///// <ORGANIZATIONS oValue="" rankCode="" />
///// <GROUPS oValue="" rankCode="" />
///// <USERS oValue="" parentGuid="" />
///// </OBJECTS>
///// </code>
///// xmlObjDoc的返回结果（字节点方式嵌入返回）：
///// <OBJECTS>
///// <ORGANIZATIONS oValue="" rankCode="" >
///// <USERS oValue="" parentGuid=""/>
///// <USERS oValue="" parentGuid=""/>
///// </ORGANIZATIONS>
///// <GROUPS oValue="" rankCode="" >
///// <USERS oValue="" parentGuid=""/>
///// <USERS oValue="" parentGuid=""/>
///// </GROUPS>
///// <USERS oValue="" parentGuid="" >
///// <USERS oValue="" parentGuid=""/>
///// </USERS>
///// </OBJECTS>
///// </remarks>
//public static void CheckUserInObjects(XmlDocument xmlUserDoc, SearchObjectColumn socu, XmlDocument xmlObjDoc, SearchObjectColumn soc, ListObjectDelete lod, string strHideType, bool bDirect)
//{
// DataAccess da = new DataAccess(OGUCommonDefine.STR_CONN);
// using (da.dBContextInfo)
// {
// da.dBContextInfo.OpenConnection();
// CheckUserInObjects(xmlUserDoc, socu, xmlObjDoc, soc, lod, strHideType, bDirect, da);
// }
//}
/// <summary>
/// 判断用户群是否存在于指定的多个部门之中
/// </summary>
/// <param name="xmlUserDoc">用户群标识（采用XML方式）</param>
/// <param name="socu">用户的属性名称
/// （ＧＵＩＤ、ＵＳＥＲ＿ＧＵＩＤ、ＬＯＧＯＮ＿ＮＡＭＥ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
/// <param name="xmlObjDoc">机构群（采用XML方式）</param>
/// <param name="soc">机构的属性名称
/// （ＧＵＩＤ、ＯＲＩＧＩＮＡＬ＿ＳＯＲＴ、ＧＬＯＢＡＬ＿ＳＯＲＴ、ＡＬＬ＿ＰＡＴＨ＿ＮＡＭＥ）</param>
/// <param name="lod">是否包含被逻辑删除的成员</param>
/// <param name="bDirect">是否直接从属（无中间部门）</param>
/// <remarks>
/// <code>
/// xmlUserDoc的结构如下（说明oValue必填，与socu配合使用；parentGuid可不填）：
/// <USERS>
/// <USERS oValue="" parentGuid="" />
/// <USERS oValue="" parentGuid="" />
/// </USERS>
/// xmlObjDoc的结构如下（说明oValue必填，与soc配合使用；parentGuid可不填；rankCode可不填）：
/// <OBJECTS>
/// <ORGANIZATIONS oValue="" rankCode="" />
/// <GROUPS oValue="" rankCode="" />
/// <USERS oValue="" parentGuid="" />
/// </OBJECTS>
/// </code>
/// xmlObjDoc的返回结果（字节点方式嵌入返回）：
/// <OBJECTS>
/// <ORGANIZATIONS oValue="" rankCode="" >
/// <USERS oValue="" parentGuid=""/>
/// <USERS oValue="" parentGuid=""/>
/// </ORGANIZATIONS>
/// <GROUPS oValue="" rankCode="" >
/// <USERS oValue="" parentGuid=""/>
/// <USERS oValue="" parentGuid=""/>
/// </GROUPS>
/// <USERS oValue="" parentGuid="" >
/// <USERS oValue="" parentGuid=""/>
/// </USERS>
/// </OBJECTS>
/// </remarks>
public static void CheckUserInObjects(XmlDocument xmlUserDoc,
SearchObjectColumn socu,
XmlDocument xmlObjDoc,
SearchObjectColumn soc,
ListObjectDelete lod,
bool bDirect)
{
CheckUserInObjects(xmlUserDoc, socu, xmlObjDoc, soc, lod, string.Empty, bDirect);
}
