ObjetoGestDoc.cs

# region Usings
using System;
using System.Collections.Generic;
using System.Linq;
using System.ComponentModel;
using System.Data;
using sage.ew.db;
using sage.ew.global;
using System.IO;
using sage.addons.gestdoc.Negocio.Interfices;
using System.Windows.Forms; // TODO no es necesario cuando eliminemos la clase DEBUG
using sage.ew.functions;
using sage.ew.formul;
using sage.ew.enumerations;
#endregion Usings

namespace sage.addons.gestdoc.Negocio.Clases
{
    #region Clase ObjetoGestDoc
    public class ObjetoGestDoc : StateDataRow, IObjetoGestDoc
    {
        # region Propiedades privadas
        private BindingList<IUsuario> _lisUsuariosDelete;
        private BindingList<IPropiedad> _lisPropiedadesDelete;
        private BindingList<ITag> _lisTagsDelete;
        private sage.ew.usuario.Usuario _oUser = null;
        # endregion Propiedades privadas

        # region Propiedades protected internal
        protected internal bool _lSubscripcionActiva = true;

        protected internal bool _bSincronizar = false;

        protected internal string _cRutaDocsOneDrive = string.Empty;

        protected internal TipoConexion _oTipoConexionServicio = TipoConexion.OneDrive;

        protected internal int _nId = 0;

        protected internal string _cNombre = string.Empty;

        protected internal BindingList<IUsuario> _lisUsuarios;

        protected internal BindingList<IPropiedad> _lisPropiedades;

        protected internal BindingList<ITag> _lisTags;

        protected internal BindingList<IObjetoGestDoc> _lisChildren = null;


        protected internal DateTime _dFechaCreacion = DateTime.Now.Date;

        protected internal string _cUsuarioCreacion = string.Empty;

        protected internal string _cRutaLocal = string.Empty;

        protected internal string _cError_message = string.Empty;

        protected internal bool _lLoading = false;

        protected internal FormBase _Form = null;

        protected internal ToolStripProgressBar _oProgressbar = null;

        protected internal sage.addons.gestdoc.gestdoc _oGestDoc = null;
        protected internal sage.ew.usuario.Usuario _oUsuario
        {
            get
            {
                if (_oUser == null)
                {
                    _oUser = new sage.ew.usuario.Usuario();

                    if (!string.IsNullOrWhiteSpace(_UsuarioCreacion))
                        _oUser._Codigo = _cUsuarioCreacion;
                }

                return _oUser;
            }
            set
            {
                if (_oUser == null)
                    _oUser = new sage.ew.usuario.Usuario();

                _oUser = value;
            }
        }
        # endregion Propiedades protected internal

        # region Propiedades públicas
        public int _Id
        {
            get
            {
                return _nId;
            }
            set
            {
                _nId = value;
            }
        }

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

        public bool _EsCarpeta
        {
            get
            {
                return (this is ICarpeta);
            }
        }

        public BindingList<IUsuario> _Usuarios
        {
            get
            {
                if (_lisUsuarios == null)                    
                    _lisUsuarios = new BindingList<IUsuario>();

                return _lisUsuarios;
            }
            set
            {
                _lisUsuarios = value;
            }
        }

        public BindingList<IPropiedad> _Propiedades
        {
            get
            {
                if (_lisPropiedades == null)
                    _lisPropiedades = new BindingList<IPropiedad>();

                return _lisPropiedades;
            }
            set
            {
                _lisPropiedades = value;
            }
        }

        public BindingList<ITag> _Tags
        {
            get
            {
                if (_lisTags == null)
                    _lisTags = new BindingList<ITag>();

                return _lisTags;
            }
            set
            {
                _lisTags = value;
            }
        }

        public DateTime _FechaCreacion
        {
            get
            {
                return _dFechaCreacion;
            }
            set
            {
                _dFechaCreacion = value;
            }
        }

        public string _UsuarioCreacion
        {
            get
            {
                return _cUsuarioCreacion;
            }
            set
            {
                _cUsuarioCreacion = value;
            }
        }

        public string _NombreUsuarioCreacion
        {
            get
            {
                string lcNombre = string.Empty;

                if (_oUsuario != null)
                    lcNombre = Convert.ToString(_oUsuario._Nombre).Trim();

                return lcNombre;
            }
        }

        public virtual string _FullPath
        {
            get
            {
                return "";
            }  
        }

        public string _Error_message
        {
            get
            {
                return _cError_message;
            }
            set
            {
                _cError_message = value;
            }
        }
        # endregion Propiedades públicas

        # region Constructor
        public ObjetoGestDoc()
        {
            _lisUsuarios = new BindingList<IUsuario>();
            _lisPropiedades = new BindingList<IPropiedad>();
            _lisTags = new BindingList<ITag>();
            
            _lisChildren = new BindingList<IObjetoGestDoc>();

            _lisUsuariosDelete = new BindingList<IUsuario>();
            _lisPropiedadesDelete = new BindingList<IPropiedad>();
            _lisTagsDelete = new BindingList<ITag>();

            _oGestDoc = sage.addons.gestdoc.GESTDOC._Get_Objeto_GestDoc();
            if (_oGestDoc != null)
            {
                _lSubscripcionActiva = (_oGestDoc._BajaSuscripcion == false);
                ConfiguacioneSincronizar();
            }
        }
        #endregion Constructor

        # region Métodos públicos de la interfaz "IObjetoGestDoc"
        public virtual bool _New(int tnIdParent)
        {
            return false;
        }

        public virtual bool _Save()
        {
            return false;
        }

        public virtual bool _Cancel()
        {
            _DescargarDatos();

            return true;
        }

        public virtual bool _Load()
        {
            return false;
        }

        public virtual  bool _Delete()
        {
            _DescargarDatos();
            
            return true;
        }

        public virtual bool _Rename(string tcNewName)
        {
            return false;
        }

        public virtual bool _Upload(string tcPathOrigen)
        {
            return false;
        }

        public virtual bool _Download(string tcPathDestino)
        {
            return false;
        }

        public virtual DialogResult _Show()
        {
            return DialogResult.Cancel;
        }

        public virtual bool _Move(int tnIDObjetoDocDestino)
        {
            return false;
        }

        public bool _DeletePropiedad(IPropiedad toPropiedad)
        {
            _lisPropiedadesDelete.Add(toPropiedad);
            _lisPropiedades.Remove(toPropiedad);

            return true;
        }

        public bool _DeleteUsuario(IUsuario toUsuario)
        {
            _lisUsuariosDelete.Add(toUsuario);
            _lisUsuarios.Remove(toUsuario);

            return true;
        }

        public bool _DeleteTag(ITag toTag)
        {
            _lisTagsDelete.Add(toTag);
            _lisTags.Remove(toTag);

            return true;
        }

        public bool _AddPropiedad()
        {
            if (_Propiedades.Where(prop => string.IsNullOrWhiteSpace(prop._Propiedad)).Count() == 0)
            {
                _Propiedades.Add(new Propiedad(this));
                return true;
            }
            else
                return false;
        }

        public bool _AddPropiedad(IPropiedad toPropiedad)
        {
            Propiedad loTag = (Propiedad)toPropiedad;

            if (_ValidPropiedad(toPropiedad._Propiedad))
            {
                if (loTag._oObjetoGestDoc == null) // Tenemos de asegurarnos que tiene la referencia al objeto de la gestión documental
                    loTag._oObjetoGestDoc = this;

                _Propiedades.Add(toPropiedad);
                return true;
            }
            else
                return false;
        }

        public bool _AddTag()
        {
            if (_Tags.Where(tag => string.IsNullOrWhiteSpace(tag._Cadena)).Count() == 0)
            {
                _Tags.Add(new Tag(this));
                return true;
            }
            else
                return false;
        }

        public bool _AddTag(ITag toTag)
        {
            Tag loTag = (Tag)toTag;

            if (_ValidTag(loTag._Cadena))
            {
                if (loTag._oObjetoGestDoc == null) // Tenemos de asegurarnos que tiene la referencia al objeto de la gestión documental
                    loTag._oObjetoGestDoc = this;

                _Tags.Add(toTag);
                return true;
            }
            else
                return false;
        }

        public bool _AddUsuario()
        {
            if (_Usuarios.Where(usuario => string.IsNullOrWhiteSpace(usuario._Usuario)).Count() == 0)
            {
                _Usuarios.Add(new Usuario(this));

                return true;
            }
            else
                return false;
        }

        public bool _AddUsuario(IUsuario toIUsuario)
        {
            Usuario loUsuario = (Usuario)toIUsuario;

            if (_ValidUsuario(toIUsuario._Usuario))
            {
                if (loUsuario._oObjetoGestDoc == null) // Tenemos de asegurarnos que tiene la referencia al objeto de la gestión documental
                    loUsuario._oObjetoGestDoc = this;

                _Usuarios.Add(toIUsuario);

                return true;
            }
            else
                return false;
        }

        public eTipoAcceso _AccesoUsuario(string tcUsuario = "")
        {
            eTipoAcceso leTipoAcceso = eTipoAcceso.Completo;
            string lcUsuario;

            if (string.IsNullOrWhiteSpace(tcUsuario))
                lcUsuario = UsuarioActual();
            else
                lcUsuario = tcUsuario;

           if (lcUsuario != "SUPERVISOR")
           {
               var loUsuario = _Usuarios.AsEnumerable().Where(user => user._Usuario == lcUsuario);

               if (loUsuario.Count() > 0)
                   leTipoAcceso = (eTipoAcceso)loUsuario.First()._Nivel;
               else
                   leTipoAcceso = eTipoAcceso.Denegado;
           }

           return leTipoAcceso;
        }

        # endregion Métodos públicos de la interfaz "IObjetoGestDoc"

        #region Métodos public virtual
        public virtual void _DescargarDatos()
        {
            _nId = 0;
            _cNombre = string.Empty;
            _dFechaCreacion = DateTime.Now.Date;

            if (_lisUsuarios != null)
                _lisUsuarios.Clear();

            if (_lisPropiedades != null)
                _lisPropiedades.Clear();

            if (_lisTags != null)
                _lisTags.Clear();

            if (_lisChildren != null)
                _lisChildren.Clear();

            if (_lisUsuariosDelete != null)
                _lisUsuariosDelete.Clear();

            if (_lisPropiedadesDelete != null)
                _lisPropiedadesDelete.Clear();

            if (_lisTagsDelete != null)
                _lisTagsDelete.Clear();
        }

        public virtual bool _LoadPropiedades()
        {
            return false;
        }

        public virtual bool _LoadUsuarios()
        {
            return false;
        }

        public virtual bool _LoadTags()
        {
            return false;
        }
        #endregion Métodos public virtual

        # region Métodos protected internal
        protected internal DialogResult _MessageBox(String tcMensaje, MessageBoxButtons toBotones = MessageBoxButtons.OK, MessageBoxIcon toIcono =  MessageBoxIcon.Exclamation, MessageBoxDefaultButton toBotonDefecto = MessageBoxDefaultButton.Button1, DialogResult toResultadoDefecte =  DialogResult.OK)
        {
            DialogResult toResultado = new DialogResult();

            if (_Form != null)  // Si tenemos referencia al formulario
            {
                string lcCaption = _Form.Text;
                toResultado = FUNCTIONS._MessageBox(tcMensaje, lcCaption, toBotones, toIcono, toBotonDefecto, _Form);
            }
            else
            {
                _Error_message = tcMensaje;
                toResultado = toResultadoDefecte;
            }

            return toResultado;
        }

        protected internal void _MensajeError(string tcMensaje, MessageBoxButtons toMessageBoxButtons = MessageBoxButtons.OK, MessageBoxIcon toMessageBoxIcon = MessageBoxIcon.Exclamation)
        {
            _MessageBox(tcMensaje, toMessageBoxButtons, toMessageBoxIcon, MessageBoxDefaultButton.Button1, DialogResult.OK);
        }

        protected internal bool _FeaturesParent(int tnIdParent)
        {
            bool llOk = true; // De momento siempre devolvemos true

            if (tnIdParent > 0)
            {
                ICarpeta loCarpeta = new Carpeta(tnIdParent);

                if (loCarpeta._Id > 0)
                {
                    loCarpeta._Tags.ToList<ITag>().ForEach(tag => _AddTag(new Tag(this)._Clonar(tag)));
                    loCarpeta._Usuarios.ToList<IUsuario>().ForEach(user => _AddUsuario(new Usuario(this)._Clonar(user)));
                    loCarpeta._Propiedades.ToList<IPropiedad>().ForEach(prop => _AddPropiedad(new Propiedad(this)._Clonar(prop)));
                }
            }

            return llOk;
        }

        protected internal string UsuarioActual()
        {
            return Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario"));
        }

        protected internal bool _LoadFeatures()
        {
            bool llOk;

            llOk = _LoadPropiedades();
            llOk = llOk && _LoadUsuarios();
            llOk = llOk && _LoadTags();

            return llOk;
        }

        protected internal bool _Download(string tcPathDestino, ToolStripProgressBar toewProgressbar)
        {
            bool llOk;

            if (toewProgressbar != null)
                _oProgressbar = toewProgressbar;

            llOk = _Download(tcPathDestino);

            return llOk;
        }
        
        protected internal bool _DeleteFeatures()
        {
            bool llOk;

            // Primero eliminamos los registros borrados
            llOk = DeletePropiedades(_lisPropiedades);
            llOk = llOk && DeleteUsuarios(_lisUsuarios);
            llOk = llOk && DeleteTags(_lisTags);

            return llOk;
        }

        protected internal  bool _SaveFeatures()
        {
            bool llOk;
                        
            // Primero eliminamos los registros borrados
            llOk = DeletePropiedades(_lisPropiedadesDelete);
            llOk = llOk && DeleteUsuarios(_lisUsuariosDelete);
            llOk = llOk && DeleteTags(_lisTagsDelete);

            // Ahora podemos actualizar la información
            llOk = llOk && SavePropiedades();
            llOk = llOk && SaveUsuarios();
            llOk = llOk && SaveTags();

            return llOk;
        }

        protected internal int _MaxLinea(string tcTabla, string tcCampoWhere, int tnIdGestDoc = 0)
        {
            string lcSql;
            int lnLinea = 0, lnId = 0;
            bool llOk;
            DataTable ldtLineaMax = new DataTable();

            if (tnIdGestDoc == 0)
                lnId = _Id;
            else
                lnId = tnIdGestDoc;

            lcSql = "SELECT MAX(LINEA) AS LINEA " +
                    " FROM " + DB.SQLDatabase("GESTDOC", tcTabla) +
                    " WHERE " + tcCampoWhere + " =  " + DB.SQLString(lnId);

            llOk = DB.SQLExec(lcSql, ref ldtLineaMax);

            if (llOk && ldtLineaMax != null && ldtLineaMax.Rows.Count > 0 && ldtLineaMax.Rows[0]["LINEA"] != DBNull.Value)
                lnLinea =  Convert.ToInt32(ldtLineaMax.Rows[0]["LINEA"]);
 
            lnLinea++;

            return lnLinea;
        }

        protected internal void _AddUsuarios(DataTable tdtUsuarios, bool tlDataRowCopia = true)
        {
            if (tdtUsuarios.Rows.Count > 0)
            {
                foreach (DataRow ldrUsuario in tdtUsuarios.Rows)
                {
                    IUsuario loUsuario = new Usuario(this,ldrUsuario);
                    _Usuarios.Add(loUsuario);
                }
            }

            if (tlDataRowCopia)
                _Usuarios.ToList<IUsuario>().ForEach(user => ((Usuario)user)._DataRowCopia()); 
        }

        protected internal void _AddPropiedades(DataTable tdtPropiedades, bool tlDataRowCopia = true)
        {
            if (tdtPropiedades.Rows.Count > 0)
            {
                foreach (DataRow ldrPropiedad in tdtPropiedades.Rows)
                {
                    IPropiedad loPropiedad = new Propiedad(this,ldrPropiedad);
                    _Propiedades.Add(loPropiedad);
                }
            }

            if (tlDataRowCopia)
                _Propiedades.ToList<IPropiedad>().ForEach(user => ((Propiedad)user)._DataRowCopia());
        }

        protected internal void _AddTags(DataTable tdtTags, bool tlDataRowCopia = true)
        {
            if (tdtTags.Rows.Count > 0)
            {
                foreach (DataRow ldrTag in tdtTags.Rows)
                {
                    ITag loTag = new Tag(this,ldrTag);
                    _AddTag(loTag); // Agregamos el Tag
                }
            }

            if (tlDataRowCopia)
                _Tags.ToList<ITag>().ForEach(user => ((Tag)user)._DataRowCopia());
        }

        protected internal bool _ValidNombre()
        {
            bool llOk = true;

            string lcNombre = _cNombre.Trim();

            if (!string.IsNullOrWhiteSpace(lcNombre) && lcNombre.IndexOfAny(new char[] { '\\', '/', ':', '*', '?', '\"', '<', '>', '|' }) != -1)
            {
                string lcMensaje;

                if (this is IDocumento)
                    lcMensaje = "archivos";
                else
                    lcMensaje = "carpetas";
                
                llOk = false;
                _MessageBox("Los nombres de " + lcMensaje + " no pueden contener ninguno de los siguientes carácteres:" + Environment.NewLine + "\\/:*?\"<>|");
            }
            else 
            {
                if (this is ICarpeta && lcNombre.Length > 50)
                {
                    _MessageBox("El ancho máximo de una carpeta es de 50 carácteres.");
                    llOk = false;
                }
                else if (this is IDocumento && lcNombre.Length > 100)
                {
                    _MessageBox("El ancho máximo de un documento es de 100 carácteres.");
                    llOk = false;
                }
            }

            return llOk;
        }

        protected internal bool _ValidPropiedad(string tcPropiedad)
        {
            if (tcPropiedad == null)
                return true;

            string lcPropiedad = tcPropiedad.Trim();

            if (!string.IsNullOrWhiteSpace(lcPropiedad) && _Propiedades.Where(prop => prop._Propiedad == lcPropiedad).Count() > 0)
            {
                _MessageBox("La propiedad '" + lcPropiedad + "' se ha entrado previamente");
                return false;
            }

            return true;
        }

        protected internal bool _ValidUsuario(string tcUsuario)
        {
            string lcUsuario = tcUsuario.Trim();

            if (!string.IsNullOrWhiteSpace(lcUsuario) && _Usuarios.Where(user => user._Usuario == lcUsuario).Count() > 0)
            {
                _MessageBox("El usuario " + lcUsuario + " se ha entrado previamente");
                return false;
            }

            return true;
        }

        protected internal bool _ValidTag(string tcCadenaTag)
        {
            string lcCadenaTag = tcCadenaTag.Trim();

            if (!string.IsNullOrWhiteSpace(lcCadenaTag) && _Tags.Where(tag => tag._Cadena.Trim() == lcCadenaTag).Count() > 0)
            {
                _MessageBox("La etiqueta " + lcCadenaTag + " se ha entrado previamente");
                return false;
            }

            return true;
        }

        protected internal DataTable _DataTableUsuarios()
        {
            string lcSql;
            bool llOk;
            DataTable ldtUsuarios = new DataTable();

            lcSql = "SELECT CODIGO, NOMBRE " + 
                 " FROM " + DB.SQLDatabase("COMUNES", "USUARIOS") +
                 " WHERE VISIBLE = " + DB.SQLTrue() + 
                 " ORDER BY NOMBRE";

            llOk = DB.SQLExec(lcSql, ref ldtUsuarios);

            if (!llOk)
                _MensajeError("Se ha producido un error al consultar los usuarios.");

            return ldtUsuarios;
        }

        protected internal int _MaxId(string tcTabla)
        {
            int lnIdMax = 0;
            string lcSql = string.Empty;
            DataTable ldtMaxId = new DataTable();

            lcSql = "SELECT MAX(id) AS maxim FROM " + DB.SQLDatabase("GESTDOC", tcTabla);

            DB.SQLExec(lcSql, ref ldtMaxId);

            if (ldtMaxId != null && ldtMaxId.Rows.Count > 0 && !string.IsNullOrWhiteSpace(Convert.ToString(ldtMaxId.Rows[0]["maxim"])))
                lnIdMax = (Convert.ToInt32(ldtMaxId.Rows[0]["maxim"]) + 1);
            else
                lnIdMax = 1;

            return lnIdMax;
        }

        protected internal string _DirectoryParents(ref string tcCarpeta, int tnCarpeta)
        {
            string lcSql, lcCarpeta = string.Empty;

            DataTable ldtCarpetas = new DataTable();

            lcSql = "SELECT ID, NOMBRE, PARENT" +
                    " FROM " + DB.SQLDatabase("GESTDOC", "CARPETAS") +
                    " WHERE id != 1"; // Excluimos el Id 1 del directorio Documentos, siempre se ha de crear en la carpeta \Gestdoc\Documentos\

            bool llOk = DB.SQLExec(lcSql, ref ldtCarpetas);

            if (llOk && ldtCarpetas.Rows.Count > 0)
                DirectoryParents(ref tcCarpeta, tnCarpeta, ldtCarpetas);

            return lcCarpeta;
        }

        protected internal bool _ExisteMantePropiedades(string tcPropiedad)
        {
            DataTable ldtProps = new DataTable();
            string lcSql;
            bool llOk;

            lcSql = "SELECT PROPIEDAD FROM  " + DB.SQLDatabase("GESTDOC", _TaulaPropiedad()) +
                    " WHERE PROPIEDAD =  " + DB.SQLString(tcPropiedad);

            DB.SQLExec(lcSql, ref ldtProps);
            llOk = (ldtProps != null && ldtProps.Rows.Count > 0);                

            return llOk;
        }

        protected internal bool _DeleteMantePropiedades(string tcPropiedad)
        {
            string lcSql;
            bool llOk;

            lcSql = "DELETE FROM  " + DB.SQLDatabase("GESTDOC", _TaulaPropiedad()) +
                    " WHERE PROPIEDAD =  " + DB.SQLString(tcPropiedad);

            llOk = DB.SQLExec(lcSql);

            if (!llOk)
                _MensajeError("Se ha producido un error al borrrar las propiedades.");

            return llOk;
        }

        protected internal string _TaulaPropiedad(IObjetoGestDoc toObjetoGestDoc = null)
        {
            if (ObjetoGestDocumental(toObjetoGestDoc) is Documento)
                return "DOC_PROP";
            else
                return "CARP_PROP";
        }

        protected internal string _TaulaTags(IObjetoGestDoc toObjetoGestDoc = null)
        {
            if (ObjetoGestDocumental(toObjetoGestDoc) is Documento)
                return "DOC_TAGS";
            else
                return "CARP_TAGS";
        }

        protected internal string _TaulaUsuarios(IObjetoGestDoc toObjetoGestDoc = null)
        {
            if (ObjetoGestDocumental(toObjetoGestDoc) is Documento)
                return "DOC_USER";
            else
                return "CARP_USER";
        }

        protected internal string _IdTaula(IObjetoGestDoc toObjetoGestDoc = null)
        {
            if (ObjetoGestDocumental(toObjetoGestDoc) is Documento)
                return "IDDOC";
            else
                return "IDCARPETA";
        }

        protected internal bool _InsertPropiedad(int tnIdGestDoc, IPropiedad toPropiedad, int tnLinea = 0, bool tlParents = true, IObjetoGestDoc toObjetoGestDoc = null)
        {
            bool llOk;
            string lcSql , lcTaula , lcCampoId;
            int lnLinea;

            lnLinea = tnLinea;
            lcTaula = _TaulaPropiedad(toObjetoGestDoc);
            lcCampoId = _IdTaula(toObjetoGestDoc);

            if (lnLinea == 0)
                lnLinea = _MaxLinea(lcTaula, lcCampoId, tnIdGestDoc);

            lcSql = "INSERT INTO " + DB.SQLDatabase("GESTDOC", lcTaula) +
                  " (" + lcCampoId + ", PROPIEDAD, VALOR, LINEA)" +
                  " Values(" + DB.SQLString(tnIdGestDoc) + ", " + DB.SQLString(toPropiedad._Propiedad) + ", " + DB.SQLString(toPropiedad._Valor) + ", " + DB.SQLString(lnLinea) + ")";

            llOk = DB.SQLExec(lcSql);

            if (llOk && tlParents && (this is ICarpeta))
                InsertPropiedadesParents(tnIdGestDoc, toPropiedad);

            return llOk;
        }

        protected internal bool _InsertTag(int tnIdGestDoc, ITag toTag, string tcIdTag, int tnLinea = 0, bool tlParents = true, IObjetoGestDoc toObjetoGestDoc = null)
        {
            bool llOk;
            string lcSql, lcTaula, lcCampoId;
            int lnLinea;

            lnLinea = tnLinea;
            lcTaula = _TaulaTags(toObjetoGestDoc);
            lcCampoId = _IdTaula(toObjetoGestDoc);

            if (lnLinea == 0)
                lnLinea = _MaxLinea(lcTaula, lcCampoId, tnIdGestDoc);

            lcSql = "INSERT INTO " + DB.SQLDatabase("GESTDOC", lcTaula) +
                  " (" + lcCampoId + ", IDTAG, LINEA)" +
                  " Values(" + DB.SQLString(tnIdGestDoc) + ", " + DB.SQLString(tcIdTag) + ", " + DB.SQLString(lnLinea) + ")";

            llOk = DB.SQLExec(lcSql);

            if (llOk && tlParents && (this is ICarpeta))
                InsertTagParents(tnIdGestDoc, toTag, tcIdTag);

            return llOk;
        }

        protected internal bool _InsertUsuario(int tnIdGestDoc, IUsuario toUsuario, int tnLinea = 0, bool tlParents = true, IObjetoGestDoc toObjetoGestDoc = null)
        {
            bool llOk;
            string lcSql, lcTaula, lcCampoId;
            int lnLinea;

            lnLinea = tnLinea;
            lcTaula = _TaulaUsuarios(toObjetoGestDoc);
            lcCampoId = _IdTaula(toObjetoGestDoc);

            if (lnLinea == 0)
                lnLinea = _MaxLinea(lcTaula, lcCampoId, tnIdGestDoc);

            lcSql = "INSERT INTO " + DB.SQLDatabase("GESTDOC", lcTaula) +
                    " (" + lcCampoId + ", USUARIO,  NIVEL, LINEA)" +
                    " Values(" + DB.SQLString(tnIdGestDoc) + ", " + DB.SQLString(toUsuario._Usuario) + ", " + DB.SQLString(toUsuario._Nivel) + ", " + DB.SQLString(lnLinea) + ")";

            llOk = DB.SQLExec(lcSql);

            if (llOk && tlParents && (this is ICarpeta))
                InsertUsuarioParents(tnIdGestDoc, toUsuario);

            return llOk;
        }

        protected internal void _PerformStepProggressbar()
        {
            if (_oProgressbar != null)
            {
                if (_oProgressbar.Value < _oProgressbar.Maximum)
                {
                    _oProgressbar.PerformStep();
                    Application.DoEvents();
                }
            }
        }

        protected internal void _MensajeError(string tcMensaje)
        {
            if (!string.IsNullOrWhiteSpace(tcMensaje))
                _Error_message = tcMensaje;
        }

        protected internal string _DirectoryGestDocDocumentos(string tcCarpeta)
        {
            string lcPath = FunctionsGestDoc._DirectorioGestDoc();

            if (string.IsNullOrWhiteSpace(lcPath))
                return "";

            lcPath = Path.Combine(lcPath, "Docs" + FUNCTIONS._Grupo_Actual());
            lcPath = Path.Combine(lcPath, "Documentos");

            if (!string.IsNullOrWhiteSpace(tcCarpeta))
                lcPath = Path.Combine(lcPath, tcCarpeta);

            return lcPath + Path.DirectorySeparatorChar;
        }

        protected internal bool _DirectoryExist(string tcPath, bool tlCreate = true)
        {
            bool llExist;
            string lcPath = string.Empty ,lcMensajeError = string.Empty;

            try
            {
                lcPath = Path.GetDirectoryName(tcPath);
                llExist = Directory.Exists(tcPath);
            }
            catch (Exception loEx)
            {
                DB.Registrar_Error(loEx); //Registramos excepción
                llExist = false;
                lcMensajeError = "No se ha podido crear el directorio " + lcPath + "." + Environment.NewLine + Environment.NewLine + loEx.Message;

            }

            if (string.IsNullOrWhiteSpace(lcMensajeError) && !llExist && tlCreate)
            {
                try 
                {
                    Directory.CreateDirectory(lcPath);
                    llExist = Directory.Exists(lcPath);
                }
                catch (Exception loEx)
                {
                    DB.Registrar_Error(loEx); //Registramos excepción
                    lcMensajeError = "No se ha podido crear el directorio " + lcPath + "." + Environment.NewLine + Environment.NewLine + loEx.Message;
                }
            }

            if (!string.IsNullOrWhiteSpace(lcMensajeError))
                _MensajeError(lcMensajeError);

            return llExist;
        }

        protected internal bool _DeleteDirectoryRecursive(string tcDirectory, bool tlRecursive = true)
        {
            bool llOk = true;

            string lcMensaje = string.Empty, lcDirectoryRename = string.Empty;

            if (Directory.Exists(tcDirectory))
            {
                // Primero intentamos mover el directorio. De esta forma gestionamos si hay ficheros en Uso
                try
                {
                    lcDirectoryRename = FunctionsGestDoc._DirectorySeparatorChar(tcDirectory);

                    if (Path.GetDirectoryName(tcDirectory).Length < 230) // Si el directorio es muy largo no lo intentamos renombrar, puede dar error, directamente lo borramos, es lo que el usuario desea hacer 
                    {
                        lcDirectoryRename = System.IO.Directory.GetParent(tcDirectory).Parent.FullName;

                        string lcGuid = Guid.NewGuid().ToString("N").Substring(0, 8);
                        lcDirectoryRename = FunctionsGestDoc._DirectorySeparatorChar(Path.Combine(lcDirectoryRename, lcGuid));
                        Directory.Move(tcDirectory, lcDirectoryRename);
                    }
                }
                catch (Exception loEx)
                {
                    llOk = false;
                    lcMensaje = "No se ha podido eliminar las versiones del documento." + Environment.NewLine + Environment.NewLine + loEx.Message;
                }

                if (llOk) // Si todo va correcto ahora podemos eliminar la carpeta renombrada
                {
                    try
                    {
                        Directory.Delete(FunctionsGestDoc._DirectorySeparatorChar(lcDirectoryRename), true); // Borramos recursivamente, si hay documentos o carpetas no se borraria
                    }
                    catch (Exception loEx)
                    {
                        lcMensaje = "No se ha podido eliminar las versiones del documento." + Environment.NewLine + loEx.Message;
                    }

                    llOk = !Directory.Exists(tcDirectory);
                }
            }

            if (!llOk)
                _MensajeError("No se ha podido eliminar el directorio " + tcDirectory + "." + lcMensaje);

            return llOk;
        }

        protected internal bool _ProcesoGestDoc()
        {
            return (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_gestdoc_proceso")));
        }

        protected internal bool _GestDocPendiente(string tcMensaje)
        {
            if (_ProcesoGestDoc()) // Si estamos ejecutando el proceso ya podemos salir
                return false;

            bool llKo = (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_ewgestdoc")));

            if (llKo)
                _MensajeError(tcMensaje);

            return llKo;
        }
        # endregion Métodos protected internal

        # region Métodos privados
        private bool DeletePropiedades(BindingList<IPropiedad> toListPropiedades)
        {
            bool llOk = true;

            foreach (IPropiedad loPropiedad in toListPropiedades)
            {
                llOk = llOk && loPropiedad._Delete();

                if (!llOk)
                    break;
            }

            return llOk;
        }

        private bool DeleteTags(BindingList<ITag> toListTags)
        {
            bool llOk = true;

            foreach (ITag loTag in toListTags)
            {
                llOk = llOk && loTag._Delete();

                if (!llOk)
                    break;
            }

            return llOk;
        }

        private bool DeleteUsuarios(BindingList<IUsuario> toListUuarios)
        {
            bool llOk = true;

            foreach (IUsuario loUsuario in toListUuarios)
            {
                llOk = llOk && loUsuario._Delete();

                if (!llOk)
                    break;
            }

            return llOk;
        }

        private bool SavePropiedades()
        {
            bool llOk = true;

            foreach (IPropiedad loPropiedad in _Propiedades)
            {
                llOk = llOk && loPropiedad._Save();

                if (!llOk)
                    break;
            }

            return llOk;
        }

        private bool SaveTags()
        {
            bool llOk = true;

            foreach (ITag loTag in _Tags)
            {
                llOk = llOk && loTag._Save();

                if (!llOk)
                    break;
            }

            return llOk;
        }

        private bool SaveUsuarios()
        {
            bool llOk = true;

            foreach (IUsuario loUsuario in _Usuarios)
            {
                llOk = llOk && loUsuario._Save();

                if (!llOk)
                    break;
            }

            return llOk;
        }

        private bool ExistPropiedad(int tnId, string tcTaula, string tcCampoId, string tcPropiedad)
        {
            bool llOk;
            bool llExist = false;
            DataTable ldtExist = new DataTable();

            llOk = DB.SQLExec("SELECT " + tcCampoId +
                              " FROM " + DB.SQLDatabase("GESTDOC", tcTaula) +
                              " WHERE " + tcCampoId + " = " + DB.SQLString(tnId) +
                              " AND PROPIEDAD = " + DB.SQLString(tcPropiedad), ref ldtExist);

            llExist = (llOk && ldtExist != null && ldtExist.Rows.Count > 0);

            return llExist;
        }

        private bool ExistTag(int tnId, string tcTaula, string tcCampoId, string tcIdTag)
        {
            bool llOk;
            bool llExist = false;
            DataTable ldtExist = new DataTable();

            llOk = DB.SQLExec("SELECT " + tcCampoId +
                              " FROM " + DB.SQLDatabase("GESTDOC", tcTaula) +
                              " WHERE " + tcCampoId + " = " + DB.SQLString(tnId) +
                              " AND IDTAG = " + DB.SQLString(tcIdTag), ref ldtExist);

            llExist = (llOk && ldtExist != null && ldtExist.Rows.Count > 0);

            return llExist;
        }

        private bool ExistUsuario(int tnId, string tcTaula, string tcCampoId, string tcUsuario)
        {
            bool llOk;
            bool llExist = false;
            DataTable ldtExist = new DataTable();

            llOk = DB.SQLExec("SELECT " + tcCampoId +
                              " FROM " + DB.SQLDatabase("GESTDOC", tcTaula) +
                              " WHERE " + tcCampoId + " = " + DB.SQLString(tnId) +
                              " AND USUARIO = " + DB.SQLString(tcUsuario), ref ldtExist);

            llExist = (llOk && ldtExist != null && ldtExist.Rows.Count > 0);

            return llExist;
        }

        private bool InsertPropiedadesParents(int tnIdParent, IPropiedad toIPropiedad)
        {
            int lnId;
            string lcTaula, lcCampoId;
            bool llOk = true, llCarpeta;
            Carpeta loCarpeta = new Carpeta();
            Documento loDocumento = new Documento();
            ObjetoGestDoc loObjetoGestDoc;

            DataTable ldtParents = FunctionsGestDoc._Children(eTipoConsultaCarpetasDocumentos.TodosNiveles, tnIdParent, tlFiltrarNivelAcceso: false);

            foreach (DataRow ldrParent in ldtParents.Rows)
            {
                lnId = Convert.ToInt32(ldrParent["id"]);
                llCarpeta = Convert.ToBoolean(ldrParent["carpeta"]); // Si es una carpeta ha de actualizar los parents (carpetas o documentos)

                if (llCarpeta)
                    loObjetoGestDoc = loCarpeta;
                else
                    loObjetoGestDoc = loDocumento;

                lcTaula = _TaulaPropiedad(loObjetoGestDoc);
                lcCampoId = _IdTaula(loObjetoGestDoc);

                if (!ExistPropiedad(lnId, lcTaula, lcCampoId, toIPropiedad._Propiedad))
                {
                    // tlParents => false.  No es necesario que actualice los parents, el DataTable ya tiene todos los documentos y carpetas a actualizar
                    llOk = _InsertPropiedad(lnId, toIPropiedad, tlParents: false, toObjetoGestDoc: loObjetoGestDoc);

                    if (!llOk)
                        break;
                }
            }

            return llOk;
        }

        private bool InsertTagParents(int tnIdParent, ITag toITag, string tcIdTag)
        {
            int lnId;
            string lcTaula, lcCampoId;
            bool llOk = true, llCarpeta;
            Carpeta loCarpeta = new Carpeta();
            Documento loDocumento = new Documento();
            ObjetoGestDoc loObjetoGestDoc = null;

            DataTable ldtParents = FunctionsGestDoc._Children(eTipoConsultaCarpetasDocumentos.TodosNiveles, tnIdParent, tlFiltrarNivelAcceso: false);

            foreach (DataRow ldrParent in ldtParents.Rows)
            {
                lnId = Convert.ToInt32(ldrParent["id"]);
                llCarpeta = Convert.ToBoolean(ldrParent["carpeta"]); // Si es una carpeta ha de actualizar los parents (carpetas o documentos)

                if (llCarpeta)
                    loObjetoGestDoc = loCarpeta;
                else
                    loObjetoGestDoc = loDocumento;

                lcTaula = _TaulaTags(loObjetoGestDoc);
                lcCampoId = _IdTaula(loObjetoGestDoc);

                if (!ExistTag(lnId, lcTaula, lcCampoId, tcIdTag))
                {
                    // tlParents => false.  No es necesario que actualice los parents, el DataTable ya tiene todos los documentos y carpetas a actualizar
                    llOk = _InsertTag(lnId, toITag, tcIdTag, tlParents: false, toObjetoGestDoc: loObjetoGestDoc);

                    if (!llOk)
                        break;
                }
            }

            return llOk;
        }

        private bool InsertUsuarioParents(int tnIdParent, IUsuario toIUsario)
        {
            int lnId;
            string lcTaula,lcCampoId;
            bool llOk = true, llCarpeta;
            Carpeta loCarpeta = new Carpeta();
            Documento loDocumento = new Documento();
            ObjetoGestDoc loObjetoGestDoc = null;

            DataTable ldtParents = FunctionsGestDoc._Children(eTipoConsultaCarpetasDocumentos.TodosNiveles, tnIdParent, tlFiltrarNivelAcceso: false);

            foreach (DataRow ldrParent in ldtParents.Rows)
            {
                lnId = Convert.ToInt32(ldrParent["id"]);
                llCarpeta = Convert.ToBoolean(ldrParent["carpeta"]); // Si es una carpeta ha de actualizar los parents (carpetas o documentos)

                if (llCarpeta)
                    loObjetoGestDoc = loCarpeta;
                else
                    loObjetoGestDoc = loDocumento;

                lcTaula = _TaulaUsuarios(loObjetoGestDoc);
                lcCampoId = _IdTaula(loObjetoGestDoc);

                if (!ExistUsuario(lnId, lcTaula, lcCampoId, toIUsario._Usuario))
                {
                    // tlParents => false.  No es necesario que actualice los parents, el DataTable ya tiene todos los documentos y carpetas a actualizar
                    llOk = _InsertUsuario(lnId, toIUsario, tlParents: false, toObjetoGestDoc: loObjetoGestDoc);

                    if (!llOk)
                        break;
                }
            }

            return llOk;
        }

        private IObjetoGestDoc ObjetoGestDocumental(IObjetoGestDoc toObjetoGestDoc = null)
        {
            IObjetoGestDoc loObjetoGestDoc;

            if (toObjetoGestDoc != null)
                loObjetoGestDoc = toObjetoGestDoc; // Actualización de un parent
            else
                loObjetoGestDoc = this; // Actualización del documento o carpeta actual

            return loObjetoGestDoc;
        }

        private void DirectoryParents(ref string tcCarpeta, int tnIdCarpetaParent, DataTable tdtCarpetas)
        {
            int lnCarpetaParent;

            DataRow[] ldrCarpeta = tdtCarpetas.Select(" id = " + Convert.ToString(tnIdCarpetaParent).Trim());

            if (ldrCarpeta != null && ldrCarpeta.Count() > 0)
            {
                tcCarpeta = Path.Combine(Convert.ToString(ldrCarpeta[0]["nombre"]).Trim(), tcCarpeta); // Agregamos la carpeta del padre PADRE + HIJA (tcCarpeta)
                lnCarpetaParent = Convert.ToInt32(ldrCarpeta[0]["parent"]);

                if (lnCarpetaParent > 0) // Si tiene padre
                    DirectoryParents(ref tcCarpeta, lnCarpetaParent, tdtCarpetas);
            }
        }

        private void ConfiguacioneSincronizar()
        {
            _bSincronizar = !string.IsNullOrWhiteSpace(_oGestDoc._Configuracion._RefreshTokenOneDrive) && !string.IsNullOrWhiteSpace(_oGestDoc._Configuracion._CuentaOneDrive);
            _cRutaDocsOneDrive = _oGestDoc._Configuracion._RutaDocsOneDrive;

            if (_oGestDoc._Configuracion._TipoServicio == 0)
                _oTipoConexionServicio = TipoConexion.OneDrive;
            else
                _oTipoConexionServicio = TipoConexion.O365;
        }
        #endregion Métodos privados
    }
    #endregion Clase ObjetoGestDoc

    # region Clase StateDataRow
    public class StateDataRow
    {
        # region Propiedades privadas
        private DataRow _drObjeto = null;
        private DataTable _dtObjeto = null;
        private eTipoActualizacionObjeto _eInsertUpdate;
        # endregion Propiedades privadas

        # region Protected internal
        protected internal Type _Tipo = null;
        # endregion Protected internal

        # region Métodos public virtual
        public virtual bool _DataRowCondicion()
        {
            return true;
        }
        # endregion Métodos public virtual

        # region Métodos protected internal
        protected internal void _DataRowCopia()
        {
            if (_DataRowCondicion()) 
                _drObjeto = DataRowObjeto();
        }

        protected internal eTipoActualizacionObjeto _TipoActualizacion()
        {
            if (_eInsertUpdate == eTipoActualizacionObjeto.Delete) // SI está macardo para borrar ya podemos salir
                return _eInsertUpdate;

            DataRow ldrTemp = DataRowObjeto();

            if (_drObjeto != null) //si la copia de la linia es null, aleshores l'hem d'insertar la linia
            {
                if (!DataRowComparer.Default.Equals(_drObjeto, ldrTemp))   //hem d comparar si hi ha hagut algun canvi.     
                    _eInsertUpdate = eTipoActualizacionObjeto.Update;
                else
                    _eInsertUpdate = eTipoActualizacionObjeto.Nothing;
            }
            else
                _eInsertUpdate = eTipoActualizacionObjeto.Insert;

            _drObjeto = null;
            _drObjeto = ldrTemp;

            return _eInsertUpdate;
        }
        # endregion Métodos protected internal

        # region Métodos privados
        private DataRow DataRowObjeto()
        {
            if (_Tipo == null)
                return null;

            PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(_Tipo);

            List<string> lstName = new List<string> { "_Children", "_Error_message" }; 

            if (_drObjeto == null)   //si no s'ha creat el datatable amb les propietats publiques el creem 
            {
                _dtObjeto = new DataTable();
                foreach (PropertyDescriptor prop in properties)
                {
                    if (!string.IsNullOrWhiteSpace(prop.Name) && prop.Name.Substring(0, 1) == "_" && !lstName.Contains(prop.Name)) // descartem les propietats q no comencen amb _ ja que només volem les publiques
                        _dtObjeto.Columns.Add(prop.Name, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType);
                }
            }

            DataRow row = _dtObjeto.NewRow();  //guardem la linia que es passa per parametre a un datarow            
            foreach (PropertyDescriptor prop in properties)
            {
                if (!string.IsNullOrWhiteSpace(prop.Name) && prop.Name.Substring(0, 1) == "_" && !lstName.Contains(prop.Name))  //descartem les propietats q no comencen amb _ ja que només volem les públiques
                {
                    try
                    {
                        row[prop.Name] = prop.GetValue(this) ?? DBNull.Value;
                    }
                    catch (Exception)
                    {
                        row[prop.Name] = DBNull.Value;
                    }
                }
            }

            return row;
        }
        # endregion Métodos privados
    }
    # endregion Clase StateDataRow
}