//[InlineData("2019-10-12", "2019-10-12T00:00:00.0000000")]
//[InlineData(">2019-10-12", ">2019-10-12T00:00:00.0000000")]
//[InlineData("2017-01-01T01:00:00+07:00", "2017-01-01T01:00:00.0000000+07:00")]
//[InlineData("2017-01-01T01:00:00+07:00..2017-01-01T01:00:00+07:00", "2017-01-01T01:00:00.0000000+07:00..2017-01-01T01:00:00.0000000+07:00")]
public void DateParserTests(string text, string expected)
{
var context = new DateTimeParseContext(CultureInfo.InvariantCulture, Mock.Of <IClock>(), Mock.Of <ITimeZone>(), new Scanner(text));
Assert.True(DateTimeParser.Parser.TryParse(context, out var result, out var error));
Assert.StartsWith(expected, result.ToString());
}
public void Build(QueryEngineBuilder <AuditTrailEvent> builder)
{
builder
.WithNamedTerm("id", builder => builder
.OneCondition((val, query) =>
{
if (!String.IsNullOrEmpty(val))
{
query.With <AuditTrailEventIndex>(x => x.CorrelationId == val);
}
return(query);
})
.MapTo <AuditTrailIndexOptions>((val, model) =>
{
model.CorrelationId = val;
})
.MapFrom <AuditTrailIndexOptions>((model) =>
{
if (!String.IsNullOrEmpty(model.CorrelationId))
{
return(true, model.CorrelationId);
}
return(false, String.Empty);
})
)
.WithNamedTerm("category", builder => builder
.OneCondition((val, query) =>
{
if (!String.IsNullOrEmpty(val))
{
query.With <AuditTrailEventIndex>(x => x.Category == val);
}
return(query);
})
.MapTo <AuditTrailIndexOptions>((val, model) =>
{
model.Category = val;
})
.MapFrom <AuditTrailIndexOptions>((model) =>
{
if (!String.IsNullOrEmpty(model.Category))
{
return(true, model.Category);
}
return(false, String.Empty);
})
)
.WithNamedTerm("event", builder => builder
.OneCondition((val, query) =>
{
if (!String.IsNullOrEmpty(val))
{
query.With <AuditTrailEventIndex>(x => x.Name == val);
}
return(query);
})
.MapTo <AuditTrailIndexOptions>((val, model) =>
{
model.Event = val;
})
.MapFrom <AuditTrailIndexOptions>((model) =>
{
if (!String.IsNullOrEmpty(model.Event))
{
return(true, model.Event);
}
return(false, String.Empty);
})
)
.WithNamedTerm("date", builder => builder
.OneCondition(async(val, query, ctx) =>
{
if (String.IsNullOrEmpty(val))
{
return(query);
}
var context = (AuditTrailQueryContext)ctx;
var clock = context.ServiceProvider.GetRequiredService <IClock>();
var localClock = context.ServiceProvider.GetRequiredService <ILocalClock>();
var userTimeZone = await localClock.GetLocalTimeZoneAsync();
var parseContext = new DateTimeParseContext(CultureInfo.CurrentUICulture, clock, userTimeZone, new Scanner(val));
if (DateTimeParser.Parser.TryParse(parseContext, out var expression, out var parseError))
{
var utcNow = clock.UtcNow;
var param = Expression.Parameter(typeof(AuditTrailEventIndex));
var field = Expression.Property(param, nameof(AuditTrailEventIndex.CreatedUtc));
var expressionContext = new BuildExpressionContext(utcNow, param, field, typeof(Func <AuditTrailEventIndex, bool>));
query.With <AuditTrailEventIndex>((Expression <Func <AuditTrailEventIndex, bool> >)expression.BuildExpression(expressionContext));
}
return(query);
})
.MapTo <AuditTrailIndexOptions>((val, model) =>
{
model.Date = val;
})
.MapFrom <AuditTrailIndexOptions>((model) =>
{
if (!String.IsNullOrEmpty(model.Date))
{
return(true, model.Date);
}
return(false, String.Empty);
})
)
.WithNamedTerm("sort", builder => builder
.OneCondition((val, query, ctx) =>
{
var context = (AuditTrailQueryContext)ctx;
var options = context.ServiceProvider.GetRequiredService <IOptions <AuditTrailAdminListOptions> >().Value;
if (options.SortOptions.TryGetValue(val, out var sortOption))
{
return(sortOption.Query(val, query, ctx));
}
return(options.DefaultSortOption.Query(val, query, ctx));
})
.MapTo <AuditTrailIndexOptions>((val, model) =>
{
// TODO add a context property to the mapping func.
if (!String.IsNullOrEmpty(val) && _options.Value.SortOptions.TryGetValue(val, out var sortOption))
{
model.Sort = sortOption.Value;
}
})
.MapFrom <AuditTrailIndexOptions>((model) =>
{
// TODO add a context property to the mapping func.
if (model.Sort != _options.Value.DefaultSortOption.Value)
{
return(true, model.Sort);
}
return(false, String.Empty);
})
.AlwaysRun()
)
.WithDefaultTerm("username", builder => builder
.ManyCondition(
(val, query, ctx) =>
{
var context = (AuditTrailQueryContext)ctx;
var lookupNormalizer = context.ServiceProvider.GetRequiredService <ILookupNormalizer>();
var normalizedUserName = lookupNormalizer.NormalizeName(val);
query.With <AuditTrailEventIndex>(x => x.NormalizedUserName.Contains(normalizedUserName));
return(new ValueTask <IQuery <AuditTrailEvent> >(query));
},
(val, query, ctx) =>
{
var context = (AuditTrailQueryContext)ctx;
var lookupNormalizer = context.ServiceProvider.GetRequiredService <ILookupNormalizer>();
var normalizedUserName = lookupNormalizer.NormalizeName(val);
query.With <AuditTrailEventIndex>(x => x.NormalizedUserName.NotContains(normalizedUserName));
return(new ValueTask <IQuery <AuditTrailEvent> >(query));
}
)
)
.WithNamedTerm("userid", builder => builder
.ManyCondition(
(val, query) =>
{
query.With <AuditTrailEventIndex>(x => x.UserId.Contains(val));
return(query);
},
(val, query) =>
{
query.With <AuditTrailEventIndex>(x => x.UserId.NotContains(val));
return(query);
}
)
);
}
