ContentQueryStatementInterpreter.cs :  » Content-Management-Systems-CMS » Kooboo » Everest » CmsServices » DataRule » C# / CSharp Open Source

/*
Kooboo is a content management system based on ASP.NET MVC framework. Copyright 2009 Yardi Technology Limited.

This program is free software: you can redistribute it and/or modify it under the terms of the
GNU General Public License version 3 as published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program.
If not, see http://www.kooboo.com/gpl3/.
*/
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Everest.Library.Reflection;
using Everest.CmsServices.Exceptions;
using System.Reflection;

using Everest.Library.ExtensionMethod;

namespace Everest.CmsServices.DataRule{
    /// <summary>
    /// 
    /// </summary>
    public abstract class ContentQueryStatementInterpreter
    {
        /// <summary>
        /// Gets or sets the query expression.
        /// </summary>
        /// <value>The query expression.</value>
        public string QueryExpression { get; private set; }

        /// <summary>
        /// Gets or sets the parameters.
        /// </summary>
        /// <value>The parameters.</value>
        public IDictionary<string, object> Parameters { get; private set; }
        /// <summary>
        /// Initializes a new instance of the <see cref="ContentQueryStatementInterpreter"/> class.
        /// </summary>
        /// <param name="queryExpression">The query expression.</param>
        /// <param name="queryString">The query string.</param>
        public ContentQueryStatementInterpreter(string queryExpression, IDictionary<string, object> queryString)
        {
            this.Interpreter(queryExpression, queryString);
        }
        static string DataParameter = "param{0}";
        static Regex braceRegex = new Regex(@"{(\w+)}", RegexOptions.Compiled | RegexOptions.IgnoreCase);
        // static Regex bracketRegex = new Regex(@"\[(\w+)\]", RegexOptions.Compiled | RegexOptions.IgnoreCase);
        /// <summary>
        /// Interpreters the specified query statement.
        /// </summary>
        /// <param name="queryExpression">The query expression.</param>
        /// <param name="queryString">The query string.</param>
        /// <param name="parameters">The parameters.</param>
        /// <returns></returns>
        protected virtual void Interpreter(string queryExpression, IDictionary<string, object> queryString)
        {
            StringBuilder stringBuilder = new StringBuilder(queryExpression);
            Parameters = new Dictionary<string, object>();
            MatchCollection braceMatches = braceRegex.Matches(queryExpression);
            int i = 0;
            foreach (Match match in braceMatches)
            {
                i++;
                string parameterName = string.Format(DataParameter, i);
                string parameterValue = match.Groups[1].Value;
                string paramName = ParameterPrefix + parameterName;
                stringBuilder.Replace(match.Value, paramName);
                if (queryString.Keys.Contains(parameterValue, StringComparer.InvariantCultureIgnoreCase))
                {
                    var value = queryString[parameterValue];
                    Parameters.Add(parameterName, value);
                }
                else
                {
                    throw new ParameterNotFoundException(parameterValue);
                }

            }

            this.QueryExpression = stringBuilder.ToString();
        }
        /// <summary>
        /// Gets the property values.
        /// </summary>
        /// <param name="control">The control.</param>
        /// <param name="nameValues">The name values.</param>
        /// <param name="queryExpression">The query expression.</param>
        /// <returns></returns>
        public static void CombinePropertyValues(object control, NameValueCollection nameValues, string queryExpression)
        {
            var type = control.GetType();
            MatchCollection matches = braceRegex.Matches(queryExpression);
            foreach (Match match in matches)
            {
                string key = match.Groups[1].Value;
                if (!nameValues.AllKeys.Contains(key, StringComparer.InvariantCultureIgnoreCase))
                {

                    var value = type.GetPropertyValue(key, control);

                    nameValues[key] = value == null ? "" : value.ToString();
                }

            }
        }
        /// <summary>
        /// Gets the parameter prefix.
        /// </summary>
        /// <value>The parameter prefix.</value>
        protected abstract string ParameterPrefix { get; }
    }
}