DocPrint.cs

//#define ewTools //Descomentar para medir el rendimiento
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using sage.ew.interficies;
using sage.ew.reports;
using sage.ew.empresa;
using sage.ew.global;
using sage.ew.ewbase.Clases;
using sage.ew.db;
using sage.ew.tpv.Clases;
using sage.ew.usuario;
using sage.ew.objetos;
using System.Data;
using System.IO;
using System.Windows.Forms;
using sage.ew.docsven;
using sage.ew.docscompra;
using sage.ew.docventatpv;
using sage.ew.functions;
using System.Drawing.Printing;
using sage.ew.enumerations;
using sage.ew.global.Diccionarios;
using System.Diagnostics;
using Sage.ES.S50.Comunicados.Negocio.Clases;
using System.Runtime.CompilerServices;
 
namespace sage.ew.ewbase
{
    public class DocPrint : IDocPrint
    {
        public enum eFormato_exportacion
        {
            Ninguno = 0,
            Pdf = 1,
            Excel = 2,
            Excel_xlsx = 3,
            Html = 4,
            Xml = 5,
            txt = 6,
            CSV = 7
        }
 
        #region Variables
 
        #region Variables de entorno

        protected bool _lHera = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_hera"));
        protected bool _lSage50 = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50"));
        protected bool _lColor = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_color"));
        protected bool _lPeso = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_peso"));
        protected bool _lCajas = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_cajas"));
 
        #endregion Variables de entorno

        private Empresa _oEmpresa = null;
        private Terminal _oTerminal = null;
        private Report _oReport = null;
        private IDocumentoImprimible _oDocumento = null;
        private List<OpcionesImpresion> _oOpciones_Impresion;
        private eFormato_exportacion _eFormato_exportacion = eFormato_exportacion.Ninguno;
        protected List<CampoOrdenacion> _oCamposOrdenacion = null;

        public event _ImpresionVistaPreliminarEvent _ImpresionVistaPreliminar;

        public delegate void _ImpresionVistaPreliminarEvent();
 
        private String _cPrinter = "";
        private String _cRutaFichero = "";
        private String _cTemplate;
        private String _cDestinatario_Email = "";
        private String _cPlantillaComunicado = "";
        private int _nNumero_Copias = 0;
        private bool _lIVA_Desglosado = true;
        private bool _lEditMode = false;
        private bool _lValorado = true;
        private bool _lVista_Preliminar = false;
        private bool _lFieldRandomBackColor = false;
        private bool _lExportar = false;
        private bool _lEmail = false;
        private bool _lEmailAut = false;
        private DataTable _dtPlantillasComunicados = null;
        private ImpresionNormalMultiple _oTipoImpresion = ImpresionNormalMultiple.Normal;
        protected String _cIdioma = "";
        protected UserControl _oUserControlAdicional = null;
        private Boolean _bUnMailCliente = false;
        private Boolean _bMarcarImpreso = false;
        private List<FiltroImpresion> _oFiltrosDocumentosImpresion = new List<FiltroImpresion>();
        protected String _cReportBaseEW = "";
        private String _cErrorMessage = "";
 
        #region Mascaras

        private ewMascara _oMascaraImport = new ewbase.ewMascara(ew.global.EW_GLOBAL._GetMascara(KeyDiccionarioMascara.wc_total));
        private ewMascara _oMascaraPrecio = new ewbase.ewMascara(ew.global.EW_GLOBAL._GetMascara(KeyDiccionarioMascara.wc_precioven));
        protected ewMascara _oMascaraPorcent = new ewbase.ewMascara(ew.global.EW_GLOBAL._GetMascara(KeyDiccionarioMascara.wc_tpc));
        protected ewMascara _oMascaraUnidades = new ewbase.ewMascara(ew.global.EW_GLOBAL._GetMascara(KeyDiccionarioMascara.wc_unidades));
        protected ewMascara _oMascaraPeso = new ewbase.ewMascara(ew.global.EW_GLOBAL._GetMascara(KeyDiccionarioMascara.wc_mascarapeso));
        protected ewMascara _oMascaraCajas = new ewbase.ewMascara(ew.global.EW_GLOBAL._GetMascara(KeyDiccionarioMascara.wc_mascaracajas));
        private bool _bImprimirExelOpenXml = false;

        public Boolean _ImprimirExelOpenXml
        {
            get
            {
                return _bImprimirExelOpenXml;
            }
            set
            {
                _bImprimirExelOpenXml = value;
            }
        }

        public ewMascara _Mascara_Importes
        {
            get
            {
                return _oMascaraImport;
            }
        }

        public ewMascara _Mascara_Precios
        {
            get
            {
                return _oMascaraPrecio;
            }
        }

        public ewMascara _Mascara_Porcentajes
        {
            get
            {
                return _oMascaraPorcent;
            }
        }

        public ewMascara _Mascara_Unidades
        {
            get
            {
                return _oMascaraUnidades;
            }
        }

        public ewMascara _Mascara_Pesos
        {
            get
            {
                return _oMascaraPeso;
            }
        }

        public ewMascara _Mascara_Cajas
        {
            get
            {
                return _oMascaraCajas;
            }
        }
 
        #endregion Mascaras
 
        #endregion Variables
 
        #region PROPIEDADES

        public virtual Boolean _ShowEditMode
        {
            get
            {
                return true;
            }
        }

        public string _Idioma
        {
            get
            {
                return _cIdioma;
            }
            set
            {
                if (_cIdioma != value)
                {
                    _cIdioma = value;
                    _Printer = String.Empty;
                }
            }
        }

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

        public String _ReportBaseEW
        {
            get
            {
                return _cReportBaseEW;
            }
        }

        public Boolean _UnMailCliente
        {
            get
            {
                return _bUnMailCliente;
            }
            set
            {
                _bUnMailCliente = value;
            }
        }
 

        public Boolean _MarcarImpreso
        {
            get
            {
                return _bMarcarImpreso;
            }
            set
            {
                _bMarcarImpreso = value;
            }
        }

        public string _Template
        {
            get
            {
                return _cTemplate;
            }
            set
            {
 
                if (_cTemplate != value)
                {
                    _cTemplate = value;
                    _cPrinter = String.Empty;
                }
            }
        }

        protected IDocumentoImprimible _Documento
        {
            get
            {
                return _oDocumento;
            }
            set
            {
                _oDocumento = value;
            }
        }

        protected Empresa _Empresa
        {
            get
            {
                if (_oDocumento == null || String.IsNullOrWhiteSpace(_oDocumento._Empresa))
                {
                    _oEmpresa = EW_GLOBAL._Empresa;
                }
                else if (_oDocumento != null && (_oEmpresa == null || _oEmpresa._Codigo != _oDocumento._Empresa))
                {
                    _oEmpresa = Empresa._NewEmpresa(_oDocumento._Empresa);
                    _oEmpresa._Load_Codigo_Config();
                }
 
                return _oEmpresa;
            }
        }

        protected Terminal _Terminal
        {
            get
            {
                if (_oTerminal == null) _oTerminal = EW_GLOBAL._Terminal == null ? new Terminal() : EW_GLOBAL._Terminal as Terminal;
 
                return _oTerminal;
            }
        }

        protected IFileDialog365 _FileDialog
        {
            get
            {
                if (_oFileDialog == null)
                {
                    _oFileDialog = EW_GLOBAL._FileDialog365;
                }
                return _oFileDialog;
            }
        }
        private IFileDialog365 _oFileDialog = null;

        protected Report _Report
        {
            get
            {
                if (_oReport == null) _oReport = _CrearReport();
                return _oReport;
            }
            set
            {
                _oReport = value;
            }
        }

        public ImpresionNormalMultiple _ImpresionNormalMultiple
        {
            get
            {
                return _oTipoImpresion;
            }
            set
            {
                _oTipoImpresion = value;
            }
        }

        public virtual bool _DivisaActiva
        {
            get
            {
                bool divisaActiva = false;
                if (_Documento != null &&  //Tengo documento
                   _Documento is IDivisaOperable && //Es operable con divisa 
                   !string.IsNullOrWhiteSpace(((IDivisaOperable)_Documento)._Divisa)) //Tengo divisa informada
                {
                    divisaActiva = !Divisa._EsDivisaEmpresa(((IDivisaOperable)_Documento)._Divisa);
                }
                return divisaActiva;
            }
        }

        public virtual String _Printer
        {
            get
            {
                if (String.IsNullOrWhiteSpace(_cPrinter)) _cPrinter = Obtener_impresora();
                if (String.IsNullOrWhiteSpace(_cPrinter)) _cPrinter = _DefaultSystemPrinter;
                return _cPrinter;
            }
            set
            {
                _cPrinter = value;
            }
        }

        public virtual String _DefaultSystemPrinter
        {
            get
            {
                PrinterSettings loSettings = new PrinterSettings();
                return loSettings.PrinterName;
            }
        }

        public List<OpcionesImpresion> _Opciones_Impresion
        {
            get
            {
                return _oOpciones_Impresion;
            }
            set
            {
                _oOpciones_Impresion = value;
            }
        }

        public virtual UserControl _UserControlAdicional
        {
            get
            {
                return _oUserControlAdicional;
            }
            set
            {
                _oUserControlAdicional = value;
            }
        }

        public bool _IVA_Desglosado
        {
            get
            {
                return _lIVA_Desglosado;
            }
            set
            {
                _lIVA_Desglosado = value;
            }
        }

        public bool _Valorado
        {
            get
            {
                return _lValorado;
            }
            set
            {
                _lValorado = value;
            }
        }

        public virtual bool _Vista_Preliminar
        {
            get
            {
                return _ImpresionNormalMultiple == ImpresionNormalMultiple.Normal ? _lVista_Preliminar : false;
            }
            set
            {
                _lVista_Preliminar = value;
 
                if (value && _ImpresionVistaPreliminar == null)
                {
                    _ImpresionVistaPreliminar += () => { _MarcaDocumentoImpreso(); };
                }
            }
        }
 

        public virtual void _MarcaDocumentoImpreso()
        {
            if (_oDocumento is IMarcaImpreso)
            {
                ((IMarcaImpreso)_oDocumento)._Printed();
            }
        }

        public int _Numero_Copias
        {
            get
            {
                return _nNumero_Copias;
            }
            set
            {
                _nNumero_Copias = value;
            }
        }

        public string _Ruta_Fichero
        {
            get
            {
                return _cRutaFichero;
            }
            set
            {
                if (value == null) _cRutaFichero = ""; //PE-94887 Estos valores se pasan a VFP y este no admite nulos
                else _cRutaFichero = value;
            }
        }

        public bool _EditMode
        {
            get
            {
                return _lEditMode;
            }
            set
            {
                _lEditMode = value;
            }
        }

        public bool _FieldRandomBackColor
        {
            get
            {
                return _lFieldRandomBackColor;
            }
            set
            {
                _lFieldRandomBackColor = value;
            }
        }

        public eFormato_exportacion _Formato_exportacion
        {
            get
            {
                return _eFormato_exportacion;
            }
            set
            {
                _eFormato_exportacion = value;
            }
        }

        public bool _Exportar
        {
            get
            {
                return _lExportar;
            }
            set
            {
                _lExportar = value;
            }
        }

        public string _Destinatario_Email
        {
            get
            {
                return _cDestinatario_Email;
            }
            set
            {
                if (value == null) _cDestinatario_Email = ""; //PE-94887 Estos valores se pasan a VFP y este no admite nulos
                else _cDestinatario_Email = value;
            }
        }

        public bool _EmailAut
        {
            get
            {
                return _lEmailAut;
            }
            set
            {
                _lEmailAut = value;
            }
        }

        public bool _Email
        {
            get
            {
                return _lEmail;
            }
            set
            {
                _lEmail = value;
            }
        }

        public virtual List<CampoOrdenacion> _CamposOrdenacion
        {
            get
            {
                return _oCamposOrdenacion;
            }
            set
            {
                _oCamposOrdenacion = value;
            }
        }

        public string _PlantillaComunicado
        {
            get
            {
                return _cPlantillaComunicado;
            }
            set
            {
                _cPlantillaComunicado = value;
            }
        }
 
        #endregion PROPIEDADES
 
        #region Eventos

        public delegate void _Evento_Exportacion_Completada(object sender, ExportEventArgs e);

        public event _Evento_Exportacion_Completada _Evento_Exportacion_Finalizada;

        public class ExportEventArgs : EventArgs
        {
 
            #region Propiedades

            public string _Path { get; set; }
 
            #endregion Propiedades
 
            #region Constructores

            public ExportEventArgs() : base()
            {
                _Path = "";
            }

            public ExportEventArgs(string TcPath) : base()
            {
                _Path = TcPath;
            }
 
            #endregion Constructores
        }

        protected void _LanzarEvento_ExportacionCompletada(string tcPath)
        {
            //Si hay suscriptores les aviso
            if (_Evento_Exportacion_Finalizada != null)
                _Evento_Exportacion_Finalizada(this, new ExportEventArgs(tcPath));
        }
 
        #endregion Eventos
 
        #region Métodos IDocPrint

        public virtual bool _Print()
        {
            throw new NotImplementedException();
        }

        public virtual bool _Show_Print(int tnAbrirEn = 1)
        {
            throw new NotImplementedException();
        }

        public virtual DocPrint _Clonar(DocPrint toDocPrint)
        {
            toDocPrint._Valorado = _Valorado;
            toDocPrint._IVA_Desglosado = _IVA_Desglosado;
            toDocPrint._Idioma = _Idioma;
            toDocPrint._EmailAut = _EmailAut;
            toDocPrint._Vista_Preliminar = _Vista_Preliminar;
            toDocPrint._Destinatario_Email = _Destinatario_Email;
            toDocPrint._PlantillaComunicado = _PlantillaComunicado;
            toDocPrint._Numero_Copias = _Numero_Copias;
            toDocPrint._Ruta_Fichero = _Ruta_Fichero;
            toDocPrint._CamposOrdenacion = _CamposOrdenacion;
            toDocPrint._Exportar = _Exportar;
            toDocPrint._Formato_exportacion = _Formato_exportacion;
            toDocPrint._Email = _Email;
            toDocPrint._Template = _Template;
            toDocPrint._Printer = _Printer;
            toDocPrint._ImpresionNormalMultiple = _ImpresionNormalMultiple;
            toDocPrint._UserControlAdicional = null;
 
            return toDocPrint;
        }
 

        public virtual DataTable _OrdenarDatosSageReports(List<CampoOrdenacion> loCamposOrdenacion, DataTable tdDatos)
        {
            String lcOrden = "";
 
            if (loCamposOrdenacion.Count > 0)
            {
                foreach (CampoOrdenacion loCampo in loCamposOrdenacion)
                {
                    if (tdDatos.Columns.Contains(loCampo._Campo))
                    {
                        if (!String.IsNullOrEmpty(lcOrden)) lcOrden += ",";
                        lcOrden += String.Format("{0} {1}", loCampo._Campo, loCampo._TipoOrden == CampoOrdenacion.TipoOrden.Ascendente ? "asc" : "desc");
                    }
                }
 
                if (!String.IsNullOrEmpty(lcOrden))
                {
                    DataView loDataView;
 
                    tdDatos.CaseSensitive = true; //Bug 109134
                    loDataView = tdDatos.DefaultView;
                    loDataView.Sort = lcOrden;
                    tdDatos = loDataView.ToTable();
                }
            }
 
            return tdDatos;
        }
 
        #endregion Métodos IDocPrint
 
        #region Métodos auxiliares

        public virtual void _OpenEditor()
        {
            _Report?._OpenEditor();
        }

        protected virtual bool _PrintNET()
        {
            bool llOk = true;
 
            //Determino acción predeterminada
            Report.ReportAction loAction = Obtener_accion(); //Se crea un método para poder reaprovechar el código desde clases deribadas
 
            //Ponemos el nombre que utilizará para la impresión
            _Report._Name = _GetFileReportName(_Documento._Nombre);
            String lcPath = _Ruta_Fichero;
            Boolean llExportO365 = false;
 
            if (_FileDialog._IsPath(lcPath))
            {
                lcPath = Path.GetTempFileName() + lcPath.Substring(lcPath.LastIndexOf("."));
                llExportO365 = true;
            }
 
            //T111264
            _Report._FieldRandomBackColor = _FieldRandomBackColor;
 
            _AsignarEventoImpresionVistaPreviaAfter(loAction);
 
            if (_ImprimirExelOpenXml && _Exportar && loAction == Report.ReportAction.xlsx)
            {
                _ExportarOpenXml(lcPath);
            }
            else
            {
                //Bloqueamos el usuario
                _Lock(loAction);
                //Bloqueamos el usuario
                _Report._ExecuteAction(ref lcPath, loAction, _Printer, Convert.ToInt16(_Numero_Copias), llSuppressUserInteraction: true);
                //Desbloqueamos el usuario
                _UnLock(loAction);
            }
 
            if (loAction != Report.ReportAction.prn)
            {
 
                //PE-96202
                switch (loAction) //En función de la acción determino 
                {
                    //No hacer nada, solo exportaciones
                    case Report.ReportAction.Email:
                    case Report.ReportAction.none:
                    case Report.ReportAction.preview:
                    case Report.ReportAction.prn:
                    case Report.ReportAction.edit:
                        break;
 
                    default:
 
                        if (llExportO365)
                        {
                            _FileDialog._UploadFile(lcPath, _Ruta_Fichero);
                        }
                        _LanzarEvento_ExportacionCompletada(lcPath); //Notifico la ruta de exportación a los suscriptores
                        break;
                }
 
                //Adicionamente a la exportación se puede haber indicado que lo mande por email
                if (!String.IsNullOrWhiteSpace(_Destinatario_Email) && File.Exists(lcPath)) _SendEmail(lcPath);
              }
 
            if (Debugger.IsAttached && !String.IsNullOrEmpty(_Report._Error_Message)) MessageBox.Show(_Report._Error_Message);
 
            //Corto el vínculo entre el documento y el objeto de impresión para no arrastrar configuraciones 
            _Documento._DocPrint = null;
 
            return llOk;
        }

        protected void _Lock(Report.ReportAction toAction)
        {
            if (toAction == Report.ReportAction.edit) Usuario._This._LockConnect($"EDIT {_ReportBase}");
        }
        
        protected void _UnLock(Report.ReportAction toAction)
        {
            if (toAction == Report.ReportAction.edit) Usuario._This._UnLockConnect();
        }
 

        public virtual String _GetFileReportName(String tcNombre)
        {
            return tcNombre;
        }

        protected virtual Boolean _ExportarOpenXml(String tcPath)
        {
            ExportExcel loExport = new ExportExcel(tcPath);
            return loExport.CreateFile(_Report._ReportTitle, _Report._ReportData);
        }

        public String _ValidaExtension(String tcPath)
        {
            Report.ReportAction loAction = Obtener_accion();
 
            return Report._ValidaExtension(loAction, tcPath);
 
        }

        protected void _AsignarEventoImpresionVistaPreviaAfter(Report.ReportAction toAction, Report toReport = null)
        {
            if (toAction == Report.ReportAction.preview && _ImpresionVistaPreliminar != null)
            {
                if (toReport is Report)
                {
                    toReport._ImpresionVistaPreliminar += () => { _ImpresionVistaPreliminar(); };
                }
                else
                {
                    _Report._ImpresionVistaPreliminar += () => { _ImpresionVistaPreliminar(); };
                }
            }
        }

        protected virtual bool _SendEmail(string tcFileName)
        {
            return _SendEmail(tcFileName, new List<string>());
        }

        protected bool _SendEmail(string tcFicherosAdjuntos, List<string> toEmailsCCO)
        {
            return _SendEmail(tcFicherosAdjuntos.Split('|').ToList(), toEmailsCCO);
        }

        protected bool _SendEmail(List<string> toFicherosAdjuntos, List<string> toEmailsCCO)
        {
#if ewTools //Rendimiento
            EwTools._WriteTrace(EwTools.eMethodStatus.Inicio);
#endif
            bool llOk = true;
            string lcSubject = _Documento._Nombre;
            string lcBody = "";
 
            // PE-104751. Revisión para terminar de centralizar el envío del correo mediante la nueva clase "SendMail"
 
            // Preparar emails destino
            List<string> loEmailsDestino = new List<string>();
            loEmailsDestino = _Destinatario_Email.Split(';').ToList();
 
            if (toFicherosAdjuntos.Count > 0)
            {
                lcBody = (toFicherosAdjuntos.Count > 1) ? "Se adjuntan los siguientes archivos o vínculos: " : "Se adjunta el siguiente archivo o vínculo: ";
                lcBody += string.Join(", ", toFicherosAdjuntos.Select(f => Path.GetFileName(f)));
            }
 
            //PE-101222: Preparar datos para guardar log al enviar email
            string lcCliente = string.Empty;
            string lcProveedor = string.Empty;
            string lcClientePotencial = string.Empty;
            string lcResumen = string.Empty;
            dynamic loDoc = _Documento;
 
            if (loDoc != null)
            {
                if (loDoc is EntregasFactura)
                {
                    lcCliente = loDoc._Items[0]._Codigo;
                    lcResumen = "Entregas a cuenta: " + loDoc._Items[0]._Factura;
                }
                else
                {
                    switch ((eTipoDocumento)loDoc._TipoDocumento)
                    {
                        case eTipoDocumento.AlbaranCompra:
                            lcProveedor = loDoc._Cabecera._Proveedor;
                            lcResumen = "Albaran de compra: " + loDoc._Numero;
                            break;
 
                        case eTipoDocumento.DepositoCompra:
                            lcProveedor = loDoc._Cabecera._Proveedor;
                            lcResumen = "Depósito de compra: " + loDoc._Numero;
                            break;
 
                        case eTipoDocumento.FacturaCompra:
                            lcProveedor = loDoc._Cabecera._Proveedor;
                            lcResumen = "Factura de compra: " + loDoc._Numero;
                            break;
 
                        case eTipoDocumento.PedidoCompra:
                            lcProveedor = loDoc._Cabecera._Proveedor;
                            lcResumen = "Pedido de compra: " + loDoc._Numero;
                            break;
 
                        case eTipoDocumento.PropuestaCompra:
                            lcProveedor = loDoc._Cabecera._Proveedor;
                            lcResumen = "Propuesta de compra: " + loDoc._Numero;
                            break;
 
                        case eTipoDocumento.AlbaranVenta:   // Albaran de venta no facturado
                        case eTipoDocumento.Factura:        // Albaran de venta facturado
                        case eTipoDocumento.Ticket:         // Albaran de venta facturado como ticket
                            lcCliente = loDoc._Cabecera._Cliente;
                            lcResumen = "Albarán de venta: " + loDoc._Letra + loDoc._Numero;
                            break;
 
                        case eTipoDocumento.DepositoVenta:
                            lcCliente = loDoc._Cabecera._Cliente;
                            lcResumen = "Depósito de venta: " + loDoc._Letra + loDoc._Numero;
                            break;
 
                        case eTipoDocumento.FacturaVenta:
 
                            string lcBodyExtra = "";
 
                            //PE-102719 : Tener en cuenta los textos configurables de Informes (Empresa > Configuracion > Informes > Textos)
                            if (!string.IsNullOrWhiteSpace(_Empresa._Mensaje_FactElec_Asunto))
                                lcSubject = _oEmpresa._Mensaje_FactElec_Asunto + " : " + lcSubject;
 
                            lcBodyExtra = _GetBodyExtra();
 
                            if (!string.IsNullOrWhiteSpace(lcBodyExtra))
                                lcBody = $"{FUNCTIONS.TextToHtml(lcBodyExtra)}<br><br>{lcBody}";
 
                            lcCliente = loDoc._Cabecera._Cliente;
                            lcResumen = "Factura de venta: " + loDoc._Letra + loDoc._Numero;
                            break;
 
                        case eTipoDocumento.PedidoVenta:
                            lcCliente = loDoc._Cabecera._Cliente;
                            lcResumen = "Pedido de venta: " + loDoc._Letra + loDoc._Numero;
                            break;
 
                        case eTipoDocumento.PresupuestoVenta:
                            lcCliente = loDoc._Cabecera._Cliente;
                            lcClientePotencial = loDoc._Cabecera._Futuro ? Convert.ToString(loDoc._Cabecera._Futuro_Cliente) : "";
                            lcResumen = "Presupuesto de venta: " + loDoc._Letra + loDoc._Numero;
                            break;
 
                        case eTipoDocumento.Services:
                            lcCliente = loDoc._Cliente;
                            lcResumen = "Servicio: " + loDoc._Letra + loDoc._Numero;
                            break;
                    }
                }
            }
 
            // PE-104208. Usar la nueva clase
            SendMail loSendMail = new SendMail
            {
                _Emails = loEmailsDestino,
                _Subject = lcSubject,
                _Body = lcBody,
                _Attachments = toFicherosAdjuntos,
                _ShowEmailForm = !_EmailAut,
                _CCOUsuarioActivo = toEmailsCCO.Count == 0,
                _CCUsuarioActivo = toEmailsCCO.Count == 0,
                _EmailsCCO = toEmailsCCO
            };
 
            // Task 198556 - Configurar email según plantilla
            ConfigurarPlantillaComunicado(loSendMail, lcCliente, lcProveedor, lcClientePotencial);
 
            // Bug 173603 : Permitimos reconfigurar el objeto
            _ConfigureSendMail(loSendMail);
 
            // Envío del correo
            llOk = loSendMail._Send(lcCliente, lcProveedor, lcResumen);
 
            if (!llOk && !string.IsNullOrWhiteSpace(loSendMail._Error_Message))
                FUNCTIONS._MessageBox(loSendMail._Error_Message, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, DialogResult.OK);
 
            return llOk;
        }

        protected virtual string _GetBodyExtra()
        {
            return _Empresa._Mensaje_FactElec_Cuerpo.Trim();
        }
 
        // Bug 173603
        public virtual void _ConfigureSendMail(SendMail sendmail)
        {
 
        }

        public virtual Report _CrearReport()
        {
#if ewTools //Rendimiento
            EwTools._WriteTrace(EwTools.eMethodStatus.Inicio);
#endif
 
            DataTable ldtLineas = new DataTable();
            Report loReport = null;
            List<FilterReportBase> llisFiltros = new List<FilterReportBase>();
 
            //PE-88304
            loReport = new Report(_GetReportFileName(), ldtLineas);
 
            //PE-97636 DEbemos poner el nombre del report base
            loReport._TableName = loReport._ReportTitle = _GetReportBase();
            //loReport._ReportTitle = lcReportName;
 
            loReport._ReportTitlePreview = _Documento._ReportTitlePreview; //PE-103490
            loReport._Name = _Documento._Nombre;
 
            //Forzamos que los ajuste de tamaño se realizen sobre el campo definición
            loReport._FieldNameOnAutosizeForze = "descripcion";
 
            _ConfigurePath(loReport);
 
            if (_Documento != null)
            {
                //Indicamos el tipo de documento
                loReport._TipoDocumento = _GetTipoDocumento();
 
                //Recuperación de filtros de cabecera de documento
                Dictionary<string, object> ldicParametrosReport = new Dictionary<string, object>();
 
#if ewTools //Rendimiento
                EwTools._WriteTrace(EwTools.eMethodStatus.Llamando, "_ConfigurarObtencionFiltros");
#endif
                //Llamo al método específico de cada Subclase para la recuperación de la configuración a utilizar durante la recuperación de filtros en el documento
                _ConfigurarObtencionFiltros(ref ldicParametrosReport);
#if ewTools //Rendimiento
                EwTools._WriteTrace(EwTools.eMethodStatus.Volviendo, "_ConfigurarObtencionFiltros");
#endif
 
                //Obtengo los datos específicos del _Documento
                _GetFilters(_Documento, ldicParametrosReport, ref llisFiltros);
#if ewTools //Rendimiento
                EwTools._WriteTrace(EwTools.eMethodStatus.Llamando, "_Obtener_Datos_SageReports");
#endif
                //Obtengo los datos de las líneas
                DataTable loDataTable = _Documento._Obtener_Datos_SageReports(ldicParametrosReport);
                //T107428 Ordenamos los datos seleccionados
                loDataTable = _OrdenarDatosSageReports(_GetCamposOrdenacion(), loDataTable);
 
                if (_Documento is ISageReportsEditDataProvider) loDataTable = ((ISageReportsEditDataProvider)_Documento)._Modificar_Datos_SageReports(loDataTable, ldicParametrosReport);
 
                loReport._ReportData = loDataTable;
 
#if ewTools //Rendimiento
                EwTools._WriteTrace(EwTools.eMethodStatus.Volviendo, "_Obtener_Datos_SageReports");
#endif
                //Asignamos si trabaja con divisas
                loReport._WorksWithDivisa = _DivisaActiva;
            }
 
#if ewTools //Rendimiento
            EwTools._WriteTrace(EwTools.eMethodStatus.Llamando, "Asignar loReport._Filtros ");
#endif
            loReport._Filtros = llisFiltros;
#if ewTools //Rendimiento
            EwTools._WriteTrace(EwTools.eMethodStatus.Volviendo, "Asignar loReport._Filtros ");
#endif
            // Lanzar impresión
            //loReport._OpenEditor(); //Descomentar esta linea si se estan copiando reports para poder editar el apartado ENLACES y cambiar la tabla
 
#if ewTools //Rendimiento
            EwTools._WriteTrace(EwTools.eMethodStatus.Fin);
#endif
 
            return loReport;
        }
 

        private void ConfigurarPlantillaComunicado(SendMail loSendMail, string tcCliente, string tcProveedor, string tcClientePotencial)
        {
            // Si no hay plantilla comunicado no hacer nada
            if (string.IsNullOrWhiteSpace(_PlantillaComunicado))
                return;
 
            // Obtener la información de la plantilla
            DataRow dtRow = ConfigurarPlantillaComunicadoCodigo(_PlantillaComunicado);
            if (dtRow == null)
                return;
 
            string lcAsunto = Convert.ToString(dtRow["asunto"]);
            string lcCuerpo = Convert.ToString(dtRow["cuerpo"]);
 
            // Sustituir el asunto    
            loSendMail._Subject = !string.IsNullOrWhiteSpace(lcAsunto) ? lcAsunto : loSendMail._Subject;
 
            string lcFigura =  string.Empty;
            ComunicadosGenerar.ComunicaTipoFigura loTipoFigura = ComunicadosGenerar.ComunicaTipoFigura.Cliente;
            if (!string.IsNullOrWhiteSpace(tcClientePotencial))
            {
                lcFigura = tcClientePotencial;
                loTipoFigura = ComunicadosGenerar.ComunicaTipoFigura.ClientePotencial;
            }
            else if (!string.IsNullOrWhiteSpace(tcCliente))
            {
                lcFigura = tcCliente;
                loTipoFigura = ComunicadosGenerar.ComunicaTipoFigura.Cliente;
            }
            else if (!string.IsNullOrWhiteSpace(tcProveedor))
            {
                lcFigura = tcProveedor;
                loTipoFigura = ComunicadosGenerar.ComunicaTipoFigura.Proveedor;
            }
 
            ComunicadosGenerar loGenerar = new ComunicadosGenerar();
            loGenerar._EnvioDocumentoEmailPorPlantillaUnoAUno = !this._EmailAut;
            if (loGenerar._Simular(lcFigura, loTipoFigura, lcCuerpo))
                loSendMail._Body = loGenerar._ResultHtml;
            loGenerar = null;
        }

        private DataRow ConfigurarPlantillaComunicadoCodigo(string tcCodigo)
        {
            DataRow dtRow = null;
            if (_dtPlantillasComunicados == null)
            {
                using (PlantillasComunicados loPlantilla = new PlantillasComunicados())
                    _dtPlantillasComunicados = loPlantilla._GetPlantillas(4);
            }
 
            if (_dtPlantillasComunicados != null)
                dtRow = _dtPlantillasComunicados.AsEnumerable().Where(x => x.Field<string>("codigo") == _PlantillaComunicado).ToList().FirstOrDefault();
 
            return dtRow;
        }
 
 
        private void _ConfigurePath(Report toReport)
        {
            _ConfigureCustomPath(toReport);
 
            toReport._PathServer = Convert.ToString(EW_GLOBAL._GetVariable("wc_iniservidor"));
        }
                        

        protected virtual void _ConfigureCustomPath(Report toReport)
        {
            ((ReportPath)toReport._Path)._Empresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
            ((ReportPath)toReport._Path)._Usuario = Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario"));
            ((ReportPath)toReport._Path)._Caja = Convert.ToString(EW_GLOBAL._GetVariable("wc_cajatpv"));
        }

        protected virtual TipoDocumento _GetTipoDocumento()
        {
            TipoDocumento loTipo;
 
            if (_Documento is ewDocCompraPEDIDO)
            {
                loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Pedicom);
            }
            else if (_Documento is ewDocCompraALBARAN)
            {
                loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Albacom);
            }
            else if (_Documento is ewDocCompraFACTURA)
            {
                loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Factucom);
            }
            else if (_Documento is ewDocCompraDEPOSITO)
            {
                loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Depocom);
            }
            else if (_Documento is ewDocCompraPROPUESTA)
            {
                loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Precom);
            }
            else if (_Documento is ewDocVentaDEPOSITO)
            {
                loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Depoven);
            }
            else if (_Documento is ewDocVentaPRESUP)
            {
                loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Presuven);
            }
            else if (_Documento is ewDocVentaTPV)
            {
                loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Albaven);
            }
            else if (_Documento is ewDocVentaFRA)
            {
                loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Factuven);
            }
            else if (_Documento is ewDocVentaPED)
            {
                loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Pediven);
            }
            else
            {
                loTipo = new TipoDocumento();
            }
 
            return loTipo;
        }

        private List<CampoOrdenacion> _GetCamposOrdenacion()
        {
            List<CampoOrdenacion> loCamposSeleccionados = new List<CampoOrdenacion>(); ;
 
            if (_CamposOrdenacion is List<CampoOrdenacion>)
            {
                loCamposSeleccionados = (from loCampo in _CamposOrdenacion
                                        where loCampo._Seleccionado && !String.IsNullOrEmpty(loCampo._Campo)
                                        select loCampo).ToList();
            }
 
            return loCamposSeleccionados;
        }

        protected virtual string _GetReportBase()
        {
            return _Documento._ReportBase;
        }

        public String _ReportBase
        {
            get
            {
                return _GetReportBase();
            }
        }

        public List<FiltroImpresion> _FiltrosDocumentosImpresion
        {
            get
            {
                return _oFiltrosDocumentosImpresion;
            }
            set
            {
                _oFiltrosDocumentosImpresion = value;
            }
        }
 
        //PE-95253
        protected virtual Report.ReportAction Obtener_accion()
        {
#if ewTools //Rendimiento
            EwTools._MedirTiempo(EwTools.eMethodStatus.Inicio);
#endif
 
            Report.ReportAction loAction = _Vista_Preliminar ? Report.ReportAction.preview : Report.ReportAction.prn;
 
            //Miro si debo modificar la acción por otra de exportación
            if (_Exportar || !String.IsNullOrEmpty(_Destinatario_Email)) //Si tengo marcado exportación o destinatario de email
            {
                switch (_Formato_exportacion)
                {
                    case eFormato_exportacion.Excel:
                        loAction = Report.ReportAction.xls;
                        break;
                    case eFormato_exportacion.Excel_xlsx:
                        loAction = Report.ReportAction.xlsx;
                        break;
                    case eFormato_exportacion.Html:
                        loAction = Report.ReportAction.html;
                        break;
                    case eFormato_exportacion.Xml:
                        loAction = Report.ReportAction.xml;
                        break;
                    //T111264
                    case eFormato_exportacion.txt:
                        loAction = Report.ReportAction.txt;
                        break;
                    case eFormato_exportacion.CSV:
                        loAction = Report.ReportAction.delimited;
                        break;
                    //Marcada exportación pero sin elegir formato => Se elige PDF
                    case eFormato_exportacion.Ninguno:
                    case eFormato_exportacion.Pdf:
                    default:
                        loAction = Report.ReportAction.pdf;
                        break;
                }
            }
 
#if ewTools //Rendimiento
            EwTools._MedirTiempo(EwTools.eMethodStatus.Fin);
#endif
 
            //T111264
            if (_EditMode) loAction = Report.ReportAction.edit;
 
            return loAction;
        }

        protected string Obtener_impresora()
        {
#if ewTools //Rendimiento
            EwTools._MedirTiempo(EwTools.eMethodStatus.Inicio);
#endif
 
            String lcSql;
            string lcPrinterName = "";
            DataTable ldtImpresora = new DataTable();
 
            #region Configuración del terminal
 
            //Determinamos si realemte hay un registro para este código
            if (_Terminal._ExisteRegistro)
            {
                String lcDocumento = "";
 
                //Ahora trato de mejorar el resultado mirando si hay una específica para el documento
                if(!String.IsNullOrEmpty(_ReportBaseEW))
                {
                    lcDocumento = _ReportBaseEW;
                }
                else if (_Documento != null)
                {
                    lcDocumento = _Documento._ReportBase;
                }                
 
                if (String.IsNullOrEmpty(lcPrinterName))
                {
                    lcSql = "";
                    //PE-95961
                    if (Convert.ToBoolean(_Terminal._Campo("HERCONFTPV")))
                    {
                        lcSql = String.Format("SELECT  i.GUID_ID FROM {0} i INNER JOIN {1} c ON i.CODIGO = c.IMPRESORA2 WHERE c.CODIGO = '{2}' ", DB.SQLDatabase("TPV", "IMPRESOR"), DB.SQLDatabase("TPV", "CAJAS"), EW_GLOBAL._GetVariable("wc_cajatpv"));
                    }
                    else if (!String.IsNullOrEmpty(_Terminal._Campo("IMPNORM").ToString().Trim()))
                    {
                        lcSql = String.Format("SELECT  i.GUID_ID FROM {0} i WHERE i.CODIGO = '{1}' ", DB.SQLDatabase("TPV", "IMPRESOR"), _Terminal._Campo("IMPNORM"));
                    }
 
 
                    if(!String.IsNullOrEmpty(lcSql))
                    {
                        ldtImpresora = new DataTable();
                        DB.SQLExec(lcSql, ref ldtImpresora);
 
                        if(ldtImpresora.Rows.Count > 0)
                        {
                            tpv.Impresora loImpresora = new tpv.Impresora();
                            loImpresora._Load(Convert.ToString(ldtImpresora.Rows[0][0]));
                            if(!String.IsNullOrEmpty(loImpresora._Nombre_Local)) lcPrinterName = functions.FUNCTIONS._GetPrinterDriver(loImpresora._Nombre_Local); //PE-95961 Se añade un trim al nombre de impresora ya que viene con espacios en blanco
                        }
                    }
 
                    //PE-96827
                    if (String.IsNullOrEmpty(lcPrinterName)) lcPrinterName = Convert.ToString(_Terminal._Campo("IMPRESORA")).TrimEnd();
                }
            }
 
            #endregion Configuración del terminal
 
            #region Configuración de último uso SAGE REPORTS
 
            //Sino tengo nombre de impresora lo busco en COMUNES.SAGEREPORTS
            if (String.IsNullOrWhiteSpace(lcPrinterName))
            {
                string lcSageReportPrinter = "";
 
                if (!String.IsNullOrEmpty(_Template))
                {
                    lcSageReportPrinter = Convert.ToString(DB.SQLValor("SAGEREPORTS", new string[2] { "USUARIO", "ID_REPLAN" }, new string[2] { Usuario._This._Codigo, _Template }, "IMPRESORA", "COMUNES"));
                }
                else
                {
                    lcSageReportPrinter = Convert.ToString(DB.SQLValor("SAGEREPORTS", new string[2] { "USUARIO", "LOWER(REPORT)" }, new string[2] { Usuario._This._Codigo, _GetReportFileName() }, "IMPRESORA", "COMUNES"));
                }
                if (!String.IsNullOrWhiteSpace(lcSageReportPrinter)) lcPrinterName = lcSageReportPrinter.TrimEnd(); //Si he obtenido impresora asigno.
            }
 
            #endregion Configuración de último uso SAGE REPORTS
 
#if ewTools //Rendimiento
            EwTools._MedirTiempo(EwTools.eMethodStatus.Fin);
#endif
 
            return lcPrinterName;
        }

        public string _ObtenerImpresoraRes(String tcDocumento)
        {
            return Convert.ToString(DB.SQLValor("IMP_REPS", new string[2] { "TERMINAL", "UPPER(INFORME)" }, new string[2] { _Terminal._Codigo, tcDocumento }, "IMPRESORA", "COMUNES"));
        }

        protected bool _GetFilters(ISageReportsFilterProvider toOrigen, Dictionary<string, object> toParams, ref List<FilterReportBase> tlisFiltros)
        {
#if ewTools //Rendimiento
            EwTools._MedirTiempo(EwTools.eMethodStatus.Inicio);
#endif
            //Diccionario de recogida de filtros
            bool llOk = true;
 
            Dictionary<string, object> ldicFiltrosDefecto, ldicFiltrosNegocio;
 
            ldicFiltrosNegocio = toOrigen._Obtener_Filtros_SageReports(toParams);
 
            llOk = _AddFiltersFromDicctionary(ldicFiltrosNegocio, ref tlisFiltros);
 
            ldicFiltrosDefecto = ReportTPV._ObtenerFiltrosDefecto();
 
            llOk = _AddFiltersFromDicctionary(ldicFiltrosDefecto, ref tlisFiltros);
 
#if ewTools //Rendimiento
            EwTools._MedirTiempo(EwTools.eMethodStatus.Fin);
#endif
            return llOk;
        }

        protected bool _AddFiltersFromDicctionary(Dictionary<string, object> toDiccionario, ref List<FilterReportBase> toFiltros)
        {
            bool llOk = true;
 
            List<String> loKeys = (from loFiltro in toFiltros
                                   select loFiltro._Key).ToList();
 
            foreach (KeyValuePair<string, object> loKeyValue in toDiccionario)
            {
                if(!loKeys.Contains(loKeyValue.Key) && loKeyValue.Value != null)
                {
                    Type loType = loKeyValue.Value.GetType();
 
                    if(loKeyValue.Value is FilterReportBase)
                    {
                        toFiltros.Add((FilterReportBase)loKeyValue.Value);
                    }
                    else if (loType == typeof(String) || loType == typeof(Int32) || loType == typeof(Int16) || loType == typeof(Boolean))
                    {
                        toFiltros.Add(new FilterReport(loKeyValue.Key, Convert.ToString(loKeyValue.Value), FilterReport.TypeFilter.Especial));
                    }
                    else
                    {
                        //Sage Reports soporta objects pero la clase puente ReportTPV no esta preparada
                        throw new ArgumentException(String.Format("Tipo de datos del filtro {0}  no soportado. Tipo: {1}", loKeyValue.Key, loType.ToString()));
                    }
                }
            }
               
            return llOk;
        }

        public void _ConfigurarObtencionFiltros(ref Dictionary<string, object> toDiccionario)
        {
            _Configurar_obtencion_filtros(ref toDiccionario);
        }

        protected virtual void _Configurar_obtencion_filtros(ref Dictionary<string, object> toDiccionario)
        {
            //Este método debe implementarse en las clases deribadas y sirve para generar un diccionario con las propiedades específicas del DocPrintXXX concreto y poder 
            //mandarlo al _Documento usando los métodos de la BASE (DocPrint)
        }

        protected virtual string _GetReportName()
        {
            return _Documento != null ? _Documento._ReportBase : "";
        }

        public virtual String _GetReportFileName()
        {
            return String.Format("{0}.report", _GetReportName().ToLower());
        }
 
        #endregion Métodos auxiliares
 
        #region Métodos públicos

        public virtual void _ObtenerConfigurarionOpcionesImpresionMultiple()
        {
 
        }
 
        //PE-95253
        public eFormato_exportacion _Obtener_formato_exportacion(ewTiposExportacion teTipo)
        {
            eFormato_exportacion leResultado = eFormato_exportacion.Ninguno;
 
            switch (teTipo)
            {
                case ewTiposExportacion.Excel:
                    leResultado = eFormato_exportacion.Excel;
                    break;
                case ewTiposExportacion.HTML:
                    leResultado = eFormato_exportacion.Html;
                    break;
 
                case ewTiposExportacion.XML:
                    leResultado = eFormato_exportacion.Xml;
                    break;
 
                case ewTiposExportacion.PDF:
                default:
                    leResultado = eFormato_exportacion.Pdf;
                    break;
            }
            return leResultado;
        }

        public bool _ValidatePrinting()
        {
            if(!ValidatePrinting())
            {
                _Reset();
                return false;
            }
 
            return true;
        }

        protected virtual void _Reset()
        {
            _oReport = null;
            _PlantillaComunicado = "";
            _Exportar = false;
        }

        protected virtual bool ValidatePrinting()
        {
           _ErrorMessage = "";
 
            if(!Report.IsSageReportInstaled())
            {
                _ErrorMessage = $"No se puede realizar {GetAccion()}.{Environment.NewLine}Sage Reports no está intalado.";
            }
            // PE-101701. Hay que comprobar que el documento exista en el disco
            else if (!File.Exists(_Report?._Path?._PathFile))
            {
                _ErrorMessage = $"No se puede realizar {GetAccion()}, el fichero del report {_Report._ReportFile.ToUpper()} no existe.";
            }
            else if (_Exportar)
            {
                if (!string.IsNullOrEmpty(_Ruta_Fichero) && !Directory.Exists(Path.GetDirectoryName(_Ruta_Fichero)))
                {
                    if (!string.IsNullOrEmpty(_Destinatario_Email))
                    {
                        if (Directory.Exists(EW_GLOBAL._Ruta_Exportacion_Docs()))
                        {
                            _Ruta_Fichero = Path.Combine(EW_GLOBAL._Ruta_Exportacion_Docs(), Path.GetFileName(_Ruta_Fichero));
                        }
                        else
                        {
                            _ErrorMessage = "La ruta de exportación configurada en el mantenimiento de empresa es incorrecta.";
                        }
                    }
                    else
                    {
                        _ErrorMessage = $"No se puede realizar {GetAccion()}, el path del fichero de exportación {Path.GetDirectoryName(_Ruta_Fichero)} no existe.";
                    }
                }
                else if (string.IsNullOrEmpty(_Ruta_Fichero))
                {
                    _ErrorMessage = "La ruta de exportación no puede estar vacia.";
                }
            }
 
            return string.IsNullOrEmpty(_ErrorMessage);
 
        }
 
        private string GetAccion()
        {
            string lcAccion;
            Report.ReportAction loAction;
 
            loAction = Obtener_accion();
 
            switch (loAction)
            {
                case Report.ReportAction.htmlPrn:
                case Report.ReportAction.prn:
                    lcAccion = "la impresión";
                    break;
                case Report.ReportAction.preview:
                    lcAccion = "la previsualización";
                    break;
                case Report.ReportAction.edit:
                    lcAccion = "la edición";
                    break;
                default:
                    lcAccion = "la exportación";
                    break;
 
            }
 
            return lcAccion;
        }

        public DocPrint()
        {
 
        }
 
        #endregion Métodos públicos
    }

    public class MultiDocPrint<T> : DocPrint where T : IDocumentoImprimible
    {
        private IDocPrint _oDocPrint = null;
        private String _cReportTitlePreview;
        private String _cNombre;

        public List<T> _Items = new List<T>();

        public String _ErrorMessages = "";

        public override Report _CrearReport()
        {
            DataTable ldtLineas = new DataTable();
            Report loReport = null;
            List<FilterReportBase> llisFiltros = new List<FilterReportBase>();
 
            //PE-88304
            loReport = new Report(((DocPrint)_DocPrint)._GetReportFileName(), ldtLineas);
 
            //PE-97636 DEbemos poner el nombre del report base
            loReport._TableName = loReport._ReportTitle = ((DocPrint)_DocPrint)._ReportBase;
            //loReport._ReportTitle = lcReportName;
 
            loReport._ReportTitlePreview = _Items.Count == 1 && !String.IsNullOrWhiteSpace(_Items[0]._ReportTitlePreview) ? _Items[0]._ReportTitlePreview : _ReportTitlePreview;
            loReport._Name = _Items.Count == 1 && !String.IsNullOrWhiteSpace(_Items[0]._Nombre) ? _Items[0]._Nombre : _Nombre;
 
            loReport._PathServer = Convert.ToString(EW_GLOBAL._GetVariable("wc_iniservidor"));
            ((ReportPath)loReport._Path)._Empresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
            ((ReportPath)loReport._Path)._Usuario = Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario"));
            ((ReportPath)loReport._Path)._Caja = Convert.ToString(EW_GLOBAL._GetVariable("wc_cajatpv"));
 
            if (_Items.Count > 0)
            {
                //Recuperación de filtros de cabecera de documento
                Dictionary<string, object> ldicParametrosReport = new Dictionary<string, object>();
 
                _AddFiltersFromDicctionary(ReportTPV._ObtenerFiltrosDefecto(), ref llisFiltros);
 
                //Obtengo los datos de las líneas
                DataTable loDataTable = _ObtenerDatosSageReports(ldicParametrosReport);
 
                loReport._ReportData = loDataTable;
 
                //Asignamos si trabaja con divisas
                loReport._WorksWithDivisa = _DivisaActiva;
 
            }
            loReport._Filtros = llisFiltros;
 
            return loReport;
        }

        public string _ReportTitlePreview
        {
            get
            {
                return _cReportTitlePreview;
            }
            set
            {
                _cReportTitlePreview = value;
            }
        }

        public string _Nombre
        {
            get
            {
                return _cNombre;
            }
            set
            {
                _cNombre = value;
            }
        }

        public IDocPrint _DocPrint
        {
            get
            {
                if (!(_oDocPrint is IDocPrint))
                {
                    _Documento = ((IDocumentoImprimible)Activator.CreateInstance(typeof(T), true));
                    _oDocPrint = _Documento._DocPrint;
                }
                return _oDocPrint;
            }
        }

        public override bool _Show_Print(int tnAbrirEn = 1)
        {
            if (_DocPrint is IDocPrint)
            {
                ((DocPrint)_Documento._DocPrint)._ImpresionNormalMultiple = _ImpresionNormalMultiple;
 
                if (_Documento._Show_Print(tnAbrirEn))
                {
                    ((DocPrint)_Documento._DocPrint)._Clonar((DocPrint)this);
                    return true;
                }
            }
            return false;
        }

        public override void _MarcaDocumentoImpreso()
        {
            if(_Items.Count > 0)
            { 
                foreach (T loItem in _Items)
                {
                    if (loItem is IMarcaImpreso) ((IMarcaImpreso)loItem)._Printed();
                }
            }
        }
 
        private DataTable _ObtenerDatosSageReports(Dictionary<string, object> tdicParametros = null)
        {
            DataTable loDt = null;
            DataTable loDtToPrint = null;
            StringBuilder loErrors = new StringBuilder();
            Int32 lnCopias = 0;
 
            if (_Numero_Copias < 0) _Numero_Copias = 0;
 
            foreach (IDocumentoImprimible loItem in _Items)
            {
                try
                {
                    loItem._DocPrint._Numero_Copias = _Numero_Copias;
 
                    loDt = loItem._Obtener_Datos_SageReports(tdicParametros);
                    if (loItem is ISageReportsEditDataProvider) loDt = ((ISageReportsEditDataProvider)loItem)._Modificar_Datos_SageReports(loDt, tdicParametros);
 
                    while (lnCopias <= _Numero_Copias)
                    {
                        if (loDtToPrint is DataTable)
                        {
                            if (loDt.Rows.Count > 0)
                            {
                                foreach (DataRow loRow in loDt.Rows)
                                {
                                    loDtToPrint.ImportRow(loRow);
                                }
                            }
                        }
                        else
                        {
                            loDtToPrint = loDt.Copy();
                        }
                        lnCopias++;
                    }
                    lnCopias = 0;
                }
                catch (Exception loEx)
                {
                    loErrors.AppendLine(loEx.Message);
                }
            }
 
            _Numero_Copias = 0;
            _ErrorMessages = loErrors.ToString();
 
            return loDtToPrint;
        }

        protected override bool _PrintNET()
        {
            bool llOk = true;
 
            // PE-101701. Hay que comprobar que el documento exista en el disco
            if (!File.Exists(_Report._Path._PathFile))
            {
                _ErrorMessages = String.Format("El report {0} no existe", _Report._ReportFile);
                return false;
            }
 
            //Determino acción predeterminada
            Report.ReportAction loAction = Obtener_accion(); //Se crea un método para poder reaprovechar el código desde clases deribadas
 
            String lcPath = _Ruta_Fichero;
            Boolean llExportO365 = false;
            //FileDialog365 oFileDialog = DeterminarExportacionO365(ref lcPath, ref llExportO365);
            if (_FileDialog._IsPath(lcPath))
            {
                lcPath = Path.GetTempFileName() + lcPath.Substring(lcPath.LastIndexOf("."));
                llExportO365 = true;
            }
 
            //T111264
            _Report._FieldRandomBackColor = _FieldRandomBackColor;
 
            _AsignarEventoImpresionVistaPreviaAfter(loAction);
            //Bloqueamos el usuario
            _Lock(loAction);
            //Ejecutamos
            _Report._ExecuteAction(ref lcPath, loAction, _Printer, 0, llSuppressUserInteraction: true);
            //Desbloqueamos el usuario
            _UnLock(loAction);
 
            if (loAction != Report.ReportAction.prn)
            {
                //PE-96202
                switch (loAction) //En función de la acción determino 
                {
                    //No hacer nada, solo exportaciones
                    case Report.ReportAction.Email:
                    case Report.ReportAction.none:
                    case Report.ReportAction.preview:
                    case Report.ReportAction.prn:
                    case Report.ReportAction.edit:
                        break;
                    default:
                        //PE-97035
                        if (llExportO365) _FileDialog._UploadFile(lcPath, _Ruta_Fichero);
 
                        //Notifico la ruta de exportación a los suscriptores
                        _LanzarEvento_ExportacionCompletada(lcPath);
                        break;
                }
 
                //Adicionamente a la exportación se puede haber indicado que lo mande por email
                if (!String.IsNullOrWhiteSpace(_Destinatario_Email) && File.Exists(lcPath)) _SendEmail(lcPath);
            }
 
            return llOk;
        }

        public override Boolean _Print()
        {
            Boolean lOk = false;
 
            if (TransformReport._TransformReportToLabel(_Report))
            {
                lOk = _PrintNET();
            }
 
            return lOk;
        }
 
    }
}