LegalizacionLibros.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Data;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using Ionic.Zip;
using sage.ew.contabilidad.Form;
using sage.ew.ewbase;
using sage.ew.ewbase.Attributes;
using sage.ew.formul.Forms;
using sage.ew.functions;
using sage.ew.functions.Clases;
using sage.ew.global;
using sage.ew.interficies;
using sage.ew.objetos;
using Sage.ew.contabilidad.DataAccess.Clases;
using Sage.ew.contabilidad.DataAccess.Interfaz;
 
namespace sage.ew.contabilidad
{
    public partial class LegalizacionLibros : DocumentoBase, IDocumentoImprimible
    {
        #region ENUMERACIONES INTERNAS
 

        public enum EstadoFirmasLibros
        {
            NoEvaluado,

            NingunaFirmaGenerada,

            AlgunaFirmaGenerada,

            TodasFirmasGeneradas,
        }
 

        public enum TipoImpresion
        {
            SolicitudLegalizacion,

            CertificadoFirmas
        }
 
 
        #endregion ENUMERACIONES INTERNAS
 
 
        #region EVENTOS
 

        public delegate void _Error_Message_Linea_After_Handler(string tcMissatge);
 

        public event _Error_Message_Linea_After_Handler _Error_Message_Linea_After;
 
 
        #endregion EVENTOS
 
 
        #region PROPIEDADES PRIVATE
 

        private ILegalizacionLibrosDA _dataAccessLegalizacionLibros
        {
            get
            {
                // Recoge el valor de la propiedad _dataAccessDocumentoBase que tiene la clase base DocumentoBase, se
                // acaba asignando en cualquiera de las llamadas a los constructores de esta clase LegalizacionLibros
                // cuando se llama a base(legalizacionLibrosDA) 
                //
                return this._dataAccessDocumentoBase as ILegalizacionLibrosDA;
            }
        }

        private int _lnAny = Convert.ToInt32(EW_GLOBAL._GetVariable("wc_any"));
 

        private string _lcAny = Convert.ToString(EW_GLOBAL._GetVariable("wc_any"));
 

        private string _cMonedaEmpresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_moneda"));
 

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

        private bool _lEmpresaNormal = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_normal"));
 

        private bool _llEjercicioPartido = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_parti"));
 

        private DateTime _dFechaIniEjer = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodoini"));
 

        private DateTime _dFechaFinEjer = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodofin"));
 
 
        #endregion PROPIEDADES PRIVATE
 
 
        #region PROPIEDADES PÚBLICAS
 
 
        #region PROPIEDADES CABECERA
 

        [FieldName("Empresa")]
        [DisplayName("EMPRESA")]
        [ReportProperty("Empresa", "", "Empresa::")]
        [DefaultValue("")]
        [DataType(DataType.Text)]
        public new string _Empresa
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._Empresa))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._Empresa)), value);
            }
        }
 

        [FieldName("Numero")]
        [DisplayName("Ejercicio:")]
        [ReportProperty("Numero", "", "Número::")]
        [DefaultValue("")]
        [DataType(DataType.Text)]
        public string _Numero
        {
            get
            {
                string lcValor = Convert.ToString(_Campo(GetFieldName(nameof(this._Numero)))).Trim().PadRight(8, ' ');
                if (lcValor.Trim() == "0")
                    lcValor = "";
 
                return lcValor;
            }
            set
            {
                // Asignar campo empresa en función de la empresa activa.
                //
                this.AsignarValoresClave();
 
                value = value.PadRight(8);
 
                this._Campo(this.GetFieldName(nameof(this._Numero)), value );
            }
        }
 

        [FieldName("Fecha")]
        [DisplayName("Fecha solicitud:")]
        [ReportProperty("Fecha", "dd/MM/yyyy", "Fecha::")]
        [DataType(DataType.DateTime)]
        public DateTime _Fecha
        {
            get
            {
                return Convert.ToDateTime(this._Campo(this.GetFieldName(nameof(this._Fecha))));
            }
            set
            {
                string lcNombreCampo = this.GetFieldName(nameof(this._Fecha)).ToUpper();
 
                this._Campo(lcNombreCampo, value);
            }
        }
 

        [FieldName("Retencion")]
        [DisplayName("Solicita retención:")]
        [ReportProperty("Solicita retención", "", "Solicita retención::")]
        [DefaultValue(false)]
        public bool _SolicitaRetencion
        {
            get
            {
                return Convert.ToBoolean(this._Campo(this.GetFieldName(nameof(this._SolicitaRetencion))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._SolicitaRetencion)), value);
            }
        }
 

        [FieldName("Ruta_dest")]
        [DefaultValue("")]
        public string _RutaGeneracion
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._RutaGeneracion))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._RutaGeneracion)), value);
            }
        }
 
 
        #endregion PROPIEDADES CABECERA
 
 
        #region PROPIEDADES EMPRESARIO
 

        [FieldName("Emp_nom")]
        [DisplayName("Nombre empresario:")]
        [ReportProperty("Nombre empresario", "", "Nombre empresario::")]
        [DefaultValue("")]
        public string _NombreEmpresario
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._NombreEmpresario))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._NombreEmpresario)), value);
            }
        }
 

        [FieldName("Emp_ap1")]
        [DisplayName("Apellido 1 empresario:")]
        [ReportProperty("Apellido 1 empresario", "", "Apellido 1 empresario::")]
        [DefaultValue("")]
        public string _Apellido1Empresario
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._Apellido1Empresario))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._Apellido1Empresario)), value);
            }
        }
 

        [FieldName("Emp_ap2")]
        [DisplayName("Apellido 2 empresario:")]
        [ReportProperty("Apellido 2 empresario", "", "Apellido 2 empresario::")]
        [DefaultValue("")]
        public string _Apellido2Empresario
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._Apellido2Empresario))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._Apellido2Empresario)), value);
            }
        }
 

        [FieldName("Emp_cif")]
        [DisplayName("Cif empresario:")]
        [ReportProperty("Cif empresario", "", "Cif empresario::")]
        [DefaultValue("")]
        public string _CifEmpresario
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._CifEmpresario))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._CifEmpresario)), value);
            }
        }
 

        [FieldName("Emp_direc")]
        [DisplayName("Dirección empresario:")]
        [ReportProperty("Dirección empresario", "", "Dirección empresario::")]
        [DefaultValue("")]
        public string _DireccionEmpresario
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._DireccionEmpresario))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._DireccionEmpresario)), value);
            }
        }
 

        [FieldName("Emp_codpos")]
        [DisplayName("Código postal empresario:")]
        [ReportProperty("Código postal empresario", "", "Código postal empresario::")]
        [DefaultValue("")]
        public string _CodposEmpresario
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._CodposEmpresario))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._CodposEmpresario)), value);
            }
        }
 

        [FieldName("Emp_ciudad")]
        [DisplayName("Ciudad empresario:")]
        [ReportProperty("Ciudad empresario", "", "Ciudad empresario::")]
        [DefaultValue("")]
        public string _CiudadEmpresario
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._CiudadEmpresario))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._CiudadEmpresario)), value);
            }
        }
 

        [FieldName("Emp_provin")]
        [DisplayName("Provincia empresario:")]
        [ReportProperty("Provincia empresario", "", "Provincia empresario::")]
        [DefaultValue("")]
        public string _ProvinciaEmpresario
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._ProvinciaEmpresario))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._ProvinciaEmpresario)), value);
            }
        }
 

        [FieldName("Emp_tel")]
        [DisplayName("Teléfono empresario:")]
        [ReportProperty("Teléfono empresario", "", "Teléfono empresario::")]
        [DefaultValue("")]
        public string _TelefonoEmpresario
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._TelefonoEmpresario))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._TelefonoEmpresario)), value);
            }
        }
 

        [FieldName("Emp_fax")]
        [DisplayName("Fax empresario:")]
        [ReportProperty("Fax empresario", "", "Fax empresario::")]
        [DefaultValue("")]
        public string _FaxEmpresario
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._FaxEmpresario))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._FaxEmpresario)), value);
            }
        }
 
 
        #endregion PROPIEDADES EMPRESARIO
 
 
        #region PROPIEDADES PRESENTADOR
 

        [FieldName("Prs_nom")]
        [DisplayName("Nombre presentador:")]
        [ReportProperty("Nombre presentador", "", "Nombre presentador::")]
        [DefaultValue("")]
        public string _NombrePresentador
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._NombrePresentador))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._NombrePresentador)), value);
            }
        }
 

        [FieldName("Prs_ap1")]
        [DisplayName("Apellido 1 presentador:")]
        [ReportProperty("Apellido 1 presentador", "", "Apellido 1 presentador::")]
        [DefaultValue("")]
        public string _Apellido1Presentador
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._Apellido1Presentador))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._Apellido1Presentador)), value);
            }
        }
 

        [FieldName("Prs_ap2")]
        [DisplayName("Apellido 2 presentador:")]
        [ReportProperty("Apellido 2 presentador", "", "Apellido 2 presentador::")]
        [DefaultValue("")]
        public string _Apellido2Presentador
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._Apellido2Presentador))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._Apellido2Presentador)), value);
            }
        }
 

        [FieldName("Prs_cif")]
        [DisplayName("Cif presentador:")]
        [ReportProperty("Cif presentador", "", "Cif presentador::")]
        [DefaultValue("")]
        public string _CifPresentador
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._CifPresentador))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._CifPresentador)), value);
            }
        }
 

        [FieldName("Prs_direc")]
        [DisplayName("Dirección presentador:")]
        [ReportProperty("Dirección presentador", "", "Dirección presentador::")]
        [DefaultValue("")]
        public string _DireccionPresentador
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._DireccionPresentador))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._DireccionPresentador)), value);
            }
        }
 

        [FieldName("Prs_codpos")]
        [DisplayName("Código postal presentador:")]
        [ReportProperty("Código postal presentador", "", "Código postal presentador::")]
        [DefaultValue("")]
        public string _CodposPresentador
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._CodposPresentador))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._CodposPresentador)), value);
            }
        }
 

        [FieldName("Prs_ciudad")]
        [DisplayName("Ciudad presentador:")]
        [ReportProperty("Ciudad presentador", "", "Ciudad presentador::")]
        [DefaultValue("")]
        public string _CiudadPresentador
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._CiudadPresentador))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._CiudadPresentador)), value);
            }
        }
 

        [FieldName("Prs_provin")]
        [DisplayName("Provincia presentador:")]
        [ReportProperty("Provincia presentador", "", "Provincia presentador::")]
        [DefaultValue("")]
        public string _ProvinciaPresentador
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._ProvinciaPresentador))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._ProvinciaPresentador)), value);
            }
        }
 

        [FieldName("Prs_tel")]
        [DisplayName("Teléfono presentador:")]
        [ReportProperty("Teléfono presentador", "", "Teléfono presentador::")]
        [DefaultValue("")]
        public string _TelefonoPresentador
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._TelefonoPresentador))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._TelefonoPresentador)), value);
            }
        }
 

        [FieldName("Prs_fax")]
        [DisplayName("Fax presentador:")]
        [ReportProperty("Fax presentador", "", "Fax presentador::")]
        [DefaultValue("")]
        public string _FaxPresentador
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._FaxPresentador))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._FaxPresentador)), value);
            }
        }
 

        [FieldName("Prs_email")]
        [DisplayName("Email presentador:")]
        [ReportProperty("Email presentador", "", "Email presentador::")]
        [DefaultValue("")]
        public string _EmailPresentador
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._EmailPresentador))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._EmailPresentador)), value);
            }
        }
 
 
        #endregion PROPIEDADES PRESENTADOR
 
 
        #region PROPIEDADES REGISTRO
 

        [FieldName("Rgs_codigo")]
        [DisplayName("Código de Registro:")]
        [ReportProperty("Código de registro", "", "Código de registro::")]
        [DefaultValue("")]
        public string _CodigoRegistro
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._CodigoRegistro))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._CodigoRegistro)), value);
            }
        }
 

        [FieldName("Rgs_tomo")]
        [DisplayName("Número de tomo registro:")]
        [ReportProperty("Número de tomo registro", "", "Número de tomo registro::")]
        [DefaultValue("")]
        public string _NumeroTomoRegistro
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._NumeroTomoRegistro))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._NumeroTomoRegistro)), value);
            }
        }
 

        [FieldName("Rgs_libro")]
        [DisplayName("Número de libro registro:")]
        [ReportProperty("Número de libro registro", "", "Número de libro registro::")]
        [DefaultValue("")]
        public string _NumeroLibroRegistro
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._NumeroLibroRegistro))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._NumeroLibroRegistro)), value);
            }
        }
 

        [FieldName("Rgs_sec")]
        [DisplayName("Número de sección registro:")]
        [ReportProperty("Número de sección registro", "", "Número de sección registro::")]
        [DefaultValue("")]
        public string _NumeroSeccionRegistro
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._NumeroSeccionRegistro))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._NumeroSeccionRegistro)), value);
            }
        }
 

        [FieldName("Rgs_folio")]
        [DisplayName("Número de folio:")]
        [ReportProperty("Número de folio registro", "", "Número de folio registro::")]
        [DefaultValue("")]
        public string _NumeroFolioRegistro
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._NumeroFolioRegistro))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._NumeroFolioRegistro)), value);
            }
        }
 

        [FieldName("Rgs_hoja")]
        [DisplayName("Número de hoja registro:")]
        [ReportProperty("Número de hoja registro", "", "Número de hoja registro::")]
        [DefaultValue("")]
        public string _NumeroHojaRegistro
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._NumeroHojaRegistro))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._NumeroHojaRegistro)), value);
            }
        }

        [FieldName("Rgs_irus")]
        [DisplayName("Identificador registral único de la sociedad:")]
        [ReportProperty("Identificador registral único de la sociedad", "", "Identificador registral único de la sociedad::")]
        [DefaultValue("")]
        public string _IRUS
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._IRUS))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._IRUS)), value);
            }
        }
 

        [FieldName("Rgs_trp")]
        [DisplayName("Tipo de registro mercantil:")]
        [ReportProperty("Tipo de registro mercantil", "", "Tipo de registro mercantil::")]
        [DefaultValue("")]
        public string _TipoRegistroMercantil
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._TipoRegistroMercantil))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._TipoRegistroMercantil)), value);
            }
        }
 

        [FieldName("Rgs_otros")]
        [DisplayName("Otros:")]
        [ReportProperty("Otros", "", "Otros::")]
        [DefaultValue("")]
        public string _OtrosRegistroMercantil
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._OtrosRegistroMercantil))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._OtrosRegistroMercantil)), value);
            }
        }
 

        [FieldName("Rgs_rm")]
        [DisplayName("Registro mercantil:")]
        [ReportProperty("Registro mercantil", "", "Registro mercantil::")]
        [DefaultValue("")]
        public string _RegistroMercantil
        {
            get
            {
                return Convert.ToString(this._Campo(this.GetFieldName(nameof(this._RegistroMercantil))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._RegistroMercantil)), value);
            }
        }
 

        [FieldName("Tot_libr")]
        [DisplayName("Nº de libros presentados:")]
        [ReportProperty("Número libros presentados", "", "Nº libros presentados::")]
        [DefaultValue(0)]
        public int _NumeroLibrosPresentados
        {
            get
            {
                return Convert.ToInt32(this._Campo(this.GetFieldName(nameof(this._NumeroLibrosPresentados))));
            }
            set
            {
                this._Campo(this.GetFieldName(nameof(this._NumeroLibrosPresentados)), value);
            }
        }
 
 
        #endregion PROPIEDADES REGISTRO
 
 
        #region PROPIEDADES IDOCUMENTOIMPRIMIBLE SOBREESCRITAS
 

        public override IDocPrint _DocPrint
        {
            get
            {
                if (_oDocPrint == null) _oDocPrint = new DocPrintLegalizacionLibros(this);
                return _oDocPrint;
            }
            set
            {
                if (value is DocPrintLegalizacionLibros)
                    _oDocPrint = (DocPrintLegalizacionLibros)value;
            }
        }
 
 
        #endregion PROPIEDADES IDOCUMENTOIMPRIMIBLE SOBREESCRITAS
 
 
        #region PROPIEDADES VARIAS
 

        public int _NumeroLibros
        {
            get
            {
                return this._LineasLegalizacionLibros._Items.Where(x => !string.IsNullOrWhiteSpace(x._RutaArchivo)).Count();
            }
        }
 

        public new string _Error_Message
        {
            get { return _cError_message; }
            set { _cError_message = value; }
        }
        private string _cError_message = "";
 

        public string _Warning_Message
        {
            get { return _cWarning_Message; }
            set { this._cWarning_Message = value; }
        }
        private string _cWarning_Message = "";
 

        public string _Error_Message_Linea
        {
            get { return _cError_Message_Linea; }
            set
            {
                _cError_Message_Linea = value;
 
                if (!string.IsNullOrWhiteSpace(_cError_Message_Linea))
                {
                    if (this._Error_Message_Linea_After != null)
                        this._Error_Message_Linea_After(_cError_Message_Linea);
                }
            }
        }
        private string _cError_Message_Linea = "";
 

        public LineasLegalizacionLibros _LineasLegalizacionLibros
        {
            get
            {
                return (LineasLegalizacionLibros)this.detalleDocumento;
            }
        }
 

        public override string _Nombre
        {
            get { return "LegalizaciónLibros."+this._lcAny.Trim();  }
            set
            {
            }
        }
        

        public TipoImpresion _TipoImpresion = TipoImpresion.SolicitudLegalizacion;
 
 
        #endregion PROPIEDADES VARIAS
 
 
        #region PROPIEDADES SOBREESCRITAS DE DOCUMENTOBASE
 

        public override bool _Solo_Lectura
        {
            get
            {
                // Continuo haciendo el control sobre la base por si añaden algo de código más que no tengamos aquí.
                //
                bool llLectura = base._Solo_Lectura;
                if (!llLectura)
                {
                    // Caso de que en la base no haya restringido el acceso, aplico el código propio aquí.
                    //
                    formul._TiposAccesosPantalla lnSoloLectura = this._oUsuario._Acceso(this._Pantalla);
                    llLectura = this._EnUso ||
                                    lnSoloLectura == formul._TiposAccesosPantalla.Denegado ||
                                    lnSoloLectura == formul._TiposAccesosPantalla.SoloLectura;
                }
 
                return llLectura;
            }
        }
 
 
        #endregion PROPIEDADES SOBREESCRITAS DE DOCUMENTOBASE
 
 
        #endregion PROPIEDADES PÚBLICAS
 
 
        #region CONSTRUCTORES
 

        public LegalizacionLibros() : this( Convert.ToString(EW_GLOBAL._GetVariable("wc_any")), 
                                            new LegalizacionLibrosDA())
        {
        }

        public LegalizacionLibros(string tcEjercicio) : this(tcEjercicio, new LegalizacionLibrosDA())
        {
        }

        public LegalizacionLibros(ILegalizacionLibrosDA legalizacionLibrosDA) : 
               this(Convert.ToString(EW_GLOBAL._GetVariable("wc_any")), new LegalizacionLibrosDA())
        {
        }

        public LegalizacionLibros(string tcEjercicio, ILegalizacionLibrosDA legalizacionLibrosDA) : 
                             base(legalizacionLibrosDA)
        {
            if (legalizacionLibrosDA == null)
            {
                throw new ArgumentNullException(nameof(legalizacionLibrosDA), "El parámetro de acceso a datos legalizacionLibrosDA no puede tener valor null.");
            }
 
            // Tareas a realizar en el constructor del objeto LegalizacionLibros
            //
            this.legalizacionLibrosConstructor();
 
            // Asignación del ejercicio lo cual ya acaba desenacadenando toda la carga del objeto 
            // LegalizacionLibros entero. Si llega un "" no cargaré nada.
            //
            if (!string.IsNullOrWhiteSpace(tcEjercicio))
            {
                if (this._Comprobar_Existe_Documento(tcEjercicio))
                {
                    this._Numero = tcEjercicio.Trim().PadRight(8, ' ');
 
                    this._LineasLegalizacionLibros._Load();
                }
            }
 
            return;
        }
 

        private void legalizacionLibrosConstructor()
        {
            // No está permitido utilizar objetos de negocio de LegalizacionLibros en empresas consolidadas.
            //
            if (!this._lEmpresaNormal)
                return;
 
            // Pensar que el método Inicializar() de la clase se ejecuta antes de llegar aquí pues lo llama la clase base 
            // 'DocumentoBase' en su constructor lo cual ocurre antes de llegar aquí.
 
 
            // Programar evento para que al cambiar el estado del mantenimiento, cambie también el estado
            // del documento.
            //
            this._Mantenimiento_Estado_Change += this.legalizacionLibros_Actualizar_Estado_Documento;
 
            // Declaración de la condición para impedir que mediante navegación se pueda acceder a una legalización de otra empresa.
            // Si bien en el formulario de legalización de libros no se permite la navegación, ponemos el control para asegurar por si algún día
            // se activa esta posibilidad.
            //
            this.Navegacion._Condicion = "EMPRESA=" + this._dataAccessLegalizacionLibros.SQLString(this._cEmpresa);
 
            return;
        }
 
 
        #endregion CONSTRUCTORES
 
 
        #region MÉTODOS PROTECTED OVERRIDE SOBREESCRITOS DE CLASE BASE 'DOCUMENTOBASE'
 

        protected override void Inicializar()
        {
            // Asignamos las propiedades para el mantenimiento.
            //
            this._Clave = "EMPRESA,NUMERO";
            this._DataBase = "COMUNES";
            this._Tabla = "C_LEGLBR";
            this._TituloMantenimiento = "Legalización de libros";
            this._TituloCabecera = "Legalización de libros";
            this._TituloMenu = "Legalizacion de libros";
            this._Campo_Nombre = "EMP_NOM";
            this._Browser_Campos = "";
            this._Browser_Titulos_Campos = "";
            this._Browser_Campo_Predet = "";
 
 
            this._Pantalla = "LEGALIBR";
            this._FormManteBaseType = typeof(frmLegalizacionLibros);
 
            this._DetalleDocumentoType = typeof(LineasLegalizacionLibros);
            this._TypeLinea = typeof(LineasLegalizacionLibros.LineaLegalizacionLibros);
 
            this._ReportTitlePreview = this._TituloMantenimiento;
            this._ReportBase = "DocumentoLegalizacion";
 
            return;
        }
 

        protected override void AsignarValoresClave()
        {
            if (string.IsNullOrWhiteSpace(this._Empresa))
                this._Empresa = this._cEmpresa;
 
            return;
        }
 
 
        #endregion MÉTODOS PROTECTED OVERRIDE SOBREESCRITOS DE CLASE BASE 'DOCUMENTOBASE'
 
 
        #region MÉTODOS PUBLIC OVERRIDE SOBREESCRITOS DE CLASE BASE 'DOCUMENTOBASE'
 

        [ExcludeFromCodeCoverage]
        public override void _Show()
        {
            // Lo asocio a la propiedad _FormMante de negocio pues así se sabe internamente
            // que negocio está ligado a visual.
            //
            this._FormMante = new frmLegalizacionLibros(this);
            this._FormMante._Show();
 
            if (!string.IsNullOrWhiteSpace(this._Codigo))
            {
                if (this._FormMante != null)
                    this._FormMante._Cargar_Documento();
            }
 
            return;
        }
 

        [ExcludeFromCodeCoverage]
        public override bool _Show_Print(int tnAbrirEn = 1)
        {
            return true;
        }
 

        public override Dictionary<string, object> _Obtener_Filtros_SageReports(Dictionary<string, object> tdicParametros = null)
        {
  
            Dictionary<string, object> ldicFiltros = new Dictionary<string, object>();
 
            switch (this._TipoImpresion)
            {
                case TipoImpresion.SolicitudLegalizacion:
                    
                    // En este report toda la información la tenemos colocada en la banda detalle del report, con un único registro en el que se
                    // mostrarán todos los campos. No hay banda de cabecera, por tanto, no hay filtros de cabecera.
                    //
 
                    break;
 
                case TipoImpresion.CertificadoFirmas:
 
                    // Datos cabecera report, se imprimen estos datos en cabecera y luego para cada linea de libro se imprime una serie de campos y el
                    // código de barras de la firma en formato EAN.
                    //
                    ldicFiltros.Add("wc_nomape1ape2_empresario", this._NombreEmpresario.Trim() + " " + this._Apellido1Empresario.Trim() + this._Apellido2Empresario.Trim());
                    ldicFiltros.Add("wc_cif_empresario", this._CifEmpresario.Trim());
                    ldicFiltros.Add("wc_direccion_empresario", this._DireccionEmpresario.Trim());
                    ldicFiltros.Add("wc_ciudad_empresario", this._CiudadEmpresario.Trim());
                    ldicFiltros.Add("wc_codpos_empresario", this._CodposEmpresario.Trim());
                    ldicFiltros.Add("wc_provincia_empresario", this._ProvinciaEmpresario.Trim());
                    ldicFiltros.Add("wc_fax_empresario", this._FaxEmpresario.Trim());
                    ldicFiltros.Add("wc_telefono_empresario", this._TelefonoEmpresario.Trim());
 
                    string lcFechaEnDtos = this.getDtosFecha(this._Fecha);
                    if (!string.IsNullOrWhiteSpace(lcFechaEnDtos))
                        lcFechaEnDtos = lcFechaEnDtos.Substring(0, 2) + " " + lcFechaEnDtos.Substring(2, 2) + " " + lcFechaEnDtos.Substring(4);
                    else
                        lcFechaEnDtos = "";
                    ldicFiltros.Add("wc_fecha_socilitud", lcFechaEnDtos.Trim());
 
                    ldicFiltros.Add("wc_tomo_registro", this._NumeroTomoRegistro.Trim());
                    ldicFiltros.Add("wc_folio_registro", this._NumeroFolioRegistro.Trim());
                    ldicFiltros.Add("wc_hoja_registro", this._NumeroHojaRegistro.Trim());
                    ldicFiltros.Add("wc_otros_registro", this._OtrosRegistroMercantil.Trim());
                    ldicFiltros.Add("wc_tiporebpub_registro", this._TipoRegistroMercantil.Trim());
                    ldicFiltros.Add("wc_irus_registro", this._IRUS.Trim());
 
                    ldicFiltros.Add("wc_numlibros", Convert.ToString(this._NumeroLibros));
 
                    break;
            }
 
            return ldicFiltros;
        }
 

        public override DataTable _Obtener_Datos_SageReports(Dictionary<string, object> tdicParametros = null)
        {
            DataTable loDt = new DataTable();
 
            switch (this._TipoImpresion)
            {
                case TipoImpresion.SolicitudLegalizacion:
 
                    // Haremos como si el report fuera de un solo registro de detalle y todo lo que colocariamos en cabecera del report lo colocamos
                    // en detalle, siguiente consejo de Jose Sevillano.
                    //
 
                    // Creamos la estructura del DataTable que alimentará el detalle del report (detalle de una única linea).
 
                    // Registro mercantil.
                    //
                    loDt.Columns.Add("registro_mercantil", typeof(String)).Caption = "Registro mercantil";
                        
                    // Datos varios.
                    //
                    loDt.Columns.Add("solicita_retencion", typeof(String)).Caption = "Solicita retención";
                    loDt.Columns.Add("fecha_solicitud", typeof(String)).Caption = "Fecha solicitud";
                    loDt.Columns.Add("num_libros", typeof(int)).Caption = "Número libros";
 
                    // Empresario.
                    //
                    loDt.Columns.Add("nombre_empresario", typeof(String)).Caption = "Nombre empresario";
                    loDt.Columns.Add("cif_empresario", typeof(String)).Caption = "Cif empresario";
                    loDt.Columns.Add("direccion_empresario", typeof(String)).Caption = "Dirección empresario";
                    loDt.Columns.Add("ciudad_empresario", typeof(String)).Caption = "Ciudad empresario";
                    loDt.Columns.Add("codpos_empresario", typeof(String)).Caption = "Codpos empresario";
 
                    // Presentador
                    //
                    loDt.Columns.Add("nombre_presentador", typeof(String)).Caption = "Nombre presentador";
                    loDt.Columns.Add("cif_presentador", typeof(String)).Caption = "Cif presentador";
                    loDt.Columns.Add("direccion_presentador", typeof(String)).Caption = "Direccion presentador";
                    loDt.Columns.Add("ciudad_presentador", typeof(String)).Caption = "Ciudad presentador";
                    loDt.Columns.Add("codpos_presentador", typeof(String)).Caption = "C.Postal presentador";
                    loDt.Columns.Add("provincia_presentador", typeof(String)).Caption = "Provincia presentador";
                    loDt.Columns.Add("fax_presentador", typeof(String)).Caption = "Fax presentador";
                    loDt.Columns.Add("telefono_presentador", typeof(String)).Caption = "Teléfono presentador";
                    loDt.Columns.Add("email_presentador", typeof(String)).Caption = "Email presentador";
 
                    // Creo un registro para el report y le relleno los datos.
                    //
 
                    DataRow loRow = loDt.NewRow();
                    loRow["registro_mercantil"] = Convert.ToString(this._RegistroMercantil.Trim());
                    loRow["solicita_retencion"] = this._SolicitaRetencion ? "SI" : "NO";
 
                    string lcFechaEnDtos = this.getDtosFecha(this._Fecha);
                    if (!string.IsNullOrWhiteSpace(lcFechaEnDtos))
                        loRow["fecha_solicitud"] = lcFechaEnDtos.Substring(0, 2) + " " + lcFechaEnDtos.Substring(2, 2) + " " + lcFechaEnDtos.Substring(4);
                    else
                        loRow["fecha_solicitud"] = "";
 
                    loRow["num_libros"] = Convert.ToInt32(this._NumeroLibros);
 
                    loRow["nombre_empresario"] = this._NombreEmpresario.Trim() + " " + this._Apellido1Empresario.Trim() + " " + this._Apellido2Empresario.Trim();
                    loRow["cif_empresario"] = this._CifEmpresario.Trim();
                    loRow["direccion_empresario"] = this._DireccionEmpresario.Trim();
                    loRow["ciudad_empresario"] = this._CiudadEmpresario.Trim();
                    loRow["codpos_empresario"] = this._CodposEmpresario.Trim();
 
                    loRow["nombre_presentador"] = this._NombrePresentador.Trim() + " " + this._Apellido1Presentador.Trim() + " " + this._Apellido2Presentador.Trim();
                    loRow["cif_presentador"] = this._CifPresentador.Trim();
                    loRow["direccion_presentador"] = this._DireccionPresentador.Trim();
                    loRow["ciudad_presentador"] = this._CiudadPresentador.Trim();
                    loRow["codpos_presentador"] = this._CodposPresentador.Trim();
                    loRow["provincia_presentador"] = this._ProvinciaPresentador.Trim();
                    loRow["fax_presentador"] = this._FaxPresentador.Trim();
                    loRow["telefono_presentador"] = this._TelefonoPresentador.Trim();
                    loRow["email_presentador"] = this._EmailPresentador.Trim();
 
                    loDt.Rows.Add(loRow);
 
                    break;
 
                case TipoImpresion.CertificadoFirmas:
 
                    loDt.Columns.Add("tipo_libro", typeof(String)).Caption = "Tipo libro";
                    loDt.Columns.Add("num_libro", typeof(int)).Caption = "Nº libro";
                    loDt.Columns.Add("fec_apertura", typeof(String)).Caption = "Fecha apert.";
                    loDt.Columns.Add("fec_cierre", typeof(String)).Caption = "Fecha cierre";
                    loDt.Columns.Add("firma", typeof(String)).Caption = "Firma";
 
                    foreach (LineasLegalizacionLibros.LineaLegalizacionLibros loLinea in this._LineasLegalizacionLibros._Items)
                    {
                        DataRow loRowLibro = loDt.NewRow();
 
                        loRowLibro["tipo_libro"] = loLinea._TipoLibro;
                        loRowLibro["num_libro"] = Convert.ToInt32(loLinea._NumLibro);
                        if (loLinea._FecApertura != null)
                            loRowLibro["fec_apertura"] = Convert.ToDateTime(loLinea._FecApertura).ToShortDateString();
                        else
                            loRowLibro["fec_apertura"] = "";
 
                        if (loLinea._FecCierre != null)
                            loRowLibro["fec_cierre"] = Convert.ToDateTime(loLinea._FecCierre).ToShortDateString();
                        else
                            loRowLibro["fec_cierre"] = "";
 
                        loRowLibro["firma"] = loLinea._Firma;
 
                        loDt.Rows.Add(loRowLibro);
                    }
                    
                    break;
            }
 
            return loDt;
        }
 

        public override bool _Comprobar_Existe_Documento(string tcEjercicio)
        {
            return this._dataAccessLegalizacionLibros._Comprobar_Existe_Documento(this._DataBase, this._Tabla, this._cEmpresa, tcEjercicio);
        }
 

        [ExcludeFromCodeCoverage]
        public override bool _Delete()
        {
            // Como en legalización de libros siempre tendremos cargado un ejercicio y de momento no permitimos borrar, eliminamos todo el código que
            // pudiera implementarse aquí, para prevenir que la clase base DocumentoBase ejecute su propio código _Delete()
 
            return true;
        }
 
 
        #endregion MÉTODOS PÚBLIC OVERRIDE SOBREESCRITOS DE CLASE BASE 'DOCUMENTOBASE'
 
 
        #region MÉTODOS PROTECTED OVERRIDE SOBREESCRITOS DE CLASE BASE 'EWMANTE'
 

        public override bool _Save_Before()
        {
            if (!string.IsNullOrWhiteSpace(this._Numero))
            {
                // Para que no guarde hora ni minutos en la fecha.
                //
                if (this._Fecha.Hour != 0 || this._Fecha.Minute != 0 || this._Fecha.Second != 0)
                {
                    DateTime ldFecha = new DateTime(this._Fecha.Year, this._Fecha.Month, this._Fecha.Day);
                    this._Fecha = ldFecha;
                }
 
                // Guardo en la propiedad que hace referencia al campo físico de nº de libros presentados, el nº de libros que tenemos actualmente en la 
                // legalización para que al hacer el _Save() guarde ese número en la base de datos.
                //
                this._NumeroLibrosPresentados = this._NumeroLibros;
            }
 
            return true;
        }
 
 
        #endregion MÉTODOS PROTECTED OVERRIDE SOBREESCRITOS DE CLASE BASE 'EWMANTE'
 
 
        #region MÉTODOS PRIVADOS
 
 
        #region MÉTODOS PRIVADOS PARA IMPORTAR LEGALIZACION DE FICHERO ZIP
 

        private bool algunDatoDeclaradoDatosPresentacion()
        {
            // Empresario
            //
            if (!string.IsNullOrWhiteSpace(this._NombreEmpresario + this._Apellido1Empresario + this._Apellido2Empresario + this._CifEmpresario))
                return true;
 
            if (!string.IsNullOrWhiteSpace(this._DireccionEmpresario + this._CodposEmpresario + this._CiudadEmpresario + this._ProvinciaEmpresario))
                return true;
 
            if (!string.IsNullOrWhiteSpace(this._TelefonoEmpresario + this._FaxEmpresario))
                return true;
 
 
            // Presentador
            //
            if (!string.IsNullOrWhiteSpace(this._NombrePresentador + this._Apellido1Presentador + this._Apellido2Presentador + this._CifPresentador))
                return true;
 
            if (!string.IsNullOrWhiteSpace(this._DireccionPresentador + this._CodposPresentador + this._CiudadPresentador + this._ProvinciaPresentador))
                return true;
 
            if (!string.IsNullOrWhiteSpace(this._TelefonoPresentador + this._FaxPresentador + this._EmailPresentador))
                return true;
 
 
            // Datos registrales
            //
            if (!string.IsNullOrWhiteSpace(this._CodigoRegistro + this._NumeroTomoRegistro + this._Apellido2Presentador + this._CifPresentador))
                return true;
 
            if (!string.IsNullOrWhiteSpace(this._NumeroFolioRegistro + this._NumeroHojaRegistro + this._TipoRegistroMercantil + this._OtrosRegistroMercantil))
                return true;
 
            if (!string.IsNullOrWhiteSpace(this._RegistroMercantil))
                return true;
 
            if (!string.IsNullOrWhiteSpace(this._IRUS))
                return true;
 
            return false;
        }
 

        [ExcludeFromCodeCoverage]
        private bool seleccionarArchivoZipValido(out string tcRutaArchivoZip)
        {
            string lcCarpetaImportacion = "";
            tcRutaArchivoZip = "";
 
            OpenFileDialog openFileDialog1 = new OpenFileDialog();
            openFileDialog1.Filter = "Archivos Zip (*.zip)|*.zip|Todos los archivos (*.*)|*.*";
            openFileDialog1.FilterIndex = 0;
            openFileDialog1.RestoreDirectory = true;
            if (!string.IsNullOrWhiteSpace(this._RutaGeneracion))
                openFileDialog1.InitialDirectory = this._RutaGeneracion;
 
            if (openFileDialog1.ShowDialog() != DialogResult.OK)
            {
                this._Error_Message = "No ha seleccionado ningún fichero ZIP de legalizacíón para importar.";
                return false;
            }
 
            if (string.IsNullOrWhiteSpace(openFileDialog1.FileName))
            {
                this._Error_Message = "No ha seleccionado ningún fichero ZIP de legalizacíón para importar.";
                return false;
            }
 
            if (Path.GetExtension(openFileDialog1.FileName).Trim().ToUpper() != ".ZIP")
            {
                this._Error_Message = "El archivo de legalización a importar debe ser de tipo ZIP.";
                return false;
            }
 
            // Verificar que el nombre del archivo sea correcto.
            if (!this.esNombreArchivoZipValido(openFileDialog1.FileName))
                return false;
 
            // Crea la carpeta de importación si no existe. Si existe se asegura de que esté vacía, si no lo está borra todo para 
            // asegurarse de que esté vacía. Si hay algún problema con todo lo anterior ya no se continúa. Es requesito tener esta
            // carpeta de importación completamente vacía pues el ZIP se copiará allá y se decomprimirá allá.
            //
            if (!this.asegurarCarpetaImportacionVacia(out lcCarpetaImportacion))
                return false;
 
            tcRutaArchivoZip = openFileDialog1.FileName.Trim();
 
            string lcNombreFicheroDestino = Path.Combine(lcCarpetaImportacion, Path.GetFileName(tcRutaArchivoZip));
 
            File.Copy(tcRutaArchivoZip, lcNombreFicheroDestino);
 
            if (!File.Exists(lcNombreFicheroDestino))
            {
                this._Error_Message = "No se ha podido copiar el fichero ZIP de legalización '" + tcRutaArchivoZip + "' a la carpeta de importación '" + lcCarpetaImportacion + "'.";
                return false;
            }
 
            if (!this.verificarRecuperarArchivoZip(lcNombreFicheroDestino, false))
            {
                // El mensaje de error ya se generó dentro del método anterior.
                return false;
            }
 
            return true;
        }
 

        private bool esNombreArchivoZipValido(string tcRutaArchivoZip)
        {
            int lnCodRegistro = -2;
 
            string lcNombreArchivo = Path.GetFileNameWithoutExtension(tcRutaArchivoZip);
            if (lcNombreArchivo.Substring(0, 2) != "LL")
            {
                this._Error_Message = "No es un fichero de legalización válido, debe comenzar por LL";
                return false;
            }
 
            if (lcNombreArchivo.Length < 7)
            {
                this._Error_Message = "No es un fichero de legalización válido, debe comenzar por LL y tener 5 dígitos numéricos a continuación con el código de registro.";
                return false;
            }
 
            if (!int.TryParse(lcNombreArchivo.Substring(2, 5), out lnCodRegistro) || lnCodRegistro <= 0)
            {
                this._Error_Message = "No es un fichero de legalización válido, debe comenzar por LL y tener 5 dígitos numéricos a continuación con el código de registro.";
                return false;
            }
 
            return true;
        }
 

        [ExcludeFromCodeCoverage]  
        private bool verificarRecuperarArchivoZip(string tcArchivoZipImportar, bool tlActualizar)
        {
            bool llOk = true;
 
            if (string.IsNullOrWhiteSpace(tcArchivoZipImportar))
                return false;
 
            string lcCarpetaExtraccion = Path.GetDirectoryName(tcArchivoZipImportar);
 
            try
            {
                using (ZipFile zip = new ZipFile(tcArchivoZipImportar))
                {
                    zip.Comment = "";
                    zip.Encryption = EncryptionAlgorithm.None;
                    zip.Password = "";
                    zip.CompressionMethod = CompressionMethod.Deflate;
                    zip.UseZip64WhenSaving = Zip64Option.Never;
                    
                    zip.ExtractAll(lcCarpetaExtraccion);
 
                    string lcArchivoNombresTxt = Path.Combine(lcCarpetaExtraccion, "NOMBRES.TXT");
                    string lcArchivoDatosTxt = Path.Combine(lcCarpetaExtraccion, "DATOS.TXT");
 
                    if (!File.Exists(lcArchivoNombresTxt))
                    {
                        this._Error_Message = "Al descomprimir el fichero ZIP de legalización '" + tcArchivoZipImportar + "' en la carpeta '" + lcCarpetaExtraccion + "' no se ha obtenido un fichero NOMBRES.TXT." +
                                               Environment.NewLine + Environment.NewLine + "EL fichero ZIP de legalización es incorrecto."+
                                               Environment.NewLine + Environment.NewLine + "Imposible realizar importación de fichero ZIP de legalización.";
                        return false;
                    }
 
                    
                    if (!File.Exists(lcArchivoDatosTxt))
                    {
                        this._Error_Message = "Al descomprimir el fichero ZIP de legalización '" + tcArchivoZipImportar + "' en la carpeta '" + lcCarpetaExtraccion + "' no se ha obtenido un fichero DATOS.TXT." +
                                               Environment.NewLine + Environment.NewLine + "El fichero ZIP de legalización es incorrecto."+
                                               Environment.NewLine + Environment.NewLine + "Imposible realizar importación de fichero ZIP de legalización.";
                        return false;
                    }
 
                    // Verificar que todos los archivos que hay en NOMBRES.TXT existen.
                    //
                    StreamReader archivoNombresTxt = new StreamReader(lcArchivoNombresTxt);
                    string lcNombreFichero = "";
                    string lcRutaCompletaFichero = "";
 
                    while ((lcNombreFichero = archivoNombresTxt.ReadLine()) != null)
                    {
                        lcRutaCompletaFichero = Path.Combine(lcCarpetaExtraccion, lcNombreFichero);
                        if (!File.Exists(lcArchivoDatosTxt))
                        {
                            this._Error_Message = "Al descomprimir el fichero ZIP de legalización '" + tcArchivoZipImportar + "' en la carpeta '" + lcCarpetaExtraccion + "' no se ha obtenido el fichero '"+ lcNombreFichero + "'" + 
                                                  "tal como consta en el archivo NOMBRES.TXT obtenido del fichero ZIP de la legalización."+Environment.NewLine + Environment.NewLine + "El fichero ZIP de legalización es incorrecto." +
                                                  Environment.NewLine + Environment.NewLine + "Imposible realizar importación de fichero ZIP de legalización.";
                            llOk = false;
                            break;
                        }
                    }
 
                    archivoNombresTxt.Close();
 
                    if (!llOk)
                        return false;
 
 
                    // Volcar todos los datos hallados en el archivo ZIP a la legalización.
                    //
                    if (tlActualizar)
                    {
                        // Vaciar todos los datos del apartado de Presentacion.
                        //
                        if (!this.importarVaciarCamposPresentacion())
                            return false;
 
                        // Cargos datos de presentación.
                        //
                        if (!this.importarCargarCamposPresentacion(lcArchivoDatosTxt))
                            return false;
 
                        // Cargos datos de libros presentados.
                        //
                        if (!this.importarCargarLibrosPresentados(lcArchivoNombresTxt, lcArchivoDatosTxt))
                            return false;
                    }
                }
            }
            catch (Exception e)
            {
                this._Error_Message = "No se ha podido " + (tlActualizar ? "importar correctamente el" : "verificar el formato del") + " fichero ZIP de legalización '" + tcArchivoZipImportar + "'." +
                                      Environment.NewLine + Environment.NewLine + e.Message + Environment.NewLine + Environment.NewLine +
                                      "Imposible realizar importación de fichero ZIP de legalización.";
                llOk = false;
            }
 
            return llOk;
        }
 

        [ExcludeFromCodeCoverage] 
        private bool asegurarCarpetaImportacionVacia(out string tcCarpetaImportacion)
        {
            string lcRutaCompletaExportacion = this._RutaGeneracionCompleta();
 
            tcCarpetaImportacion = Path.Combine(lcRutaCompletaExportacion, "Import");
 
            if (!Directory.Exists(tcCarpetaImportacion))
                Directory.CreateDirectory(tcCarpetaImportacion);
 
            if (!Directory.Exists(tcCarpetaImportacion))
            {
                this._Error_Message = "No se ha podido crear la carpeta de importación '" + tcCarpetaImportacion + "'." + Environment.NewLine + Environment.NewLine +
                                      "Imposible realizar importación de fichero ZIP de legalización.";
                return false;
            }
 
            int lnNumFicheros = 0;
            if (this.algunFicheroEnRutaGeneracion(tcCarpetaImportacion, out lnNumFicheros))
            {
                if (!this.borrarTodosArchivosRuta(tcCarpetaImportacion))
                {
                    this._Error_Message = "La carpeta destino de la importación ('" + tcCarpetaImportacion + "') ya contiene ficheros y no ha sido " +
                                          "posible eliminarlos todos." + Environment.NewLine + Environment.NewLine + "Imposible realizar importación de fichero ZIP " +
                                          "de legalización.";
                    return false;
                }
            }
 
            return true;
        }
 

        private bool algunFicheroEnRutaGeneracion(string tcRutaGeneracion, out int tnNumFicheros)
        {
            bool llExistenFicheros = false;
 
            string[] laFicheros = Directory.GetFiles(tcRutaGeneracion);
            tnNumFicheros = laFicheros.Count();
 
            llExistenFicheros = (tnNumFicheros > 0);
 
            return llExistenFicheros;
        }
 

        [ExcludeFromCodeCoverage]  
        private bool borrarTodosArchivosRuta(string tcRuta)
        {
            bool llTodosArchivosBorrados = true;
 
            try
            {
                string[] laFicheros = Directory.GetFiles(tcRuta);
                foreach (string lcFichero in laFicheros)
                {
                    if (File.Exists(lcFichero))
                    {
                        File.Delete(lcFichero);
                        if (File.Exists(lcFichero))
                        {
                            llTodosArchivosBorrados = false;
                            break;
                        }
                    }
                }
            }
            catch (Exception)
            {
                llTodosArchivosBorrados = false;
            }
 
            return llTodosArchivosBorrados;
        }
 

        private bool importarVaciarCamposPresentacion()
        {
            bool llOk = true;
 
            try
            {
                // Cabecera
                //
                this._Fecha = DateTime.Today;
                this._SolicitaRetencion = false;
 
                // Datos empresario
                //
                this._NombreEmpresario = "";
                this._Apellido1Empresario = "";
                this._Apellido2Empresario = "";
                this._CifEmpresario = "";
                this._DireccionEmpresario = "";
                this._CodposEmpresario = "";
                this._CiudadEmpresario = "";
                this._ProvinciaEmpresario = "";
                this._TelefonoEmpresario = "";
                this._FaxEmpresario = "";
 
                // Datos presentador
                //
                this._NombrePresentador = "";
                this._Apellido1Presentador = "";
                this._Apellido2Presentador = "";
                this._CifPresentador = "";
                this._DireccionPresentador = "";
                this._CodposPresentador = "";
                this._CiudadPresentador = "";
                this._ProvinciaPresentador = "";
                this._TelefonoPresentador = "";
                this._FaxPresentador = "";
                this._EmailPresentador = "";
 
                // Datos registrales
                //
                this._CodigoRegistro = "";
                this._NumeroTomoRegistro = "";
                this._NumeroLibroRegistro = "";
                this._NumeroSeccionRegistro = "";
                this._NumeroFolioRegistro = "";
                this._NumeroHojaRegistro = "";
                this._TipoRegistroMercantil = "";
                this._OtrosRegistroMercantil = "";
                this._RegistroMercantil = "";
                this._IRUS = "";
            }
            catch (Exception e)
            {
                this._Error_Message = "Se ha producido un error el vaciar los campos de presentación de la legalización." + Environment.NewLine + Environment.NewLine +
                                      "Mensaje de error: " + e.Message;
                llOk = false;
            }
 
            return llOk;
        }
 

        [ExcludeFromCodeCoverage]  
        private bool importarCargarCamposPresentacion(string tcRutaFicheroDatosTxt)
        {
            bool llOk = true;
 
            try
            {
                // Cargar en esta lista de string las lineas del fichero.
                //
                List<string> lstFileLines = File.ReadAllLines(tcRutaFicheroDatosTxt).ToList();
 
                // Datos cabecera.
                //
                this.importarCargarCamposPresentacion_Cabecera(lstFileLines);
 
                // Datos empresario.
                //
                this.importarCargarCamposPresentacion_Empresario(lstFileLines);
 
                // Datos presentador.
                //
                this.importarCargarCamposPresentacion_Presentador(lstFileLines);
 
                // Datos registrales.
                //
                this.importarCargarCamposPresentacion_DatosRegistrales(lstFileLines);
            }
            catch (Exception e)
            {
                this._Error_Message = "Se ha producido un error al cargar los campos de presentación de la legalización con los procedentes del archivo ZIP " +
                                      "que se está importando." + Environment.NewLine + Environment.NewLine +"Mensaje de error: " + e.Message;
                llOk = false;
            }
 
            return llOk;
        }
 

        private void importarCargarCamposPresentacion_Cabecera(List<string> tlstLineas)
        {
            // Obtener fecha.
            //
            string lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "101");
            DateTime? ldtFecha = this.setDtosToFecha(lcValorCampo);
            if (ldtFecha == null)
                this._Fecha = DateTime.Today;
            else
                this._Fecha = Convert.ToDateTime(ldtFecha);
 
            // Solicita retencion SI/NO
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "401");
            this._SolicitaRetencion = lcValorCampo.Trim().ToUpper() == "SI";
 
            return;
        }
 

        private void importarCargarCamposPresentacion_Empresario(List<string> tlstLineas)
        {
            string lcValorCampo = "";
 
            // Nombre empresario.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "102");
            this._NombreEmpresario = lcValorCampo;
 
            // Apellido 1 empresario.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "103");
            this._Apellido1Empresario = lcValorCampo;
 
            // Apellido 2 empresario.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "104");
            this._Apellido2Empresario = lcValorCampo;
 
            // CIF empresario.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "105");
            this._CifEmpresario = lcValorCampo;
 
            // Direccion empresario.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "106");
            this._DireccionEmpresario = lcValorCampo;
 
            // Ciudad empresario.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "107");
            this._CiudadEmpresario = lcValorCampo;
 
            // Codpos empresario.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "108");
            this._CodposEmpresario = lcValorCampo;
 
            // Código de provincia empresario (2 dígitos)
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "109");
            this._ProvinciaEmpresario = FUNCTIONS._GetProvinciaFromCodigoProvincia(lcValorCampo);
 
            // Fax empresario.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "110");
            this._FaxEmpresario = lcValorCampo;
 
            // Telefono empresario.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "111");
            this._TelefonoEmpresario = lcValorCampo;
 
            return;
        }
 
        
        private void importarCargarCamposPresentacion_Presentador(List<string> tlstLineas)
        {
            string lcValorCampo = "";
 
            // Nombre presentador.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "301");
            this._NombrePresentador = lcValorCampo;
 
            // Apellido 1 presentador.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "302");
            this._Apellido1Presentador = lcValorCampo;
 
            // Apellido 2 presentador.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "303");
            this._Apellido2Presentador = lcValorCampo;
 
            // CIF presentador.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "304");
            this._CifPresentador = lcValorCampo;
 
            // Direccion presentador.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "305");
            this._DireccionPresentador = lcValorCampo;
 
            // Ciudad presentador.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "306");
            this._CiudadPresentador = lcValorCampo;
 
            // Codpos presentador.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "307");
            this._CodposPresentador = lcValorCampo;
 
            // Provincia presentador.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "308");
            this._ProvinciaPresentador = lcValorCampo;
 
            // Fax presentador.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "309");
            this._FaxPresentador = lcValorCampo;
 
            // Telefono presentador.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "310");
            this._TelefonoPresentador = lcValorCampo;
 
            // Email presentador.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "311");
            this._EmailPresentador = lcValorCampo;
 
            return;
        }
 

        private void importarCargarCamposPresentacion_DatosRegistrales(List<string> tlstLineas)
        {
            string lcValorCampo = "";
 
            // Código registro.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "112");
            this._CodigoRegistro = lcValorCampo;
 
            // Número tomo.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "201");
            this._NumeroTomoRegistro = lcValorCampo;
 
            // Número libro.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "202");
            this._NumeroLibroRegistro = lcValorCampo;
 
            // Número sección.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "203");
            this._NumeroSeccionRegistro = lcValorCampo;
 
            // Número folio.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "204");
            this._NumeroFolioRegistro = lcValorCampo;
 
            // Tipo registro mercantil.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "205");
            this._TipoRegistroMercantil = lcValorCampo;
 
            // Número hoja.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "206");
            this._NumeroHojaRegistro = lcValorCampo;
 
            // Otros registro mercantil.
            //
            lcValorCampo = this.importarGetCampoDatosTxt(tlstLineas, "207");
            this._OtrosRegistroMercantil = lcValorCampo;
 
            // Registro mercantil.
            //
            // Ojo que este campo de registro mercantil ni se exporta ni se importa, no viaja nunca en el fichero ZIP de legalización.
 
            return;
        }
 

        private string importarGetCampoDatosTxt(List<string> tlstLista, string codigoCampo)
        {
            string lcRegistroBuscado ="", lcValorCampo = "";
 
            lcRegistroBuscado = tlstLista.Where(x => x.Length >= codigoCampo.Length && x.Substring(0, codigoCampo.Length) == codigoCampo).FirstOrDefault();
 
            lcRegistroBuscado = lcRegistroBuscado.Trim();
 
            if (!string.IsNullOrWhiteSpace(lcRegistroBuscado) && lcRegistroBuscado.Length > codigoCampo.Length)
                lcValorCampo = lcRegistroBuscado.Substring(codigoCampo.Length);
 
            return lcValorCampo;
        }
 

        private int importarNumLiniasFicheroEnDatosTxt(List<string> tlstLista, string codigoCampo)
        {
            int lnNumLinias = tlstLista.Where(x => x.Length >= codigoCampo.Length && x.Substring(0, codigoCampo.Length) == codigoCampo).Count();
 
            return lnNumLinias;
        }
 

        [ExcludeFromCodeCoverage]  
        private bool importarCargarLibrosPresentados(string tcRutaFicheroNombresTxt, string tcRutaFicheroDatosTxt)
        {
            bool llOk = true;
 
            int lnLiniaFichero = 1, lnNumLineasFicheroEnDatosTxt = 0;
            string lcCodigoCampo = "", lcValorCampo = "", lcPrefijoCodigoCampo = "", lcNombreFichero = "", lcRutaCompletaFichero = "", lcCarpetaExtraccion = "";
            DateTime? ldtFecha = null;
 
            try
            {
                lcCarpetaExtraccion = Path.GetDirectoryName(tcRutaFicheroNombresTxt);
 
                // Cargar en esta lista de string las lineas del fichero DATOS.TXT que sera sobre la que trabajaremos para extraer los campos
                // que nos interesan de cada libro.
                //
                List<string> lstFileLinesDatosTxt = File.ReadAllLines(tcRutaFicheroDatosTxt).ToList();
 
                // Borrar todos los libros declarados y actualizo a la base de datos, antes de crear las nuevas lineas.
                //
                this._LineasLegalizacionLibros._Delete();
                this._LineasLegalizacionLibros._Save();
 
                StreamReader archivoNombresTxt = new StreamReader(tcRutaFicheroNombresTxt);
                while ((lcNombreFichero = archivoNombresTxt.ReadLine()) != null)
                {
                    lcRutaCompletaFichero = Path.Combine(lcCarpetaExtraccion, lcNombreFichero);
 
                    if (!File.Exists(lcRutaCompletaFichero))
                    {
                        this._Error_Message = "Al intentar actualizar los libros a la legalización no se ha detectado la existencia del fichero '" + lcNombreFichero + "' en la carpeta '" + lcCarpetaExtraccion + "' " +
                                              "tal como consta en el archivo NOMBRES.TXT obtenido del fichero ZIP de la legalización." + Environment.NewLine + Environment.NewLine + "El fichero ZIP de legalización es incorrecto." +
                                              Environment.NewLine + Environment.NewLine + "Imposible realizar importación de fichero ZIP de legalización.";
                        llOk = false;
                        break;
                    }
 
                    // Confirmamos que en el fichero DATOS.TXT existen las 6 lineas de información para este fichero (tipo, numlibro, fecha apert., fecha cierre, fecha cierre ant., huella)
                    lnNumLineasFicheroEnDatosTxt = this.importarNumLiniasFicheroEnDatosTxt(lstFileLinesDatosTxt, Convert.ToString(lnLiniaFichero).Trim().PadLeft(3, '0'));
                    if (lnNumLineasFicheroEnDatosTxt!=6)
                    {
                        this._Error_Message = "Al intentar actualizar los libros a la legalización no se ha detectado la existencia del fichero '" + lcNombreFichero + "' en la carpeta '" + lcCarpetaExtraccion + "' " +
                                              "tal como consta en el archivo NOMBRES.TXT obtenido del fichero ZIP de la legalización." + Environment.NewLine + Environment.NewLine + "El fichero ZIP de legalización es incorrecto." +
                                              Environment.NewLine + Environment.NewLine + "Imposible realizar importación de fichero ZIP de legalización.";
                        llOk = false;
                        break;
                    }
 
                    // Añado registro nuevo de linea de libro.
                    //
                    LineasLegalizacionLibros.LineaLegalizacionLibros loLinea = this._LineasLegalizacionLibros._NewItem();
 
                    lcPrefijoCodigoCampo = Convert.ToString(lnLiniaFichero).Trim().PadLeft(3, '0');
 
                    // Capto el tipo de fichero del fichero en curso que estoy recuperando.
                    //
                    lcCodigoCampo = lcPrefijoCodigoCampo + "01";
                    lcValorCampo = this.importarGetCampoDatosTxt(lstFileLinesDatosTxt, lcCodigoCampo);
                    loLinea._TipoLibroVisual = lcValorCampo;
 
                    // Capto el número de libro del fichero en curso que estoy recuperando.
                    //
                    lcCodigoCampo = lcPrefijoCodigoCampo + "02";
                    lcValorCampo = this.importarGetCampoDatosTxt(lstFileLinesDatosTxt, lcCodigoCampo);
                    loLinea._NumLibro = lcValorCampo;
 
                    loLinea._RutaArchivo = lcRutaCompletaFichero;
 
                    // Fecha de apertura del fichero en curso que estoy recuperando.
                    //
                    lcCodigoCampo = lcPrefijoCodigoCampo + "03";
                    lcValorCampo = this.importarGetCampoDatosTxt(lstFileLinesDatosTxt, lcCodigoCampo);
                    ldtFecha = this.setDtosToFecha(lcValorCampo);
                    if (ldtFecha == null)
                        loLinea._FecApertura = null;
                    else
                        loLinea._FecApertura = Convert.ToDateTime(ldtFecha);
 
                    // Fecha de cierre del fichero en curso que estoy recuperando.
                    //
                    lcCodigoCampo = lcPrefijoCodigoCampo + "04";
                    lcValorCampo = this.importarGetCampoDatosTxt(lstFileLinesDatosTxt, lcCodigoCampo);
                    ldtFecha = this.setDtosToFecha(lcValorCampo);
                    if (ldtFecha == null)
                        loLinea._FecCierre = null;
                    else
                        loLinea._FecCierre = Convert.ToDateTime(ldtFecha);
 
                    // Fecha de cierre anterior del fichero en curso que estoy recuperando.
                    //
                    lcCodigoCampo = lcPrefijoCodigoCampo + "05";
                    lcValorCampo = this.importarGetCampoDatosTxt(lstFileLinesDatosTxt, lcCodigoCampo);
                    ldtFecha = this.setDtosToFecha(lcValorCampo);
                    if (ldtFecha == null)
                        loLinea._FecCierreAnt = null;
                    else
                        loLinea._FecCierreAnt = Convert.ToDateTime(ldtFecha);
 
 
                    // Firma del fichero en curso que estoy recuperando.
                    //
                    lcCodigoCampo = lcPrefijoCodigoCampo + "06";
                    lcValorCampo = this.importarGetCampoDatosTxt(lstFileLinesDatosTxt, lcCodigoCampo);
                    loLinea._Firma = lcValorCampo;
 
                    // Pasamos a procesar el siguiente libro.
                    //
                    lnLiniaFichero++;
                }
 
                archivoNombresTxt.Close();
            }
            catch (Exception e)
            {
                this._Error_Message = "Se ha producido un error el cargar los libros procedentes del fichero ZIP de legalización." + Environment.NewLine + Environment.NewLine +
                                      "Mensaje de error: " + e.Message;
                llOk = false;
            }
 
            return llOk;
        }
 
 
        #endregion MÉTODOS PRIVADOS PARA IMPORTAR LEGALIZACION DE FICHERO ZIP
 
 
        #region MÉTODOS PRIVADOS PARA EXPORTAR LEGALIZACION A FICHERO ZIP
 

        private bool datosEmpresarioOk(ref string tcFaltaCampo)
        {
            if (string.IsNullOrWhiteSpace(this._NombreEmpresario))
            {
                tcFaltaCampo = "Nombre empresario";
                return false;
            }
 
 
            if (string.IsNullOrWhiteSpace(this._CifEmpresario))
            {
                tcFaltaCampo = "CIF empresario";
                return false;
            }
 
            if (string.IsNullOrWhiteSpace(this._DireccionEmpresario))
            {
                tcFaltaCampo = "Dirección empresario";
                return false;
            }
 
            if (string.IsNullOrWhiteSpace(this._CodposEmpresario))
            {
                tcFaltaCampo = "Código postal empresario";
                return false;
            }
 
            if (string.IsNullOrWhiteSpace(this._CiudadEmpresario))
            {
                tcFaltaCampo = "Ciudad empresario";
                return false;
            }
 
            if (string.IsNullOrWhiteSpace(this._ProvinciaEmpresario))
            {
                tcFaltaCampo = "Provincia empresario";
                return false;
            }
 
            return true;
        }
 

        private bool datosPresentadorOk(ref string tcFaltaCampo)
        {
            if (string.IsNullOrWhiteSpace(this._NombrePresentador))
            {
                tcFaltaCampo = "Nombre presentador";
                return false;
            }
 
 
            if (string.IsNullOrWhiteSpace(this._CifPresentador))
            {
                tcFaltaCampo = "CIF presentador";
                return false;
            }
 
            return true;
        }
 

        private bool datosRegistroOk(ref string tcFaltaCampo)
        {
            if (!string.IsNullOrWhiteSpace(this._IRUS)) // Customer Change Request 222922
            {
                if (string.IsNullOrWhiteSpace(this._TipoRegistroMercantil))
                {
                    tcFaltaCampo = "Tipo de registro público";
                    return false;
                }
                return true;
            }
 
            if (string.IsNullOrWhiteSpace(this._CodigoRegistro))
            {
                tcFaltaCampo = "Código de registro";
                return false;
            }
 
            // Task 167756, no se obliga a declarar nº libro, nº sección ni nº de hoja, por tanto no controlamos aquí estos campos.
            //
            if (string.IsNullOrWhiteSpace(this._NumeroTomoRegistro))
            {
                tcFaltaCampo = "Número de tomo registro";
                return false;
            }
 
            if (string.IsNullOrWhiteSpace(this._NumeroFolioRegistro))
            {
                tcFaltaCampo = "Número de folio registro";
                return false;
            }
             
            if (string.IsNullOrWhiteSpace(this._TipoRegistroMercantil))
            {
                tcFaltaCampo = "Tipo de registro público";
                return false;
            }
 
            if (string.IsNullOrWhiteSpace(this._RegistroMercantil))
            {
                tcFaltaCampo = "Registro mercantil de";
                return false;
            }
 
            return true;
        }
 
 

        [ExcludeFromCodeCoverage] 
        private bool exportarCopiarFicherosARutaGeneracion()
        {
            bool llOk = true;
 
            string lcRutaGeneracion = this._RutaGeneracionCompleta();
 
            try
            {
 
                string lcNombreFicheroOrigen = "", lcNombreFicheroDestino = "", lcExtensionFichero = "";
                string lcCheckSum = "";
                foreach (LineasLegalizacionLibros.LineaLegalizacionLibros loLinea in this._LineasLegalizacionLibros._Items)
                {
                    if (!string.IsNullOrWhiteSpace(loLinea._RutaArchivo))
                    {
                        lcNombreFicheroOrigen = loLinea._RutaArchivo.Trim();
                        lcExtensionFichero = Path.GetExtension(lcNombreFicheroOrigen);
                        lcNombreFicheroDestino = Path.Combine(lcRutaGeneracion, loLinea._TipoLibro.Trim() + "_" + loLinea._NumLibro.Trim() + lcExtensionFichero);
 
                        File.Copy(lcNombreFicheroOrigen, lcNombreFicheroDestino);
 
                        if (!File.Exists(lcNombreFicheroDestino))
                        {
                            this._Error_Message = "No se ha podido copiar el archivo '" + lcNombreFicheroOrigen + "' en la carpeta destino de generación '" + lcRutaGeneracion + "'.";
                            llOk = false;
                            break;
                        }
 
                        lcCheckSum = Criptografia.GenerateSHA256ToBase64String(lcNombreFicheroDestino);
                        if (string.IsNullOrWhiteSpace(lcCheckSum))
                        {
                            this._Error_Message = "No se ha podido obtener la firma SHA256 del archivo '" + lcNombreFicheroDestino + "'.";
                            llOk = false;
                            break;
 
                        }
                        loLinea._Firma = lcCheckSum;
                    }
                }
            }
            catch (Exception e)
            {
                this._Error_Message = "No se han podido copiar los archivos de los libros a la ruta de generación '" + lcRutaGeneracion + "'." +
                                      Environment.NewLine + Environment.NewLine + e.Message;
                                   
                llOk = false;
            }
 
            return llOk;
        }
 

        [ExcludeFromCodeCoverage]
        private bool exportarPrepararFicheroNombresTxt()
        {
            bool llOk = true;
            string lcRutaGeneracion = this._RutaGeneracionCompleta();
 
            try
            {
                string lcFicheroNombres = Path.Combine(lcRutaGeneracion, "NOMBRES.TXT");
 
                using (StreamWriter sw = File.CreateText(lcFicheroNombres))
                {
                    string lcExtensionFichero = "", lcNombreFicheroDestino = "";
                    foreach (LineasLegalizacionLibros.LineaLegalizacionLibros loLinea in this._LineasLegalizacionLibros._Items)
                    {
                        if (!string.IsNullOrWhiteSpace(loLinea._RutaArchivo))
                        {
                            lcExtensionFichero = Path.GetExtension(loLinea._RutaArchivo.Trim());
                            lcNombreFicheroDestino = loLinea._TipoLibro.Trim() + "_" + loLinea._NumLibro.Trim() + lcExtensionFichero;
                            sw.WriteLine(lcNombreFicheroDestino);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                this._Error_Message = "No se ha podido preparar el fichero NOMBRES.TXT en la carpeta '" + lcRutaGeneracion + "'." +
                                      Environment.NewLine + Environment.NewLine + e.Message;
                llOk = false;
            }
 
            return llOk;
        }
 

        [ExcludeFromCodeCoverage]
        private bool exportarPrepararFicheroDatosTxt()
        {
            bool llOk = true;
            string lcRutaGeneracion = this._RutaGeneracionCompleta();
 
            try
            {
                string lcFicheroDatos = Path.Combine(lcRutaGeneracion, "DATOS.TXT");
 
                using (StreamWriter sw = File.CreateText(lcFicheroDatos))
                {
                    this.exportarPrepararFicheroDatosTxt_DatosEmpresario(sw);
 
                    this.exportarPrepararFicheroDatosTxt_DatosRegistrales(sw);
 
                    this.exportarPrepararFicheroDatosTxt_DatosPresentador(sw);
 
                    this.exportarPrepararFicheroDatosTxt_DatosOtros(sw);
 
                    this.exportarPrepararFicheroDatosTxt_DatosLibros(sw);
                }
            }
            catch (Exception e)
            {
                this._Error_Message = "No se ha podido preparar el fichero DATOS.TXT en la carpeta '" + lcRutaGeneracion + "'." +
                                      Environment.NewLine + Environment.NewLine + e.Message; 
                llOk = false;
            }
 
            return llOk;
        }
 

        private void exportarPrepararFicheroDatosTxt_DatosEmpresario(StreamWriter sw)
        {
 
            // CCR198381, he mirado en FOX y alli SÍ se generaba registro 100 con el registro mercantil. He mirado en el
            // documento de análisis en el que nos basamos cuando pasamos de FOX a .NET esta pantalla y en el análisis
            // tampoco aparece el registro "100" pero por lo que dice la incidencia Spira relacionada con el CCR en 
            // la web de LEGALIA está pidiendo este registro por lo que si además tenemos en cuenta que en FOX ya
            // se generaba este registro "100" todo parece apuntar a que es un descuido de análisis. Añado pues el
            // registro "100" que se omitió por error al pasar a .NET.
            //
            // Registro mercantil
            //
            string lcCadena = "100" + this.getCadenaLongitud(this._RegistroMercantil, 32); 
            sw.WriteLine(lcCadena);
 
            // Fecha de solicitud.
            //
            lcCadena = "101" + this.getDtosFecha(this._Fecha);
            sw.WriteLine(lcCadena);
 
            // Nombre empresario.
            //
            lcCadena = "102" + this.getCadenaLongitud(this._NombreEmpresario, 100);
            sw.WriteLine(lcCadena);
 
            // Apellido 1 empresario.
            //
            lcCadena = "103" + this.getCadenaLongitud(this._Apellido1Empresario, 32);
            sw.WriteLine(lcCadena);
 
            // Apellido 2 empresario.
            //
            lcCadena = "104" + this.getCadenaLongitud(this._Apellido2Empresario, 32);
            sw.WriteLine(lcCadena);
 
            // CIF empresario.
            //
            lcCadena = "105" + this.getCadenaLongitud(this._CifEmpresario, 9);
            sw.WriteLine(lcCadena);
 
            // Dirección empresario.
            //
            lcCadena = "106" + this.getCadenaLongitud(this._DireccionEmpresario, 32);
            sw.WriteLine(lcCadena);
 
            // Ciudad empresario.
            //
            lcCadena = "107" + this.getCadenaLongitud(this._CiudadEmpresario, 32);
            sw.WriteLine(lcCadena);
 
            // Código postal empresario.
            //
            lcCadena = "108" + this.getCadenaLongitud(this._CodposEmpresario, 5);
            sw.WriteLine(lcCadena);
 
            // Código de la provincia empresario.
            //
            lcCadena = "109" + this.getCadenaLongitud(this._CodposEmpresario, 2);
            sw.WriteLine(lcCadena);
 
            // Fax empresario.
            //
            lcCadena = "110" + this.getCadenaLongitud(this._FaxEmpresario, 10);
            sw.WriteLine(lcCadena);
 
            // Teléfono empresario.
            //
            lcCadena = "111" + this.getCadenaLongitud(this._TelefonoEmpresario, 10);
            sw.WriteLine(lcCadena);
 
            // Código de registro.
            //
            lcCadena = "112" + this.getCadenaLongitud(this._CodigoRegistro, 5);
            sw.WriteLine(lcCadena);
 
            return;
        }
 

        private void exportarPrepararFicheroDatosTxt_DatosRegistrales(StreamWriter sw)
        {
            // Tomo
            //
            string lcCadena = "201" + this.getCadenaLongitud(this._NumeroTomoRegistro, 6);
            sw.WriteLine(lcCadena);
 
            // Libro.
            //
            if (!string.IsNullOrWhiteSpace(this._NumeroLibroRegistro))
            {
                // Task 167756, si no está declarado no lo adjuntamos al fichero.
                //
                lcCadena = "202" + this.getCadenaLongitud(this._NumeroLibroRegistro, 6);
                sw.WriteLine(lcCadena);
            }
 
            // Sección.
            //
            if (!string.IsNullOrWhiteSpace(this._NumeroSeccionRegistro))
            {
                // Task 167756, si no está declarado no lo adjuntamos al fichero.
                //
                lcCadena = "203" + this.getCadenaLongitud(this._NumeroSeccionRegistro, 6);
                sw.WriteLine(lcCadena);
            }
 
            // Folio.
            //
            lcCadena = "204" + this.getCadenaLongitud(this._NumeroFolioRegistro, 6);
            sw.WriteLine(lcCadena);
 
            // Tipo de registro público.
            //
            lcCadena = "205" + this.getCadenaLongitud(this._TipoRegistroMercantil, 32);
            sw.WriteLine(lcCadena);
 
            // Hoja.
            //
            if (!string.IsNullOrWhiteSpace(this._NumeroHojaRegistro))
            {
                // Task 167756, si no está declarado no lo adjuntamos al fichero.
                //
                lcCadena = "206" + this.getCadenaLongitud(this._NumeroHojaRegistro, 10);
                sw.WriteLine(lcCadena);
            }
 
            // Otros.
            //
            lcCadena = "207" + this.getCadenaLongitud(this._OtrosRegistroMercantil, 32);
            sw.WriteLine(lcCadena);
 
            return;
        }
 

        private void exportarPrepararFicheroDatosTxt_DatosPresentador(StreamWriter sw)
        {
            // Nombre presentador.
            //
            string lcCadena = "301" + this.getCadenaLongitud(this._NombrePresentador, 100);
            sw.WriteLine(lcCadena);
 
            // Apellido 1 presentador
            //
            lcCadena = "302" + this.getCadenaLongitud(this._Apellido1Presentador, 32);
            sw.WriteLine(lcCadena);
 
            // Apellido 2 presentador.
            //
            lcCadena = "303" + this.getCadenaLongitud(this._Apellido2Presentador, 32);
            sw.WriteLine(lcCadena);
 
            // CIF presentador.
            //
            lcCadena = "304" + this.getCadenaLongitud(this._CifPresentador, 9);
            sw.WriteLine(lcCadena);
 
            // Dirección presentador.
            //
            lcCadena = "305" + this.getCadenaLongitud(this._DireccionPresentador, 32);
            sw.WriteLine(lcCadena);
 
            // Ciudad presentador.
            //
            lcCadena = "306" + this.getCadenaLongitud(this._CiudadPresentador, 32);
            sw.WriteLine(lcCadena);
 
            // Código postal presentador.
            //
            lcCadena = "307" + this.getCadenaLongitud(this._CodposPresentador, 5);
            sw.WriteLine(lcCadena); 
 
            // Provincia presentador.
            //
            lcCadena = "308" + this.getCadenaLongitud(this._ProvinciaPresentador, 32);
            sw.WriteLine(lcCadena);
 
            // Fax presentador.
            //
            lcCadena = "309" + this.getCadenaLongitud(this._FaxPresentador, 10);
            sw.WriteLine(lcCadena);
 
            // Teléfono presentador.
            //
            lcCadena = "310" + this.getCadenaLongitud(this._TelefonoPresentador, 10);
            sw.WriteLine(lcCadena);
 
            // Correo electrónico.
            //
            lcCadena = "311" + this.getCadenaLongitud(this._EmailPresentador, 60);
            sw.WriteLine(lcCadena);
 
            return;
        }
 

        private void exportarPrepararFicheroDatosTxt_DatosOtros(StreamWriter sw)
        {
            // Solicita retención.
            //
            string lcCadena = "401" + (this._SolicitaRetencion ? "SI" : "NO");
            sw.WriteLine(lcCadena);
 
            // Número total de libros presentados.
            //
            lcCadena = "501" + Convert.ToString(this._NumeroLibros).Trim().PadLeft(3,'0');
            sw.WriteLine(lcCadena);
 
            return;
        }
 

        [ExcludeFromCodeCoverage] 
        private void exportarPrepararFicheroDatosTxt_DatosLibros(StreamWriter sw)
        {
            int lnContadorReg = 1;
            string lcCadena = "";
 
            foreach (LineasLegalizacionLibros.LineaLegalizacionLibros loLineaLibro in this._LineasLegalizacionLibros._Items)
            {
                if (!string.IsNullOrWhiteSpace(loLineaLibro._RutaArchivo))
                {
                    // Descripción del tipo de libro.
                    //
                    lcCadena = Convert.ToString(lnContadorReg).Trim().PadLeft(3, '0') + "01" + this.getCadenaLongitud(loLineaLibro._TipoLibroVisual, 100);
                    sw.WriteLine(lcCadena);
 
                    // Nº de libro.
                    //
                    lcCadena = Convert.ToString(lnContadorReg).Trim().PadLeft(3, '0') + "02" + this.getCadenaLongitud(loLineaLibro._NumLibro, 3);
                    sw.WriteLine(lcCadena);
 
                    // Fecha de apertura del libro.
                    //
                    lcCadena = Convert.ToString(lnContadorReg).Trim().PadLeft(3, '0') + "03" + this.getDtosFecha(loLineaLibro._FecApertura);
                    sw.WriteLine(lcCadena);
 
                    // Fecha de cierre del libro.
                    //
                    lcCadena = Convert.ToString(lnContadorReg).Trim().PadLeft(3, '0') + "04" + this.getDtosFecha(loLineaLibro._FecCierre);
                    sw.WriteLine(lcCadena);
 
                    // Fecha de último cierre del libro.
                    //
                    lcCadena = Convert.ToString(lnContadorReg).Trim().PadLeft(3, '0') + "05" + this.getDtosFecha(loLineaLibro._FecCierreAnt);
                    sw.WriteLine(lcCadena);
 
                    // Huella digital del libro.
                    //
                    lcCadena = Convert.ToString(lnContadorReg).Trim().PadLeft(3, '0') + "06" + this.getCadenaLongitud(loLineaLibro._Firma, 64);
                    sw.WriteLine(lcCadena);
 
                    lnContadorReg++;
                }
            }
            return;
        }
 

        [ExcludeFromCodeCoverage]  
        private bool exportarPrepararFicheroZip()
        {
            bool llOk = true;
 
            string lcRutaGeneracion = this._RutaGeneracionCompleta();
 
            try
            {
                using (ZipFile zip = new ZipFile())
                {
                    List<string> lstFicherosAnadir = new List<string>();
 
                    // Propietats del zip
                    zip.Comment = "";
                    zip.Encryption = EncryptionAlgorithm.None;
                    //zip.Password = "";
                    zip.CompressionMethod = CompressionMethod.Deflate;
                    zip.UseZip64WhenSaving = Zip64Option.Never;
 
                    this.obtenerListaFicherosAnadirAZip(ref lstFicherosAnadir, lcRutaGeneracion);
                    zip.AddFiles(lstFicherosAnadir, false, "");
 
                    string lcNombreFicheroZip = Path.Combine(lcRutaGeneracion, "LL" + this._CodigoRegistro.Trim() + this._CifEmpresario.Trim() + ".ZIP");
                    zip.Save(lcNombreFicheroZip);
 
                    if (!File.Exists(lcNombreFicheroZip))
                    {
                        llOk = false;
                        this._Error_Message = "No se ha podido generar correctamente el fichero ZIP de legalización en la carpeta '" + lcRutaGeneracion + "'";
                    }
                }
            }
            catch (Exception e)
            {
                llOk = false;
                this._Error_Message = "No se ha podido generar correctamente el fichero ZIP de legalización en la carpeta '" + lcRutaGeneracion + "'." +
                                      Environment.NewLine + Environment.NewLine + e.Message;
            }
 
            return llOk;
        }
 

        private void obtenerListaFicherosAnadirAZip(ref List<string> tlstFicheros, string tcRutaExportacion)
        {
            tlstFicheros.Add(Path.Combine(tcRutaExportacion, "NOMBRES.TXT"));
            tlstFicheros.Add(Path.Combine(tcRutaExportacion, "DATOS.TXT"));
 
            string lcNombreFicheroOrigen = "", lcExtensionFichero = "", lcNombreFicheroDestino = "";
 
            foreach (LineasLegalizacionLibros.LineaLegalizacionLibros loLinea in this._LineasLegalizacionLibros._Items)
            {
                if (!string.IsNullOrWhiteSpace(loLinea._RutaArchivo))
                {
                    lcNombreFicheroOrigen = loLinea._RutaArchivo.Trim();
                    lcExtensionFichero = Path.GetExtension(lcNombreFicheroOrigen);
                    lcNombreFicheroDestino = Path.Combine(tcRutaExportacion, loLinea._TipoLibro.Trim() + "_" + loLinea._NumLibro.Trim() + lcExtensionFichero);
 
                    tlstFicheros.Add(lcNombreFicheroDestino);
                }
            }
 
            return;
        }
 
 
        #endregion MÉTODOS PRIVADOS PARA EXPORTAR LEGALIZACION A FICHERO ZIP
 
 
        #region MÉTODOS PRIVADOS VARIOS
 

        private string getCadenaLongitud(string tcCadena, int lnLongitud)
        {
            string lcCadenaRetorno = (tcCadena.Length >= lnLongitud ? tcCadena.Substring(0, lnLongitud) : tcCadena.Trim().PadRight(lnLongitud, ' '));
 
            return lcCadenaRetorno;
        }
 

        private string getDtosFecha(DateTime? dtFecha)
        {
            string fechaRetorno = "";
 
            if (dtFecha == null)
                fechaRetorno =  new string(' ', 8);
            else
            {
                DateTime dtFecha2 = Convert.ToDateTime(dtFecha);
                fechaRetorno =  Convert.ToString(dtFecha2.Day).Trim().PadLeft(2, '0') +
                                Convert.ToString(dtFecha2.Month).Trim().PadLeft(2, '0') +
                                Convert.ToString(dtFecha2.Year).Trim();
            }
            return fechaRetorno;
        }
 

        private DateTime? setDtosToFecha(string tcFecha)
        {
            DateTime? fechaRetorno = null;
 
            if (tcFecha.Trim().Length != 8)
                return null;
 
            try
            {
                fechaRetorno = new DateTime(Convert.ToInt32(tcFecha.Substring(4, 4)), Convert.ToInt32(tcFecha.Substring(2, 2)) , Convert.ToInt32(tcFecha.Substring(0, 2)));
            }
            catch (Exception)
            {
                fechaRetorno = null;
            }
 
            return fechaRetorno;
        }
 

        [ExcludeFromCodeCoverage] 
        private void ajustesVisualesGrid(ewgrid toGrid)
        {
            if (toGrid.Columns.Contains("_TipoLibro"))
            {
                toGrid.Columns["_TipoLibro"].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
                toGrid.Columns["_TipoLibro"].HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleLeft;
            }
 
            if (toGrid.Columns.Contains("_RutaArchivo"))
            {
                toGrid.Columns["_RutaArchivo"].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
                toGrid.Columns["_RutaArchivo"].HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleLeft;
            }
 
            if (toGrid.Columns.Contains("_NumLibro"))
            {
                toGrid.Columns["_NumLibro"].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
                toGrid.Columns["_NumLibro"].HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
            }
 
            if (toGrid.Columns.Contains("_FecApertura"))
            {
                toGrid.Columns["_FecApertura"].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
                toGrid.Columns["_FecApertura"].HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
            }
 
            if (toGrid.Columns.Contains("_FecCierre"))
            {
                toGrid.Columns["_FecCierre"].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
                toGrid.Columns["_FecCierre"].HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
            }
 
            if (toGrid.Columns.Contains("_FecCierreAnt"))
            {
                toGrid.Columns["_FecCierreAnt"].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
                toGrid.Columns["_FecCierreAnt"].HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
            }
 
            if (toGrid.Columns.Contains("_FicheroFirmado"))
            {
                toGrid.Columns["_FicheroFirmado"].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
                toGrid.Columns["_FicheroFirmado"].HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
            }
 
            if (toGrid.Columns.Contains("_VerFichero"))
            {
                toGrid.Columns["_VerFichero"].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
                toGrid.Columns["_VerFichero"].HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
            }
 
            return;
        }
 

        private void legalizacionLibros_Actualizar_Estado_Documento(_EstadosMantenimiento teEstado)
        {
            if (this._FormMante == null)
                return;
 
            formul.EstadosDocumento estadosDocumento = formul.EstadosDocumento.NoHayDocumento;
 
            switch (teEstado)
            {
                case _EstadosMantenimiento.EsperandoCodigo:
                    estadosDocumento = formul.EstadosDocumento.NoHayDocumento;
                    break;
 
                case _EstadosMantenimiento.MostrandoRegistro:
                    estadosDocumento = formul.EstadosDocumento.HayDocumento;
                    break;
 
                case _EstadosMantenimiento.EntrandoNuevo:
                    estadosDocumento = formul.EstadosDocumento.EntrandoNuevo;
                    break;
 
                case _EstadosMantenimiento.EditandoRegistro:
                    estadosDocumento = formul.EstadosDocumento.HayDocumento;
                    break;
 
                case _EstadosMantenimiento.SinRegistro:
                    estadosDocumento = formul.EstadosDocumento.NoHayDocumento;
                    break;
 
                default:
                    break;
            }
 
            ((frmLegalizacionLibros)_FormMante)._EstadoDocumento = estadosDocumento;
 
            return;
        }
 
 
        #endregion MÉTODOS PRIVADOS VARIOS
 
 
        #endregion MÉTODOS PRIVADOS
 
 
        #region MÉTODOS PÚBLICOS
 

        [ExcludeFromCodeCoverage]
        public override void _Print()
        {
            this._oDocPrint = null;
 
            this._ReportBase = this._TipoImpresion == LegalizacionLibros.TipoImpresion.SolicitudLegalizacion ? "LEGASOLI" : "LEGAFIRM";
 
            this._DocPrint._Print();
 
            return;
        }
 

        [ExcludeFromCodeCoverage] 
        public string _RutaGeneracionCompleta(bool tlNoCrearCarpeta=false)
        {
            string lcRutaGeneracion = "";
            string lcGrupoEmp = this._dataAccessLegalizacionLibros.ObtenerDbComunes.Trim().Substring(4, 4);
 
            lcRutaGeneracion = Path.Combine(this._RutaGeneracion.Trim(), "Grupo" + lcGrupoEmp.Trim());
            lcRutaGeneracion = Path.Combine(lcRutaGeneracion, this._cEmpresa);
            lcRutaGeneracion = Path.Combine(lcRutaGeneracion, this._lcAny);
 
            if (!tlNoCrearCarpeta)
            {
                try
                {
                    if (!Directory.Exists(lcRutaGeneracion))
                        Directory.CreateDirectory(lcRutaGeneracion);
                }
                catch (Exception)
                {
                }
            }
 
            return lcRutaGeneracion;
        }
 

        public void _AgruparLineasPorTipoLibro()
        {
            this._dataAccessLegalizacionLibros._AgruparLineasPorTipoLibro(this, this._cEmpresa);
 
            return;
        }
 

        public bool _EsPrimerLibroTipo(string tcTipoLibro, string tcNumLibro)
        {
            bool llEsPrimerLibro = false;
 
            if (string.IsNullOrWhiteSpace(tcTipoLibro))
                return false;
 
            if (string.IsNullOrWhiteSpace(tcNumLibro))
                return false;
 
            int lnNumLibro = 0;
            if (!Int32.TryParse(tcNumLibro.Trim(), out lnNumLibro))
                return false;
 
            llEsPrimerLibro = this._LineasLegalizacionLibros._Items.Where(x => x._TipoLibro.Trim() == tcTipoLibro.Trim() && 
                             !string.IsNullOrWhiteSpace(x._RutaArchivo) && !string.IsNullOrWhiteSpace(x._NumLibro) 
                             && Convert.ToInt32(x._NumLibro) < lnNumLibro).Count() == 0;
 
            return llEsPrimerLibro;
        }
 

        public bool _HayMasLibrosTipo(string tcTipoLibro, string tcNumLibro)
        {
            bool llHayMasLibros = false;
 
            if (string.IsNullOrWhiteSpace(tcTipoLibro))
                return false;
 
            if (string.IsNullOrWhiteSpace(tcNumLibro))
                return false;
 
            int lnNumLibro = 0;
            if (!Int32.TryParse(tcNumLibro.Trim(), out lnNumLibro))
                return false;
 
            llHayMasLibros = this._LineasLegalizacionLibros._Items.Where(x => x._TipoLibro.Trim() == tcTipoLibro.Trim() && !string.IsNullOrWhiteSpace(x._RutaArchivo) && Convert.ToInt32(x._NumLibro) > lnNumLibro).Count() > 0;
 
            return llHayMasLibros;
        }
 

        public DateTime? _GetFechaFinLibroAnterior(string tcTipoLibro, string tcNumLibro)
        {
            DateTime? ldtFechaFinAnterior = null;
 
            LineasLegalizacionLibros.LineaLegalizacionLibros loLineaAnterior = this._LineasLegalizacionLibros._Items.Where(x => !string.IsNullOrWhiteSpace(x._TipoLibro) && x._TipoLibro.Trim() == tcTipoLibro.Trim() && Convert.ToInt32(x._NumLibro) < Convert.ToInt32(tcNumLibro)).OrderBy(x => x._NumLibro).LastOrDefault();
            if (loLineaAnterior != null)
            {
                if (loLineaAnterior._FecCierre != null)
                    ldtFechaFinAnterior = loLineaAnterior._FecCierre;
            }
 
            return ldtFechaFinAnterior;
        }
 

        public void _RenumerarLibrosTipoLibro(string tcTipoLibro)
        {
            if (string.IsNullOrWhiteSpace(tcTipoLibro))
                return;
 
            List<LineasLegalizacionLibros.LineaLegalizacionLibros> lstLineas = this._LineasLegalizacionLibros._Items.Where(x => !string.IsNullOrWhiteSpace(x._TipoLibro) && x._TipoLibro.Trim() == tcTipoLibro.Trim()).ToList();
 
            int lnNumLibro = 0;
            //if (lstLineas.Count > 0)
            //{
            //    lnNumLibro = Convert.ToInt32(lstLineas[0]._NumLibro);
            //    lnNumLibro--;
            //}
            
            foreach (LineasLegalizacionLibros.LineaLegalizacionLibros loLinea in lstLineas)
            {
                lnNumLibro++;
                loLinea._NumLibro = Convert.ToString(lnNumLibro).Trim().PadLeft(3, '0');
            }
 
            return;
        }
 

        public string _NumNuevoDocumento(string tcTipoLibro)
        {
            string lcNumeroNuevoDocumento = "";
 
            var lineasDeclaradas = this._LineasLegalizacionLibros._Items.Where(x => !string.IsNullOrEmpty(x._TipoLibro) &&
                                                                                    x._TipoLibro.Trim() == tcTipoLibro);
            if (lineasDeclaradas.Count() == 0)
            {
                lcNumeroNuevoDocumento = "001";
            }
            else
            {
                lcNumeroNuevoDocumento = lineasDeclaradas.Max(x => x._NumLibro);
                if (string.IsNullOrWhiteSpace(lcNumeroNuevoDocumento))
                    lcNumeroNuevoDocumento = "000";
 
                lcNumeroNuevoDocumento = Convert.ToString(Convert.ToInt32(lcNumeroNuevoDocumento) + 1).Trim().PadLeft(3,'0');
            }
 
            if (string.IsNullOrWhiteSpace(lcNumeroNuevoDocumento))
                lcNumeroNuevoDocumento = "001";
 
            return lcNumeroNuevoDocumento;
        }
 

        public EstadoFirmasLibros _ObtenerEstadoFirmasLibros()
        {
            EstadoFirmasLibros loEstadoFirmas = EstadoFirmasLibros.NoEvaluado;
 
            int liniasConArchivo = this._LineasLegalizacionLibros._Items.Where(x => !string.IsNullOrWhiteSpace(x._RutaArchivo)).Count();
 
            if (liniasConArchivo == 0)
            {
                loEstadoFirmas = EstadoFirmasLibros.NoEvaluado;
            }
            else
            {
                int liniasConArchivoSinFirma = this._LineasLegalizacionLibros._Items.Where(x => !string.IsNullOrWhiteSpace(x._RutaArchivo) && string.IsNullOrWhiteSpace(x._Firma)).Count();
 
                if (liniasConArchivoSinFirma == 0)
                {
                    // No hay ningún archivo sin firmar, están todos firmados.
                    //
                    loEstadoFirmas = EstadoFirmasLibros.TodasFirmasGeneradas;
                }
                else
                {
                    // Hay algún archivo sin firmar.
                    //
                    if (liniasConArchivoSinFirma == liniasConArchivo)
                    {
                        // No hay ningún archivo firmado.
                        //
                        loEstadoFirmas = EstadoFirmasLibros.NingunaFirmaGenerada;
                    }
                    else if (liniasConArchivoSinFirma < liniasConArchivo)
                    {
                        // Hay algún archivo sin firma y algún archivo con firma.
                        //
                        loEstadoFirmas = EstadoFirmasLibros.AlgunaFirmaGenerada;
                    }
                }
            }
 
            return loEstadoFirmas;
        }
 

        public bool _Comprobaciones_Borrar()
        {
            // Dejo esta comprobación libre de código pues hoy por hoy no está implementada la eliminación de documento Legalización y de esta forma
            // también evitamos que la clase base haga código en su propio método que pueda afectar.
 
            return true;
        }
 

        public bool _Comprobaciones_CargarDatos()
        {
            // Si no tenemos documento no hacemos nada y salimos.
            // Esto en teoria no pasará nunca pues en _Numero siempre tendremos el ejercicio activo.
            //
            if (string.IsNullOrWhiteSpace(this._Numero))
            {
                this._Error_Message = "No tiene cargada ninguna legalización de libros en pantalla.";
                return false;
            }
 
            // Legalización de libros en uso.
            //
            if (this._EnUso)
            {
                this._Error_Message = "La legalización de libros se encuenta en uso desde otro terminal." + Environment.NewLine + Environment.NewLine +
                                      "Imposible cargar datos de empresario, presentador y registro mercantil.";
                return false;
            }
 
            return true;
        }
 

        public bool _Comprobaciones_CargarDatos_Warning()
        {
            if (this.algunDatoDeclaradoDatosPresentacion())
            {
                this._Warning_Message = "Atención, existen datos ya declarados en la pestaña 'Datos de presentación'."+Environment.NewLine+Environment.NewLine+
                                        "Si continua con la acción de carga, los datos existentes en dicha pestaña se perderán pues serán sobreescritos por los procedentes de la carga.";
                return false;
            }
 
            return true;
        }
 

        public bool _Comprobaciones_ImportarFichero(ref string tcArchivoZipLegalizacion)
        {
            // Si no tenemos documento no hacemos nada y salimos.
            // Esto en teoria no pasará nunca pues en _Numero siempre tendremos el ejercicio activo.
            //
            if (string.IsNullOrWhiteSpace(this._Numero))
            {
                this._Error_Message = "No tiene cargada ninguna legalización de libros en pantalla.";
                return false;
            }
 
            // Legalización de libros en uso.
            //
            if (this._EnUso)
            {
                this._Error_Message = "La legalización de libros se encuenta en uso desde otro terminal." + Environment.NewLine + Environment.NewLine +
                                      "Imposible importar fichero de legalización en el formulario.";
                return false;
            }
 
            // No está declarada la ruta de generación.
            //
            if (string.IsNullOrWhiteSpace(this._RutaGeneracion))
            {
                this._Error_Message = "La ruta de generación no puede estar vacía pues se utiliza para volcar el resultado de la importación." + Environment.NewLine + Environment.NewLine +
                                      "Imposible importar fichero de legalización en el formulario.";
                return false;
            }
 
            tcArchivoZipLegalizacion = "";
            if (!this.seleccionarArchivoZipValido(out tcArchivoZipLegalizacion))
            {
                // El mensaje de error ya se ha obtenido dentro del método.
                //
                return false;
            }
 
            return true;
        }
 

        public bool _Comprobaciones_ImportarFichero_Warning()
        {
            int lnNumLibros = this._NumeroLibros;
            bool llWarning = false;
 
            if (lnNumLibros>0)
            {
                this._Warning_Message = "Atención, actualmente tiene declarados ya " + Convert.ToString(lnNumLibros).Trim() + " " + (lnNumLibros > 1 ? "libros" : "libro") + " en la legalización." +
                                        Environment.NewLine+Environment.NewLine+"Si continúa con la importación de datos a partir de fichero ZIP, perderá estos datos.";
                llWarning = true;
           }
 
            if (this.algunDatoDeclaradoDatosPresentacion())
            {
                if (!string.IsNullOrWhiteSpace(this._Warning_Message))
                    this._Warning_Message += Environment.NewLine + Environment.NewLine;
                
                this._Warning_Message += "Atención, existen datos ya declarados en la pestaña 'Datos de presentación'." + Environment.NewLine + Environment.NewLine +
                                        "Si continua con la importación de datos a partir de fichero ZIP, los datos existentes en dicha pestaña se perderán pues serán sobreescritos por los procedentes de la importación.";
                llWarning = true;
            }
 
            if (llWarning)
                return false;
 
            // La ruta de generación tendrá el formato EUROSERV\LIBROS\GRP0001\01\2020\ donde EUROSERV\LIBROS es la ruta que hay declarada como
            // ruta de generación.
            //
            string lcRutaGeneracion = this._RutaGeneracionCompleta();
 
            int lnNumFicheros = 0;
            if (this.algunFicheroEnRutaGeneracion(lcRutaGeneracion, out lnNumFicheros))
            {
                this._Warning_Message = "Atención, se ha detectado la existencia de " + Convert.ToString(lnNumFicheros).Trim() + " " + (lnNumFicheros > 1 ? "archivos" : "archivo") + " " +
                                        "en la ruta donde debe generarse el fichero ZIP de la legalización." + Environment.NewLine + Environment.NewLine + lcRutaGeneracion + Environment.NewLine + Environment.NewLine +
                                        "Antes de realizar la creación del fichero ZIP de la legalización se eliminarán todos los archivos existentes en dicha carpeta.";
                return false;
            }
 
            return true;
        }
 

        public bool _Comprobaciones_Imprimir()
        {
            this._Error_Message = "";
 
            if (string.IsNullOrWhiteSpace(this._Numero))
            {
                this._Error_Message = "No se ha cargado todavía ninguna legalización.";
                return false;
            }
 
            if (this._LineasLegalizacionLibros._Items.Count == 0)
            {
                this._Error_Message = "No se ha declarado todavía ningún libro en el apartado 'Relación de libros'.";
                return false;
            }
 
            // Si está en uso no permitimos imprimir ficheros.
            //
            if (this._EnUso)
            {
                this._Error_Message = "La legalización de libros se encuenta en uso desde otro terminal." + Environment.NewLine + Environment.NewLine +
                                      "Imposible imprimir solicitud de legalización en este momento.";
                return false;
            }
 
 
            int liniasSinArchivo = this._LineasLegalizacionLibros._Items.Where(x => string.IsNullOrWhiteSpace(x._RutaArchivo)).Count();
            if (liniasSinArchivo > 0)
            {
                this._Error_Message = "Se ha detectado algún libro en el apartado 'Relación de libros' sin ruta de archivo declarada." + Environment.NewLine + Environment.NewLine +
                                      "Para poder realizar la impresión de la solicitud de legalización es necesario declarar los archivos de todos los libros, y generar ficheros y firmas de todos los libros.";
                return false;
            }
 
            int liniasArchivoSinFirma = this._LineasLegalizacionLibros._Items.Where(x => !string.IsNullOrWhiteSpace(x._RutaArchivo) && string.IsNullOrWhiteSpace(x._Firma)).Count();
            if (liniasArchivoSinFirma > 0)
            {
                this._Error_Message = "Se ha detectado algún libro en el apartado 'Relación de libros' sin firma realizada." + Environment.NewLine + Environment.NewLine +
                                      "Para poder realizar la impresión de la solicitud de legalización es necesario generar ficheros y firmas de todos los libros.";
                return false;
            }
 
            return true;
        }
 

        public bool _Comprobaciones_ExportarFichero()
        {
            this._Error_Message = "";
 
            // No se ha cargado ninguna legalización.
            //
            if (string.IsNullOrWhiteSpace(this._Numero))
            {
                this._Error_Message = "No se ha cargado todavía ninguna legalización.";
                return false;
            }
 
            // No hay ningún libro declarado en la legalización.
            //
            if (this._LineasLegalizacionLibros._Items.Count == 0)
            {
                this._Error_Message = "No se ha declarado todavía ningún libro en el apartado 'Relación de libros'.";
                return false;
            }
 
            // Si está en uso no permitimos crear ficheros.
            //
            if (this._EnUso)
            {
                this._Error_Message = "La legalización de libros se encuenta en uso desde otro terminal." + Environment.NewLine + Environment.NewLine +
                                      "Imposible generar fichero ZIP de legalización en este momento.";
                return false;
            }
 
            // No está declarada la ruta de generación.
            //
            if (string.IsNullOrWhiteSpace(this._RutaGeneracion))
            {
                this._Error_Message = "La ruta de generación no puede estar vacía." + Environment.NewLine + Environment.NewLine +
                                      "Imposible generar fichero ZIP de legalización.";
                return false;
            }
 
            // Libros con ruta de fichero declarada.
            //
            int liniasSinArchivo = this._LineasLegalizacionLibros._Items.Where(x => string.IsNullOrWhiteSpace(x._RutaArchivo)).Count();
            if (liniasSinArchivo > 0)
            {
                this._Error_Message = "Se ha detectado algún libro en el apartado 'Relación de libros' sin ruta de archivo declarada." + Environment.NewLine + Environment.NewLine +
                                      "Para poder realizar la creación de ficheros y firmas todos los libros deben tener ruta de archivo declarada.";
                return false;
            }
 
            // Deben existir todos los ficheros declarados en las rutas.
            //
            string lcFichero = "";
            string lcFicherosFaltan = "";
            int lnFicherosInexistentes = 0;
            foreach (LineasLegalizacionLibros.LineaLegalizacionLibros loLinea in this._LineasLegalizacionLibros._Items)
            {
                lcFichero = loLinea._RutaArchivo.Trim();
                if (!File.Exists(lcFichero))
                {
                    lnFicherosInexistentes++;
                    lcFicherosFaltan += lcFichero + Environment.NewLine;
                }
            }
            if (lnFicherosInexistentes>0)
            {
                this._Error_Message = "No se ha detectado la existencia de " + (lnFicherosInexistentes == 1 ? "el fichero" : "los ficheros siguientes") + ":" +
                                      Environment.NewLine + Environment.NewLine + lcFicherosFaltan + Environment.NewLine + Environment.NewLine +
                                      "Para poder realizar la creación de ficheros de la legalización, todos los libros deben tener como ruta un archivo existente.";
                return false;
            }
 
            // Ruta de generación declarada.
            //
            if (string.IsNullOrWhiteSpace(this._RutaGeneracion))
            {
                this._Error_Message = "Falta declarar la ruta donde generar los ficheros.";
                return false;
            }
 
            // La ruta de generación tendrá el formato EUROSERV\LIBROS\GRP0001\01\2020\ donde EUROSERV\LIBROS es la ruta que hay declarada como
            // ruta de generación.
            //
            string lcRutaGeneracion = this._RutaGeneracionCompleta();
            if (!Directory.Exists(lcRutaGeneracion))
            {
                try
                {
                    Directory.CreateDirectory(lcRutaGeneracion);
                }
                catch (Exception)
                {
                }
                if (!Directory.Exists(lcRutaGeneracion))
                {
                    this._Error_Message = "No ha sido posible crear el directorio de exportación '"+ lcRutaGeneracion.Trim()+ "'.";
                    return false;
                }
            }
 
 
            // Verificación de que estén los datos obligatorios en la pestaña de "Datos de presentación".
            //
            string lcFaltaCampo = "";
            if (!this.datosEmpresarioOk(ref lcFaltaCampo))
            {
                this._Error_Message = "Falta declarar el campo '"+lcFaltaCampo+"' en el apartado 'Datos del empresario' de la pestaña 'Datos de presentación'.";
                return false;
            }
 
            if (!this.datosPresentadorOk(ref lcFaltaCampo))
            {
                this._Error_Message = "Falta declarar el campo '" + lcFaltaCampo + "' en el apartado 'Datos del presentador' de la pestaña 'Datos de presentación'.";
                return false;
            }
 
            if (!this.datosRegistroOk(ref lcFaltaCampo))
            {
                this._Error_Message = "Falta declarar el campo '" + lcFaltaCampo + "' en el apartado 'Datos registrales' de la pestaña 'Datos de presentación'.";
                return false;
            }
 
            return true;
        }
 

        public bool _Comprobaciones_ExportarFichero_Warning()
        {
            // La ruta de generación tendrá el formato EUROSERV\LIBROS\GRP0001\01\2020\ donde EUROSERV\LIBROS es la ruta que hay declarada como
            // ruta de generación.
            //
            string lcRutaGeneracion = this._RutaGeneracionCompleta();
 
            int lnNumFicheros = 0;
            if (this.algunFicheroEnRutaGeneracion(lcRutaGeneracion, out lnNumFicheros))
            {
                this._Warning_Message = "Atención, se ha detectado la existencia de "+Convert.ToString(lnNumFicheros).Trim() + " "+(lnNumFicheros > 1 ? "archivos" : "archivo") + " " +  
                                        "en la ruta donde debe generarse el fichero ZIP de la legalización."+Environment.NewLine+Environment.NewLine+lcRutaGeneracion + Environment.NewLine + Environment.NewLine +
                                        "Antes de realizar la creación del fichero ZIP de la legalización se eliminarán todos los archivos existentes en dicha carpeta.";
                return false;
            }
 
            return true;
        }
 

        [ExcludeFromCodeCoverage]
        public new void _ShowDialog()
        {
            // Crear la instancia del formulario.
            //
            this._FormMante = new frmLegalizacionLibros(this);
 
            // Primero cargamos el documento,  y luego lo mostramos modal.
            //
            if (!string.IsNullOrWhiteSpace(this._Codigo))
            {
                if (this._FormMante != null)
                    this._FormMante._CargarDocumento();
            }
 
            // Mostrar el formulario.
            //
            ((formul.FormBaseDocumento)_FormMante).ShowDialog();
        }
 

        [ExcludeFromCodeCoverage]
        public void _Set_GridDetalleRelacionLibros(objetos.UserControls.Mantegrid mantegrid)
        {
            this._LineasLegalizacionLibros._Grid = mantegrid;
 
            sage.ew.objetos.ewgrid loGrid = ((sage.ew.objetos.UserControls.Mantegrid)this._LineasLegalizacionLibros._Grid)._Grid;
 
            this.ajustesVisualesGrid(loGrid);
 
            return;
        }
 

        [ExcludeFromCodeCoverage]
        public void _Set_FormMante(dynamic formMante)
        {
            this._FormMante = formMante;
        }
 

        [ExcludeFromCodeCoverage] 
        public void _CargarDatosComunesTerritorios()
        {
            // DATOS EMPRESARIO (CIF, NOMBRE, APELLIDO1, APELLIDO2 se sacan del mismo sitio en territorio Común y en territorio Canarias).
            //
            if (!string.IsNullOrWhiteSpace(EW_GLOBAL._Empresa._NombreTC))
            {
                this._NombreEmpresario = EW_GLOBAL._Empresa._NombreTC;
            }
            else
            {
                // Si el nombre empresa está vacío, ponemos el campo apellidos (según análisis).
                //
                this._NombreEmpresario = EW_GLOBAL._Empresa._ApellidosTC;
            }
 
            if (!string.IsNullOrWhiteSpace(EW_GLOBAL._Empresa._NombreTC))
            {
                // Solo guardo en apellidos lo que toca en caso de que el nombre se haya recuperado correctamente
                // en el paso anterior, pues caso contrario los apellidos ya se han puesto en el campo nombre y
                // no es necesario volver a repertirlos en el propio campo apellidos.
                //
                string lcApellidos = EW_GLOBAL._Empresa._ApellidosTC.Trim();
                int lnPosEspacio = lcApellidos.IndexOf(' ');
                if (lnPosEspacio > 0)
                {
                    // Si en apellidos de empresa hay al menos un espacio, interpretamos hasta el primer espacio como primer apellido
                    // y todo lo que venga a partir de alli como el segundo.
                    //
                    this._Apellido1Empresario = lcApellidos.Substring(0, lnPosEspacio);
                    this._Apellido2Empresario = lcApellidos.Substring(lnPosEspacio + 1);
                }
                else
                {
                    // Si en apellidos de empresa no hay espacio, va todo al primer apellido.
                    this._Apellido1Empresario = lcApellidos;
                    this._Apellido2Empresario = "";
                }
            }
 
            this._CifEmpresario = EW_GLOBAL._Empresa._CifTC;
 
 
            // DATOS REGISTRO
            //
            this._CodigoRegistro = EW_GLOBAL._Empresa._CodigoAdministracion;
            this._NumeroTomoRegistro = EW_GLOBAL._Empresa._NumeroTomoRegistro;
            this._NumeroLibroRegistro = EW_GLOBAL._Empresa._NumeroLibroRegistro;
            this._NumeroSeccionRegistro = EW_GLOBAL._Empresa._NumeroSeccionRegistro;
            this._NumeroFolioRegistro = EW_GLOBAL._Empresa._NumeroFolioRegistro;
            this._NumeroHojaRegistro = EW_GLOBAL._Empresa._NumeroHojaRegistro;
            this._TipoRegistroMercantil = EW_GLOBAL._Empresa._TipoRegistroPublico;
            this._OtrosRegistroMercantil = EW_GLOBAL._Empresa._OtrosRegistro;
            this._RegistroMercantil = EW_GLOBAL._Empresa._RegistroMercantil;
            this._IRUS = EW_GLOBAL._Empresa._IRUS;
 
            return;
        }
 

        [ExcludeFromCodeCoverage] 
        public void _CargarDatosTerritorioComun()
        {
            string lcDireccion = EW_GLOBAL._Empresa._SiglaTC.Trim() + " " +
                                 EW_GLOBAL._Empresa._NombreViaTC.Trim() +
                                 (!string.IsNullOrWhiteSpace(EW_GLOBAL._Empresa._NumeroTC) ? " " + EW_GLOBAL._Empresa._NumeroTC.Trim() : "") +
                                 (!string.IsNullOrWhiteSpace(EW_GLOBAL._Empresa._EscaleraTC) ? " " + EW_GLOBAL._Empresa._EscaleraTC.Trim() : "") +
                                 (!string.IsNullOrWhiteSpace(EW_GLOBAL._Empresa._PisoTC) ? " " + EW_GLOBAL._Empresa._PisoTC.Trim() : "") +
                                 (!string.IsNullOrWhiteSpace(EW_GLOBAL._Empresa._PuertaTC) ? " " + EW_GLOBAL._Empresa._PuertaTC.Trim() : "");
 
            lcDireccion = lcDireccion.Trim();
            if (lcDireccion.Length > 32)
                lcDireccion = lcDireccion.Substring(0, 32);
 
            this._DireccionEmpresario = lcDireccion;
            this._CodposEmpresario = EW_GLOBAL._Empresa._CodigoPostalTC;
            this._CiudadEmpresario = EW_GLOBAL._Empresa._MunicipioTC;
            this._ProvinciaEmpresario = EW_GLOBAL._Empresa._ProvinciaTC;
            this._TelefonoEmpresario = EW_GLOBAL._Empresa._TelefonoTC;
            this._FaxEmpresario = EW_GLOBAL._Empresa._FaxTC;
 
            // DATOS PRESENTADOR
            //
            this._NombrePresentador = EW_GLOBAL._Empresa._NombreContactoTC;
 
            string lcApellidos = EW_GLOBAL._Empresa._ApellidosContactoTC.Trim();
            int lnPosEspacio = lcApellidos.IndexOf(' ');
            if (lnPosEspacio > 0)
            {
                // Si en apellidos hay al menos un espacio, interpretamos hasta el primer espacio como primer apellido
                // y todo lo que venga a partir de alli como el segundo.
                //
                this._Apellido1Presentador = lcApellidos.Substring(0, lnPosEspacio);
                this._Apellido2Presentador = lcApellidos.Substring(lnPosEspacio + 1);
            }
            else
            {
                // Si en apellidos de empresa no hay espacio, va todo al primer apellido.
                //
                this._Apellido1Presentador = lcApellidos;
                this._Apellido2Presentador = "";
            }
            this._CifPresentador = EW_GLOBAL._Empresa._CifContactoTC;
 
            this._DireccionPresentador = EW_GLOBAL._Empresa._NombreViaContactoTC;
            this._CodposPresentador = EW_GLOBAL._Empresa._CodigoPostalContactoTC;
            this._CiudadPresentador = EW_GLOBAL._Empresa._MunicipioContactoTC;
            this._ProvinciaPresentador = EW_GLOBAL._Empresa._ProvinciaContactoTC;
            this._TelefonoPresentador = EW_GLOBAL._Empresa._TelefonoContactoTC;
            this._FaxPresentador = EW_GLOBAL._Empresa._FaxContactoTC;
            this._EmailPresentador = EW_GLOBAL._Empresa._C_emailTC;
 
            return;
        }
 

        [ExcludeFromCodeCoverage] 
        public void _CargarDatosTerritorioCanarias()
        {
            string lcDireccion = EW_GLOBAL._Empresa._SiglaCanarias.Trim() + " " +
                                 EW_GLOBAL._Empresa._NombreViaCanarias.Trim() +
                                 (!string.IsNullOrWhiteSpace(EW_GLOBAL._Empresa._NumeroCanarias) ? " " + EW_GLOBAL._Empresa._NumeroCanarias.Trim() : "") +
                                 (!string.IsNullOrWhiteSpace(EW_GLOBAL._Empresa._EscaleraCanarias) ? " " + EW_GLOBAL._Empresa._EscaleraCanarias.Trim() : "") +
                                 (!string.IsNullOrWhiteSpace(EW_GLOBAL._Empresa._PisoCanarias) ? " " + EW_GLOBAL._Empresa._PisoCanarias.Trim() : "") +
                                 (!string.IsNullOrWhiteSpace(EW_GLOBAL._Empresa._PuertaCanarias) ? " " + EW_GLOBAL._Empresa._PuertaCanarias.Trim() : "");
 
            lcDireccion = lcDireccion.Trim();
            if (lcDireccion.Length > 32)
                lcDireccion = lcDireccion.Substring(0, 32);
 
            this._DireccionEmpresario = lcDireccion;
            this._CodposEmpresario = EW_GLOBAL._Empresa._CodigoPostalCanarias;
            this._CiudadEmpresario = EW_GLOBAL._Empresa._MunicipioCanarias;
            this._ProvinciaEmpresario = EW_GLOBAL._Empresa._ProvinciaCanarias;
            this._TelefonoEmpresario = EW_GLOBAL._Empresa._TelefonoCanarias;
            this._FaxEmpresario = EW_GLOBAL._Empresa._FaxCanarias;
 
            // DATOS PRESENTADOR
            //
            this._NombrePresentador = EW_GLOBAL._Empresa._NombreContactoCanarias;
 
            string lcApellidos = EW_GLOBAL._Empresa._ApellidosContactoCanarias.Trim();
            int lnPosEspacio = lcApellidos.IndexOf(' ');
            if (lnPosEspacio > 0)
            {
                // Si en apellidos hay al menos un espacio, interpretamos hasta el primer espacio como primer apellido
                // y todo lo que venga a partir de alli como el segundo.
                //
                this._Apellido1Presentador = lcApellidos.Substring(0, lnPosEspacio);
                this._Apellido2Presentador = lcApellidos.Substring(lnPosEspacio + 1);
            }
            else
            {
                // Si en apellidos de empresa no hay espacio, va todo al primer apellido.
                //
                this._Apellido1Presentador = lcApellidos;
                this._Apellido2Presentador = "";
            }
            this._CifPresentador = EW_GLOBAL._Empresa._CifContactoCanarias;
 
            this._DireccionPresentador = EW_GLOBAL._Empresa._NombreViaContactoCanarias;
            this._CodposPresentador = EW_GLOBAL._Empresa._CodigoPostalContactoCanarias;
            this._CiudadPresentador = EW_GLOBAL._Empresa._MunicipioContactoCanarias;
            this._ProvinciaPresentador = EW_GLOBAL._Empresa._ProvinciaContactoCanarias;
            this._TelefonoPresentador = EW_GLOBAL._Empresa._TelefonoContactoCanarias;
            this._FaxPresentador = EW_GLOBAL._Empresa._FaxContactoCanarias;
            this._EmailPresentador = EW_GLOBAL._Empresa._EmailContactoCanarias;
 
            return;
        }
 

        [ExcludeFromCodeCoverage]
        public bool _ImportarFicheroLegalizacion(string tcFicheroZipLegalizacion)
        {
            this._Error_Message = "";
 
            // Crea la carpeta de importación si no existe. Si existe se asegura de que esté vacía, si no lo está borra todo para 
            // asegurarse de que esté vacía. Si hay algún problema con todo lo anterior ya no se continúa. Es requesito tener esta
            // carpeta de importación completamente vacía pues el ZIP se copiará allá y se decomprimirá allá.
            //
            string lcCarpetaImportacion = "";
            if (!this.asegurarCarpetaImportacionVacia(out lcCarpetaImportacion))
                return false;
 
            string lcNombreFicheroDestino = Path.Combine(lcCarpetaImportacion, Path.GetFileName(tcFicheroZipLegalizacion));
 
            File.Copy(tcFicheroZipLegalizacion, lcNombreFicheroDestino);
 
            if (!File.Exists(lcNombreFicheroDestino))
            {
                this._Error_Message = "No se ha podido copiar el fichero ZIP de legalización '" + tcFicheroZipLegalizacion + "' a la carpeta de importación '" + lcCarpetaImportacion + "'.";
                return false;
            }
 
            if (!this.verificarRecuperarArchivoZip(lcNombreFicheroDestino, true))
            {
                // El mensaje de error ya se generó dentro del método anterior.
                return false;
            }
 
            return true;
        }
 

        [ExcludeFromCodeCoverage] 
        public bool _ExportarFicheroLegalizacion()
        {
            this._Error_Message = "";
            bool llRetorno = true;
 
            string lcRutaGeneracion = this._RutaGeneracionCompleta();
 
            // Borrar ficheros que puedan haber en la ruta de generación. Préviamente ya se avisó al usuario.
            //
            bool llTodosArchivosBorrados = this.borrarTodosArchivosRuta(lcRutaGeneracion);
            if (!llTodosArchivosBorrados)
            {
                this._Error_Message = "No se han podido borrar todos los archivos existentes en la carpeta '" + lcRutaGeneracion + "'." + Environment.NewLine + Environment.NewLine +
                                      "Imposible realizar la creación de fichero ZIP de la legalización.";
                return false;
            }
 
 
            // Copiar ficheros de libros a ruta de generación adaptando nombres, y generar y guardar firmas.
            //
            bool llOk = this.exportarCopiarFicherosARutaGeneracion();
            if (!llOk)
                return false;
 
 
            // Preparar fichero NOMBRES.TXT
            //
            llOk = this.exportarPrepararFicheroNombresTxt();
            if (!llOk)
                return false;
 
 
            // Preparar fichero DATOS.TXT
            //
            llOk = this.exportarPrepararFicheroDatosTxt();
            if (!llOk)
                return false;
 
 
            // Crear fichero ZIP de legalización con los ficheros: NOMBRES.TXT, DATOS.TXT y todos los ficheros de libros incorporados.
            //
            llOk = this.exportarPrepararFicheroZip();
            if (!llOk)
                return false;
 
 
            return llRetorno;
        }
 
 
        #endregion MÉTODOS PÚBLICOS
 
 
        #region CLASE DE LINEAS DE LIBROS PRESENTADOS EN LA LEGALIZACION
 

        public class LineasLegalizacionLibros : ewManteTRel<LineasLegalizacionLibros.LineaLegalizacionLibros, LineasLegalizacionLibros.Clave>
        {
            #region PROPIEDADES PRIVADAS
 

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

            public List<object> _lstTiposLibro = new List<object>();
 
 
            #endregion PROPIEDADES PRIVADAS
 
 
            #region PROPIEDADES PUBLICAS
 

            public Dictionary<string, string> _dicTiposLibro = new Dictionary<string, string>();
 

            public LegalizacionLibros _oLegalizacion
            {
                get
                {
                    return (LegalizacionLibros)_ewMantePrincipal;
                }
            }
 
 
            #endregion PROPIEDADES PUBLICAS
 
 
            #region CONSTRUCTOR
 

            public LineasLegalizacionLibros() : this(null, new LegalizacionLibrosDA())
            {
            }
 

            public LineasLegalizacionLibros(string tcEjercicio) : this(tcEjercicio, new LegalizacionLibrosDA())
            {
            }
 

            public LineasLegalizacionLibros(ILegalizacionLibrosDA legalizacionLibrosDA) : 
                                            this(null, legalizacionLibrosDA)
            {
            }

            public LineasLegalizacionLibros(string tcEjercicio, ILegalizacionLibrosDA legalizacionLibrosDA) : 
                                            base(legalizacionLibrosDA)
            {
                // No hace falta establecer la propiedad _dataAccess aquí pues esta propiedad esta definida en la
                // clase base ewManteTRel (es de tipo protected, visible aquí en esta clase) por que al llamar al
                // constructor base(legalizacionLibrosDA) con el interfaz de acceso a datos como parámetro ya se
                // establece dicha propiedad en la clase base ewManteTRel y por tanto queda definida también para
                // la clase LineasLegalizacionLibros en la que estamos pues hereda de ewManteTRel.
                //
                // _dataAccess = legalizacionLibrosDA;
 
                this.cargarDicLstTiposLibro();
 
                this.crearEstructura();
 
                if (!string.IsNullOrEmpty(tcEjercicio))
                {
                    this._Claves._Empresa._Valor = this._lcEmpresa;
                    this._Claves._Numero._Valor = tcEjercicio;
                }
 
                return;
            }
 

            private void crearEstructura()
            {
                this._DataBase = "COMUNES";
                this._Tabla = "D_LEGLBR";
                this._OrdenarPor = "LINEA";
                this._Condicion = "";
 
                // Código de empresa.
                //
                ewCampoTRel def_Empresa = this._AddCampoTRel("_Empresa", "Empresa");
                def_Empresa._AnchoColumna = 7;
                def_Empresa._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Empresa._Editable = false;
                def_Empresa._Error_Duplicados = "";
                def_Empresa._Error_Validar_Dato = "";
                def_Empresa._ExpandirPunto = false;
                def_Empresa._FormatString = "";
                def_Empresa._PermiteDuplicados = true;
                def_Empresa._TipoColumna = gridColumnsTypes.Texto;
                def_Empresa._Titulo = "Empresa";
                def_Empresa._Updatable = true;
                def_Empresa._Validar_Asignar_Cargando = false;
                def_Empresa._Validar_Dato_BaseDatos = "";
                def_Empresa._Validar_Dato_Campos = "";
                def_Empresa._Validar_Dato_CampoTRel_Asignar = "";
                def_Empresa._Validar_Dato_Clave = "";
                def_Empresa._Validar_Dato_Tabla = "";
                def_Empresa._Visible = false;
 
 
                // Ejercicio
                //
                ewCampoTRel def_Numero = this._AddCampoTRel("_Numero", "Numero");
                def_Numero._AnchoColumna = 7;
                def_Numero._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Numero._Editable = false;
                def_Numero._Error_Duplicados = "Ha introducido un valor que ya está asignado a otro registro. No se permiten valores duplicados en este campo.";
                def_Numero._Error_Validar_Dato = "Ha introducido un valor que no se ha encontrado en su mantenimiento origen.";
                def_Numero._ExpandirPunto = false;
                def_Numero._FormatString = "";
                def_Numero._PermiteDuplicados = true;
                def_Numero._TipoColumna = gridColumnsTypes.Texto;
                def_Numero._Titulo = "Ejercicio";
                def_Numero._Updatable = true;
                def_Numero._Validar_Asignar_Cargando = false;
                def_Numero._Validar_Dato_BaseDatos = "";
                def_Numero._Validar_Dato_Campos = "";
                def_Numero._Validar_Dato_CampoTRel_Asignar = "";
                def_Numero._Validar_Dato_Clave = "";
                def_Numero._Validar_Dato_Tabla = "";
                def_Numero._Visible = false;
 
 
                // Linea
                //
                this._AddCampoTRel("_Linia", "Linea", ewCampoTRel.Visible.No, ewCampoTRel.Updatable.Si, ewCampoTRel.Editable.No, "", gridColumnsTypes.Número);
                
                // Tipo de libro.
                // Campo real de la tabla que ocultamos pero actualizamos
                //
                this._AddCampoTRel("_TipoLibro", "Tipo", false, true, false);
 
 
                // Campo visible solamente. Como tal no se actualiza, pero el Set de la propiedad actualiza el valor de la propiedad _Tipo
                // Dejo la lista de elementos de cuentas bancarias vacía a la espera de que se haga el _Load(), es allí donde las carga.
                //
                ewCampoTRel def_TipoLibro = this._AddCampoTRel("_TipoLibroVisual", "", true, false, true, "Tipo de libro", gridColumnsTypes.Combo, toComboValues: this._lstTiposLibro, tnAnchoColumna : 24);
                def_TipoLibro._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_TipoLibro._Error_Duplicados = "";
                def_TipoLibro._Error_Validar_Dato = "";
                def_TipoLibro._ExpandirPunto = false;
                def_TipoLibro._FormatString = "";
                def_TipoLibro._PermiteDuplicados = false;
 
 
                // Ruta al archivo del libro
                //
                ewCampoTRel def_RutaArchivo = this._AddCampoTRel("_RutaArchivo", "Ruta_fich");
                def_RutaArchivo._AnchoColumna = 0;
                def_RutaArchivo._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.Fill;
                def_RutaArchivo._Editable = true;
                def_RutaArchivo._Error_Duplicados = "";
                def_RutaArchivo._Error_Validar_Dato = "";
                def_RutaArchivo._ExpandirPunto = false;
                def_RutaArchivo._FormatString = "";
                def_RutaArchivo._PermiteDuplicados = true;
                def_RutaArchivo._TipoColumna = gridColumnsTypes.Texto;
                def_RutaArchivo._Titulo = "Fichero";
                def_RutaArchivo._Updatable = true;
                def_RutaArchivo._Validar_Asignar_Cargando = false;
                def_RutaArchivo._Validar_Dato_BaseDatos = "";
                def_RutaArchivo._Validar_Dato_Campos = "";
                def_RutaArchivo._Validar_Dato_CampoTRel_Asignar = "";
                def_RutaArchivo._Validar_Dato_Clave = "";
                def_RutaArchivo._Validar_Dato_Tabla = "";
                def_RutaArchivo._Visible = true;
 
 
                // Columna de tipo botón para seleccionar un archivo.
                //
                this._AddCampoTRel("", "", ewCampoTRel.Visible.Si, ewCampoTRel.Updatable.No, ewCampoTRel.Editable.No, "", gridColumnsTypes.Boton, null, 2, null, "...");
 
 
                // Número de libro.
                //
                ewCampoTRel def_NumLibro = this._AddCampoTRel("_NumLibro", "Num_libro");
                def_NumLibro._AnchoColumna = 5;
                def_NumLibro._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_NumLibro._Editable = true;
                def_NumLibro._Error_Duplicados = "";
                def_NumLibro._Error_Validar_Dato = "";
                def_NumLibro._ExpandirPunto = false;
                def_NumLibro._FormatString = "";
                def_NumLibro._PermiteDuplicados = true;
                def_NumLibro._TipoColumna = gridColumnsTypes.Texto;
                def_NumLibro._Titulo = "Número";
                def_NumLibro._Updatable = true;
                def_NumLibro._Validar_Asignar_Cargando = false;
                def_NumLibro._Validar_Dato_BaseDatos = "";
                def_NumLibro._Validar_Dato_Campos = "";
                def_NumLibro._Validar_Dato_CampoTRel_Asignar = "";
                def_NumLibro._Validar_Dato_Clave = "";
                def_NumLibro._Validar_Dato_Tabla = "";
                def_NumLibro._Visible = true;
 
 
                // Fecha apertura
                //
                ewCampoTRel def_FechaApertura = this._AddCampoTRel("_FecApertura", "Fec_aper");
                def_FechaApertura._AnchoColumna = 7;
                def_FechaApertura._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_FechaApertura._Editable = true;
                def_FechaApertura._Error_Duplicados = "";
                def_FechaApertura._Error_Validar_Dato = "";
                def_FechaApertura._ExpandirPunto = false;
                def_FechaApertura._FormatString = "";
                def_FechaApertura._PermiteDuplicados = true;
                def_FechaApertura._TipoColumna = gridColumnsTypes.Fecha;
                def_FechaApertura._Titulo = "Fecha apertura";
                def_FechaApertura._Updatable = true;
                def_FechaApertura._Validar_Asignar_Cargando = false;
                def_FechaApertura._Validar_Dato_BaseDatos = "";
                def_FechaApertura._Validar_Dato_Campos = "";
                def_FechaApertura._Validar_Dato_CampoTRel_Asignar = "";
                def_FechaApertura._Validar_Dato_Clave = "";
                def_FechaApertura._Validar_Dato_Tabla = "";
                def_FechaApertura._Visible = true;
 
 
                // Fecha cierre
                //
                ewCampoTRel def_FechaCierre = this._AddCampoTRel("_FecCierre", "Fec_cierre");
                def_FechaCierre._AnchoColumna = 6;
                def_FechaCierre._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_FechaCierre._Editable = true;
                def_FechaCierre._Error_Duplicados = "";
                def_FechaCierre._Error_Validar_Dato = "";
                def_FechaCierre._ExpandirPunto = false;
                def_FechaCierre._FormatString = "";
                def_FechaCierre._PermiteDuplicados = true;
                def_FechaCierre._TipoColumna = gridColumnsTypes.Fecha;
                def_FechaCierre._Titulo = "Fecha cierre";
                def_FechaCierre._Updatable = true;
                def_FechaCierre._Validar_Asignar_Cargando = false;
                def_FechaCierre._Validar_Dato_BaseDatos = "";
                def_FechaCierre._Validar_Dato_Campos = "";
                def_FechaCierre._Validar_Dato_CampoTRel_Asignar = "";
                def_FechaCierre._Validar_Dato_Clave = "";
                def_FechaCierre._Validar_Dato_Tabla = "";
                def_FechaCierre._Visible = true;
 
 
                // Fecha cierre anterior
                //
                ewCampoTRel def_FechaCierreAnt = this._AddCampoTRel("_FecCierreAnt", "Fec_cie_an");
                def_FechaCierreAnt._AnchoColumna = 7;
                def_FechaCierreAnt._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_FechaCierreAnt._Editable = true;
                def_FechaCierreAnt._Error_Duplicados = "";
                def_FechaCierreAnt._Error_Validar_Dato = "";
                def_FechaCierreAnt._ExpandirPunto = false;
                def_FechaCierreAnt._FormatString = "";
                def_FechaCierreAnt._PermiteDuplicados = true;
                def_FechaCierreAnt._TipoColumna = gridColumnsTypes.Fecha;
                def_FechaCierreAnt._Titulo = "F.Cierre Lib.Ant.";
                def_FechaCierreAnt._Updatable = true;
                def_FechaCierreAnt._Validar_Asignar_Cargando = false;
                def_FechaCierreAnt._Validar_Dato_BaseDatos = "";
                def_FechaCierreAnt._Validar_Dato_Campos = "";
                def_FechaCierreAnt._Validar_Dato_CampoTRel_Asignar = "";
                def_FechaCierreAnt._Validar_Dato_Clave = "";
                def_FechaCierreAnt._Validar_Dato_Tabla = "";
                def_FechaCierreAnt._Visible = true;
 
                // Firma digital.
                // 
                ewCampoTRel def_Firma = this._AddCampoTRel("_Firma", "Firma");
                def_Firma._AnchoColumna = 0;
                def_Firma._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Firma._Editable = false;
                def_Firma._Error_Duplicados = "";
                def_Firma._Error_Validar_Dato = "";
                def_Firma._ExpandirPunto = false;
                def_Firma._FormatString = "";
                def_Firma._PermiteDuplicados = true;
                def_Firma._TipoColumna = gridColumnsTypes.Texto;
                def_Firma._Titulo = "Firma";
                def_Firma._Updatable = true;
                def_Firma._Validar_Asignar_Cargando = false;
                def_Firma._Validar_Dato_BaseDatos = "";
                def_Firma._Validar_Dato_Campos = "";
                def_Firma._Validar_Dato_CampoTRel_Asignar = "";
                def_Firma._Validar_Dato_Clave = "";
                def_Firma._Validar_Dato_Tabla = "";
                def_Firma._Visible = false;
 
                // Columna de tipo botón para ver el archivo.
                //
                //this._AddCampoTRel("_VerFichero", "", ewCampoTRel.Visible.Si, ewCampoTRel.Updatable.No, ewCampoTRel.Editable.No, "Ver fichero", gridColumnsTypes.Imagen, tnAnchoColumna: 3);
 
                ewCampoTRel def_Verfichero = this._AddCampoTRel("_VerFichero", "", ewCampoTRel.Visible.Si, ewCampoTRel.Updatable.No, ewCampoTRel.Editable.No, "", gridColumnsTypes.Imagen);
                def_Verfichero._AnchoColumna = 3;
                def_Verfichero._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Verfichero._Titulo = "Ver";
 
                // Columna de tipo imagén para mostrar aspa rojo o visto bueno en función de si se ha generado fichero y firma para una fichero.
                //
                //this._AddCampoTRel("_FicheroFirmado", "", ewCampoTRel.Visible.Si, ewCampoTRel.Updatable.No, ewCampoTRel.Editable.No, "Firmado", gridColumnsTypes.Imagen, tnAnchoColumna: 3);
                ewCampoTRel def_Firmado = this._AddCampoTRel("_FicheroFirmado", "", ewCampoTRel.Visible.Si, ewCampoTRel.Updatable.No, ewCampoTRel.Editable.No, "", gridColumnsTypes.Imagen);
                def_Firmado._AnchoColumna = 5;
                def_Firmado._AutoModeSizeColumna = DataGridViewAutoSizeColumnMode.None;
                def_Firmado._Titulo = "Firmado";
 
                return;
            }
 

            private void cargarDicLstTiposLibro()
            {
                this._dicTiposLibro.Clear();
 
                // Rellenar el diccionar con los tiposde libro.
                //
                this._dicTiposLibro.Add("Diario","DIARIO");
                this._dicTiposLibro.Add("Inventario y cuentas anuales" ,"INV_CUEN");
                this._dicTiposLibro.Add("Balances de comprobación (sumas y saldos)","BAL_SUMS");
                this._dicTiposLibro.Add("Inventario", "INVENTAR");
                this._dicTiposLibro.Add("Balances", "BALANCES");
                this._dicTiposLibro.Add("Memoria","MEMORIA");
                this._dicTiposLibro.Add("Mayor","MAYOR");
                this._dicTiposLibro.Add("Libro de Pérdidas y Ganancias","PER_GAN");
                this._dicTiposLibro.Add("IVA", "IVA");
                this._dicTiposLibro.Add("Facturas emitidas","FAC_EMIT");
                this._dicTiposLibro.Add("Facturas recibidas","FAC_RECI");
                this._dicTiposLibro.Add("Detalle del Diario","DET_DIA");
                this._dicTiposLibro.Add("Registro de Acciones Nominativas","ACCIONES");
                this._dicTiposLibro.Add("Registro de Socios", "SOCIOS");
                this._dicTiposLibro.Add("Libro de Actas" ,"ACTASCON");
                this._dicTiposLibro.Add("Libro de Detalle de Actas", "ACTASDET");
                this._dicTiposLibro.Add("Libro de Actas del Consejo", "ACTALCON");
                this._dicTiposLibro.Add("Libro de Detalle de Actas del Consejo","ACTACODE");
                this._dicTiposLibro.Add("Libro de Contratos del Socio Único con la Sociedad Unipersonal","SOCUNICO");
                this._dicTiposLibro.Add("Otros","OTROS");
 
                this._lstTiposLibro.Clear();
                foreach (KeyValuePair<string, string> loKeyValuePair in this._dicTiposLibro)
                    this._lstTiposLibro.Add(loKeyValuePair.Key);
 
                return;
            }
 
 
            #endregion CONSTRUCTOR
 
 
            #region MÉTODOS PUBLIC OVERRIDE SOBREESCRITOS DE EWMANTTREL
 

            public override void _Load()
            {
                // Nos aseguramos de que la clave esté bien informada.
                //
                this._Claves._Empresa._Valor = this._oLegalizacion._Empresa;
                this._Claves._Numero._Valor = this._oLegalizacion._Numero;
 
                this._bIsLoading = true;
 
                base._Load();
 
                this._bIsLoading = false;
 
                return;
            }
 

            [ExcludeFromCodeCoverage]
            public override bool _Save()
            {
                // Nos aseguramos de que la clave esté bien informada.
                //
                this._Claves._Empresa._Valor = this._oLegalizacion._Empresa;
                this._Claves._Numero._Valor = this._oLegalizacion._Numero;
 
                bool llOk = base._Save();
 
                return llOk;
            }
 
 
            #endregion MÉTODOS PUBLIC OVERRIDE SOBREESCRITOS DE EWMANTTREL
 

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

                public ClaveTRel _Numero { get; set; }
 

                public ClaveTRel _Linia { get; set; }
 

                public Clave()
                {
                    // Definición de las propiedades de cada una de las claves.
 
                    // Empresa de la legalización de libros.
                    //
                    this._Empresa = new ClaveTRel();
                    this._Empresa._EsFiltro = true;
                    this._Empresa._EsCampoLinea = false;
 
 
                    // Ejercicio de la legalización de libros.
                    //
                    this._Numero = new ClaveTRel();
                    this._Numero._EsFiltro = true;
                    this._Numero._EsCampoLinea = false;
 
 
                    // Linea del registdro de la legalización de libros.
                    //
                    this._Linia = new ClaveTRel();
                    this._Linia._EsCampoLinea = true;
                    this._Linia._Valor = 0;
                }
            }
 

            public class LineaLegalizacionLibros : ILinTRel
            {
                #region PROPIEDADES PRIVADAS
 

                private LineasLegalizacionLibros _oLineasLegalizacion
                {
                    get
                    {
                        return (LineasLegalizacionLibros)loParent;
                    }
                }
 
 
                #endregion PROPIEDADES PRIVADAS
 
                
                #region PROPIEDADES PUBLICAS
 

                [ReportProperty("Empresa", "", "Empresa:")]
                public string _Empresa
                {
                    get
                    {
                        return this._cEmpresa;
                    }
                    set
                    {
                        this._cEmpresa = value;
                    }
                }

                private string _cEmpresa = "";
 

                [ReportProperty("Ejercicio", "", "Ejercicio:")]
                public string _Numero
                {
                    get
                    {
                        return this._cNumero;
                    }
                    set
                    {
                        this._cNumero = value;
                    }
                }

                private string _cNumero = "";
 

                public int _Linia
                {
                    get { return _nLinia; }
                    set { _nLinia = value; }
                }
                private int _nLinia = 0;
 

                public string _TipoLibro
                {
                    get
                    {
                        if (_cTipoLibro == null)
                            _cTipoLibro = "";
 
                        return _cTipoLibro;
                    }
                    set
                    {
                        _cTipoLibro = value;
                    }
                }
                private string _cTipoLibro = "";
 

                public string _TipoLibroVisual
                {
                    get
                    {
                        string lcTipoLibroVisual = this._oLineasLegalizacion._dicTiposLibro.FirstOrDefault(x => x.Value == this._TipoLibro.Trim()).Key;
 
                        return lcTipoLibroVisual;
                    }
                    set
                    {
                        if (value == null)
                            return;
 
                        string lcTipoLibro = "";
 
                        this._oLineasLegalizacion._dicTiposLibro.TryGetValue(value.Trim(), out lcTipoLibro);
 
                        this._TipoLibro = lcTipoLibro;
                    }
                }
 

                public string _RutaArchivo
                {
                    get
                    {
                        return _cRutaArchivo;
                    }
                    set
                    {
                        _cRutaArchivo = value;
                    }
                }
                private string _cRutaArchivo = "";
 

                public string _NumLibro
                {
                    get
                    {
                        return _cNumLibro;
                    }
                    set
                    {
                        _cNumLibro = value;
                    }
                }
                private string _cNumLibro = "";
 

                [ReportProperty("FecApertura", "dd/MM/yyyy", "Fecha apertura:")]
                public DateTime? _FecApertura
                {
                    get
                    {
                        return this._dFecApertura;
                    }
                    set
                    {
                        if (loParent != null && !loParent._bIsLoading)
                        {
                            bool llCambio = (this._dFecApertura != value);
 
                            if (llCambio)
                            {
                                if (value !=null && this._dFecCierre != null && value >= this._dFecCierre)
                                {
                                    this._oLineasLegalizacion._oLegalizacion._Error_Message_Linea = "La fecha de apertura (" + Convert.ToDateTime(value).ToShortDateString() + ") debe ser inferior a la fecha de cierre (" + Convert.ToDateTime(this._dFecCierre).ToShortDateString() + ").";
                                    return; 
                                }
                            }
                        }
 
                        this._dFecApertura = value;
                    }
                }

                private DateTime? _dFecApertura = null;
 

                [ReportProperty("FecCierre", "dd/MM/yyyy", "Fecha cierre:")]
                public DateTime? _FecCierre
                {
                    get
                    {
                        return this._dFecCierre;
                    }
                    set
                    {
                        if (loParent != null && !loParent._bIsLoading)
                        {
                            bool llCambio = (this._dFecCierre != value);
 
                            if (llCambio)
                            {
                                if (value != null && this._dFecApertura != null && this._dFecApertura >= value)
                                {
                                    this._oLineasLegalizacion._oLegalizacion._Error_Message_Linea = "La fecha de cierre (" + Convert.ToDateTime(value).ToShortDateString() + ") debe ser superior a la fecha de apertura (" + Convert.ToDateTime(this._dFecApertura).ToShortDateString() + ").";
                                    return;
                                }
                            }
                        }
 
                        this._dFecCierre = value;
                    }
                }

                private DateTime? _dFecCierre = null;
 

                [ReportProperty("FecCierreAnt", "dd/MM/yyyy", "Fecha cierre libro anterior:")]
                public DateTime? _FecCierreAnt
                {
                    get
                    {
                        return this._dFecCierreAnt;
                    }
                    set
                    {
                        if (loParent != null && !loParent._bIsLoading && value != null)
                        {
                            bool llCambio = (this._dFecCierreAnt != value);
 
                            if (llCambio)
                            {
                                if (value !=  null && this._dFecApertura !=  null && value >= this._dFecApertura)
                                {
                                    this._oLineasLegalizacion._oLegalizacion._Error_Message_Linea = "La fecha de cierre anterior (" + Convert.ToDateTime(value).ToShortDateString() + ") debe ser inferior a la fecha de apertura (" + Convert.ToDateTime(this._dFecApertura).ToShortDateString() + ").";
                                    return;
                                }
                            }
                        }
 
                        this._dFecCierreAnt = value;
                    }
                }

                private DateTime? _dFecCierreAnt = null;
 

                public string _Firma
                {
                    get
                    {
                        return _cFirma;
                    }
                    set
                    {
                        _cFirma = value;
                    }
                }
                private string _cFirma = "";
 

                public object _Parent
                {
                    get { return loParent; }
                    set { loParent = (LineasLegalizacionLibros)value; }
                }
                private LineasLegalizacionLibros loParent;
 
 
                #endregion PROPIEDADES PUBLICAS
 
 
                #region CONSTRUCTOR
 

                public LineaLegalizacionLibros()
                {
                }
 
 
                #endregion CONSTRUCTOR
 
 
                #region MÉTODOS PÚBLICOS.
 

                public bool Fila_Plena()
                {
                    bool lbFilaPlena;
 
                    lbFilaPlena = _TipoLibro != "" && _RutaArchivo != "" ;
 
                    return lbFilaPlena;
                }
 
 
                #endregion MÉTODOS PÚBLICOS.
            }
        }
 
 
        #endregion CLASE DE LINEAS DE LIBROS PRESENTADOS EN LA LEGALIZACION
    }
 

    public class DocPrintLegalizacionLibros : DocPrint
    {
        [ExcludeFromCodeCoverage]
        public override bool _Print()
        {
            if (_Show_Print())
            {
                return _PrintNET();
            }
            return true;
        }
 

        [ExcludeFromCodeCoverage]
        public override bool _Show_Print(int tnAbrirEn = 1)
        {
            frmReportAction loForm;
 
            loForm = new frmReportAction();
            loForm._ReportBase = _Documento._ReportBase;
            loForm._Nombre = _Documento._Nombre;
            loForm._Printer = _Printer;
            loForm._ImpresionNormalMultiple = _ImpresionNormalMultiple;
            loForm._UserControlAdicional = _UserControlAdicional;
            loForm._PrinterCopies = Convert.ToInt16(_Numero_Copias);
            loForm._MostrarExportacionCSV = false;
            loForm._MostrarOpcionColores = false;
            loForm._ShowEditMode = true;
            loForm._ShowDialog();  
 
            if (loForm.DialogResult == DialogResult.OK)
            {
                _Vista_Preliminar = loForm._VistaPreliminar;
                _Ruta_Fichero = loForm._FilePath;
                _Printer = loForm._Printer;
                _Exportar = loForm._Exportar;
                _EditMode = loForm._EditMode;
                _FieldRandomBackColor = loForm._FieldRandomBackColor;
                _Formato_exportacion = loForm._FormatoExportacion;
 
                return true;
            }
 
            return false;
        }
 

        public DocPrintLegalizacionLibros(IDocumentoImprimible toLegalizacion) : base()
        {
            _Documento = toLegalizacion;
        }
    }
 
}