Backups.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.IO;
using System.Data.SqlClient;

namespace sage.ew.db
{
    public class Backups
    {
        public string _Grupo
        {
            get
            {
                return _cGrupo;
            }
            set
            {
                _cGrupo = value;
            }
        }
        private string _cGrupo = string.Empty;

        public string _RutaLocal
        {
            get
            {
                return _cRutaLocal;
            }
            set
            {
                _cRutaLocal = value;
            }
        }
        private string _cRutaLocal = string.Empty;

        public string _Ejercicio
        {
            get
            {
                return _cEjercicio;
            }
            set
            {
                _cEjercicio = value;
            }
        }
        private string _cEjercicio = string.Empty;

        public string _ErrorMessage
        {
            get
            {
                return _cErrorMessage;
            }
            set
            {
                _cErrorMessage = value;
            }
        }
        private string _cErrorMessage = string.Empty;

        public string _GrupoOrigenBackup
        {
            get
            {
                return _c_GrupoOrigenBackup;
            }
            set
            {
                _c_GrupoOrigenBackup = value;
            }
        }
        private string _c_GrupoOrigenBackup = string.Empty;

        public string _Sufijo
        {
            get
            {
                return _cSufijo;
            }
            set
            {
                _cSufijo = value;
            }
        }
        private string _cSufijo = string.Empty;

        public List<string> _ListaDBRestauradas = new List<string>();

        public bool _LimpiarEjercicios { get; set; } = false;

        public List<string> _EjerciciosMantener { get; set; } = new List<string>();

        public List<string> _EjerciciosCopiados { get; set; } = new List<string>();

        #region DELEGADOS
        public delegate void _ActualizarEstadoProgreso(string tcEstado, int tnPorcentaje);

        public event _ActualizarEstadoProgreso _ActualizarEstado;
        #endregion


        public Backups()
        {
        }

        public Backups(string tcGrupo, string tcRutaLocal, string tcEjercicio, string tcGrupoBackup = "", string tcSufijoDB = "", bool tbLimpiarEjercicios = false, List<string> toEjerciciosMantener = null)
        {
            _Grupo = tcGrupo;
            _RutaLocal = tcRutaLocal;
            _Ejercicio = tcEjercicio;
            _GrupoOrigenBackup = tcGrupoBackup;
            _Sufijo = tcSufijoDB;
            _LimpiarEjercicios = tbLimpiarEjercicios;
            _EjerciciosMantener = toEjerciciosMantener;

            _ListaDBRestauradas = new List<string>();
        }        

        public void _BackupSageSys()
        {
            bool lbOk = true;

            //Comprobamos carpeta, sino la creamos
            if (!Directory.Exists(_RutaLocal))
                Directory.CreateDirectory(_RutaLocal);

            //Copia del SageSys
            lbOk = DB._DbBackup("EUROWINSYS", _RutaLocal);

            if (!lbOk)
            {
                _ErrorMessage = DB.Error_Message;
                throw new Exception("Error al ejecutar la copia de los datos: " + _ErrorMessage);
            }
        }

        public void _BackupBasesDatosGrupo()
        {
            bool lbOk = true;

            DataTable ldtEjercici = new DataTable();
            DataTable ldtModulos = new DataTable();
            string lcSql = string.Empty;

            //Comprobamos carpeta, sino la creamos
            if (!Directory.Exists(_RutaLocal))
                Directory.CreateDirectory(_RutaLocal);            

            string lcDbComunes = "COMU" + _Grupo;

            //Copia del comunes
            lbOk = DB._DbBackup(lcDbComunes, _RutaLocal);

            if (!lbOk)
            {
                _ErrorMessage = DB.Error_Message;
                throw new Exception("Error al ejecutar la copia de los datos: " + _ErrorMessage);
            }

            //Obtenemos las conexiones de gestion de este comunes
            lcSql = "select conexion, [any] as anyo from " + DB.SQLDatabaseReal(lcDbComunes, "EJERCICI");
            DB.SQLExec(lcSql, ref ldtEjercici);

            if (ldtEjercici != null && ldtEjercici.Rows.Count > 0)
            {                
                foreach (DataRow rowEjer in ldtEjercici.Rows)
                {
                    //Comprobamos si hay que copiar un ejercicio o todos                
                    if (_Ejercicio != "Todos")
                    {
                        if (Convert.ToString(rowEjer["anyo"]).Trim() == _Ejercicio.Trim())
                        {
                            lbOk = DB._DbBackup(Convert.ToString(rowEjer["conexion"]).Trim(), _RutaLocal);
                            if (!lbOk)
                            {
                                _ErrorMessage = DB.Error_Message;
                                throw new Exception("Error al ejecutar la copia de los datos: " + _ErrorMessage);
                            }
                            break;
                        }
                    }
                    else
                    {
                        if (DB.SQLDatabaseExistStrict(Convert.ToString(rowEjer["anyo"]).Trim())) //Bug 199477
                        {
                            lbOk = DB._DbBackup(Convert.ToString(rowEjer["conexion"]).Trim(), _RutaLocal);
                            if (!lbOk)
                            {
                                _ErrorMessage = DB.Error_Message;
                                throw new Exception("Error al ejecutar la copia de los datos: " + _ErrorMessage);
                            }
                            _EjerciciosCopiados.Add(Convert.ToString(rowEjer["anyo"]).Trim());
                        }                        
                    }
                }
            }       
            //Copia de los módulos
            lcSql = "select nom_conex from " + DB.SQLDatabaseReal(lcDbComunes, "MODULOS");
            DB.SQLExec(lcSql, ref ldtModulos);

            if (ldtModulos != null && ldtModulos.Rows.Count > 0)
            {
                foreach (DataRow rowModulo in ldtModulos.Rows)
                {
                    //Hacemos backup de cada uno de los modulos con el nombre de la conexion directamente
                    lbOk = DB._DbBackup(Convert.ToString(rowModulo["nom_conex"]).Trim(), _RutaLocal);
                    if (!lbOk)
                    {
                        _ErrorMessage = DB.Error_Message;
                        throw new Exception("Error al ejecutar la copia de los datos: " + _ErrorMessage);
                    }
                }
            }
        }

        public bool _RestoreBasesDatosGrupo()
        {
            bool llOk = true;
            DataTable ldtEjercici = new DataTable();
            DataTable ldtModulos = new DataTable();
            string lcSql = string.Empty;

            string lcDbComunes = "COMU" + _Grupo;
            string lcDbComunesOrigen = "COMU" + _GrupoOrigenBackup;

            _ActualizarMensajeProgreso("Limpiar bases de datos actuales", 20);
            
            llOk = LimpiarGrupoActual(lcDbComunes);

            _ActualizarMensajeProgreso("Restaurando Comunes: " + lcDbComunes + " ... ", 20);

            //Restauración del comunes            
            llOk = RestaurarComunes(lcDbComunesOrigen, lcDbComunes);            

            if (!llOk)
            {
                _ErrorMessage = DB.Error_Message;
                return false;
            }

            //Restauración de ejercicios
            llOk = RestaurarEjercicios(lcDbComunes);            

            //Restauración de los módulos
            llOk = RestaurarModulos(lcDbComunes);            
            

            _ActualizarMensajeProgreso("", 100);

            return llOk;
        }

        private bool LimpiarGrupoActual(string tcComunesGrupo)
        {
            DataTable ldtEjercici = new DataTable();
            DataTable ldtModulos = new DataTable();
            bool llOk = true;
            string lcSql;
                       
            //Obtener las bases de datos de gestion y modulos de la base de datos actual para tener la lista de bases de datos a borrar
            lcSql = "select conexion, [any] as anyo from " + DB.SQLDatabaseReal(tcComunesGrupo, "EJERCICI");
            DB.SQLExec(lcSql, ref ldtEjercici);

            if (ldtEjercici != null && ldtEjercici.Rows.Count > 0)
            {                
                foreach (DataRow rowEjer in ldtEjercici.Rows)
                {                    
                    if (_Ejercicio != "Todos")
                    {
                        //Task 181077: Si es una copia de ejercicio único, sólo limpiar los ejercicios posteriores y sólo si está marcado como _LimpiarEjercicios
                        if (Convert.ToString(rowEjer["anyo"]).Trim() == _Ejercicio
                        || (_LimpiarEjercicios && Convert.ToInt32(rowEjer["anyo"]) > Convert.ToInt32(_Ejercicio)))
                        {
                            _ActualizarMensajeProgreso("Eliminando Ejercicio: " + Convert.ToString(rowEjer["conexion"]).Trim() + " ... ", 20);
                            llOk = DB._DBRemove(new SqlConnection(DB.Conexion), Convert.ToString(rowEjer["conexion"]).Trim());
                        }
                    }
                    else
                    {
                        //Task 181077: Si estamos ante una copia de "Todos" ejercicios miramos si está marcado _LimpiarEjercicios y sólo en ese caso limpiar, sino dejarlos
                        if (_LimpiarEjercicios || (!_LimpiarEjercicios && !_EjerciciosMantener.Contains(Convert.ToString(rowEjer["anyo"]).Trim())))
                        {
                            _ActualizarMensajeProgreso("Eliminando Ejercicio: " + Convert.ToString(rowEjer["conexion"]).Trim() + " ... ", 20);
                            llOk = DB._DBRemove(new SqlConnection(DB.Conexion), Convert.ToString(rowEjer["conexion"]).Trim());
                        }
                    }                    
                }
            }            

            //Eliminación de los módulos
            lcSql = "select nom_conex from " + DB.SQLDatabaseReal(tcComunesGrupo, "MODULOS");
            DB.SQLExec(lcSql, ref ldtModulos);

            if (ldtModulos != null && ldtModulos.Rows.Count > 0)
            {
                foreach (DataRow rowModulo in ldtModulos.Rows)
                {
                    _ActualizarMensajeProgreso("Eliminando Módulo: " + Convert.ToString(rowModulo["nom_conex"]).Trim() + " ... ", 20);
                    llOk = DB._DBRemove(new SqlConnection(DB.Conexion), Convert.ToString(rowModulo["nom_conex"]).Trim());
                }
            }

            //Eliminar la base de datos de comunes
            llOk = DB._DBRemove(new SqlConnection(DB.Conexion), tcComunesGrupo);

            return llOk;

        }

        private bool RestaurarComunes(string tcDbComunesOrigen, string tcDbComunes)
        {
            bool llOk;

            llOk = Backups._DbRestore(tcDbComunesOrigen, tcDbComunes, _RutaLocal, GrupoempTools._UserPropBdGrNuevo);
            if (llOk)
            {
                _ListaDBRestauradas.Add(tcDbComunes);
            }

            return llOk;
        }

        private bool RestaurarEjercicios(string tcDbComunes)
        {
            bool llOk = true;
            string lcSql = string.Empty;
            string lcConexionNueva = string.Empty;
            DataTable ldtEjercici = new DataTable();

            //Obtenemos las conexiones de gestion del comunes restaurado
            lcSql = "select conexion, [any] as anyo from " + DB.SQLDatabaseReal(tcDbComunes, "EJERCICI");
            DB.SQLExec(lcSql, ref ldtEjercici);

            if (ldtEjercici != null && ldtEjercici.Rows.Count > 0)
            {
                foreach (DataRow rowEjer in ldtEjercici.Rows)
                {
                    //Comprobamos si hay que restaurar un ejercicio o todos
                    if (_Ejercicio != "Todos")
                    {
                        if (Convert.ToString(rowEjer["conexion"]).Trim().Length > 2)
                            lcConexionNueva = Convert.ToString(rowEjer["conexion"]).Trim().Substring(0, Convert.ToString(rowEjer["conexion"]).Trim().Length - 2) + _Sufijo;

                        if (Convert.ToString(rowEjer["anyo"]).Trim() == _Ejercicio.Trim())
                        {                            
                            if (Convert.ToString(rowEjer["conexion"]).Trim().Length > 2)
                                lcConexionNueva = Convert.ToString(rowEjer["conexion"]).Trim().Substring(0, Convert.ToString(rowEjer["conexion"]).Trim().Length - 2) + _Sufijo;
                            else
                            {
                                _ErrorMessage = "Error en la conexión de ejercicio";
                                return false;
                            }

                            _ActualizarMensajeProgreso("Restaurando Ejercicio: " + lcConexionNueva + " ... ", 50);

                            llOk = Backups._DbRestore(Convert.ToString(rowEjer["conexion"]).Trim(), lcConexionNueva, _RutaLocal, GrupoempTools._UserPropBdGrNuevo);
                            
                            if (!llOk)
                            {
                                _ErrorMessage = DB.Error_Message;
                                return false;
                            }

                            //Actualizar conexion de la base de datos de ejercici
                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcDbComunes, "EJERCICI") + " SET ruta = " + DB.SQLString(lcConexionNueva) + ", rutaser = " + DB.SQLString(lcConexionNueva) +
                                        ", conexion = " + DB.SQLString(lcConexionNueva) +
                                        " WHERE [any] = " + DB.SQLString(Convert.ToString(rowEjer["anyo"]).Trim());
                            DB.SQLExec(lcSql);
                            
                            //Bug 148848: A parte de marcar como predeterminado el que se restaura, hay que marcar sin predeterminado el resto de ejercicios
                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcDbComunes, "EJERCICI") +
                                    " SET predet = 0 ";                                    
                            DB.SQLExec(lcSql);

                            //Bug 124169: En el momento de restaurar cuando sólo se ha restaurado un ejercicio, marcamos dicho ejercicio como predeterminado en la tabla EJERCICI
                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcDbComunes, "EJERCICI") +
                                    " SET predet = 1 " +
                                    " WHERE [any] = " + DB.SQLString(_Ejercicio);
                            DB.SQLExec(lcSql);

                            //break;
                        }
                        else
                        {
                            //Task 147254: Puesto que ahora no borramos los otros ejercicios que haya quitamos la consulta de limpiar la tabla EJERCICI
                            //En su lugar comprobamos si la base de datos que no estamos restaurando existe en sqlserver y si no existe la quitamos de la tabla ejercici restaurada
                            if (!DB._SQLExisteBBDD(lcConexionNueva))
                            {
                                lcSql = "DELETE FROM " + DB.SQLDatabaseReal(tcDbComunes, "EJERCICI") +
                                        " WHERE [any] = " + DB.SQLString(Convert.ToString(rowEjer["anyo"]).Trim());
                                DB.SQLExec(lcSql);
                            }
                        }
                    }
                    else
                    {                        
                        if (Convert.ToString(rowEjer["conexion"]).Trim().Length > 2)
                            lcConexionNueva = Convert.ToString(rowEjer["conexion"]).Trim().Substring(0, Convert.ToString(rowEjer["conexion"]).Trim().Length - 2) + _Sufijo;
                        else
                        {
                            _ErrorMessage = "Error en la conexión de ejercicio";
                            return false;
                        }

                        //Bug 199477. Si ejercicios está null o vacío, como antes, restauramos (copias sin esta lista en metadatos).
                        //Si tiene un valor miramos si existe en la lista de copiados para restaurar su base de datos
                        if (_EjerciciosCopiados == null || _EjerciciosCopiados.Count == 0 ||_EjerciciosCopiados.Contains(Convert.ToString(rowEjer["anyo"]).Trim())) 
                        {
                            _ActualizarMensajeProgreso("Restaurando Ejercicio: " + lcConexionNueva + " ... ", 50);

                            llOk = Backups._DbRestore(Convert.ToString(rowEjer["conexion"]).Trim(), lcConexionNueva, _RutaLocal, GrupoempTools._UserPropBdGrNuevo);
                        }
                        else
                            llOk = true;
                        _ListaDBRestauradas.Add(lcConexionNueva);

                        if (!llOk)
                        {
                            _ErrorMessage = DB.Error_Message;
                            return false;
                        }

                        //Actualizar conexion de la base de datos de ejercici
                        lcSql = "UPDATE " + DB.SQLDatabaseReal(tcDbComunes, "EJERCICI") + " SET ruta = " + DB.SQLString(lcConexionNueva) + ", rutaser = " + DB.SQLString(lcConexionNueva) +
                                    ", conexion = " + DB.SQLString(lcConexionNueva) +
                                    " WHERE [any] = " + DB.SQLString(Convert.ToString(rowEjer["anyo"]).Trim());
                        DB.SQLExec(lcSql);
                    }
                }
            }

            return llOk;
        }

        public bool RestaurarModulos(string tcDbComunes)
        {
            bool llOk = true;
            string lcSql = string.Empty;
            DataTable ldtModulos = new DataTable();
            string lcConexionNueva = string.Empty;

            lcSql = "select nombre, nom_conex from " + DB.SQLDatabaseReal(tcDbComunes, "MODULOS");
            DB.SQLExec(lcSql, ref ldtModulos);

            if (ldtModulos != null && ldtModulos.Rows.Count > 0)
            {
                foreach (DataRow rowModulo in ldtModulos.Rows)
                {                    
                    if (Convert.ToString(rowModulo["nom_conex"]).Trim().Length > 2)
                        lcConexionNueva = Convert.ToString(rowModulo["nom_conex"]).Trim().Substring(0, Convert.ToString(rowModulo["nom_conex"]).Trim().Length - 2) + _Sufijo;
                    else
                    {
                        _ErrorMessage = "Error en la conexión de ejercicio";
                        return false;
                    }

                    _ActualizarMensajeProgreso("Restaurando Módulo: " + lcConexionNueva + " ... ", 80);

                    llOk = Backups._DbRestore(Convert.ToString(rowModulo["nom_conex"]).Trim(), lcConexionNueva, _RutaLocal, GrupoempTools._UserPropBdGrNuevo);

                    _ListaDBRestauradas.Add(lcConexionNueva);

                    if (!llOk)
                    {
                        _ErrorMessage = DB.Error_Message;
                        return false;
                    }

                    //Actualizar conexion de la base de datos de ejercici
                    lcSql = "UPDATE " + DB.SQLDatabaseReal(tcDbComunes, "MODULOS") + " SET nom_conex = " + DB.SQLString(lcConexionNueva) + ", tablas = " + DB.SQLString(lcConexionNueva) +                                
                                " WHERE nombre = " + DB.SQLString(Convert.ToString(rowModulo["nombre"]).Trim());
                    DB.SQLExec(lcSql);
                }
            }

            return llOk;
        }
        

        public static bool _DbRestore(string tcNombreBak, string tcNombreNuevo, string tcCarpetaBackup, string tcPropietario)
        {
            string lcRutaDatosBd = string.Empty;

            //Usar este método que ya directamente nos retorna la ruta de los ficheros de base de datos de este servidor. Necesario cuando queramos restaurar copias
            //de grupos no existentes
            if (!DB.DbRutaBaseDatos())
            {
                DB.Error_Message = "No se ha podido averiguar la ruta física de los archivos de la base de datos. Error: " + DB.Error_Message;
                return false;
            }
            else
                lcRutaDatosBd = System.IO.Path.GetDirectoryName(DB._RutaBaseDatos);

            return DB._DbRestore(tcNombreBak, tcNombreNuevo, tcCarpetaBackup, tcPropietario, lcRutaDatosBd);
        }

        private void _ActualizarMensajeProgreso(string tcMensaje, int tnPorcentaje)
        {
            if (_ActualizarEstado != null)
                _ActualizarEstado(tcMensaje, tnPorcentaje);
        }        
    }
}