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);
}
