GoogleMapsConfigManager.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using sage.ew.interficies;
using System.Xml.Linq;
using System.Data;
using System.Drawing;
using sage.ew.db;
using sage.ew.listados.Clases;
using System.Drawing.Design;
using System.Windows.Forms.Design;
using System.Windows.Forms;
using sage.ew.formul.Forms;
using System.Reflection;
using sage.ew.global;
using sage.ew.functions;
using System.Globalization;

namespace sage.ew.formul.Clases
{
    public class GoogleMapsConfigManager
    {

        private Dictionary<String, GoogleMapsConfig> _oListConfig = new Dictionary<String, GoogleMapsConfig>();

        public GoogleMapsConfig _AddConfig(ColumnDefinition toColCP, ColumnDefinition toColPoblacion)
        {
            GoogleMapsConfig loConfig;
            String lcCodigo = toColCP._GetCodigoParent();

            if (_oListConfig.ContainsKey(lcCodigo))
            {
                loConfig = _oListConfig[lcCodigo];
            }
            else
            {
                loConfig = new GoogleMapsConfig(toColCP, toColPoblacion);
                _oListConfig.Add(lcCodigo, loConfig);
            }

            return loConfig;
        }
             
        public void _Load(Dictionary<string, ColumnDefinition> toListColumns)
        {

            _oListConfig.Clear();

            var loGroups = toListColumns.Values.Where(f=>f._TipoCampo == GoogleMapsConfig.TipoCampo.CodigoPostal).GroupBy(d => d._GoogleMapsConfig._Codigo);

            foreach(var loGroup in loGroups)
            {
                String lcKey = loGroup.Key;

                if (!String.IsNullOrEmpty(loGroup.Key))
                {
                    String lcKeyCP = loGroup.Key.Substring(0, lcKey.IndexOf("@@"));
                    String lcKeyPoblacion = loGroup.Key.Substring(lcKey.IndexOf("@@") + 2);

                    ColumnDefinition loColCp = toListColumns[lcKeyCP];
                    ColumnDefinition loColPoblacion;

                    if (loColCp._GoogleMapsConfig._ColumnPoblacion is ColumnDefinition)
                    {
                        loColPoblacion = loColCp._GoogleMapsConfig._ColumnPoblacion;
                    }
                    else if (!String.IsNullOrEmpty(loColCp._GoogleMapsConfig._Codigo) && toListColumns.ContainsKey(loColCp._GoogleMapsConfig._Codigo.Substring(loColCp._GoogleMapsConfig._Codigo.IndexOf("@@") + 2)))
                    {
                        loColPoblacion = toListColumns[loColCp._GoogleMapsConfig._Codigo.Substring(loColCp._GoogleMapsConfig._Codigo.IndexOf("@@") + 2)];
                    }
                    else if (!String.IsNullOrEmpty(loColCp._GoogleMapsConfig._Codigo))
                    {
                        loColPoblacion = toListColumns.Values.Where(f => f._TipoCampo == GoogleMapsConfig.TipoCampo.Poblacion && f._GoogleMapsConfig._Codigo.StartsWith(loColCp._Codigo)).First();
                    }
                    else
                    {
                        loColPoblacion = toListColumns.Values.Where(f => f._TipoCampo == GoogleMapsConfig.TipoCampo.Poblacion).First();
                    }

                    if (loColPoblacion is ColumnDefinition)
                    {
                        GoogleMapsConfig loConfig = _AddConfig(loColCp, loColPoblacion);

                        List<ColumnDefinition> loConfigColumns = (from loCol in toListColumns.Values
                                                                  where loCol._GoogleMapsConfig._Codigo == loConfig._Codigo
                                                                  select loCol).ToList();
                        if (loConfigColumns.Count > 0)
                        {
                            loConfig._Columns.Clear();
                            foreach (ColumnDefinition loCol in loConfigColumns)
                            {
                                loConfig._Activo = loCol._GoogleMapsConfig._Activo;
                                foreach (KeyValuePair<String, GoogleMapsConfig.GoogleMapsConfigColums> loKeyPairValue in loCol._GoogleMapsConfig._Columns)
                                {
                                    GoogleMapsConfig.GoogleMapsConfigColums loGoogleMapsConfigColums = loKeyPairValue.Value;

                                    if ((loGoogleMapsConfigColums._Codigo == "contador" || toListColumns.ContainsKey(loGoogleMapsConfigColums._Codigo)) && toListColumns.ContainsKey(loGoogleMapsConfigColums._CodigoCP) && toListColumns.ContainsKey(loGoogleMapsConfigColums._CodigoPoblacion))
                                    {
                                        if (!loConfig._Columns.ContainsKey(loGoogleMapsConfigColums._Codigo)) loConfig._Columns.Add(loGoogleMapsConfigColums._Codigo, loGoogleMapsConfigColums);
                                    }
                                }
                                loCol._GoogleMapsConfig = loConfig;
                            }
                        }
                        else
                        {
                            loColCp._GoogleMapsConfig = loConfig;
                            loColPoblacion._GoogleMapsConfig = loConfig;
                        }

                        if (toListColumns.ContainsKey(loColCp._GetCodigoParent()))
                        {
                            ColumnDefinition loParent = toListColumns[loColCp._GetCodigoParent()];
                            if (loParent._TipoCampo == GoogleMapsConfig.TipoCampo.CodigoPostal) loParent._GoogleMapsConfig = loConfig;
                        }

                        //Buscamos campo población por si se ha seleccionada el del registro y el del CP
                        List<ColumnDefinition> loColumPoblacion = toListColumns.Values.Where(f => f._TipoCampo == GoogleMapsConfig.TipoCampo.Poblacion && f._GetCodigoParent() == loColCp._GetCodigoParent()).ToList();

                        if (loColumPoblacion.Count > 0)
                        {
                            ColumnDefinition loCol = loColumPoblacion.First();
                            loConfig._ColumnPoblacionRel = loCol;
                            loCol._GoogleMapsConfig = loConfig;
                        }
                    }
                }
            }              
        }

        public void _RemoveColumn(ColumnDefinition toColumn)
        {
            foreach(GoogleMapsConfig loConfig in _oListConfig.Values)
            {
                if(loConfig._Columns.ContainsKey(toColumn._Codigo)) loConfig._Columns.Remove(toColumn._Codigo);
            }
        }

        public void _SetColumn(ColumnDefinition toColumn)
        {
            if (toColumn is ColumnDefinition && toColumn._IsNumeric)
            {
                foreach (GoogleMapsConfig loConfig in _oListConfig.Values)
                {
                    if (!loConfig._Columns.ContainsKey(toColumn._Codigo))
                    {
                        GoogleMapsConfig.GoogleMapsConfigColums loGoogleMapsConfigColums = new GoogleMapsConfig.GoogleMapsConfigColums(true, toColumn._Titulo);
                        loGoogleMapsConfigColums._ColumnDefinition = toColumn;
                        loGoogleMapsConfigColums._CodigoCP = loConfig._ColumnCP._Codigo;
                        loGoogleMapsConfigColums._CodigoPoblacion = loConfig._ColumnPoblacion._Codigo;

                        loConfig._Columns.Add(toColumn._Codigo, loGoogleMapsConfigColums);
                    }
                }
            }
        }

        public GoogleMapsConfigManager()
        {

        }
    }

    public class GoogleMapsConfig
    {
        public enum TipoCampo
        {
            NoPermite = 0,
            CodigoPostal = 1,
            Poblacion = 2
        }
        private String _cCodigo;
        private String _cErrorMessage;
        private Boolean _bGoogleMaps = false;
        private Dictionary<String, GoogleMapsConfigColums> _oColumns = new Dictionary<String, GoogleMapsConfigColums>();
        private ColumnDefinition _oColumnCP;
        private ColumnDefinition _oColumnPoblacion;
        private ColumnDefinition _oColumnPoblacionRel;

        public Boolean _IsConfigured
        {
            get
            {
                return _oColumnCP is ColumnDefinition && _oColumnPoblacion is ColumnDefinition;
            }
        }

        public ColumnDefinition _ColumnCP
        {
            get
            {
                return _oColumnCP;
            }
            set
            {
                 _oColumnCP = value;
            }
        }

        public ColumnDefinition _ColumnPoblacion
        {
            get
            {
                return _oColumnPoblacion;
            }
            set
            {
                _oColumnPoblacion = value;
            }
        }

        public ColumnDefinition _ColumnPoblacionRel
        {
            get
            {
                return _oColumnPoblacionRel;
            }
            set
            {
                _oColumnPoblacionRel = value;
            }
        }
        public String _Codigo
        {
            get
            {
                if (_ColumnCP is ColumnDefinition && _ColumnPoblacion is ColumnDefinition)
                {
                    _cCodigo = String.Format("{0}@@{1}", _ColumnCP._Codigo, _ColumnPoblacion._Codigo);
                }
                return _cCodigo;
            }           
        }

        public Boolean _Activo
        {
            get
            {
                return _bGoogleMaps;
            }
            set
            {
                _bGoogleMaps = value;
            }
        }

        public Dictionary<String, GoogleMapsConfigColums> _Columns
        {
            get
            {
                return _oColumns;
            }
            set
            {
                _oColumns = value;

                if (_IsConfigured)
                {
                    foreach (GoogleMapsConfigColums loCol in _oColumns.Values)
                    {
                        loCol._CodigoCP = _oColumnCP._Codigo;
                        loCol._CodigoPoblacion = _oColumnPoblacion._Codigo;
                    }
                }
            }
        }

        public class GoogleMapsConfigColums
        {
            private Boolean _bActivo = false;
            private String _cTitulo = "";
            private String _cCodigo = "contador";
            private String _cCodigoCP = "";
            private String _cCodigoPoblacion = "";
            private String _cCampo = "";
            private ColumnDefinition _oColDefinition;

            public String _Codigo
            {
                get
                {
                    return _cCodigo;
                }
            }

            public String _Campo
            {
                get
                {
                    return _cCampo;
                }
            }

            public String _CodigoCP
            {
                get
                {
                    return _cCodigoCP;
                }
                internal set
                {
                    _cCodigoCP = value;
                }
            }

            public String _CodigoPoblacion
            {
                get
                {
                    return _cCodigoPoblacion;
                }     
                internal set
                {
                    _cCodigoPoblacion = value;
                }

            }           

            public ColumnDefinition _ColumnDefinition
            {
                get
                {
                    return _oColDefinition;
                }
                set
                {
                    _oColDefinition = value;
                    if (value is ColumnDefinition)
                    {
                        _cCodigo = _oColDefinition._Codigo;
                        _cCampo = _oColDefinition._Titulo;
                        if (String.IsNullOrEmpty(_cTitulo)) _cTitulo = _oColDefinition._Titulo;
                    }
                }
            }


            public Boolean _Activo
            {
                get
                {
                    return _bActivo;
                }
                set
                {
                    _bActivo = value;
                }
            }

           
            public String _Titulo
            {
                get
                {
                    return _cTitulo;
                }
                set
                {
                    _cTitulo = value;
                }
            }

            public XElement _ToXElement()
            {
                XElement loElement;
                List<XElement> loList = new List<XElement>();
                List<XElement> loPath = new List<XElement>();

                loList.Add(new XElement("Codigo", _Codigo));
                loList.Add(new XElement("Activo", _Activo ? Boolean.TrueString : Boolean.FalseString));
                loList.Add(new XElement("Titulo", _Titulo));
                loList.Add(new XElement("CodigoCP", _cCodigoCP));
                loList.Add(new XElement("CodigoPoblacion", _cCodigoPoblacion));
                loList.Add(new XElement("Campo", _cCampo));

                loElement = new XElement("GoogleMapsColumn", loList.ToArray());


                return loElement;
            }

            public GoogleMapsConfigColums(Boolean tlActivo, String tcTitulo)
            {
                _cTitulo = String.Format("Distribución por {0}", tcTitulo.ToLower());
                _bActivo = tlActivo;
            }

            public GoogleMapsConfigColums(Boolean tlActivo)
            {
                _bActivo = tlActivo;
            }

            public GoogleMapsConfigColums(XElement toElement)
            {
                _bActivo = Convert.ToBoolean(toElement.Element("Activo").Value);
                _cTitulo = Convert.ToString(toElement.Element("Titulo").Value);
                _cCodigo = Convert.ToString(toElement.Element("Codigo").Value);
                _cCodigoCP = Convert.ToString(toElement.Element("CodigoCP").Value);
                _cCampo = Convert.ToString(toElement.Element("Campo").Value);
                _cCodigoPoblacion = Convert.ToString(toElement.Element("CodigoPoblacion").Value);
            }
        }


        public XElement _ToXElement()
        {
            XElement loElement;
            List<XElement> loList = new List<XElement>();

            loList.Add(new XElement("Activo", _bGoogleMaps ? Boolean.TrueString : Boolean.FalseString));
            loList.Add(new XElement("Codigo", _Codigo));

            foreach (GoogleMapsConfigColums loColum in _Columns.Values)
            {
                loList.Add(loColum._ToXElement());
            }

            loElement = new XElement("GoogleMapsConfig", loList.ToArray());

            return loElement;
        }

        public List<GoogleMapsConfigColums> _ActiveColumns
        {
            get
            {
                List<GoogleMapsConfigColums> loList = (from loCol in _Columns.Values
                                                       where loCol._Activo
                                                       select loCol).ToList();
                return loList;
            }
        }

        public string _ErrorMessage
        {
            get
            {
                return _cErrorMessage;
            }
            set
            {
                _cErrorMessage = value;
            }
        }

        public bool _IsValid()
        {
            _ErrorMessage = "";

            if (_ActiveColumns.Count() == 0)
            {
                _ErrorMessage = "Debe seleccionar al menos una columna";
            }
            else if(_ActiveColumns.Where(f => String.IsNullOrEmpty(f._Titulo) || String.IsNullOrWhiteSpace(f._Titulo) ).Count() > 0)
            {
                _ErrorMessage = "Debe especificar el título";
            }
            
            return String.IsNullOrEmpty(_ErrorMessage);
        }

        public GoogleMapsConfig()
        {
        }

        public GoogleMapsConfig(ColumnDefinition toCp, ColumnDefinition toPoblacion)
        {
            _oColumnCP = toCp;
            _oColumnPoblacion = toPoblacion;

            GoogleMapsConfig.GoogleMapsConfigColums loColumConfig = new GoogleMapsConfig.GoogleMapsConfigColums(true, "localización");

            loColumConfig._CodigoCP = _oColumnCP._Codigo;
            loColumConfig._CodigoPoblacion = _oColumnPoblacion._Codigo;

            _oColumns.Add("contador", loColumConfig);
        }

        public GoogleMapsConfig(Boolean tlActivo)
        {
            _bGoogleMaps = tlActivo;
        }

        public GoogleMapsConfig(XElement toElement)
        {
            _bGoogleMaps = Convert.ToBoolean(toElement.Element("Activo").Value);
            _cCodigo = toElement.Element("Codigo").Value;

            foreach (XElement loElement in toElement.Elements("GoogleMapsColumn"))
            {
                GoogleMapsConfigColums loConfig = new GoogleMapsConfigColums(loElement);
                
                _oColumns.Add(loConfig._Codigo, loConfig);
            }
        }
    }

}