public override Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object parsedValue)
{
Expression property = context.GetInstance();
return(FilterExpressionBuilder.In(
property,
context.RuntimeTypes.Peek().Source,
parsedValue));
}
/// <summary>
/// Returns the moderation workflow supporting the specified group.
/// </summary>
/// <param name="group">ID of the group</param>
/// <returns>Moderation workflow supporting the specified group</returns>
private CommunityMembershipWorkflow GetWorkflowFor(string group)
{
CommunityMembershipWorkflow expectedSocialWorkflow = null;
var listOfWorkflow = Enumerable.Empty <Composite <Workflow, MembershipModeration> >();
var filterWorkflowsByGroup =
FilterExpressionBuilder <MembershipModeration> .Field(m => m.Group)
.EqualTo(group);
var criteria = new CompositeCriteria <WorkflowFilter, MembershipModeration>
{
PageInfo = new PageInfo {
PageSize = 1
},
ExtensionFilter = filterWorkflowsByGroup
};
try
{
listOfWorkflow = _workflowService.Get(criteria).Results;
if (listOfWorkflow.Any())
{
var workflow = listOfWorkflow.First().Data;
expectedSocialWorkflow =
new CommunityMembershipWorkflow(workflow.Id.Id, workflow.Name, workflow.InitialState.Name);
}
}
catch (SocialAuthenticationException ex)
{
throw new SocialRepositoryException("The application failed to authenticate with Episerver Social.",
ex);
}
catch (MaximumDataSizeExceededException ex)
{
throw new SocialRepositoryException(
"The application request was deemed too large for Episerver Social.", ex);
}
catch (SocialCommunicationException ex)
{
throw new SocialRepositoryException("The application failed to communicate with Episerver Social.", ex);
}
catch (SocialException ex)
{
throw new SocialRepositoryException("Episerver Social failed to process the application request.", ex);
}
return(expectedSocialWorkflow);
}
public override Expression HandleOperation(
QueryableFilterContext context,
IFilterOperationField field,
IValueNode value,
object?parsedValue)
{
Expression property = context.GetInstance();
parsedValue = ParseValue(value, parsedValue, field.Type, context);
if (parsedValue is null)
{
throw ThrowHelper.Filtering_CouldNotParseValue(this, value, field.Type, field);
}
return(FilterExpressionBuilder.LowerThanOrEqual(property, parsedValue));
}
public void BuildExpression_single(string filterstring, string expr)
{
//arrange
var parts = filterstring.Split('=');
var filterkvp = new KeyValuePair <string, string>(parts[0], parts[1]);
var filterOps = new FilterOptionsParser().Parse(new List <KeyValuePair <string, string> >()
{
filterkvp
});
//act
var exp = new FilterExpressionBuilder().Build <TestObj>(filterOps);
//assert
exp.Item1.Should().Be(expr);
exp.Item2.Count().Should().Be(1);
}
public async void onFilterAlarms()
{
//Implement for each query Group by PropertyName : StationName , Priority or Desc.
//ExpressGen();
IEnumerable <IGrouping <string, Item> > groupFields =
from item in filters
group item by item.FieldName;
filterParseDeleg = FilterExpressionBuilder.GetExpression <RestorationAlarmLists>(groupFields);
RestAlarmsRepo.filterParseDeleg = filterParseDeleg;
await RestAlarmsRepo.GetCustAlarmAct();
Console.WriteLine(filterParseDeleg.Body);
}
public void TestContains()
{
var entities = this.database.CreateSimilarEntities(3, "Name 1");
this.database.CreateSimilarEntities(3, "Name 2");
this.database.CreateSimilarEntities(3, "Name 3");
var builder = new FilterExpressionBuilder <Entity, string>(nameof(Entity.Name), "e 1");
var expression = builder.CreateContainsExpression();
using (var context = this.database.Create())
{
var result = context.Entities
.Where(expression)
.ToList();
Assert.Equal(entities, result, new PropertyComparer <Entity>());
}
}
public void TestIntComparison(
Func <Entity, bool> filter,
Func <FilterExpressionBuilder <Entity, int>, Expression <Func <Entity, bool> > > expressionFactory)
{
var entities = this.database.CreateEnumeratedEntities(10)
.Where(filter)
.ToList();
var builder = new FilterExpressionBuilder <Entity, int>(
nameof(Entity.Id), IntComparisonValue);
var expression = expressionFactory(builder);
using (var context = this.database.Create())
{
var result = context.Entities
.Where(expression)
.ToList();
Assert.Equal(entities, result, new PropertyComparer <Entity>());
}
}
public void GetFilterExpressionForNullable()
{
int?value = 4567;
var a = FilterExpressionBuilder.CreateBuilder <MyTestClass>(builder =>
{
builder.Add("a", FilterExpressionParameter.Create(fep =>
{
fep.Value = value;
fep.ComparisonType = ComparisonType.Equal;
fep.Operator = Operator.Or;
})).Add("b", FilterExpressionParameter.Create(fep =>
{
fep.Value = value;
fep.ComparisonType = ComparisonType.Equal;
fep.Operator = Operator.Or;
}));
}).FilterExpression;
Assert.IsAssignableFrom <Expression <Func <MyTestClass, bool> > >(a);
}
public async void onUserQuery()
{
RestAlarmsRepo.sortParseDeleg = FieldOrders.ToList();
//RestAlarmsRepo.orderParseDeleg = sortOrderList.First(i => i.ID == sortTemplate);
Console.WriteLine("Run Standard Query cmd");
IEnumerable <IGrouping <string, Item> > groupFields =
from item in qFilters
group item by item.FieldName;
// Preparing for New Database
queryParseDeleg = FilterExpressionBuilder.GetExpression <RestorationAlarmLists>(groupFields);
RestAlarmsRepo.filterParseDeleg = queryParseDeleg;
//RestAlarmsRepo.qDateTimeCondEnd = DateTime.Now;
await RestAlarmsRepo.TGetQueryAlarmAct();
Console.WriteLine(queryParseDeleg.Body);
}
public override bool TryHandleLeave(
QueryableFilterContext context,
IFilterField field,
ObjectFieldNode node,
[NotNullWhen(true)] out ISyntaxVisitorAction?action)
{
// Dequeue last
Expression condition = context.GetLevel().Dequeue();
context.PopInstance();
context.RuntimeTypes.Pop();
if (context.InMemory)
{
condition = FilterExpressionBuilder.NotNullAndAlso(
context.GetInstance(),
condition);
}
context.GetLevel().Enqueue(condition);
action = SyntaxVisitor.Continue;
return(true);
}
public void Setup()
{
_builder = new FilterExpressionBuilder<TestSource>();
}
public static IQueryable <T> Where <T>(this IQueryable <T> query, string filter)
{
var expression = FilterExpressionBuilder.Build <T>(filter);
return(query.Where(expression));
}
private static Expression GetExpressionBodyWithNullCheck(this QueryableClosure closure) => FilterExpressionBuilder.NotNullAndAlso(closure.Parameter, closure.Level.Peek().Peek());
private Expression GetExpressionBodyWithNullCheck() => FilterExpressionBuilder.NotNullAndAlso(Parameter, Level.Peek().Peek());
