public bool LessThanEqualTo_IsValid(int propertyValue, int lessThanEqualTo)
{
//Create Validator
var validator = new LessThanEqualTo <Contact, int>(lessThanEqualTo);
RuleValidatorContext <Contact, int> context = BuildContextForNumberOfDependents(propertyValue);
var notification = new ValidationNotification();
//Validate the validator only, return true of no error returned
return(validator.Validate(context, null, notification));
}
private static BaseExpression Invert(BaseExpression expression)
{
return(expression switch {
EqualTo a => (BaseExpression) new NotEqualTo(a.Left, a.Right),
GreaterThan a => new LessThanEqualTo(a.Left, a.Right),
GreaterThanEqualTo a => new LessThan(a.Left, a.Right),
LessThan a => new GreaterThanEqualTo(a.Left, a.Right),
LessThanEqualTo a => new GreaterThan(a.Left, a.Right),
NotEqualTo a => new EqualTo(a.Left, a.Right),
_ => new EqualTo(new ConstantNumber((Number)0), new Bracketed(expression))
});
public bool LessThanEqualTo_Expression_IsValid(string propertyValue, string lessThan)
{
DateTime propertyValueDateTime = DateTime.Parse(propertyValue);
DateTime lessThanDateTime = DateTime.Parse(lessThan);
//Create Validator
var validator = new LessThanEqualTo <CalendarEvent, DateTime>(c => c.EndDate);
// Build context for CalendarEvent containing a StartDate of propertyValue.
RuleValidatorContext <CalendarEvent, DateTime> context = BuildContextForCalendarEventStartDate("Test Event", propertyValueDateTime, lessThanDateTime);
var notification = new ValidationNotification();
//Validate the validator only, return true of no error returned
return(validator.Validate(context, null, notification));
}
public virtual TResult Visit(BaseExpression expression)
{
return(expression switch {
Phi a => Visit(a),
Increment a => Visit(a),
Decrement a => Visit(a),
ErrorExpression a => Visit(a),
Bracketed a => Visit(a),
Abs a => Visit(a),
Sqrt a => Visit(a),
Sine a => Visit(a),
Cosine a => Visit(a),
Tangent a => Visit(a),
ArcSine a => Visit(a),
ArcCos a => Visit(a),
ArcTan a => Visit(a),
PostIncrement a => Visit(a),
PreIncrement a => Visit(a),
PostDecrement a => Visit(a),
PreDecrement a => Visit(a),
Add a => Visit(a),
Subtract a => Visit(a),
Multiply a => Visit(a),
Divide a => Visit(a),
Modulo a => Visit(a),
Negate a => Visit(a),
Exponent a => Visit(a),
Or a => Visit(a),
And a => Visit(a),
Not a => Visit(a),
Factorial a => Visit(a),
Variable a => Visit(a),
ConstantNumber a => Visit(a),
ConstantString a => Visit(a),
EqualTo a => Visit(a),
NotEqualTo a => Visit(a),
GreaterThan a => Visit(a),
GreaterThanEqualTo a => Visit(a),
LessThan a => Visit(a),
LessThanEqualTo a => Visit(a),
_ => VisitUnknown(expression)
});
protected override bool Visit(LessThanEqualTo eq) => true;
protected override Type Visit(LessThanEqualTo eq) => BinaryLogical(eq);
[NotNull] protected abstract TResult Visit([NotNull] LessThanEqualTo eq);
public static void CreateFilter(object sender, object selectedItem)
{
if (selectedItem is FilterCollectionViewModel filterCollectionViewModel)
{
CreateFilter(sender, filterCollectionViewModel.Parent);
return;
}
var button = (Button)sender;
var type = (string)button.CommandParameter;
FilterBase entity;
switch (type)
{
case nameof(ActiveOn):
entity = ActiveOn.New("0001-01-01");
break;
case nameof(ActiveWithin):
entity = ActiveWithin.New("0001-01-01,0001-01-01");
break;
case nameof(OfType):
entity = OfType.New("TypeName");
break;
case nameof(NotOfType):
entity = NotOfType.New("TypeName");
break;
case nameof(Contain):
entity = Contain.New("Property", "Value");
break;
case nameof(NotContain):
entity = NotContain.New("Property", "Value");
break;
case nameof(EqualTo):
entity = EqualTo.New("Property", "Value");
break;
case nameof(NotEqualTo):
entity = NotEqualTo.New("Property", "Value");
break;
case nameof(GreaterThan):
entity = GreaterThan.New("Property", "Value");
break;
case nameof(LessThan):
entity = LessThan.New("Property", "Value");
break;
case nameof(GreaterThanEqualTo):
entity = GreaterThanEqualTo.New("Property", "Value");
break;
case nameof(LessThanEqualTo):
entity = LessThanEqualTo.New("Property", "Value");
break;
case nameof(Between):
entity = Between.New("Property", "0001-01-01", "0001-01-01");
break;
case nameof(WithinArray):
entity = WithinArray.New("Property", "ValueA,ValueB,ValueC");
break;
case nameof(NotWithinArray):
entity = NotWithinArray.New("Property", "ValueA,ValueB,ValueC");
break;
case nameof(IsNull):
entity = IsNull.New("Property");
break;
case nameof(IsNotNull):
entity = IsNotNull.New("Property");
break;
case nameof(IsNullOrGreaterThan):
entity = IsNullOrGreaterThan.New("Property", "Value");
break;
case nameof(IsNullOrGreaterThanEqualTo):
entity = IsNullOrGreaterThanEqualTo.New("Property", "Value");
break;
case nameof(IsNullOrLessThan):
entity = IsNullOrLessThan.New("Property", "Value");
break;
case nameof(IsNullOrLessThanEqualTo):
entity = IsNullOrLessThanEqualTo.New("Property", "Value");
break;
case nameof(StartsWith):
entity = StartsWith.New("Property", "Value");
break;
case nameof(EndsWith):
entity = EndsWith.New("Property", "Value");
break;
case nameof(TakeFirst):
entity = TakeFirst.New(1);
break;
case nameof(OfDerivedType):
entity = OfDerivedType.New("TypeName");
break;
case nameof(NotOfDerivedType):
entity = NotOfDerivedType.New("TypeName");
break;
default:
throw new ArgumentOutOfRangeException();
}
FilterViewModel viewModel;
FilterCollectionViewModel viewModelCollection;
if (selectedItem is GroupViewModel entityGroupViewModel)
{
entityGroupViewModel.IsExpanded = true;
entityGroupViewModel.Element.Filters.Add(entity);
viewModelCollection = entityGroupViewModel.Children.OfType <FilterCollectionViewModel>().First();
viewModel = new FilterViewModel(entity, viewModelCollection);
viewModelCollection.Children.Add(viewModel);
}
else if (selectedItem is OutputViewModel outputViewModel)
{
if (!(outputViewModel.Element is AggregateOutputBase elementAsAggregate))
{
return;
}
outputViewModel.IsExpanded = true;
elementAsAggregate.Filters.Add(entity);
viewModelCollection = outputViewModel.Children.OfType <FilterCollectionViewModel>().First();
viewModel = new FilterViewModel(entity, viewModelCollection);
viewModelCollection.Children.Add(viewModel);
}
else
{
return;
}
viewModelCollection.IsExpanded = true;
viewModel.IsSelected = true;
viewModel.IsExpanded = true;
}
protected override BaseExpression Visit(LessThanEqualTo eq)
{
using (AppendLine("<="))
return(base.Visit(eq));
}
[NotNull] protected virtual BaseExpression Visit([NotNull] LessThanEqualTo eq)
{
return(new LessThanEqualTo(Visit(eq.Left), Visit(eq.Right)));
}
protected override IDataFlowGraphExpressionNode Visit(LessThanEqualTo eq) => VisitBinary(eq, YololBinaryOp.LessThanEqualTo);
protected override bool Visit(LessThanEqualTo eq) => VisitBinary(eq);
protected override IEnumerable <BaseStatement> Visit(LessThanEqualTo eq) => Binary(eq, (a, b) => new LessThanEqualTo(a, b));
protected override bool Visit(LessThanEqualTo eq) => base.Visit(eq.Left) || base.Visit(eq.Right);
protected override bool Visit(LessThanEqualTo eq) => Visit(eq.Left) && Visit(eq.Right);
