RgpdComunicadosOperation.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using sage.ew.interficies;
using sage.addons.rgpd.Negocio.Mantes;
using System.Data;
using sage.ew.global;
using sage.ew.db;
using sage.addons.rgpd.Negocio.Interficies;

namespace sage.addons.rgpd.Negocio
{
    internal class RgpdComunicadosOperation
    {
        private static IRgpdComunicadosOperationProvider _ComunicadosManager
        {
            get
            {
                if (_oComunicadosManager == null)
                    _oComunicadosManager = getComunicadorsOperationProvider();
                return _oComunicadosManager;
            }
            set { _oComunicadosManager = value; }
        }
        private static IRgpdComunicadosOperationProvider _oComunicadosManager = null;


        private static IRgpdComunicadosOperationProvider getComunicadorsOperationProvider()
        {
            return new RgpdComunicadosManagerFiltrado(); //RgpdComunicadosManager();
            //return new RgpdComunicadosOperationsProviderTest();
        }

        internal static IRespuestaComunicado _MandarComunicadoDeSolicitudConsentimiento(object sender, string tcRutaFichero = "")
        {
            if (_ComunicadosManager != null)
            {
                return _ComunicadosManager._RgpdEnviarComunicado(eTipoPlantilla.RecogidaDatos.__ToSolicitudComunicado(sender, tcRutaFichero));
            }
            else
                return null;
        }

        internal static IRespuestaComunicado _MandarComunicadoDeConfirmacionSolicitudSupresion(object sender, string tcRutaFichero = "")
        {
            if (_ComunicadosManager != null)
            {
                return _ComunicadosManager._RgpdEnviarComunicado(eTipoPlantilla.Supresion.__ToSolicitudComunicado(sender, tcRutaFichero));
            }
            else
                return null;
        }

        internal static IRespuestaComunicado _MandarComunicadoDeNotificacionDeAcceso(object sender, string tcRutaFichero = "")
        {
            if (_ComunicadosManager != null)
            {
                return _ComunicadosManager._RgpdEnviarComunicado(eTipoPlantilla.Acceso.__ToSolicitudComunicado(sender, tcRutaFichero));
            }
            else
                return null;
        }

        internal static IRespuestaComunicado _MandarComunicadoDeEmisionPortabilidad(object sender, string tcRutaFichero = "")
        {
            if (_ComunicadosManager != null)
            {
                return _ComunicadosManager._RgpdEnviarComunicado(eTipoPlantilla.Portabilidad.__ToSolicitudComunicado(sender, tcRutaFichero));
            }
            else
                return null;
        }

        internal static IRespuestaProceso _ComunicadoMasivoSolicitudConsentimiento(string tcCodigoEntidad, IEnumerable<string> tlisCodigoInstancias)
        {
            //Datos generales para el comunicado
            ISolicitudComunicado loSolicitud = new RgpdSolicitudComunicado();
            loSolicitud._NombreOrigen = eTipoPlantilla.RecogidaDatos.__ObtenerNombreOrigen();
            loSolicitud._CodigoPlantilla = eTipoPlantilla.RecogidaDatos.__ObtenerPlantilla();

            //Datos de tratamientos
            List<ManteExtEntidades> lisInstancias = new List<ManteExtEntidades>();
            List<IMante> lisInstanciasMante = new List<IMante>();

            //Recupero todas las instancias de tratamientos de entidades
            tlisCodigoInstancias.ToList().ForEach(loCodigoInstancia =>lisInstancias.Add(new ManteExtEntidades(tcCodigoEntidad, loCodigoInstancia.TrimEnd())));
            
            //Ordeno por código de instacia
            lisInstancias = lisInstancias.OrderBy(loEle => loEle._CodigoInstancia).ToList();

            //No es necesario => El Manager de comunicados esta decorado con una validación de permiso
            //lisInstancias = lisInstancias.Where(loEle => loEle._NoEnviarComunicados == false).ToList(); 

            //Recupero los mantenimientos
            lisInstancias.ForEach(loTratamiento => lisInstanciasMante.Add(loTratamiento._Mante));
            
            //Asigno los mantenimientos a la solicitud
            loSolicitud._Mantenimientos = lisInstanciasMante;

            //Invoco a los comunicados
            IRespuestaComunicado loRespuesta = _ComunicadosManager._RgpdEnviarComunicado(loSolicitud);

            //Creamos una instancia de respuesta
            ResultadoProceso loResultadoProceso = new ResultadoProceso();

            if (loRespuesta._Ejecutado) //Si se ha procesado
            {
                //Ahora debo procesar los ficheros de respuesta
                if (lisInstancias.Count == loRespuesta._RutasFicheros.Count())
                {
                    OperationBroker loBrokerOperaciones = new OperationBroker();
                    string lcFicherosNoRecibidos = string.Empty;
                    bool llErroresPresentes = false;

                    //Creamos las operaciones
                    foreach (ManteExtEntidades loInstanciaEntidad in lisInstancias)
                    {
                        int lnIndex = lisInstancias.FindIndex(loEle => loEle == loInstanciaEntidad);
                        string lcRuta = loRespuesta._RutasFicheros.ElementAt(lnIndex);

                        if (String.IsNullOrWhiteSpace(lcRuta))
                        {
                            llErroresPresentes = true;
                            lcFicherosNoRecibidos += "No se ha generado fichero para " + loInstanciaEntidad._CodigoInstancia + Environment.NewLine;
                        }
                        else
                        {
                            loBrokerOperaciones._AddOperacion(new OperationAdjuntarSolicitudConsentimiento(loInstanciaEntidad, lcRuta));
                        }
                    }
                    loBrokerOperaciones._EjecutarOperaciones();

                    loResultadoProceso._Estado = llErroresPresentes ? eResultadoProceso.CompletadoConErrores : eResultadoProceso.CompletadoCorrectamente;
                    loResultadoProceso._DetallesDelProceso = lcFicherosNoRecibidos;
                }
                else
                {
                    loResultadoProceso._Estado = eResultadoProceso.Error;
                    loResultadoProceso._DetallesDelProceso = "La solicitud no se ha completado correctamente, los ficheros generados no concuerdan con las solicitudes.";
                    //Número de ficheros no concordante
                    //ew.functions.FUNCTIONS._MessageBox("La solicitud no se ha completado correctamente, los ficheros generados no concuerdan con las solicitudes.", caption: "RGPD Comunicados");
                }
            }
            else 
            {
                loResultadoProceso._Estado = eResultadoProceso.Error;
                loResultadoProceso._DetallesDelProceso = "La solicitud no se ha podido completar: " +
                                                          Environment.NewLine + Environment.NewLine + loRespuesta._MessageError;

                //ew.functions.FUNCTIONS._MessageBox("La solicitud no se ha podido completar, los comunicados indican lo siguiente: " + 
                //    Environment.NewLine + Environment.NewLine + loRespuesta._MessageError, caption: "RGPD Comunicados");
            }

            return loResultadoProceso;
        }

        private bool laEntidadPuedeRecibirComunicados(object toSender)
        {
            bool puedeRecibirComunicados = true;
            if(toSender is ManteExtEntidades)
            {
                puedeRecibirComunicados = ((ManteExtEntidades)toSender)._NoEnviarComunicados;  
            }
            return puedeRecibirComunicados;
        }
    }

    internal class ResultadoProceso : IRespuestaProceso
    {
        public eResultadoProceso _Estado
        {
            get { return estadoProceso; }
            set { estadoProceso = value; }
        }
        private eResultadoProceso estadoProceso = eResultadoProceso.Indeterminado;

        public string _DetallesDelProceso
        {
            get { return _cDetallesDelProceso; }
            set { _cDetallesDelProceso = value; }
        }
        private string _cDetallesDelProceso = string.Empty;

        public ResultadoProceso() { }
    }


    internal class TipoPlantillaInfoAttribute : Attribute
    {

        public TipoPlantillaInfoAttribute(string tcNombreOrigen, string tcPlantillaPorDefecto, string tcCampoPlantilla)
        {
            SetProperties(tcNombreOrigen, tcPlantillaPorDefecto, tcCampoPlantilla);
        }

        private void SetProperties(string tcNombreOrigen, string tcPlantillaPorDefecto, string tcCampoPlantilla)
        {
            this._NombreOrigen = tcNombreOrigen;
            this._PlantillaPorDefecto = tcPlantillaPorDefecto;
            this._CampoPlantillaEspecifica = tcCampoPlantilla;
        }

        public string _NombreOrigen { get; private set; }
        public string _PlantillaPorDefecto { get; private set; }
        public string _CampoPlantillaEspecifica { get; private set; }
    }

    internal static class EnumExtensions
    {
        public static TAttribute __GetAttribute<TAttribute>(this eTipoPlantilla value)
            where TAttribute : Attribute
        {
            var type = value.GetType();
            var name = Enum.GetName(type, value);
            return type.GetField(name) // I prefer to get attributes this way
                .GetCustomAttributes(false)
                .OfType<TAttribute>()
                .SingleOrDefault();
        }
    }

    internal static class TipoPlantillaExtensions
    {
        public static string __ObtenerNombreOrigen(this eTipoPlantilla p)
        {
            var attr = p.__GetAttribute<TipoPlantillaInfoAttribute>();

            return attr._NombreOrigen;
        }

        public static string __ObtenerNombreCampoPlantilla(this eTipoPlantilla p)
        {
            var attr = p.__GetAttribute<TipoPlantillaInfoAttribute>();

            return attr._CampoPlantillaEspecifica;
        }

        public static string __ObtenerCodigoPlantillaPorDefecto(this eTipoPlantilla p)
        {
            var attr = p.__GetAttribute<TipoPlantillaInfoAttribute>();

            return attr._PlantillaPorDefecto;
        }

        public static string __ObtenerPlantilla(this eTipoPlantilla p)
        {
            //Empresa actual
            string lcEmpresaActual = DB.SQLString(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa", "")));
            string lcCampo = p.__ObtenerNombreCampoPlantilla();
            string lcDefaultValue = p.__ObtenerCodigoPlantillaPorDefecto();

            //Recupero los datos por empresa
            DataTable ldtDatos = new DataTable();

            //Es un query que devuelve siempre valor si hay registro (con o sin valor informado)
            string lcSQL = "SELECT TOP(1) " + lcCampo + " AS PLANTILLA FROM " + DB.SQLDatabase("RGPD", "DELEGADOS") +
                           " WHERE EMPRESA = " + lcEmpresaActual + " AND " + lcCampo + " != '' " +
                           "UNION " +
                           "SELECT TOP(1) " + DB.SQLString(lcDefaultValue) + " AS PLANTILLA FROM " + DB.SQLDatabase("RGPD", "DELEGADOS") +
                           " WHERE EMPRESA = " + lcEmpresaActual + " AND " + lcCampo + " = '' ";

            if (DB.SQLExec(lcSQL, ref ldtDatos) && ldtDatos.Rows.Count > 0)
                return Convert.ToString(ldtDatos.Rows[0]["PLANTILLA"]).TrimEnd();

            return lcDefaultValue;
        }

        public static ISolicitudComunicado __ToSolicitudComunicado(this eTipoPlantilla tePlantilla, object toSender, string tcRutaFichero = "")
        {
            RgpdSolicitudComunicado loSolicitud = new RgpdSolicitudComunicado(toSender as ManteExtEntidades);
            loSolicitud._CodigoPlantilla = tePlantilla.__ObtenerPlantilla();
            loSolicitud._NombreOrigen = tePlantilla.__ObtenerNombreOrigen();
            if (!String.IsNullOrWhiteSpace(tcRutaFichero))
                loSolicitud._RutasFicheros = new List<string>() { tcRutaFichero };
            return loSolicitud;
        }
    }
}