OfflineUpAndDownFTP_Impl.cs

using sage.ew.db;
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using System.Windows;

namespace sage.addons.offline.Negocio.Clases
{
    internal class OfflineUpAndDownFTP_Impl : IOfflineUpAndDown
    {
        #region Propiedades

        public int _idConf
        {
            get
            {
                return _nIdConf;
            }
            set
            {
                _nIdConf = value;

                _oFtpUserData = CargarConfiguracion();
            }
        }
        private int _nIdConf = 0;

        private FtpUserData _oFtpUserData = null;

        #endregion Propiedades


        #region Constructores

        public OfflineUpAndDownFTP_Impl()
        {

        }

        public OfflineUpAndDownFTP_Impl(FtpUserData config) : this()
        {
            _oFtpUserData = config;
        }

        #endregion Constructores


        #region Métodos públicos




        public bool Comprobar_Conexion(FtpUserData toFtpUserData, bool lbAsistConfSig)
        {
            string lcRemoteUri = toFtpUserData.ToRemoteUri();

            try
            {
                FtpWebRequest ftpRequest = (FtpWebRequest)WebRequest.Create(lcRemoteUri);
                if (!string.IsNullOrWhiteSpace(toFtpUserData.proxy))
                {
                    WebProxy proxyObject = new WebProxy(toFtpUserData.proxy, true);
                    ftpRequest.Proxy = proxyObject;
                }
                ftpRequest.UsePassive = !toFtpUserData.ftp_activo;
                ftpRequest.EnableSsl = toFtpUserData.use_ssl_tls;
                if (toFtpUserData.use_ssl_tls && !toFtpUserData.validate_server_cert)
                {
                    ServicePointManager.ServerCertificateValidationCallback = 
                        (sender, certificate, chain, errors) =>
                        {
                            return true;
                        };
                }

                ftpRequest.Timeout = 10000;
                ftpRequest.Credentials = new NetworkCredential(toFtpUserData.user, toFtpUserData.password);
                ftpRequest.Method = WebRequestMethods.Ftp.ListDirectory;
                FtpWebResponse response = (FtpWebResponse)ftpRequest.GetResponse();
                StreamReader streamReader = new StreamReader(response.GetResponseStream());

                string lcCarpetaFtp = streamReader.ReadLine();

                //Basta con ver que la cosa ha ido bien.
                streamReader.Close();
            }
            catch (Exception loEx)
            {
                if (!lbAsistConfSig)
                {
                    toFtpUserData.error_message = "Se ha producido un error al obtener datos del FTP (" + loEx.Message + ").";
                }
                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 false;
            }
            finally
            {
                ServicePointManager.ServerCertificateValidationCallback = null;
            }

            return true;
        }


        public bool Descargar_Fichero(string path, string fileName, string carpeta, int idConf, bool deleteSource)
        {
            _idConf = idConf;
            _oFtpUserData.carpetaserv = carpeta;

            string lcRemoteUri = _oFtpUserData.ToRemoteUri();
            try
            {
                FtpWebRequest ftpRequest = (FtpWebRequest)WebRequest.Create(lcRemoteUri);
                if (!string.IsNullOrWhiteSpace(_oFtpUserData.proxy))
                {
                    WebProxy proxyObject = new WebProxy(_oFtpUserData.proxy, true);
                    ftpRequest.Proxy = proxyObject;
                }
                ftpRequest.UsePassive = !_oFtpUserData.ftp_activo;
                ftpRequest.EnableSsl = _oFtpUserData.use_ssl_tls;
                if (_oFtpUserData.use_ssl_tls && !_oFtpUserData.validate_server_cert)
                {
                    ServicePointManager.ServerCertificateValidationCallback =
                        (sender, certificate, chain, errors) =>
                        {
                            return true;
                        };
                }

                ftpRequest.Timeout = 10000;
                ftpRequest.Credentials = new NetworkCredential(_oFtpUserData.user, _oFtpUserData.password);
                ftpRequest.Method = WebRequestMethods.Ftp.ListDirectory;
                FtpWebResponse response = (FtpWebResponse)ftpRequest.GetResponse();
                StreamReader streamReader = new StreamReader(response.GetResponseStream());

                string lcCarpetaFtp = streamReader.ReadLine();
                while (!string.IsNullOrEmpty(lcCarpetaFtp))
                {
                    if (!lcCarpetaFtp.StartsWith("/"))
                        lcCarpetaFtp = "/" + lcCarpetaFtp;

                    if (!lcCarpetaFtp.EndsWith("/"))
                        lcCarpetaFtp = lcCarpetaFtp + "/";

                    if (!_oFtpUserData.rutaserv.StartsWith("/"))
                        _oFtpUserData.rutaserv = "/" + _oFtpUserData.rutaserv;

                    if (!_oFtpUserData.rutaserv.EndsWith("/"))
                        _oFtpUserData.rutaserv = _oFtpUserData.rutaserv + "/";

                    if (lcCarpetaFtp.ToUpper() == _oFtpUserData.rutaserv.ToUpper())
                    {
                        string fullFileName = Path.Combine(path, fileName);
                        if (Directory.Exists(path))
                        {
                            if (File.Exists(fullFileName))
                                File.Delete(fullFileName);
                        }
                        else
                        {
                            Directory.CreateDirectory(path);
                        }

                        DescargarArchivoFTP(fileName, path, true, deleteSource);

                        break;
                    }
                    lcCarpetaFtp = streamReader.ReadLine();
                }

                streamReader.Close();
            }
            catch (Exception loEx)
            {
                string error = "Se ha producido un error al obtener datos del FTP (" + loEx.Message + ").";
                //callback?.Invoke(error);
                return false;
            }
            finally
            {
                ServicePointManager.ServerCertificateValidationCallback = null;
            }

            return true;
        }


        public List<string> GetListFiles(string carpetaserv, int idConf)
        {
            List<string> lsFicheros = new List<string>();

            _idConf = idConf;
            if(!string.IsNullOrWhiteSpace(carpetaserv))
                _oFtpUserData.carpetaserv = carpetaserv + "/";

            return GetListFiles(_oFtpUserData);
        }

        //Se crea este método (fuera de interfície) para poder inyectar la configuración FTP a la operación 
        //Esta pensado para la migración ANTES de ajustar la tabla MULTCONF cosa que impide el uso normal de los métodos por la fuerte dependencia interna
        public List<string> GetListFiles(FtpUserData configFtp)
        {
            List<string> lsFicheros = new List<string>();

            // Ruta fichero en el FTP
            string lcRemoteUri = configFtp.ToRemoteUri();

            lcRemoteUri = lcRemoteUri + "//" + configFtp.rutaserv + "//" + configFtp.carpetaserv;

            try
            {
                FtpWebRequest ftpRequest = (FtpWebRequest)WebRequest.Create(lcRemoteUri);
                if (!string.IsNullOrWhiteSpace(configFtp.proxy))
                {
                    WebProxy proxyObject = new WebProxy(configFtp.proxy, true);
                    ftpRequest.Proxy = proxyObject;
                }
                ftpRequest.UsePassive = !configFtp.ftp_activo;
                ftpRequest.EnableSsl = configFtp.use_ssl_tls;
                if (configFtp.use_ssl_tls && !configFtp.validate_server_cert)
                {
                    ServicePointManager.ServerCertificateValidationCallback =
                        (sender, certificate, chain, errors) =>
                        {
                            return true;
                        };
                }

                ftpRequest.Timeout = 10000;
                ftpRequest.Credentials = new NetworkCredential(configFtp.user, configFtp.password);
                ftpRequest.Method = WebRequestMethods.Ftp.ListDirectory;
                FtpWebResponse response = (FtpWebResponse)ftpRequest.GetResponse();
                StreamReader streamReader = new StreamReader(response.GetResponseStream());

                string lcFichero = streamReader.ReadLine();
                while (!string.IsNullOrEmpty(lcFichero))
                {
                    lsFicheros.Add(lcFichero);

                    lcFichero = streamReader.ReadLine();
                }

                streamReader.Close();
            }
            catch (Exception)
            {
                return new List<string>();
            }
            finally
            {
                ServicePointManager.ServerCertificateValidationCallback = null;
            }

            return lsFicheros;
        }

        public bool Subir_Fichero(string archivo, string zipFilename, string carpeta, int idConf, ref long uploadedFileSize)
        {
            try
            {
                _idConf = idConf;
                _oFtpUserData.carpetaserv = carpeta;

                if (!CargarArchivoFTP(archivo, zipFilename, ref uploadedFileSize))
                {
                    string error = "No se han podido subir el fichero " + archivo + " al FTP.";
                    //callback?.Invoke(error);
                    return false;
                }
            }
            catch (Exception loEx)
            {
                string error = "Se ha producido un error al subir datos al FTP (" + loEx.Message + ").";
                //callback?.Invoke(error);
                DB.Registrar_Error(loEx);
                return false;
            }

            return true;
        }


        #endregion Métodos públicos


        #region Métodos privados


        private FtpUserData CargarConfiguracion()
        {
            //Santi => valor idconf 0 no tengo claro si es apropiado
            Dictionary<string, object> tablaMultconf = DB.SQLREGValor("MULTCONF", "IDCONF", _idConf.ToString(), "OFFLINE");

            string cadenaEncriptada = tablaMultconf["cfg_ftp"].ToString().Trim();

            var toolsOffline = new clsOffLine();
            string cadenaDesencriptada = toolsOffline.Cadena_Desencriptar(cadenaEncriptada);

            var trozos = cadenaDesencriptada.Split('~');

            if (trozos.Length == 7)
            {
                var ftp_user_data = new FtpUserData
                {
                    server = trozos[0].Trim(),
                    user = trozos[1].Trim(),
                    password = trozos[2].Trim(),
                    port = Convert.ToDecimal(trozos[3]),
                    proxy = trozos[4].Trim(),
                    rutaserv = trozos[5].Trim(),
                    ftp_activo = trozos[6].Trim().ToUpper() == "SI"
                };
                return ftp_user_data;
            }
            else if (trozos.Length == 9)
            {
                var ftp_user_data = new FtpUserData
                {
                    server = trozos[0].Trim(),
                    user = trozos[1].Trim(),
                    password = trozos[2].Trim(),
                    port = Convert.ToDecimal(trozos[3]),
                    proxy = trozos[4].Trim(),
                    rutaserv = trozos[5].Trim(),
                    ftp_activo = trozos[6].Trim().ToUpper() == "SI",
                    use_ssl_tls = trozos[7].Trim().ToUpper() == "SI",
                    validate_server_cert = trozos[8].Trim().ToUpper() == "SI",
                };
                return ftp_user_data;
            }

            throw new NotSupportedException("Error cargando configuración FTP");
        }

        private void MakeFTPDir(FtpUserData ftpUserData)
        {
            FtpWebRequest ftpRequest = null;
            Stream ftpStream = null;
            string pathToCreate = ftpUserData.rutaserv + "//" + ftpUserData.carpetaserv;
            string[] subDirs = pathToCreate.Split('/');
            string currentDir = ftpUserData.ToRemoteUri();
            bool llExist = false;

            foreach (string subDir in subDirs)
            {
                if (!string.IsNullOrWhiteSpace(subDir))
                {
                    try
                    {
                        llExist = false;
                        ftpRequest = (FtpWebRequest)FtpWebRequest.Create(currentDir);
                        if (!string.IsNullOrWhiteSpace(ftpUserData.proxy))
                        {
                            WebProxy proxyObject = new WebProxy(ftpUserData.proxy, true);
                            ftpRequest.Proxy = proxyObject;
                        }
                        ftpRequest.UsePassive = !ftpUserData.ftp_activo;
                        ftpRequest.EnableSsl = ftpUserData.use_ssl_tls;
                        if (ftpUserData.use_ssl_tls && !ftpUserData.validate_server_cert)
                        {
                            ServicePointManager.ServerCertificateValidationCallback =
                                (sender, certificate, chain, errors) =>
                                {
                                    return true;
                                };
                        }

                        ftpRequest.Timeout = 10000;
                        ftpRequest.Method = WebRequestMethods.Ftp.ListDirectory;
                        ftpRequest.Credentials = new NetworkCredential(ftpUserData.user, ftpUserData.password);

                        FtpWebResponse response = (FtpWebResponse)ftpRequest.GetResponse();
                        StreamReader streamReader = new StreamReader(response.GetResponseStream());

                        string lcFolder = streamReader.ReadLine();
                        while (!string.IsNullOrEmpty(lcFolder))
                        {
                            if  (lcFolder.Contains("/"))
                            {
                                lcFolder = lcFolder.Substring(lcFolder.LastIndexOf("/") + 1);

                            }

                            if (lcFolder.ToUpper() == subDir.ToUpper())
                            {
                                llExist = true;
                                break;
                            }
                            lcFolder = streamReader.ReadLine();
                        }

                        streamReader.Close();
                        response.Close();

                        currentDir = currentDir + "//" + subDir;

                        if (!llExist)
                        {
                            ftpRequest = (FtpWebRequest)FtpWebRequest.Create(currentDir);
                            if (!string.IsNullOrWhiteSpace(ftpUserData.proxy))
                            {
                                WebProxy proxyObject = new WebProxy(ftpUserData.proxy, true);
                                ftpRequest.Proxy = proxyObject;
                            }
                            ftpRequest.UsePassive = !ftpUserData.ftp_activo;
                            ftpRequest.EnableSsl = ftpUserData.use_ssl_tls;
                            if (ftpUserData.use_ssl_tls && !ftpUserData.validate_server_cert)
                            {
                                ServicePointManager.ServerCertificateValidationCallback =
                                    (sender, certificate, chain, errors) =>
                                    {
                                        return true;
                                    };
                            }

                            ftpRequest.Timeout = 10000;
                            ftpRequest.Method = WebRequestMethods.Ftp.MakeDirectory;
                            ftpRequest.UseBinary = true;
                            ftpRequest.Credentials = new NetworkCredential(ftpUserData.user, ftpUserData.password);

                            response = (FtpWebResponse)ftpRequest.GetResponse();
                            ftpStream = response.GetResponseStream();
                            ftpStream.Close();
                            response.Close();
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.Message);
                    }
                    finally
                    {
                        ServicePointManager.ServerCertificateValidationCallback = null;
                    }
                }
            }
        }

        private bool CargarArchivoFTP(string fileNameWithPath, string fileNameZip, ref long uploadedFileSize)
        {
            string lcRemoteUri = _oFtpUserData.ToRemoteUri();

            try
            {
                // Priemro comprobar que existe la carpeta en el FTP
                //MakeFTPDir(lcRemoteUri, _oFtpUserData.rutaserv + "/" + _oFtpUserData.carpetaserv, _oFtpUserData.user, _oFtpUserData.password);
                MakeFTPDir(_oFtpUserData);

                if (!string.IsNullOrWhiteSpace(fileNameZip) && File.Exists(fileNameWithPath))
                {
                    clsOffLine utilsOffline = new clsOffLine();
                    string pathArchivoComprimido = utilsOffline.Fichero_Comprimir(fileNameWithPath, fileNameZip);

                    fileNameWithPath = Path.Combine(Path.GetDirectoryName(fileNameWithPath), pathArchivoComprimido);
                    fileNameWithPath = Path.Combine(fileNameWithPath, fileNameZip);
                }

                //Ahora subimos fichero
                // Ruta fichero en el FTP
                string lcFileFtp = lcRemoteUri + _oFtpUserData.rutaserv + "/" + _oFtpUserData.carpetaserv + System.IO.Path.GetFileName(fileNameWithPath);

                FtpWebRequest ftpRequest = (FtpWebRequest)WebRequest.Create(lcFileFtp);
                if (!string.IsNullOrWhiteSpace(_oFtpUserData.proxy))
                {
                    WebProxy proxyObject = new WebProxy(_oFtpUserData.proxy, true);
                    ftpRequest.Proxy = proxyObject;
                }
                ftpRequest.UsePassive = !_oFtpUserData.ftp_activo;
                ftpRequest.EnableSsl = _oFtpUserData.use_ssl_tls;
                if (_oFtpUserData.use_ssl_tls && !_oFtpUserData.validate_server_cert)
                {
                    ServicePointManager.ServerCertificateValidationCallback =
                        (sender, certificate, chain, errors) =>
                        {
                            return true;
                        };
                }

                ftpRequest.Timeout = 10000;
                ftpRequest.Credentials = new NetworkCredential(_oFtpUserData.user, _oFtpUserData.password);
                ftpRequest.Method = WebRequestMethods.Ftp.UploadFile;

                 // Subir fichero
                using (Stream fileStream = File.OpenRead(fileNameWithPath))
                {
                    using (Stream ftpStream = ftpRequest.GetRequestStream())
                    {
                        fileStream.CopyTo(ftpStream);
                    }
                }

                uploadedFileSize = new FileInfo(fileNameWithPath).Length;
            }
            catch
            {
                throw;
            }
            finally
            {
                ServicePointManager.ServerCertificateValidationCallback = null;
            }

            return true;
        }


        private bool DescargarArchivoFTP(string archivo, string carpetaLocal, bool uncompressZip, bool deleteSource)
        {
            return DescargarArchivoFTP(_oFtpUserData, archivo, carpetaLocal, uncompressZip, deleteSource);
        }

        //Se crea este método (fuera de interfície) para poder inyectar la configuración FTP a la operación 
        //Esta pensado para la migración ANTES de ajustar la tabla MULTCONF cosa que impide el uso normal de los métodos por la fuerte dependencia interna
        public bool DescargarArchivoFTP(FtpUserData datosFtp, string archivo, string carpetaLocal, bool uncompressZip, bool deleteSource)
        {
            string lcRemoteUri = datosFtp.ToRemoteUri();

            string lcDirTemp = carpetaLocal;
            string lcFileName = Path.Combine(lcDirTemp, archivo);

            string lcFileFtp = null;

            try
            {
                // Ruta fichero en el FTP
                lcFileFtp = lcRemoteUri + "//" + datosFtp.rutaserv + "//" + datosFtp.carpetaserv + "//" + archivo;

                FtpWebRequest ftpRequest = (FtpWebRequest)WebRequest.Create(lcFileFtp);
                if (!string.IsNullOrWhiteSpace(datosFtp.proxy))
                {
                    WebProxy proxyObject = new WebProxy(datosFtp.proxy, true);
                    ftpRequest.Proxy = proxyObject;
                }
                ftpRequest.UsePassive = !datosFtp.ftp_activo;
                ftpRequest.EnableSsl = datosFtp.use_ssl_tls;
                if (datosFtp.use_ssl_tls && !datosFtp.validate_server_cert)
                {
                    ServicePointManager.ServerCertificateValidationCallback =
                        (sender, certificate, chain, errors) =>
                        {
                            return true;
                        };
                }

                ftpRequest.Timeout = 10000;
                ftpRequest.Credentials = new NetworkCredential(datosFtp.user, datosFtp.password);
                ftpRequest.Method = WebRequestMethods.Ftp.DownloadFile;

                // bajar fichero
                using (Stream ftpStream = ftpRequest.GetResponse().GetResponseStream())
                {
                    using (Stream fileStream = File.Create(lcFileName))
                    {
                        ftpStream.CopyTo(fileStream);
                    }
                }

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

                if (deleteSource)
                {
                    ftpRequest = (FtpWebRequest)WebRequest.Create(lcFileFtp);

                    if (!string.IsNullOrWhiteSpace(datosFtp.proxy))
                    {
                        WebProxy proxyObject = new WebProxy(datosFtp.proxy, true);
                        ftpRequest.Proxy = proxyObject;
                    }
                    ftpRequest.UsePassive = !datosFtp.ftp_activo;
                    ftpRequest.EnableSsl = datosFtp.use_ssl_tls;
                    if (datosFtp.use_ssl_tls && !datosFtp.validate_server_cert)
                    {
                        ServicePointManager.ServerCertificateValidationCallback =
                            (sender, certificate, chain, errors) =>
                            {
                                return true;
                            };
                    }

                    ftpRequest.Timeout = 10000;
                    ftpRequest.Credentials = new NetworkCredential(datosFtp.user, datosFtp.password);
                    ftpRequest.Method = WebRequestMethods.Ftp.DeleteFile;

                    FtpWebResponse response = (FtpWebResponse)ftpRequest.GetResponse();
                    response.Close();
                }
            }
            catch
            {
                throw;
            }
            finally
            {
                ServicePointManager.ServerCertificateValidationCallback = null;
            }

            return true;
        }

        private bool _LocalCertificateValidationCallback(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
        {
            return true;
        }
        #endregion Métodos privados
    }
}