private static Filter CreateFilterCondition(CompareOperator compareOperator, string columnName, object value) {
return new FilterCondition {
CompareOperator = compareOperator,
Left = new FilterParameter {Value = columnName, FilterParameterType = FilterParameterType.Column},
Right = new FilterParameter {Value = value, FilterParameterType = FilterParameterType.Value}
};
}
public static string GetOperatorDescription(CompareOperator compareOperator)
{
string summary = "";
switch (compareOperator)
{
case CompareOperator.Equals:
summary += "==";
break;
case CompareOperator.NotEquals:
summary += "!=";
break;
case CompareOperator.LessThan:
summary += "<";
break;
case CompareOperator.GreaterThan:
summary += ">";
break;
case CompareOperator.LessThanOrEquals:
summary += "<=";
break;
case CompareOperator.GreaterThanOrEquals:
summary += ">=";
break;
}
return summary;
}
/// <param name="operator">The comparison operation to perform.</param>
/// <param name="propertyToCompare">The name of the property to compare with.</param>
/// <exception cref="ArgumentException"><paramref name="propertyToCompare"/> is a <see cref="string.Empty"/>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="propertyToCompare"/> is null.</exception>
public ComparePropertyRule(string propertyToCompare, CompareOperator @operator)
: base(null)
{
Guard.ArgumentNotNullOrEmptyString(propertyToCompare, "propertyToCompare");
PropertyToCompare = propertyToCompare;
CompareOperator = @operator;
}
/// <summary>
///
/// </summary>
/// <param name="fileSize">filesize in bytes</param>
/// <param name="compareOperator">operator that specifies how to compare filesizes</param>
public FileSizeSearchCriteria(long fileSize, CompareOperator compareOperator)
{
if (fileSize < 0)
throw new ArgumentOutOfRangeException("fileSize");
this.fileSize = fileSize;
this.compareOperator = compareOperator;
}
public RequiredIfRule(string rootType, string property, string compareSource, CompareOperator compareOperator, object compareValue, RuleInvocationType invocationTypes, Error error)
: base(rootType, property, error, invocationTypes)
{
this.CompareSource = compareSource;
this.CompareOperator = compareOperator;
this.CompareValue = compareValue;
InitializePredicates(compareSource);
}
/// <summary>
/// Creates a new instance of <see cref="CompareRule"/> for the specified property.
/// </summary>
/// <param name="rootType"></param>
/// <param name="property"></param>
/// <param name="conditionType"></param>
/// <param name="comparePath"></param>
/// <param name="compareOperator"></param>
/// <param name="error"></param>
/// <param name="invocationTypes"></param>
public CompareRule(string rootType, string property, string compareSource, CompareOperator compareOperator, Error error, RuleInvocationType invocationTypes)
: base(rootType, property, error, invocationTypes)
{
this.CompareSource = compareSource;
this.CompareOperator = compareOperator;
InitializePredicates(compareSource);
ValidateRuleCriteria();
}
public IDSearchCriteria(long id, IDSearchField field, CompareOperator compareOperator)
{
if (id < 0)
throw new ArgumentException("Invalid id");
this.id = id;
this.field = field;
this.compareOperator = compareOperator;
}
public RequiredIfRule(string rootType, string property, string compareSource, CompareOperator compareOperator, object compareValue, RuleInvocationType invocationTypes, params ConditionTypeSet[] sets)
: base(rootType, property,
CreateError(property, compareSource, compareOperator, compareValue, sets), invocationTypes)
{
this.CompareSource = compareSource;
this.CompareOperator = compareOperator;
this.CompareValue = compareValue;
InitializePredicates(compareSource);
}
public QuantitySearchCriteria(QuantityField fields, long quantity, CompareOperator compareOperator, MatchRule fieldMatchRule)
{
if (quantity < 0)
throw new ArgumentOutOfRangeException("quantity");
this.quantityFields = fields;
this.quantity = quantity;
this.compareOperator = compareOperator;
this.fieldMatchRule = fieldMatchRule;
}
/// <summary>
/// Creates a comparison WhereTerm.
/// </summary>
/// <param name="expr1">Expression on the left side of the operator</param>
/// <param name="expr2">Expression on the right side of the operator</param>
/// <param name="op">Conditional operator to be applied on the expressions</param>
/// <returns>A new conditional WhereTerm</returns>
/// <remarks>
/// A comparison term compares two expression on the basis of their values. Expressions can be of any type but their results must be of comparible types.
/// For instance, you can not compare a database field of type 'date' and a static value of type 'int'.
/// </remarks>
/// <example>
/// <code>
/// ...
/// query.WherePhrase.Terms.Add(WhereTerm.CreateCompare(SqlExpression.Field("name", tCustomers), SqlExpression.String("J%"), CompareOperator.Like));
/// </code>
/// </example>
public static WhereTerm CreateCompare(SqlExpression expr1, SqlExpression expr2, CompareOperator op)
{
WhereTerm term = new WhereTerm();
term.expr1 = expr1;
term.expr2 = expr2;
term.op = op;
term.type = WhereTermType.Compare;
return term;
}
public static string Get(CompareOperator compareOperator) {
switch (compareOperator) {
case CompareOperator.Equals:
return "=";
case CompareOperator.GreaterOrEqualThan:
return ">=";
case CompareOperator.GreaterThan:
return ">";
case CompareOperator.LessOrEqualThan:
return "<=";
case CompareOperator.LessThan:
return "<";
case CompareOperator.Is:
return "is";
default:
return "";
}
}
public static bool IsAllowedOperator(JsonSchema schema, CompareOperator compareOperator)
{
switch (schema.Type)
{
case JsonObjectType.None:
return(true);
case JsonObjectType.Boolean:
return(BooleanOperators.Contains(compareOperator));
case JsonObjectType.Integer:
case JsonObjectType.Number:
return(NumberOperators.Contains(compareOperator));
case JsonObjectType.String:
return(StringOperators.Contains(compareOperator));
case JsonObjectType.Array:
return(ArrayOperators.Contains(compareOperator));
}
return(false);
}
/* get the sql search condition of this field */
internal string GetSqlSearchCondition(long id, CompareOperator compareOperator)
{
string fieldName = string.Empty;
if (this == IDSearchField.ItemID)
{
fieldName = "ItemID";
}
else if (this == IDSearchField.ParentID)
{
fieldName = "ParentID";
}
else if (this == IDSearchField.VolumeID)
{
fieldName = "VolumeID";
}
else
{
throw new NotImplementedException(string.Format("IDSearchField {0} not implemented", value));
}
return(compareOperator.GetSqlCompareString(fieldName, id.ToString()));
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("{0}, ", Group);
switch (Group)
{
case Group.Branch:
switch (SubGroupBranch)
{
case GroupBranch.Goto: sb.AppendFormat("{0}, {1}", BranchOptionsGoto.ToString(), PrintOperands()); break;
case GroupBranch.Jump: sb.AppendFormat("{0}, {1}", BranchOptionsJump.ToString(), PrintOperands()); break;
case GroupBranch.Play: sb.AppendFormat("{0}, {1}", BranchOptionsPlay.ToString(), PrintOperands()); break;
default: sb.Append("???, "); break;
}
break;
case Group.Compare:
sb.AppendFormat("{0}, {1}", CompareOperator.ToString(), PrintOperands());
break;
case Group.Set:
switch (SubGroupSet)
{
case GroupSet.Set: sb.AppendFormat("{0}, {1}", SetOperator.ToString(), PrintOperands()); break;
case GroupSet.SetSystem: sb.AppendFormat("{0}, {1}", SetOperator.ToString(), PrintOperands()); break;
default: sb.Append("???, "); break;
}
break;
}
return(sb.ToString());
}
public virtual bool Evaluate(CompareOperator compareOperator, float floatValue)
{
float lhs = value;
float rhs = floatValue;
bool condition = false;
switch (compareOperator)
{
case CompareOperator.Equals:
condition = lhs == rhs;
break;
case CompareOperator.NotEquals:
condition = lhs != rhs;
break;
case CompareOperator.LessThan:
condition = lhs < rhs;
break;
case CompareOperator.GreaterThan:
condition = lhs > rhs;
break;
case CompareOperator.LessThanOrEquals:
condition = lhs <= rhs;
break;
case CompareOperator.GreaterThanOrEquals:
condition = lhs >= rhs;
break;
}
return(condition);
}
protected virtual string GetWhereOperatorCompare(CompareOperator op)
{
switch (op)
{
case CompareOperator.Equals:
return("=");
case CompareOperator.NotEquals:
return("<>");
case CompareOperator.GreaterOrEqualThan:
return(">=");
case CompareOperator.GreaterThan:
return(">");
case CompareOperator.LessOrEqualThan:
return("<=");
case CompareOperator.LessThan:
return("<");
}
return(null);
}
static public bool IsBinary(this CompareOperator inComparison)
{
switch (inComparison)
{
case CompareOperator.LessThan:
case CompareOperator.LessThanOrEqualTo:
case CompareOperator.EqualTo:
case CompareOperator.NotEqualTo:
case CompareOperator.GreaterThan:
case CompareOperator.GreaterThanOrEqualTo:
case CompareOperator.Contains:
case CompareOperator.StartsWith:
case CompareOperator.EndsWith:
case CompareOperator.DoesNotContain:
case CompareOperator.DoesNotStartWith:
case CompareOperator.DoesNotEndWith:
case CompareOperator.Matches:
case CompareOperator.DoesNotMatch:
return(true);
default:
return(false);
}
}
public virtual bool Evaluate(CompareOperator compareOperator, bool booleanValue)
{
bool condition = false;
bool lhs = Value;
bool rhs = booleanValue;
switch (compareOperator)
{
case CompareOperator.Equals:
condition = lhs == rhs;
break;
case CompareOperator.NotEquals:
condition = lhs != rhs;
break;
default:
Debug.LogError("The " + compareOperator.ToString() + " comparison operator is not valid.");
break;
}
return(condition);
}
/// <summary>
/// Initializes a new instance of the <see cref="CompareValueRule{TEntity, TProperty}"/> class specifying the compare to value.
/// </summary>
/// <param name="compareOperator">The <see cref="CompareOperator"/>.</param>
/// <param name="compareToValue">The compare to value.</param>
/// <param name="compareToText">The compare to text to be passed for the error message (default is to use <paramref name="compareToValue"/>).</param>
public CompareValueRule(CompareOperator compareOperator, TProperty compareToValue, LText compareToText = null) : base(compareOperator)
{
_compareToValue = compareToValue;
_compareToText = compareToText;
}
/// <summary>
/// Initializes a new instance of the <see cref="CompareValueRule{TEntity, TProperty}"/> class specifying the compare to property.
/// </summary>
/// <param name="compareOperator">The <see cref="CompareOperator"/>.</param>
/// <param name="compareToPropertyExpression">The <see cref="Expression"/> to reference the compare to entity property.</param>
/// <param name="compareToText">The compare to text <see cref="LText"/> to be passed for the error message (default is to derive the text from the property itself).</param>
public ComparePropertyRule(CompareOperator compareOperator, Expression <Func <TEntity, TCompareProperty> > compareToPropertyExpression, LText?compareToText = null) : base(compareOperator)
{
Beef.Check.NotNull(compareToPropertyExpression, nameof(compareToPropertyExpression));
_compareTo = PropertyExpression.Create(compareToPropertyExpression, true);
_compareToText = compareToText;
}
public ValueCompareFilter(DataMember member, IComparable valueToCompare, CompareOperator compareOperator)
{
Member = member;
ValueToCompare = valueToCompare;
Operator = compareOperator;
}
static public string Name(this CompareOperator inComparison)
{
switch (inComparison)
{
case CompareOperator.LessThanOrEqualTo:
return("Less Than or Equal To");
case CompareOperator.LessThan:
return("Less Than");
case CompareOperator.EqualTo:
return("Equal To");
case CompareOperator.NotEqualTo:
return("Not Equal To");
case CompareOperator.GreaterThan:
return("Greater Than");
case CompareOperator.GreaterThanOrEqualTo:
return("Greater Than Or Equal To");
case CompareOperator.True:
return("Is True");
case CompareOperator.False:
return("Is False");
case CompareOperator.Contains:
return("Contains");
case CompareOperator.StartsWith:
return("Starts With");
case CompareOperator.EndsWith:
return("Ends With");
case CompareOperator.DoesNotContain:
return("Does Not Contain");
case CompareOperator.DoesNotStartWith:
return("Does Not Start With");
case CompareOperator.DoesNotEndWith:
return("Does Not End With");
case CompareOperator.IsEmpty:
return("Is Empty");
case CompareOperator.IsNotEmpty:
return("Is Not Empty");
case CompareOperator.Matches:
return("Matches");
case CompareOperator.DoesNotMatch:
return("Does Not Match");
default:
throw new ArgumentException("Unknown comparison type " + inComparison, "inComparison");
}
}
/// <param name="operator">The comparison operation to perform.</param>
/// <param name="propertyToCompare">The property to compare with.</param>
public ComparePropertyRuleAttribute(string propertyToCompare, CompareOperator @operator)
: base(@operator)
{
PropertyToCompare = propertyToCompare;
}
public static bool IsMatch(CompareOperator<Cell> compareOperator, string value)
{
var processor = new CellProcessorBase();
processor.AddOperator(new CompareDefault());
return compareOperator.CanCompare(new TypedValue(null, typeof(object)), TestUtils.CreateCell(value));
}
/// <param name="operator">The comparison operation to perform.</param>
/// <param name="valueToCompare">The value to compare with.</param>
public CompareDateTimeRuleAttribute(string valueToCompare, CompareOperator @operator)
: base(@operator)
{
ValueToCompare = valueToCompare;
ValueToCompareDateTime = DateTimeConverter.Parse(valueToCompare);
}
static Func<ModelType, ConditionType> CreateError(string property, string compareSource = null, CompareOperator compareOperator = CompareOperator.Equal, object compareValue = null, params ConditionTypeSet[] sets)
{
return (ModelType rootType) =>
{
// Determine the appropriate error message
// If compareSource is null then a ModelExpression has been specified to handle the validation
if (compareSource == null)
{
return new Error(GetErrorCode(rootType.Name, property, "RequiredIf"), "required", typeof(RequiredIfRule),
(s) => s
.Replace("{property}", GetLabel(rootType, property)), sets);
}
else
{
string message;
if (compareValue == null)
message = compareOperator == CompareOperator.Equal ? "required-if-not-exists" : "required-if-exists";
else
{
bool isDate = compareValue is DateTime;
switch (compareOperator)
{
case CompareOperator.Equal:
message = "required-if-equal";
break;
case CompareOperator.NotEqual:
message = "required-if-not-equal";
break;
case CompareOperator.GreaterThan:
message = isDate ? "required-if-after" : "required-if-greater-than";
break;
case CompareOperator.GreaterThanEqual:
message = isDate ? "required-if-on-or-after" : "required-if-greater-than-or-equal";
break;
case CompareOperator.LessThan:
message = isDate ? "required-if-before" : "required-if-less-than";
break;
case CompareOperator.LessThanEqual:
message = isDate ? "required-if-on-or-before" : "required-if-less-than-or-equal";
break;
default:
throw new ArgumentException("Invalid comparison operator for required if rule");
}
}
// Get the comparison source
ModelSource source;
ModelProperty sourceProperty;
ModelSource.TryGetSource(rootType, compareSource, out source, out sourceProperty);
// Create and return the error
var compareValueFormatted = compareValue == null ? "" : ((ModelValueProperty)sourceProperty).FormatValue(compareValue);
return new Error(GetErrorCode(rootType.Name, property, "RequiredIf"), message, typeof(RequiredIfRule),
(s) => s
.Replace("{property}", GetLabel(rootType, property))
.Replace("{compareSource}", GetSourceLabel(rootType, compareSource))
.Replace("{compareValue}", compareValueFormatted), sets);
}
};
}
public RequiredIfRule(string rootType, string property, string compareSource, CompareOperator compareOperator, object compareValue, Error error)
: this(rootType, property, compareSource, compareOperator, compareValue, RuleInvocationType.InitNew | RuleInvocationType.PropertyChanged, error)
{
}
static private ArgumentException InvalidComparisonException(CompareOperator inComparison)
{
return(new ArgumentException("Invalid comparison type " + inComparison, "inComparison"));
}
/// <summary>
/// Search for list of taxon by factor.
/// </summary>
/// <param name="taxonSearchFactorFieldViewModels"></param>
/// <param name="factorId"></param>
/// <param name="restrictToCurrentTaxonFilter"></param>
/// <param name="settings"></param>
/// <returns></returns>
private List <ITaxon> SearchTaxonByFactor(List <TaxonSearchFactorFieldViewModel> taxonSearchFactorFieldViewModels, Int32 factorId, Boolean restrictToCurrentTaxonFilter, MySettings.MySettings settings)
{
if (taxonSearchFactorFieldViewModels == null)
{
taxonSearchFactorFieldViewModels = new List <TaxonSearchFactorFieldViewModel>();
}
TaxonList taxonList = new TaxonList();
ISpeciesFactSearchCriteria searchCriteria = new SpeciesFactSearchCriteria();
searchCriteria.IncludeNotValidHosts = false;
searchCriteria.IncludeNotValidTaxa = false;
searchCriteria.FieldSearchCriteria = new SpeciesFactFieldSearchCriteriaList();
searchCriteria.Factors = new FactorList();
ISpeciesFactFieldSearchCriteria fieldSearchCriteria;
searchCriteria.FieldLogicalOperator = LogicalOperator.And;
if (taxonSearchFactorFieldViewModels.Count > 0)
{
if (restrictToCurrentTaxonFilter)
{
if (settings.Filter.Taxa.HasSettings)
{
searchCriteria.Taxa = CoreData.TaxonManager.GetTaxa(_user, settings.Filter.Taxa.TaxonIds.ToList());
}
else
{
return(new TaxonList());
}
}
IFactor factor = CoreData.FactorManager.GetFactor(_user, factorId);
searchCriteria.Factors.Add(factor);
// Add factor field to search criteria by list of factor field id
foreach (var field in factor.DataType.Fields)
{
if (field.Type.Id == (int)FactorFieldDataTypeId.Enum)
{
if (field.Enum != null && field.Enum.Values != null)
{
fieldSearchCriteria = new SpeciesFactFieldSearchCriteria();
// fieldSearchCriteria.IsEnumAsString = true;
fieldSearchCriteria.FactorField = field;
fieldSearchCriteria.Operator = CompareOperator.Equal;
foreach (var val in field.Enum.Values)
{
if (val.KeyInt.HasValue && taxonSearchFactorFieldViewModels.Any(x => x.FactorFieldTypeId == val.Id))
{
String factorValue = taxonSearchFactorFieldViewModels.First(x => x.FactorFieldTypeId == val.Id).FactorFieldTypeValue;
fieldSearchCriteria.AddValue(factorValue);
}
}
if (fieldSearchCriteria.Values.IsNotEmpty())
{
searchCriteria.FieldSearchCriteria.Add(fieldSearchCriteria);
}
}
}
else if (field.Type.Id == (int)FactorFieldDataTypeId.Boolean)
{
if (field.Enum != null && field.Enum.Values != null)
{
fieldSearchCriteria = new SpeciesFactFieldSearchCriteria();
// fieldSearchCriteria.IsEnumAsString = true;
fieldSearchCriteria.FactorField = field;
fieldSearchCriteria.Operator = CompareOperator.Equal;
foreach (var val in field.Enum.Values)
{
if (val.KeyInt.HasValue && taxonSearchFactorFieldViewModels.Any(x => x.FactorFieldTypeId == val.Id))
{
String factorValue = taxonSearchFactorFieldViewModels.First(x => x.FactorFieldTypeId == val.Id).FactorFieldTypeValue;
fieldSearchCriteria.AddValue(factorValue);
}
}
if (fieldSearchCriteria.Values.IsNotEmpty())
{
searchCriteria.FieldSearchCriteria.Add(fieldSearchCriteria);
}
}
}
else if (field.Type.Id == (int)FactorFieldDataTypeId.Double)
{
if (taxonSearchFactorFieldViewModels.Any(x => x.FactorFieldTypeId == field.Id))
{
TaxonSearchFactorFieldViewModel factorField = taxonSearchFactorFieldViewModels.First(x => x.FactorFieldTypeId == field.Id);
CompareOperator compareOperator = factorField.CompareOperatorIsSpecified ? factorField.CompareOperator : CompareOperator.Equal;
String factorValue = factorField.FactorFieldTypeValue;
fieldSearchCriteria = new SpeciesFactFieldSearchCriteria();
fieldSearchCriteria.FactorField = field;
fieldSearchCriteria.Operator = compareOperator;
fieldSearchCriteria.AddValue(factorValue.WebParseInt32());
searchCriteria.FieldSearchCriteria.Add(fieldSearchCriteria);
}
}
else if (field.Type.Id == (int)FactorFieldDataTypeId.Int32)
{
if (taxonSearchFactorFieldViewModels.Any(x => x.FactorFieldTypeId == field.Id))
{
TaxonSearchFactorFieldViewModel factorField = taxonSearchFactorFieldViewModels.First(x => x.FactorFieldTypeId == field.Id);
CompareOperator compareOperator = factorField.CompareOperatorIsSpecified ? factorField.CompareOperator : CompareOperator.Equal;
String factorValue = factorField.FactorFieldTypeValue;
fieldSearchCriteria = new SpeciesFactFieldSearchCriteria();
fieldSearchCriteria.FactorField = field;
fieldSearchCriteria.Operator = compareOperator;
fieldSearchCriteria.AddValue(factorValue.WebParseInt32());
searchCriteria.FieldSearchCriteria.Add(fieldSearchCriteria);
}
}
else if (field.Type.Id == (int)FactorFieldDataTypeId.String)
{
if (taxonSearchFactorFieldViewModels.Any(x => x.FactorFieldTypeId == field.Id))
{
TaxonSearchFactorFieldViewModel factorField = taxonSearchFactorFieldViewModels.First(x => x.FactorFieldTypeId == field.Id);
CompareOperator compareOperator = factorField.CompareOperatorIsSpecified ? factorField.CompareOperator : CompareOperator.Equal;
String factorValue = factorField.FactorFieldTypeValue;
fieldSearchCriteria = new SpeciesFactFieldSearchCriteria();
fieldSearchCriteria.FactorField = field;
fieldSearchCriteria.Operator = compareOperator;
fieldSearchCriteria.AddValue(factorValue);
searchCriteria.FieldSearchCriteria.Add(fieldSearchCriteria);
}
}
}
}
else
{
return(new TaxonList());
}
// Get taxa.
taxonList = CoreData.AnalysisManager.GetTaxa(_user, searchCriteria);
return(taxonList);
}
/// <param name="operator">The comparison operation to perform.</param>
/// <param name="valueToCompare">The value to compare with.</param>
public CompareIntRuleAttribute(int valueToCompare, CompareOperator @operator)
: base(@operator)
{
ValueToCompare = valueToCompare;
}
private static CompareFilter <ClrValue> Binary(PropertyPath path, CompareOperator @operator, ClrValue value)
{
return(new CompareFilter <ClrValue>(path, @operator, value ?? ClrValue.Null));
}
public void DebugPrint(Log log, int depth = 0)
{
Value1.DebugPrint(log, depth);
log.Write(LogLevel.Verbose, new ColorMod(new string(' ', depth * 4) + CompareOperator.ToWorkshop(), ConsoleColor.DarkYellow));
Value2.DebugPrint(log, depth);
}
public CompareValidatorAttribute(CompareOperator compareOperator, string compareToProperty)
: base("{0} {1} {2}")
{
this.CompareOperator = compareOperator;
this.CompareToProperty = compareToProperty;
}
public string ToWorkshop()
{
return(Value1.ToWorkshop() + " " + CompareOperator.ToWorkshop() + " " + Value2.ToWorkshop());
}
/// <summary>
/// Initializes a new instance of the <see cref="CompareValueRule{TEntity, TProperty}"/> class specifying the compare to value function.
/// </summary>
/// <param name="compareOperator">The <see cref="CompareOperator"/>.</param>
/// <param name="compareToValueFunction">The compare to value function.</param>
/// <param name="compareToTextFunction">The compare to text function (default is to use the result of the <paramref name="compareToValueFunction"/>).</param>
public CompareValueRule(CompareOperator compareOperator, Func <TEntity, TProperty> compareToValueFunction, Func <TEntity, LText> compareToTextFunction = null) : base(compareOperator)
{
_compareToValueFunction = compareToValueFunction ?? throw new ArgumentNullException(nameof(compareToValueFunction));
_compareToTextFunction = compareToTextFunction;
}
public CompareExpression(IExpression leftExpression, IExpression rightExpression, CompareOperator oper)
: base(leftExpression, rightExpression)
{
this.oper = oper;
}
public QuantitySearchCriteria(QuantityField fields, long quantity, CompareOperator compareOperator)
: this(fields, quantity, compareOperator, MatchRule.AnyMustMatch)
{
}
public RequiredIfRule(string rootType, string property, string compareSource, CompareOperator compareOperator, object compareValue, RuleInvocationType invocationTypes, Error error, object requiredValue)
: this(rootType, property, compareSource, compareOperator, compareValue, invocationTypes, error)
{
RequiredValue = requiredValue;
}
/* get the sql search condition of this field */
internal string GetSqlSearchCondition(long id, CompareOperator compareOperator)
{
string fieldName = string.Empty;
if (this == IDSearchField.ItemID)
fieldName = "ItemID";
else if (this == IDSearchField.ParentID)
fieldName = "ParentID";
else if (this == IDSearchField.VolumeID)
fieldName = "VolumeID";
else
throw new NotImplementedException(string.Format("IDSearchField {0} not implemented", value));
return compareOperator.GetSqlCompareString(fieldName, id.ToString());
}
public RequiredIfRule(string rootType, string property, string compareSource, CompareOperator compareOperator, object compareValue, RuleInvocationType invocationTypes, object requiredValue, params ConditionTypeSet[] sets)
: this(rootType, property, compareSource, compareOperator, compareValue, invocationTypes, sets)
{
RequiredValue = requiredValue;
}
/// <summary>
/// Initialize a new compare validator
/// </summary>
/// <param name="compareOperator">Compare operator</param>
public CompareValidator(CompareOperator compareOperator)
{
this.compareOperator = compareOperator;
}
/// <param name="operator">The comparison operation to perform.</param>
/// <param name="valueToCompare">The value to compare with.</param>
public CompareByteRuleAttribute(byte valueToCompare, CompareOperator @operator)
: base(@operator)
{
ValueToCompare = valueToCompare;
}
public RequiredIfRule(string rootType, string property, string compareSource, CompareOperator compareOperator, object compareValue, params ConditionTypeSet[] sets)
: this(rootType, property, compareSource, compareOperator, compareValue, RuleInvocationType.InitNew | RuleInvocationType.PropertyChanged, sets)
{
}
public static bool IsMatch(CompareOperator<Cell> compareOperator, object instance, Type type, string value)
{
return compareOperator.CanCompare(new TypedValue(instance, type), CreateCell(value));
}
public virtual void IfZCmp(NewType type, CompareOperator compareOperator, Label label)
{
IfZCmp(type.Type, compareOperator, label);
}
private static bool CompareOperation(Price lhs, Price rhs, CompareOperator cp)
{
bool result;
if (((Object)rhs == null) || ((Object)lhs == null))
{
throw new ApplicationException("One or both Prices can not be Null!");
}
else
{
// Use Eq because it is not possible to do operator overloading on an interface
if (!(lhs.Underlying.Equals(rhs.Underlying)))
{
throw new ApplicationException("Cannot compare prices with different currencies");
}
else if (!(lhs.Instrument.Equals(rhs.Instrument)))
{
throw new ApplicationException("Cannot compare prices with different instruments");
}
else
{
switch (cp)
{
case CompareOperator.Greater:
result = (lhs.Quantity > rhs.Quantity);
break;
case CompareOperator.GreaterOrEqual:
result = (lhs.Quantity >= rhs.Quantity);
break;
case CompareOperator.Smaller:
result = (lhs.Quantity < rhs.Quantity);
break;
case CompareOperator.SmallerOrEqual:
result = (lhs.Quantity <= rhs.Quantity);
break;
default:
throw new ApplicationException("You did not select a valid comparison option");
}
return result;
}
}
}
public CompareExpression(object leftValue, object rightValue, CompareOperator oper)
: base(leftValue, rightValue)
{
this.oper = oper;
}
private static Expression CompareExpression(CompareOperator filterOperator, MemberExpression compareTarget, object filterValue, object filterValue2)
{
var propertyType = ((PropertyInfo)compareTarget.Member).PropertyType;
var value = TypeConverter.Convert(filterValue, propertyType);
var fix = Expression.PropertyOrField(Expression.Constant(ValueHold.ValueHoldFor(propertyType, value, out var ft), ft), "Value");
switch (filterOperator)
{
case CompareOperator.Equal:
return(Expression.Equal(compareTarget, fix));
case CompareOperator.NotEqual:
return(Expression.NotEqual(compareTarget, fix));
break;
case CompareOperator.GreaterThan:
return(Expression.GreaterThan(compareTarget, fix));
break;
case CompareOperator.GreaterThanOrEqual:
return(Expression.GreaterThanOrEqual(compareTarget, fix));
break;
case CompareOperator.LessThan:
return(Expression.LessThan(compareTarget, fix));
break;
case CompareOperator.LessThanOrEqual:
return(Expression.LessThanOrEqual(compareTarget, fix));
break;
case CompareOperator.Contains:
return(Expression.Call(compareTarget, propertyType.GetMethod("Contains", new[] { propertyType }), fix));
break;
case CompareOperator.ContainsNot:
return(Expression.Not(Expression.Call(compareTarget, propertyType.GetMethod("Contains", new[] { propertyType }), fix)));
break;
case CompareOperator.Between:
var fix2 = Expression.PropertyOrField(Expression.Constant(ValueHold.ValueHoldFor(propertyType, filterValue2, out var ftx2), ftx2), "Value");
return(Expression.AndAlso(Expression.GreaterThanOrEqual(compareTarget, fix), Expression.LessThanOrEqual(compareTarget, fix2)));
break;
case CompareOperator.NotBetween:
var fix2N = Expression.PropertyOrField(Expression.Constant(ValueHold.ValueHoldFor(propertyType, filterValue2, out var ftx2N), ftx2N), "Value");
return(Expression.Not(Expression.AndAlso(Expression.GreaterThanOrEqual(compareTarget, fix), Expression.LessThanOrEqual(compareTarget, fix2N))));
break;
default:
throw new ArgumentOutOfRangeException(nameof(filterOperator), filterOperator, null);
}
}
/// <summary>
/// Renders a comaprison operator
/// </summary>
/// <param name="builder"></param>
/// <param name="op"></param>
protected virtual void Operator(StringBuilder builder, CompareOperator op)
{
if (op == CompareOperator.Equal)
{
builder.Append("=");
}
else if (op == CompareOperator.NotEqual)
{
builder.Append("<>");
}
else if (op == CompareOperator.Greater)
{
builder.Append(">");
}
else if (op == CompareOperator.Less)
{
builder.Append("<");
}
else if (op == CompareOperator.LessOrEqual)
{
builder.Append("<=");
}
else if (op == CompareOperator.GreaterOrEqual)
{
builder.Append(">=");
}
else if (op == CompareOperator.Like)
{
builder.Append("like");
}
else if (op == CompareOperator.Is)
{
builder.Append(" is ");
}
else if (op == CompareOperator.IsNot)
{
builder.Append(" is not ");
}
else
{
throw new InvalidQueryException("Unkown operator: " + op.ToString());
}
}
/// <summary>
/// Renders editor for condition info.
/// </summary>
static public void ConditionData(UndoTarget inUndo, RSConditionData ioCondition, RSValidationFlags inFlags, RSValidationContext inContext)
{
string preview = ioCondition.GetPreviewString(inContext.Trigger, inContext.Library);
GUILayout.Label(preview, RSGUIStyles.RuleHeaderStyle);
EditorGUILayout.Space();
// Enabled
bool bEnabled = EditorGUILayout.Toggle(Content.ConditionEnabledLabel, ioCondition.Enabled);
if (bEnabled != ioCondition.Enabled)
{
inUndo.MarkDirty("Changed Condition Enabled");
ioCondition.Enabled = bEnabled;
}
EditorGUILayout.Space();
using (new EditorGUI.DisabledGroupScope(!bEnabled))
{
RSTypeInfo prevQueryType = ioCondition.Query.TypeInfo(inContext.Trigger, inContext.Library);
// Query
ResolvableValueData(inUndo, Content.ConditionValueLabel, ioCondition.Query, null, inFlags.ForConditionQuery(), inContext);
// comparison
RSTypeInfo queryTypeInfo = ioCondition.Query.TypeInfo(inContext.Trigger, inContext.Library);
if (ioCondition.Query.Mode != ResolvableValueMode.Value && queryTypeInfo != null)
{
EditorGUILayout.Space();
RSEditorUtility.s_ComparisonOperators.Clear();
foreach (var comparison in queryTypeInfo.AllowedOperators())
{
RSEditorUtility.s_ComparisonOperators.Add(comparison, comparison.Name(), (int)comparison);
}
CompareOperator nextOperator = ioCondition.Operator;
if (!RSEditorUtility.s_ComparisonOperators.Contains(nextOperator))
{
nextOperator = RSEditorUtility.s_ComparisonOperators.Get(0);
}
nextOperator = ListGUILayout.Popup(Content.ConditionComparisonLabel, nextOperator, RSEditorUtility.s_ComparisonOperators);
if (nextOperator != ioCondition.Operator)
{
inUndo.MarkDirty("Changed Condition Operator");
ioCondition.Operator = nextOperator;
}
if (nextOperator.IsBinary())
{
EditorGUILayout.Space();
if (prevQueryType != queryTypeInfo)
{
inUndo.MarkDirty("Changed Condition Query Type");
RSResolvableValueData.SetAsValue(ref ioCondition.Target, queryTypeInfo.DefaultValue);
}
ResolvableValueData(inUndo, Content.ConditionTargetLabel, ioCondition.Target, queryTypeInfo, inFlags.ForConditionTarget(), inContext);
}
else
{
if (ioCondition.Target != null)
{
inUndo.MarkDirty("Removed Condition Comparison Target");
ioCondition.Target = null;
}
}
if (ioCondition.Query.IsMultiValue())
{
EditorGUILayout.Space();
Subset subset = (Subset)EditorGUILayout.EnumPopup(Content.ConditionSubsetLabel, ioCondition.MultiQuerySubset);
if (subset != ioCondition.MultiQuerySubset)
{
inUndo.MarkDirty("Changed Condition MultiQuerySubset");
ioCondition.MultiQuerySubset = subset;
}
}
}
}
}
/// <summary> /// Used by Ifs, While, and the like. Child classes required to declare and implement comparisons. /// </summary> /// <param name="compareOperator"></param> /// <param name="value"></param> /// <returns></returns> public abstract bool Evaluate(CompareOperator compareOperator, object value);
internal DependencyCheck(IEditorField dependee, object satisfiedBy, MaskMatch match, CompareOperator compare, bool isMask)
{
_dependee = dependee;
_satisfiedBy = satisfiedBy;
_match = match;
_compare = compare;
_isInt = _satisfiedBy is int;
_isMask = isMask && _isInt;
}
/// <param name="operator">The comparison operation to perform.</param>
/// <param name="valueToCompare">The value to compare with.</param>
public CompareLongRuleAttribute(long valueToCompare, CompareOperator @operator)
: base(@operator)
{
ValueToCompare = valueToCompare;
}
public static bool IsMatch(CompareOperator <Cell> compareOperator, object instance, Type type, string value)
{
return(compareOperator.CanCompare(new TypedValue(instance, type), CreateCell(value)));
}
/// <summary>
/// Creates a comparison WhereTerm.
/// </summary>
/// <param name="expr1">Expression on the left side of the operator</param>
/// <param name="expr2">Expression on the right side of the operator</param>
/// <param name="op">Conditional operator to be applied on the expressions</param>
/// <returns>A new conditional WhereTerm</returns>
/// <remarks>
/// A comparison term compares two expression on the basis of their values. Expressions can be of any type but their results must be of comparible types.
/// For instance, you can not compare a database field of type 'date' and a static value of type 'int'.
/// </remarks>
/// <example>
/// <code>
/// ...
/// query.WherePhrase.Terms.Add(WhereTerm.CreateCompare(SqlExpression.Field("name", tCustomers), SqlExpression.String("J%"), CompareOperator.Like));
/// </code>
/// </example>
public static WhereTerm CreateCompare(SqlExpression expr1, SqlExpression expr2, CompareOperator op)
{
WhereTerm term = new WhereTerm();
term.expr1 = expr1;
term.expr2 = expr2;
term.op = op;
term.type = WhereTermType.Compare;
return(term);
}
//public int? EnumAttribute { get; set; }
public FilterAttribute(string targetProperty, CompareOperator compareOperator)
{
TargetProperty = targetProperty;
Operator = compareOperator;
}
protected virtual string GetWhereOperatorCompare(CompareOperator op)
{
switch (op) {
case CompareOperator.Equals:
return "=";
case CompareOperator.NotEquals:
return "<>";
case CompareOperator.GreaterOrEqualThan:
return ">=";
case CompareOperator.GreaterThan:
return ">";
case CompareOperator.LessOrEqualThan:
return "<=";
case CompareOperator.LessThan:
return "<";
}
return null;
}
public FilterAttribute(string sourceJoinProperty, string targetProperty, CompareOperator compareOperator)
: this(targetProperty, compareOperator)
{
SourceJoinProperty = sourceJoinProperty;
}
public CompareConstraint(CompareOperator compareOp)
{
CompareOp = compareOp;
}
/// <param name="operator">The comparison operation to perform.</param>
/// <param name="valueToCompare">The value to compare with.</param>
/// <exception cref="ArgumentNullException"><paramref name="valueToCompare"/> is a null reference.</exception>
/// <exception cref="ArgumentException"><paramref name="valueToCompare"/> is <see cref="string.Empty"/>.</exception>
public CompareStringRuleAttribute(string valueToCompare, CompareOperator @operator)
: base(@operator)
{
Guard.ArgumentNotNullOrEmptyString(valueToCompare, "valueToCompare");
ValueToCompare = valueToCompare;
}
