ReportTemplates.cs

using System;
using System.Collections.Generic;
using System.Linq;
using sage.ew.enumerations;
using System.Data;
using sage.ew.db;
using sage.ew.formul.Forms;
using sage.ew.global;
using sage.ew.reports;
using System.IO;
using sage.ew.ewbase.Clases;
using sage.ew.docscompra;
using sage.ew.docsven;
using sage.ew.docventatpv;
using sage.ew.cliente;
using System.Windows.Forms;
using sage.ew.functions;
using sage.ew.objetos;
using sage.ew.interficies;
using Sage.ES.S50.Addons;

namespace sage.ew.ewbase
{

    public class TipoReport
        : ITipoReport
    {
        private int _nCodigo;
        private string _cDescripcion;
        private string _cReportBase;
        private bool _bCrearRegistroDefecto = true;

        public int _Codigo
        {
            get
            {
                return _nCodigo;
            }
        }

        public string _Descripcion
        {
            get
            {
                return _cDescripcion;
            }
        }

        public string _ReportBase
        {
            get
            {
                return _cReportBase;
            }
        }

        public bool _CrearRegistroDefecto
        {
            get
            {
                return _bCrearRegistroDefecto;
            }
            set
            {
                _bCrearRegistroDefecto = value;
            }
        }

        public TipoReport(int tnCodigo, string tcDescripcion, string tcReportBase)
        {
            _nCodigo = tnCodigo;
            _cDescripcion = tcDescripcion;
            _cReportBase = tcReportBase;
        }
    }

    public class ConfigReportTemplates
        :IConfigReportTemplates
    {
        private ReportPath _oReportPath = null;
        private List<ITipoReport> _oListadoTiposReport = null;
      
        public List<ITipoReport> _ListadoTiposReport
        {
            get
            {
                if (_oListadoTiposReport == null)
                {
                    _oListadoTiposReport = new List<ITipoReport>();

                    foreach (int lnVal in Enum.GetValues(typeof(TiposReport)))
                    {
                        TiposReport loTipo = (TiposReport)Enum.Parse(typeof(TiposReport), Convert.ToString(lnVal));

                        TipoReport loTipoReport = new TipoReport(lnVal, loTipo.__GetDescription(), loTipo.ToString().ToUpper().Trim())
                        {
                            _CrearRegistroDefecto = loTipo != TiposReport.SinDefinir
                        };

                        _oListadoTiposReport.Add(loTipoReport);
                    }
                }

                return _oListadoTiposReport;
            }
        }

        public ReportTPV _GetReportTPV(int tnTipo, string tcFichero, dynamic toDoc)
        {
            bool lDocCamposAdi = true;
            DataTable loDataTable;
            ReportTPV loReport = null;
            DataTrasp loDataTrasp = new DataTrasp();
            TipoDocumento loTipo = new TipoDocumento();
            dynamic loDocument = null;
            var admiteFiltros = true;
            var tipoReport = Report.TipoReport.Informe; //Defecto
            var directorioTipoEtiqueta = "";
            var campoReportNonVisibleFields = true;

            //PE-103473
            switch (tnTipo)
            {
                case (int)TiposReport.Pediven:
                    loDocument = new ewDocVentaPED();
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Pediven);
                    break;
                case (int)TiposReport.Albaven:
                    loDocument = new ewDocVentaTPV();
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Albaven);
                    break;
                case (int)TiposReport.Ticket:
                    loDocument = new ewDocVentaTPV();
                    loDocument._Cabecera._Tipo_Doc = Convert.ToInt32(eTipoDocumento.Ticket);
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Ticket);
                    break;
                case (int)TiposReport.Factuven:
                    loDocument = new ewDocVentaFRA();
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Factuven);
                    lDocCamposAdi = false;
                    break;
                case (int)TiposReport.Depoven:
                    loDocument = new ewDocVentaDEPOSITO();
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Depoven);
                    break;
                case (int)TiposReport.Presuven:
                    loDocument = new ewDocVentaPRESUP();
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Presuven);
                    break;
                case (int)TiposReport.Depocom:
                    loDocument = new ewDocCompraDEPOSITO();
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Depocom);
                    break;
                case (int)TiposReport.Pedicom:
                    loDocument = new ewDocCompraPEDIDO();
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Pedicom);
                    break;
                case (int)TiposReport.Precom:
                    loDocument = new ewDocCompraPROPUESTA();
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Precom);
                    break;
                case (int)TiposReport.Albacom:
                    loDocument = new ewDocCompraALBARAN();
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Albacom);
                    break;
                case (int)TiposReport.Factucom:
                    loDocument = new ewDocCompraFACTURA();
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Factucom);
                    lDocCamposAdi = false;
                    break;

                case (int)TiposReport.Envio:
                    loDocument = new EtiquetasEnvio();
                    ((EtiquetasEnvio)loDocument)._TipoImpresion = EtiquetasEnvio.TipoImpresion.Etiquetas;
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Envio);
                    directorioTipoEtiqueta = "envioeti"; //Se usa para construir el path del template.
                    lDocCamposAdi = false;
                    admiteFiltros = false;
                    tipoReport = Report.TipoReport.Etiqueta;
                    campoReportNonVisibleFields = false;
                    break;

                case (int)TiposReport.Hoja_rep:
                    //Por la ubicación del report es un informe pese a compartir clase con etiquetas de envio
                    loDocument = new EtiquetasEnvio();
                    ((EtiquetasEnvio)loDocument)._TipoImpresion = EtiquetasEnvio.TipoImpresion.HojaReparto;
                    loTipo = new TipoDocumento(TipoDocumento.eTipoDocumento.Hoja_rep);
                    lDocCamposAdi = false;
                    admiteFiltros = false;
                    campoReportNonVisibleFields = false;

                    break;
            }

            if (loDocument != null)
            {
                //Preparamos los datos por defecto del report
                Dictionary<string, object> ldicParametrosReport = new Dictionary<string, object>();

                loDataTable = loDocument._Obtener_Datos_SageReports(ldicParametrosReport);
                if (toDoc is ISageReportsEditDataProvider) loDataTable = ((ISageReportsEditDataProvider)toDoc)._Modificar_Datos_SageReports(loDataTable, ldicParametrosReport);

                Dictionary<string, object> ldicFiltrosReport = null;
                if(admiteFiltros)
                    ldicFiltrosReport = loDocument._Obtener_Filtros_SageReports(ldicParametrosReport);

                loReport = new ReportTPV(loDocument._ReportBase, $"{tcFichero}.report", loDataTable, null, ldicFiltrosReport, tipoReport)
                {
                    _TipoDocumento = loTipo
                };
                loDataTrasp._DocumentName = loDocument._ReportTitlePreview;

                DataTrasp.Config loConfig = new DataTrasp.Config(loTipo, EW_GLOBAL._Empresa._CamposAdicionalesDocumentos && lDocCamposAdi)
                {
                    _ConnectionString = DB.Conexion,
                    _Comunes = DB.DbComunes,
                    _TablaCamposAdicionales = DB.SQLDatabase("GESTION", "MCAMPOS") //Campos adicionales
                };


                if (tipoReport == Report.TipoReport.Etiqueta) //Para genericas
                {
                    ((ReportEtiquetaPath)loReport._Path)._TipoEtiqueta = directorioTipoEtiqueta;
                    
                }
                else 
                {
                    if (campoReportNonVisibleFields)
                    {
                        loConfig._ReportNonVisibleFields = loDocument._ReportNonVisibleFields;
                    }
                }


                AddonsController.Instance.Commands.ReportTemplatesAddDataBase(loConfig);

                loDataTrasp._DataTraspConfig = loConfig;
                loDataTrasp._GlobalVar = EW_GLOBAL._GetAllVariable();
                loReport._DataTrasp = loDataTrasp;
            }

            return loReport;

        }

        public BaseReportPath _GetReportPath()
        {
            if(_oReportPath == null) _oReportPath = new ReportPath();
            return _oReportPath;
        }

        public String _DB
        {
            get
            {
                return "COMUNES";
            }
        }

        public ReportTemplatesBase _GetReportTemplates(String tcEmpresa)
        {
            return new ReportTemplates(tcEmpresa);
        }

        public ReportTemplatesBase _GetReportTemplates(String tcEmpresa, String tcIdioma)
        {
            return new ReportTemplates(tcEmpresa, tcIdioma);
        }
    }

   
    public class ReportTemplate:
        ewMante
    {
        public enum TipoBase
        {
            Formato = 1,
            Idioma = 2
        }

        private dynamic _oLink;
        private bool _bIsNew = false;
        private ITipoReport _oTipoReport;
        private string _cIdioma, _cEmpresa;
        private ReportTemplate _oTemplateBase = null;

        private static string _cGrupoEmpresa;
        private static BaseReportPath _oReportPath;
        private static string _cPathServer = Convert.ToString(EW_GLOBAL._GetVariable("wc_iniservidor"));

        private IConfigReportTemplates _oConfigReportTemplates;

        public IConfigReportTemplates _ConfigReportTemplates
        {
            get
            {
                return _oConfigReportTemplates;
            }
            private set
            {
                _oConfigReportTemplates = value;

                _oReportPath = _oConfigReportTemplates._GetReportPath();
                _DataBase = _oConfigReportTemplates is IConfigReportTemplates ? _oConfigReportTemplates._DB : "COMUNES";
            }
        }

        protected void _OpenTemplate()
        {
            ReportTPV loReport = null;
            DataTrasp loDataTrasp = new DataTrasp();

            loReport = _ConfigReportTemplates._GetReportTPV(_TipoReport._Codigo, _Fichero, _Documento);

            if (loReport == null)
            { 
                loReport = new ReportTPV(_ReportBase, $"{_Fichero}.report", null, null, Report.TipoReport.Informe);
                loDataTrasp._GlobalVar = EW_GLOBAL._GetAllVariable();
                loReport._DataTrasp = loDataTrasp;
                
                loReport._Path = _ReportPath;
                loReport._Path._ReportFile = $"{_Fichero}.report";
            }

            if (loReport._Path is BaseReportPath)
            {
                if (string.IsNullOrEmpty(loReport._Path._PathServer)) loReport._Path._PathServer = Convert.ToString(EW_GLOBAL._GetVariable("wc_iniservidor"));
                if (string.IsNullOrEmpty(loReport._Path._ReportFile)) loReport._Path._ReportFile = $"{_Fichero}.report";

                loReport._OpenEditor();
            }
        }

        public List<ITipoReport> _ListadoTiposReport
        {
            get
            {
                return _ConfigReportTemplates._ListadoTiposReport;
            }
        }


        public ReportTemplate _TemplateBase
        {
            get
            {
                if (_oTemplateBase == null) _oTemplateBase = _ObtenerBase();

                return _oTemplateBase;
            }
            set
            {
                _oTemplateBase = value;
            }
        }

        private String _GrupoEmpresa
        {
            get
            {
                return _cGrupoEmpresa;
            }
        }

        public TipoBase _TipoBase { get; set; } = TipoBase.Idioma;

        public dynamic _Link
        {
            get
            {
                return _oLink;
            }
            set
            {
                _oLink = value;
            }
        }

        public new bool _IsNew
        {
            get
            {
                return _bIsNew;
            }
            set
            {
                _bIsNew = value;
            }
        }

        public override string _Codigo
        {
            get
            {
                return base._Codigo;
            }
            set
            {
                base._Codigo = value;

                if (!string.IsNullOrWhiteSpace(value)) _Id = Convert.ToInt32(value);
            }
        }

        public int _Id
        {
            get
            {
                return (_lisCampos.ContainsKey("ID") || Convert.ToInt32(_lisCampos["ID"]._NewVal) > 0) ? Convert.ToInt32(_lisCampos["ID"]._NewVal) : 0;
            }
            set
            {
                if (_lisCampos.ContainsKey("ID")) _lisCampos["ID"]._NewVal = value;
            }
        }

        public bool _TodasEmp
        {
            get
            {
                return _lisCampos.ContainsKey("TODASEMP") ? Convert.ToBoolean(_lisCampos["TODASEMP"]._NewVal) : false;
            }
            set
            {
                if (_lisCampos.ContainsKey("TODASEMP")) _lisCampos["TODASEMP"]._NewVal = value;
            }
        }

        public int _Parent
        {
            get
            {
                return (_lisCampos.ContainsKey("ID_PARENT") || Convert.ToInt32(_lisCampos["ID_PARENT"]._NewVal) > 0) ? Convert.ToInt32(_lisCampos["ID_PARENT"]._NewVal) : 0;
            }
            set
            {
                if (_lisCampos.ContainsKey("ID_PARENT")) _lisCampos["ID_PARENT"]._NewVal = value;
            }
        }

        public override string _Nombre
        {
            get
            {
                return (_lisCampos.ContainsKey("NOMBRE")) ? Convert.ToString(_lisCampos["NOMBRE"]._NewVal) : String.Empty;
            }
            set
            {
                if (_lisCampos.ContainsKey("NOMBRE")) _lisCampos["NOMBRE"]._NewVal = value;
            }
        }

        public string _FicheroExt
        {
            get
            {
                return $"{_Fichero}.report";
            }
        }

        public string _Fichero
        {
            get
            {
                return (_lisCampos.ContainsKey("FICHERO") && !string.IsNullOrWhiteSpace(Convert.ToString(_lisCampos["FICHERO"]._NewVal))) ? Convert.ToString(_lisCampos["FICHERO"]._NewVal).Trim() : _GetNameFichero(_Empresa, _Idioma);
            }
            set
            {
                if (_lisCampos.ContainsKey("FICHERO")) _lisCampos["FICHERO"]._NewVal = value;
            }
        }

        public string _Observaciones
        {
            get
            {
                return (_lisCampos.ContainsKey("OBSERVA") && !string.IsNullOrWhiteSpace(Convert.ToString(_lisCampos["OBSERVA"]._NewVal))) ? Convert.ToString(_lisCampos["OBSERVA"]._NewVal).Trim() : String.Empty;
            }
            set
            {
                if (_lisCampos.ContainsKey("OBSERVA")) _lisCampos["OBSERVA"]._NewVal = value;
            }
        }

        public bool _Predet
        {
            get
            {
                return (_lisCampos.ContainsKey("PREDET")) ? Convert.ToBoolean(_lisCampos["PREDET"]._NewVal) : false;
            }
            set
            {
                if (_lisCampos.ContainsKey("PREDET")) _lisCampos["PREDET"]._NewVal = value;
            }
        }

        public string _Idioma
        {
            get
            {
                return _lisCampos.ContainsKey("IDI_PLAN") ? Convert.ToString(_lisCampos["IDI_PLAN"]._NewVal).Trim() : string.Empty;
            }
            set
            {
                if (_lisCampos.ContainsKey("IDI_PLAN")) _lisCampos["IDI_PLAN"]._NewVal = value;
                _cIdioma = value;
            }
        }

        public string _Empresa
        {
            get
            {
                return _lisCampos.ContainsKey("EMPRESA") && !string.IsNullOrWhiteSpace(Convert.ToString(_lisCampos["EMPRESA"]._NewVal)) ? Convert.ToString(_lisCampos["EMPRESA"]._NewVal) : Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
            }
            set
            {
                if (_lisCampos.ContainsKey("EMPRESA")) _lisCampos["EMPRESA"]._NewVal = value;
                _cEmpresa = value;
            }
        }

        public ITipoReport _TipoReport
        {
            get
            {
                if (_lisCampos.ContainsKey("TIPO") && _ValidaTipoReport(Convert.ToInt32(_lisCampos["TIPO"]._NewVal)))
                {
                    _oTipoReport = _GetTipoReport(Convert.ToInt32(_lisCampos["TIPO"]._NewVal));
                }
                return _oTipoReport;
            }
            set
            {
                if (_ValidaTipoReport(value._Codigo))
                {
                    _oTipoReport = value;
                    if (_lisCampos.ContainsKey("TIPO")) _lisCampos["TIPO"]._NewVal = _oTipoReport._Codigo;
                }
            }
        }

        private ITipoReport _GetTipoReport(int tnCodigo)
        {
            return _ConfigReportTemplates._ListadoTiposReport.Where(f => f._Codigo == tnCodigo).First();
        }

        private bool _ValidaTipoReport(int tnCodigo)
        {
            return _ConfigReportTemplates._ListadoTiposReport.Where(f => f._Codigo == tnCodigo).Count() > 0;
        }

        public bool _IsCustomFileCreated
        {
            get
            {
                return File.Exists(Path.Combine(_cPathServer, _ReportPath._IniPamReportStoredPath, _FicheroExt));
            }
        }

        public bool _IsFileBase
        {
            get
            {
                return IsFileBase(_Fichero);
            }
        }

        public bool IsFileBase(string tcFileName)
        {
            tcFileName = tcFileName.ToUpper().Trim();

            return _ConfigReportTemplates._ListadoTiposReport.Any(f => f._ReportBase.ToUpper().Trim() == tcFileName);
        }

        public bool _IsFileBaseParent
        {
            get
            {
                return _TemplateBase._Fichero == _Fichero;
            }
        }


        public bool _RemoveFile()
        {
            return _FileCanBeRemoved() ? _RemoveFile(_ReportPath._IniPamReportStoredPath, _Fichero) : false;
        }

        public bool _RemoveFile(string tcFileName)
        {
            return _RemoveFile(_ReportPath._IniPamReportStoredPath, tcFileName);
        }
        
        public static bool _RemoveFile(string tcInitPathServer, string tcFileName)
        {
            string lcPathFile;

            lcPathFile = Path.Combine(_cPathServer, tcInitPathServer, $"{tcFileName.Trim()}.report");

            try
            {
                if (File.Exists(lcPathFile)) File.Delete(lcPathFile);
            }
            catch
            {
                return false;
            }

            return true;
        }

        public override bool _Save_Before()
        {
            // Si estamos modificando un registro y no hay nombre no se permite continuar
            if (_Estado == _EstadosMantenimiento.EntrandoNuevo || _Estado == _EstadosMantenimiento.EditandoRegistro)
            {
                // Plug-in 3.0. No hay que validar el campo nombre ya que puede que no exista en las cabeceras de documentos
                if (ValidarCampoNombre)
                {
                    if (string.IsNullOrWhiteSpace(_Nombre))
                    {
                        _Error_Message = "Es obligatorio cumplimentar el campo Nombre.";

                        if (_FormMante != null)
                            this._FormMante._SetError_OnControl("_Nombre", _Error_Message);

                        return false;
                    }
                }
            }

            return true;
        }

        public new bool _ReadOnly
        {
            get
            {
                return string.IsNullOrEmpty(_Codigo) ? false : _Parent == 0;
            }
        }

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

            _oTemplateBase = null;
            _TipoBase = TipoBase.Idioma;

            _Browser_Condicion = $"EMPRESA = '{_Empresa}' AND IDI_PLAN = '{_Idioma}' ";
        }

        public override bool _Save()
        {
            string lcSql;

            if (!_Save_Before()) return false;

            lcSql = $"UPDATE {DB.SQLDatabase(_DataBase, _Tabla)} SET NOMBRE = {DB.SQLString(_Nombre)}, OBSERVA = {DB.SQLString(_Observaciones)}, " +
                    $"      FICHERO = {DB.SQLString(_Fichero)}, TODASEMP = {Convert.ToInt16(_TodasEmp)} " +
                    $"WHERE ID = {_Codigo} ";


            if (DB.SQLExec(lcSql))
            {
                _CopyTemplates();
            }

            _bIsNew = false;

            return true;
        }

        private bool _SaveFileName()
        {
            string lcSql = $"UPDATE { DB.SQLDatabase(_DataBase, _Tabla)} SET FICHERO = { DB.SQLString(_Fichero)} WHERE ID = {_Codigo} ";

            return DB.SQLExec(lcSql);
        }

        public void _CopyTemplates()
        {
            DataTable loDt = new DataTable();
            Int32 lnCodigo;
            String lcSql, lcNameFicheroOri, lcIdioma, lcEmpresa;

            lnCodigo = _ObtenerCodigoMax();

            //Idiomas
            if (_TipoBase == TipoBase.Idioma && _TemplateBase != null && _TemplateBase._Parent > 0)
            {
                lcSql = String.Format("SELECT i.EMPRESA, i.CODIGO, fic.FICHERO FROM {0} i LEFT JOIN (SELECT r.ID, r.EMPRESA  COLLATE Modern_Spanish_CS_AI as EMPRESA , r.IDI_PLAN  COLLATE Modern_Spanish_CS_AI as IDI_PLAN, r.ID_PARENT FROM {1} r WHERE r.ID_PARENT = {3}) as f ON i.CODIGO  = f.IDI_PLAN AND i.EMPRESA = f.EMPRESA AND f.ID_PARENT = {3} INNER JOIN {1} fic ON i.CODIGO = fic.IDI_PLAN AND fic.ID_PARENT = {4} AND i.EMPRESA = fic.EMPRESA WHERE f.ID is null {5} ", DB.SQLDatabase("GESTION", "IDIOMA"), DB.SQLDatabase(this._DataBase, this._Tabla), _Empresa, _Parent, _TemplateBase._Parent, _TodasEmp ? String.Empty : String.Format(" AND i.EMPRESA = '{0}' ", _Empresa));
                lcSql += " UNION ";
                lcSql += String.Format("SELECT e.CODIGO as 'EMPRESA', '' as 'CODIGO', fic.FICHERO FROM {0} e LEFT JOIN (SELECT r.ID, r.EMPRESA as EMPRESA , r.IDI_PLAN as IDI_PLAN, r.ID_PARENT  FROM {1} r WHERE IDI_PLAN = '' AND r.ID_PARENT = {2}) as f ON e.CODIGO  = f.EMPRESA AND f.IDI_PLAN = '' AND f.ID_PARENT = {2}  INNER JOIN {1} fic ON e.CODIGO = fic.EMPRESA AND fic.ID_PARENT = {3} AND fic.IDI_PLAN = '' WHERE  f.ID is null {4} ", DB.SQLDatabase("GESTION", "EMPRESA"), DB.SQLDatabase(this._DataBase, this._Tabla), _Parent, _TemplateBase._Parent, _TodasEmp ? String.Empty : String.Format(" AND e.CODIGO = '{0}' ", _Empresa));
            }
            else
            {
                lcSql = String.Format("SELECT i.EMPRESA, i.CODIGO, '' as FICHERO FROM {0} i LEFT JOIN (SELECT r.ID, r.EMPRESA  COLLATE Modern_Spanish_CS_AI as EMPRESA , r.IDI_PLAN  COLLATE Modern_Spanish_CS_AI as IDI_PLAN, r.ID_PARENT FROM {1} r WHERE r.ID_PARENT = {2}) as f ON i.CODIGO  = f.IDI_PLAN AND i.EMPRESA = f.EMPRESA AND f.ID_PARENT = {2} WHERE f.ID is null {3} ", DB.SQLDatabase("GESTION", "IDIOMA"), DB.SQLDatabase(this._DataBase, this._Tabla), _Parent, _TodasEmp ? String.Empty : String.Format(" AND i.EMPRESA = '{0}' ", _Empresa));
                lcSql += " UNION ";
                lcSql += String.Format("SELECT e.CODIGO as 'EMPRESA', '' as 'CODIGO', '' as FICHERO FROM {0} e LEFT JOIN (SELECT r.ID, r.EMPRESA as EMPRESA , r.IDI_PLAN as IDI_PLAN, r.ID_PARENT FROM {1} r WHERE IDI_PLAN = '' AND r.ID_PARENT = {2}) as f ON e.CODIGO  = f.EMPRESA AND f.IDI_PLAN = '' AND f.ID_PARENT = {2} WHERE  f.ID is null {3} ", DB.SQLDatabase("GESTION", "EMPRESA"), DB.SQLDatabase(this._DataBase, this._Tabla), _Parent, _TodasEmp ? String.Empty : String.Format(" AND e.CODIGO = '{0}' ", _Empresa));
            }
            DB.SQLExec(lcSql, ref loDt);


            foreach (DataRow ldRow in loDt.Rows)
            {
                lnCodigo++;

                lcIdioma = Convert.ToString(ldRow["CODIGO"]);
                lcEmpresa = Convert.ToString(ldRow["EMPRESA"]);
                lcNameFicheroOri = _TipoBase == TipoBase.Formato ? _Fichero : Convert.ToString(ldRow["FICHERO"]);
                //lcNameFicheroDestino = _GetNameFichero(lcEmpresa, lcIdioma, lnCodigo);

                _CopyTemplate(lcEmpresa, lnCodigo, lcIdioma, lcNameFicheroOri);
                //_CreateFile(lcNameFicheroDestino, lcNameFicheroOri, false);
            }
        }

        public override bool _Delete()
        {
            Boolean lOk;
            String lcSql, lcErrorMessage = "";
            DataTable loDt = new DataTable();

            //Cogemos todos los ficheros de las plantillas relacionadas que no se esten utilizando en otras plantillas
            lcSql = String.Format("SELECT DISTINCT a.FICHERO FROM  {0} a LEFT JOIN  {0} b ON a.FICHERO = b.FICHERO AND a.ID <> b.ID AND b.ID_PARENT <> {1}  WHERE a.ID_PARENT = {1} AND a.ID_PARENT > 0 AND b.ID is null", DB.SQLDatabase(this._DataBase, this._Tabla), _Parent);
            DB.SQLExec(lcSql, ref loDt);

            if (lOk = base._Delete())
            {
                //Eliminamos los datos guardados de impresión
                lcSql = String.Format("DELETE w FROM {0} w INNER JOIN {1} e ON e.ID = w.ID_REPLAN WHERE e.ID_PARENT = {2} ", DB.SQLDatabase(_DataBase, "SAGEREPORTS"), DB.SQLDatabase(_DataBase, this._Tabla), _Parent);
                DB.SQLExec(lcSql);

                //Eliminamos los ficheros que se pueden eliminar
                foreach (DataRow loRow in loDt.Rows)
                {
                    if (!_RemoveFile(_ReportPath._IniPamReportStoredPath, Convert.ToString(loRow["FICHERO"])))
                    {
                        lcErrorMessage += String.Format("{1}Se ha producido un error al eliminar el fichero {0}", Convert.ToString(loRow["FICHERO"]).Trim(), String.IsNullOrEmpty(lcErrorMessage) ? String.Empty : Environment.NewLine);
                    }
                }

                //Eliminamos las plantillas asociadas
                lcSql = String.Format("DELETE FROM {0} WHERE ID_PARENT = {1} AND ID_PARENT > 0 ", DB.SQLDatabase(this._DataBase, this._Tabla), _Parent);
                DB.SQLExec(lcSql);
            }

            _Error_Message = lcErrorMessage;

            return lOk;
        }


        private void _CopyTemplate(string tcEmpresa, int tnCodigo, string tcCodigoIdioma = "", string tcFichero = "")
        {
            string lcSql;

            lcSql = String.Format("INSERT INTO {0} (EMPRESA, TIPO, IDI_PLAN, NOMBRE, FICHERO, ID, ID_PARENT, OBSERVA , GRUPO, TODASEMP) VALUES ('{1}',{2},'{3}', {4}, '{5}', {6}, {7}, {8}, '{9}', {10}); ", DB.SQLDatabase(_DataBase, _Tabla), tcEmpresa, _TipoReport._Codigo, tcCodigoIdioma, DB.SQLString(_Nombre), string.IsNullOrEmpty(tcFichero) ? _Fichero : tcFichero, tnCodigo, _Codigo, DB.SQLString(_Observaciones), _cGrupoEmpresa, Convert.ToInt16(_TodasEmp));
            DB.SQLExec(lcSql);
        }

        public ReportTemplate(IConfigReportTemplates toConfig)
            :this()
        {
            _DataBase = toConfig._DB;
            _oConfigReportTemplates = toConfig;
        }

        public ReportTemplate()
        {
            _Clave = "ID";
            _DataBase = "COMUNES";
            _Tabla = "REPLAN";
            _TituloMantenimiento = "Mantenimiento de plantillas de reports";
            _Pantalla = "REPLAN";

            _Browser_Titulos_Campos = "Nombre";
            _Browser_Campos = "NOMBRE";
            _Browser_Clave = "ID";
            _Browser_Campos_No_Visibles = "ID";
            _Browser_Condicion = $"EMPRESA = '{_Empresa}' AND IDI_PLAN = '{_Idioma}' ";

            _FormManteBaseType = typeof(frmReplan);

            _cGrupoEmpresa = DB.DbComunes.Substring(4, 4);
        }

      
        public override void _New(string tcCodigo = "")
        {
            string lcSql, lcNombreFichero;
            int lnCodigo = _ObtenerCodigoMax() + 1;

            //lcNombreFichero = _GetNameFichero(_Empresa, _Idioma, lnCodigo);

            lcNombreFichero = _TemplateBase._Fichero;

            lcSql = string.Format("INSERT INTO {0} (EMPRESA, TIPO, IDI_PLAN, ID, ID_PARENT, FICHERO, GRUPO) VALUES ('{1}',{2},'{3}',{4}, {4}, '{5}', '{6}'); ", DB.SQLDatabase(this._DataBase, this._Tabla), String.IsNullOrEmpty(_cEmpresa) ? _Empresa : _cEmpresa, _TipoReport._Codigo, String.IsNullOrEmpty(_cIdioma) ? _Idioma : _cIdioma, lnCodigo, lcNombreFichero, _cGrupoEmpresa);
            DB.SQLExec(lcSql);

            this._Codigo = Convert.ToString(lnCodigo);

            _bIsNew = true;
        }

        private ReportTemplate _ObtenerBase()
        {
            DataTable loDt = new DataTable();
            ReportTemplate loReportTemplate = null;

            if (_TipoReport == null)
                return null;

            string lcSql = $"SELECT ID FROM {DB.SQLDatabase(_DataBase, _Tabla)} WHERE EMPRESA = '{_Empresa}' AND IDI_PLAN = '{_Idioma}' AND TIPO = {_TipoReport._Codigo} AND ID_PARENT = 0 ";
            DB.SQLExec(lcSql, ref loDt);

            if (loDt.Rows.Count > 0)
            {
                loReportTemplate = new ReportTemplate(_ConfigReportTemplates)
                {
                    _Codigo = Convert.ToString(loDt.Rows[0][0])
                };
            }

            return loReportTemplate;
        }

        private int _ObtenerCodigoMax()
        {
            DataTable loDt = new DataTable();

            string lcSql = $"SELECT MAX(ID) FROM {DB.SQLDatabase(_DataBase, _Tabla)} ";
            DB.SQLExec(lcSql, ref loDt);

            return loDt.Rows.Count > 0 && !loDt.Rows[0].IsNull(0) ? Convert.ToInt32(loDt.Rows[0][0]) : 0;

        }

        private String _GetNameFichero(string tcEmpresa, string tcIdioma, int tnCodigo = 0)
        {
            int lnCodigo;
            string lcFichero;

            lnCodigo = tnCodigo > 0 ? tnCodigo : _Id;
            lcFichero = string.Format("{0}{1}{2}{3}{4}", _cGrupoEmpresa, tcEmpresa, _ReportBase, tcIdioma, lnCodigo);

            return lcFichero;
        }

        public static void _RemoveRegistrosDefecto(IConfigReportTemplates toConfig, String tcCodigoEmpresa, String tcCodigoIdioma)
        {
            string lcDataBase;
            string lcSql, lcCampo, lcValor;
            DataTable loDt = new DataTable();
            BaseReportPath loReportPath = toConfig._GetReportPath();

            lcDataBase = toConfig._DB;

            lcCampo = string.IsNullOrEmpty(tcCodigoIdioma) ? "EMPRESA" : "IDI_PLAN";
            lcValor = string.IsNullOrEmpty(tcCodigoIdioma) ? tcCodigoEmpresa : tcCodigoIdioma;


            //Eliminamos los datos guardados de impresión
            lcSql = string.Format("DELETE w FROM {0} w INNER JOIN {1} e ON e.ID = w.ID_REPLAN WHERE w.{2} = '{3}' ", DB.SQLDatabase(lcDataBase, "SAGEREPORTS"), DB.SQLDatabase(lcDataBase, "REPLAN"), String.IsNullOrEmpty(tcCodigoIdioma) ? "EMPRESA" : "IDIOMA", lcValor);
            DB.SQLExec(lcSql);

            lcSql = string.Format("SELECT DISTINCT a.FICHERO FROM {0} a LEFT JOIN  {0} b ON a.FICHERO = b.FICHERO AND a.ID <> b.ID  AND b.{1} <> '{2}' WHERE  a.{1} = '{2}' AND a.ID_PARENT > 0 AND b.ID is null", DB.SQLDatabase(lcDataBase, "REPLAN"), lcCampo, lcValor);
            DB.SQLExec(lcSql, ref loDt);

            foreach (DataRow loRow in loDt.Rows)
            {
                _RemoveFile(loReportPath._IniPamReportStoredPath, Convert.ToString(loRow["FICHERO"]));
            }

            lcSql = $"DELETE FROM {DB.SQLDatabase(lcDataBase, "REPLAN")} WHERE {lcCampo} = '{lcValor}' ";
            DB.SQLExec(lcSql);
        }


        public static void _ValidaTemplates(IConfigReportTemplates toConfig, String tcCodigoEmpresa, String tcCodigoIdioma)
        {
            string lcDataBase = toConfig._DB;
            DataTable loDt = new DataTable();

            //Validamos que esten los registros por defecto
            string lcSql = $"SELECT * FROM {DB.SQLDatabase(lcDataBase, "REPLAN")} WHERE EMPRESA = '{tcCodigoEmpresa}' AND IDI_PLAN = '{tcCodigoIdioma}' AND ID_PARENT = 0 ";
            DB.SQLExec(lcSql, ref loDt);

            List<ITipoReport> loList = toConfig._ListadoTiposReport.Where(f => f._CrearRegistroDefecto).ToList();

            foreach (ITipoReport loTipo in loList)
            {
                DataRow[] loRow = loDt.Select(string.Format("TIPO = {0}", loTipo._Codigo));

                if (loRow.Length == 0)
                {
                    _CreaRegistroDefecto(toConfig, tcCodigoEmpresa, tcCodigoIdioma, loTipo);
                }
            }

            //Validamos que tenga grupo empresa
            lcSql = $"SELECT * FROM {DB.SQLDatabase(lcDataBase, "REPLAN")} WHERE GRUPO = '' AND ID_PARENT > 0 ";
            DB.SQLExec(lcSql, ref loDt);

            if (loDt.Rows.Count > 0)
            {
                foreach (DataRow ldRow in loDt.Rows)
                {
                    ReportTemplate loReport = new ReportTemplate(toConfig)
                    {
                        _Codigo = Convert.ToString(ldRow["ID"])
                    };
                    if (!Convert.ToString(ldRow["FICHERO"]).StartsWith(_cGrupoEmpresa)) loReport._UpdateFile(string.Format("{0}{1}", _cGrupoEmpresa, ldRow["FICHERO"]));
                }

                lcSql = string.Format("UPDATE {0} SET GRUPO = '{1}' WHERE GRUPO = '' AND ID_PARENT > 0 ", DB.SQLDatabase(lcDataBase, "REPLAN"), _cGrupoEmpresa);
                DB.SQLExec(lcSql, ref loDt);
            }

            //Validamos relaciones
            lcSql = string.Format("SELECT MIN(a.ID) as ID, a.NOMBRE, a.TIPO FROM {0} a INNER JOIN {0} b ON a.ID_PARENT = b.ID AND b.ID_PARENT = 0 GROUP BY a.NOMBRE, a.TIPO", DB.SQLDatabase(lcDataBase, "REPLAN"));
            DB.SQLExec(lcSql, ref loDt);

            foreach (DataRow ldRow in loDt.Rows)
            {
                lcSql = string.Format("UPDATE {0} SET ID_PARENT = {1} WHERE NOMBRE = '{2}' AND TIPO = {3} ", DB.SQLDatabase(lcDataBase, "REPLAN"), ldRow["ID"], ldRow["NOMBRE"], ldRow["TIPO"]);
                DB.SQLExec(lcSql);
            }

        }

        public static void _ValidaTodasTemplates(IConfigReportTemplates toConfig, string tcCodigoEmpresa)
        {
            string lcDataBase = toConfig._DB;
            DataTable loDt = new DataTable();

            //Validamos que esten los registros por defecto
            string lcSql = $"SELECT * FROM {DB.SQLDatabase(lcDataBase, "REPLAN")} WHERE EMPRESA = '{tcCodigoEmpresa}' AND ID_PARENT = 0 ";
            DB.SQLExec(lcSql, ref loDt);

            List<ITipoReport> loList = toConfig._ListadoTiposReport.Where(f => f._CrearRegistroDefecto).ToList();
            DataTable loDtIdiomas = Idiomas._GetIdiomas(string.Format("EMPRESA = '{0}'", tcCodigoEmpresa), "CODIGO");

            List<String> loListIdioma = (from loRow in loDtIdiomas.AsEnumerable()
                                        select Convert.ToString(loRow["CODIGO"])).ToList();

            if (!loListIdioma.Contains("")) loListIdioma.Add("");

            foreach (string lcCodigoIdioma in loListIdioma)
            {
                foreach (ITipoReport loTipo in loList)
                {
                    DataRow[] loRow = loDt.Select(string.Format("TIPO = {0} AND IDI_PLAN = '{1}' ", loTipo._Codigo, lcCodigoIdioma));

                    if (loRow.Length == 0)
                    {
                        _CreaRegistroDefecto(toConfig, tcCodigoEmpresa, lcCodigoIdioma, loTipo);
                    }
                }
            }

            //Validamos que tenga grupo empresa
            lcSql = string.Format("SELECT * FROM {0} WHERE GRUPO = '' AND ID_PARENT > 0 ", DB.SQLDatabase(lcDataBase, "REPLAN"));
            DB.SQLExec(lcSql, ref loDt);

            if (loDt.Rows.Count > 0)
            {
                foreach (DataRow ldRow in loDt.Rows)
                {
                    ReportTemplate loReport = new ReportTemplate(toConfig)
                    {
                        _Codigo = Convert.ToString(ldRow["ID"])
                    };
                    if (!Convert.ToString(ldRow["FICHERO"]).StartsWith(_cGrupoEmpresa)) loReport._UpdateFile(String.Format("{0}{1}", _cGrupoEmpresa, ldRow["FICHERO"]));
                }

                lcSql = String.Format("UPDATE {0} SET GRUPO = '{1}' WHERE GRUPO = '' AND ID_PARENT > 0 ", DB.SQLDatabase(lcDataBase, "REPLAN"), _cGrupoEmpresa);
                DB.SQLExec(lcSql, ref loDt);
            }

            //Validamos relaciones
            lcSql = String.Format("SELECT MIN(a.ID) as ID, a.NOMBRE, a.TIPO FROM {0} a INNER JOIN {0} b ON a.ID_PARENT = b.ID AND b.ID_PARENT = 0 GROUP BY a.NOMBRE, a.TIPO", DB.SQLDatabase(lcDataBase, "REPLAN"));
            DB.SQLExec(lcSql, ref loDt);

            foreach (DataRow ldRow in loDt.Rows)
            {
                lcSql = String.Format("UPDATE {0} SET ID_PARENT = {1} WHERE NOMBRE = '{2}' AND TIPO = {3} ", DB.SQLDatabase(lcDataBase, "REPLAN"), ldRow["ID"], ldRow["NOMBRE"], ldRow["TIPO"]);
                DB.SQLExec(lcSql);
            }

        }

        private static void _CreaRegistro(IConfigReportTemplates toConfig, string tcCodigoEmpresa, string tcCodigoIdioma, TiposReport toTipo, string tcFichero)
        {
            int lnCodigo;
            string lcDataBase;
            ReportTemplate loRemplate;
            string lcSql, lcNombre, lcObs, lcFichero;
            DataTable loDt = new DataTable();
            BaseReportPath loPath = toConfig._GetReportPath();

            if (!string.IsNullOrEmpty(tcFichero.Trim()))
            {
                lcDataBase = toConfig._DB;
                lcFichero = string.Format("{0}{1}{2}{3}", _cGrupoEmpresa, tcCodigoEmpresa, tcFichero.Trim(), tcCodigoIdioma);

                if (!_ExistsFile(loPath._IniPamReportStoredPath, lcFichero))
                {
                    lcSql = string.Format("UPDATE {0} SET PREDET = 0 WHERE EMPRESA = '{1}' AND IDI_PLAN = '{2}' AND TIPO = {3} ", DB.SQLDatabase(lcDataBase, "REPLAN"), tcCodigoEmpresa, tcCodigoIdioma, Convert.ToInt32(toTipo));
                    DB.SQLExec(lcSql);

                    lcSql = string.Format("SELECT MAX(ID) FROM {0} ", DB.SQLDatabase(lcDataBase, "REPLAN"));
                    DB.SQLExec(lcSql, ref loDt);

                    lnCodigo = (loDt.Rows.Count > 0 && !loDt.Rows[0].IsNull(0) ? Convert.ToInt32(loDt.Rows[0][0]) : 0) + 1;

                    lcNombre = string.Format("{0} personalizada", toTipo.__GetDescription());
                    lcObs = string.Format("Plantilla personalizada de {0} generada automáticamente", toTipo.__GetDescription());
                    lcFichero = string.Format("{0}{1}{2}{3}{4}", _cGrupoEmpresa, tcCodigoEmpresa, tcFichero.Trim(), tcCodigoIdioma, lnCodigo);

                    lcSql = string.Format("INSERT INTO {0} (EMPRESA, TIPO, IDI_PLAN, ID, ID_PARENT, PREDET, NOMBRE , OBSERVA, FICHERO, GRUPO) VALUES ('{1}',{2},'{3}',{4}, {4}, 1, '{5}', '{6}', '{7}', '{8}'); ", DB.SQLDatabase(lcDataBase, "REPLAN"), tcCodigoEmpresa, Convert.ToInt32(toTipo), tcCodigoIdioma, lnCodigo++, lcNombre, lcObs, lcFichero, _cGrupoEmpresa);
                    DB.SQLExec(lcSql);

                    _CreateFile(loPath, lcFichero, toTipo);

                    loDt = new DataTable();
                    lcSql = string.Format("SELECT ID FROM {0} WHERE ID = ID_PARENT {1} AND TIPO = {2} ", DB.SQLDatabase(lcDataBase, "REPLAN"), string.IsNullOrEmpty(tcCodigoIdioma) ? string.Empty : String.Format(" AND EMPRESA = '{0}'", tcCodigoEmpresa), Convert.ToInt32(toTipo));
                    DB.SQLExec(lcSql, ref loDt);

                    foreach (DataRow loRow in loDt.Rows)
                    {
                        loRemplate = new ReportTemplate(toConfig)
                        {
                            _Codigo = Convert.ToString(loRow["ID"])
                        };
                        loRemplate._CopyTemplates();
                    }
                }
            }
        }


        public static void _CreaRegistrosDefecto(IConfigReportTemplates toConfig, string tcCodigoEmpresa, string tcCodigoIdioma)
        {
            string lcDataBase;
            ReportTemplate loRemplate;
            DataTable loDt = new DataTable();

            lcDataBase = toConfig._DB;

            string lcSql = $"SELECT * FROM {DB.SQLDatabase(lcDataBase, "REPLAN")} " +
                           $"WHERE GRUPO = '{Convert.ToString(EW_GLOBAL._GetVariable("wc_grupo"))}' AND EMPRESA = '{tcCodigoEmpresa}' AND IDI_PLAN = '{tcCodigoIdioma}' AND ID_PARENT = 0 ";

            DB.SQLExec(lcSql, ref loDt);

            List<ITipoReport> loList = toConfig._ListadoTiposReport.Where(f => f._CrearRegistroDefecto).ToList();

            foreach (ITipoReport loTipo in loList)
            {
                DataRow[] loRow = loDt.Select(string.Format("TIPO = {0}", loTipo._Codigo));

                if (loRow.Length == 0)
                {
                    ReportTemplate._CreaRegistroDefecto(toConfig, tcCodigoEmpresa, tcCodigoIdioma, loTipo);
                }
            }

            loDt = new DataTable();
            lcSql = string.Format("SELECT ID FROM {0} WHERE ID = ID_PARENT {1} ", DB.SQLDatabase(lcDataBase, "REPLAN"), string.IsNullOrEmpty(tcCodigoIdioma) ? string.Empty : string.Format(" AND EMPRESA <> '{0}'", tcCodigoEmpresa));
            DB.SQLExec(lcSql, ref loDt);

            foreach (DataRow loRow in loDt.Rows)
            {
                loRemplate = new ReportTemplate(toConfig)
                {
                    _Codigo = Convert.ToString(loRow["ID"])
                };
                loRemplate._CopyTemplates();
            }
        }

        public static void _CreaRegistroDefecto(IConfigReportTemplates toConfig, string tcCodigoEmpresa, string tcCodigoIdioma, ITipoReport toTipo)
        {
            int lnCodigo;
            string lcDataBase;
            ReportTemplate loRemplate;
            string lcNombre, lcObs, lcFichero;
            DataTable loDt = new DataTable();
           
            lcDataBase = toConfig._DB;

            string lcSql = $"SELECT MAX(ID) FROM {DB.SQLDatabase(lcDataBase, "REPLAN")} ";
            DB.SQLExec(lcSql, ref loDt);

            lnCodigo = (loDt.Rows.Count > 0 && !loDt.Rows[0].IsNull(0) ? Convert.ToInt32(loDt.Rows[0][0]) : 0) + 1;


            lcNombre = toTipo._Descripcion;
            lcObs = $"Plantilla de {lcNombre} generada automáticamente";

            lcFichero = toTipo._ReportBase;

            lcSql = string.Format("INSERT INTO {0} (EMPRESA, TIPO, IDI_PLAN, ID, ID_PARENT, PREDET, NOMBRE , OBSERVA, FICHERO, GRUPO) VALUES ('{1}',{2},'{3}',{4}, 0, 1, '{5}', '{6}', '{7}', ''); ", DB.SQLDatabase(lcDataBase, "REPLAN"), tcCodigoEmpresa, toTipo._Codigo, tcCodigoIdioma, lnCodigo++, lcNombre, lcObs, lcFichero);
            DB.SQLExec(lcSql);

            //_CreateFile(lcFichero, toTipo);

            loDt = new DataTable();
            lcSql = string.Format("SELECT ID FROM {0} WHERE ID = ID_PARENT {1} AND TIPO = {2} ", DB.SQLDatabase(lcDataBase, "REPLAN"), string.IsNullOrEmpty(tcCodigoIdioma) ? string.Empty : $" AND EMPRESA = '{tcCodigoEmpresa}'", toTipo._Codigo);
            DB.SQLExec(lcSql, ref loDt);

            foreach (DataRow loRow in loDt.Rows)
            {
                loRemplate = new ReportTemplate(toConfig)
                {
                    _Codigo = Convert.ToString(loRow["ID"])
                };
                loRemplate._CopyTemplates();
            }
        }

        public bool _FileCanBeRemoved()
        {
            DataTable loDt = new DataTable();

            loDt = new DataTable();
            string lcSql = $"SELECT * FROM {DB.SQLDatabase(_DataBase, "REPLAN")} WHERE ID <> {_Id} AND FICHERO = '{_Fichero}' ";
            DB.SQLExec(lcSql, ref loDt);

            return loDt.Rows.Count == 0;
        }

        public bool _ChangeFile(FileInfo toFile)
        {
            string lcName = _GetNameFichero(_Empresa, _Idioma, Convert.ToInt32(_Codigo));

            if (_CopyFile(toFile.FullName, Path.Combine(_cPathServer, _ReportPath._IniPamReportStoredPath, $"{lcName}.report") , true))
            {
                _Fichero = lcName;
                _SaveFileName();

                return true;
            }
            return false;
        }

        private void _UpdateFile(string tcNewFile)
        {
            tcNewFile = tcNewFile.Trim();
            if (!string.IsNullOrEmpty(tcNewFile))
            {
                _CreateFile(tcNewFile, _Fichero);
                _Fichero = tcNewFile;

                _SaveFileName();
            }
        }


        protected string _ReportBase
        {
            get
            {
                return _TipoReport._ReportBase;
            }
        }

        public bool _IsFileChanged
        {
            get
            {
                return _Fichero != _GetNameFichero(_Empresa, _Idioma);
            }
        }

        public bool _EditTemplate(bool tlMantenerFichero)
        {
            bool lbOk = false;
            string lcFichero, lcFicheroTmp = string.Empty;

            lcFichero = _GetNameFichero(_Empresa, _Idioma);
            if (_Fichero != lcFichero)
            {
                lcFicheroTmp = _Fichero;

                if (!tlMantenerFichero)
                {
                    _Fichero = lcFichero;
                    _SaveFileName();
                }
            }
            else if (_IsNew && _oTemplateBase != null)
            {
                lcFicheroTmp = _oTemplateBase._Fichero;
            }

            if (!_ExistsFile()) lbOk = _CreateFile(_Fichero, lcFicheroTmp);
            _OpenTemplate();

            return lbOk;
        }

        public BaseReportPath _ReportPath
        {
            get
            {
                if (_oReportPath == null || !_TipoReport._Codigo.Equals(ultimoCodigoReport)) //Para que refresque si ha cambiado el tipo
                {
                    ReportTPV report = null; //Trato de obtener un path específico; sino devuelvo el genérico
                    try
                    {
                        report = _ConfigReportTemplates._GetReportTPV(_TipoReport._Codigo, _Fichero, _Documento);
                    }
                    catch (Exception exception)
                    {
                        DB.Registrar_Error(exception);
                    }
                    finally
                    {
                        if (report != null)
                        {
                            _oReportPath = report._Path;
                            ultimoCodigoReport = _TipoReport._Codigo;
                        }
                        else
                        {
                            _oReportPath = _ConfigReportTemplates._GetReportPath();
                            _oReportPath._PathServer = Convert.ToString(EW_GLOBAL._GetVariable("wc_iniservidor"));
                            ultimoCodigoReport = -1;
                        }
                    }
                }
                return _oReportPath;
            }
        }
        private int ultimoCodigoReport = -1;


        private Boolean _ExistsFile()
        {
            String lcNombre, lcPathDestino, lcPathPam;

            lcPathPam = _ReportPath._IniPamReportStoredPath;

            if (!String.IsNullOrEmpty(_Fichero))
            {
                lcNombre = String.Format("{0}.report", _Fichero);
                lcPathDestino = Path.Combine(_cPathServer, lcPathPam, lcNombre);

                return File.Exists(lcPathDestino);
            }
            return true;
        }

        private static Boolean _ExistsFile(String tcniPamReportStoredPath, String tcFile)
        {
            String[] lcArr;
            String lcNombre, lcPathDestino;

            if (!String.IsNullOrEmpty(tcFile))
            {
                lcNombre = String.Format("{0}*.report", tcFile);
                lcPathDestino = Path.Combine(_cPathServer, tcniPamReportStoredPath);

                lcArr = Directory.GetFiles(lcPathDestino, lcNombre);
                return lcArr.Length > 0;
            }
            return true;
        }

        private bool _CreateFile(String tcFileName, String tcFileOri, Boolean tlValidateFile = false)
        {
            bool lbExistFile;
            string lcNombre = string.Empty;
            string lcPathDestino = string.Empty;
            string lcPathOrigen = string.Empty;
            string lcPathPam = string.Empty;
            string lcPathBase = string.Empty;
            string lcMessage = string.Empty;

            lcNombre = string.Format("{0}.report", tcFileName);

            lcPathPam = _ReportPath._IniPamReportStoredPath;
            lcPathBase = _ReportPath._BaseReportStoredPath;

            if (!string.IsNullOrEmpty(tcFileOri))
            {
                lcPathOrigen = Path.Combine(_cPathServer, lcPathPam, string.Format("{0}.report", tcFileOri));
                if (!File.Exists(lcPathOrigen))
                {
                    lcPathOrigen = Path.Combine(_cPathServer, lcPathBase, string.Format("{0}.report", _ReportBase));
                }
            }
            else
            {
                lcPathOrigen = Path.Combine(_cPathServer, lcPathBase, string.Format("{0}.report", _ReportBase));
            }

            lcPathDestino = Path.Combine(_cPathServer, lcPathPam, lcNombre);

            
            lbExistFile = File.Exists(lcPathDestino);

            if (lbExistFile && _LinkForm)
            {
                lcMessage = String.Format("Se ha detectado que el fichero {0} ya existe. ¿ Desea mantener el fichero ?", lcNombre);
                lbExistFile = DialogResult.Yes == FUNCTIONS._MessageBox(lcMessage, "Información", MessageBoxButtons.YesNo, MessageBoxIcon.Information, MessageBoxDefaultButton.Button2);
            }

            return !lbExistFile ? _CopyFile(lcPathOrigen, lcPathDestino) : false;

        }


        private static Boolean _CreateFile(BaseReportPath toReportPath, String tcFileName, TiposReport toTipo)
        {
            Boolean lbExistFile;
            String lcNombre, lcPathDestino, lcPathOrigen, lcPathPam, lcPathBase;

            lcPathPam = toReportPath._IniPamReportStoredPath;
            lcPathBase = toReportPath._BaseReportStoredPath;
            lcNombre = String.Format("{0}.report", tcFileName);
            lcPathDestino = Path.Combine(_cPathServer, lcPathPam, lcNombre);
            lcPathOrigen = Path.Combine(_cPathServer, lcPathBase, String.Format("{0}.report", toTipo));

            lbExistFile = File.Exists(lcPathDestino);

            return !lbExistFile ? _CopyFile(lcPathOrigen, lcPathDestino) : false;

        }

        private static Boolean _CopyFile(String tcPathOrigen, String tcPathDestino, Boolean tlForze = false)
        {
            try
            {
                if (tcPathOrigen.ToLower() != tcPathDestino.ToLower())
                {
                    FileInfo loFile = new FileInfo(tcPathDestino);
                    if (!loFile.Directory.Exists) Directory.CreateDirectory(loFile.Directory.FullName);

                    if (!File.Exists(tcPathDestino) || tlForze)
                    {
                        File.Copy(tcPathOrigen, tcPathDestino, true);
                        //PE-97635 Quitamos la marca del reaonly al nuevo fichero 
                        FileAttributes attributes = File.GetAttributes(tcPathDestino);

                        if ((attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
                        {
                            File.SetAttributes(tcPathDestino, attributes & ~FileAttributes.ReadOnly);
                        }
                    }
                }
            }
            catch (Exception)
            {
                return false;
            }
            return true;
        }
    }

    public class ReportTemplates
        : ReportTemplatesBase
    {
        private ConfigReportTemplates _oConfigReportTemplates = new ConfigReportTemplates();

        public override IConfigReportTemplates _ConfigReportTemplates
        {
            get
            {
                return _oConfigReportTemplates;
            }
        }

        public static string _GetDefaultTemplate(ITipoReport toTipoReport)
        {
            ReportTemplates loTemplates = new ReportTemplates(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));

            return loTemplates._GetTemplate(toTipoReport);
        }

        public static string _GetTemplatePredet(ITipoReport toTipoReport, string tcIdioma)
        {
            return _GetTemplatePredet(toTipoReport._Codigo, tcIdioma);
        }

        public static string _GetTemplatePredet(int tnTipoReport, string tcIdioma)
        {
            ReportTemplates loTemplates;

            if (string.IsNullOrEmpty(tcIdioma.Trim()))
            {
                loTemplates = new ReportTemplates(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));
            }
            else
            {
                loTemplates = new ReportTemplates(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")), tcIdioma);
            }

            return loTemplates._GetTemplate(tnTipoReport, false);
        }

        public static string _GetEquivalTemplate(string tcCodigoTemplate, string tcCodigoIdioma)
        {
            string lcTemplate = tcCodigoTemplate;
            ReportTemplate loTemplate = new ReportTemplate(new ConfigReportTemplates())
            {
                _Empresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")),
                _Codigo = tcCodigoTemplate
            };

            if (!loTemplate._IsFileBase)
            {
                ReportTemplates loTemplates;

                if (string.IsNullOrEmpty(tcCodigoIdioma.Trim()))
                {
                    loTemplates = new ReportTemplates(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));
                }
                else
                {
                    loTemplates = new ReportTemplates(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")), tcCodigoIdioma);
                }

                DataTable loDt = loTemplates._Templates(loTemplate._TipoReport);

                lcTemplate = (from loRow in loDt.AsEnumerable()
                              where Convert.ToInt32(loRow["ID_PARENT"]) == loTemplate._Parent
                              select Convert.ToString(loRow["ID"])).FirstOrDefault();


                if (string.IsNullOrEmpty(lcTemplate)) lcTemplate = loTemplates._GetTemplate(loTemplate._TipoReport);

            }

            return lcTemplate;
        }

        public ReportTemplates(string tcCodigoEmpresa, string tcCodigoIdioma, bool tlValidate = false)
            :base(tcCodigoEmpresa, tcCodigoIdioma, tlValidate)
        {
         
        }

        public ReportTemplates(string tcCodigoEmpresa, bool tlValidate = false)
           : base(tcCodigoEmpresa, tlValidate)
        {

        }
    }

    public abstract class ReportTemplatesBase
    {
        protected enum TipoIdiomaEmpresa
        {
            Idioma = 0,
            Empresa = 1
        }

        private DataTable _oTmp = null;
        private DataTable _oPlan = null;

        public abstract IConfigReportTemplates _ConfigReportTemplates { get; }

        protected TipoIdiomaEmpresa _TipoIdiomaEmpresa { get; }

        public string _Idioma { get; set; }

        public string _Empresa { get; set; }


        private string _DB
        {
            get
            {
                return _ConfigReportTemplates._DB;
            }
        }

        protected DataTable _Plan
        {
            get
            {
                if (_oPlan == null)
                {
                    String lcSql;
                    _oPlan = new DataTable();

                    lcSql = String.Format("SELECT * FROM {0} WHERE EMPRESA = '{1}' AND IDI_PLAN = '{2}' {3}", DB.SQLDatabase(_DB, "REPLAN"), _Empresa, _Idioma, (_TipoIdiomaEmpresa == TipoIdiomaEmpresa.Idioma && String.IsNullOrEmpty(_Idioma)) ? " AND 1 = 0 " : String.Empty );
                    DB.SQLExec(lcSql, ref _oPlan);

                    if (_oTmp != null)
                    {
                        foreach (DataRow loRow in _oTmp.Rows)
                        {
                            List<DataRow> ldRowPlan = (from loRowTmp in _oPlan.AsEnumerable()
                                                       where Convert.ToString(loRowTmp["ID"]) == Convert.ToString(loRow["ID"])
                                                       select loRowTmp).ToList();

                            if (ldRowPlan.Count > 0)
                            {
                                ldRowPlan[0]["PREDET"] = loRow["PREDET"];
                            }
                        }
                    }
                    
                }
                return _oPlan;
            }
        }

        public ITipoReport _GetTipoReport(Int32 tnCodigo)
        {
            return _ConfigReportTemplates._ListadoTiposReport.Where(f => f._Codigo == tnCodigo).First();
        }

        public DataTable _Templates(ITipoReport toTipoReport)
        {
            return _Templates(toTipoReport._Codigo);
        }

        public DataTable _Templates(Int32 tnTipoReport)
        {
            List<ReportTemplate> lolistTemplates = new List<ReportTemplate>();
            DataTable loDt = _Plan.Clone();

            if (_Plan.Rows.Count > 0)
            {
                List<DataRow> loList = (from loRow in _Plan.AsEnumerable()
                                        where Convert.ToInt32(loRow["TIPO"]) == tnTipoReport
                                        select loRow).ToList();

                foreach (DataRow loRow in loList)
                {
                    loDt.ImportRow(loRow);
                }
            }

            return loDt;
        }

        public virtual void _Refresh()
        {
            _oTmp = _oPlan;
            _oPlan = null;
        }

        public string _GetPredet(ITipoReport toTipoReport)
        {
            return _GetPredet(toTipoReport._Codigo);
        }

        public string _GetPredet(int tnTipoReport)
        {
            List<DataRow> loList = (from loRow in _Plan.AsEnumerable()
                                    where Convert.ToInt32(loRow["TIPO"]) == tnTipoReport && Convert.ToBoolean(loRow["PREDET"])
                                    select loRow).ToList();

            return loList.Count > 0 ? Convert.ToString(loList[0]["ID"]) : string.Empty;
        }

        public string _GetTemplate(ITipoReport toTipoReport, bool tlSearchLastUsetTemplate = true)
        {
            return _GetTemplate(toTipoReport._Codigo, tlSearchLastUsetTemplate);
        }

        public string _GetTemplate(int tnTipoReport, bool tlSearchLastUsetTemplate = true)
        {

            string lcTemplate = "";

            if(tlSearchLastUsetTemplate) lcTemplate = _GetLastUserTemplate(tnTipoReport);

            if (string.IsNullOrEmpty(lcTemplate)) lcTemplate = _GetPredet(tnTipoReport);

            if (string.IsNullOrEmpty(lcTemplate))
            {

                List<DataRow> loList = (from loRow in _Plan.AsEnumerable()
                                        where Convert.ToInt32(loRow["TIPO"]) == tnTipoReport && Convert.ToInt32(loRow["ID_PARENT"]) == 0
                                        select loRow).ToList();

                lcTemplate = loList.Count > 0 ? Convert.ToString(loList[0]["ID"]) : string.Empty;

            }
            return lcTemplate;
        }


        public DataRow _GetTemplate(string tcCodigo)
        {


            if (int.TryParse(tcCodigo, out int lnCodigo))
            {
                List<DataRow> loList = (from loRow in _Plan.AsEnumerable()
                                        where Convert.ToInt32(loRow["ID"]) == lnCodigo
                                        select loRow).ToList();

                return loList.Count > 0 ? loList[0] : null;
            }
            return null;
        }


        private string _GetLastUserTemplate(ITipoReport toTipoReport)
        {
            return _GetLastUserTemplate(toTipoReport._Codigo);
        }

        private string _GetLastUserTemplate(Int32 tnTipoReport)
        {
            string lcUsuario, lcSql;
            DataTable loDt = new DataTable();

            lcUsuario = usuario.Usuario._This._Codigo;

            lcSql = string.Format("SELECT * FROM {0} WHERE USUARIO = '{1}' AND EMPRESA = '{4}' AND TIPO_DOC = {2} {3} ORDER BY FECHA DESC ", DB.SQLDatabase(_DB, "SAGEREPORTS"), lcUsuario, tnTipoReport, !String.IsNullOrEmpty(_Idioma.Trim()) ? String.Format(" AND IDIOMA = '{0}' ", _Idioma.Trim()) : String.Empty, _Empresa);
            DB.SQLExec(lcSql, ref  loDt);

            return loDt.Rows.Count > 0 ? Convert.ToString(loDt.Rows[0]["ID_REPLAN"]) : String.Empty;
        }

        public void _SetPredet(ITipoReport toTipo, string tcCodigo)
        {
            _SetPredet(toTipo._Codigo, tcCodigo);
        }

        public void _SetPredet(int tnTipo, string tcCodigo)
        {
            List<DataRow> loList = (from loRow in _Plan.AsEnumerable()
                                    where Convert.ToInt32(loRow["TIPO"]) == tnTipo
                                    select loRow).ToList();

            foreach (DataRow loRow in loList)
            {
                loRow["PREDET"] = Convert.ToString(loRow["ID"]) == tcCodigo;
            }
        }

        public bool _ExistTemplate(ITipoReport toTipo, int tnCodigoTemplate)
        {
            return _ExistTemplate(toTipo._Codigo, tnCodigoTemplate);
        }

        public bool _ExistTemplate(int tnTipo, int tnCodigoTemplate)
        {
            List<DataRow> loList = (from loRow in _Plan.AsEnumerable()
                                    where Convert.ToInt32(loRow["TIPO"]) == tnTipo && Convert.ToString(loRow["IDI_PLAN"]).Trim() == _Idioma && Convert.ToString(loRow["EMPRESA"]) == _Empresa && Convert.ToInt32(loRow["ID"]) == tnCodigoTemplate
                                    select loRow).ToList();

            return loList.Count > 0;
        }

        public virtual bool _Save()
        {
            string lcSql;
          
            List<DataRow> loList = (from loRow in _Plan.AsEnumerable()
                                    where Convert.ToBoolean(loRow["PREDET"])
                                    select loRow).ToList();

            lcSql = string.Format("UPDATE {0} SET PREDET = 0 WHERE EMPRESA = '{1}' AND IDI_PLAN = '{2}' ", DB.SQLDatabase(_DB, "REPLAN"), _Empresa, _Idioma);
            DB.SQLExec(lcSql);

            foreach (DataRow loRow in loList)
            {
                lcSql = string.Format("UPDATE {0} SET PREDET = 1 WHERE ID = '{1}' ", DB.SQLDatabase(_DB, "REPLAN"), loRow["ID"]);
                DB.SQLExec(lcSql);
            }

            return true;
        }

        #region static 
       
        public void _CreateRelTemplate(String tcCodigoEmpresa, String tcCodigoIdioma = "")
        {
            ReportTemplate._CreaRegistrosDefecto(_ConfigReportTemplates, tcCodigoEmpresa, tcCodigoIdioma);
        }

        public void _RemoveRelTemplate(String tcCodigoEmpresa, String tcCodigoIdioma = "")
        {
            ReportTemplate._RemoveRegistrosDefecto(_ConfigReportTemplates, tcCodigoEmpresa, tcCodigoIdioma);
        }

        #endregion static

        #region constructores

        public ReportTemplatesBase(String tcCodigoEmpresa, String tcCodigoIdioma, Boolean tlValidate = false)
        {
            this._Empresa = tcCodigoEmpresa;
            this._Idioma = tcCodigoIdioma;
            this._TipoIdiomaEmpresa = TipoIdiomaEmpresa.Idioma;

            if (!String.IsNullOrEmpty(tcCodigoEmpresa) && tlValidate) ReportTemplate._ValidaTemplates(_ConfigReportTemplates, tcCodigoEmpresa, tcCodigoIdioma);
        }

        public ReportTemplatesBase(String tcCodigoEmpresa, Boolean tlValidate = false)
        {
            this._Empresa = tcCodigoEmpresa;
            this._Idioma = String.Empty;
            this._TipoIdiomaEmpresa = TipoIdiomaEmpresa.Empresa;

            if (!String.IsNullOrEmpty(tcCodigoEmpresa) && tlValidate) ReportTemplate._ValidaTemplates(_ConfigReportTemplates, tcCodigoEmpresa, String.Empty);
        }

        #endregion constructores
    }
}