Example #1
0
        /// <summary>
        /// A transform that allows a parameter at execution time to control the ORDER BY statement.
        /// </summary>
        /// <param name = "parameterName" > Name of the parameter.</param>
        /// <exception cref="ArgumentNullException">parameterName is null.</exception>
        /// <returns>ICommandExpression&lt; TFilter&gt;.</returns>
        /// <exception cref="FormatException">Order By parameter either contains unsafe characters or a bad format</exception>
        public static CommandTransform OrderByExpression(string parameterName = "OrderBy")
        {
            if (parameterName == null)
            {
                throw new ArgumentNullException(nameof(parameterName));
            }

            var orderByModifier = new CommandTransform("OrderByExpression", info =>
            {
                var orderByParameter = info.Parameters.First(p => p.ParameterName == parameterName);

                if (orderByParameter.Value == null ||
                    !(OrderByRegex.IsMatch(orderByParameter.Value.ToString())))
                {
                    throw new FormatException("Order By paramter either contains unsafe characters or a bad format");
                }

                return(new ExecutableCommandInfo
                {
                    CommandText = info.CommandText + "\r\nORDER BY " + orderByParameter.Value,
                    Parameters = info.Parameters.Where(p => p.ParameterName != parameterName).ToArray(),
                    DbCommandType = info.DbCommandType
                });
            }
                                                       );

            return(orderByModifier);
        }
Example #2
0
        /// <summary>
        /// Builds the where filter.
        /// </summary>
        /// <typeparam name="TFilter">The type of the t filter.</typeparam>
        /// <typeparam name="TResult">The type of the t result.</typeparam>
        /// <param name="processor">The processor.</param>
        /// <param name="options">The options.</param>
        /// <returns>ICommandExpression&lt;TFilter&gt;.</returns>
        public static CommandTransform WhereFilter <TFilter, TResult>(ICommandProcessorWithResults <TFilter> processor, Type resultType, ExpandoObject options)
        {
            var whereFilterModifier = new CommandTransform("WhereFilter",
                                                           new WhereFilterTransformFactory <TFilter>(processor, resultType, options)
                                                           .BuildWhereFilterTransform);

            return(whereFilterModifier);
        }
Example #3
0
        /// <summary>
        /// Builds the where filter.
        /// </summary>
        /// <typeparam name="TFilter">The type of the t filter.</typeparam>
        /// <typeparam name="TResult">The type of the t result.</typeparam>
        /// <param name="processor">The processor.</param>
        /// <param name="options">The options.</param>
        /// <returns>ICommandExpression&lt;TFilter&gt;.</returns>
        public static CommandTransform WhereFilter <TFilter, TResult>(ISingleResultSetCommandProcessor <TFilter, TResult> processor, ExpandoObject options)
        {
            var whereFilterModifier = new CommandTransform("WhereFilter",
                                                           new WhereFilterTransformFactory <TFilter, TResult>(processor, options)
                                                           .BuildWhereFilterTransform);

            return(whereFilterModifier);
        }
Example #4
0
        /// <summary>
        /// Builds the where filter.
        /// </summary>
        /// <typeparam name="TFilter">The type of the t filter.</typeparam>
        /// <typeparam name="TResult">The type of the t result.</typeparam>
        /// <param name="processor">The processor.</param>
        /// <param name="optionsObject">The options object.</param>
        /// <returns>ICommandExpression&lt;TFilter&gt;.</returns>
        public static CommandTransform WhereFilter <TFilter>(ICommandProcessorWithResults <TFilter> processor, Type resultType, object optionsObject = null)
        {
            var whereFilterModifier = new CommandTransform("WhereFilter",
                                                           new WhereFilterTransformFactory <TFilter>(processor, resultType, optionsObject != null ? optionsObject.ToExpando() : new ExpandoObject())
                                                           .BuildWhereFilterTransform);

            return(whereFilterModifier);
        }
Example #5
0
        /// <summary>
        /// Builds the where filter.
        /// </summary>
        /// <typeparam name="TFilter">The type of the t filter.</typeparam>
        /// <typeparam name="TResult">The type of the t result.</typeparam>
        /// <param name="processor">The processor.</param>
        /// <param name="whereFilterOptions">The where filter options.</param>
        /// <returns>ICommandExpression&lt;TFilter&gt;.</returns>
        public static CommandTransform WhereFilter <TFilter, TResult>(ISingleResultSetCommandProcessor <TFilter, TResult> processor, IDictionary <string, object> whereFilterOptions)
        {
            var whereFilterModifier = new CommandTransform("WhereFilter",
                                                           new WhereFilterTransformFactory <TFilter, TResult>(processor, whereFilterOptions)
                                                           .BuildWhereFilterTransform);

            return(whereFilterModifier);
        }