FileDialog365.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Sage.FileDialog;
using System.Data;
using Sage.DriveManagement.Interfaces;
using System.Windows.Forms;
using Sage.DriveManagement;
using System.IO;
using System.Text.RegularExpressions;
using System.Drawing;
using Sage.O365Management.Classes.OData;
using System.Globalization;
using sage.ew.enumerations;
using sage.ew.interficies;
using sage.ew.db;

namespace sage.ew.o365.Clases
{
    public class FileDialog365 : IFileDialog365
    {
        private O365FileConsumer _oO365Management;
        private OneDriveFileConsumer _oOneDriveManagement;
        private string[] _oAllowedDrives = null;
        private IFileDialogLauncher _oDialog = null;
        private Dictionary<string, string> _oConversion = new Dictionary<string, string>();

        public string _Path { get; set; }

        public string _ErrorMessage { get; set; } = string.Empty;

        public TipoConexion _Tipo { get; set; } = TipoConexion.Todas;

        public TipoOneDrive _TipoOneDrive { get; set; } = TipoOneDrive.Exportacion;

        private string[] _AllowedDrives
        {
            get
            {
               
                DriveInfo[] loDrives = DriveInfo.GetDrives();

                _oAllowedDrives = loDrives.Select(x => x.Name.Contains(":") ? x.Name.Substring(0, x.Name.IndexOf(":")) : x.Name).ToArray();

                loDrives = null;

                if (_Tipo == TipoConexion.Todas)
                {
                    if (_oOneDriveManagement._IsConfigured && _oO365Management._IsConfigured)
                    {
                        _oAllowedDrives = _oAllowedDrives.Union(new string[] { "OD", "SH" }).ToArray();
                    }
                    else if (_oOneDriveManagement._IsConfigured)
                    {
                        _oAllowedDrives = _oAllowedDrives.Union(new string[] { "OD" }).ToArray();
                    }
                    else if (_oO365Management._IsConfigured)
                    {
                        _oAllowedDrives = _oAllowedDrives.Union(new string[] { "SH" }).ToArray();
                    }
                }
                else if (_Tipo == TipoConexion.OneDrive && _oOneDriveManagement._IsConfigured)
                {
                    _oAllowedDrives = _oAllowedDrives.Union(new string[] { "OD"}).ToArray();
                }
                else if (_Tipo == TipoConexion.O365 && _oO365Management._IsConfigured)
                {
                    _oAllowedDrives = _oAllowedDrives.Union(new string[] { "SH" }).ToArray();
                }
                             
                return _oAllowedDrives;
            }
        }

        public IFileDialogLauncher _Dialog
        {
            get
            {
                if (_oDialog == null)
                {
                    _oDialog = new FileDialogLauncher();
                    
                    _InitializeStyles();
                    if (!string.IsNullOrEmpty(_oO365Management._DefaultPath)) _oDialog.Path = _oO365Management._DefaultPath;
                }
                return _oDialog;
            }
        }

        private void _InitializeStyles()
        {
            FileDialogForm loForm = (FileDialogForm)_Dialog.Form;
            loForm.BackColor = Color.FromArgb(250, 250, 250);
            loForm.WindowState = FormWindowState.Maximized;
            loForm.Font = new Font("Segoe UI", 9);
            loForm.WindowState = FormWindowState.Normal;

            loForm.Controls["FoldersDrive"].Font = loForm.Font;
            loForm.Controls["FileViewDrive"].Font = loForm.Font;
            loForm.Controls["TxtAddressBar"].BackColor = loForm.BackColor;

            loForm.MinimumSize = new Size(700, loForm.Height);
        }

        #region Constructores

        public FileDialog365()
        {
            _Load();
        }

        public FileDialog365(TipoOneDrive toTipoOneDrive) 
        {
            _TipoOneDrive = toTipoOneDrive;
            _Load();
        }

        public FileDialog365(TipoConexion toTipoConexion, TipoOneDrive toTipoOneDrive) 
        {
            _Tipo = toTipoConexion;
            _TipoOneDrive = toTipoOneDrive;
            _Load();
        }

        #endregion Constructores

        private void _Load()
        {
            _oO365Management = new O365FileConsumer(_TipoOneDrive);
            _oO365Management._Load();

            _oOneDriveManagement = new OneDriveFileConsumer(_TipoOneDrive);
            _oOneDriveManagement._Load();

            _oConversion.Add("sh:", @"\O365");
            _oConversion.Add( "od:", @"\OneDrive");
        }

        public bool _IsPath(string tcPath)
        {
            bool llOk = false;

            foreach (KeyValuePair<string, string> oValue in _oConversion)
            {
                if (tcPath.StartsWith(oValue.Value)) return true; 
            }

            return llOk;
        }

        public bool _UploadFile(string tcPathOriginal, string tcPathDestination)
        {
            bool llOk = false;

            try
            {
                tcPathDestination = _TransformPathOneDriveToDrive(tcPathDestination);

                //Validamos la conexión de O365 si el destino es O365
                if (tcPathDestination.StartsWith("sh:") && _ValidateConnection(TipoConexion.O365))
                {
                    llOk = true;
                }

                //Validamos la conexión de OneDrive si el destino es OneDrive
                if (tcPathDestination.StartsWith("od:") && _ValidateConnection(TipoConexion.OneDrive))
                {
                    llOk = true;
                    //PE-98984 Quitamos los acentos y las ñ ya que sino falla al subir el fichero
                    tcPathDestination = _CleanStringToUpdate(tcPathDestination);
                }

                if (llOk)
                {
                    FolderFileClientManager _Folder = new FolderFileClientManager
                    {
                        AllowedDrives = _AllowedDrives,
                        Credentials = _GetCredentials()
                    };

                    //Pe: 
                    //tcPathDestination => od:\gestdoc\aaa.JPEG
                    //tcPathOriginal => C:\EUROWINSPRB\STD\EW800SERV\Modulos\GestDoc\Sincro\Docs0008\48.JPEG
                    llOk = _Folder.FileUpload(tcPathDestination, tcPathOriginal);
                }
                 
                return llOk;
            }
            catch (Exception e)
            {
                //PE-103320: Buscamos en la excepción generada el error de no se encuentra el filePath. Si lo encontramos, guardamos en _ErrorMessage un mensaje explícito
                //de que no se puede guardar fichero en la carpeta raíz de Microsoft 365
                if (e.Message.IndexOf("filePath") != -1)
                    _ErrorMessage = "No se puede guardar el fichero en la carpeta raíz de Microsoft 365";
            }
            return false;
        }

        public bool _DownLoadFile(string oneDriveFilePath, string localFilePath)
        {
            bool llOk = false;

            //Tratamiento previo
            try
            {
                //Formateo origen
                oneDriveFilePath = _TransformPathOneDriveToDrive(oneDriveFilePath);

                //Formateo destino
                //Quitamos los acentos y las ñ ya que sino falla al subir el fichero
                localFilePath = _CleanStringToUpdate(localFilePath);

                //Validamos la conexión de O365 si el destino es O365
                if (oneDriveFilePath.StartsWith("sh:") && _ValidateConnection(TipoConexion.O365))
                {
                    llOk = true;
                }

                //Validamos la conexión de OneDrive si el destino es OneDrive
                if (oneDriveFilePath.StartsWith("od:") && _ValidateConnection(TipoConexion.OneDrive))
                {
                    llOk = true;
                }

                if(llOk) //El formato es bueno y tengo conexión
                {
                    if(_FileExist(oneDriveFilePath)) //Verifico que el fichero exista
                    {
                        FolderFileClientManager _Folder = new FolderFileClientManager
                        {
                            AllowedDrives = _AllowedDrives,
                            Credentials = _GetCredentials()
                        };

                        var oneDriveFileName = Path.GetFileName(oneDriveFilePath);
                        var localFileExtension = Path.GetExtension(localFilePath);
                        if (string.IsNullOrWhiteSpace(localFileExtension))
                            localFilePath = Path.Combine(localFilePath, oneDriveFileName); //Le pongo el mismo nombre que en origen

                        var ok = _Folder.FileDownload(oneDriveFilePath, localFilePath);

                        return ok;
                    }
                }
            }
            catch (Exception e)
            {
                _ErrorMessage = "Se ha producido un error al descargar el fichero.";
                DB.Registrar_Error(e);
            }
            return false;
        }

        public bool _DeleteFile(string tcFileName)
        {
            bool llOk = false;

            try
            {
                tcFileName = _TransformPathOneDriveToDrive(tcFileName);

                //Validamos la conexión de O365 si el destino es O365
                if (tcFileName.StartsWith("sh:") && _ValidateConnection(TipoConexion.O365))
                {
                    llOk = true;
                }

                //Validamos la conexión de OneDrive si el destino es OneDrive
                if (tcFileName.StartsWith("od:") && _ValidateConnection(TipoConexion.OneDrive))
                {
                    llOk = true;
                    //PE-98984 Quitamos los acentos y las ñ ya que sino falla al subir el fichero
                    tcFileName = _CleanStringToUpdate(tcFileName);
                }

                if (llOk)
                {
                    FolderFileClientManager _Folder = new FolderFileClientManager
                    {
                        AllowedDrives = _AllowedDrives,
                        Credentials = _GetCredentials()
                    };

                    llOk = _Folder.DeleteFile(tcFileName);
                }

                return llOk;
            }
            catch (Exception e)
            {
                _ErrorMessage = e.Message;
                // revisar el error para poner un mensaje explicito
                //if (e.Message.IndexOf("filePath") != -1)
                //    _ErrorMessage = "No se puede guardar el fichero en la carpeta raíz de Microsoft 365";
            }
            return false;
        }
        public bool _FileExist(String tcFileName)
        {
            Boolean llOk = false;

            try
            {
                tcFileName = _TransformPathOneDriveToDrive(tcFileName);

                //Validamos la conexión de O365 si el destino es O365
                if (tcFileName.StartsWith("sh:") && _ValidateConnection(TipoConexion.O365))
                {
                    llOk = true;
                }

                //Validamos la conexión de OneDrive si el destino es OneDrive
                if (tcFileName.StartsWith("od:") && _ValidateConnection(TipoConexion.OneDrive))
                {
                    llOk = true;
                    //PE-98984 Quitamos los acentos y las ñ ya que sino falla al subir el fichero
                    tcFileName = _CleanStringToUpdate(tcFileName);
                }

                if (llOk)
                {
                    FolderFileClientManager _Folder = new FolderFileClientManager
                    {
                        AllowedDrives = _AllowedDrives,
                        Credentials = _GetCredentials()
                    };

                    llOk = _Folder.FileExists(tcFileName);
                }

                return llOk;
            }
            catch (Exception e)
            {
                _ErrorMessage = e.Message;
                // revisar el error para poner un mensaje explicito
                //if (e.Message.IndexOf("filePath") != -1)
                //    _ErrorMessage = "No se puede guardar el fichero en la carpeta raíz de Microsoft 365";
            }
            return false;
        }

        public bool _CreateFolder(string tcDirectoryPath)
        {
            bool llOk = false;

            try
            {
                tcDirectoryPath = _TransformPathOneDriveToDrive(tcDirectoryPath);

                //Validamos la conexión de O365 si el destino es O365
                if (tcDirectoryPath.StartsWith("sh:") && _ValidateConnection(TipoConexion.O365))
                {
                    llOk = true;
                }

                //Validamos la conexión de OneDrive si el destino es OneDrive
                if (tcDirectoryPath.StartsWith("od:") && _ValidateConnection(TipoConexion.OneDrive))
                {
                    llOk = true;
                    tcDirectoryPath = _CleanStringToUpdate(tcDirectoryPath);
                }

                if (llOk)
                {
                    FolderFileClientManager _Folder = new FolderFileClientManager
                    {
                        AllowedDrives = _AllowedDrives,
                        Credentials = _GetCredentials()
                    };

                    llOk = _Folder.CreatePath(tcDirectoryPath);
                }

                return llOk;
            }
            catch (Exception e)
            {
                _ErrorMessage = e.Message;
            }
            return false;
        }
        public bool _DeleteFolder(String tcDirectoryPath)
        {
            Boolean llOk = false;

            try
            {
                tcDirectoryPath = _TransformPathOneDriveToDrive(tcDirectoryPath);

                //Validamos la conexión de O365 si el destino es O365
                if (tcDirectoryPath.StartsWith("sh:") && _ValidateConnection(TipoConexion.O365))
                {
                    llOk = true;
                }

                //Validamos la conexión de OneDrive si el destino es OneDrive
                if (tcDirectoryPath.StartsWith("od:") && _ValidateConnection(TipoConexion.OneDrive))
                {
                    llOk = true;
                    tcDirectoryPath = _CleanStringToUpdate(tcDirectoryPath);
                }

                if (llOk)
                {
                    FolderFileClientManager _Folder = new FolderFileClientManager
                    {
                        AllowedDrives = _AllowedDrives,
                        Credentials = _GetCredentials()
                    };

                    try
                    {
                        Regex path_regex = new Regex(InvalidFormatPath_Regex);
                        if (!path_regex.IsMatch(tcDirectoryPath))
                        {
                            throw new Exception(InvalidFormatPath_Literal);
                        }
                        IPathInformation _PathInformation = new PathInformation(tcDirectoryPath, false);
                        IDrive oDrive = StaticObjects.GetIDriveByPath(tcDirectoryPath);
                        var result = oDrive.DriveFolder.FolderDelete(tcDirectoryPath);
                        oDrive = null;
                        return result;
                    }
                    catch (Exception _Exception)
                    {
                        throw _Exception;
                    }
                }

                return llOk;
            }
            catch (Exception e)
            {
                _ErrorMessage = e.Message;
            }
            return false;
        }
        internal string InvalidFormatPath_Regex
        {
            get
            {
                //Que no termine con un punto y que no contenga ninguno de los siguientes caracteres: * ? \ / "" : < > |
                return @"^(?:(\w{1,2})\:|\\)((\\[^\*\?\/\""\:<>\|]+)+)[^\.]$";
            }
        }
        public bool _RenameFolder(String tcDirectoryPath, string tcNewForderName)
        {
            Boolean llOk = false;

            try
            {
                tcDirectoryPath = _TransformPathOneDriveToDrive(tcDirectoryPath);

                //Validamos la conexión de O365 si el destino es O365
                if (tcDirectoryPath.StartsWith("sh:") && _ValidateConnection(TipoConexion.O365))
                {
                    llOk = true;
                }

                //Validamos la conexión de OneDrive si el destino es OneDrive
                if (tcDirectoryPath.StartsWith("od:") && _ValidateConnection(TipoConexion.OneDrive))
                {
                    llOk = true;
                    tcDirectoryPath = _CleanStringToUpdate(tcDirectoryPath);
                }

                if (llOk)
                {
                    FolderFileClientManager _Folder = new FolderFileClientManager
                    {
                        AllowedDrives = _AllowedDrives,
                        Credentials = _GetCredentials()
                    };

                    try
                    {
                        Regex path_regex = new Regex(InvalidFormatPath_Regex);
                        if (!path_regex.IsMatch(tcDirectoryPath))
                        {
                            throw new Exception(InvalidFormatPath_Literal);
                        }
                       
                        IPathInformation _PathInformation = new PathInformation(tcDirectoryPath, false);
                        IDrive oDrive = StaticObjects.GetIDriveByPath(tcDirectoryPath);
                        var result = oDrive.DriveFolder.FolderRename(tcDirectoryPath, tcNewForderName);
                        oDrive = null;
                        return result;
                    }
                    catch (Exception _Exception)
                    {
                        throw _Exception;
                    }
                }

                return llOk;
            }
            catch (Exception e)
            {
                _ErrorMessage = e.Message;
                //if (e.Message.IndexOf("filePath") != -1)
                //    _ErrorMessage = "No se puede guardar el fichero en la carpeta raíz de Microsoft 365";
            }
            return false;
        }

        internal string InvalidFormatPath_Literal
        {
            get
            {
                string Culture = string.Empty;

                if (CultureInfo.CurrentCulture.DisplayName.Contains("English"))
                {
                    Culture = "en";
                }
                else
                {
                    if (CultureInfo.CurrentCulture.DisplayName.Contains("Spanish"))
                        Culture = "es";
                    else
                        Culture = "es";
                }

                switch (Culture)
                {
                    case "en":
                        return @"A name can't contain any of the following characters: \ / : * ? < > |";
                    case "es":
                        return @"Escribe un nombre que no termine con un punto y que no contenga ninguno de los siguientes caracteres: * ? \ / "" : < > |";
                    default:
                        return string.Empty;
                }
            }
        }
        private string _CleanStringToUpdate(String tcPathDestination)
        {
            tcPathDestination = functions.FUNCTIONS._Quitar_Acentos(tcPathDestination);

            // Eliminamos las Ñ de la ruta y del fichero
            Regex loChar_n = new Regex("[ñ]", RegexOptions.Compiled);
            Regex loChar_N = new Regex("[Ñ]", RegexOptions.Compiled);

            tcPathDestination = loChar_n.Replace(tcPathDestination, "n");
            tcPathDestination = loChar_N.Replace(tcPathDestination, "N");

            string lcPath = Path.GetDirectoryName(tcPathDestination);
            string lcFile = Path.GetFileName(tcPathDestination);

            // Los espacios de los ficheros los sube con "%20", en las carpetas lo permite correctamente
            Regex loEspace = new Regex("[ ]", RegexOptions.Compiled);
            lcFile = loEspace.Replace(lcFile, "_");

            return Path.Combine(lcPath, lcFile);
        }

        public bool _DirectoryExists(String tcDirectoryPath)
        {
            Boolean llOk = false;

            tcDirectoryPath = _TransformPathOneDriveToDrive(tcDirectoryPath);

            //Validamos la conexión de O365 si el destino es O365
            if (tcDirectoryPath.StartsWith("sh:") && _ValidateConnection(TipoConexion.O365))
            {
                llOk = true;
            }

            //Validamos la conexión de OneDrive si el destino es OneDrive
            if (tcDirectoryPath.StartsWith("od:") && _ValidateConnection(TipoConexion.OneDrive))
            {
                llOk = true;
            }

            if (llOk)
            {
                FolderFileClientManager _Folder = new FolderFileClientManager
                {
                    AllowedDrives = _AllowedDrives,
                    Credentials = _GetCredentials()
                };

                //PE-105340 Si al validar da excepción (presuntamente de login, lo doy por malo pero no lanzo excepción)
                try
                {
                    llOk = _Folder.FolderExists(tcDirectoryPath);
                }
                catch (Exception loEx) 
                {
                    //No se lanza excepción durante la comprobación. Se da por mala.
                    _RaiseException(loEx);
                    llOk = false;
                }
            }
                 
            return llOk;
        }

        public DialogResult _GetPathFile(String tcTitle, String tcType = "Todos los archivos (*.*)|*.*", String tcPath = "")
        {
            return _Launch(tcTitle, DialogTypes.SaveDialog, tcType, tcPath);
        }

        public DialogResult _GetPathFolder(String tcTitle)
        {
            try
            {
                return _Launch(tcTitle, DialogTypes.FolderDialog);
            }            
            catch (Exception loException)
            {
                _RaiseException(loException);
                return DialogResult.None;
            }
        }

        public List<string> _GetFolderFilenamesList(string tcDirectoryPath)
        {
            bool llOk = false;

            //Tratamiento previo
            try
            {
                //Formateo origen
                tcDirectoryPath = _TransformPathOneDriveToDrive(tcDirectoryPath);

                //Validamos la conexión de O365 si el destino es O365
                if (tcDirectoryPath.StartsWith("sh:") && _ValidateConnection(TipoConexion.O365))
                {
                    llOk = true;
                }

                //Validamos la conexión de OneDrive si el destino es OneDrive
                if (tcDirectoryPath.StartsWith("od:") && _ValidateConnection(TipoConexion.OneDrive))
                {
                    llOk = true;
                }

                if (llOk) //El formato es bueno y tengo conexión
                {
                    if (_DirectoryExists(tcDirectoryPath)) //Verifico que el fichero exista
                    {
                        FolderFileClientManager _Folder = new FolderFileClientManager
                        {
                            AllowedDrives = _AllowedDrives,
                            Credentials = _GetCredentials()
                        };


                        var resultado = _Folder.DirectoryFiles(tcDirectoryPath, "*.*");

                        if (resultado != null)
                            return resultado.ToList();
                        else
                            return new List<string>();
                    }
                }
            }
            catch (Exception e)
            {
                _ErrorMessage = "Se ha producido un error al descargar el fichero.";
                db.DB.Registrar_Error(e);
            }
            return new List<string>();
        }

        private DialogResult _Launch(String tcTitle, DialogTypes toType, String tcType = "Todos los archivos (*.*)|*.*", String tcPath = "")
        {
            
            DialogResult loResult = DialogResult.Cancel;
           
            if (_ValidateConnection(_Tipo) || //Conexion bien configurada y conectada
                _SinConfigurar(_Tipo)) //No utiliza conexion => Ha de abrir igual pero lo hará sin los iconos de unidades cloud
            {
                //PE-104439 Tratamos el path para pasarselo a FileDialog
                _SetDefaultPath(tcPath);
                loResult = (DialogResult)_Dialog.LaunchFileDialog(_AllowedDrives, tcType, toType, false, false, _GetCredentials(), false, tcTitle, false, false);

                if (loResult == DialogResult.OK)
                {
                    _Path = _TranformPathDriveToOneDrive(_Dialog.Path);

                    //Si tiene algún fichero seleccionado, lo añadimos a la ruta
                    if (_Dialog.Files.Count() > 0)
                    {
                        _Path = Path.Combine(_Path, _Dialog.Files[0]);
                    }
                }

                if (_oDialog.Form != null && !((FileDialogForm)_Dialog.Form).IsDisposed)
                {
                    ((FileDialogForm)_Dialog.Form).Dispose();
                }

                _oDialog.Dispose();
            }

            return loResult; 
        }

        private void _SetDefaultPath(string tcPath)
        {
            String lcFile, lcPath;
            String[] loFiles = new String[] { };

            try
            {
                lcFile = lcPath = "";
                //Si esta vacio ponemos el por defecto
                if (String.IsNullOrWhiteSpace(tcPath.Trim()))
                {
                    lcPath = _TransformPathOneDriveToDrive(_GetDefaultPath(_Tipo)).Trim();
                }
                //Miramos que no sea de OneDrive o O365
                else if (_IsPath(tcPath))
                {
                    lcPath = _TransformPathOneDriveToDrive(tcPath);

                    if (tcPath.Contains("\\"))
                    {
                        lcPath = tcPath.Substring(0, tcPath.LastIndexOf("\\") );
                        if (!tcPath.EndsWith("\\")) lcFile = tcPath.Substring(tcPath.LastIndexOf("\\") + 1);
                        loFiles = new string[] { lcFile };
                    }
                }
                //Es un path fisico
                else
                {
                    FileInfo loFile = new FileInfo(tcPath);

                    lcPath = loFile.DirectoryName;
                    lcFile = loFile.Name;
                    loFiles = new string[] { lcFile };
                }


                _Dialog.Path = lcPath;
                _Dialog.Files = loFiles;
            }
            catch
            {
            }
        }

        private bool _ValidateConnection(TipoConexion toTipoConexion)
        {
            if (toTipoConexion == TipoConexion.Todas)
            {
                return _oOneDriveManagement._ValidateConnection() || _oO365Management._ValidateConnection();
            }
            else
            {
                if (toTipoConexion == TipoConexion.OneDrive)
                {
                    return _oOneDriveManagement._ValidateConnection();
                }
                else
                {
                    return _oO365Management._ValidateConnection();
                }
            }
        }

        private bool _SinConfigurar(TipoConexion toTipoConexion)
        {
            var tenemosConfiguracion = false;
            if (toTipoConexion == TipoConexion.Todas)
            {
                tenemosConfiguracion = _oOneDriveManagement._IsConfigured || _oO365Management._IsConfigured;
            }
            else
            {
                if (toTipoConexion == TipoConexion.OneDrive)
                {
                    tenemosConfiguracion = _oOneDriveManagement._IsConfigured;
                }
                else
                {
                    tenemosConfiguracion = _oO365Management._IsConfigured;
                }
            }

            return !tenemosConfiguracion;
        }

        private String _GetDefaultPath(TipoConexion toTipoConexion)
        {
            String lcPath = "";

            if (toTipoConexion == TipoConexion.OneDrive)
            {
                lcPath = _oOneDriveManagement._DefaultPath;
            }
            else if(toTipoConexion == TipoConexion.O365)
            {
                lcPath = _oO365Management._DefaultPath;
            }

            return (lcPath == null ? "" : lcPath);
        }

        public Boolean _OpenAndSavePath(String tcPathDestino, Int16 tnTipo)
        {
            Boolean llOk = false; 
            DialogResult loResult;

            loResult =  tnTipo == 0 ? _GetPathFolder("Seleccione la carpeta"): _GetPathFile("Seleccione el fichero");

            if (DialogResult.OK == loResult)
            {
                if (!String.IsNullOrEmpty(_Path))
                {
                    //PE-98984 Cambiamos el encoding del fichero 
                    System.IO.File.WriteAllText(tcPathDestino, string.Format("{0}|{1}", _Path, Convert.ToInt16(_IsPath(_Path))));
                }
            }

            return llOk;
        }

        private string _TransformPathOneDriveToDrive(string tcDirectoryPath)
        {
            //Sino es un path (tipo OneDrive\xxx) ni es una unidad (tipo od:) o está vacio le asigno el path por defecto
            if((!_IsPath(tcDirectoryPath) && !tcDirectoryPath.StartsWith("sh:") && !tcDirectoryPath.StartsWith("od:")) || string.IsNullOrWhiteSpace(tcDirectoryPath))
            {
                tcDirectoryPath = _GetDefaultPath(_Tipo).TrimEnd() + tcDirectoryPath;
            }


            foreach (KeyValuePair<string, string> oValue in _oConversion)
            {
                tcDirectoryPath = tcDirectoryPath.Replace(oValue.Value, oValue.Key);
            }

            //En este punto mi path ha de tener unidad... o mal vamos... Las llamadas por código es posible que no la tengan
            if (!tcDirectoryPath.StartsWith("sh:") && !tcDirectoryPath.StartsWith("od:"))
            {
                if (_Tipo == TipoConexion.O365)
                {
                    tcDirectoryPath = @"sh:\" + tcDirectoryPath;
                }
                else
                {
                    //Para tipo conexión Todas lo trato como OneDrive... sino haber especificado la unidad.
                    tcDirectoryPath = @"od:\" + tcDirectoryPath;
                };
            }

            return tcDirectoryPath;
        }

        private string _TranformPathDriveToOneDrive(String tcDirectoryPath)
        {
            foreach (KeyValuePair<String,String> oValue in _oConversion)
            {
                tcDirectoryPath = Regex.Replace(tcDirectoryPath, oValue.Key, oValue.Value);
            }
            return tcDirectoryPath;
        }

        private ICredentials[] _GetCredentials()
        {
            try
            {
                List<ICredentials> _CredentialsList = new List<ICredentials>();
                ICredentials _Credential = null;

                if (_Tipo == TipoConexion.Todas)
                {
                    if (_oOneDriveManagement._IsConfigured)
                    {
                        _Credential = new Credentials
                        {
                            Name = "OneDrive",
                            Credential = _oOneDriveManagement._RefreshToken
                        };
                        _CredentialsList.Add(_Credential);
                    }

                    if (_oO365Management._IsConfigured)
                    {
                        _Credential = new Credentials
                        {
                            Name = "Office365",
                            ClientId = ((IService[])_oO365Management.ServiceResourceIds).Where(x => x.capability == "MyFiles").FirstOrDefault().serviceResourceId,
                            Credential = _oO365Management._RefreshToken
                        };
                        _CredentialsList.Add(_Credential);
                    }
                }
                else if (_Tipo == TipoConexion.OneDrive)
                {
                    if (_oOneDriveManagement._IsConfigured)
                    {
                        _Credential = new Credentials
                        {
                            Name = "OneDrive",
                            Credential = _oOneDriveManagement._RefreshToken
                        };
                        _CredentialsList.Add(_Credential);
                    }
                }
                else
                {
                    if (_oO365Management._IsConfigured)
                    {
                        _Credential = new Credentials
                        {
                            Name = "Office365",
                            ClientId = ((IService[])_oO365Management.ServiceResourceIds).Where(x => x.capability == "MyFiles").FirstOrDefault().serviceResourceId,
                            Credential = _oO365Management._RefreshToken
                        };
                        _CredentialsList.Add(_Credential);
                    }
                }
                

                return _CredentialsList.ToArray();
            }
            catch (Exception _Exception)
            {
                throw _Exception;
            }
        }

        public void _RaiseException(Exception toException)
        {
            string lcErrorMessage = "";

            lcErrorMessage = "Se ha producido un error cuando se ha intentado realizar operaciones con FileDialog365" +
                Environment.NewLine + "El mensaje por parte de FileDialog365 es: " + Environment.NewLine + toException.Message;

            functions.FUNCTIONS._MessageBox(lcErrorMessage, "Error FileDialog365",
                System.Windows.Forms.MessageBoxButtons.OK,
                System.Windows.Forms.MessageBoxIcon.Error,
                System.Windows.Forms.MessageBoxDefaultButton.Button1);
            db.DB.Registrar_Error(toException);
        }

        private bool disposed = false;

        public void Dispose()
        {
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called.
            if (!this.disposed)
            {
                // If disposing equals true, dispose all managed
                // and unmanaged resources.
                if (disposing)
                {
                    // Dispose managed resources.
                    _oO365Management = null;
                    _oOneDriveManagement = null;
                    _oAllowedDrives = null;
                    if (_oDialog != null)
                        _oDialog.Dispose();
                    _oDialog = null;
                    _oConversion = null;
                }
                // Note disposing has been done.
                disposed = true;
            }
        }

        // Use C# finalizer syntax for finalization code.
        // This finalizer will run only if the Dispose method
        // does not get called.
        // It gives your base class the opportunity to finalize.
        // Do not provide finalizer in types derived from this class.
        ~FileDialog365()
        {
            //if (!hasFinalized)
            //{
                // Do not re-create Dispose clean-up code here.
                // Calling Dispose(disposing: false) is optimal in terms of
                // readability and maintainability.
                Dispose(disposing: false);

            //    //h ttps://docs.microsoft.com/es-es/dotnet/api/system.gc.reregisterforfinalize?view=net-6.0
            //    hasFinalized = true;
            //    GC.ReRegisterForFinalize(this);
            //}
        }

        //private bool hasFinalized = false;
    }   
}