public CompareExpression(ComparisonOperator operation, IExpression left, IExpression right) : base(left, right) { this.operation = operation; switch (operation) { case ComparisonOperator.Equal: this.function = Operators.CompareObjectEqual; break; case ComparisonOperator.NotEqual: this.function = Operators.CompareObjectNotEqual; break; case ComparisonOperator.Less: this.function = Operators.CompareObjectLess; break; case ComparisonOperator.LessEqual: this.function = Operators.CompareObjectLessEqual; break; case ComparisonOperator.Greater: this.function = Operators.CompareObjectGreater; break; case ComparisonOperator.GreaterEqual: this.function = Operators.CompareObjectGreaterEqual; break; } }
/** * A factory method allowing to create a conditional formatting rule * with a cell comparison operator<p/> * TODO - formulas Containing cell references are currently not Parsed properly * * @param comparisonOperation - a constant value from * <tt>{@link NPOI.hssf.record.CFRuleRecord.ComparisonOperator}</tt>: <p> * <ul> * <li>BETWEEN</li> * <li>NOT_BETWEEN</li> * <li>EQUAL</li> * <li>NOT_EQUAL</li> * <li>GT</li> * <li>LT</li> * <li>GE</li> * <li>LE</li> * </ul> * </p> * @param formula1 - formula for the valued, Compared with the cell * @param formula2 - second formula (only used with * {@link NPOI.ss.usermodel.ComparisonOperator#BETWEEN}) and * {@link NPOI.ss.usermodel.ComparisonOperator#NOT_BETWEEN} operations) */ public IConditionalFormattingRule CreateConditionalFormattingRule( ComparisonOperator comparisonOperation, String formula1, String formula2) { XSSFConditionalFormattingRule rule = new XSSFConditionalFormattingRule(_sheet); CT_CfRule cfRule = rule.GetCTCfRule(); cfRule.AddFormula(formula1); if (formula2 != null) cfRule.AddFormula(formula2); cfRule.type = (ST_CfType.cellIs); ST_ConditionalFormattingOperator operator1; switch (comparisonOperation) { case ComparisonOperator.BETWEEN: operator1 = ST_ConditionalFormattingOperator.between; break; case ComparisonOperator.NOT_BETWEEN: operator1 = ST_ConditionalFormattingOperator.notBetween; break; case ComparisonOperator.LT: operator1 = ST_ConditionalFormattingOperator.lessThan; break; case ComparisonOperator.LE: operator1 = ST_ConditionalFormattingOperator.lessThanOrEqual; break; case ComparisonOperator.GT: operator1 = ST_ConditionalFormattingOperator.greaterThan; break; case ComparisonOperator.GE: operator1 = ST_ConditionalFormattingOperator.greaterThanOrEqual; break; case ComparisonOperator.EQUAL: operator1 = ST_ConditionalFormattingOperator.equal; break; case ComparisonOperator.NOT_EQUAL: operator1 = ST_ConditionalFormattingOperator.notEqual; break; default: throw new ArgumentException("Unknown comparison operator: " + comparisonOperation); } cfRule.@operator = (operator1); return rule; }
public static string Parse(ComparisonOperator comparisonOperator, string param) { switch (comparisonOperator) { case ComparisonOperator.Contains: return string.Format("Like '%{0}%'", HttpUtility.UrlEncode(SoqlUtil.Escape(param))); case ComparisonOperator.Equals: return string.Format("='{0}'", HttpUtility.UrlEncode(SoqlUtil.Escape(param))); case ComparisonOperator.GreaterOrEqual: return string.Format(">='{0}'", HttpUtility.UrlEncode(SoqlUtil.Escape(param))); case ComparisonOperator.GreaterThan: return string.Format(">'{0}'", HttpUtility.UrlEncode(SoqlUtil.Escape(param))); case ComparisonOperator.In: return string.Format(" IN ({0})", HttpUtility.UrlEncode(SoqlUtil.Escape(param))); case ComparisonOperator.LessOrEqual: return string.Format("<='{0}'", HttpUtility.UrlEncode(SoqlUtil.Escape(param))); case ComparisonOperator.LessThan: return string.Format("<'{0}'", HttpUtility.UrlEncode(SoqlUtil.Escape(param))); case ComparisonOperator.NotEquals: return string.Format("!='{0}'", HttpUtility.UrlEncode(SoqlUtil.Escape(param))); case ComparisonOperator.NotIn: return string.Format("NOT IN ({0})", HttpUtility.UrlEncode(SoqlUtil.Escape(param))); case ComparisonOperator.StartsWith: return string.Format("Like '{0}%'", HttpUtility.UrlEncode(SoqlUtil.Escape(param))); default: return ""; } }
// Constructors public QueryStrings(int fieldId, ComparisonOperator comparisonOp, string matchingValue, LogicalOperator logicalOp) { FieldId = fieldId; ComparisonOp = comparisonOp; MatchingValue = matchingValue; LogicalOp = logicalOp; }
public CompareExpression(ComparisonOperator operation, IExpression left, IExpression right) : base(left, right) { this.operation = operation; switch (operation) { case ComparisonOperator.NonStrictEqual: this.function = NonStrictEqual; break; case ComparisonOperator.NonStrictNotEqual: this.function = NonStrictNotEqual; break; case ComparisonOperator.Equal: this.function = Operators.CompareObjectEqual; break; case ComparisonOperator.NotEqual: this.function = Operators.CompareObjectNotEqual; break; case ComparisonOperator.Less: this.function = Operators.CompareObjectLess; break; case ComparisonOperator.LessEqual: this.function = Operators.CompareObjectLessEqual; break; case ComparisonOperator.Greater: this.function = Operators.CompareObjectGreater; break; case ComparisonOperator.GreaterEqual: this.function = Operators.CompareObjectGreaterEqual; break; default: throw new ArgumentException("Invalid operator"); } }
public DateDiffCompareValidator(ValueAccess valueAccess, ComparisonOperator comparisonOperator, int dateDiff) : base(valueAccess, comparisonOperator) { this.valueAccess = valueAccess; this.comparisonOperator = comparisonOperator; this.dateDiff = dateDiff; }
///<summary> ///</summary> ///<param name="propLeft"></param> ///<param name="comparisonOperator"></param> ///<param name="propRight"></param> ///<exception cref="ArgumentNullException"></exception> public InterPropRule(IPropDef propLeft, ComparisonOperator comparisonOperator, IPropDef propRight) { if (propLeft == null) throw new ArgumentNullException("propLeft"); if (propRight == null) throw new ArgumentNullException("propRight"); LeftProp = propLeft; ComparisonOp = comparisonOperator; RightProp = propRight; }
public FilterOperation(string inKey, string outKey, string outType, object value, ComparisonOperator comparisonOperator) : base(inKey, outKey) { _value = Common.GetObjectConversionMap()[outType](value); _comparisonOperator = comparisonOperator; Name = string.Format("FilterOperation ({0})", outKey); IsFilter = true; }
public IConditionalFormattingRule CreateConditionalFormattingRule( ComparisonOperator comparisonOperation, String formula1) { HSSFWorkbook wb = (HSSFWorkbook)_sheet.Workbook; CFRuleRecord rr = CFRuleRecord.Create(_sheet, (byte)comparisonOperation, formula1, null); return new HSSFConditionalFormattingRule(wb, rr); }
//************************************************************************* // Constructor: NumericComparisonColumnAutoFillUserSettings() // /// <summary> /// Initializes a new instance of the /// NumericComparisonColumnAutoFillUserSettings class. /// </summary> //************************************************************************* public NumericComparisonColumnAutoFillUserSettings() { m_eComparisonOperator = ComparisonOperator.GreaterThan; m_dSourceNumberToCompareTo = 0; m_sDestinationString1 = null; m_sDestinationString2 = null; AssertValid(); }
public NodeComparison(Int64 size, ComparisonOperator comparison = null) { this.Size = size; if (comparison == null) this.Operator = ComparisonOperator.Equals; else this.Operator = comparison; }
/// <summary> /// Initializes a new instance of the <see cref="ValueAccessComparisonValidator"/> class. /// </summary> /// <param name="valueAccess">The <see cref="ValueAccess"/> to use when extracting the comparison operand.</param> /// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> that specifies the kind of /// comparison to perform.</param> /// <param name="messageTemplate">The message template to use when logging validation failures.</param> /// <param name="tag">The tag that describes the purpose of the validator.</param> public ValueAccessComparisonValidator(ValueAccess valueAccess, ComparisonOperator comparisonOperator, string messageTemplate, string tag) : this(valueAccess, comparisonOperator, messageTemplate, tag, false) { this.valueAccess = valueAccess; this.comparisonOperator = comparisonOperator; }
public PropertyComparisonValidatorAttribute(string propertyToCompare, ComparisonOperator comparisonOperator) { if (propertyToCompare == null) { throw new ArgumentNullException("propertyToCompare"); } this.propertyToCompare = propertyToCompare; this.comparisonOperator = comparisonOperator; }
/// <summary> /// Initializes a new instance of the <see cref="ValueAccessComparisonValidator"/> class. /// </summary> /// <param name="valueAccess">The <see cref="ValueAccess"/> to use when extracting the comparison operand.</param> /// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> that specifies the kind of /// comparison to perform.</param> /// <param name="messageTemplate">The message template to use when logging validation failures.</param> /// <param name="negated">Indicates if the validation logic represented by the validator should be negated.</param> public ValueAccessComparisonValidator(ValueAccess valueAccess, ComparisonOperator comparisonOperator, string messageTemplate, bool negated) : this(valueAccess, comparisonOperator, messageTemplate, null, negated) { this.valueAccess = valueAccess; this.comparisonOperator = comparisonOperator; }
public ValueAccessComparisonValidator(ValueAccess valueAccess, ComparisonOperator comparisonOperator, string messageTemplate, string tag, bool negated) : base(messageTemplate, tag, negated) { if (valueAccess == null) { throw new ArgumentNullException("valueAccess"); } this.valueAccess = valueAccess; this.comparisonOperator = comparisonOperator; }
/// <summary> /// A factory method allowing to Create a conditional formatting rule /// with a cell comparison operator /// TODO - formulas containing cell references are currently not Parsed properly /// </summary> /// <param name="comparisonOperation">a constant value from HSSFConditionalFormattingRule.ComparisonOperator</param> /// <param name="formula1">formula for the valued, Compared with the cell</param> /// <param name="formula2">second formula (only used with HSSFConditionalFormattingRule#COMPARISON_OPERATOR_BETWEEN /// and HSSFConditionalFormattingRule#COMPARISON_OPERATOR_NOT_BETWEEN operations)</param> /// <returns></returns> public HSSFConditionalFormattingRule CreateConditionalFormattingRule( ComparisonOperator comparisonOperation, String formula1, String formula2) { HSSFWorkbook wb = _workbook; CFRuleRecord rr = CFRuleRecord.Create(wb, comparisonOperation, formula1, formula2); return new HSSFConditionalFormattingRule(wb, rr); }
public Clause(string ColumnName, ComparisonOperator Operator, object Value) { Contract.Requires(ColumnName != null); this.ColumnName = ColumnName; this.Operator = Operator; this.Value = Value; this.CaseSensitive = true; this.Level = 1; }
public void Serialize_ComparisionFilter(ComparisonOperator op, string expectedJson) { var filters = new SearchFilterCollection { new ComparisonFilter(x => x.NutritionFact_Calories){Operator = op, Value = 100} }; string json = JsonConvert.SerializeObject(filters); StringAssert.Contains(expectedJson, json); }
public wDBRowCollection Where(string what, ComparisonOperator op, object operand) { string operandTwo = ""; if (operand is int) operandTwo = ((int)operand).ToString(); else if (operand is string) operandTwo = (string)operand; else if (operand is bool) operandTwo = ((bool)operand) ? "1" : "0"; wDBRowCollection newCollection = new wDBRowCollection(); for (int i = 0; i < this.rows.Count; i++) { string operandOne = this.rows[i][what]; double opOne = 0, opTwo = 0; double.TryParse(operandOne, out opOne); double.TryParse(operandTwo, out opTwo); switch(op) { case ComparisonOperator.Is: if(operandOne == operandTwo) newCollection.rows.Add(this.rows[i]); break; case ComparisonOperator.IsNot: if(operandOne != operandTwo) newCollection.rows.Add(this.rows[i]); break; case ComparisonOperator.LessThan: if(opOne < opTwo) newCollection.rows.Add(this.rows[i]); break; case ComparisonOperator.LessThanEqualTo: if(opOne <= opTwo) newCollection.rows.Add(this.rows[i]); break; case ComparisonOperator.GreaterThan: if(opOne > opTwo) newCollection.rows.Add(this.rows[i]); break; case ComparisonOperator.GreaterThanEqualTo: if(opOne >= opTwo) newCollection.rows.Add(this.rows[i]); break; case ComparisonOperator.StartsWith: { if (operandOne.StartsWith(operandTwo)) { newCollection.rows.Add(this.rows[i]); } break; } } } return newCollection; }
public static string Parse(ComparisonOperator comparisonOperator, string param1, string param2) { Assert.ArgumentNotNull(param1, "param1"); Assert.ArgumentNotNull(param2, "param2"); switch (comparisonOperator) { case ComparisonOperator.DoesNotContain: return string.Format("Not {0} Like '%{1}%'", HttpUtility.UrlEncode(SoqlUtil.Escape(param1)), HttpUtility.UrlEncode(SoqlUtil.Escape(param2))); default: return ""; } }
public NodeComparison(string value) { if (value.Contains(ComparisonOperator.GreaterThan.ToString())) { Size = Convert.ToInt64(value.Replace(ComparisonOperator.GreaterThan.ToString(), "")); Operator = ComparisonOperator.GreaterThan; } else if (value.Contains(ComparisonOperator.GreaterThan.Alternate)) { Size = Convert.ToInt64(value.Replace(ComparisonOperator.GreaterThan.Alternate, "")); Operator = ComparisonOperator.GreaterThan; } else if (value.Contains(ComparisonOperator.GreaterThanOrEqual.ToString())) { Size = Convert.ToInt64(value.Replace(ComparisonOperator.GreaterThanOrEqual.ToString(), "")); Operator = ComparisonOperator.GreaterThanOrEqual; } else if (value.Contains(ComparisonOperator.GreaterThanOrEqual.Alternate)) { Size = Convert.ToInt64(value.Replace(ComparisonOperator.GreaterThanOrEqual.Alternate, "")); Operator = ComparisonOperator.GreaterThanOrEqual; } else if (value.Contains(ComparisonOperator.LessThan.ToString())) { Size = Convert.ToInt64(value.Replace(ComparisonOperator.LessThan.ToString(), "")); Operator = ComparisonOperator.LessThan; } else if (value.Contains(ComparisonOperator.LessThan.Alternate)) { Size = Convert.ToInt64(value.Replace(ComparisonOperator.LessThan.Alternate, "")); Operator = ComparisonOperator.LessThan; } else if(value.Contains(ComparisonOperator.LessThanOrEqual.ToString())) { Size = Convert.ToInt64(value.Replace(ComparisonOperator.LessThanOrEqual.ToString(), "")); Operator = ComparisonOperator.LessThanOrEqual; } else if (value.Contains(ComparisonOperator.LessThanOrEqual.Alternate)) { Size = Convert.ToInt64(value.Replace(ComparisonOperator.LessThanOrEqual.Alternate, "")); Operator = ComparisonOperator.LessThanOrEqual; } else { Size = Convert.ToInt64(value.Replace(ComparisonOperator.Equals.ToString(), "")); Operator = ComparisonOperator.Equals; } }
public static IQueryable<Tracker.Core.Data.Guid> ById(this IQueryable<Tracker.Core.Data.Guid> queryable, ComparisonOperator comparisonOperator, System.Guid id) { switch (comparisonOperator) { case ComparisonOperator.GreaterThan: case ComparisonOperator.GreaterThanOrEquals: case ComparisonOperator.LessThan: case ComparisonOperator.LessThanOrEquals: throw new ArgumentException("Parameter 'comparisonOperator' must be ComparisonOperator.Equals or ComparisonOperator.NotEquals to support System.Guid type.", "comparisonOperator"); case ComparisonOperator.NotEquals: return queryable.Where(g => g.Id != id); default: return queryable.Where(g => g.Id == id); } }
public static IQueryable<Petshop.Data.Entities.LineItem> ByLineNum(this IQueryable<Petshop.Data.Entities.LineItem> queryable, ComparisonOperator comparisonOperator, System.Int32 lineNum) { switch (comparisonOperator) { case ComparisonOperator.GreaterThan: return queryable.Where(l => l.LineNum > lineNum); case ComparisonOperator.GreaterThanOrEquals: return queryable.Where(l => l.LineNum >= lineNum); case ComparisonOperator.LessThan: return queryable.Where(l => l.LineNum < lineNum); case ComparisonOperator.LessThanOrEquals: return queryable.Where(l => l.LineNum <= lineNum); case ComparisonOperator.NotEquals: return queryable.Where(l => l.LineNum != lineNum); default: return queryable.Where(l => l.LineNum == lineNum); } }
public static IQueryable<Tracker.Core.Data.UserRole> ByUserId(this IQueryable<Tracker.Core.Data.UserRole> queryable, ComparisonOperator comparisonOperator, int userId) { switch (comparisonOperator) { case ComparisonOperator.GreaterThan: return queryable.Where(u => u.UserId > userId); case ComparisonOperator.GreaterThanOrEquals: return queryable.Where(u => u.UserId >= userId); case ComparisonOperator.LessThan: return queryable.Where(u => u.UserId < userId); case ComparisonOperator.LessThanOrEquals: return queryable.Where(u => u.UserId <= userId); case ComparisonOperator.NotEquals: return queryable.Where(u => u.UserId != userId); default: return queryable.Where(u => u.UserId == userId); } }
public static IQueryable<Petshop.Data.Entities.Cart> ByCartId(this IQueryable<Petshop.Data.Entities.Cart> queryable, ComparisonOperator comparisonOperator, System.Int32 cartId) { switch (comparisonOperator) { case ComparisonOperator.GreaterThan: return queryable.Where(c => c.CartId > cartId); case ComparisonOperator.GreaterThanOrEquals: return queryable.Where(c => c.CartId >= cartId); case ComparisonOperator.LessThan: return queryable.Where(c => c.CartId < cartId); case ComparisonOperator.LessThanOrEquals: return queryable.Where(c => c.CartId <= cartId); case ComparisonOperator.NotEquals: return queryable.Where(c => c.CartId != cartId); default: return queryable.Where(c => c.CartId == cartId); } }
public static IQueryable<Tracker.Data.Entities.Audit> ById(this IQueryable<Tracker.Data.Entities.Audit> queryable, ComparisonOperator comparisonOperator, System.Int32 id) { switch (comparisonOperator) { case ComparisonOperator.GreaterThan: return queryable.Where(a => a.Id > id); case ComparisonOperator.GreaterThanOrEquals: return queryable.Where(a => a.Id >= id); case ComparisonOperator.LessThan: return queryable.Where(a => a.Id < id); case ComparisonOperator.LessThanOrEquals: return queryable.Where(a => a.Id <= id); case ComparisonOperator.NotEquals: return queryable.Where(a => a.Id != id); default: return queryable.Where(a => a.Id == id); } }
public static IQueryable<Tracker.Data.Entities.TaskDetail> ByIdentification(this IQueryable<Tracker.Data.Entities.TaskDetail> queryable, ComparisonOperator comparisonOperator, System.Int32 identification) { switch (comparisonOperator) { case ComparisonOperator.GreaterThan: return queryable.Where(t => t.Identification > identification); case ComparisonOperator.GreaterThanOrEquals: return queryable.Where(t => t.Identification >= identification); case ComparisonOperator.LessThan: return queryable.Where(t => t.Identification < identification); case ComparisonOperator.LessThanOrEquals: return queryable.Where(t => t.Identification <= identification); case ComparisonOperator.NotEquals: return queryable.Where(t => t.Identification != identification); default: return queryable.Where(t => t.Identification == identification); } }
public static IQueryable<PetShop.Core.Data.Order> ByOrderId(this IQueryable<PetShop.Core.Data.Order> queryable, ComparisonOperator comparisonOperator, int orderId) { switch (comparisonOperator) { case ComparisonOperator.GreaterThan: return queryable.Where(o => o.OrderId > orderId); case ComparisonOperator.GreaterThanOrEquals: return queryable.Where(o => o.OrderId >= orderId); case ComparisonOperator.LessThan: return queryable.Where(o => o.OrderId < orderId); case ComparisonOperator.LessThanOrEquals: return queryable.Where(o => o.OrderId <= orderId); case ComparisonOperator.NotEquals: return queryable.Where(o => o.OrderId != orderId); default: return queryable.Where(o => o.OrderId == orderId); } }
public static IQueryable<Tracker.Core.Data.Role> ById(this IQueryable<Tracker.Core.Data.Role> queryable, ComparisonOperator comparisonOperator, int id) { switch (comparisonOperator) { case ComparisonOperator.GreaterThan: return queryable.Where(r => r.Id > id); case ComparisonOperator.GreaterThanOrEquals: return queryable.Where(r => r.Id >= id); case ComparisonOperator.LessThan: return queryable.Where(r => r.Id < id); case ComparisonOperator.LessThanOrEquals: return queryable.Where(r => r.Id <= id); case ComparisonOperator.NotEquals: return queryable.Where(r => r.Id != id); default: return queryable.Where(r => r.Id == id); } }
public static IQueryable<PetShop.Core.Data.Supplier> BySuppId(this IQueryable<PetShop.Core.Data.Supplier> queryable, ComparisonOperator comparisonOperator, int suppId) { switch (comparisonOperator) { case ComparisonOperator.GreaterThan: return queryable.Where(s => s.SuppId > suppId); case ComparisonOperator.GreaterThanOrEquals: return queryable.Where(s => s.SuppId >= suppId); case ComparisonOperator.LessThan: return queryable.Where(s => s.SuppId < suppId); case ComparisonOperator.LessThanOrEquals: return queryable.Where(s => s.SuppId <= suppId); case ComparisonOperator.NotEquals: return queryable.Where(s => s.SuppId != suppId); default: return queryable.Where(s => s.SuppId == suppId); } }
public static IQueryable <SmartSocial.Data.SeriesValue> ByIdDataType(this IQueryable <SmartSocial.Data.SeriesValue> queryable, ComparisonOperator comparisonOperator, int?idDataType) { if (idDataType == null && comparisonOperator != ComparisonOperator.Equals && comparisonOperator != ComparisonOperator.NotEquals) { throw new ArgumentNullException("idDataType", "Parameter 'idDataType' cannot be null with the specified ComparisonOperator. Parameter 'comparisonOperator' must be ComparisonOperator.Equals or ComparisonOperator.NotEquals to support null."); } switch (comparisonOperator) { case ComparisonOperator.GreaterThan: return(queryable.Where(s => s.IdDataType > idDataType)); case ComparisonOperator.GreaterThanOrEquals: return(queryable.Where(s => s.IdDataType >= idDataType)); case ComparisonOperator.LessThan: return(queryable.Where(s => s.IdDataType < idDataType)); case ComparisonOperator.LessThanOrEquals: return(queryable.Where(s => s.IdDataType <= idDataType)); case ComparisonOperator.NotEquals: return(idDataType == null ? queryable.Where(s => s.IdDataType != null) : queryable.Where(s => s.IdDataType != idDataType)); default: return(idDataType == null ? queryable.Where(s => s.IdDataType == null) : queryable.Where(s => s.IdDataType == idDataType)); } }
/// <summary> /// Initializes a new instance of the XPathQuery class /// </summary> /// <param name="attributeName">The name of the attribute to compare against</param> /// <param name="comparisonOperator">The value comparison operator to use</param> /// <remarks> /// This constructor only supports the use of the <c>ComparisonOperator.IsPresent</c> and <c>ComparisonOperator.NotPresent</c> values /// </remarks> public XPathQuery(string attributeName, ComparisonOperator comparisonOperator) : this(attributeName, comparisonOperator, null, false) { }
/// <summary> /// Provides data to the datasources /// </summary> /// <param name="sender"></param> /// <param name="e"></param> void m_DashboardViewer_DataLoading(object sender, DataLoadingWebEventArgs e) { string componentName = String.Empty; string dataSourceName = String.Empty; object dataCollection = null; Preferences subkey = null; // // Get the information about the datasource // componentName = e.DataSourceComponentName; dataSourceName = e.DataSourceName; /* ** Check if this is a JAMS DataSource and if so, load the data. */ try { // // We must have a preferences object to load JAMS datasources // if (m_Preferences != null) { // Get the Preferences subkey for this datasource subkey = m_Preferences.OpenSubKey(dataSourceName); if (subkey != null) { // History datasource if (componentName.StartsWith("HistoryDS")) { // // Load each History parameter from Preferences and if the value starts with '$' // try to get the value from a matching Dashboard parameter. // string folderName = GetParameterValue(subkey, "QueryFolderName", @"\"); string jobName = GetParameterValue(subkey, "QueryJobName", "*"); string setupName = GetParameterValue(subkey, "QuerySetupName", "*"); string startDateRaw = GetParameterValue(subkey, "QueryStartDate", "Today"); string startTime = GetParameterValue(subkey, "QueryStartTime", "00:00:00.00"); string endDateRaw = GetParameterValue(subkey, "QueryEndDate", "Tomorrow"); string endTime = GetParameterValue(subkey, "QueryEndTime", "00:00:00.00"); string withinDelta = GetParameterValue(subkey, "QueryWithin", "0"); string includeSuccess = GetParameterValue(subkey, "QueryIncludeSuccess", "true"); string includeInfo = GetParameterValue(subkey, "QueryIncludeInfo", "true"); string includeWarning = GetParameterValue(subkey, "QueryIncludeWarning", "true"); string includeError = GetParameterValue(subkey, "QueryIncludeError", "true"); string includeFatal = GetParameterValue(subkey, "QueryIncludeFatal", "true"); string checkSched = GetParameterValue(subkey, "QueryCheckSched", "true"); string checkHold = GetParameterValue(subkey, "QueryCheckHold", "true"); string checkStart = GetParameterValue(subkey, "QueryCheckStart", "true"); string checkCompletion = GetParameterValue(subkey, "QueryCheckCompletion", "true"); string searchRecursivelyRaw = GetParameterValue(subkey, "QuerySearchRecursively", "true"); bool useDates = subkey.GetBoolean("QueryUseDates", true); DateTime startDate = DateTime.MinValue; DateTime endDate = DateTime.MinValue; bool searchRecursively = Boolean.Parse(searchRecursivelyRaw); ComparisonOperator searchFolderOperator = ComparisonOperator.MatchFolder; // // Determine the Start & End dates based either on the WithinTime or date range // if (useDates) { startDate = Date.Evaluate(startDateRaw, Server).Date; startDate += Date.Evaluate(startTime, Server).TimeOfDay; endDate = Date.Evaluate(endDateRaw, Server).Date; endDate += Date.Evaluate(endTime, Server).TimeOfDay; } else { // // They are using the "Within..." controls, // the end date is right now and the start date is the current time minus the delta. // startDate = DateTime.Now - DeltaTime.Parse(withinDelta).TimeSpan; endDate = DateTime.Now; } // // Add History Search Criteria // List <HistorySelection> selectionList = new List <HistorySelection>(); selectionList.Add(new HistorySelection(HistorySelectionField.JobName, ComparisonOperator.Like, jobName)); selectionList.Add(new HistorySelection(HistorySelectionField.SetupName, ComparisonOperator.Like, setupName)); if (searchRecursively) { searchFolderOperator = ComparisonOperator.MatchFolderRecursively; } selectionList.Add(new HistorySelection(HistorySelectionField.FolderName, searchFolderOperator, folderName)); // // Query History using the supplied values // dataCollection = JAMS.History.Find(selectionList, startDate, endDate, Boolean.Parse(includeSuccess), Boolean.Parse(includeInfo), Boolean.Parse(includeWarning), Boolean.Parse(includeError), Boolean.Parse(includeFatal), Boolean.Parse(checkSched), Boolean.Parse(checkHold), Boolean.Parse(checkStart), Boolean.Parse(checkCompletion), HistorySearchOptions.None, Server); } else if (componentName.StartsWith("CompletionsBySeverityDS")) { DateTime startDate = DateTime.Now; DeltaTime lookbackInterval = DeltaTime.Zero; // // Load the lookbackInterval from Preferences and if the value starts with '$' // try to get the value from a matching Dashboard parameter. // string lookbackIntervalRaw = GetParameterValue(subkey, "QueryLookBackInterval", "00:00:00.00"); // // The startDate will be the current time minus the lookback interval // if (DeltaTime.TryParse(lookbackIntervalRaw, out lookbackInterval)) { startDate = startDate.Subtract(lookbackInterval.ToTimeSpan()); } // // Retrieve the completion data that occured within 24 hours before the startDate // dataCollection = Statistics.GetCompletionsBySeverity(startDate, Server); } else if (componentName.StartsWith("QueueDS")) { // // Load the BatchQueue mask parameter and if the value starts with '$' // try to get the value from a matching Dashboard parameter. // string queueMask = GetParameterValue(subkey, "QueryQueueName", "*"); // // Retrieve the queue data // dataCollection = BatchQueue.Find(queueMask, Server); } else if (componentName.StartsWith("ResourceDS")) { // // Load the Resource mask parameter and if the value starts with '$' // try to get the value from a matching Dashboard parameter. // string resourceMask = GetParameterValue(subkey, "QueryResourceName", "*"); // // Retrieve the Resource data // dataCollection = Resource.Find(resourceMask, Server); } else if (componentName.StartsWith("AgentDS")) { // // Load the Agent mask parameter and if the value starts with '$' // try to get the value from a matching Dashboard parameter. // string agentMask = GetParameterValue(subkey, "QueryAgentName", "*"); // // Retrieve the Agent data // dataCollection = Agent.Find(agentMask, Server); } else if (componentName.StartsWith("PowerShellDS")) { dataCollection = GetPowerShellDataSourceData(subkey); } } } } catch (Exception ex) { throw ex; } if (dataCollection != null) { e.Data = dataCollection; } }
public MycobankLiteratureSearch(MycobankLiteratureSearchField searchField, ComparisonOperator comparisonOperator, string value, int?limit = null) : base(searchField, comparisonOperator, value, limit) { }
/// <summary> /// Initializes a new instance of the <see cref="PropertyComparisonValidator"/> class. /// </summary> /// <param name="valueAccess">The <see cref="ValueAccess"/> to use to extract the value to compare.</param> /// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> representing the kind of comparison to perform.</param> public PropertyComparisonValidator(ValueAccess valueAccess, ComparisonOperator comparisonOperator) : base(valueAccess, comparisonOperator) { }
/// <summary>Creates a new evaluatable that returns the result of the two given numbers compared using the given operator.</summary> public BooleanMathsComparison(double value1, ComparisonOperator op, double value2) { Operand1 = new NumberConstant(value1); Operand2 = new NumberConstant(value2); Operator = op; }
public abstract string GetRelationalOperator(ComparisonOperator op);
/// <summary> /// Saves a tracking condition for an activity /// </summary> /// <param name="activity"></param> /// <param name="key"></param> /// <param name="member"></param> /// <param name="op"></param> /// <param name="value"></param> internal void SaveTrackingCondition(Activity activity, ref ActivityTrackingCondition key, string member, ComparisonOperator op, string value) { ActivityTrackPoint trackPoint = GetTrackPointForActivity(activity); if (trackPoint != null) { if (key == null) { key = new ActivityTrackingCondition(); trackPoint.MatchingLocations[0].Conditions.Add(key); } key.Member = member; key.Value = value; key.Operator = op; } }
private static Condition internal_buildCondition(string modifier1, Name v1, string modifier2, Name v2, ComparisonOperator op) { IValueRetriver value1 = ConvertToValueRetriever(modifier1, v1); IValueRetriver value2 = ConvertToValueRetriever(modifier2, v2); if (value1.Equals(value2)) { throw new InvalidOperationException("Both given property names are intrinsically equal. Condition would always return a constant result."); } if (value1.InnerName.IsPrimitive && value2.InnerName.IsPrimitive && !value1.HasModifier && !value2.HasModifier) { throw new InvalidOperationException("Both given property names are primitive values. Expected at least one non-primitive value."); } if (op == ComparisonOperator.Equal) { //May be a definition if (value1.InnerName.IsVariable && !value1.HasModifier) { return(new EqualityDefinitionCondition(v1, value2)); } if (value2.InnerName.IsVariable && !value2.HasModifier) { return(new EqualityDefinitionCondition(v2, value1)); } } if (value1.InnerName.IsPrimitive != value2.InnerName.IsPrimitive) { IValueRetriver prop = value1.InnerName.IsPrimitive ? value2 : value1; PrimitiveValue value = (value1.InnerName.IsPrimitive ? value1.InnerName : value2.InnerName).GetPrimitiveValue(); op = v1.IsPrimitive ? op.Mirror() : op; if (value.TypeCode == TypeCode.Boolean) { switch (op) { case ComparisonOperator.Equal: return(new PredicateCondition(prop, value)); case ComparisonOperator.NotEqual: return(new PredicateCondition(prop, !value)); } } return(new PrimitiveComparisonCondition(prop, value, op)); } return(new PropertyComparisonCondition(value1, value2, op)); }
public PropertyComparisonCondition(IValueRetriever property1, IValueRetriever property2, ComparisonOperator op) { Property1 = property1; Property2 = property2; Operator = op; }
public SingleColumnValueFilter <TEntity> ComparisonOperator(ComparisonOperator comparisonOperator) { _comparisonOperator = comparisonOperator; return(this); }
private static bool CompareNumbers(ComparisonOperator op, double left, double right) => op switch {
public static TQuery FieldConditionIf <TQuery, TValue>(this TQuery query, Field field, ComparisonOperator op, TValue value = default, Func <TValue, bool> condition = null) where TQuery : IRepositoryQuery { bool result = condition == null || condition(value); return(result ? query.FieldCondition(field, op, value) : query); }
public MoreCondition(LogicalOperator logicalOperator, ISqlField field1, ComparisonOperator oper, ISqlField field2 = null) { LogicalOperator = logicalOperator; Condition = new Condition(field1, oper, field2); }
public static Condition BuildCondition(Name v1, Name v2, ComparisonOperator op) { return(internal_buildCondition(null, v1, null, v2, ComparisonOperator.Equal)); }
public MycobankLiteratureSearch(MycobankLiteratureSearchField searchField, string targetTableName, string targetFieldCode, ComparisonOperator comparisonOperator, string value, int?limit = null) : base(searchField, targetTableName, targetFieldCode, comparisonOperator, value, limit) { }
/// <summary> /// Reads the condition data from the underlying stream. /// </summary> /// <param name="reader">The reader.</param> public void Read(BinaryReader reader) { Ability = (AbilityType)reader.ReadByte(); Value = reader.ReadInt32(); Operation = (ComparisonOperator)reader.ReadByte(); }
public MultivaluedInstanceComparisonFilter(ComparisonOperator comparisonOperator, PropertyDefinition property, object propertyValue) : base(comparisonOperator, property, propertyValue) { }
/// <summary> /// Initializes a new instance of the <see cref="PropertyComparisonValidator"/> class. /// </summary> /// <param name="valueAccess">The <see cref="ValueAccess"/> to use to extract the value to compare.</param> /// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> representing the kind of comparison to perform.</param> /// <param name="negated">Indicates if the validation logic represented by the validator should be negated.</param> public PropertyComparisonValidator(ValueAccess valueAccess, ComparisonOperator comparisonOperator, bool negated) : base(valueAccess, comparisonOperator, null, negated) { }
public static IRepositoryQuery <TModel> FieldConditionIf <TModel, TValue>(this IRepositoryQuery <TModel> query, Expression <Func <TModel, object> > objectPath, ComparisonOperator op, TValue value = default, Func <TValue, bool> condition = null) where TModel : class { bool result = condition == null || condition(value); return(result ? query.FieldCondition(objectPath, op, value) : query); }
public static TQuery FieldConditionIf <TQuery, TValue>(this TQuery query, Field field, ComparisonOperator op, TValue value = default, bool condition = true) where TQuery : IRepositoryQuery { return(condition ? query.FieldCondition(field, op, value) : query); }
/// <summary> /// Initializes a new instance of the XPathQuery class /// </summary> /// <param name="attributeName">The name of the attribute to compare against</param> /// <param name="comparisonOperator">The value comparison operator to use</param> /// <param name="value">The value to compare against</param> public XPathQuery(string attributeName, ComparisonOperator comparisonOperator, object value) : this(attributeName, comparisonOperator, value, false) { }
public static IRepositoryQuery <TModel> FieldConditionIf <TModel, TValue>(this IRepositoryQuery <TModel> query, Expression <Func <TModel, object> > objectPath, ComparisonOperator op, TValue value = default, bool condition = true) where TModel : class { return(condition ? query.FieldCondition(objectPath, op, value) : query); }
public IConditionalFormattingRule CreateConditionalFormattingRule( ComparisonOperator comparisonOperation, String formula) { return(CreateConditionalFormattingRule(comparisonOperation, formula, null)); }
public static IQueryable <SmartSocial.Data.SeriesValue> ByIdSeriesValue(this IQueryable <SmartSocial.Data.SeriesValue> queryable, ComparisonOperator comparisonOperator, int idSeriesValue) { switch (comparisonOperator) { case ComparisonOperator.GreaterThan: return(queryable.Where(s => s.IdSeriesValue > idSeriesValue)); case ComparisonOperator.GreaterThanOrEquals: return(queryable.Where(s => s.IdSeriesValue >= idSeriesValue)); case ComparisonOperator.LessThan: return(queryable.Where(s => s.IdSeriesValue < idSeriesValue)); case ComparisonOperator.LessThanOrEquals: return(queryable.Where(s => s.IdSeriesValue <= idSeriesValue)); case ComparisonOperator.NotEquals: return(queryable.Where(s => s.IdSeriesValue != idSeriesValue)); default: return(queryable.Where(s => s.IdSeriesValue == idSeriesValue)); } }
public static IQueryable <SmartSocial.Data.SeriesValue> ByRowPosition(this IQueryable <SmartSocial.Data.SeriesValue> queryable, ComparisonOperator comparisonOperator, int?rowPosition) { if (rowPosition == null && comparisonOperator != ComparisonOperator.Equals && comparisonOperator != ComparisonOperator.NotEquals) { throw new ArgumentNullException("rowPosition", "Parameter 'rowPosition' cannot be null with the specified ComparisonOperator. Parameter 'comparisonOperator' must be ComparisonOperator.Equals or ComparisonOperator.NotEquals to support null."); } switch (comparisonOperator) { case ComparisonOperator.GreaterThan: return(queryable.Where(s => s.RowPosition > rowPosition)); case ComparisonOperator.GreaterThanOrEquals: return(queryable.Where(s => s.RowPosition >= rowPosition)); case ComparisonOperator.LessThan: return(queryable.Where(s => s.RowPosition < rowPosition)); case ComparisonOperator.LessThanOrEquals: return(queryable.Where(s => s.RowPosition <= rowPosition)); case ComparisonOperator.NotEquals: return(rowPosition == null ? queryable.Where(s => s.RowPosition != null) : queryable.Where(s => s.RowPosition != rowPosition)); default: return(rowPosition == null ? queryable.Where(s => s.RowPosition == null) : queryable.Where(s => s.RowPosition == rowPosition)); } }
public static IRepositoryQuery <T> FieldCondition <T>(this IRepositoryQuery <T> query, Expression <Func <T, object> > objectPath, ComparisonOperator op, object value = null) where T : class { return(query.AddCollectionOptionValue(FieldConditionsKey, new FieldCondition { Field = objectPath, Value = value, Operator = op })); }
/// <summary> /// Initializes a new instance of the XPathQuery class /// </summary> /// <param name="attributeName">The name of the attribute to compare against</param> /// <param name="comparisonOperator">The value comparison operator to use</param> /// <param name="value">The value to compare against</param> /// <param name="negate">Indicates if this query should be negated with the not() operator</param> /// <param name="attributeType">The data type of the attribute being queried</param> /// <param name="isMultivalued">The multivalued status of the attribute being queried</param> /// <remarks> /// This constructor can be used when a connection to the resource management service not available. The attribute type and multivalued status are not validated against the schema /// </remarks> public XPathQuery(string attributeName, ComparisonOperator comparisonOperator, object value, bool negate, AttributeType attributeType, bool isMultivalued) { this.SetupBuilder(attributeName, comparisonOperator, value, negate, attributeType, isMultivalued); }
public static T FieldCondition <T>(this T query, Field field, ComparisonOperator op, object value = null) where T : IRepositoryQuery { return(query.AddCollectionOptionValue(FieldConditionsKey, new FieldCondition { Field = field, Value = value, Operator = op })); }
public ComparisonCondition(Property property, bool not, ComparisonOperator op, object value) : base(property, not) { m_Operator = op; m_Value = new PropertyValue(property.Type, value); }