source: branches/WebApplication/MVC2/HLWebOKBQueryPlugin/ViewModels/FilterModel.cs @ 6170

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using HLWebOKBQueryPlugin.OKBQueryService;
using HLWebOKBQueryPlugin.Helpers;

namespace HLWebOKBQueryPlugin.Models
{
    /// <summary>
    /// Model for Filter Data.
    /// Current Filters (selected),
    /// and available Filters. 
    /// </summary>
    public class FilterModel
    {

        public static string ComboboxName { get { return "filtersCombobox"; } }
        public static string ParentIdName { get { return "parentId"; } }
        public static string ValueTextbox { get { return "valueTextbox"; } }
        public static string ValueDropDownList { get { return "valueDropDownList"; } }


        /// <summary>
        /// Constructor
        /// </summary>
        public FilterModel()
        {

        }

        public FilterModel(CombinedFilter filter)
        {
            Content = filter;
        }

        /// <summary>
        /// Get Bool States.
        /// </summary>
        public List<Boolean> BoolStates
        {
            get
            {
                List<Boolean> boolStates = new List<Boolean>();

                boolStates = new List<Boolean>();
                boolStates.Add(true);
                boolStates.Add(false);

                return boolStates;
            }
        }


        /// <summary>
        /// Available Filters
        /// </summary>
        public List<Filter> AvailableFilters
        {
            get
            {
                QueryServiceClient client = Query.GetClientFactory("okbtester", "okbtester");
                return client.GetFilters().ToList<Filter>();
            }
        }


        /// <summary>
        /// Available Filters without AND and OR.
        /// </summary>
        public List<Filter> AvailableFilterForCombobox
        {
            get
            {
                List<Filter> filters = AvailableFilters;

                filters.Remove(filters.OfType<CombinedFilter>().Where(x => x.Operation == BooleanOperation.Or).FirstOrDefault());
                filters.Remove(filters.OfType<CombinedFilter>().Where(x => x.Operation == BooleanOperation.And).FirstOrDefault());

                return filters;
            }
        }

        /// <summary>
        /// Content
        /// </summary>
        public CombinedFilter Content { get; set; }

      

        /// <summary>
        /// Delete a filter with given id.
        /// </summary>
        /// <param name="id">filter id</param>
        internal bool RemoveFilter(Guid id)
        {
            bool removed = false;
            List<Filter> orFilters = Content.Filters.ToList<Filter>();

            foreach (CombinedFilter f in orFilters)
            {
                Filter deleteFilter = f.Filters.Where(x => x.Id == id).FirstOrDefault();
                if (deleteFilter != null)
                {
                    List<Filter> masterFilters = f.Filters.ToList<Filter>();
                    masterFilters.Remove(deleteFilter);
                    f.Filters = masterFilters.ToArray<Filter>();
                    removed = true;
                    break;
                }
            }

            Content.Filters = orFilters.ToArray<Filter>();
            return removed;
        }

        /// <summary>
        /// Add a new filters
        /// </summary>
        /// <param name="filterTypeName">type name</param>
        /// <param name="parentId">parent filter id</param>
        internal void AddFilter(string filterTypeName, Guid parentId)
        {

            // get selected filter (combobox)
            Filter filter = AvailableFilters.Where(x => x.FilterTypeName.Equals(filterTypeName)).FirstOrDefault();


            // find the partent filterr
            List<Filter> orFilters = Content.Filters.ToList<Filter>(); ;
            CombinedFilter parentFilter = (CombinedFilter)orFilters.Where(e => e.Id.Equals(parentId)).FirstOrDefault();

            // remove
            orFilters.Remove(parentFilter);

            List<Filter> filterList = parentFilter.Filters.ToList<Filter>();


            // Add the new filter
            filterList.Add(filter);
            //Response.Write("addx:" + filter.Id);

            parentFilter.Filters = filterList.ToArray<Filter>();

            // Add the current filter (AND)
            orFilters.Add(parentFilter);

            Content.Filters = orFilters.ToArray<Filter>();
        }

        /// <summary>
        /// Update existing filters with posted value
        /// </summary>
        /// <param name="parentId">parent filter id</param>
        /// <param name="postValues">dictionary with posted values</param>
        internal void UpdateWithPostValues(Dictionary<Guid, Dictionary<string, string>> postValues)
        {
            // Set values for the existing Filters
            foreach (CombinedFilter cf in Content.Filters)
            {
                foreach (Filter f in cf.Filters)
                {

                    Dictionary<string, string> dict = postValues.Where(x => x.Key.Equals(f.Id)).FirstOrDefault().Value;
                    if (dict != null)
                    {
                        foreach (KeyValuePair<string, string> kvp in dict)
                        {
                            if ("StringComparisonFilter".Equals(f.GetType().Name))
                            {
                                if (kvp.Key.Equals(FilterModel.ValueTextbox))
                                {
                                    ((StringComparisonFilter)f).Value = kvp.Value;
                                }
                                // To this for alle keys

                            }
                            else
                            {
                                // To this for all filters
                            }
                        }
                    }
                }
            }
        }
    }
}