Beispiel #1
0
        /// <summary>
        /// Get a filter argument from the arguments collection, or throw an exception if the argument does not exist.
        /// </summary>
        /// <param name="arguments"></param>
        /// <param name="ordinalPosition"></param>
        /// <param name="name">An optional name for the parameter that describes the expected value.</param>
        /// <returns></returns>
        public static FluidValue GetArgumentOrThrow(this FilterArguments arguments, int ordinalPosition, string name = null)
        {
            // Check for named argument first.
            if (!string.IsNullOrWhiteSpace(name) &&
                arguments.HasNamed(name))
            {
                return(arguments[name]);
            }

            // Check for argument in specified ordinal position.
            var value = arguments.At(ordinalPosition - 1);

            if (!value.IsNil())
            {
                return(value);
            }

            throw new ArgumentException($"Argument \"[{ordinalPosition:0;0;?}]{ name }\" not defined.");
        }
Beispiel #2
0
        /// <summary>
        /// Get a filter argument from the arguments collection, or return a default value if the argument does not exist.
        /// </summary>
        /// <param name="arguments"></param>
        /// <param name="ordinalPosition"></param>
        /// <param name="name">An optional name for the parameter that describes the expected value.</param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static FluidValue GetArgumentOrDefault(this FilterArguments arguments, int ordinalPosition, string name, string defaultValue, TemplateOptions options)
        {
            // Check for named argument first.
            if (!string.IsNullOrWhiteSpace(name) &&
                arguments.HasNamed(name))
            {
                return(arguments[name] as StringValue);
            }

            // Check for argument in specified ordinal position.
            var value = arguments.At(ordinalPosition - 1);

            if (!value.IsNil())
            {
                return(FluidValue.Create(value, options));
            }

            // Return default value
            return(FluidValue.Create(defaultValue, options));
        }
Beispiel #3
0
        public static ValueTask <FluidValue> FormatString(FluidValue input, FilterArguments arguments, TemplateContext context)
        {
            if (input.IsNil())
            {
                return(NilValue.Instance);
            }

            var format = input.ToStringValue();

            var culture = context.CultureInfo;

            if (arguments.HasNamed("culture"))
            {
                culture = CultureInfo.CreateSpecificCulture(arguments["culture"].ToStringValue()) ?? context.CultureInfo;
            }

            var parameters = arguments.ValuesToObjectArray();

            return(new StringValue(string.Format(culture, format, parameters)));
        }
Beispiel #4
0
        public ValueTask <FluidValue> ProcessAsync(FluidValue input, FilterArguments arguments, TemplateContext ctx)
        {
            if (input.ToObjectValue() is TagBuilder tagBuilder)
            {
                if (arguments.HasNamed("add_classes"))
                {
                    var classes = arguments["add_classes"].ToStringValue();
                    if (!string.IsNullOrEmpty(classes))
                    {
                        foreach (var cssClass in classes.Split(' ', StringSplitOptions.RemoveEmptyEntries))
                        {
                            tagBuilder.AddCssClass(cssClass);
                        }
                    }
                }

                return(new ValueTask <FluidValue>(input));
            }

            return(new ValueTask <FluidValue>(NilValue.Instance));
        }