CentrosAdministrativosFactura.cs

using System;
using System.Collections.Generic;
using System.Linq;
using sage.ew.ewbase;
using sage.ew.db;
using System.Data;
using System.ComponentModel;
using sage.ew.global;
using System.Windows.Forms;
using sage.ew.botones;
using sage.ew.global.Diccionarios;
using sage.ew.interficies;
using sage.ew.contabilidad;
using sage.ew.functions;
using sage.ew.docsven;
using System.Reflection;
using System.Web.Script.Serialization;

namespace sage.ew.cliente
{    
    public class CentrosAdministrativosFactura : CentrosAdministrativosBase<CentroAdministrativoLineaFactura, CentroAdministrativoClaveFactura>
    {
        #region PROPIEDADES PRIVADAS

        protected internal ewDocVentaFRA _oFactura = null;
        private int _lnItems = 0;
        private bool _lExistenRegistros = false;

        #endregion

        #region PROPIEDADES PUBLICAS

        public bool _ExistenRegistros
        {
            get
            {
                return _lExistenRegistros;
            }
        }

        public bool _CargarRegistrosCliente { get; set; } = true;

        #endregion

        #region CONSTRUCTORES

        public CentrosAdministrativosFactura() : base()
        {

        }

        public CentrosAdministrativosFactura(ewDocVentaFRA toFactura)
        {
            _oFactura = toFactura;

            _Claves._Empresa._Valor = toFactura._Empresa;
            _Claves._Ejercicio._Valor = toFactura._Cabecera._Ejercicio.Trim(); 
            _Claves._Factura._Valor = toFactura._Cabecera._Factura;
            _Claves._Cliente._Valor = toFactura._Cabecera._Cliente;
        }

        #endregion
        
        #region METODOS PROTECTED

        protected override void _Inicializar()
        {
            _DataBase = "COMUNES";
            _Tabla = "CCAAFAC";
            _Condicion = "";
            _Titulo_Browser = "Buscar centros administrativos";
        }

        protected override void _CrearEstructura()
        {
            base._CrearEstructura();

            // Campo Ejercicio
            _AddCampoTRel("_Ejercicio", "Ejercicio", false, true, false);

            //Campo factura
            _AddCampoTRel("_Factura", "Factura", false, true, false);

            //Campo XML
            _AddCampoTRel("_Xml", "Xml", false, true, false);
        }

        #endregion

        #region METODOS PUBLICOS

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

            if (_oFactura != null )
            {
                _lExistenRegistros = (_Items.Count != 0);

                if (!_lExistenRegistros && _CargarRegistrosCliente) //si no hay registros cargamos los registros del cliente
                {                    
                    _oFactura._Cabecera._oCliente._TRelCentrosAdmin._Load();
                    var lstCentros = _oFactura._Cabecera._oCliente._TRelCentrosAdmin._Items.GroupBy(c => c._Rol).Select(c => c.FirstOrDefault());
                    if (lstCentros != null && lstCentros.Count() > 0)
                        lstCentros.ToList().ForEach(centro => _Items.Add(new CentroAdministrativoLineaFactura(this, centro)));
                    lstCentros = null;
                }
            }

            _lnItems = _Items.Where(c=>c.Fila_Plena()).Count();
        }

       
        public bool _Save(bool tlFacturaElectronica = false)
        {
            bool llSave = true;
            if (_HayCambios())
            {               
                llSave = base._Save();
                if (llSave)
                {
                    if(tlFacturaElectronica)
                        FacturaElectronica();

                    _lnItems = _Items.Where(c => c.Fila_Plena()).Count();
                    _lExistenRegistros = (_lnItems!=0);
                }
            }

            return llSave;
        }


        public CentrosAdministrativosFactura _Duplicar()
        {
            CentrosAdministrativosFactura loNewCentrosAdminFactura = new CentrosAdministrativosFactura(this._oFactura);

            foreach (CentroAdministrativoLineaFactura loCentroOrigen in this._Items)
            {
                CentroAdministrativoLineaFactura loCentroDestino = new CentroAdministrativoLineaFactura();
                loCentroDestino._Parent = loNewCentrosAdminFactura;

                this.copiarCamposCentro(loCentroOrigen, loCentroDestino);

                loNewCentrosAdminFactura._Items.Add(loCentroDestino);
            }

            return loNewCentrosAdminFactura;
        }


        public void  _CopiarRegistrosDesde(CentrosAdministrativosFactura toCentrosAdminOrigen)
        {
            foreach (CentroAdministrativoLineaFactura loCentroOrigen in toCentrosAdminOrigen._Items)
            {
                CentroAdministrativoLineaFactura loCentroDestino = new CentroAdministrativoLineaFactura();
                loCentroDestino._Parent = this;

                this.copiarCamposCentro(loCentroOrigen, loCentroDestino);

                this._Items.Add(loCentroDestino);
            }

            return;
        }

        #endregion

        #region METODOS PRIVADOS

        private bool _HayCambios()
        {
            bool llHayCambios = true;

            if (_lnItems == _Items.Count)
            {             
                foreach (CentroAdministrativoLineaFactura lin in _Items)
                {
                    llHayCambios = lin._HayCambios();
                    if (llHayCambios)
                        break;
                }
            }

            return llHayCambios;
        }

        private void FacturaElectronica()
        {
            if (_oFactura._ExisteFacturaElectronica())
            {
                DialogResult loDlgResult = FUNCTIONS._MessageBox("Se han realizado cambios en los centros asociados a la factura " + Environment.NewLine + Environment.NewLine +
                    " ¿Desea generar de nuevo la factura electrónica?", MessageBoxButtons.YesNo, MessageBoxIcon.Information, MessageBoxDefaultButton.Button2, DialogResult.No);

                if (loDlgResult == DialogResult.Yes) _oFactura._FirmarFacturaAutomatico();
                
            }
        }

        private void copiarCamposCentro(CentroAdministrativoLineaFactura toCentroOrigen, CentroAdministrativoLineaFactura toCentroDestino)
        {
            toCentroDestino._Empresa = toCentroOrigen._Empresa;
            toCentroDestino._Ejercicio = toCentroOrigen._Ejercicio;
            toCentroDestino._Factura = toCentroOrigen._Factura;
            toCentroDestino._Cliente = toCentroOrigen._Cliente;
            toCentroDestino._Rol = toCentroOrigen._Rol;
            toCentroDestino._Codcentro = toCentroOrigen._Codcentro;

            toCentroDestino._Apellido1 = toCentroOrigen._Apellido1;
            toCentroDestino._Apellido2 = toCentroOrigen._Apellido2;
            toCentroDestino._CodPost = toCentroOrigen._CodPost;
            toCentroDestino._Contacto = toCentroOrigen._Contacto;
            toCentroDestino._Descripcion = toCentroOrigen._Descripcion;
            toCentroDestino._Direccion = toCentroOrigen._Direccion;
            toCentroDestino._Email = toCentroOrigen._Email;
            toCentroDestino._Fax = toCentroOrigen._Fax;
            toCentroDestino._Pais = toCentroOrigen._Pais;
            toCentroDestino._Poblacion = toCentroOrigen._Poblacion;
            toCentroDestino._Provincia = toCentroOrigen._Provincia;
            toCentroDestino._Responsa = toCentroOrigen._Responsa;
            toCentroDestino._Telefono = toCentroOrigen._Telefono;
            toCentroDestino._Url = toCentroOrigen._Url;
            toCentroDestino._EnvCli = toCentroOrigen._EnvCli;

            toCentroDestino._Xml = toCentroOrigen._Xml;

            return;
        }

        public bool _HayCambios(List<CentroAdministrativoLineaFactura> loLinCentros)
        {
            JavaScriptSerializer loJS;
            CentroAdministrativoLineaFactura loLinCentroOrigen;

            try
            {
                if (_Items.Count == loLinCentros.Count)
                {
                    foreach (CentroAdministrativoLineaFactura loLinCentroDestino in loLinCentros)
                    {
                        loLinCentroOrigen = _Items.Where(f => f._Rol == loLinCentroDestino._Rol).FirstOrDefault();

                        if (loLinCentroOrigen is CentroAdministrativoLineaFactura)
                        {
                            loJS = new JavaScriptSerializer();
                            if (loJS.Serialize(loLinCentroOrigen) != loJS.Serialize(loLinCentroDestino)) return true;
                        }
                        else
                        {
                            return true;
                        }
                    }

                    return false;
                }
            }
            catch
            {

            }
            finally
            {
                loJS = null;
            }

            return true;
        }

        #endregion

    }

    public class CentroAdministrativoClaveFactura : CentroAdministrativoClaveBase
    {
        public ClaveTRel _Ejercicio { get; set; }

        public ClaveTRel _Factura { get; set; }

        public ClaveTRel _Cliente { get; set; }

        public CentroAdministrativoClaveFactura() : base()
        {
            _Ejercicio = new ClaveTRel
            {
                _EsFiltro = true,
                _Valor = ""
            };
         
            _Factura = new ClaveTRel
            {
                _EsFiltro = true,
                _Valor = ""
            };

            //no debe actuar como clave, nos podemos encontrar con una factura donde el cliente factura no tiene centros y se ha guardado los centros del albarán (actualmente no puede pasar, no está implementada esta funcionalidad, pero antes si) 
            _Cliente = new ClaveTRel
            {
                _EsFiltro = false,      
                _Valor = ""
            };
        }
    }

    public class CentroAdministrativoLineaFactura : CentroAdministrativoLineaBase
    {
        #region PROPIEDADES PRIVADAS

        private string _cEjercicio = string.Empty;
        private string _cFactura = string.Empty;
        private string _cNombreRol = null;
        private string _cISOPais = null;
        private string _cXml = string.Empty;

        private Dictionary<string, object> _dicCopia = null;

        #endregion

        #region PROPIEDADES PUBLICAS

        public string _Ejercicio
        {
            get { return _cEjercicio; }
            set
            {
                if (value != _cEjercicio)
                {
                    _cEjercicio = value;
                    if (_Parent != null)
                        ((CentrosAdministrativosFactura)_Parent)._Exportar_Null();
                }
            }
        }

        public string _Factura
        {
            get { return _cFactura; }
            set
            {
                if (value != _cFactura)
                {
                    _cFactura = value;
                    if (_Parent != null)
                        ((CentrosAdministrativosFactura)_Parent)._Exportar_Null();
                }
            }
        }

        public override string _Rol
        {
            get
            {
                return base._Rol;
            }
            set
            {               
                if (!ValidarRol((base._Rol != value), value))
                    return;

                base._Rol = value;                
            }
        }

        public string _NombreRol
        {
            get
            {
                if(_cNombreRol==null && !string.IsNullOrWhiteSpace(_Rol))
                    _cNombreRol= Convert.ToString(DB.SQLValor("ROLES", "CODIGO", _Rol, "NOMBRE2", "COMUNES"));
                return _cNombreRol;
            }
        }

        public string _ISOPais
        {
            get
            {
                if (_cISOPais == null && !string.IsNullOrWhiteSpace(_Pais))
                    _cISOPais = Convert.ToString(DB.SQLValor("PAISES", "CODIGO", _Pais, "ISO2", "COMUNES"));
                return _cISOPais;
            }
        }

        public string _Xml
        {
            get { return _cXml; }
            set
            {
                if (value != _cXml)
                {
                    _cXml = value;
                    if (_Parent != null)
                        ((CentrosAdministrativosFactura)_Parent)._Exportar_Null();
                }
            }
        }

        #endregion

        #region CONSTRUCTORES

        public CentroAdministrativoLineaFactura() : base()
        {           
        }

        public CentroAdministrativoLineaFactura(CentrosAdministrativosFactura toCentro, CentroAdministrativoLineaBase toCentroLinea)
        {
            _Parent = toCentro;            
            _Clonar(toCentroLinea);

            if (toCentro._oFactura != null)
            {
                _Empresa = toCentro._oFactura._Empresa;
                _Ejercicio = toCentro._oFactura._Cabecera._Ejercicio.Trim();
                _Factura = toCentro._oFactura._Cabecera._Factura;
                _Cliente = toCentro._oFactura._Cabecera._Cliente;
            }
        }

        public override void _Load(bool tlForzado = false)
        {
            base._Load(tlForzado);

            _dicCopia = DiccionarioLinea();
        }

        #endregion

        #region METODOS PRIVADOS

        private bool ValidarRol(bool tlModif, string tcRol)
        {
            bool llOk = true;

            if (!((CentrosAdministrativosFactura)_Parent)._bIsLoading)
            {
                if (tlModif && _Parent != null)
                {
                    var loListRoles = ((CentrosAdministrativosFactura)_Parent)._Items.Where(c => c._Rol == tcRol);
                    if (loListRoles != null && loListRoles.Count() > 0)
                    {
                        ((CentrosAdministrativosFactura)_Parent)._Show_Error_Message("El Rol ya está incluido en la factura.");
                        llOk = false;
                    }
                    loListRoles = null;
                }
            }

            return llOk;
        }
        
        private Dictionary<string, object> DiccionarioLinea()
        {
            //Lista de propiedades q descartamos
            List<string> lstName = new List<string> { "_Parent", "_ComboRol" };

            Dictionary<string, object> lodicLin = this.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).Where(prop => !string.IsNullOrWhiteSpace(prop.Name) && prop.Name.Substring(0, 1) == "_" && !lstName.Contains(prop.Name)).ToDictionary(prop => prop.Name, prop => prop.GetValue(this, null));

            return lodicLin;
        }

        protected internal bool _HayCambios()
        {
            bool llHayCambios = true;

            Dictionary<string, object> ldicTemp = DiccionarioLinea();

            if (_dicCopia != null) //si es null no existe            
                llHayCambios = !_dicCopia.OrderBy(k => k.Key).SequenceEqual(ldicTemp.OrderBy(k => k.Key));                
            
            _dicCopia = null;
            _dicCopia = ldicTemp;

            return llHayCambios;
        }

        #endregion
    }
}