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;
}
private void BindDataGrid()
{
WhereSqlClauseBuilder builder = ConditionMapping.GetWhereSqlClauseBuilder(this.UserUploadCondition);
if (this.processUsers.ReadOnly)
{
this.ObjectDataSourceUploadLogs.Condition = builder;
}
else
{
ConnectiveSqlClauseCollection collection = new ConnectiveSqlClauseCollection(LogicOperatorDefine.And);
collection.Add(builder);
WhereSqlClauseBuilder userwherebuilder = new WhereSqlClauseBuilder();
userwherebuilder.LogicOperator = LogicOperatorDefine.Or;
foreach (var item in this.processUsers.SelectedOuUserData)
{
userwherebuilder.AppendItem("OPERATOR_ID", item.ID);
}
collection.Add(userwherebuilder);
this.ObjectDataSourceUploadLogs.Condition = collection.ToSqlString(TSqlBuilder.Instance);
}
this.ObjectDataSourceUploadLogs.LastQueryRowCount = -1;
this.DeluxeGridUploadLog.PageIndex = 0;
this.DeluxeGridUploadLog.SelectedKeys.Clear();
this.DeluxeGridUploadLog.DataBind();
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
qc.FromClause = TimePointContext.Current.UseCurrentTime ? "SC.SchemaUserSnapshot_Current O INNER JOIN SC.UserAndContainerSnapshot_Current R ON O.ID = R.UserID" : "SC.SchemaUserSnapshot O INNER JOIN SC.UserAndContainerSnapshot R ON O.ID = R.UserID";
qc.SelectFields = "O.*";
if (string.IsNullOrEmpty(this.orderBy))
qc.OrderByClause = "R.VersionStartTime DESC";
else
qc.OrderByClause = orderBy;
base.OnBuildQueryCondition(qc);
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
var timeCondition1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("R.");
var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("O.");
builder.AppendItem("R.ContainerID", this.containerId);
InnerBuildWhere(builder);
builder.AppendItem("O.Status", (int)SchemaObjectStatus.Normal);
builder.AppendItem("R.Status", (int)SchemaObjectStatus.Normal);
var allConditions = new ConnectiveSqlClauseCollection(timeCondition1, timeCondition2, builder);
if (string.IsNullOrEmpty(qc.WhereClause))
{
qc.WhereClause = allConditions.ToSqlString(TSqlBuilder.Instance);
}
else
{
qc.WhereClause = allConditions.ToSqlString(TSqlBuilder.Instance) + " AND (" + qc.WhereClause + ")";
}
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
base.OnBuildQueryCondition(qc);
qc.SelectFields = "*";
qc.FromClause = TimePointContext.Current.UseCurrentTime ? "SC.AUAdminScopeItemSnapshot_Current" : "SC.AUAdminScopeItemSnapshot";
if (string.IsNullOrEmpty(qc.OrderByClause))
qc.OrderByClause = "AUScopeItemName ASC";
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
builder.AppendCondition("SchemaType", this.scopeType).NormalFor("Status");
var timeBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder();
var allCondition = new ConnectiveSqlClauseCollection(builder, timeBuilder).ToSqlString(TSqlBuilder.Instance);
if (string.IsNullOrEmpty(qc.WhereClause))
{
qc.WhereClause = allCondition;
}
else
{
qc.WhereClause = qc.WhereClause + "AND (" + allCondition + ")";
}
}
/// <summary>
/// 将时间点有关的SQL条件填充到ConnectiveSqlClauseCollection
/// </summary>
/// <param name="builder"></param>
/// <param name="timePoint"></param>
/// <param name="fieldPrefix">字段前缀。如果是表空间或Schema，不要忘记后面的'.'</param>
public void FillTimePointInBuilder(ConnectiveSqlClauseCollection builder, DateTime timePoint, string fieldPrefix)
{
//输出结果应该是
//VersionStartTime <= getdate() AND (VersionEndTime > getdate() OR VersionEndTime IS NULL)
builder.NullCheck("builder");
string timeString = TSqlBuilder.Instance.DBCurrentTimeFunction;
if (timePoint == DateTime.MinValue && this._UseSimulatedTime && TimePointContext.Current.UseCurrentTime == false)
timePoint = TimePointContext.Current.SimulatedTime;
if (timePoint != DateTime.MinValue)
timeString = TSqlBuilder.Instance.FormatDateTime(timePoint);
WhereSqlClauseBuilder sBuilder = new WhereSqlClauseBuilder();
string vsFieldName = JoinFieldName(fieldPrefix, this.VersionStartTimeFieldName);
sBuilder.AppendItem(vsFieldName, timeString, "<=", true);
WhereSqlClauseBuilder eBuilder = new WhereSqlClauseBuilder(LogicOperatorDefine.Or);
string veFieldName = JoinFieldName(fieldPrefix, this.VersionEndTimeFieldName);
eBuilder.AppendItem(veFieldName, timeString, ">", true).AppendItem(veFieldName, "NULL", "IS", true);
builder.LogicOperator = LogicOperatorDefine.And;
builder.Add(sBuilder).Add(eBuilder);
}
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;
}
}
}
}
private static ConnectiveSqlClauseCollection SchemaStrict(ConnectiveSqlClauseCollection c, string prefix, PC.StandardObjectSchemaType schema)
{
WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
where.AppendItem(prefix + "SchemaType", schema);
c.Add(where);
return c;
}
protected override void OnConnectConditions(ConnectiveSqlClauseCollection allConditions)
{
base.OnConnectConditions(allConditions);
allConditions.Add(VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("OU."));
allConditions.Add(VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("O."));
WhereSqlClauseBuilder where1 = new WhereSqlClauseBuilder();
where1.AppendItem("OU.Status", (int)SchemaObjectStatus.Normal);
where1.AppendItem("O.Status", (int)SchemaObjectStatus.Normal);
allConditions.Add(where1);
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
base.OnBuildQueryCondition(qc);
qc.SelectFields = "S.*";
qc.FromClause = this.FromSqlClause;
if (string.IsNullOrEmpty(qc.OrderByClause))
qc.OrderByClause = "S.Name ASC";
var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("S.");
WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
var allConditions = new ConnectiveSqlClauseCollection(timeCondition, where);
where.AppendCondition("S.CategoryID", this.categoryID);
if (string.IsNullOrEmpty(qc.WhereClause) == false)
qc.WhereClause += " AND ";
qc.WhereClause += allConditions.ToSqlString(TSqlBuilder.Instance);
}
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);
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
base.OnBuildQueryCondition(qc);
qc.SelectFields = SelectFields;
qc.FromClause = this.FromSqlClause;
if (string.IsNullOrEmpty(qc.OrderByClause))
qc.OrderByClause = DefaultOrderByClause; ;
var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("S.");
var timeCondition1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("M.");
WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
var allConditions = new ConnectiveSqlClauseCollection(timeCondition, timeCondition1, where);
BuildWhere(where);
if (string.IsNullOrEmpty(qc.WhereClause) == false)
qc.WhereClause += " AND ";
qc.WhereClause += allConditions.ToSqlString(TSqlBuilder.Instance);
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
base.OnBuildQueryCondition(qc);
qc.SelectFields = "S.*";
qc.FromClause = this.FromSqlClause;
if (string.IsNullOrEmpty(qc.OrderByClause))
qc.OrderByClause = "S.SearchContent ASC";
var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("S.");
var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("M.");
WhereSqlClauseBuilder where = new WhereSqlClauseBuilder().NormalFor("S.Status").NormalFor("M.Status");
var allConditions = new ConnectiveSqlClauseCollection(timeCondition, timeCondition2, where);
where.AppendCondition("M.ContainerID", this.scope.ID);
if (string.IsNullOrEmpty(qc.WhereClause) == false)
qc.WhereClause += " AND ";
qc.WhereClause += allConditions.ToSqlString(TSqlBuilder.Instance);
}
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, "用户没有权限打开此文件"));
}
/// <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);
}
/// <summary>
/// 获得指定附件的副本
/// </summary>
/// <param name="materials">附件集合</param>
/// <returns>指定附件对应的副本集合</returns>
internal MaterialList LoadCopyVersionMaterial(MaterialList materials)
{
ExceptionHelper.TrueThrow<ArgumentNullException>(materials == null, "materials");
MaterialList copyVersionMaterials = new MaterialList();
if (materials.Count != 0)
{
ConnectiveSqlClauseCollection orClause = new ConnectiveSqlClauseCollection(LogicOperatorDefine.Or);
foreach (Material material in materials)
{
WhereSqlClauseBuilder whereSqlClause = new WhereSqlClauseBuilder();
whereSqlClause.AppendItem("PARENT_ID", material.ID);
whereSqlClause.AppendItem("WF_ACTIVITY_ID", material.WfActivityID);
whereSqlClause.AppendItem("VERSION_TYPE", (int)MaterialVersionType.CopyVersion);
orClause.Add(whereSqlClause);
}
string sql = string.Format("SELECT * FROM WF.MATERIAL WHERE {0}",
orClause.AppendTenantCodeSqlClause(typeof(Material)).ToSqlString(TSqlBuilder.Instance));
using (DbContext dbi = DbHelper.GetDBContext(GetConnectionName()))
{
using (IDataReader dr = DbHelper.RunSqlReturnDR(sql, GetConnectionName()))
{
while (dr.Read())
{
Material material = new Material();
ORMapping.DataReaderToObject(dr, material);
copyVersionMaterials.Add(material);
}
}
}
DecorateMaterials(copyVersionMaterials);
}
return copyVersionMaterials;
}
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"];
}
});
});
}
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
if (qc.OrderByClause.IsNullOrEmpty())
qc.OrderByClause = "VersionStartTime DESC";
qc.WhereClause.IsNotEmpty((s) => qc.WhereClause += " AND ");
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder();
builder.AppendItem("Status", (int)SchemaObjectStatus.Normal);
builder.AppendItem("SchemaType", "Applications");
var conditions = new ConnectiveSqlClauseCollection(timeCondition, builder);
qc.WhereClause += conditions.ToSqlString(TSqlBuilder.Instance);
}
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;
}
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;
}
private static string BuilderSubSqlClause(WfMatrixQueryParam para, string wfMatrixID, string inSql)
{
WhereSqlClauseBuilder matrixIdBuilder = new WhereSqlClauseBuilder();
matrixIdBuilder.AppendItem(DB_FIELD_MATRIX_ID, wfMatrixID);
matrixIdBuilder.AppendTenantCode();
WhereSqlClauseBuilder fieldBuilder = new WhereSqlClauseBuilder();
fieldBuilder.AppendItem(DB_FIELD_DIMENSION_KEY, para.QueryName);
fieldBuilder.AppendItem(DB_FIELD_STRING_VALUE, para.QueryValue);
fieldBuilder.AppendTenantCode();
WhereSqlClauseBuilder fieldEmptyBuilder = new WhereSqlClauseBuilder();
fieldEmptyBuilder.AppendItem(DB_FIELD_DIMENSION_KEY, para.QueryName);
fieldEmptyBuilder.AppendItem(DB_FIELD_STRING_VALUE, "");
fieldEmptyBuilder.AppendTenantCode();
ConnectiveSqlClauseCollection fieldClauseConnector = new ConnectiveSqlClauseCollection(LogicOperatorDefine.Or);
fieldClauseConnector.Add(fieldBuilder);
fieldClauseConnector.Add(fieldEmptyBuilder);
ConnectiveSqlClauseCollection matrixIdConnector = new ConnectiveSqlClauseCollection(LogicOperatorDefine.And);
matrixIdConnector.Add(matrixIdBuilder);
matrixIdConnector.Add(fieldClauseConnector);
StringBuilder strBuilder = new StringBuilder(SELECT_MC_CLAUSE);
strBuilder.Append(matrixIdConnector.ToSqlString(TSqlBuilder.Instance));
if (!string.IsNullOrEmpty(inSql))
{
strBuilder.AppendFormat(" AND {0} IN ({1})", DB_FIELD_MATRIX_ROW_ID, inSql);
}
return(strBuilder.ToString());
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
qc.FromClause = FromClause;
qc.SelectFields = SelectFields;
if (string.IsNullOrEmpty(this.orderBy))
{
qc.OrderByClause = this.DefaultOrderBy;
}
else
{
qc.OrderByClause = orderBy;
}
base.OnBuildQueryCondition(qc);
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("R.");
var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("O.");
builder.AppendItem(UserIdField, userId);
InnerBuildWhere(builder);
var conditionUserSchemas = DataSourceUtil.SchemaTypeCondition("R.UserSchemaType", this.UserSchemaTypes);
var conditionContainerSchemas = DataSourceUtil.SchemaTypeCondition("R.ContainerSchemaType", this.ContainerSchemaTypes);
var allConditions = new ConnectiveSqlClauseCollection(timeCondition, timeCondition2, conditionUserSchemas, conditionContainerSchemas, builder);
OnConnectConditions(allConditions);
if (string.IsNullOrEmpty(qc.WhereClause))
{
qc.WhereClause = allConditions.ToSqlString(TSqlBuilder.Instance);
}
else
{
//将builder中的内容与WhereClause合并
qc.WhereClause = allConditions.ToSqlString(TSqlBuilder.Instance) + " AND (" + qc.WhereClause + ")";
}
}
public TCollection LoadByInBuilder(Action <InSqlClauseBuilder> inAction, Action <OrderBySqlClauseBuilder> orderByAction, ORMappingItemCollection mappings)
{
inAction.NullCheck("whereAction");
TCollection result = null;
PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration(string.Format("LoadByInBuilder({0})", this.GetType().FullName), () =>
{
InSqlClauseBuilder inBuilder = new InSqlClauseBuilder();
inAction(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 (orderByAction != null)
{
orderByBuilder = new OrderBySqlClauseBuilder();
orderByAction(orderByBuilder);
}
result = InnerLoadByBuilder(condition, orderByBuilder, mappings);
}
else
{
result = new TCollection();
}
});
return(result);
}
public List <AURoleDisplayItem> LoadAURoleDisplayItems(string unitID, bool normalOnly, DateTime timePoint)
{
string sql = @"SELECT SR.Name, SR.CodeName, SR.DisplayName, S.ID, S.SchemaRoleID, S.Status FROM SC.AURoleSnapshot S
INNER JOIN SC.SchemaMembers R ON S.ID = R.MemberID AND S.SchemaType = R.MemberSchemaType
INNER JOIN SC.AUSchemaRoleSnapshot SR ON SR.ID = S.SchemaRoleID
WHERE";
WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
where.AppendCondition("R.ContainerID", unitID).AppendCondition("R.ContainerSchemaType", AUCommon.SchemaAdminUnit);
if (normalOnly)
{
where.NormalFor("R.Status").NormalFor("S.Status").NormalFor("SR.Status");
}
var timeCondition1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "S.");
var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "SR.");
var timeCondition3 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "R.");
sql += new ConnectiveSqlClauseCollection(timeCondition1, timeCondition2, timeCondition3, where).ToSqlString(TSqlBuilder.Instance);
List <AURoleDisplayItem> result = new List <AURoleDisplayItem>();
AUCommon.DoDbAction(() =>
{
using (DbContext context = DbContext.GetContext(this.GetConnectionName()))
{
using (IDataReader dr = DbHelper.RunSqlReturnDR(sql, this.GetConnectionName()))
{
while (dr.Read())
{
AURoleDisplayItem item = new AURoleDisplayItem();
ORMapping.DataReaderToObject <AURoleDisplayItem>(dr, item);
result.Add(item);
}
}
}
});
return(result);
}
private string GetUpdateSql(string ownerID, string type, SCConditionCollection conditions)
{
if (type.IsNullOrEmpty())
{
type = "Default";
}
conditions.ForEach(c => { c.OwnerID = ownerID; c.Type = type; });
return(VersionStrategyUpdateSqlHelper.ConstructUpdateSql(null, (strB, context) =>
{
ConnectiveSqlClauseCollection connectiveBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder();
WhereSqlClauseBuilder keyBuilder = new WhereSqlClauseBuilder();
keyBuilder.AppendItem("OwnerID", ownerID);
keyBuilder.AppendItem("type", type);
connectiveBuilder.Add(keyBuilder);
strB.AppendFormat("UPDATE {0} SET VersionEndTime = {1} WHERE {2}",
this.GetMappingInfo().TableName, "@currentTime", connectiveBuilder.ToSqlString(TSqlBuilder.Instance));
for (int i = 0; i < conditions.Count; i++)
{
SCCondition condition = conditions[i];
condition.SortID = i;
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
condition.VersionEndTime = DBTimePointActionContext.MaxVersionEndTime;
condition.Type = type;
InsertSqlClauseBuilder insertBuilder = ORMapping.GetInsertSqlClauseBuilder(condition, this.GetMappingInfo(), "VersionStartTime");
insertBuilder.AppendItem("VersionStartTime", "@currentTime", "=", true);
strB.AppendFormat("INSERT INTO {0}{1}", this.GetMappingInfo().TableName, insertBuilder.ToSqlString(TSqlBuilder.Instance));
}
}));
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
base.OnBuildQueryCondition(qc);
qc.SelectFields = "S.*";
qc.FromClause = this.FromSqlClause;
if (string.IsNullOrEmpty(qc.OrderByClause))
{
qc.OrderByClause = "S.Name ASC";
}
var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("S.");
WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
var allConditions = new ConnectiveSqlClauseCollection(timeCondition, where);
where.AppendCondition("S.CategoryID", this.categoryID);
if (string.IsNullOrEmpty(qc.WhereClause) == false)
{
qc.WhereClause += " AND ";
}
qc.WhereClause += allConditions.ToSqlString(TSqlBuilder.Instance);
}
/// <summary>
/// 根据TimePoint和状态来生成Builder
/// </summary>
/// <param name="includingDeleted"></param>
/// <param name="timePoint"></param>
/// <param name="tablePrefixes"></param>
/// <returns></returns>
private IConnectiveSqlClause CreateStatusAndTimePointBuilder(bool includingDeleted, DateTime timePoint, params string[] tablePrefixes)
{
ConnectiveSqlClauseCollection result = new ConnectiveSqlClauseCollection();
foreach (string tablePrefix in tablePrefixes)
{
IConnectiveSqlClause timePointBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, tablePrefix);
result.Add(timePointBuilder);
WhereSqlClauseBuilder statusBuilder = new WhereSqlClauseBuilder();
if (includingDeleted == false)
{
statusBuilder.AppendItem(tablePrefix + "Status", (int)SchemaObjectStatus.Normal);
}
result.Add(statusBuilder);
}
return(result);
}
public SCAclMemberCollection LoadMembers(IConnectiveSqlClause condition, DateTime timePoint)
{
ConnectiveSqlClauseCollection timePointBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint);
ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(condition, timePointBuilder);
string sql = string.Format(
"SELECT * FROM {0} WHERE {1} ORDER BY SortID",
this.GetLoadingTableName(timePoint),
connectiveBuilder.ToSqlString(TSqlBuilder.Instance));
SCAclMemberCollection result = new SCAclMemberCollection();
using (DbContext context = DbContext.GetContext(this.GetConnectionName()))
{
using (IDataReader reader = DbHelper.RunSqlReturnDR(sql, this.GetConnectionName()))
{
ORMapping.DataReaderToCollection(result, reader);
return(result);
}
}
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
qc.SelectFields = "U.* ";
qc.FromClause = "SC.SchemaUserSnapshot U ";
if (qc.OrderByClause.IsNullOrEmpty())
{
qc.OrderByClause = "U.VersionStartTime DESC";
}
qc.WhereClause.IsNotEmpty((s) => qc.WhereClause += " AND ");
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
builder.AppendItem("U.Status", (int)SchemaObjectStatus.Normal, "!=");
var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("U.");
var allConditions = new ConnectiveSqlClauseCollection(builder, timeCondition);
qc.WhereClause += allConditions.ToSqlString(TSqlBuilder.Instance);
}
/// <summary>
/// 查询角色所包含的成员
/// </summary>
/// <param name="schemaTypes">成员的SchemaType</param>
/// <param name="appCodeName"></param>
/// <param name="roleCodeNames"></param>
/// <param name="includingDeleted"></param>
/// <param name="timePoint"></param>
/// <returns></returns>
public SCObjectAndRelationCollection QueryRolesContainsMembers(string[] schemaTypes, string appCodeName, string[] roleCodeNames, bool removeDuplicateData, bool includingDeleted, DateTime timePoint)
{
SCObjectAndRelationCollection result = new SCObjectAndRelationCollection();
InSqlClauseBuilder roleBuilder = new InSqlClauseBuilder("R.CodeName");
roleBuilder.AppendItem(roleCodeNames);
if (roleBuilder.IsEmpty == false)
{
InSqlClauseBuilder schemaBuilder = new InSqlClauseBuilder("MA.MemberSchemaType");
schemaBuilder.AppendItem(schemaTypes);
WhereSqlClauseBuilder appBuilder = new WhereSqlClauseBuilder();
appBuilder.AppendItem("A.CodeName", appCodeName);
IConnectiveSqlClause extraBuilder = CreateStatusAndTimePointBuilder(includingDeleted, timePoint,
"A.", "MA.", "R.", "UC.", "SR.", "SC.");
string resourcePath = "QueryRolesContainsMembers_Current.sql";
if (timePoint != DateTime.MinValue && includingDeleted == true)
{
resourcePath = "QueryRolesContainsMembers.sql";
}
string sqlTemplate = ResourceHelper.LoadStringFromResource(Assembly.GetExecutingAssembly(), string.Concat("MCS.Library.SOA.DataObjects.Security.Adapters.Templates.", resourcePath));
ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(roleBuilder, schemaBuilder, appBuilder, extraBuilder);
string sql = string.Format(sqlTemplate, connectiveBuilder.ToSqlString(TSqlBuilder.Instance));
DataTable table = DbHelper.RunSqlReturnDS(sql, this.GetConnectionName()).Tables[0];
result.LoadFromDataView(table.DefaultView, removeDuplicateData);
}
return(result);
}
/// <summary>
/// 根据<see cref="IConnectiveSqlClause"/>指定的条件和时间点载入对象
/// </summary>
/// <param name="condition">表示条件的<see cref="IConnectiveSqlClause"/></param>
/// <returns>一个<see cref="DESchemaObjectCollection"/>，包含条件指定的对象。</returns>
public DEEntityInstanceBaseCollection Load(IConnectiveSqlClause condition)
{
//var timePointBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint);
DEEntityInstanceBaseCollection result = new DEEntityInstanceBaseCollection();
if (condition.IsEmpty == false)
{
ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(condition);
using (DbContext context = DbContext.GetContext(this.GetConnectionName()))
{
VersionedObjectAdapterHelper.Instance.FillData(GetMappingInfo().TableName, connectiveBuilder, this.GetConnectionName(),
reader =>
{
result.LoadFromDataReader(reader);
});
}
}
return(result);
}
/// <summary>
/// 根据<see cref="IConnectiveSqlClause"/>指定的条件和时间点载入对象
/// </summary>
/// <param name="condition">表示条件的<see cref="IConnectiveSqlClause"/></param>
/// <param name="timePoint">时间点 - 或 - <see cref="DateTime.MinValue"/>表示当前时间</param>
/// <returns>一个<see cref="SchemaObjectCollection"/>，包含条件指定的对象。</returns>
public SchemaObjectCollection Load(IConnectiveSqlClause condition, DateTime timePoint)
{
var timePointBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint);
SchemaObjectCollection result = new SchemaObjectCollection();
if (condition.IsEmpty == false)
{
ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(condition, timePointBuilder);
using (DbContext context = DbContext.GetContext(this.GetConnectionName()))
{
VersionedObjectAdapterHelper.Instance.FillData(GetMappingInfo().TableName, connectiveBuilder, this.GetConnectionName(),
view =>
{
result.LoadFromDataView(view);
});
}
}
return(result);
}
public static PC.SchemaObjectCollection QuerySchemaObjectsById(string[] pIds)
{
if (pIds == null)
{
throw new ArgumentNullException("pIds");
}
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
builder.AppendItem("Status", (int)SchemaObjectStatus.Normal);
InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("ID");
inBuilder.AppendItem(pIds);
ConnectiveSqlClauseCollection connBuilder = new ConnectiveSqlClauseCollection();
connBuilder.Add(builder);
connBuilder.Add(inBuilder);
return(PC.Adapters.SchemaObjectAdapter.Instance.Load(connBuilder));
}
private object BuildWhere()
{
DbConnectionMappingContext.ClearAllMappings();
FormQueryCondition queryCondition = new FormQueryCondition()
{
Subject = this.Request.QueryString["sfSubject"],
CreateTimeBegin = GetRequestData <DateTime>("sfStart", DateTime.MinValue),
CreateTimeEnd = GetRequestData <DateTime>("sfEnd", DateTime.MinValue),
DraftDepartmentName = this.Request.QueryString["sfDept"] ?? string.Empty,
CurrentUsersName = this.Request.QueryString["sfApplicant"] ?? string.Empty,
ApplicationName = this.Request.QueryString[sfAppName.ClientID],
ProgramName_SinoOcean = this.Request.QueryString[sfProgramName.ClientID]
};
WhereSqlClauseBuilder builder = ConditionMapping.GetWhereSqlClauseBuilder(queryCondition,
new AdjustConditionValueDelegate(AdjustQueryConditionValue));
//申请部门
if (string.IsNullOrEmpty(queryCondition.DraftDepartmentName) == false)
{
builder.AppendItem("CONTAINS(DRAFT_DEPARTMENT_NAME," + GetFullTextParameter(queryCondition.DraftDepartmentName) + ")", "", "", true);
}
var allConditions = new ConnectiveSqlClauseCollection(builder);
//if (MostSupervisor == false || NormalSupervisior == false)
//{
// //检查是否具有分类授权
// WfApplicationAuthCollection authInfo = WfApplicationAuthAdapter.Instance.GetUserApplicationAuthInfo(DeluxeIdentity.Current.User);
// var builder2 = authInfo.GetApplicationAndProgramBuilder("APPLICATION_NAME", "PROGRAM_NAME");
// allConditions.Add(builder2);
//}
string whereCondition = allConditions.ToSqlString(TSqlBuilder.Instance);
return(whereCondition);
}
/// <summary>
/// 读取需要停止的频道
/// </summary>
/// <param name="leadTime">多长时间之内没有节目</param>
/// <returns></returns>
public AMSChannelCollection LoadNeedStopChannels(TimeSpan leadTime)
{
InSqlClauseBuilder inBuilder = new InSqlClauseBuilder("OuterC.State");
inBuilder.AppendItem(
AMSChannelState.Running.ToString(),
AMSChannelState.Starting.ToString(),
AMSChannelState.Stopping.ToString());
//得到从现在开始到leadTime时间段内，需要启动的节目
WhereSqlClauseBuilder startTimeBuilder = new WhereSqlClauseBuilder();
startTimeBuilder.AppendItem("E.StartTime", "GETUTCDATE()", ">=", true);
startTimeBuilder.AppendItem("E.StartTime",
string.Format("DATEADD(second, {0}, GETUTCDATE())", (int)leadTime.TotalSeconds),
"<", true);
//得到还没有结束的节目
WhereSqlClauseBuilder endTimeBuilder = new WhereSqlClauseBuilder();
endTimeBuilder.AppendItem("E.EndTime", "GETUTCDATE()", ">", true);
endTimeBuilder.AppendItem("E.EndTime",
string.Format("DATEADD(second, {0}, GETUTCDATE())", (int)leadTime.TotalSeconds),
"<=", true);
ConnectiveSqlClauseCollection connective = new ConnectiveSqlClauseCollection(LogicOperatorDefine.Or,
startTimeBuilder, endTimeBuilder);
//子查询，表示在未来一段时间内需要播放的节目
string subSql = string.Format("SELECT C.ID FROM AMS.Channels C INNER JOIN AMS.EventsChannels EC ON C.ID = EC.ChannelID INNER JOIN AMS.Events E ON EC.EventID = E.ID WHERE {0}",
connective.ToSqlString(TSqlBuilder.Instance));
string sql = string.Format("SELECT * FROM AMS.Channels OuterC WHERE {0} AND OuterC.ID NOT IN ({1})",
inBuilder.ToSqlStringWithInOperator(TSqlBuilder.Instance),
subSql);
return(this.QueryData(sql));
}
private string GetUpdateSql(string containerID, SCAclContainerOrMemberCollectionBase members)
{
return(VersionStrategyUpdateSqlHelper.ConstructUpdateSql(
null, (strB, context) =>
{
string tableName = this.GetMappingInfo().TableName;
ConnectiveSqlClauseCollection connectiveBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder();
WhereSqlClauseBuilder keyBuilder = new WhereSqlClauseBuilder();
keyBuilder.AppendItem("ContainerID", containerID);
connectiveBuilder.Add(keyBuilder);
strB.AppendFormat(
"UPDATE {0} SET VersionEndTime = {1} WHERE {2}",
tableName,
"@currentTime",
connectiveBuilder.ToSqlString(TSqlBuilder.Instance));
for (int i = 0; i < members.Count; i++)
{
SCAclItem aclitem = members[i];
aclitem.SortID = i;
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
aclitem.VersionEndTime = ConnectionDefine.MaxVersionEndTime;
InsertSqlClauseBuilder insertBuilder = ORMapping.GetInsertSqlClauseBuilder(aclitem, this.GetMappingInfo(), "VersionStartTime");
insertBuilder.AppendItem("VersionStartTime", "@currentTime", "=", true);
strB.AppendFormat("INSERT INTO {0}{1}", tableName, insertBuilder.ToSqlString(TSqlBuilder.Instance));
}
}));
}
/// <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));
}
/// <summary>
/// 载入管理单元Schema
/// </summary>
/// <param name="condition">包含查询条件的<see cref="IConnectiveSqlClause"/></param>
/// <param name="timePoint">时间点</param>
/// <param name="includingDeleted">是否包含删除的</param>
/// <returns></returns>
internal SchemaObjectCollection LoadAUSchema(IConnectiveSqlClause condition, bool normalOnly, DateTime timePoint)
{
//TODO:测试
string sql = @"SELECT O.* FROM SC.SchemaObject O INNER JOIN SC.AUSchemaSnapshot S
ON O.ID = S.ID AND O.VersionStartTime = S.VersionStartTime AND O.SchemaType = S.SchemaType
WHERE 1=1 AND ";
var timeCondition1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "S.");
var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "O.");
SchemaObjectCollection result = new SchemaObjectCollection();
ConnectiveSqlClauseCollection allConditions = new ConnectiveSqlClauseCollection(timeCondition1, timeCondition2, condition);
if (normalOnly)
{
allConditions.Add(new WhereSqlClauseBuilder().NormalFor("O.Status"));
}
sql += allConditions.ToSqlString(TSqlBuilder.Instance);
return(LoadSchemaObjects(sql));
}
/// <summary>
/// 根据下级名称，载入指定的管理单元
/// </summary>
/// <param name="name">下级名称</param>
/// <param name="parentID">父级ID</param>
/// <param name="childSchemaType">子级Schema类型</param>
/// <param name="normalOnly">是否仅包含正常对象</param>
/// <param name="timePoint">时间点</param>
/// <returns></returns>
public SchemaObjectCollection LoadAUByChildName(string name, string parentID, string childSchemaType, bool normalOnly, DateTime timePoint)
{
string sql = @"SELECT O.* FROM SC.SchemaObject O
INNER JOIN SC.AdminUnitSnapshot S ON O.ID = S.ID AND O.VersionStartTime = S.VersionStartTime AND O.SchemaType = S.SchemaType
INNER JOIN SC.SchemaRelationObjects R ON O.ID = R.ObjectID AND O.SchemaType = R.ChildSchemaType
WHERE 1=1 AND ";
var timeCondition1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "S.");
var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "O.");
var timeCondition3 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "R.");
WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
where.AppendItem("R.ParentID", parentID);
where.AppendItem("S.Name", name);
where.AppendItem("R.ChildSchemaType", childSchemaType);
if (normalOnly)
where.NormalFor("R.Status").NormalFor("O.Status");
sql += new ConnectiveSqlClauseCollection(timeCondition1, timeCondition2, timeCondition3, where).ToSqlString(TSqlBuilder.Instance);
return LoadSchemaObjects(sql);
}
protected void dataSourceMain_Selecting(object sender, ObjectDataSourceSelectingEventArgs e)
{
var allConditions = new ConnectiveSqlClauseCollection(this.DeluxeSearch.GetCondition());
var condition = this.CurrentAdvancedSearchCondition;
WhereSqlClauseBuilder builder = ConditionMapping.GetWhereSqlClauseBuilder(condition);
string categoryID = Request.QueryString["categoryID"];
if (!string.IsNullOrEmpty(categoryID))
{
DECategory dcg = CategoryAdapter.Instance.GetByID(categoryID);
dcg.FullPath += "%";
builder.AppendItem("CodeName", dcg.FullPath, string.Empty, "${DataField}$ like ${Data}$");
}
allConditions.Add(builder);
this.dataSourceMain.Condition = allConditions;
}
/// <summary>
/// 填充IN子句
/// </summary>
/// <param name="connectiveBuilder"></param>
/// <param name="condition"></param>
/// <param name="mapping"></param>
/// <param name="ignoreDefaultValue"></param>
/// <param name="acv"></param>
/// <param name="ignoreProperties">需要忽略的属性</param>
private static void FillInSqlClauseBuilderFromMapping(
ConnectiveSqlClauseCollection connectiveBuilder,
object condition,
IEnumerable <InConditionMappingItem> mapping,
bool ignoreDefaultValue,
AdjustConditionValueDelegate acv,
string[] ignoreProperties)
{
foreach (InConditionMappingItem item in mapping)
{
if (Array.Exists <string>(ignoreProperties, target => (string.Compare(target, item.PropertyName, true) == 0)) == false)
{
object data = GetValueFromObject(item, condition);
if (data != null)
{
InSqlClauseBuilder builder = new InSqlClauseBuilder(item.DataFieldName);
if (data is IEnumerable && data.GetType().IsPrimitive == false)
{
foreach (object dataItem in (IEnumerable)data)
{
DoAdjustValueAndAppendItem(dataItem, item, ignoreDefaultValue, acv,
(adJustedData) => builder.AppendItem(item.IsExpression, adJustedData));
}
}
else
{
DoAdjustValueAndAppendItem(data, item, ignoreDefaultValue, acv,
(adJustedData) => builder.AppendItem(item.IsExpression, adJustedData));
}
connectiveBuilder.Add(builder);
}
}
}
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
qc.FromClause = FromClause;
qc.SelectFields = SelectFields;
if (string.IsNullOrEmpty(this.orderBy))
{
qc.OrderByClause = this.DefaultOrderBy;
}
else
{
qc.OrderByClause = orderBy;
}
base.OnBuildQueryCondition(qc);
var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("R.");
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("O.");
builder.AppendItem(ParentIdField, parentId);
InnerBuildWhere(builder);
var schemaCondition1 = DataSourceUtil.SchemaTypeCondition("R.ChildSchemaType", this.ChildSchemaTypes);
var schemaCondition2 = DataSourceUtil.SchemaTypeCondition("R.ParentSchemaType", this.ParentSchemaTypes);
var allConditions = new ConnectiveSqlClauseCollection(builder, timeCondition, timeCondition2, schemaCondition1, schemaCondition2);
if (string.IsNullOrEmpty(qc.WhereClause))
{
qc.WhereClause = allConditions.ToSqlString(TSqlBuilder.Instance);
}
else
{
qc.WhereClause = allConditions.ToSqlString(TSqlBuilder.Instance) + " AND (" + qc.WhereClause + ")";
}
}
/// <summary>
/// 根据Container来加载UserAndContainerSnapshot的信息
/// </summary>
/// <param name="containerID"></param>
/// <param name="timePoint"></param>
/// <returns></returns>
public SameContainerUserAndContainerSnapshotCollection LoadByContainerID(string containerID, DateTime timePoint)
{
containerID.CheckStringIsNullOrEmpty("containerID");
ConnectiveSqlClauseCollection timePointBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint);
WhereSqlClauseBuilder whereBuilder = new WhereSqlClauseBuilder();
whereBuilder.AppendItem("ContainerID", containerID);
ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(whereBuilder, timePointBuilder);
string sql = string.Format("SELECT * FROM {0} WHERE {1}",
this.GetLoadingTableName(timePoint), connectiveBuilder.ToSqlString(TSqlBuilder.Instance));
SameContainerUserAndContainerSnapshotCollection result = new SameContainerUserAndContainerSnapshotCollection();
using (DbContext context = DbContext.GetContext(this.GetConnectionName()))
{
using (IDataReader reader = DbHelper.RunSqlReturnDR(sql, this.GetConnectionName()))
{
while (reader.Read())
{
UserAndContainerSnapshot item = new UserAndContainerSnapshot();
ORMapping.DataReaderToObject(reader, item);
if (result.ContainsKey(item.UserID) == false)
{
result.Add(item);
}
}
}
}
return(result);
}
/// <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);
}
/// <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);
}
}
private IConnectiveSqlClause GetCommonCondition()
{
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
builder.AppendItem("SEND_TO_USER", DeluxeIdentity.CurrentUser.ID);
WhereSqlClauseBuilder wBuilder1 = new WhereSqlClauseBuilder();
wBuilder1.AppendItem("EXPIRE_TIME", "null", "is", true);
WhereSqlClauseBuilder wBuilder2 = new WhereSqlClauseBuilder();
wBuilder2.AppendItem("EXPIRE_TIME", "not null", "is", true);
wBuilder2.AppendItem("EXPIRE_TIME", "getdate()", ">", true);
ConnectiveSqlClauseCollection collection = new ConnectiveSqlClauseCollection(LogicOperatorDefine.Or);
collection.Add(wBuilder1);
collection.Add(wBuilder2);
WhereSqlClauseBuilder wBuilder3 = new WhereSqlClauseBuilder();
wBuilder3.AppendItem("STATUS", TaskStatus.Yue.ToString("d"));
ConnectiveSqlClauseCollection collection1 = new ConnectiveSqlClauseCollection(LogicOperatorDefine.And);
collection1.Add(wBuilder3);
collection1.Add(collection);
ConnectiveSqlClauseCollection collection2 = new ConnectiveSqlClauseCollection(LogicOperatorDefine.Or);
WhereSqlClauseBuilder wBuilder4 = new WhereSqlClauseBuilder();
wBuilder4.AppendItem("STATUS", TaskStatus.Ban.ToString("d"));
collection2.Add(collection1);
collection2.Add(wBuilder4);
return(new ConnectiveSqlClauseCollection(builder, collection2));
}
public AURole LoadAURole(string schemaRoleID, string unitID, bool normalOnly, DateTime timePoint)
{
string sql = @"SELECT O.* FROM SC.SchemaObject O INNER JOIN SC.AURoleSnapshot S
ON O.ID = S.ID AND O.VersionStartTime = S.VersionStartTime AND O.SchemaType = S.SchemaType
INNER JOIN SC.SchemaMembers R ON O.ID = R.MemberID AND O.SchemaType = R.MemberSchemaType
WHERE";
WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
where.AppendCondition("S.SchemaRoleID", schemaRoleID);
where.AppendCondition("R.ContainerID", unitID);
where.NormalFor("R.Status");
if (normalOnly)
{
where.NormalFor("O.Status");
}
var timeCondition1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "S.");
var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "O.");
sql += new ConnectiveSqlClauseCollection(timeCondition1, timeCondition2, where).ToSqlString(TSqlBuilder.Instance);
return((AURole)LoadSchemaObjects(sql).FirstOrDefault());
}
/// <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;
}
private SchemaObjectCollection LoadAURolesInner(string[] unitIds, string[] schemaRoleIDs, bool normalOnly, DateTime timePoint)
{
string sql = @"SELECT O.* FROM SC.SchemaObject O INNER JOIN SC.AURoleSnapshot S
ON O.ID = S.ID AND O.VersionStartTime = S.VersionStartTime AND O.SchemaType = S.SchemaType
INNER JOIN SC.SchemaMembers R ON O.ID = R.MemberID AND O.SchemaType = R.MemberSchemaType
WHERE";
IConnectiveSqlClause inBuilder = DbBuilderHelper.In("S.SchemaRoleID", schemaRoleIDs);
IConnectiveSqlClause inBuilder2 = DbBuilderHelper.In("R.ContainerID", unitIds);
WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
if (normalOnly)
{
where.NormalFor("O.Status").NormalFor("R.Status");
}
var timeCondition1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "S.");
var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint, "O.");
sql += new ConnectiveSqlClauseCollection(timeCondition1, timeCondition2, where, inBuilder, inBuilder2).ToSqlString(TSqlBuilder.Instance);
return(LoadSchemaObjects(sql));
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
qc.FromClause = TimePointContext.Current.UseCurrentTime ? "SC.SchemaUserSnapshot_Current O INNER JOIN SC.UserAndContainerSnapshot_Current R ON O.ID = R.UserID" : "SC.SchemaUserSnapshot O INNER JOIN SC.UserAndContainerSnapshot R ON O.ID = R.UserID";
qc.SelectFields = "O.*";
if (string.IsNullOrEmpty(this.orderBy))
{
qc.OrderByClause = "R.VersionStartTime DESC";
}
else
{
qc.OrderByClause = orderBy;
}
base.OnBuildQueryCondition(qc);
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
var timeCondition1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("R.");
var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("O.");
builder.AppendItem("R.ContainerID", this.containerId);
InnerBuildWhere(builder);
builder.AppendItem("O.Status", (int)SchemaObjectStatus.Normal);
builder.AppendItem("R.Status", (int)SchemaObjectStatus.Normal);
var allConditions = new ConnectiveSqlClauseCollection(timeCondition1, timeCondition2, builder);
if (string.IsNullOrEmpty(qc.WhereClause))
{
qc.WhereClause = allConditions.ToSqlString(TSqlBuilder.Instance);
}
else
{
qc.WhereClause = allConditions.ToSqlString(TSqlBuilder.Instance) + " AND (" + qc.WhereClause + ")";
}
}
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();
}
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
base.OnBuildQueryCondition(qc);
qc.SelectFields = SelectFields;
qc.FromClause = this.FromSqlClause;
if (string.IsNullOrEmpty(qc.OrderByClause))
{
qc.OrderByClause = DefaultOrderByClause;
}
;
var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("S.");
var timeCondition1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("M.");
WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
var allConditions = new ConnectiveSqlClauseCollection(timeCondition, timeCondition1, where);
BuildWhere(where);
if (string.IsNullOrEmpty(qc.WhereClause) == false)
{
qc.WhereClause += " AND ";
}
qc.WhereClause += allConditions.ToSqlString(TSqlBuilder.Instance);
}
/// <summary>
/// 根据condition所提供的SQL查询条件查询
/// </summary>
/// <param name="condition"></param>
/// <param name="timePoint"></param>
/// <returns></returns>
public SCConditionCollection Load(IConnectiveSqlClause condition, DateTime timePoint)
{
ConnectiveSqlClauseCollection timePointBuilder = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder(timePoint);
ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection(condition, timePointBuilder);
string sql = string.Format("SELECT * FROM {0} WHERE {1} ORDER BY SortID",
this.GetMappingInfo().TableName,
connectiveBuilder.ToSqlString(TSqlBuilder.Instance));
SCConditionCollection result = new SCConditionCollection();
AUCommon.DoDbAction(() =>
{
using (DbContext context = DbContext.GetContext(this.GetConnectionName()))
{
using (IDataReader reader = DbHelper.RunSqlReturnDR(sql, this.GetConnectionName()))
{
ORMapping.DataReaderToCollection(result, reader);
}
}
});
return result;
}
protected void ObjectDataSourceSelecting(object sender, ObjectDataSourceSelectingEventArgs e)
{
if (e.ExecutingSelectCount == false)
{
e.InputParameters["authType"] = (WfApplicationAuthType)int.Parse(this.rdoList.SelectedValue);
if (views.ActiveViewIndex == 1)
{
if (string.IsNullOrEmpty(this.lastUser.Value))
{
e.Cancel = true;
}
else
{
e.InputParameters["appName"] = null;
e.InputParameters["programName"] = null;
e.InputParameters["authType"] = WfApplicationAuthType.None;
WfApplicationAuthCollection authInfo = WfApplicationAuthAdapter.Instance.GetUserApplicationAuthInfo(new OguUser(lastUser.Value));
string condition = "1=2";
if (authInfo.Count > 0)
{
ConnectiveSqlClauseCollection allMatch = new ConnectiveSqlClauseCollection(LogicOperatorDefine.Or);
foreach (var item in authInfo)
{
WhereSqlClauseBuilder where = new WhereSqlClauseBuilder();
where.AppendItem("APPLICATION_NAME", item.ApplicationName);
where.AppendItem("PROGRAM_NAME", item.ProgramName);
where.AppendItem("AUTH_TYPE", item.AuthType);
allMatch.Add(where);
}
condition = allMatch.ToSqlString(TSqlBuilder.Instance);
}
else
{
e.Cancel = true;
}
e.InputParameters["where"] = condition;
}
}
}
}
protected void DeluxeObjectDataSource1_Selecting(object sender, ObjectDataSourceSelectingEventArgs e)
{
if (e.ExecutingSelectCount == false)
{
WhereSqlClauseBuilder mappingbuilder = this.QueryCondition != null ? ConditionMapping.GetWhereSqlClauseBuilder(this.QueryCondition) : new WhereSqlClauseBuilder();
WhereSqlClauseBuilder where2 = (WhereSqlClauseBuilder)new WhereSqlClauseBuilder().AppendItem("SCHEDULE_ID", DBNull.Value, "IS NOT");
ConnectiveSqlClauseCollection all = new ConnectiveSqlClauseCollection(mappingbuilder, where2);
this.dataSourceMain.Condition = all;
}
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
qc.FromClause = FromClause;
qc.SelectFields = SelectFields;
if (this.orderBy.IsNullOrEmpty())
qc.OrderByClause = this.DefaultOrderBy;
else
qc.OrderByClause = orderBy;
base.OnBuildQueryCondition(qc);
WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();
var timeCondition = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("R.");
var timeCondition2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("O.");
builder.AppendItem(ParentIdField, parentId);
builder.AppendItem<int>("R.Status", (int)SchemaObjectStatus.Normal);
builder.AppendItem<int>("O.Status", (int)SchemaObjectStatus.Normal);
InnerBuildWhere(builder);
var conditionMemberCondition = DataSourceUtil.SchemaTypeCondition("R.MemberSchemaType", this.MemberSchemaTypes);
var conditionContainerCondition = DataSourceUtil.SchemaTypeCondition("R.ContainerSchemaType", this.ContainerSchemaTypes);
var allCondition = new ConnectiveSqlClauseCollection(builder, conditionMemberCondition, conditionMemberCondition, timeCondition, timeCondition2);
if (string.IsNullOrEmpty(qc.WhereClause))
{
qc.WhereClause = allCondition.ToSqlString(TSqlBuilder.Instance);
}
else
{
qc.WhereClause = allCondition.ToSqlString(TSqlBuilder.Instance) + " AND (" + qc.WhereClause + ")";
}
}
private void ExecQuery()
{
InitPageSize();
bindingControl.CollectData();
WhereSqlClauseBuilder builder = ConditionMapping.GetWhereSqlClauseBuilder(QueryCondition,
new AdjustConditionValueDelegate(AdjustQueryConditionValue));
builder.AppendItem("UT.STATUS", (int)TaskStatus.Ban);
//// LDM 流转中数据的获取
//if (null != Request.QueryString["process_status"] && Request.QueryString["process_status"] == "Running")
// builder.AppendItem("PN.STATUS", "Running");
//// LDM 已办结数据的获取
//if (null != Request.QueryString["process_status"] && Request.QueryString["process_status"] == "Completed")
// builder.AppendItem("ISNULL(PN.STATUS,N'Completed')", "Completed");
if (QueryCondition.ApplicationName == "全部")
{
QueryCondition.ApplicationName = "";
}
string subjectQueryString = string.Empty;
if (string.IsNullOrEmpty(QueryCondition.TaskTitle) == false)
{
StringBuilder subjectSB = new StringBuilder();
//关键词分割符为全角或半角空格
char[] separators = new char[] { ' ', ' ' };
string[] wordsSplitted = QueryCondition.TaskTitle.Split(separators, StringSplitOptions.RemoveEmptyEntries);
//将关键词构造为谓词查询格式
for (int i = 0; i < wordsSplitted.Length; i++)
{
if (i > 0)
{
subjectSB.Append(" AND ");
}
subjectSB.Append("\"");
subjectSB.Append(wordsSplitted[i].Replace("\"", "\"\""));
subjectSB.Append("\"");
}
subjectQueryString = string.Format("CONTAINS(TASK_TITLE,{0})", TSqlBuilder.Instance.CheckQuotationMark(subjectSB.ToString(), true));
}
WhereSqlClauseBuilder processStatusBuilder = new WhereSqlClauseBuilder(LogicOperatorDefine.Or);
switch (WebUtility.GetRequestQueryString("process_status", "Running"))
{
case "Running":
processStatusBuilder.AppendItem("PN.STATUS", "Running");
processStatusBuilder.AppendItem("PN.STATUS", "Maintaining");
break;
case "Completed":
processStatusBuilder.AppendItem("PN.STATUS", "Completed");
processStatusBuilder.AppendItem("PN.STATUS", "Aborted");
break;
}
ConnectiveSqlClauseCollection connectiveBuilder = new ConnectiveSqlClauseCollection();
connectiveBuilder.Add(builder).Add(processStatusBuilder);
if (connectiveBuilder.IsEmpty)
whereCondition.Value = subjectQueryString;
else if (subjectQueryString == string.Empty)
whereCondition.Value = connectiveBuilder.ToSqlString(TSqlBuilder.Instance);
else
whereCondition.Value = connectiveBuilder.ToSqlString(TSqlBuilder.Instance) + " AND " + subjectQueryString;
if (QueryCondition.DraftDepartmentName != string.Empty)
{
whereCondition.Value += string.Format(" AND CONTAINS(DRAFT_DEPARTMENT_NAME,'\"*"
+ TSqlBuilder.Instance.CheckQuotationMark(QueryCondition.DraftDepartmentName, false) + "*\"')");
}
whereCondition.Value += string.Format(" AND SEND_TO_USER = {0}",
TSqlBuilder.Instance.CheckQuotationMark(DeluxeIdentity.CurrentUser.ID, true));
LastQueryRowCount = -1;
this.GridViewTask.PageIndex = 0;
}
private string BuildWhereCondition()
{
WhereSqlClauseBuilder builder = ConditionMapping.GetWhereSqlClauseBuilder(this.Condition,
new AdjustConditionValueDelegate(AdjustQueryConditionValue));
builder.AppendItem("SEND_TO_USER", DeluxeIdentity.CurrentUser.ID);
WhereSqlClauseBuilder whereExpireTime = new WhereSqlClauseBuilder(LogicOperatorDefine.Or);
whereExpireTime.AppendItem("EXPIRE_TIME", "null", "is", true);
whereExpireTime.AppendItem("EXPIRE_TIME", "getdate()", ">", true);
WhereSqlClauseBuilder whereStatus = new WhereSqlClauseBuilder();
whereStatus.AppendItem("STATUS", ((int)TaskStatus.Yue).ToString());
var conditionGroup1 = new ConnectiveSqlClauseCollection(whereExpireTime, whereStatus);
WhereSqlClauseBuilder whereStatus2 = new WhereSqlClauseBuilder();
whereStatus2.AppendItem("STATUS", ((int)TaskStatus.Ban).ToString());
//collection2.Add(collection1);
ConnectiveSqlClauseCollection collection2 = new ConnectiveSqlClauseCollection(LogicOperatorDefine.Or, conditionGroup1, whereStatus2);
var allConditions = new ConnectiveSqlClauseCollection(builder, collection2);
return allConditions.ToSqlString(TSqlBuilder.Instance);
}
protected void ObjectDataSourceSelecting(object sender, ObjectDataSourceSelectingEventArgs e)
{
if (this.Condition == null)
{
var condition = this.CurrentAdvancedSearchCondition;
WhereSqlClauseBuilder builder = ConditionMapping.GetWhereSqlClauseBuilder(condition);
this.Condition = new ConnectiveSqlClauseCollection(builder, this.search1.GetCondition());
}
this.src1.Condition = this.Condition;
}
protected override void OnBuildQueryCondition(QueryCondition qc)
{
StringBuilder sb = new StringBuilder(1024);
var wbP1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("P1.");
var wbM = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("M.");
var wbM1 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("M1.");
var wbR2 = VersionStrategyQuerySqlBuilder.Instance.TimePointToBuilder("R2.");
var whereM = new WhereSqlClauseBuilder();
var whereR2 = new WhereSqlClauseBuilder();
var mConditions = new ConnectiveSqlClauseCollection(wbM, whereM);
var r2Conditions = new ConnectiveSqlClauseCollection(wbR2, whereR2);
whereM.AppendItem("M.MemberID", roleId);
whereR2.AppendItem("R2.ParentID", roleId);
string sqlWhere = qc.WhereClause;
if (string.IsNullOrEmpty(sqlWhere))
sqlWhere = wbM1.ToSqlString(TSqlBuilder.Instance);
else
sqlWhere = "(" + sqlWhere + ") AND " + wbM1.ToSqlString(TSqlBuilder.Instance);
sb.AppendFormat((TimePointContext.Current.UseCurrentTime ? @"(
SELECT P1.*,M1.InnerSort,M1.ContainerID as AppID
FROM SC.SchemaMembersSnapshot_Current M1
INNER JOIN SC.SchemaPermissionSnapshot_Current P1 ON M1.MemberID = P1.ID
WHERE
P1.Status = 1 AND
M1.Status = 1
AND {0}
AND {1}
AND M1.ContainerSchemaType = 'Applications' AND M1.MemberSchemaType = 'Permissions'
AND M1.ContainerID =
(SELECT M.ContainerID FROM
SC.SchemaMembersSnapshot_Current M
WHERE
{2}
AND M.ContainerSchemaType ='Applications'
AND M.MemberSchemaType = 'Roles'
AND M.Status = 1
)
) Q1 LEFT JOIN (
--查现有的权限
SELECT *
FROM SC.SchemaRelationObjectsSnapshot_Current R2
WHERE R2.ParentSchemaType = 'Roles'
AND R2.ChildSchemaType = 'Permissions'
AND R2.Status = 1
AND {3}
) Q2 ON Q1.ID = Q2.ObjectID"
: @"(
SELECT P1.*,M1.InnerSort,M1.ContainerID as AppID
FROM SC.SchemaMembersSnapshot M1
INNER JOIN SC.SchemaPermissionSnapshot P1 ON M1.MemberID = P1.ID
WHERE
P1.Status = 1 AND
M1.Status = 1
AND {0}
AND {1}
AND M1.ContainerSchemaType = 'Applications' AND M1.MemberSchemaType = 'Permissions'
AND M1.ContainerID =
(SELECT M.ContainerID FROM
SC.SchemaMembersSnapshot M
WHERE
{2}
AND M.ContainerSchemaType ='Applications'
AND M.MemberSchemaType = 'Roles'
AND M.Status = 1
)
) Q1 LEFT JOIN (
--查现有的权限
SELECT *
FROM SC.SchemaRelationObjectsSnapshot R2
WHERE R2.ParentSchemaType = 'Roles'
AND R2.ChildSchemaType = 'Permissions'
AND R2.Status = 1
AND {3}
) Q2 ON Q1.ID = Q2.ObjectID"), sqlWhere, wbP1.ToSqlString(TSqlBuilder.Instance), mConditions.ToSqlString(TSqlBuilder.Instance), r2Conditions.ToSqlString(TSqlBuilder.Instance));
qc.FromClause = sb.ToString();
qc.WhereClause = "";
if (string.IsNullOrEmpty(qc.OrderByClause))
qc.OrderByClause = "Q1.InnerSort";
qc.SelectFields = "Q1.*,Q2.ObjectID AS ApplyID";
base.OnBuildQueryCondition(qc);
}
