FunctionsGestDoc.cs

# region Usings
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using sage.ew.db;
using sage.ew.global;
using System.Drawing;
using Microsoft.Win32;
using System.Runtime.InteropServices;
using sage.ew.interficies;
using System.IO;
using sage.addons.gestdoc.Negocio.Interfices;
using System.Reflection;
using System.ComponentModel;
using sage.ew.docventatpv;
using sage.ew.docsven;
using sage.ew.stocks;
using sage.ew.ewbase;
using sage.ew.docscompra;
using sage.ew.functions;
using sage.ew.listados.Clases;
using sage.ew.enumerations;
#endregion Usings

namespace sage.addons.gestdoc.Negocio.Clases
{
    public static partial class FunctionsGestDoc
    {
        #region Importación de dll
        [DllImport("Shell32", CharSet = CharSet.Auto)]
        private static extern int ExtractIconEx(
          string lpszFile,
          int nIconIndex,
          IntPtr[] phIconLarge,
          IntPtr[] phIconSmall,
          int nIcons);

        [DllImport("user32.dll", EntryPoint = "DestroyIcon", SetLastError = true)]
        private static extern int DestroyIcon(IntPtr hIcon);
        #endregion Importación de dll

        public static DataTable _Children(eTipoConsultaCarpetasDocumentos teTipoCarpetasDocumentos = eTipoConsultaCarpetasDocumentos.Nivel, int tnIdParentCarpeta = 1, string tcUsuario = "", bool tlFiltrarNivelAcceso = true, bool tlDelete = false)
        {
            DataTable ldtCarpetas = new DataTable();
            DataTable ldtDocumentos = new DataTable();
            DataTable ldtCarpetasDocs = new DataTable();
            
            string lcUsuario;
            bool llOk, llOrphan;

            if (string.IsNullOrWhiteSpace(tcUsuario))
                lcUsuario = Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario"));
            else
                lcUsuario = tcUsuario;

            llOrphan = (teTipoCarpetasDocumentos == eTipoConsultaCarpetasDocumentos.Nivel && tnIdParentCarpeta == 1 && lcUsuario != "SUPERVISOR"); // Al consultar las carpetas del nivel si estamos en Documentos ha de presentar las carpetas huérfanas

            llOk = _Carpetas(ref ldtCarpetas, teTipoCarpetasDocumentos, tnIdParentCarpeta, lcUsuario, tlOrphan: llOrphan);
            llOk = llOk && _Documentos(ref ldtDocumentos, teTipoCarpetasDocumentos, tnIdParentCarpeta, lcUsuario, tlDelete);

            if (llOk)
            {
                _AddColumnsIconDocumentos(ldtCarpetas);
                _AddColumnDatatable(ldtCarpetas, "useract", "System.String");
                _AddColumnDatatable(ldtCarpetas, "description", "System.Object");
                _AddColumnDatatable(ldtCarpetas, "extension", "System.Object");

                ldtCarpetasDocs = ldtCarpetas.Clone(); // Clonamos la estructura del DataTable

                int lnNivel;
                if (ldtCarpetas.Rows.Count > 0) // Ahora añadiremos las carpetas y los documentos si es necesario
                    lnNivel = Convert.ToInt32(ldtCarpetas.Rows[0]["nivel"]);
                else
                {
                    DataTable ldtCarpeta = new DataTable();
                    _Carpetas(ref ldtCarpeta, teTipoCarpetasDocumentos, tnIdParentCarpeta, lcUsuario, tlOrphan: llOrphan); // En un principio no seria necesario, siempre debería de tener acceso, si estamos desde la capa visual

                    if (ldtCarpeta.Rows.Count > 0)
                        lnNivel = Convert.ToInt32(ldtCarpeta.Rows[0]["nivel"]);
                    else
                        lnNivel = 0;
                }

                _ChildrenCarpetasDocumentos(teTipoCarpetasDocumentos, tnIdParentCarpeta, lnNivel, ref ldtCarpetasDocs, ref ldtCarpetas, ref ldtDocumentos, tlOrphan: llOrphan);

                if (!tlDelete && tlFiltrarNivelAcceso) // En el borrado de una carpeta ha de controlar si hay carpetas que no podamos eliminar
                    _NivelAccesoCarpetas(ref ldtCarpetasDocs, teTipoCarpetasDocumentos, tnIdParentCarpeta, lcUsuario);
            }

            return ldtCarpetasDocs;
        }

        public static void _AddColumnsIconDocumentos(DataTable tdtGestDoc, bool tlIconsEdition = true)
        {
            _AddColumnDatatable(tdtGestDoc, "iconSmall", "System.Object");
            _AddColumnDatatable(tdtGestDoc, "iconLarge", "System.Object");

            if (tlIconsEdition)
            {
                _AddColumnDatatable(tdtGestDoc, "iconSmallEdition", "System.Object");
                _AddColumnDatatable(tdtGestDoc, "iconLargeEdition", "System.Object");
                _AddColumnDatatable(tdtGestDoc, "iconSmallEditionByOtherUSer", "System.Object");
                _AddColumnDatatable(tdtGestDoc, "iconLargeEditionByOtherUSer", "System.Object");
            }
        }


        public static bool _NivelAccesoCarpetas(ref DataTable tdtCarpetasDocs, eTipoConsultaCarpetasDocumentos teTipoCarpetasDocumentos, int tnIdParentCarpeta, string tcUsuario)
        {
            if (tdtCarpetasDocs.Rows.Count == 0)
                return true;

            // Si somos el usuario supervisor ya podemos salir, tenemos acceso a todo el arbol
            if (tcUsuario == "SUPERVISOR")
                return true;

            var ldtCarpetas = tdtCarpetasDocs.AsEnumerable().Where(myRow => ((myRow.Field<int>("nivel") == -1))); // Necesario para poder realizar la asignación

            DataTable ldtCarpetasDocs = tdtCarpetasDocs.Clone();

            if (tnIdParentCarpeta == 1) // Si presentamos en el ID 1 ha de presentar únicamente las carpetas que cuelgan de "Documentos" y las carpetas huérfanas. En la carpeta 1 no podemos subir documentos
            {
                if (teTipoCarpetasDocumentos == eTipoConsultaCarpetasDocumentos.TodosNiveles) // Devuelve las carpetas/documentos existentes a partir de un Id parent en todos los niveles recursivo por debajo del parent.
                    ldtCarpetasDocs = tdtCarpetasDocs.AsEnumerable().Where(myRow => (myRow.Field<bool>("carpeta") == true && myRow.Field<int>("nivel") >= 1 && (myRow.Field<int>("id_parent") == tnIdParentCarpeta || myRow.Field<bool>("orphan")))).__CopyToDataTable();
                else
                    ldtCarpetasDocs = tdtCarpetasDocs.AsEnumerable().Where(myRow => ((myRow.Field<int>("id_parent") == tnIdParentCarpeta && myRow.Field<int>("nivel") >= 1) || myRow.Field<bool>("orphan"))).__CopyToDataTable();  // Consultamos carpetas y documentos del Id Parent actual y las carpetas huérfanas
            }
            else
                ldtCarpetasDocs = tdtCarpetasDocs.AsEnumerable().Where(myRow => (myRow.Field<int>("id_parent") == tnIdParentCarpeta && myRow.Field<int>("nivel") >= 1)).__CopyToDataTable(); // Consultamos carpetas y documentos del Id Parent actual

            tdtCarpetasDocs.Clear();
            tdtCarpetasDocs.Dispose();

            tdtCarpetasDocs = ldtCarpetasDocs;

            return true;
        }

        public static bool _Carpetas(ref DataTable tdtCarpetas, eTipoConsultaCarpetasDocumentos teTipoCarpetasDocumentos, int tnIdParentCarpeta, string tcUsuario, bool tlFilterId = false, bool tlOrphan = false)
        {
            string lcSql, lcNivelUsuarioCarpetas, lcLeftNivelCarpetas = "";
            bool llOk;

            if (tcUsuario == "SUPERVISOR")
                lcNivelUsuarioCarpetas = ", 2 AS nivel ";  // 2. Acceso Total
            else
            {
                lcNivelUsuarioCarpetas = "," + DB.SQLNvl("cu.nivel", "0") + " AS nivel "; // 1 Solo lectura, 2 Total , 0 Sin Registro Denegado
                lcLeftNivelCarpetas = "LEFT JOIN " + DB.SQLDatabase("GESTDOC", "CARP_USER") + " cu ON c.id = cu.idcarpeta AND cu.usuario = " + DB.SQLString(tcUsuario);
            }

            lcSql = "SELECT c.id, c.nombre, c.parent AS id_parent, c.modified, c.created, " + DB.SQLTrue() + " AS carpeta, " + DB.SQLFalse() + " AS orphan " + lcNivelUsuarioCarpetas +
                    " FROM " + DB.SQLDatabase("GESTDOC", "CARPETAS") + " c " + lcLeftNivelCarpetas;

            if (teTipoCarpetasDocumentos == eTipoConsultaCarpetasDocumentos.Nivel) // Consultamos únicamente la carpetas del parent que nos llega
            {
                if (tlFilterId)
                    lcSql += " WHERE c.id = " + DB.SQLString(tnIdParentCarpeta); // Consultaremos la carpeta actual
                else
                {
                    // Si filtramos por la carpeta documentos ---> ID == 1. ha de presentar las carpetas huerfanas
                    if (!tlOrphan)
                        lcSql += " WHERE c.parent = " + DB.SQLString(tnIdParentCarpeta); // Únicamente las carpetas del primer nivel, sin posibilidad de añadir nuevos documentos
                }
            }

            lcSql += " ORDER BY c.parent, c.nombre"; // Ordenamos las carpetas 

            llOk = DB.SQLExec(lcSql, ref tdtCarpetas); // Consultamos las carpetas

            return llOk;
        }

        public static bool _Documentos(ref DataTable tdtDocumentos, eTipoConsultaCarpetasDocumentos teTipoCarpetasDocumentos, int tnIdParent, string tcUsuario, bool tlDelete)
        {
            string lcSql, lcFields, lcLeft = "";
            bool llOk = true;
            DataTable ldtDocumentos = new DataTable();

            if (tcUsuario == "SUPERVISOR")
                lcFields = ", 2 AS nivel ";  // 2. Acceso Total
            else
            {
                lcFields = "," + DB.SQLNvl("du.nivel", "0") + " AS nivel "; // 1 Solo lectura, 2 Total , 0 Sin Registro Denegado
                lcLeft = "LEFT JOIN " + DB.SQLDatabase("GESTDOC", "DOC_USER") + " du ON c.id = du.iddoc AND du.usuario = " + DB.SQLString(tcUsuario);
            }

            lcSql = "SELECT c.id, c.nom_doc AS nombre, c.extension, c.carpeta as id_parent, c.modified, c.created, " + DB.SQLFalse() + " AS carpeta," + DB.SQLFalse() + " AS orphan, " + 
                    " de.ejercicio, d.useract " + lcFields +
                    " FROM " + DB.SQLDatabase("GESTDOC", "DOCUMENT_C") + " c" +
                    " LEFT JOIN " + DB.SQLDatabase("GESTDOC", "DOCUMENT_D") + " d ON c.id = d.iddoc AND c.version = d.version "+
                    " LEFT JOIN " + DB.SQLDatabase("GESTDOC", "DOC_ENLACE") + " de ON c.id = de.iddoc "+ // AND (de.ejercicio = " + DB.SQLString(lcAny) + " OR de.ejercicio = 0) " +
                    lcLeft;

            if (teTipoCarpetasDocumentos == eTipoConsultaCarpetasDocumentos.Nivel) // Únicamente me interesan los documento de la carpeta que tenemos en el Id de la carpeta parent
                lcSql += " WHERE c.carpeta = " + DB.SQLString(tnIdParent);

            lcSql += " ORDER BY c.carpeta, c.nom_doc"; // Ordenamos los documentos 
                
            llOk = DB.SQLExec(lcSql, ref ldtDocumentos); // Consultamos los documentos
            
            if (llOk)
            {
                if (ldtDocumentos.Rows.Count > 0)
                {
                    List<Int16> lstEjercicios = new List<Int16>() { 0, Convert.ToInt16(Convert.ToString(EW_GLOBAL._GetVariable("wc_any"))) };
                    tdtDocumentos = ldtDocumentos.AsEnumerable().Where(row => (row["ejercicio"] == DBNull.Value) || lstEjercicios.Contains(Convert.ToInt16(row["ejercicio"]))).__CopyToDataTable();  // Excluimos los documentos de otros ejercicios

                    if (tdtDocumentos.Rows.Count == 0) // Si no tenemos registros la función "__CopyToDataTable" no clona la estructura del datatable
                        tdtDocumentos = ldtDocumentos.Clone();
                }
                else
                    tdtDocumentos = ldtDocumentos.Copy();

                FUNCTIONS._DisposeDatatable(ldtDocumentos);
            }

            return llOk;
        }

        public static void _ChildrenCarpetasDocumentos(eTipoConsultaCarpetasDocumentos teTipoCarpetasDocumentos, int tnId_Parent, int tnNivel, ref DataTable tdtCarpetasDocs, ref DataTable tdtCarpetas, ref DataTable tdtDocumentos, bool tlOrphan = false)
        {
            if ((tlOrphan && tnId_Parent == 1) || (!tlOrphan))
            {
                _ChildrenDocumentos(tnId_Parent, tnNivel, ref tdtCarpetasDocs, ref tdtDocumentos);  // Consultamos los documentos de la carpeta actual y los agregamos
            }

            DataRow[] ldrCarpetas = tdtCarpetas.Select("id_parent = " + Convert.ToString(tnId_Parent).Trim(), "nombre");  // Consultamos todas las carpetas con el parent que le pasamos. Ordenamos las carpetas por nombre

            if (ldrCarpetas != null && ldrCarpetas.Count() > 0)
            {
                int lnNivel;
                int lnParent = tnId_Parent;
                bool llAcceso;

                foreach (DataRow ldrCarpeta in ldrCarpetas)
                {
                    llAcceso = (Convert.ToInt32(ldrCarpeta["nivel"]) > 0);

                    if (llAcceso && tnNivel == 0) // Si no tenemos acceso en la carpeta padre y tenemos acceso en la carpeta actual es un registro que lo tenemos de marcar como huérfana
                        ldrCarpeta["orphan"] = true;

                    tdtCarpetasDocs.ImportRow(ldrCarpeta); // Añadimos el registro de la carpeta

                    if (teTipoCarpetasDocumentos == eTipoConsultaCarpetasDocumentos.TodosNiveles || tlOrphan) // Si añadimos todo (documentos y carpetas) o estamos borrando un carpeta, ha de añadir los documentos y las carpetas hijas. Si ha de presentar los huérfanos
                    {
                        lnParent = Convert.ToInt32(ldrCarpeta["id"]);
                        lnNivel = Convert.ToInt32(ldrCarpeta["nivel"]);
                        _ChildrenCarpetasDocumentos(teTipoCarpetasDocumentos, lnParent, lnNivel, ref tdtCarpetasDocs, ref tdtCarpetas, ref tdtDocumentos, tlOrphan: tlOrphan); // Buscaremos si la carpeta actual tiene carpetas hijas con el ID actual
                    }
                }
            }
        }

        public static void _ChildrenDocumentos(int tnParentCarpeta, int tnNivel, ref DataTable tdtCarpetasDocs, ref DataTable tdtDocumentos)
        {
            DataRow[] ldrDocumentos = tdtDocumentos.Select("id_parent = " + Convert.ToString(tnParentCarpeta).Trim(), "nombre"); // Consultamos todos las documentos con el parent de la carpeta. Ordenamos los documentos por nombre

            if (ldrDocumentos != null && ldrDocumentos.Count() > 0)
            {
                bool llAcceso;
                string lcExtension;
                int lnRegDocumento;

                foreach (DataRow ldrDocumento in ldrDocumentos)
                {
                    llAcceso = (Convert.ToInt32(ldrDocumento["nivel"]) > 0);

                    if (llAcceso && tnNivel == 0) // Si no tenemos acceso en la carpeta padre y tenemos acceso al documento actual es un registro que lo tenemos de marcar como huérfano
                        ldrDocumento["orphan"] = true;

                    lcExtension = Convert.ToString(ldrDocumento["extension"]).Trim();

                    tdtCarpetasDocs.ImportRow(ldrDocumento); // Añadimos el documento 

                    FileExensionDocumento loFileExensionDocumento = _FileExtensionDocumento(lcExtension);

                    if (loFileExensionDocumento != null)
                    {
                        lnRegDocumento = tdtCarpetasDocs.Rows.Count - 1;

                        tdtCarpetasDocs.Rows[lnRegDocumento]["description"] = ""; // TODO: loFileExensionDocumento._Description;
                        tdtCarpetasDocs.Rows[lnRegDocumento]["IconSmall"] = loFileExensionDocumento._IconSmall;
                        tdtCarpetasDocs.Rows[lnRegDocumento]["IconLarge"] = loFileExensionDocumento._IconLarge;
                        tdtCarpetasDocs.Rows[lnRegDocumento]["IconSmallEdition"] = loFileExensionDocumento._IconSmallEdition;
                        tdtCarpetasDocs.Rows[lnRegDocumento]["IconLargeEdition"] = loFileExensionDocumento._IconLargeEdition;
                        tdtCarpetasDocs.Rows[lnRegDocumento]["IconSmallEditionByOtherUser"] = loFileExensionDocumento._IconSmallEditionByOtherUser;
                        tdtCarpetasDocs.Rows[lnRegDocumento]["IconLargeEditionByOtherUser"] = loFileExensionDocumento._IconLargeEditionByOtherUser;
                    }
                }
            }
        }

        public static FileExensionDocumento _FileExtensionDocumento(string tcExtension)
        {
            bool llExist = false;
            object loObjet = sage.ew.global.EW_GLOBAL._GetVariable("wo_FileExensionDocumentoGestdoc");
            string lcExtension = tcExtension.ToLower();

            FileExensionDocumento loFileExensionDocumento = null;
            Dictionary<string, FileExensionDocumento> dictFileExtension = null;

            if (loObjet != null)
            {
                dictFileExtension = (Dictionary<string, FileExensionDocumento>)loObjet;
                if (dictFileExtension.ContainsKey(lcExtension))
                    llExist = dictFileExtension.TryGetValue(lcExtension, out loFileExensionDocumento);

            }
            else
            {
                EW_GLOBAL.ValorEnClave_VarGlob("wo_FileExensionDocumentoGestdoc", new Dictionary<string, FileExensionDocumento>());

                loObjet = sage.ew.global.EW_GLOBAL._GetVariable("wo_FileExensionDocumentoGestdoc");
                llExist = false;
            }

            if (!llExist)
            {
                loFileExensionDocumento = new FileExensionDocumento();
                loFileExensionDocumento._Extension = lcExtension;
                loFileExensionDocumento._Description = _DescriptionExtension(lcExtension);
                try
                {
                    loFileExensionDocumento._IconSmall = _IconForExtension(lcExtension, eIconSize.Small);
                    loFileExensionDocumento._IconLarge = _IconForExtension(lcExtension, eIconSize.Large);
                    loFileExensionDocumento._IconSmallEdition = _IconOverlay(loFileExensionDocumento._IconSmall, sage.ew.images.Properties.Resources.Edition16x16);
                    loFileExensionDocumento._IconLargeEdition = _IconOverlay(loFileExensionDocumento._IconLarge, sage.ew.images.Properties.Resources.Edition32x32);
                    loFileExensionDocumento._IconSmallEditionByOtherUser = _IconOverlay(loFileExensionDocumento._IconSmall, sage.ew.images.Properties.Resources.EditionByOtherUser16x16);
                    loFileExensionDocumento._IconLargeEditionByOtherUser = _IconOverlay(loFileExensionDocumento._IconLarge, sage.ew.images.Properties.Resources.EditionByOtherUser32x32);

                }
                catch (Exception loEx)
                {
                    DB.Registrar_Error(loEx);
                }


                if (dictFileExtension == null)
                    dictFileExtension = (Dictionary<string, FileExensionDocumento>)loObjet;

                dictFileExtension.Add(lcExtension, loFileExensionDocumento);
            }

            return loFileExensionDocumento;
        }

        public static RegistryKey _RegistryKeyDefaultIcon(RegistryKey keyForClass)
        {
            RegistryKey keyForCLSID = keyForClass.OpenSubKey("CLSID");
            if (keyForCLSID == null) return null;

            string clsid = "CLSID\\" + Convert.ToString(keyForCLSID.GetValue(null)) + "\\DefaultIcon";
            RegistryKey keyForIcon = Registry.ClassesRoot.OpenSubKey(clsid);
            if (keyForIcon == null)
                return null;

            return keyForIcon;
        }

        public static RegistryKey _RegistryKeyDefaultOpenWithProdids(RegistryKey keyForExt)
        {
            RegistryKey keyOpenWithProgids = keyForExt.OpenSubKey("OpenWithProgids"); 

            if (keyOpenWithProgids != null)
            {
                RegistryKey keyForIcon = null;
                string lcTipo;

                string[] valueNames = keyOpenWithProgids.GetValueNames();
                foreach (string valueName in valueNames)
                {
                    RegistryKey keyForExtName = Registry.ClassesRoot.OpenSubKey(valueName);

                    if (keyForExtName != null)
                    {
                        keyForIcon = keyForExtName.OpenSubKey("DefaultIcon");
                        if (keyForIcon != null)
                        {
                            lcTipo = Convert.ToString(keyForExtName.GetValue(null)); // MP4 Video ...
                            if (lcTipo != null && !string.IsNullOrWhiteSpace(lcTipo))
                                return keyForIcon;
                        }
                    }
                }
            }

            return null;
        }

        public static string Extension_GetExePath(string strExtension)
        {
            //We need a leading dot, so add it if it's missing.
            if (!strExtension.StartsWith(".")) strExtension = "." + strExtension;

            //Get the class-name associated with the passed extension
            Microsoft.Win32.RegistryKey rkClassName
               = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(strExtension);
            //Exit, if not found
            if (rkClassName == null) return string.Empty;
            string strClassName = rkClassName.GetValue("").ToString();

            //Get the shell-command for the retrieved executable 
            //This key is found at HKCR\[ClassName]\shell\open\command\(Default)
            //One or more of the paths may be missing, so each of them is being tested
            //separately.
            Microsoft.Win32.RegistryKey rkShellCommandRoot
               = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(strClassName);
            if (rkShellCommandRoot == null) return string.Empty;

            Microsoft.Win32.RegistryKey rkShell
               = rkShellCommandRoot.OpenSubKey("shell");
            if (rkShell == null) return string.Empty;

            Microsoft.Win32.RegistryKey rkOpen
               = rkShell.OpenSubKey("open");
            if (rkOpen == null) return string.Empty;

            Microsoft.Win32.RegistryKey rkCommand
               = rkOpen.OpenSubKey("command");
            if (rkCommand == null) return string.Empty;

            string strShellCommand = rkCommand.GetValue("").ToString();

            //The shell-command may contain additional parameters and may be wrapped in double quotes,
            //so parse out the exe-path.
            string strExePath;
            if (strShellCommand.StartsWith(@""""))
                //Extract path (wrapped in double-quotes)
                strExePath = strShellCommand.Split('"')[1];
            else
                //Extract first word (until first space char)
                strExePath = strShellCommand.Split(' ')[0];

            return strExePath;
        }

        public static Icon _IconForExtension(string tcExtension, eIconSize toeIconSize = eIconSize.Large)
        {
            tcExtension = tcExtension.ToLower().Trim();

            string lcKeyExtension = tcExtension.Trim();

            if (string.IsNullOrWhiteSpace(lcKeyExtension))
                return _IconForExtension("txt", toeIconSize);

            lcKeyExtension = "." + lcKeyExtension.ToLower();

            RegistryKey keyForExt = Registry.ClassesRoot.OpenSubKey(lcKeyExtension);
            if (keyForExt == null && tcExtension != "txt")
                return _IconForExtension("txt", toeIconSize);

            string className = Convert.ToString(keyForExt.GetValue(null));
            RegistryKey keyForClass = Registry.ClassesRoot.OpenSubKey(className);
            if (keyForClass == null && tcExtension != "txt")
                return _IconForExtension("txt", toeIconSize);

            RegistryKey keyForIcon = keyForClass.OpenSubKey("DefaultIcon");

            if (keyForIcon == null)
            {
                RegistryKey keyForClassDefaultIcon = _RegistryKeyDefaultIcon(keyForClass);

                if (keyForClassDefaultIcon == null)
                {
                    RegistryKey keyOpenWithProgids = _RegistryKeyDefaultOpenWithProdids(keyForExt);
                    if (keyOpenWithProgids != null)
                        keyForIcon = keyOpenWithProgids;

                    if (keyForIcon == null && tcExtension != "txt")
                        return _IconForExtension("txt", toeIconSize);
                }
                else
                    keyForIcon = keyForClassDefaultIcon;
            }

            string[] defaultIcon = null;

            try
            {
                defaultIcon = Convert.ToString(keyForIcon.GetValue(null)).Split(',');
            }
            catch (Exception) // De momento no es necesario gestionar nada
            {
            }

            if (defaultIcon == null)
            {
                Icon loIcon = IconForExtensionResources(tcExtension, toeIconSize);

                if (loIcon == null && tcExtension != "txt")
                    loIcon = IconForExtensionResources("txt", toeIconSize);

                return loIcon;
            }

            if (defaultIcon.Count() <= 1) // Si solo hay un icono, puede que no sea válido
            {
                RegistryKey keyForIconDef = _RegistryKeyDefaultIcon(keyForClass);

                if (keyForIconDef != null)
                {
                    keyForIcon = keyForIconDef;
                    defaultIcon = Convert.ToString(keyForIcon.GetValue(null)).Split(',');
                }
            }

            return ExtractIcon(tcExtension, toeIconSize, defaultIcon);
        }

        private static Icon ExtractIcon(string tcExtension, eIconSize toeIconSize, string[] toKeyDefaultIcon)
        {
            Icon loIcon = null;
            int index = (toKeyDefaultIcon.Length > 1) ? Int32.Parse(toKeyDefaultIcon[1]) : 0;
            int lnRead = 0;
            IntPtr[] hDummy = new IntPtr[1] { IntPtr.Zero };
            IntPtr[] hIconEx = new IntPtr[1] { IntPtr.Zero };

            try
            {
                if (toeIconSize == eIconSize.Large)
                    lnRead = ExtractIconEx(toKeyDefaultIcon[0], index, hIconEx, hDummy, 1);
                else
                    lnRead = ExtractIconEx(toKeyDefaultIcon[0], index, hDummy, hIconEx, 1);

                if (lnRead > 0 && hIconEx[0] != IntPtr.Zero)
                    loIcon = (Icon)Icon.FromHandle(hIconEx[0]).Clone(); // Obtenemos el primer icono extraido
            }
            catch (Exception)
            {
                // De momento no es necesario gestionar nada
            }
            finally
            {
                foreach (IntPtr ptr in hIconEx)
                    if (ptr != IntPtr.Zero)
                        DestroyIcon(ptr);

                foreach (IntPtr ptr in hDummy)
                    if (ptr != IntPtr.Zero)
                        DestroyIcon(ptr);
            }

            if (loIcon == null && tcExtension != "txt") // Si no encuentra el icono presentamos la imagen del txt
                loIcon = _IconForExtension("txt", toeIconSize);

            if (loIcon == null) // Si por el motivo que sea no puede extraer el icono vamos a utilizar los que tenemos en el resources
                IconForExtensionResources(tcExtension, toeIconSize);

            return loIcon;
        }

        private static Icon IconForExtensionResources(string tcExtension, eIconSize toeIconSize = eIconSize.Large)
        {
            Icon loIcon = null;

            switch (tcExtension)
            {
                case "pdf":
                    if (toeIconSize == eIconSize.Large)
                        loIcon = Properties.Resources.icon_pdf_32;
                    else
                        loIcon = Properties.Resources.icon_pdf_16;
                    break;

                case "doc":
                case "docx":
                    if (toeIconSize == eIconSize.Large)
                        loIcon = Properties.Resources.icon_docx_32;
                    else
                        loIcon = Properties.Resources.icon_docx_16;
                    break;

                case "xls":
                case "xlsx":
                    if (toeIconSize == eIconSize.Large)
                        loIcon = Properties.Resources.icon_xls_32;
                    else
                        loIcon = Properties.Resources.icon_xls_16;
                    break;

                default:
                    if (toeIconSize == eIconSize.Large)
                        loIcon = Properties.Resources.icon_txt_32;
                    else
                        loIcon = Properties.Resources.icon_txt_16;

                    break;
            }

            return loIcon;
        }

        public static string _ReadDefaultValueSubkey(string tcRegKey)
        {
            using (var lcKey = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(tcRegKey, false))
            {
                if (lcKey != null)
                    return lcKey.GetValue("") as string;
            }
            return null;
        }

        public static Icon _IconOverlay(Icon toIconBackGround, Image toImageOverlay) 
        {
            if (toIconBackGround != null)
            {
                if (toImageOverlay == null)
                    return toIconBackGround;

                Image imageOriginal = toIconBackGround.ToBitmap();
                int lnHeight = toIconBackGround.Height;
                int lnWidth = toIconBackGround.Size.Width;
                int lnDif;

                if (lnHeight > 16)
                    lnDif = lnHeight / 12;
                else
                    lnDif = lnHeight / 6;

                imageOriginal = (Image)(new Bitmap(imageOriginal, new Size(lnWidth - lnDif, lnHeight - lnDif)));

                Bitmap bitmap = new Bitmap(lnWidth, lnWidth);
                Graphics canvas = Graphics.FromImage(bitmap);
                canvas.DrawImage(imageOriginal, new Point(lnDif, lnDif));
                canvas.DrawImage(toImageOverlay, new Point(0, 0));
                canvas.Save();

                return Icon.FromHandle(bitmap.GetHicon());
            }

            return null;
        }

        public static string _DescriptionExtension(string tcExtension)
        {
            string lcExtension = tcExtension.ToLower().Trim();

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

            if (lcExtension.StartsWith(".") && lcExtension.Length > 1)
                lcExtension = lcExtension.Substring(1);

            string lcDescription = _ReadDefaultValueSubkey(lcExtension + "file");
            if (!String.IsNullOrEmpty(lcDescription))
                return lcDescription;

            using (var lcKey = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey("." + lcExtension, false))
            {
                if (lcKey == null)
                    return "";
                
                try
                {
                    string lcProgId = lcKey.GetValue("").ToString();

                    using (var lcSubkey = lcKey.OpenSubKey("OpenWithProgids"))
                    {
                        if (lcSubkey == null)
                            return "";

                        var lcNames = lcSubkey.GetValueNames();
                        if (lcNames == null || lcNames.Length == 0)
                            return "";

                        foreach (var lcName in lcNames)
                        {
                            lcDescription = _ReadDefaultValueSubkey(lcName);
                            if (!String.IsNullOrEmpty(lcDescription))
                                return lcDescription;
                        }
                    }

                }
                catch (Exception)
                {
                }
            }

            return "";
        }

        public static int _EnlaceTabla(string tcDataBase, string tcTabla)
        {
            if (string.IsNullOrWhiteSpace(tcDataBase) || string.IsNullOrWhiteSpace(tcTabla))
                return 0;

            int lnId = 0;
            string lcSql;
            bool llOk = true;
            DataTable ldtEnlaces = new DataTable();

            lcSql = "SELECT ID, LIBRERIA, CLASE " +
                    " FROM " + DB.SQLDatabase("GESTDOC", "ENLACES") +
                    " WHERE DB = " + DB.SQLString(tcDataBase) +
                    " AND TABLA = " + DB.SQLString(tcTabla);
            llOk = DB.SQLExec(lcSql, ref ldtEnlaces);

            if (llOk && ldtEnlaces != null && ldtEnlaces.Rows.Count > 0 && (Convert.ToInt32(ldtEnlaces.Rows[0]["id"]) > 0))
                lnId = Convert.ToInt32(ldtEnlaces.Rows[0]["id"]);

            return lnId;
        }

        public static int _Enlace(IGestionDocumental toEnlace, string tcLibreria, string tcClase, string tcCarpeta)
        {
            if (string.IsNullOrWhiteSpace(tcLibreria) || string.IsNullOrWhiteSpace(tcClase))
                return 0;

            int lnId = 0;
            string lcSql;
            bool llOk = true;
            DataTable ldtEnlaces = new DataTable();

            lcSql = "SELECT ID, LIBRERIA, CLASE " +
                    " FROM " + DB.SQLDatabase("GESTDOC", "ENLACES") +
                    " WHERE LIBRERIA = " + DB.SQLString(tcLibreria) +
                    " AND CLASE = " + DB.SQLString(tcClase);
            llOk = DB.SQLExec(lcSql, ref ldtEnlaces);

            if (llOk && ldtEnlaces != null && ldtEnlaces.Rows.Count > 0 && (Convert.ToInt32(ldtEnlaces.Rows[0]["id"]) > 0))
                lnId = Convert.ToInt32(ldtEnlaces.Rows[0]["id"]);
            else
            {
                DataTable ldtMaxId = new DataTable();
                lcSql = "SELECT MAX(id) AS maxim FROM " + DB.SQLDatabase("GESTDOC", "ENLACES");
                DB.SQLExec(lcSql, ref ldtMaxId);

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

                lcSql = "INSERT INTO " + DB.SQLDatabase("GESTDOC", "ENLACES") +
                        " (ID, LIBRERIA, CLASE, CARPETA, DB, TABLA)" +
                        " Values(" + DB.SQLString(lnId) + ", " + DB.SQLString(tcLibreria) + ", " + DB.SQLString(tcClase) + ", " + DB.SQLString(tcCarpeta) + ", " + DB.SQLString(toEnlace._DataBase) + ", " + DB.SQLString(toEnlace._Tabla) + ")";
                llOk = DB.SQLExec(lcSql);

                if (!llOk)
                    lnId = 0;
            }

            return lnId;
        }

        public static bool _Sage50Assembly(string tcLibreria)
        {
            List<string> ltsLibrerias = new List<string>() { "sage.ew.empresa", "sage.es.s50.comunicados", "sage.es.s50.fabricacion", "sage.es.S50.fintech", "sage.es.s50.modelos", "sage.es.s50.nuevoejercicio,", "sage.es.s50.s50Update", "sage.ew.articulo", "sage.ew.botones", "sage.ew.cliente", "sage.ew.contabilidad", "sage.ew.docscompra", "sage.ew.docsven", "sage.ew.docventatpv", "sage.ew.ewbase", "sage.ew.formul", "sage.ew.functions", "sage.ew.global", "sage.ew.graficas", "sage.ew.listados", "sage.ew.lote", "sage.ew.o365", "sage.ew.objetos", "sage.ew.perfiles", "sage.ew.sepa", "sage.ew.serie", "sage.ew.stocks", "sage.ew.tpv", "sage.ew.txtbox", "sage.ew.usuario" };

            return ltsLibrerias.Contains(tcLibreria.ToLower());
        }

        public static void _AddColumnDatatable(DataTable tdtDatatable, string tcNameDataColumn, string tcTypeDataColumn)
        {
            DataColumn ldtNewCol = new DataColumn(tcNameDataColumn, Type.GetType(tcTypeDataColumn));
            tdtDatatable.Columns.Add(ldtNewCol);
        }

        public static DataTable _DocumentosEnlace(IGestionDocumental toIGestionDocumental, int tnIdEnlace, string tcValor)
        {
            if (tnIdEnlace == 0 || string.IsNullOrWhiteSpace(tcValor))
                return null;

            DataTable ldtDocumentos = new DataTable();
            string lcSql, lcExtension, lcUsuario, lcInnerAcceso = string.Empty, lcWhere = string.Empty, lcUseract;
            bool llOk = true;

            lcUsuario = Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario"));

            if (lcUsuario != "SUPERVISOR") // Si no somos el Supervisor certificamos que tenemos acceso al documento y a la carpeta
            {
                lcInnerAcceso = " INNER JOIN " + DB.SQLDatabase("GESTDOC", "DOC_USER") + " D_U ON D_U.IDDOC = D.IDDOC AND D_U.USUARIO = " + DB.SQLString(lcUsuario) + " AND D_U.NIVEL >=1 " +
                                " INNER JOIN " + DB.SQLDatabase("GESTDOC", "CARP_USER") + " C_U ON C_U.IDCARPETA = D_C.CARPETA AND C_U.USUARIO = " + DB.SQLString(lcUsuario) + " AND C_U.NIVEL >=1 ";
            }

            lcSql = "SELECT D.ENLACE, D.IDDOC, D.VALOR, D.EJERCICIO, D_C.TITULO, D_C.NOM_DOC, D_C.EXTENSION, D_D.USERACT " +
                    " FROM " + DB.SQLDatabase("GESTDOC", "DOC_ENLACE") + " D " +
                    " INNER JOIN " + DB.SQLDatabase("GESTDOC", "DOCUMENT_C") + " D_C ON D_C.ID = D.IDDOC" +
                    " LEFT JOIN " + DB.SQLDatabase("GESTDOC", "DOCUMENT_D") + " D_D ON D_D.IDDOC = D.IDDOC AND D_C.VERSION = D_D.VERSION " +
                    lcInnerAcceso +
                    " WHERE D.ENLACE = " + DB.SQLString(tnIdEnlace) +
                    " AND D.VALOR = " + DB.SQLString(tcValor);

            if (toIGestionDocumental._GestEjercicio)
                lcSql += " AND D.EJERCICIO = " + Convert.ToString(EW_GLOBAL._GetVariable("wc_any"));

            lcSql += " ORDER BY D_C.TITULO";

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

            if (llOk && ldtDocumentos != null && ldtDocumentos.Rows.Count > 0)
            {
                _AddColumnsIconDocumentos(ldtDocumentos, false);

                foreach (DataRow ldrDocumento in ldtDocumentos.Rows)
                {
                    lcExtension = Convert.ToString(ldrDocumento["extension"]);
                    lcUseract = Convert.ToString(ldrDocumento["useract"]).Trim();
                    FileExensionDocumento loFileExensionDocumento = _FileExtensionDocumento(lcExtension);
                    if (loFileExensionDocumento != null) // Actualmente utilizamos el IconSmall
                    {
                        if (string.IsNullOrWhiteSpace(lcUseract))
                        {
                            ldrDocumento["IconSmall"] = loFileExensionDocumento._IconSmall; 
                            ldrDocumento["IconLarge"] = loFileExensionDocumento._IconLarge;
                        }
                        else
                        {
                            if (lcUseract == lcUsuario)
                            {
                                ldrDocumento["IconSmall"] = loFileExensionDocumento._IconSmallEdition;
                                ldrDocumento["IconLarge"] = loFileExensionDocumento._IconLargeEdition;
                            }
                            else
                            {
                                ldrDocumento["IconSmall"] = loFileExensionDocumento._IconSmallEditionByOtherUser;
                                ldrDocumento["IconLarge"] = loFileExensionDocumento._IconLargeEditionByOtherUser;
                            }
                        }
                    }
                }
            }

            return ldtDocumentos;
        }

        public static string _ValueKeys(IGestionDocumental toEnlace)
        {
            string lcValor = string.Empty;

            if (toEnlace._Keys != null)
            {
                foreach (string lcPropertyName in toEnlace._Keys.Values)
                {
                    object loPropertyValue = _GetReflectionPropertyValue(toEnlace, lcPropertyName);

                    if (loPropertyValue != null)
                    {
                        string lcPropertyValue;

                        if (loPropertyValue.GetType() == typeof(DateTime))
                            lcPropertyValue = ((DateTime)loPropertyValue).ToString(EW_GLOBAL._CustomFormatDate); // De momento guardaremos la fecha en formato corto
                        else
                            lcPropertyValue = loPropertyValue.ToString();

                        if (!string.IsNullOrWhiteSpace(lcValor))
                            lcValor += "|";

                        lcValor += lcPropertyValue;
                    }
                }
            }

            return lcValor;
        }

        public static object _GetReflectionPropertyValue(object toObjeto, string tcPropertyName)
        {
            if (toObjeto == null)
                return null;

            PropertyInfo loPropertyInfo = null;
            object loObjeto = toObjeto;
            string lcPropertyName;

            if (tcPropertyName.Contains("."))
            {
                string[] lstPropertyNames = tcPropertyName.Split('.'); // Si tenemos "_Cabecera._Proveedor"

                if (lstPropertyNames.Count() == 2) // De momento este es el nivel máximo permitido
                {
                    string lclcPropertyNameParent = lstPropertyNames[0];
                    object loPropertyValueParent = _GetReflectionPropertyValue(toObjeto, lclcPropertyNameParent); // Instancia de "_Cabecera"

                    if (loPropertyValueParent == null)
                        return null;
                    else
                    {
                        loObjeto = loPropertyValueParent;
                        lcPropertyName = lstPropertyNames[1];
                    }
                }
                else
                    return null;
            }
            else
                lcPropertyName = tcPropertyName;

            try
            {
                loPropertyInfo = loObjeto.GetType().GetProperty(lcPropertyName);
            }
            catch (Exception)
            {
            }

            if (loPropertyInfo == null)
                return null;
 
            return loPropertyInfo.GetValue(loObjeto, null);
        }

        public static bool _SetReflectionPropertyValues(object toObjeto, string tcValues)
        {
            bool llOk = (toObjeto is IGestionDocumental);
            if (llOk)
            {
                string[] lstValores = tcValues.Split('|');
                IGestionDocumental loIGestionDocumental = (IGestionDocumental)toObjeto;
                int lnIndice = 0;
                string lcPropertyName;
                object loValue;

                if (loIGestionDocumental._Keys.Count == lstValores.Count()) // Certificamos que coincide
                {
                    foreach (KeyValuePair<string, string> kvpGestion in loIGestionDocumental._Keys)
                    {
                        lcPropertyName = kvpGestion.Value;
                        loValue = lstValores[lnIndice];
                        lnIndice++;

                        ReflectionPropertyValue(loIGestionDocumental, ref lcPropertyName, ref loValue); // Tratamiento especial para asientos ...

                        llOk = FunctionsGestDoc._SetReflectionPropertyValue(loIGestionDocumental, lcPropertyName, loValue);

                        if (!llOk)
                            break;
                    }
                }
            }

            return llOk;
        }

        private static void ReflectionPropertyValue(IGestionDocumental toIGestionDocumental, ref string tcPropertyName, ref object toValue)
        {
            bool llAsientos = (toIGestionDocumental is IAsientos);

            if (llAsientos && tcPropertyName == "_Guid") // Tratamiento especial para asientos, tenemos guardado el GUID 
            {
                int lnAsiento = Convert.ToInt32(DB.SQLValor("ASIENTOS", "EMPRESA='" + ((dynamic)toIGestionDocumental)._Empresa + "' AND GUID", Convert.ToString(toValue), "NUMERO"));

                if (lnAsiento > 0)
                {
                    toValue = Convert.ToString(lnAsiento); // Lo convertimos a string para poder asignarlo por reflection en la función correspondiente
                    tcPropertyName = "_Numero";
                }
            }
        }

        public static bool _SetReflectionPropertyValue(object toObjeto, string tcPropertyName, object toValue)
        {
            bool llOk = false;
            string lcPropertyName = tcPropertyName;
            dynamic loObjeto = (dynamic)toObjeto; // DMD dynamic
            PropertyInfo propertyInfo = null;

            try
            {
                if (tcPropertyName.Contains("."))
                {
                    string[] lstPropertyNames = tcPropertyName.Split('.'); // Si tenemos "_Cabecera._Proveedor"

                    if (lstPropertyNames.Count() == 2) // De momento este es el nivel máximo permitido
                    {
                        string lclcPropertyNameParent = lstPropertyNames[0]; // _Cabecera
                        object loPropertyValueParent = loObjeto.GetType().GetProperty(lclcPropertyNameParent).GetValue(loObjeto); // Instancia de "_Cabecera"

                        if (loPropertyValueParent == null)
                            return false;
                        else
                        {
                            loObjeto = (dynamic)loPropertyValueParent;
                            lcPropertyName = lstPropertyNames[1]; // _ Proveedor
                        }
                    }
                    else
                        return false;
                }

                propertyInfo = loObjeto.GetType().GetProperty(lcPropertyName);
                
                if (propertyInfo != null)
                {
                    Type type = propertyInfo.PropertyType; 
                    object loValue = null;

                    TypeConverter converter = TypeDescriptor.GetConverter(type);
                    if (converter.CanConvertFrom(typeof(string))) 
                        loValue = converter.ConvertFrom(toValue);

                    if (loValue != null)
                        propertyInfo.SetValue(loObjeto, loValue, null);

                    llOk = true;
                }
            }
            catch (Exception)
            {
            }

            return llOk;
        }

        public static bool _DeleteDocumentos(dynamic toDocumento, string tcValueKeys = "")
        {
            bool llOk = true, llDelete = false;

            if (toDocumento is IGestionDocumental)
            {
                IGestionDocumental loIGestionDocumental = (IGestionDocumental)toDocumento;
                int lnIdEnlace = FunctionsGestDoc._EnlaceTabla(loIGestionDocumental._DataBase, loIGestionDocumental._Tabla);
                if (lnIdEnlace > 0)
                {
                    string lcSql, lcValueKeys, lcWhereEjercicio = string.Empty;
                    if (string.IsNullOrWhiteSpace(tcValueKeys))
                        lcValueKeys = FunctionsGestDoc._ValueKeys(loIGestionDocumental);
                    else
                        lcValueKeys = tcValueKeys;
                   
                    if (!string.IsNullOrWhiteSpace(lcValueKeys)) // Buscaremos los diferentes documentos
                    {
                        DataTable ldtDocumentos = new DataTable();

                        if (loIGestionDocumental._GestEjercicio)
                            lcWhereEjercicio = " AND ejercicio = " + DB.SQLString(Convert.ToString(EW_GLOBAL._GetVariable("wc_any")));

                        lcSql = "SELECT iddoc FROM " + DB.SQLDatabase("GESTDOC", "DOC_ENLACE") +
                                " WHERE enlace = " + DB.SQLString(lnIdEnlace) + " AND valor = " + DB.SQLString(lcValueKeys) +
                                lcWhereEjercicio;
                        llOk = DB.SQLExec(lcSql, ref ldtDocumentos);

                        if (llOk && ldtDocumentos != null && ldtDocumentos.Rows.Count > 0 && (Convert.ToInt32(ldtDocumentos.Rows[0]["iddoc"]) > 0))
                        {
                            int lnIdDoc;
                            foreach (DataRow ldrDocumento in ldtDocumentos.Rows) // Borraremos los diferentes documentos de la gestión documental
                            {
                                lnIdDoc = Convert.ToInt32(ldrDocumento["iddoc"]);
                                IDocumento loDocumento = new Documento(lnIdDoc);
                                if (loDocumento._Id > 0)
                                {
                                    llDelete = loDocumento._Delete();
                                    llOk = llOk && llDelete; // TODO: Si falla el borrado de algun documento, al menos se ha de avisar
                                }
                            }
                        }
                    }
                }
            }

            return llOk;
        }

        public static eTipoDocumentoGestDoc _TipoDocumento(dynamic toDocumento)
        {
            eTipoDocumentoGestDoc loeTipoDocumentoGestDoc = eTipoDocumentoGestDoc.Otro;

            if (toDocumento is StockAlbRegulari || toDocumento is StockAlbTraspaso || toDocumento is StockINI || toDocumento is StockInventario)
                loeTipoDocumentoGestDoc = eTipoDocumentoGestDoc.Stock;
            else if (toDocumento is ewMante)
                 loeTipoDocumentoGestDoc = eTipoDocumentoGestDoc.Mante;
            else if (toDocumento is IAsientos)
                 loeTipoDocumentoGestDoc = eTipoDocumentoGestDoc.Asiento;
            else if (toDocumento is ewDocVentaTPV || toDocumento is ewDocVentaPED || toDocumento is ewDocVentaPRESUP || toDocumento is ewDocVentaDEPOSITO || toDocumento is ewDocVentaFRA)
                loeTipoDocumentoGestDoc = eTipoDocumentoGestDoc.Venta;
            else if (toDocumento is ewDocCompraALBARAN || toDocumento is ewDocCompraPEDIDO || toDocumento is ewDocCompraPROPUESTA || toDocumento is ewDocCompraDEPOSITO)
                loeTipoDocumentoGestDoc = eTipoDocumentoGestDoc.Compra;
            else if (toDocumento is ewDocCompraFACTURA)
                loeTipoDocumentoGestDoc = eTipoDocumentoGestDoc.FacturaCompra;

            return loeTipoDocumentoGestDoc;
        }

        public static int _NumArchivosYCarpetas(string tcPath)
        {
            if (!Directory.Exists(tcPath))
                return 0;

            int lnFicheros = Directory.GetFiles(tcPath, "*.*", SearchOption.AllDirectories).Count();
            // TODO, esto de aqui abajo parece que no va bien, cuenta carpetas donde no las hay
            int lnCarpetas = Directory.GetDirectories(tcPath, "*", SearchOption.AllDirectories).Count();
            int lnNumeroTotal = (lnFicheros + lnCarpetas);

            lnNumeroTotal = lnNumeroTotal < 0 ? 0 : lnNumeroTotal;

            return lnNumeroTotal;
        }

        public static string _TamanyoDocumentoFormateado(decimal tnBytes)
        {
            double lnBytesPorKB = 1024;
            double lnBytesDocumento = Convert.ToDouble(tnBytes);
            string lcCadenaTamanyo = "";

            if (tnBytes < 1024)
                lcCadenaTamanyo = String.Format("{0:n0}", lnBytesDocumento) + " bytes";
            else
            {
                if (tnBytes >= 1024 && tnBytes < 1048576)
                {
                    lcCadenaTamanyo = String.Format("{0:n0}", Math.Ceiling(lnBytesDocumento / lnBytesPorKB)) + " KB";
                }
                else
                {
                    if (tnBytes >= 1048576 && tnBytes < 1073741824)
                    {
                        lcCadenaTamanyo = String.Format("{0:n1}", lnBytesDocumento / Math.Pow(lnBytesPorKB, 2)) + " MB";
                    }
                    else
                    {
                        if (tnBytes >= 1073741824 && tnBytes < 1099511627776)
                        {
                            lcCadenaTamanyo = String.Format("{0:n1}", lnBytesDocumento / Math.Pow(lnBytesPorKB, 3)) + " GB";
                        }
                        else
                        {
                            if (tnBytes >= 1099511627776)
                            {
                                lcCadenaTamanyo = String.Format("{0:n2}", lnBytesDocumento / Math.Pow(lnBytesPorKB, 4)) + " TB";
                            }
                        }

                    }
                }
            }

            return lcCadenaTamanyo;
        }

        public static string _DirectorioGestDoc(string tcCarpeta = "")
        {
            string lcPath = Convert.ToString(EW_GLOBAL._GetVariable("wc_iniservidor")).ToString().Trim();

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

            lcPath = Path.Combine(lcPath, "Modulos");
            lcPath = Path.Combine(lcPath, "GestDoc");

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

            return lcPath;
        }

        public static string _DirectorySeparatorChar(string tcPath)
        {
            string lcDirectoryName = tcPath;

            if (lcDirectoryName.EndsWith("\\") == false)
                lcDirectoryName += Path.DirectorySeparatorChar;

            return lcDirectoryName;
        }

        public static string _DirectorioSincro()
        {
            return Path.Combine(FunctionsGestDoc._DirectorioGestDoc("Sincro"), "Docs" + FUNCTIONS._Grupo_Actual());
        }

        public static void _SincronizarGestDocUnload()
        {
            object loObjet = sage.ew.global.EW_GLOBAL._GetVariable("wo_Sincroniza_GestDoc");

            if (loObjet != null)
            {
                Sincroniza_GestDoc loSincroniza_GestDoc = (Sincroniza_GestDoc)loObjet;
                loSincroniza_GestDoc._Unload();
            }
        }

        public static Sincroniza_GestDoc _SincronizarGestDoc(TipoConexion toTipoConexionServicio)
        {
            bool llNew = false;
            // Únicamente me interesa tener una instancia de la clase de gestión documental
            object loObjet = sage.ew.global.EW_GLOBAL._GetVariable("wo_Sincroniza_GestDoc");

            Sincroniza_GestDoc loSincroniza_GestDoc = null;

            if (loObjet == null)
                llNew = true;
            else
            {
                loSincroniza_GestDoc = (Sincroniza_GestDoc)loObjet;

                if (loSincroniza_GestDoc._TipoConexionServicio != toTipoConexionServicio || (loSincroniza_GestDoc._Grupo != FUNCTIONS._Grupo_Actual())) // Si cambiamos de grupo o de tipo de conexión, descargamos
                {
                    llNew = true;
                    loSincroniza_GestDoc._Unload();
                }
            }

            if (llNew)
            {
                loSincroniza_GestDoc = new Sincroniza_GestDoc(toTipoConexionServicio);
                EW_GLOBAL.ValorEnClave_VarGlob("wo_Sincroniza_GestDoc", loSincroniza_GestDoc);
            }

            return loSincroniza_GestDoc;
        }

        public static void _SincronizarDocumento(eSincronizacionGestDoc teSincronizacionGestDoc, string tcRutaDocsOneDrive, TipoConexion toTipoConexionServicio,  int tnId, string tcGuid, string tcFileName, string tcOldName, string tcFilePathUpload, string tcPathSincronizacion)
        {
            Sincroniza_GestDoc loSincroniza_GestDoc = _SincronizarGestDoc(toTipoConexionServicio);

            if (loSincroniza_GestDoc != null)
                loSincroniza_GestDoc._SincronizarDocumento(teSincronizacionGestDoc, tcRutaDocsOneDrive, tnId, tcGuid, tcFileName, tcOldName, tcFilePathUpload, tcPathSincronizacion);
        }

        public static void _SincronizarCarpeta(eSincronizacionGestDoc teSincronizacionGestDoc, string tcRutaDocsOneDrive, TipoConexion toTipoConexionServicio, int tnId, string tcGuid, string tcPath, string tcPathSincro, string tcPathSincronizacion = "")
        {
            Sincroniza_GestDoc loSincroniza_GestDoc = _SincronizarGestDoc(toTipoConexionServicio);

            if (loSincroniza_GestDoc != null)
                loSincroniza_GestDoc._SincronizarCarpeta(teSincronizacionGestDoc, tcRutaDocsOneDrive, tnId, tcGuid, tcPath, tcPathSincro, tcPathSincronizacion);
        }
    }
}