FtpConfigUC.cs

using System;
using System.Windows.Forms;
using sage.addons.offline.Negocio.Clases;
using sage.ew.global;
using sage.ew.global.DependencyInjection;
using sage.ew.interficies;

namespace sage.addons.offline.Visual.UserControls
{
    public partial class
        FtpConfigUC : UserControl
    {
        #region Propiedades

        public Negocio.Mantes.ConfComOffline _Negocio { get; set; } = null;

        public OneDriveConfig _OneDriveConfig { get; set; } = null;
        
        public bool ComprobacionEjecutada
        {
            get
            {
                if(_lComprobacionEjecutada)
                {
                    //Verificamos que coincida con la que se ha verificado
                    if (_configuracionComprobada != null)
                        _lComprobacionEjecutada = ObtenerConfiguracion().Equals(_configuracionComprobada);
                    else
                        _lComprobacionEjecutada = false;
                }
                return _lComprobacionEjecutada;
            }
            private set { _lComprobacionEjecutada = value; }
        }
        bool _lComprobacionEjecutada = false;
        private FtpUserData _configuracionComprobada = null;

        public bool _ReadOnly
        {
            get
            {
                return _lReadOnly;
            }
            set
            {
                _lReadOnly = value;
                SetReadOnlyTo(value);
            }
        }
        private bool _lReadOnly = false;

        #endregion Propiedades

        #region Constructores

        public FtpConfigUC()
        {
            InitializeComponent();

            if (!EW_GLOBAL._EsEjecutable)
                return;

            _OneDriveConfig = new OneDriveConfig
            {
                Location = new System.Drawing.Point(125, 140)
            };
            Controls.Add(_OneDriveConfig);

            ewradiobutton1.CheckedChanged += new EventHandler(ewradiobutton1_CheckedChanged);
            ewradiobutton2.CheckedChanged += new EventHandler(ewradiobutton2_CheckedChanged);
        }

        #endregion Constructores

        private void SetReadOnlyTo(bool valor)
        {
            if (!EW_GLOBAL._EsEjecutable)
                return;

            txtServidor.ReadOnly = valor;
            nudPuerto.ReadOnly = valor;
            txtProxi.ReadOnly = valor;
            txtUsuario.ReadOnly = valor;
            txtPassword.ReadOnly = valor;
            txtCarpeta.ReadOnly = valor;
            btProbarConfiguracion.Enabled = !valor;
            chkActivo.Enabled = !valor;
            chkUseSSL.Enabled = !valor;
            chkValidateFTPSCert.Enabled = !valor && chkUseSSL.Checked;

            _OneDriveConfig._ReadOnly = valor;
       
            ewradiobutton1.Enabled = !_lReadOnly;
            ewradiobutton2.Enabled = !_lReadOnly;

            if (!_lReadOnly)
            {
                ewradiobutton2_CheckedChanged(ewradiobutton2, null);
            }

        }

        private void BtProbarConfiguracion_Click(object sender, EventArgs e)
        {
            ProbarConfiguracion();
        }
        public bool ProbarConfiguracion(bool final=false)
        {
            bool ret = false;
            if (!ValidarParametros(out string mensaje))
            {
                ShowMessage(mensaje);
                return ret;
            }

            var configuracionFtp = ObtenerConfiguracion();
            AsistenteOfflineBizRule bzr = DependencyInjector.Instance.Retrieve<AsistenteOfflineBizRule>();  
            bzr.IsFTP = true;
            bzr.ftp_user_data = configuracionFtp;
            

            if (OfflineUploader.Comprobar_Conexion(bzr, false))
            {
                _configuracionComprobada = configuracionFtp;
                _lComprobacionEjecutada = true;
                if (!final)
                {
                    ShowMessage("Prueba de sincronización FTP completada con éxito");
                }
                ret = true;
            }
            else
            { 
                ShowMessage("Prueba de sincronización FTP no completada" + Environment.NewLine + Environment.NewLine + bzr.ftp_user_data.error_message);
                bzr.ftp_user_data.error_message = "";
            }
            return ret;
        }


        private bool ValidarParametros(out string mensaje)
        {
            var parametrosOk = true;
            mensaje = string.Empty;

            if(string.IsNullOrWhiteSpace(_Negocio.Servidor))
            {
                parametrosOk = false;
                mensaje += "El servidor no puede estar en blanco" + Environment.NewLine; 
            }

            if (string.IsNullOrWhiteSpace(_Negocio.Usuario))
            {
                parametrosOk = false;
                mensaje += "El usuario no puede estar en blanco" + Environment.NewLine;
            }

            if (string.IsNullOrWhiteSpace(_Negocio.Password))
            {
                parametrosOk = false;
                mensaje += "El password no puede estar en blanco" + Environment.NewLine;
            }

            //Proxi, carpeta y puerto puede no requerir datos adicionales 

            return parametrosOk;
        }

        internal FtpUserData ObtenerConfiguracion()
        {
            var config = new FtpUserData
            {
                server = txtServidor.Text.TrimEnd(),
                user = txtUsuario.Text.TrimEnd(),
                password = txtPassword.Text.TrimEnd(),
                port = nudPuerto.Value,
                proxy = txtProxi.Text.TrimEnd(),
                rutaserv = txtCarpeta.Text.TrimEnd(),
                ftp_activo = chkActivo.Checked,
                use_ssl_tls = chkUseSSL.Checked,
                validate_server_cert = chkValidateFTPSCert.Checked,
            };
            return config;
        }

        //internal void EstablecerConfiguracion(FtpUserData config)
        //{
        //    txtServidor.Text = config.server.TrimEnd();
        //    txtUsuario.Text = config.user.TrimEnd();
        //    txtPassword.Text = config.password.TrimEnd();
        //    nudPuerto.Value = config.port;
        //    txtProxi.Text = config.proxy.TrimEnd();
        //    txtCarpeta.Text = config.rutaserv.TrimEnd();
        // }

        protected void ShowMessage(string message)
        {
            MessageBox.Show(message, "Configuración conexión FTP", MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1);
        }
        public void _Binding()
        {
            _Negocio.GetCadenaEncriptada(_Negocio._ConfiguracionFtp);

            if (ewradiobuttonGroup1.DataBindings["_SelectedItemIndexEx"] != null)
                ewradiobuttonGroup1.DataBindings[0].ReadValue();
            else
                ewradiobuttonGroup1.DataBindings.Add("_SelectedItemIndexEx", _Negocio, "_Conexion", true);

            if (txtServidor.DataBindings["Text"] != null)
                txtServidor.DataBindings[0].ReadValue();
            else
                txtServidor.DataBindings.Add("Text", _Negocio, "Servidor", true);

            if (nudPuerto.DataBindings["Value"] != null)
                nudPuerto.DataBindings[0].ReadValue();
            else
                nudPuerto.DataBindings.Add("Value", _Negocio, "Puerto", true);
            
            if (txtProxi.DataBindings["Text"] != null)
                txtProxi.DataBindings[0].ReadValue();
            else
                txtProxi.DataBindings.Add("Text", _Negocio, "Proxy", true);

            if (chkUseSSL.DataBindings["Checked"] != null)
                chkUseSSL.DataBindings[0].ReadValue();
            else
                chkUseSSL.DataBindings.Add("Checked", _Negocio, "Use_SSL_TLS", true);

            if (chkValidateFTPSCert.DataBindings["Checked"] != null)
                chkValidateFTPSCert.DataBindings[0].ReadValue();
            else
                chkValidateFTPSCert.DataBindings.Add("Checked", _Negocio, "Validate_Server_Cert", true);

            if (chkActivo.DataBindings["Checked"] != null)
                chkActivo.DataBindings[0].ReadValue();
            else
                chkActivo.DataBindings.Add("Checked", _Negocio, "FTP_Activo", true);

            if (txtUsuario.DataBindings["Text"] != null)
                txtUsuario.DataBindings[0].ReadValue();
            else
                txtUsuario.DataBindings.Add("Text", _Negocio, "Usuario", true);

            if (txtPassword.DataBindings["Text"] != null)
                txtPassword.DataBindings[0].ReadValue();
            else
                txtPassword.DataBindings.Add("Text", _Negocio, "Password", true);
            
            if (txtCarpeta.DataBindings["Text"] != null)
                txtCarpeta.DataBindings[0].ReadValue();
            else
                txtCarpeta.DataBindings.Add("Text", _Negocio, "CarpetaSrv", true);

            _OneDriveConfig._Negocio = _Negocio;
            _OneDriveConfig._Binding();
        }

        private void ewradiobutton2_CheckedChanged(object sender, EventArgs e)
        {
            ew.objetos.ewradiobutton radio = (ew.objetos.ewradiobutton)sender;
            if (radio.Checked)
            {
                if (!_lReadOnly)
                {
                    txtServidor.ReadOnly = true;
                    nudPuerto.ReadOnly = true;
                    txtProxi.ReadOnly = true;
                    txtUsuario.ReadOnly = true;
                    txtPassword.ReadOnly = true;
                    txtCarpeta.ReadOnly = true;
                    btProbarConfiguracion.Enabled = false;
                    chkActivo.Enabled = false;
                    chkUseSSL.Enabled = false;
                    chkValidateFTPSCert.Enabled = false;

                    _OneDriveConfig.Enabled = true;
                    _OneDriveConfig._BloquearControles(false); //Internamente invoca al _Refresh de o365 que habilita o no los diferentes controles
                }
            }
            else
            {
                _OneDriveConfig.Enabled = false;
            }
        }

        private void ewradiobutton1_CheckedChanged(object sender, EventArgs e)
        {
            ew.objetos.ewradiobutton radio = (ew.objetos.ewradiobutton)sender;
            if (radio.Checked)
            {
                if (!_lReadOnly)
                {
                    txtServidor.ReadOnly = false;
                    nudPuerto.ReadOnly = false;
                    txtProxi.ReadOnly = false;
                    txtUsuario.ReadOnly = false;
                    txtPassword.ReadOnly = false;
                    txtCarpeta.ReadOnly = false;
                    btProbarConfiguracion.Enabled = true;
                    chkActivo.Enabled = true;
                    chkUseSSL.Enabled = true;
                    chkValidateFTPSCert.Enabled = chkUseSSL.Checked;

                    _OneDriveConfig.Enabled = false;
                }
            }
        }

        private void txtCarpeta_Validating(object sender, System.ComponentModel.CancelEventArgs e)
        {
            string lcValor = txtCarpeta.Text.Trim();

            if (!string.IsNullOrWhiteSpace(lcValor) && lcValor != "/")
            {
                if (!lcValor.StartsWith("/"))
                {
                    lcValor = "/" + lcValor;
                }

                if (!lcValor.EndsWith("/"))
                {
                    lcValor = lcValor + "/";
                }
            }

            txtCarpeta.Text = lcValor;
        }

        private void chkUseSSL_CheckedChanged(object sender, EventArgs e)
        {
            if (chkUseSSL.Checked && chkUseSSL.Enabled)
                chkValidateFTPSCert.Enabled = true;
            else
                chkValidateFTPSCert.Enabled = false;
        }
    }

    public class ewradiobuttonGroupEx : ew.objetos.ewradiobuttonGroup
    {
        public int _SelectedItemIndexEx
        {
            get 
            {
                return _SelectedItemIndex - 1;
            }
            set 
            {
                _SelectedItemIndex = value+1;
            }
        }
    }
}