public void Where()
{
var input = new ArrayValue(new[] {
new ObjectValue(new { Title = "a", Pinned = true }),
new ObjectValue(new { Title = "b", Pinned = false }),
new ObjectValue(new { Title = "c", Pinned = true })
});
var context = new TemplateContext();
context.MemberAccessStrategy.Register(new { Title = "a", Pinned = true }.GetType());
var arguments1 = new FilterArguments().Add(new StringValue("Pinned"));
var result1 = ArrayFilters.Where(input, arguments1, context);
Assert.Equal(2, result1.Enumerate().Count());
var arguments2 = new FilterArguments()
.Add(new StringValue("Pinned"))
.Add(BooleanValue.Create(false))
;
var result2 = ArrayFilters.Where(input, arguments2, context);
Assert.Single(result2.Enumerate());
var arguments3 = new FilterArguments()
.Add(new StringValue("Title"))
.Add(new StringValue("c"));
var result3 = ArrayFilters.Where(input, arguments3, context);
Assert.Single(result3.Enumerate());
}
public Task Handle(EvaluatingLiquidExpression notification, CancellationToken cancellationToken)
{
var context = notification.TemplateContext;
var options = context.Options;
options.Scope.SetValue("Request", new ObjectValue(new LiquidRequestAccessor()));
options.MemberAccessStrategy.Register <LiquidRequestAccessor, FluidValue>((_, name, _) =>
{
var request = _httpContextAccessor.HttpContext?.Request;
if (request == null)
{
return(NilValue.Instance);
}
return(name switch
{
nameof(HttpRequest.QueryString) => new StringValue(request.QueryString.Value),
nameof(HttpRequest.ContentType) => new StringValue(request.ContentType),
nameof(HttpRequest.ContentLength) => NumberValue.Create(request.ContentLength ?? 0),
nameof(HttpRequest.Form) => request.HasFormContentType ? new ObjectValue(request.Form) : NilValue.Instance,
nameof(HttpRequest.Protocol) => new StringValue(request.Protocol),
nameof(HttpRequest.Path) => new StringValue(request.Path.Value),
nameof(HttpRequest.PathBase) => new StringValue(request.PathBase.Value),
nameof(HttpRequest.Host) => new StringValue(request.Host.Value),
nameof(HttpRequest.IsHttps) => BooleanValue.Create(request.IsHttps),
nameof(HttpRequest.Scheme) => new StringValue(request.Scheme),
nameof(HttpRequest.Method) => new StringValue(request.Method),
_ => NilValue.Instance
});
});
public async ValueTask <FluidValue> ProcessAsync(FluidValue input, FilterArguments args, LiquidTemplateContext context)
{
var layoutAccessor = context.Services.GetRequiredService <ILayoutAccessor>();
var layout = await layoutAccessor.GetLayoutAsync();
return(BooleanValue.Create(layout.Zones.IsNotEmpty(input.ToStringValue())));
}
public override void ConfigureServices(IServiceCollection services)
{
services.Configure <TemplateOptions>(o =>
{
o.Scope.SetValue("Site", new ObjectValue(new LiquidSiteSettingsAccessor()));
o.MemberAccessStrategy.Register <LiquidSiteSettingsAccessor, FluidValue>(async(obj, name, context) =>
{
var liquidTemplateContext = (LiquidTemplateContext)context;
var siteService = liquidTemplateContext.Services.GetRequiredService <ISiteService>();
var site = await siteService.GetSiteSettingsAsync();
FluidValue result = name switch
{
nameof(ISite.SiteName) => new StringValue(site.SiteName),
nameof(ISite.PageTitleFormat) => new StringValue(site.PageTitleFormat),
nameof(ISite.SiteSalt) => new StringValue(site.SiteSalt),
nameof(ISite.SuperUser) => new StringValue(site.SuperUser),
nameof(ISite.Calendar) => new StringValue(site.Calendar),
nameof(ISite.TimeZoneId) => new StringValue(site.TimeZoneId),
nameof(ISite.ResourceDebugMode) => new StringValue(site.ResourceDebugMode.ToString()),
nameof(ISite.UseCdn) => BooleanValue.Create(site.UseCdn),
nameof(ISite.CdnBaseUrl) => new StringValue(site.CdnBaseUrl),
nameof(ISite.PageSize) => NumberValue.Create(site.PageSize),
nameof(ISite.MaxPageSize) => NumberValue.Create(site.MaxPageSize),
nameof(ISite.MaxPagedCount) => NumberValue.Create(site.MaxPagedCount),
nameof(ISite.BaseUrl) => new StringValue(site.BaseUrl),
nameof(ISite.HomeRoute) => new ObjectValue(site.HomeRoute),
nameof(ISite.AppendVersion) => BooleanValue.Create(site.AppendVersion),
nameof(ISite.CacheMode) => new StringValue(site.CacheMode.ToString()),
nameof(ISite.Properties) => new ObjectValue(site.Properties),
_ => NilValue.Instance
};
return(result);
});
});
services.AddScoped <ISetupEventHandler, SetupEventHandler>();
services.AddScoped <IPermissionProvider, Permissions>();
services.AddScoped <IAuthorizationHandler, SuperUserHandler>();
services.AddRecipeExecutionStep <SettingsStep>();
services.AddSingleton <ISiteService, SiteService>();
// Site Settings editor
services.AddScoped <IDisplayManager <ISite>, DisplayManager <ISite> >();
services.AddScoped <IDisplayDriver <ISite>, DefaultSiteSettingsDisplayDriver>();
services.AddScoped <IDisplayDriver <ISite>, ButtonsSettingsDisplayDriver>();
services.AddScoped <INavigationProvider, AdminMenu>();
services.AddScoped <ITimeZoneSelector, DefaultTimeZoneSelector>();
services.AddTransient <IDeploymentSource, SiteSettingsDeploymentSource>();
services.AddSingleton <IDeploymentStepFactory>(new DeploymentStepFactory <SiteSettingsDeploymentStep>());
services.AddScoped <IDisplayDriver <DeploymentStep>, SiteSettingsDeploymentStepDriver>();
services.AddScoped <IRecipeEnvironmentProvider, RecipeEnvironmentSiteNameProvider>();
}
public override async ValueTask <FluidValue> EvaluateAsync(TemplateContext context)
{
var leftValue = await Left.EvaluateAsync(context);
var rightValue = await Right.EvaluateAsync(context);
return(BooleanValue.Create(leftValue.ToBooleanValue() && rightValue.ToBooleanValue()));
}
static RequestLiquidTemplateEventHandler()
{
TemplateContext.GlobalMemberAccessStrategy.Register <HttpRequest, FluidValue>((request, name) =>
{
switch (name)
{
case "QueryString": return(new StringValue(request.QueryString.Value));
case "ContentType": return(new StringValue(request.ContentType));
case "ContentLength": return(NumberValue.Create(request.ContentLength ?? 0));
case "Cookies": return(new ObjectValue(new CookieCollectionWrapper(request.Cookies)));
case "Headers": return(new ObjectValue(new HeaderDictionaryWrapper(request.Headers)));
case "Query": return(new ObjectValue(request.Query));
case "Form": return(request.HasFormContentType ? (FluidValue) new ObjectValue(request.Form) : NilValue.Instance);
case "Protocol": return(new StringValue(request.Protocol));
case "Path": return(new StringValue(request.Path.Value));
case "PathBase": return(new StringValue(request.PathBase.Value));
case "Host": return(new StringValue(request.Host.Value));
case "IsHttps": return(BooleanValue.Create(request.IsHttps));
case "Scheme": return(new StringValue(request.Scheme));
case "Method": return(new StringValue(request.Method));
default: return(null);
}
});
TemplateContext.GlobalMemberAccessStrategy.Register <FormCollection, FluidValue>((forms, name) =>
{
if (name == "Keys")
{
return(new ArrayValue(forms.Keys.Select(x => new StringValue(x))));
}
return(new ArrayValue(forms[name].Select(x => new StringValue(x)).ToArray()));
});
TemplateContext.GlobalMemberAccessStrategy.Register <QueryCollection, string[]>((queries, name) => queries[name].ToArray());
TemplateContext.GlobalMemberAccessStrategy.Register <CookieCollectionWrapper, string>((cookies, name) => cookies.RequestCookieCollection[name]);
TemplateContext.GlobalMemberAccessStrategy.Register <HeaderDictionaryWrapper, string[]>((headers, name) => headers.HeaderDictionary[name].ToArray());
}
public override ValueTask <FluidValue> GetValueAsync(string name, TemplateContext context)
{
return(name switch
{
"length" => new ValueTask <FluidValue>(NumberValue.Create(Length)),
"index" => new ValueTask <FluidValue>(NumberValue.Create(Index)),
"index0" => new ValueTask <FluidValue>(NumberValue.Create(Index0)),
"rindex" => new ValueTask <FluidValue>(NumberValue.Create(RIndex)),
"rindex0" => new ValueTask <FluidValue>(NumberValue.Create(RIndex0)),
"first" => new ValueTask <FluidValue>(BooleanValue.Create(First)),
"last" => new ValueTask <FluidValue>(BooleanValue.Create(Last)),
_ => new ValueTask <FluidValue>(NilValue.Instance),
});
internal static ExcelValue Create(ExcelFormulaToken token, ExpressionScope scope)
{
switch (token.Subtype)
{
case ExcelFormulaTokenSubtype.Text: return(new TextValue(token.Value, scope.OutLanguage));
case ExcelFormulaTokenSubtype.Number: return(new DecimalValue(double.Parse(token.Value, CultureInfo.InvariantCulture), scope.OutLanguage));
case ExcelFormulaTokenSubtype.Logical: return(BooleanValue.Create(bool.Parse(token.Value)));
case ExcelFormulaTokenSubtype.Range: return(new RangeValue(token.Value));
default: throw new InvalidOperationException($"ExcelValue.Create: invalid subtype {token.Subtype}");
}
;
}
internal static ExcelValue Create(JToken token, Language language)
{
if (token == null)
{
return(NA);
}
switch (token.Type)
{
case JTokenType.Object: return(new JsonObjectValue((JObject)token, language));
case JTokenType.Array: return(new ArrayValue((JArray)token, language));
case JTokenType.Boolean: return(BooleanValue.Create((bool)token));
case JTokenType.Integer:
case JTokenType.Float:
return(new DecimalValue((double)token, language));
default: return(new TextValue(token.ToString(), language));
}
}
public override ValueTask <FluidValue> GetValueAsync(string name, TemplateContext context)
{
switch (name)
{
case "length": return(new ValueTask <FluidValue>(NumberValue.Create(Length)));
case "index": return(new ValueTask <FluidValue>(NumberValue.Create(Index)));
case "index0": return(new ValueTask <FluidValue>(NumberValue.Create(Index0)));
case "rindex": return(new ValueTask <FluidValue>(NumberValue.Create(RIndex)));
case "rindex0": return(new ValueTask <FluidValue>(NumberValue.Create(RIndex0)));
case "first": return(new ValueTask <FluidValue>(BooleanValue.Create(First)));
case "last": return(new ValueTask <FluidValue>(BooleanValue.Create(Last)));
default:
return(new ValueTask <FluidValue>(NilValue.Instance));
}
}
public ValueTask <FluidValue> ProcessAsync(FluidValue input, FilterArguments args, TemplateContext context)
{
var content = input.ToBooleanValue();
return(new ValueTask <FluidValue>(BooleanValue.Create(content)));
}
public TemplateContext SetValue(string name, bool value)
{
return(SetValue(name, BooleanValue.Create(value)));
}
internal override FluidValue Evaluate(FluidValue leftValue, FluidValue rightValue)
{
return(BooleanValue.Create(leftValue.ToBooleanValue() && rightValue.ToBooleanValue()));
}
/// <summary>
/// Adds tenant level services for managing liquid view template files.
/// </summary>
public static OrchardCoreBuilder AddLiquidViews(this OrchardCoreBuilder builder)
{
builder.ConfigureServices(services =>
{
services.AddSingleton <LiquidViewParser>();
services.AddSingleton <IAnchorTag, AnchorTag>();
services.AddTransient <IConfigureOptions <TemplateOptions>, TemplateOptionsFileProviderSetup>();
services.TryAddEnumerable(
ServiceDescriptor.Transient <IConfigureOptions <LiquidViewOptions>,
LiquidViewOptionsSetup>());
services.TryAddEnumerable(
ServiceDescriptor.Transient <IConfigureOptions <ShapeTemplateOptions>,
LiquidShapeTemplateOptionsSetup>());
services.AddSingleton <IApplicationFeatureProvider <ViewsFeature>, LiquidViewsFeatureProvider>();
services.AddScoped <IRazorViewExtensionProvider, LiquidViewExtensionProvider>();
services.AddSingleton <LiquidTagHelperFactory>();
services.Configure <TemplateOptions>(o =>
{
o.ValueConverters.Add(x =>
{
if (x is Shape s)
{
return(new ObjectValue(s));
}
if (!(o is IShape) && o is IHtmlContent c)
{
return(new HtmlContentValue(c));
}
return(null);
});
o.MemberAccessStrategy.Register <Shape>("*", new ShapeAccessor());
o.MemberAccessStrategy.Register <ZoneHolding>("*", new ShapeAccessor());
o.MemberAccessStrategy.Register <ShapeMetadata>();
o.Scope.SetValue("Culture", new ObjectValue(new LiquidCultureAccessor()));
o.MemberAccessStrategy.Register <LiquidCultureAccessor, FluidValue>((obj, name, ctx) =>
{
return(name switch
{
nameof(CultureInfo.Name) => new StringValue(CultureInfo.CurrentUICulture.Name),
"Dir" => new StringValue(CultureInfo.CurrentUICulture.GetLanguageDirection()),
_ => NilValue.Instance
});
});
o.Scope.SetValue("Request", new ObjectValue(new LiquidRequestAccessor()));
o.MemberAccessStrategy.Register <LiquidRequestAccessor, FluidValue>((obj, name, ctx) =>
{
var request = ((LiquidTemplateContext)ctx).Services.GetRequiredService <IHttpContextAccessor>().HttpContext?.Request;
if (request != null)
{
return(name switch
{
nameof(HttpRequest.QueryString) => new StringValue(request.QueryString.Value),
nameof(HttpRequest.ContentType) => new StringValue(request.ContentType),
nameof(HttpRequest.ContentLength) => NumberValue.Create(request.ContentLength ?? 0),
nameof(HttpRequest.Cookies) => new ObjectValue(new CookieCollectionWrapper(request.Cookies)),
nameof(HttpRequest.Headers) => new ObjectValue(new HeaderDictionaryWrapper(request.Headers)),
nameof(HttpRequest.Query) => new ObjectValue(request.Query),
nameof(HttpRequest.Form) => request.HasFormContentType ? (FluidValue) new ObjectValue(request.Form) : NilValue.Instance,
nameof(HttpRequest.Protocol) => new StringValue(request.Protocol),
nameof(HttpRequest.Path) => new StringValue(request.Path.Value),
nameof(HttpRequest.PathBase) => new StringValue(request.PathBase.Value),
nameof(HttpRequest.Host) => new StringValue(request.Host.Value),
nameof(HttpRequest.IsHttps) => BooleanValue.Create(request.IsHttps),
nameof(HttpRequest.Scheme) => new StringValue(request.Scheme),
nameof(HttpRequest.Method) => new StringValue(request.Method),
nameof(HttpRequest.RouteValues) => new ObjectValue(new RouteValueDictionaryWrapper(request.RouteValues)),
_ => NilValue.Instance
});
}
return(NilValue.Instance);
});
public static TemplateContext SetValue(this TemplateContext context, string name, bool value)
{
return(context.SetValue(name, BooleanValue.Create(value)));
}
public static ExcelValue CreateBoolean(string oper, ExcelValue v1, ExcelValue v2, bool ignoreCase = true)
{
if (v1 == NA || v2 == NA)
{
return(NA);
}
if (v1 is ErrorValue)
{
return(v1);
}
if (v2 is ErrorValue)
{
return(v2);
}
if (oper == "=")
{
if (v1 is BooleanValue)
{
return(BooleanValue.Create(v1 == v2));
}
if ((v1 is TextValue && v2 is TextValue)) //*********** || (v1 is JsonTextValue && v2 is JsonTextValue))
{
return(BooleanValue.Create(string.Compare((string)v1.InnerValue, (string)v2.InnerValue, ignoreCase) == 0));
}
if (v1 is DecimalValue && v2 is DecimalValue)
{
return(BooleanValue.Create(((double)v1.InnerValue).IsEqual((double)v2.InnerValue)));
}
return(FALSE);
}
if (oper == "<" || oper == "<=")
{
var tmp = v1;
v1 = v2;
v2 = tmp;
oper = oper == "<" ? ">=" : ">";
}
if (oper == ">")
{
if (v1 is BooleanValue)
{
return(BooleanValue.Create(v1 == TRUE && v2 == FALSE));
}
if ((v1 is TextValue && v2 is TextValue)) //********** || (v1 is JsonTextValue && v2 is JsonTextValue))
{
return(BooleanValue.Create(string.Compare((string)v1.InnerValue, (string)v2.InnerValue, ignoreCase) > 0));
}
if (v1 is DecimalValue && v2 is DecimalValue)
{
return(BooleanValue.Create(((double)v1.InnerValue).CompareWith((double)v2.InnerValue) > 0));
}
return(BooleanValue.Create(string.Compare(v1.InnerValue.ToString(), v2.InnerValue.ToString(), ignoreCase) > 0));
}
if (oper == ">=")
{
if (v1 is BooleanValue)
{
return(BooleanValue.Create(!(v1 == FALSE && v2 == TRUE)));
}
if ((v1 is TextValue && v2 is TextValue)) // *************** || (v1 is JsonTextValue && v2 is JsonTextValue))
{
return(BooleanValue.Create(string.Compare((string)v1.InnerValue, (string)v2.InnerValue, ignoreCase) >= 0));
}
if (v1 is DecimalValue && v2 is DecimalValue)
{
return(BooleanValue.Create(((double)v1.InnerValue).CompareWith((double)v2.InnerValue) >= 0));
}
return(BooleanValue.Create(string.Compare(v1.InnerValue.ToString(), v2.InnerValue.ToString(), ignoreCase) >= 0));
}
throw new InvalidOperationException($"Unhandled comparison {v1?.GetType().Name ?? "NULL"} {oper} {v2?.GetType().Name ?? "NULL"}");
}
