clsAlmacen.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.ComponentModel;

using sage.ew.global;
using sage.ew.db;
using sage.ew.ewbase;
using sage.ew.contabilidad;
using sage.ew.interficies;
using sage.ew.functions;
using System.Windows.Forms;
using sage.ew.global.Diccionarios;
using sage.ew.articulo.DataAccess.Clases;
using sage.ew.objetos;
using sage.ew.txtbox.UserControls;

namespace sage.ew.articulo
{
    public class Almacen : ewMante, IGridPlanesAnaliticos
    {
        #region PROPIEDADES PUBLICAS

        public bool _CentralERP
        {
            get
            {
                if (_lisCampos.ContainsKey("CENTRALERP"))
                    return Convert.ToBoolean(_lisCampos["CENTRALERP"]._NewVal);
                else
                    return false;
            }
            set
            {
                if (_lisCampos.ContainsKey("CENTRALERP"))
                {
                    _lisCampos["CENTRALERP"]._NewVal = value;

                    _Exportar_Null();
                }
            }
        }

        public string _Cliente
        {
            get
            {
                if (_lisCampos.ContainsKey("CLIENTE"))
                {
                    return _lisCampos["CLIENTE"]._NewVal.ToString();
                }
                else
                {
                    return String.Empty;
                }
            }
            set
            {
                if (_lisCampos.ContainsKey("CLIENTE"))
                {
                    _lisCampos["CLIENTE"]._NewVal = value;
                }
            }
        }

        public string _CuentaSecundaria
        {
            get { return Convert.ToString(_Campo("SECUN")); }
            set { this._Campo("SECUN", value); }
        }

        public AlmacenPlanes _AlmacenPlanes
        {
            get
            {
                if (_oAlmacenPlanes == null)
                {
                    _oAlmacenPlanes = new AlmacenPlanes(_Codigo);

                    _AddManteTRel(_oAlmacenPlanes);

                    _oAlmacenPlanes._Load();
                }
                return _oAlmacenPlanes;
            }
        }
        private AlmacenPlanes _oAlmacenPlanes;

        #endregion PROPIEDADES PUBLICAS

        #region CONSTRUCTORS

        public Almacen()
        {
            // Asignamos las propiedades para Almacenes
            this._Clave = "Codigo";
            this._DataBase = "Gestion";
            this._Tabla = "Almacen";
            this._Pantalla = "ALMACEN"; //Para determinar si es de solo lectura
            this._TituloMantenimiento = "Mantenimiento de almacenes";

            this._FormManteBaseType = typeof(Forms.frmAlmacen);            
        }

        public Almacen(string tcCodigo)
        {
            // Asignamos las propiedades para Almacenes
            this._Clave = "Codigo";
            this._DataBase = "Gestion";
            this._Tabla = "Almacen";
            this._Pantalla = "ALMACEN"; //Para determinar si es de solo lectura
            this._TituloMantenimiento = "Mantenimiento de almacenes";

            this._FormManteBaseType = typeof(Forms.frmAlmacen);            

            this._Codigo = tcCodigo;
            this._Load();
        }

         #endregion CONSTRUCTORS        


        #region METODOS PUBLICOS

        public override bool _Delete()
        {
            bool llOk = true;
            List<string> loList = new List<string>();

            // Taules de GESTION
            loList.Clear();
            loList.Add("STOCKS");
            loList.Add("STOCKINI");
            loList.Add("REGULARI");
            loList.Add("C_PEDIVE");
            loList.Add("C_ALBVEN");
            loList.Add("C_ALBDEP");
            loList.Add("D_ALBVEN");
            loList.Add("C_ALBARE");
            loList.Add("C_ALBCOM");
            loList.Add("C_PEDICO");
            loList.Add("D_ALBCOM");
            loList.Add("EMPRESA");
            loList.Add("C_TRANS");
            loList.Add("D_TRANS");
            loList.Add("C_PROD");
            loList.Add("D_PROD");
  
            llOk = llOk && !_Existen_Registros("GESTION", loList, "ALMACEN");


            // Taules de COMUNES
            loList.Clear();
            loList.Add("COMPRAS");
            loList.Add("MODELO");
            loList.Add("MOVSERIE");
            loList.Add("RECOMPRAS");

            llOk = llOk && !_Existen_Registros("COMUNES", loList, "ALMACEN");


            if (llOk)
            {
                // Cargar el mantetrel para borrar los datos relacionados correctamente (desde negocio o listas previas)
                AlmacenPlanes loAlm = _AlmacenPlanes;

                UltimoCosteDto oUltimoCoste = new UltimoCosteDto
                {
                    _Almacen = _Codigo,
                };
                UltimosCostesDA loUltCos = new UltimosCostesDA();
                loUltCos.EliminarUltimoCoste(oUltimoCoste, true);
    
                return base._Delete();
            }
            else
                this._Error_Message = "Este código de almacén está siendo utilizado por el programa. No se puede borrar el código de almacén.";

            return llOk;
        }

        public override void _Evento_ShowGrafica_before(object sender, ref formul.Forms.FormListado toForm, ref bool tlOk)
        {
            ((txtbox.UserControls.txtAlmacenDesdeHasta)toForm._Filtros["txtAlmacenDesdeHasta"])._SetValorUnico(this._Codigo);
        }

        public override void _Load()
        {
            base._Load();

            if (_oAlmacenPlanes != null && Convert.ToString(_oAlmacenPlanes._Claves._Almacen._Valor) != this._Codigo)
            {
                if (_oAlmacenPlanes._Grid != null)
                {
                    _oAlmacenPlanes._Claves._Almacen._Valor = this._Codigo;
                    _oAlmacenPlanes._Load();
                }
                else
                {
                    _oAlmacenPlanes = null;
                }
            }
        }


        public override bool _Save()
        {
            bool lbOk;

            // Si s'han inclós secundarias, activo el camp
            if (_AlmacenPlanes._Items.Count > 0)
            {

                if (Convert.ToBoolean(global.EW_GLOBAL._GetVariable("wl_distsec")))
                {
                    // Comprovar el total de porcentaje   
                    string lcPlan; 
                    if (!_AlmacenPlanes._TotalPorcentajes(out lcPlan))
                    {
                        _Error_Message = "La suma del porcentaje del plan analítico " + lcPlan + " debe ser 100.";
                        return false;
                    }
                }
            }
                
            lbOk = base._Save();

            return lbOk;
        }

        public bool _Existen_Duplicados_Secundarias()
        {
            if (this._AlmacenPlanes != null)
            {
                DataTable ldtItems = this._AlmacenPlanes._ToDataTable();

                var duplicates = ldtItems.AsEnumerable().GroupBy(i => new { Secnivel1 = i.Field<string>("_Secundaria").Trim(), Secnivel2 = i.Field<string>("_Secnivel2").Trim(), Plancont = i.Field<string>("_Plancont").Trim() }).Where(g => g.Count() > 1).Select(g => new { g.Key.Secnivel1, g.Key.Secnivel2, g.Key.Plancont }).ToList();

                if (duplicates.Count > 0)
                    return true;
                else
                    return false;
            }
            else
                return false;

        }

        public bool _Existen_Vacios_Secundarias()
        {
            if (this._AlmacenPlanes != null)
            {
                DataTable ldtItems = this._AlmacenPlanes._ToDataTable();
                DataRow[] result = ldtItems.Select("_Secundaria = '' AND _Secnivel2 = '' AND _Plancont <> ''");
                if (result.Length > 0)
                    return true;
                else
                    return false;
            }
            else
                return false;
        }

        public bool _Existen_Duplicados_Nivel1_Nivel2_Vacio(string tcNivel1, string tcPlan)
        {
            if (this._AlmacenPlanes != null)
            {                
                var registros = this._AlmacenPlanes._Items.Where(x => x._Secundaria.Trim() == tcNivel1.Trim() && x._Plancont == tcPlan);

                var nivel2vacio = registros.Where(x => string.IsNullOrWhiteSpace(x._Secnivel2)).Count();
                var nivel2lleno = registros.Where(x => !string.IsNullOrWhiteSpace(x._Secnivel2)).Count();

                if (nivel2vacio > 0 && nivel2lleno > 0)
                    return true;
                else
                    return false;
            }
            else
                return false;
        }

        public bool ImportarPlanAnalitico(string tcPlan)
        {
            //Sino hay datos 
            if (String.IsNullOrEmpty(tcPlan))
            {
                _Error_Message = "El plan analítico orígen no puede estar en blanco.";
                return false;
            }

            PlanContable loPlan = new PlanContable(tcPlan);
            loPlan._Load();
            if (loPlan._Existe_Registro())
            {
                //recuperamos las cuentas del plan
                var ctasPlanOrigen = loPlan._SecundariasPlan._Items.Where(loEle => loEle._PlanContable == tcPlan).ToList();

                if (!ctasPlanOrigen.Any())
                {
                    _Error_Message = "No hay datos que copiar para este plan analítico.";
                    return false;
                }

                //Po cada cuenta recuperada secundaria
                foreach (sage.ew.contabilidad.PlanContable.SecundariasPlan.SecundariaPlan loSecundaria in ctasPlanOrigen)
                {
                    //Determino si ya forma parte el plan y sus cuentas secundaria 1 y 2 de la cuenta contable destino
                    if (!_AlmacenPlanes._Items.Where(loEle => loEle._Plancont == loSecundaria._PlanContable &&
                        loEle._Secundaria == loSecundaria._Secundaria1 &&
                        loEle._Secnivel2 == loSecundaria._Secundaria2).Any())
                    {
                        //Sino forma parte, añado la nueva cuenta
                        AlmacenPlanes.AlmacenPlan loNewSecundaria = _AlmacenPlanes._NewItem();
                        loNewSecundaria._Plancont = loSecundaria._PlanContable;
                        loNewSecundaria._Secundaria = loSecundaria._Secundaria1;
                        loNewSecundaria._Secnivel2 = loSecundaria._Secundaria2;

                        loNewSecundaria._CodAnalit = ((string.IsNullOrEmpty(loSecundaria._Secundaria2)) ? (loSecundaria._Secundaria1) : (loSecundaria._Secundaria1.ToString().Trim() + "." + loSecundaria._Secundaria2));
                        loNewSecundaria._NomAnalit = FUNCTIONS._AnalitNombre(loSecundaria._Secundaria1 + "." + loSecundaria._Secundaria2);
                    }
                    else
                    {
                        //Si pasa por aquí es que ya existe esa combinación de plancontable, nivel1 y nivel2
                    }
                }

                // Repartir el porcentaje
                if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_repasi")) || Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_distsec")))
                    this._AlmacenPlanes._RepartirPorcentaje(tcPlan);
            }
            else
            {
                _Error_Message = "El plan analítico orígen no existe.";
                return false;
            }

            return true;
        }

        public List<string> _Lista_Planes()
        {
            List<string> loListaPlanes = new List<string>();

            // Construyo una lista de todos los planes analíticos detectados en la cuenta contable.
            var consultaplanes = from nivelesplanes in this._AlmacenPlanes._Items.AsEnumerable()
                                 where !string.IsNullOrWhiteSpace(nivelesplanes._Plancont) && !string.IsNullOrWhiteSpace(nivelesplanes._Secundaria)
                                 group nivelesplanes by nivelesplanes._Plancont
                                 into n
                                 select n.Key;

            loListaPlanes = consultaplanes.ToList();

            return loListaPlanes;
        }


        public DataTable _DtPlanes()
        {
            DataTable ldtPlanes = new DataTable();
            ldtPlanes.Columns.Add("codigo", typeof(string));
            ldtPlanes.Columns.Add("nombre", typeof(string));

            // Construyo una lista de todos los planes analíticos detectados en la cuenta contable.
            var consulta = (from nivelesplanes in this._AlmacenPlanes._Items.AsEnumerable()
                            where !string.IsNullOrWhiteSpace(nivelesplanes._Plancont)
                            group nivelesplanes by
                            new
                            {
                                codigo = nivelesplanes._Plancont,
                                nombre = nivelesplanes._NombrePlan
                            }
                                into g
                                select new
                                {
                                    codigo = g.Key.codigo,
                                    nombre = g.Key.nombre
                                }).OrderBy(c => c.codigo);

            foreach (var reg in consulta)
            {
                DataRow loRow = ldtPlanes.NewRow();
                loRow["codigo"] = reg.codigo;
                loRow["nombre"] = reg.nombre;
                ldtPlanes.Rows.Add(loRow);
            }

            return ldtPlanes;
        }

        public DataTable _DtNiveles1Plan(string tcPlan)
        {
            DataTable ldtNiveles1Plan = new DataTable();
            ldtNiveles1Plan.Columns.Add("codigo", typeof(string));
            ldtNiveles1Plan.Columns.Add("nombre", typeof(string));

            // Construyo una lista de todos los planes analíticos detectados en la cuenta contable.
            var consulta = (from nivelesplanes in this._AlmacenPlanes._Items.AsEnumerable()
                            where nivelesplanes._Plancont == tcPlan && !string.IsNullOrWhiteSpace(nivelesplanes._Secundaria)
                            group nivelesplanes by
                            new
                            {
                                codigo = nivelesplanes._Secundaria,
                                nombre = nivelesplanes._Nombre
                            }
                                into g
                                select new
                                {
                                    codigo = g.Key.codigo,
                                    nombre = g.Key.nombre
                                }).OrderBy(c => c.codigo);

            foreach (var reg in consulta)
            {
                DataRow loRow = ldtNiveles1Plan.NewRow();
                loRow["codigo"] = reg.codigo;
                loRow["nombre"] = reg.nombre;
                ldtNiveles1Plan.Rows.Add(loRow);
            }

            return ldtNiveles1Plan;
        }

        public DataTable _DtNiveles2Plan(string tcPlan, string tcCuentaNiv1 = "")
        {
            DataTable ldtNiveles2Plan = new DataTable();
            ldtNiveles2Plan.Columns.Add("codigo", typeof(string));
            ldtNiveles2Plan.Columns.Add("nombre", typeof(string));

            // Construyo una lista de todos las cuentas de nivel 2 detectados en la cuenta-plan
            var consulta = (from nivelesplanes in this._AlmacenPlanes._Items.AsEnumerable()
                            where nivelesplanes._Plancont == tcPlan && !string.IsNullOrWhiteSpace(nivelesplanes._Secundaria)
                            && !string.IsNullOrWhiteSpace(nivelesplanes._Secnivel2)
                            && (!string.IsNullOrWhiteSpace(tcCuentaNiv1) ? nivelesplanes._Secundaria == tcCuentaNiv1 : true)
                            group nivelesplanes by
                            new
                            {
                                codigo = nivelesplanes._Secnivel2,
                                nombre = nivelesplanes._Nombre2
                            }
                                into g
                                select new
                                {
                                    codigo = g.Key.codigo,
                                    nombre = g.Key.nombre
                                }).OrderBy(c => c.codigo);

            foreach (var reg in consulta)
            {
                DataRow loRow = ldtNiveles2Plan.NewRow();
                loRow["codigo"] = reg.codigo;
                loRow["nombre"] = reg.nombre;
                ldtNiveles2Plan.Rows.Add(loRow);
            }

            return ldtNiveles2Plan;
        }

        #endregion METODOS PUBLICOS

        public static Dictionary<string,string> ObtenerTodosLosAlmacenes()
        {
            Dictionary<string, string> diccAlmacenes = new Dictionary<string, string>();
            DataTable dtAlmacenes = new DataTable();

            string lcSql = $"SELECT CODIGO, NOMBRE FROM {DB.SQLDatabase("GESTION","ALMACEN")} ORDER BY CODIGO ASC ";
            if(DB.SQLExec(lcSql, ref dtAlmacenes) && dtAlmacenes.Rows.Count > 0)
            {
                foreach (DataRow row in dtAlmacenes.Rows)
                {
                    diccAlmacenes.Add(Convert.ToString(row["CODIGO"]).TrimEnd(), Convert.ToString(row["NOMBRE"]).TrimEnd());
                }
            }
            return diccAlmacenes;
        }

        public class AlmacenPlanes : ewManteTRel<AlmacenPlanes.AlmacenPlan, AlmacenPlanes.Clave>
        {
            ewMascara _oMascaraTPC = new ewMascara(EW_GLOBAL._GetMascara(KeyDiccionarioMascara.wc_tpc));

            string _cEmpresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));



            public AlmacenPlanes()
            {
                CrearEstructura();
            }

            public AlmacenPlanes(string tcCodigoArticulo)
            {
                CrearEstructura();

                this._Claves._Almacen._Valor = tcCodigoArticulo;
            }

            private void CrearEstructura()
            {
                // Definir la base
                _DataBase = "Gestion";
                _Tabla = "Alma_anali";
                _Condicion = "";

                bool lbImputarpor = (EW_GLOBAL._Empresa._ImputarPor == 0 ? true : false);

                //PE-97774
                ewCampoTRel.Editable loEditable = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_hera")) ? ewCampoTRel.Editable.No : ewCampoTRel.Editable.Si;

                // Omplim els camps i relació de propietats
                _AddCampoTRel("_Almacen", "Almacen", ewCampoTRel.Visible.No, ewCampoTRel.Updatable.Si, ewCampoTRel.Editable.No);


                ewCampoTRel _Def_PlanCont = _AddCampoTRel("_Plancont", "Plancont", ewCampoTRel.Visible.Si, ewCampoTRel.Updatable.Si, ewCampoTRel.Editable.Si, "Plan");
                {
                    // Validacions
                    _Def_PlanCont._Validar_Dato_BaseDatos = "Gestion";
                    _Def_PlanCont._Validar_Dato_Tabla = "Plans";
                    _Def_PlanCont._Validar_Dato_Clave = "Codigo";
                    _Def_PlanCont._Validar_Dato_Campos = "Nombre";
                    _Def_PlanCont._Validar_Dato_CampoTRel_Asignar = "_NombrePlan";
                    _Def_PlanCont._Error_Validar_Dato = "El plan analítico indicado no existe.";
                    _Def_PlanCont._PermiteDuplicados = true;
                    _Def_PlanCont._Validar_Asignar_Cargando = true;

                    // Configurar el browser
                    _Def_PlanCont._Browser = new sage.ew.botones.btBrowPlanes();

                    // Configurar el manteniment
                    _Def_PlanCont._Mante = new sage.ew.botones.btMantePlanes();

                    // PE-105465. Rellenar con ceros
                    _Def_PlanCont._Relleno = '0';
                }

                _AddCampoTRel("_NombrePlan", "", ewCampoTRel.Visible.Si, ewCampoTRel.Updatable.No, ewCampoTRel.Editable.No, "Nombre");

                // Codigo de la secundaria
                ewCampoTRel _Def_Columna = _AddCampoTRel("_Secundaria", "Secnivel1", ewCampoTRel.Visible.Si, ewCampoTRel.Updatable.Si, ewCampoTRel.Editable.Si, "C.NA1");
                {
                    // Validacions
                    _Def_Columna._Validar_Dato_BaseDatos = "Gestion";
                    _Def_Columna._Validar_Dato_Tabla = "Secundar";
                    _Def_Columna._Validar_Dato_Clave = "Codigo";
                    _Def_Columna._Validar_Dato_Campos = "Nombre";
                    _Def_Columna._Validar_Dato_CampoTRel_Asignar = "_Nombre";
                    _Def_Columna._Error_Validar_Dato = (lbImputarpor ? "El código" : "El nivel ") + " analítico indicado no existe.";
                    _Def_Columna._PermiteDuplicados = true;
                    _Def_Columna._Validar_Asignar_Cargando = true;

                    // Configurar el browser
                    _Def_Columna._Browser = new sage.ew.botones.btBrowSecundar
                    {
                        _Condicion = " nivel = 1"
                    };

                    // Configurar el manteniment
                    _Def_Columna._Mante = new sage.ew.botones.btManteSecundar();

                    //Task 148792 => Suprimir relleno de 0's
                    // PE-105465. Rellenar con ceros
                    //_Def_Columna._Relleno = '0';
                }

                // Nombre de la secundaria
                _Def_Columna = _AddCampoTRel("_Nombre", "", ewCampoTRel.Visible.Si, ewCampoTRel.Updatable.No, ewCampoTRel.Editable.No, "Nombre");

                
                bool lbColPorcentajeVisible = Convert.ToBoolean(EW_GLOBAL._GetVariable("Wl_DistSec"));
                bool lbColNivel2Visible = !Convert.ToBoolean(EW_GLOBAL._GetVariable("Wl_Secunico"));

                //Porcentaje nivel1
                _Def_Columna = _AddCampoTRel("_Porcentaje1", "", !lbImputarpor && lbColPorcentajeVisible && lbColNivel2Visible, false, false, "%C.NA1", gridColumnsTypes.Número, new ewMascara("999.99"));
                {
                    _Def_Columna._Mascara._Rango_Min = 0.00M;
                }

                // Codigo de la secundaria de nivel 2
                _Def_Columna = _AddCampoTRel("_Secnivel2", "Secnivel2", lbColNivel2Visible, true, true, "C.NA2");
                {
                    // Validacions
                    _Def_Columna._Validar_Dato_BaseDatos = "Gestion";
                    _Def_Columna._Validar_Dato_Tabla = "Secundar";
                    _Def_Columna._Validar_Dato_Clave = "Codigo";
                    _Def_Columna._Validar_Dato_Campos = "Nombre";
                    _Def_Columna._Validar_Dato_CampoTRel_Asignar = "_Nombre2";
                    _Def_Columna._Error_Validar_Dato = (lbImputarpor ? "El código" : "El nivel ") + " analítico indicado no existe.";
                    _Def_Columna._PermiteDuplicados = true;
                    _Def_Columna._Validar_Asignar_Cargando = true;

                    // Configurar el browser
                    _Def_Columna._Browser = new sage.ew.botones.btBrowSecundar
                    {
                        _Condicion = " nivel = 2"
                    };

                    // Configurar el manteniment
                    _Def_Columna._Mante = new sage.ew.botones.btManteSecundar();

                    //Task 148792 => Suprimir relleno de 0's
                    // PE-105465. Rellenar con ceros
                    //_Def_Columna._Relleno = '0';
                }

                // Nombre de la secundaria
                _Def_Columna = _AddCampoTRel("_Nombre2", "", lbColNivel2Visible, false, false, "Nombre");

                _Def_Columna = _AddCampoTRel("_CodAnalit", "", lbImputarpor, false, true, "Código analítico");
                {
                    // Configurar el browser
                    _Def_Columna._Browser = new sage.ew.botones.btBrowSecundar();
                }

                _Def_Columna = _AddCampoTRel("_NomAnalit", "", lbImputarpor, false, false, "Nombre");

                // Columna de porcentaje                
                _Def_Columna = _AddCampoTRel("_Porcentaje", "Porcentaje", lbColPorcentajeVisible, true, true, (lbImputarpor ? "%Código analítico" : (lbColNivel2Visible ? "%C.NA2" : "%C.NA1")), gridColumnsTypes.Número, new ewMascara("999.99"));
                {
                    _Def_Columna._Mascara._Rango_Min = 0.00M;
                }
            }

            public void _RepartirPorcentaje(string tcPlanCont = "")
            {                
                List<AlmacenPlanes.AlmacenPlan> loListaOrdenada;
                if (string.IsNullOrWhiteSpace(tcPlanCont))  //Bug 113210: Si nos viene el parámetro con el plan, filtramos por dicho plan
                    loListaOrdenada = _Items.OrderBy(x => x._Plancont).ThenBy(n => n._Secundaria).ToList();
                else
                    loListaOrdenada = _Items.Where(y => y._Plancont == tcPlanCont).OrderBy(x => x._Plancont).ThenBy(n => n._Secundaria).ToList();

                //Montamos bucle por el número de planes distintos que hay en el grid para tener un 100% en cada plan
                foreach (var line in loListaOrdenada.GroupBy(info => info._Plancont)
                        .Select(group => new
                        {
                            Plancont = group.Key,
                            Count = group.Count()
                        })
                        .OrderBy(x => x.Plancont))
                {
                    //Lista filtrada sólo por plan
                    List<AlmacenPlanes.AlmacenPlan> loListaFiltrada = _Items.Where(x => x._Plancont == line.Plancont).ToList();

                    //Agrupamos por el nivel1 (_Secundaria) para repartir el % equitativamente para todo el nivel1 (independientemente del nivel2 que tenga cada uno)
                    var agrupacionNivel1 = loListaFiltrada.GroupBy(info => info._Secundaria)
                        .Select(group => new
                        {
                            Nivel1 = group.Key,
                            Count = group.Count()
                        })
                        .OrderBy(x => x.Nivel1);

                    decimal lnDecimal = 100;
                    decimal lnPercent = _oMascaraTPC.Redondeo(lnDecimal / agrupacionNivel1.Count());
                    decimal lnResto = lnDecimal - agrupacionNivel1.Count() * lnPercent;
                    int lnX = 1;
                    foreach (var lineNivel in agrupacionNivel1)
                    {
                        //para cada nivel 1 recorremos sus registros de nivel 2 si tiene más de uno desglosamos de nuevo el tpc equitativamente entre los
                        //registros de nivel2 para cada nivel1, partiendo del % de nivel1 ya calculado                        
                        decimal lnPercentNivel1 = lnPercent;
                        if (lnX == agrupacionNivel1.Count())
                            lnPercentNivel1 = lnPercent + lnResto;                                                    

                        //Lista filtrada por plan y nivel1 (ordenada por nivel2)
                        List<AlmacenPlanes.AlmacenPlan> loListaFiltradaNivel1 = _Items.Where(x => x._Plancont == line.Plancont && x._Secundaria == lineNivel.Nivel1)
                                                                              .OrderBy(x => x._Secnivel2)
                                                                              .ToList();
                        decimal lnPercentNivel2 = _oMascaraTPC.Redondeo(lnPercentNivel1 / lineNivel.Count);
                        decimal lnRestoNivel2 = lnPercentNivel1 - lineNivel.Count * lnPercentNivel2;

                        //Asignación final de porcentaje al registro
                        int lnY = 1;
                        foreach (AlmacenPlanes.AlmacenPlan loSecundaria in loListaFiltradaNivel1)
                        {
                            if (loSecundaria.Fila_Plena())
                            {                                
                                if (lnY == loListaFiltradaNivel1.Count)
                                    loSecundaria._Porcentaje = lnPercentNivel2 + lnRestoNivel2;
                                else
                                    loSecundaria._Porcentaje = lnPercentNivel2;    
                            }
                            lnY++;
                        }
                        lnX++;
                    }
                }
            }
            
            public void _InsertarTodas()
            {
                // Eliminem les línies actual (no de la taula)
                _Items.Clear();

                // Agafem totes les secundaries
                using (_Vista V_PLANES = new _Vista("GESTION", "PLAN_D", new Dictionary<string, object>() { { "Plancont", "%" } }, false, true)) 
                {
                    foreach (DataRow ldtPlan in V_PLANES._DataTable.Rows)
                    {
                        AlmacenPlanes.AlmacenPlan loSecund = this._NewItem();
                        loSecund._Plancont = ldtPlan["Plancont"].ToString();
                        loSecund._Secundaria = ldtPlan["Secnivel1"].ToString();
                        loSecund._Secnivel2 = ldtPlan["Secnivel2"].ToString();


                        loSecund._CodAnalit = ((string.IsNullOrEmpty(loSecund._Secnivel2)) ? (loSecund._Secundaria) : (loSecund._Secundaria.ToString().Trim() + "." + loSecund._Secnivel2));
                        loSecund._NomAnalit = FUNCTIONS._AnalitNombre(loSecund._Secundaria + "." + loSecund._Secnivel2);
                    }
                }

                // Repartir el porcentaje
                if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_repasi")) || Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_distsec")))
                    this._RepartirPorcentaje();
            }

            public void _BorrarTodas()
            {
                // Eliminem les línies actual (no de la taula)
                _Items.Clear();
            }

            public bool _TotalPorcentajes(out string tcPlan)
            {
                bool lbTotalOk = true;
                tcPlan = string.Empty;

                Dictionary<string, decimal> lnPorcentajePlan = new Dictionary<string, decimal>();
                //Obtenemos una lista ordenada por plan contable
                List<AlmacenPlanes.AlmacenPlan> loListaOrdenada = _Items.OrderBy(x => x._Plancont).ToList();

                foreach (AlmacenPlanes.AlmacenPlan loSecundaria in loListaOrdenada)
                {
                    if (loSecundaria.Fila_Plena())
                    {
                        if (lnPorcentajePlan.ContainsKey(loSecundaria._Plancont))
                            lnPorcentajePlan[loSecundaria._Plancont] += loSecundaria._Porcentaje;
                        else
                            lnPorcentajePlan.Add(loSecundaria._Plancont, loSecundaria._Porcentaje);
                    }
                }

                //Iteramos cada Plan y su porcentaje acumulado
                foreach (KeyValuePair<string, decimal> lnPorcen in lnPorcentajePlan)
                {
                    if (lnPorcen.Value != 100M)
                    {
                        lbTotalOk = false;
                        tcPlan = lnPorcen.Key;
                        break;
                    }
                }

                return lbTotalOk;

            }

            public string _DefinicionPlanAnalitico(string tcCodigo)
            {
                if (string.IsNullOrWhiteSpace(tcCodigo))
                    return string.Empty;

                string lcDescripcionPlan = string.Empty;

                lcDescripcionPlan = Convert.ToString(DB.SQLValor("PLANS", "CODIGO", tcCodigo, "NOMBRE")).Trim();

                return "Listado de códigos analíticos del plan " + lcDescripcionPlan;
            }


            public void _CalcularTotalPorcentajesLinea(ref string tcPlan, ref string tcNivel1, ref string tcNivel2, out decimal tpcPlan, out decimal tpcNivel1)
            {
                Int32 lnLen = Convert.ToInt32(EW_GLOBAL._GetLenCampo(KeyDiccionarioLenCampos.wn_secundarias));

                tpcPlan = 0.0M;
                tpcNivel1 = 0.0M;
                string lcPlan = tcPlan.Trim();
                string lcNivel1 = tcNivel1.Trim();
                string lcNivel2 = tcNivel2.Trim();

                if (!this._bIsLoading) //Bug 105927: En el momento de estar cargando no calculamos el porcentaje, sólo cuando estamos desplazando por las filas
                {
                    DataTable ldtSecundarias = this._ToDataTable();

                    var groupedDataPlan = (from b in ldtSecundarias.AsEnumerable()
                                           where b.Field<string>("_Plancont").Trim() == lcPlan
                                           group b by b.Field<string>("_Plancont").Trim()
                                               into g
                                               select new
                                               {
                                                   Plancont = g.Key,
                                                   Percent = g.Sum(x => x.Field<decimal>("_Porcentaje"))
                                               })
                                      .ToList();

                    if (groupedDataPlan != null && groupedDataPlan.Count > 0)
                    {
                        tpcPlan = Convert.ToDecimal(groupedDataPlan[0].Percent);
                    }


                    var groupedDataNivel1 = (from b in ldtSecundarias.AsEnumerable()
                                             where b.Field<string>("_Plancont").Trim() == lcPlan &&
                                                   ((EW_GLOBAL._Empresa._ImputarPor == 0) ?
                                                                                           b.Field<string>("_Secundaria").Trim() == lcNivel1 &&
                                                                                           b.Field<string>("_Secnivel2").Trim() == lcNivel2
                                                                                         :
                                                                                           b.Field<string>("_Secundaria").Trim() == lcNivel1)
                                             group b by new
                                             {
                                                 c1 = b.Field<string>("_Plancont").Trim(),
                                                 c2 = b.Field<string>("_Secundaria").Trim(),
                                             }
                                                 into g
                                                 select new
                                                 {
                                                     Plancont = g.Key.c1,
                                                     Nivel1 = g.Key.c2,
                                                     Percent = g.Sum(x => x.Field<decimal>("_Porcentaje"))
                                                 })
                                      .ToList();

                    if (groupedDataNivel1 != null && groupedDataNivel1.Count > 0)
                    {
                        tpcNivel1 = Convert.ToDecimal(groupedDataNivel1[0].Percent);
                    }
                }
                else //Bug 105927: En el caso de no estar en una fila seleccionada por estar en el loading del grid entonces tampoco mostramos el valor de plan y nivel
                {
                    tcPlan = "--";
                    tcNivel1 = "--";
                }

            }

            public class Clave : IClaves
            {
                public ClaveTRel _Almacen { get; set; }

                public ClaveTRel _Plancont { get; set; }

                public ClaveTRel _Secundaria { get; set; }

                public ClaveTRel _Secnivel2 { get; set; }

                public Clave()
                {
                    // Definim les propietats de cada una de les claus
                    _Almacen = new ClaveTRel();
                    _Almacen._EsFiltro = true;       // Actuarà com a filtre per recuperar els registres

                    _Plancont = new ClaveTRel();
                    _Plancont._EsFiltro = false;

                    _Secundaria = new ClaveTRel();
                    _Secundaria._EsFiltro = false;

                    _Secnivel2 = new ClaveTRel();
                    _Secnivel2._EsFiltro = false;

                    // i posem valors per defecte
                    _Almacen._Valor = "";
                    _Plancont._Valor = "";
                    _Secundaria._Valor = "";
                    _Secnivel2._Valor = "";

                    // Per defecte, totes les ClaveTRel son EsClave = true
                }
            }

            public class AlmacenPlan : ILinTRel, INivelAnaliticoTRel
            {

                //PE-98248
                private bool _lHera = Convert.ToBoolean(ew.global.EW_GLOBAL._GetVariable("wl_hera"));
                private bool _lSoloNivelesDefinidos = (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_solonivdef")));

                public string _Almacen
                {
                    get { return _cAlmacen; }
                    set { _cAlmacen = value; }
                }
                private string _cAlmacen = "";
                
                public string _Nombre
                {
                    get 
                    { 
                        return _cNombre.Trim(); 
                    }
                    set 
                    { 
                        _cNombre = value; 
                    }
                }
                private string _cNombre = "";

                
                public string _Secundaria
                {
                    get { return _cSecnivel1; }
                    set
                    {
                        if (_cSecnivel1 != value)
                        {
                            // Comprovacions codi postal
                            if (loParent != null)
                            {                                
                                // PE-105465. Hay que recoger el nuevo valor por si se han añadido 0s
                                object newValor = value;
                                if (newValor != null && !string.IsNullOrWhiteSpace(value))   //Bug 105422
                                {
                                    //Task 111764
                                    _AsignarPlanAnalitico();

                                    //Task 111764
                                    if (!SecundariaValida(value, "2", _Plancont))
                                        return;

                                    CuentaSecundaria loSec = new CuentaSecundaria(value);
                                    string oldNombre = _Nombre;
                                    if (loParent.CamposTRel_Validar_Valor("_Secundaria", value, this, out newValor))
                                    {
                                        value = _cSecnivel1;

                                        if (EW_GLOBAL._Empresa._ImputarPor == 0)
                                        {
                                            if (string.IsNullOrWhiteSpace(_cSecnivel1))
                                            {
                                                _cSecnivel2 = string.Empty;
                                                _cNombre2 = string.Empty;
                                            }
                                        }
                                    }
                                    else if (loSec._NivelCuenta != CuentaSecundaria.NivelCuenta.Nivel1)
                                    {
                                        value = _cSecnivel1;
                                        loParent._ManteGrid._Show_Error_Message((EW_GLOBAL._Empresa._ImputarPor == 0 ? "El código analítico indicado no existe." : "La cuenta introducida no es de nivel 1."));
                                        _Nombre = oldNombre;
                                    }
                                    else if (_lSoloNivelesDefinidos && !loParent._bIsLoading && !string.IsNullOrWhiteSpace(value) && !CONTABILIDAD._ExisteNivelAnaliticoPlan(_Plancont, CuentaSecundaria.NivelCuenta.Nivel1, value))
                                    {
                                        value = _cSecnivel1;
                                        loParent._ManteGrid._Show_Error_Message((EW_GLOBAL._Empresa._ImputarPor == 0 ? "El código" : "El nivel ") + value + " introducido no está definido en el plan analítico " + _Plancont.Trim() + ".");
                                        _Nombre = oldNombre;
                                    }
                                    else
                                    {
                                        value = newValor.ToString();
                                    }


                                    if (_CodAnalit.Contains("."))
                                    {
                                        //int lnPos = _cCodAnalit.IndexOf(".");
                                        //string cSecun2 = _cCodAnalit.Substring(lnPos + 1);
                                        _cCodAnalit = (!string.IsNullOrWhiteSpace(value) ? value + "." + _Secnivel2 : string.Empty) ;
                                    }
                                    else
                                    {
                                        _cCodAnalit = value;
                                    }
                                    _cNomAnalit = FUNCTIONS._AnalitNombre(_cCodAnalit);
                                }
                                else
                                {
                                    value = "";
                                    _Nombre = "";
                                }                                
                            }
                        }

                        if (_cSecnivel1 != value)
                        {
                            _cSecnivel1 = value;
                            loParent._Exportar_Null();
                        }
                    }
                }
                private string _cSecnivel1 = "";

                
                public decimal _Porcentaje
                {
                    get { return _nPorcentaje; }
                    set
                    {
                        if (value != _nPorcentaje)
                        {
                            _nPorcentaje = value;
                            loParent._Exportar_Null();
                        }
                    }
                }
                private decimal _nPorcentaje = 0;


                private decimal _nPorcentaje1 = 0;
                public decimal _Porcentaje1
                {
                    get
                    {
                        AlmacenPlanes loSecundarias = (AlmacenPlanes)this._Parent;
                        var registros = loSecundarias._Items.Where(x => x._Secundaria.Trim() == _Secundaria.Trim() && x._Plancont == _Plancont);
                        _nPorcentaje1 = 0;
                        foreach (AlmacenPlanes.AlmacenPlan ldr in registros)
                        {
                            _nPorcentaje1 += ldr._Porcentaje;
                        }

                        return _nPorcentaje1;
                    }
                    set
                    {
                        if (value != _nPorcentaje1)
                        {
                            _nPorcentaje1 = value;
                        }
                    }
                }

                public string _Secnivel2
                {
                    get { return _cSecnivel2; }
                    set
                    {
                        if (_cSecnivel2 != value)
                        {
                            // Comprovacions
                            if (loParent != null)
                            {
                                // PE-105465. Hay que recoger el nuevo valor por si se han añadido 0s
                                object newValor = value;
                                if (newValor != null && !string.IsNullOrWhiteSpace(value))   //Bug 105422
                                {
                                    //Task 111764
                                    if (EW_GLOBAL._Empresa._ImputarPor == 1)
                                        _AsignarCuentaNivel1YPlan();

                                    if (!Secnivel2Valida(value))
                                        return;

                                    CuentaSecundaria loSec = new CuentaSecundaria(value);
                                    string oldNombre = _Nombre2;
                                    if (loParent.CamposTRel_Validar_Valor("_Secnivel2", value, this, out newValor))
                                    {
                                        value = _cSecnivel2;

                                        if (EW_GLOBAL._Empresa._ImputarPor == 0)
                                        {
                                            if (string.IsNullOrWhiteSpace(_cSecnivel2))
                                            {
                                                _cSecnivel1 = string.Empty;
                                                _cNombre = string.Empty;
                                            }
                                        }
                                    }
                                    else if (loSec._NivelCuenta != CuentaSecundaria.NivelCuenta.Nivel2)
                                    {
                                        value = _cSecnivel2;

                                        if (EW_GLOBAL._Empresa._ImputarPor == 0)
                                        {
                                            if (string.IsNullOrWhiteSpace(_cSecnivel2))
                                            {
                                                _cSecnivel1 = string.Empty;
                                                _cNombre = string.Empty;
                                            }
                                        }

                                        loParent._ManteGrid._Show_Error_Message((EW_GLOBAL._Empresa._ImputarPor == 0 ? "El código analítico indicado no existe." : "La cuenta introducida no es de nivel 2."));
                                        _Nombre2 = oldNombre;
                                    }
                                    else if (_lSoloNivelesDefinidos && !loParent._bIsLoading && !string.IsNullOrWhiteSpace(value) && !CONTABILIDAD._ExisteNivelAnaliticoPlan(_Plancont, CuentaSecundaria.NivelCuenta.Nivel2, value))
                                    {
                                        loParent._ManteGrid._Show_Error_Message((EW_GLOBAL._Empresa._ImputarPor == 0 ? "El código" : "El nivel ") + value + " introducido no está definido en el plan analítico " + _Plancont.Trim() + ".");
                                        value = _cSecnivel2;
                                        _Nombre2 = oldNombre;
                                    }
                                    else
                                    {
                                        value = newValor.ToString();
                                    }

                                    _cCodAnalit = (!string.IsNullOrEmpty(value) ? _Secundaria.ToString().Trim() + "." + value : _Secundaria.ToString());
                                    _cNomAnalit = FUNCTIONS._AnalitNombre(_cCodAnalit);
                                }
                                else
                                {
                                    value = "";
                                    _Nombre2 = "";
                                }
                            }
                        }

                        if (_cSecnivel2 != value)
                        {
                            _cSecnivel2 = value;
                            loParent._Exportar_Null();
                        }
                    }
                }
                private string _cSecnivel2 = "";

                
                public string _Nombre2
                {
                    get { return _cNombre2.Trim(); }
                    set { _cNombre2 = value; }
                }
                private string _cNombre2 = "";

                
                public string _Plancont
                {
                    get { return _cPlancont; }
                    set
                    {
                        // Comprovacions 
                        if (loParent != null)
                        {
                            object newValor = value;
                            if (newValor != null && !string.IsNullOrWhiteSpace(value))
                            {
                                string oldNombre = _NombrePlan;
                                if (loParent.CamposTRel_Validar_Valor("_Plancont", value, this, out newValor))
                                {
                                    value = _cPlancont;
                                    _NombrePlan = oldNombre;
                                }
                                else
                                {
                                    value = newValor.ToString();
                                }
                            }
                            else
                            {
                                value = "";
                                _NombrePlan = "";
                            }
                        }

                        if (value != _cPlancont)
                        {
                            _cPlancont = value;
                            loParent._Exportar_Null();
                            if (!string.IsNullOrWhiteSpace(_cPlancont))
                            {
                                loParent._ListDefCampos["_Secundaria"]._Browser._Condicion = " nivel = 1 ";
                                loParent._ListDefCampos["_Secnivel2"]._Browser._Condicion = " nivel = 2 ";
                            }
                        }
                    }
                }
                private string _cPlancont = "";

                
                public string _NombrePlan
                {
                    get { return _cNombrePlan.Trim(); }
                    set { _cNombrePlan = value; }
                }
                private string _cNombrePlan = "";


                public string _CodAnalit
                {
                    get { return _cCodAnalit.Trim(); }
                    set { _cCodAnalit = value; }
                }
                private string _cCodAnalit = "";


                public string _NomAnalit
                {
                    get { return _cNomAnalit.Trim(); }
                    set { _cNomAnalit = value; }
                }
                private string _cNomAnalit = "";


                public bool _PrimeraSecundaria
                {
                    get
                    {
                        bool lbPrimeraSecundaria;
                        AlmacenPlanes loParent = (AlmacenPlanes)_Parent;
                        if (loParent._Items.Count > 0)
                            lbPrimeraSecundaria = (loParent._Items.Where(lin => lin._Plancont == _Plancont && lin._Secundaria.Trim() == _Secundaria.Trim()).ToList().IndexOf(this) == 0);
                        else if (string.IsNullOrWhiteSpace(_Secundaria))
                            lbPrimeraSecundaria = true;
                        else lbPrimeraSecundaria = false;

                        return lbPrimeraSecundaria;
                    }
                }

                public bool _PrimerPlan
                {
                    get
                    {
                        bool lbPrimerPlan;
                        AlmacenPlanes loParent = (AlmacenPlanes)_Parent;
                        if (loParent._Items.Count > 0)
                            lbPrimerPlan = (loParent._Items.Where(lin => lin._Plancont == _Plancont).ToList().IndexOf(this) == 0);
                        else if (string.IsNullOrWhiteSpace(_Plancont))
                            lbPrimerPlan = true;
                        else
                            lbPrimerPlan = false;

                        return lbPrimerPlan;
                    }
                }

                private AlmacenPlanes loParent;
                public object _Parent
                {
                    get { return loParent; }
                    set { loParent = (AlmacenPlanes)value; }
                }

                public AlmacenPlan()
                {

                }

                private bool SecundariaValida(string tcSecundaria, string tcNivell, string tcCuenta = "")
                {
                    if (string.IsNullOrWhiteSpace(tcSecundaria) && _PrimeraSecundaria)
                    {
                        if (tcNivell == "2" && tcSecundaria.Trim() != Convert.ToString(_Secundaria).Trim() &&
                            loParent._Items.Where(lin => lin._Plancont == _Plancont && !lin._PrimerPlan).ToList().Count > 0)
                        {
                            FUNCTIONS._MessageBox("No está permitida la eliminación, existen cuentas de nivel 1, 2 asociadas al mismo plan contable " + _Plancont.Trim(), "Planes analíticos", MessageBoxButtons.OK, MessageBoxIcon.Stop);
                            return false;
                        }
                    }

                    string lcCuenta = tcNivell == "1" ? Convert.ToString(_Plancont) : Convert.ToString(_Secundaria).Trim();
                    if (string.IsNullOrWhiteSpace(tcSecundaria) || tcSecundaria.Trim() == lcCuenta.Trim())
                        return true;

                    return true;
                }

                protected internal void _AsignarPlanAnalitico()
                {
                    //comprovem si la _Plancont està buida, si es aixi assignem la compta de l'anterior

                    if (string.IsNullOrWhiteSpace(_Plancont) && _PrimerPlan)
                    {
                        int lnPos = loParent._Items.IndexOf(this);
                        if (lnPos > 0)
                        {
                            AlmacenPlan loAnterior = loParent._Items[lnPos - 1];
                            if (!string.IsNullOrWhiteSpace(loAnterior._cSecnivel1))
                            {
                                _cPlancont = loAnterior._Plancont;
                            }
                            loAnterior = null;
                        }
                    }
                }

                protected internal void _AsignarCuentaNivel1YPlan()
                {
                    if (string.IsNullOrWhiteSpace(_Plancont) && string.IsNullOrWhiteSpace(_Secundaria) && _PrimeraSecundaria)
                    {
                        int lnPos = loParent._Items.IndexOf(this);
                        if (lnPos > 0)
                        {
                            AlmacenPlan loAnterior = loParent._Items[lnPos - 1];
                            if (!string.IsNullOrWhiteSpace(loAnterior._cSecnivel1) && !string.IsNullOrWhiteSpace(loAnterior._cSecnivel2))
                            {
                                _cPlancont = loAnterior._Plancont;
                                _cSecnivel1 = loAnterior._Secundaria;
                            }
                            loAnterior = null;
                        }
                    }
                }

                private bool Secnivel2Valida(string tcSecundaria)
                {
                    if (string.IsNullOrWhiteSpace(_Plancont) && string.IsNullOrWhiteSpace(_Secundaria) && _PrimeraSecundaria)
                    {
                        int lnPos = loParent._Items.IndexOf(this);
                        if (lnPos > 0)
                        {
                            AlmacenPlan loAnterior = loParent._Items[lnPos - 1];
                            if (!string.IsNullOrWhiteSpace(loAnterior._cSecnivel1) && string.IsNullOrWhiteSpace(loAnterior._cSecnivel2))
                            {
                                FUNCTIONS._MessageBox("No está permitida la inserción de una cuenta de nivel 2 ya que existe un registro sin nivel 2 para el mismo plan y cuenta de nivel 1", "Planes analíticos", MessageBoxButtons.OK, MessageBoxIcon.Stop);
                                return false;
                            }
                            loAnterior = null;
                        }
                    }


                    return true;
                }

                public bool Fila_Plena()
                {
                    bool lbFilaPlena;

                    lbFilaPlena = !(string.IsNullOrWhiteSpace(_Plancont)) && !(string.IsNullOrWhiteSpace(_Secundaria)); //Comprobar también el _Plancont para la fila plena

                    return lbFilaPlena;
                }
            }
        }
    }
}