OfflineUpAndDownOneDrive_Impl.cs

using sage.ew.enumerations;
using sage.ew.global;
using sage.ew.global.DependencyInjection;
using sage.ew.interficies;
using System;
using System.Collections.Generic;
using System.IO;

namespace sage.addons.offline.Negocio.Clases
{
    internal class OfflineUpAndDownOneDrive_Impl : IOfflineUpAndDown
    {
        private IFileDialog365 _oFileDialog365;
        readonly TipoConexion _oTipoConexionServicio = TipoConexion.OneDrive;

        #region Constructores


        public OfflineUpAndDownOneDrive_Impl(int idConf = 0)
        {
            //Hay que indicarle un IdConf para poder recuperar las credenciales
            EW_GLOBAL.ValorEnClave_VarGlob("wn_offlineIdConf365", idConf);

            var factory = DependencyInjector.Instance.Retrieve<IO365Factory>();
            _oFileDialog365 = factory._NewFileDialog365(_oTipoConexionServicio, TipoOneDrive.ComunicacionesOffline);
        }


        #endregion Constructores

        public bool Comprobar_Conexion(FtpUserData toFtpUserData, bool lbAsistConfSig)
        {
            //No hay operación de comprobación para OneDrive como tal. Si se invoca algún método se procede al login fuera del programa y se pierde el control
            //y el resultado... No obtante probamos de ejecutar alguna operación.

            var nombreDirectorio = @"od:\UnitTestBorrar\";
            var resultado = false;
            if (_oFileDialog365._DirectoryExists(nombreDirectorio))
            {
                _oFileDialog365._DeleteFolder(nombreDirectorio);
            }
            resultado =_oFileDialog365._CreateFolder(nombreDirectorio);
            resultado = resultado && _oFileDialog365._DeleteFolder(nombreDirectorio);

            if (!resultado)
            {
                if (!lbAsistConfSig)
                {
                    toFtpUserData.error_message = "Se ha producido un error al obtener datos del OneDrive.";
                }
                else
                {
                    toFtpUserData.error_message = "Para avanzar al siguiente paso debe definir una configuración de conexión. Configure Servidor FTP o OneDrive para poder continuar.";
                }
            }

            return resultado;
        }



        public bool Descargar_Fichero(string path, string fileName, string carpeta, int idConf, bool deleteSource)
        {
            try
            {
                //Verificar donde debe descargar los ficheros
                var rutaServidor = Convert.ToString(EW_GLOBAL._GetVariable("wc_iniservidor")).Trim();
                rutaServidor = Path.Combine(rutaServidor, "MODULOS\\offline\\descargas");

                string rutaFicherosServidor = Path.Combine(rutaServidor, path);
                string fullLocalFileName = Path.Combine(rutaFicherosServidor, fileName);

                if (Directory.Exists(rutaFicherosServidor))
                {
                    if (File.Exists(fullLocalFileName))
                        File.Delete(fullLocalFileName);
                }
                else
                {
                    Directory.CreateDirectory(path);
                }

                var oneDriveFileName = Path.Combine(carpeta, fileName);

                var llOk = DescargarArchivoOneDrive(oneDriveFileName, fullLocalFileName, true, deleteSource);

                return llOk;

            }
            catch (Exception loEx)
            {
                string error = "Se ha producido un error al obtener datos de OneDrive (" + loEx.Message + ").";
                //callback?.Invoke(error);
                return false;
            }
        }


        private bool DescargarArchivoOneDrive(string oneDriveFileName, string fullLocalFileName, bool uncompressZip, bool deleteSource)
        {

            var llOk = _oFileDialog365._DownLoadFile(oneDriveFileName, fullLocalFileName);

            if (uncompressZip && File.Exists(fullLocalFileName))
            {
                clsOffLine utilsOffline = new clsOffLine();
                utilsOffline.Fichero_Descomprimir(fullLocalFileName, Path.GetDirectoryName(fullLocalFileName), false);
            }

            if (deleteSource)
            {
                _oFileDialog365._DeleteFile(oneDriveFileName);
            }

            return llOk;
        }

        public bool Subir_Fichero(string archivo, string zipFilename, string carpeta, int idConf, ref long uploadedFileSize)
        {
            var llOk = false;

            try
            {
                //Hay dos llamadas distintas a este método. Una de ellas (el envio general) sin valor para este parámetro y presuntament en archivo llega una ruta
                //completa 
                if (!string.IsNullOrWhiteSpace(zipFilename))
                {
                    if (File.Exists(archivo))
                    {
                        clsOffLine utilsOffline = new clsOffLine();
                        string pathArchivoComprimido = utilsOffline.Fichero_Comprimir(archivo, zipFilename);

                        archivo = Path.Combine(Path.GetDirectoryName(archivo), pathArchivoComprimido);
                        archivo = Path.Combine(archivo, zipFilename);
                    }
                }

                if (carpeta != "/") //Raiz... lo ignoro
                    llOk = GarantizarDirectorioDestino(carpeta);
                else
                    llOk = true;

                if (llOk)
                {
                    var destino = Path.Combine(carpeta, Path.GetFileName(archivo));
                    llOk = _oFileDialog365._UploadFile(archivo, destino);
                    if(!llOk && !string.IsNullOrWhiteSpace(_oFileDialog365._ErrorMessage))
                    {
                        //callback?.Invoke(_oFileDialog365._ErrorMessage);
                        return false;
                    }
                }

                uploadedFileSize = new FileInfo(archivo).Length;

                return llOk;
            }
            catch (Exception loEx)
            {
                string error = "Se ha producido un error al enviar datos a OneDrive (" + loEx.Message + ").";
                //callback?.Invoke(error);
                return false;
            }
        }

        #region Métodos privados

        private bool GarantizarDirectorioDestino(string tcFolderUpload)
        {
            bool llOk = true;

            if (!_oFileDialog365._DirectoryExists(tcFolderUpload))
            {
                llOk = _oFileDialog365._CreateFolder(tcFolderUpload);

                llOk = _oFileDialog365._DirectoryExists(tcFolderUpload);

                if (!llOk)
                {
                    // TODO: Gestión de errores
                }
            }

            return llOk;
        }

        public List<string> GetListFiles(string carpetaserv, int idConf)
        {
            if (_oFileDialog365._DirectoryExists(carpetaserv))
            {
                var ficheros = _oFileDialog365._GetFolderFilenamesList(carpetaserv);
                return ficheros;
            }
            else
            {
                return new List<string>();
            }
        }


        #endregion Métodos privados
    }
}