public virtual string GenerateSqlString(IConditionGroup conditionGroup) { var conditionString = string.Empty; ConcatConditionGroup(ref conditionString, LogicalOperator.And, conditionGroup, string.Empty, string.Empty); return(string.IsNullOrEmpty(conditionString) ? null : GetCheckedConditionString(conditionString)); }
/// <summary> /// Evaluates the file type expressions within a condition group to determine whether they are all valid. /// For now, we assume that the conditionGroup.Conditions collection contains only ICondition objects. If there /// are any IPolicyObject objects within the collection that are not ICondition, these will not be validated. /// Validation is only performed on ConditionGroups with AND logic. /// </summary> /// <param name="conditionGroup">The condition group to evaluae</param> /// <returns></returns> private static bool ValidateIntraPolicyConditionGroup(IConditionGroup conditionGroup) { //For now, we only validate on AND logic if (ConditionLogic.AND == conditionGroup.Logic) { List<Workshare.Policy.FileType> fileTypesInConditionGroup = new List<Workshare.Policy.FileType>(); foreach (IPolicyObject policyObject in conditionGroup.Conditions) { if (policyObject is ICondition) { if (!ValidateIntraPolicyCondition((ICondition)policyObject, fileTypesInConditionGroup)) { return false; } } else { //the following is for the developer - we are only expecting to find expressions in a //Policy -> ConditionGroup -> Condition structure. You're in this code because presumably //we have now changed the way we structure expressions System.Resources.ResourceManager resourceManager = new System.Resources.ResourceManager("Workshare.Policy.Properties.Resources", typeof(PolicySuites).Assembly); string message = resourceManager.GetString("VALIDATION_INTRAPOLICY_EXPRESSIONS_UNSUPPORTEDSTRUCTURE", System.Globalization.CultureInfo.InvariantCulture); Logger.LogError(message); System.Diagnostics.Debug.Assert(false, message); } } } return true; }
private void ConcatConditionGroup(ref string conditionString, LogicalOperator concatOperator, IConditionGroup conditionGroup, string groupPrefix = "(", string groupPostfix = ")") { var groupString = string.Empty; foreach (var condition in conditionGroup.Conditions) { if (condition is IConditionGroup) { ConcatConditionGroup(ref groupString, conditionGroup.ConcatOperator, (IConditionGroup)condition); } else if (condition is IFieldCondition) { ConcatFieldCondition(ref groupString, conditionGroup.ConcatOperator, (IFieldCondition)condition); } else if (condition is IConditionString) { ConcatConditionString(ref groupString, conditionGroup.ConcatOperator, (IConditionString)condition); } } if (string.IsNullOrEmpty(groupString)) { return; } conditionString = string.Concat(conditionString, GetOperatorStringIfStringIsNotEmpty(conditionString, concatOperator), groupPrefix, groupString, groupPostfix); }
// ReSharper disable MemberCanBePrivate.Global // ReSharper disable UnusedMethodReturnValue.Global public IConditionGroup Add(IConditionGroup group) // ReSharper restore UnusedMethodReturnValue.Global // ReSharper restore MemberCanBePrivate.Global { base.Add(group); return(this); }
/// <summary> /// Evaluates the filesize expressions within a condition group to determine whether they are valid. /// For now, we assume that ConditionGroup.Conditions will contain only ICondition objects. Any other /// IPolicyObject objects in the collection will not be validated. /// </summary> /// <param name="conditionGroup">The condition group to evaluate</param> /// <returns></returns> private static bool ValidateIntraPolicyConditionGroup(IConditionGroup conditionGroup) { ValidRangeCollection validFileSizeRanges = new ValidRangeCollection(); if (ConditionLogic.AND == conditionGroup.Logic) { //only need to validate on condition groups with AND logic foreach (IPolicyObject policyObject in conditionGroup.Conditions) { if (policyObject is ICondition) { validFileSizeRanges.Remove(GetInvalidRangesFromExpression((ICondition)policyObject)); } else { //the following is for the developer - we are only expecting to find expressions in a //Policy -> ConditionGroup -> Condition structure. You're in this code because presumably //we have now changed the way we structure expressions System.Resources.ResourceManager resourceManager = new System.Resources.ResourceManager("Workshare.Policy.Properties.Resources", typeof(PolicySuites).Assembly); string message = resourceManager.GetString("VALIDATION_INTRAPOLICY_EXPRESSIONS_UNSUPPORTEDSTRUCTURE", System.Globalization.CultureInfo.InvariantCulture); Logger.LogError(message); System.Diagnostics.Debug.Assert(false, message); } } } return (validFileSizeRanges.ValidRanges.Count != 0); }
/// <summary> /// 物理删除数据库中已经标记删除的数据 /// </summary> /// <param name="condition"></param> public void PhysicalDelete(ICondition condition) { IConditionGroup group = RepositoryHelper.ToConditionGroup(condition).Add(isLogicDeleteCondition); session.CreateQuery(string.Format("DELETE FROM {0} WHERE {1}", entityType.Name, group.ToHql())). SetParameters(group.Parameters).ExecuteUpdate(); }
/// <summary> /// 按条件查询结果集 /// </summary> /// <param name="condition">条件</param> /// <returns>返回的结果集</returns> public IList <TEntity> Query(ICondition condition) { IConditionGroup group = RepositoryHelper.ToConditionGroup(condition).Add(isLogicDeleteCondition); return (session.CreateQuery(string.Format("FROM {0} WHERE {1}", entityType.Name, group.ToHql())).SetParameters( group.Parameters).List <TEntity>()); }
/// <summary> /// 得到指定条件的查询结果 /// 如果条件可返回多条记录,则只返回第一条 /// </summary> /// <param name="condition">条件</param> /// <returns>返回的对象</returns> public TEntity Get(ICondition condition) { IConditionGroup group = RepositoryHelper.ToConditionGroup(condition).Add(isLogicDeleteCondition); return (session.CreateQuery(string.Format("FROM {0} where {1}", entityType.Name, group.ToHql())).SetParameters( group.Parameters).SetMaxResults(1).UniqueResult <TEntity>()); }
/// <summary> /// 得到指定条件记录的数量 /// </summary> /// <param name="condition">查询条件</param> /// <returns></returns> public int Count(ICondition condition) { IConditionGroup group = RepositoryHelper.ToConditionGroup(condition).Add(isLogicDeleteCondition); return (session.CreateQuery(string.Format("SELECT COUNT(ID) FROM {0} where {1}", entityType.Name, group.ToHql())) .SetParameters(group.Parameters).UniqueResult <int>()); }
/// <summary> /// 得到指定条件记录的数量 /// </summary> /// <param name="condition"></param> /// <returns></returns> public int Count(ICondition condition) { IConditionGroup cg = RepositoryHelper.ToConditionGroup(condition); return (session.CreateQuery(string.Format("Select COUNT(ID) From {0} WHERE {1}", entityType.Name, cg.ToHql())). SetParameters(cg.Parameters).UniqueResult <int>()); }
/// <summary> /// 分页查询 /// </summary> /// <param name="condition">条件</param> /// <param name="orderBy">排序条件</param> /// <param name="pageSize">页大小</param> /// <param name="pageNum">页码</param> /// <returns></returns> public IList <TEntity> QueryPage(ICondition condition, OrderByGroup orderBy, int pageSize, int pageNum) { IConditionGroup group = RepositoryHelper.ToConditionGroup(condition).Add(isLogicDeleteCondition); return (session.CreateQuery(string.Format("FROM {0} where {1} Order By {2}", entityType.Name, group.ToHql(), orderBy.ToHql())).SetParameters(group.Parameters).SetFirstResult( (pageNum - 1) * pageSize).SetMaxResults(pageNum).List <TEntity>()); }
public string GenerateConditionString(IConditionGroup conditionGroup) { if (conditionGroup == null) { return(string.Empty); } var conditionString = ConditionConverter.GenerateSqlString(conditionGroup); return(string.IsNullOrEmpty(conditionString) ? string.Empty : conditionString); }
public ConditionGroup(ConditionGroup conditionGroup, IPolicyObjectCollection<IPolicyObject> conditions) : base(conditionGroup) { if (null == conditionGroup) throw new Workshare.Policy.Exceptions.ArgumentNullException("conditionGroup", "Input condition group is null"); m_parent = conditionGroup.m_parent; m_logic = conditionGroup.Logic; m_exitOnFirstPass = conditionGroup.ExitOnFirstPass; m_conditions = new PolicyObjectCollection<IPolicyObject>(conditions as PolicyObjectCollection<IPolicyObject>); }
/// <summary> /// 按条件查询结果集 /// </summary> /// <param name="condition">条件</param> /// <param name="orderBy">排序条件</param> /// <param name="includeLogicDelete">是否包含逻辑删除的数据</param> /// <returns>返回的结果集</returns> public IList <TEntity> Query(ICondition condition, OrderByGroup orderBy, bool includeLogicDelete) { IConditionGroup group = RepositoryHelper.ToConditionGroup(condition); if (!includeLogicDelete) { group = group.Add(isLogicDeleteCondition); } return (session.CreateQuery(string.Format("FROM {0} WHERE {1} ORDER BY {2}", entityType.Name, group.ToHql(), orderBy.ToHql())).List <TEntity>()); }
private static void AddForensicCategoryIDs(IConditionGroup conditionGroup, Dictionary<Guid, bool> categoryIDs) { if (conditionGroup == null || conditionGroup.Conditions == null) { return; } foreach (ICondition condition in conditionGroup.Conditions) { AddForensicCategoryIDs(condition, categoryIDs); } }
/// <summary> /// 分布查询 /// </summary> /// <param name="condition">查询条件</param> /// <param name="orderBy">排序条件</param> /// <param name="includeLogicDelete">是否包含逻辑删除数据</param> /// <param name="pageSize">页大小</param> /// <param name="pageNum">页码</param> /// <returns></returns> public IList <TEntity> QueryPage(ICondition condition, OrderByGroup orderBy, bool includeLogicDelete, int pageSize, int pageNum) { IConditionGroup group = RepositoryHelper.ToConditionGroup(condition); if (!includeLogicDelete) { group = group.Add(isLogicDeleteCondition); } return (session.CreateQuery(string.Format("FROM {0} WHERE {1} ORDER BY {2}", entityType.Name, group.ToHql(), orderBy.ToHql())).SetFirstResult((pageNum - 1) * pageSize).SetMaxResults (pageSize).List <TEntity>()); }
private void CopyConditionGroup(ConditionGroup conditionGroup) { if (null == conditionGroup) throw new Workshare.Policy.Exceptions.ArgumentNullException("conditionGroup", "Input condition group is null"); m_parent = conditionGroup.m_parent; m_logic = conditionGroup.Logic; m_exitOnFirstPass = conditionGroup.ExitOnFirstPass; m_policySetObserver = conditionGroup.PolicySetObserver; if (null != conditionGroup.Conditions) { m_conditions = new PolicyObjectCollection<IPolicyObject>(conditionGroup.Conditions as PolicyObjectCollection<IPolicyObject>); (m_conditions as PolicyObjectCollection<IPolicyObject>).PolicySetObserver = m_policySetObserver; } }
public Condition(Condition condition, bool readOnly, bool createNewId) : base(condition, readOnly, createNewId) { if (null == condition) { Utilities.ErrorMessage errorMessage = new Utilities.ErrorMessage( "INPUT_CONDITION_NULL", "Workshare.Policy.Properties.Resources", Assembly.GetExecutingAssembly()); Logger.LogError(errorMessage.LogString); throw new Workshare.Policy.Exceptions.ArgumentNullException("condition", errorMessage.DisplayString); } m_parent = condition.m_parent; m_policySetObserver = condition.m_policySetObserver; m_isNegated = condition.m_isNegated; SetDefaults(condition.Class, condition.Operator, condition.m_dataLeft, createNewId); }
/// <summary> /// Removes a ConditionGroup from a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the ConditionGroup</param> /// <param name="conditionGroup">The ConditionGroup to remove</param> private static void RemoveConditionGroup(IPolicySet policySet, IConditionGroup conditionGroup) { if ((null == policySet) || (null == conditionGroup)) { return; } foreach(IPolicyObject conditionOrGroup in conditionGroup.Conditions) { if (conditionOrGroup is ICondition) { RemoveCondition(policySet, conditionOrGroup as ICondition); } else if (conditionOrGroup is IConditionGroup) { RemoveConditionGroup(policySet, conditionOrGroup as IConditionGroup); } } //do extra processing on the IActionConditionGroup specialization if (conditionGroup is IActionConditionGroup) { RemoveActionGroup(policySet, ((IActionConditionGroup)conditionGroup).ActionGroup); } policySet.MasterCatalogue.ConditionGroups.Remove(conditionGroup); }
public void WriteConditionGroup(IPolicySet policySet, IPolicyObject parent, IConditionGroup group) { for (int i = 0; i < group.Conditions.Count; ++i) { if (group.Conditions[i] is ICondition) { WriteCondition(policySet, group, group.Conditions[i] as ICondition, group.Logic); } else if (group.Conditions[i] is IConditionGroup) { WriteConditionGroup(policySet, parent, group.Conditions[i] as IConditionGroup); } } }
public void WriteConditionGroup(IConditionGroup conditionGroup) { if (null == conditionGroup) return; CollectionInserter<IConditionGroup>.Insert(m_conditionGroups, conditionGroup); }
public IConditionGroup Add(IConditionGroup group) { EmbeddedStatements.Add(group); return(this); }
/// <summary> /// 增加一个条件组 /// </summary> /// <param name="conditionGroup"></param> /// <returns></returns> public IConditionGroup Add(IConditionGroup conditionGroup) { conditions.Add(conditionGroup); return(this); }
/// <summary> /// Recursively searches for a condition, or condition group, in a condition group /// </summary> /// <param name="conditionGroup">The condition group to search</param> /// <param name="policyObject">The object to find</param> /// <returns>true if an object is found with GUID that matches that of the object to find</returns> public static bool ContainsConditionOrConditionGroup(IConditionGroup conditionGroup, IPolicyObject policyObject) { if (!((policyObject is ICondition) || (policyObject is IConditionGroup))) { throw new ArgumentException("Unexpected data type"); } foreach (IPolicyObject childPolicyObject in conditionGroup.Conditions) { if (childPolicyObject is IConditionGroup) { if (ContainsConditionOrConditionGroup((IConditionGroup) childPolicyObject, policyObject)) { return true; } } else if (childPolicyObject is ICondition) { if (childPolicyObject.Identifier == policyObject.Identifier) { return true; } } } if (conditionGroup.Identifier == policyObject.Identifier) { return true; } return false; }
/// <summary> /// Recursively changes the condition logic on all condition groups /// </summary> /// <param name="conditionGroup">Condition group to change</param> /// <param name="logic">Condition Group logic</param> public static void ChangeConditionGroupLogic(IConditionGroup conditionGroup, ConditionLogic logic) { foreach (IPolicyObject policyObject in conditionGroup.Conditions) { if (policyObject is IConditionGroup) { ChangeConditionGroupLogic((IConditionGroup) policyObject, logic); } } conditionGroup.Logic = logic; }
/// <summary> /// Adds a condition to a condition group /// </summary> /// <param name="condition">The condition, or condition group, to add</param> /// <returns>True if the condition, or condition group, is successfully added, otherwise false</returns> protected bool AddCondition(IConditionGroup conditionGroup, IPolicyObject condition) { if (!((condition is ICondition) || (condition is IConditionGroup))) { ArgumentException ex = new ArgumentException("Object to add is not a condition or condition group"); Logger.LogError(ex.Message); throw ex; } if (ConditionUnitFactory.ContainsConditionOrConditionGroup(conditionGroup, condition)) { return false; } m_conditionGroup.Conditions.Add(condition); if (condition is ICondition) { ((ICondition)condition).Parent = m_conditionGroup; } else { ((IConditionGroup)condition).Parent = m_conditionGroup; } SetChildFormModifiedFlag(); return true; }
public ConditionEventArgs(IConditionGroup conditionGroup, IHyperlinkObject hyperlinkObject) { m_conditionGroup = conditionGroup; m_hyperlinkObject = hyperlinkObject; }
public ConditionEventArgs(IConditionGroup conditionGroup, ConditionDisplayBase conditionMethodDisplay, IHyperlinkObject hyperlinkObject) { m_conditionGroup = conditionGroup; m_hyperlinkObject = hyperlinkObject; Add(conditionMethodDisplay); }
public void WriteConditionGroup(IPolicySet policySet, IPolicyObject parent, IConditionGroup group) { ICataloguePolicy parentCataloguePolicy = parent as ICataloguePolicy; if (null == parentCataloguePolicy) return; IPolicy policy = new P5Policy(policySet, parentCataloguePolicy.Identifier, parentCataloguePolicy.Name, parentCataloguePolicy.Status); policy.Conditions.Add(group); WriteChildCollection(policySet, policy, parentCataloguePolicy.Name.Value, policy.Conditions); }