TFS_ANTIGUO/TPAtesa_CuentasCobrar/CuentasCobrar.UI/Controllers/BancoController.cs

using CuentasCobrar.CORE.Exceptions;
using CuentasCobrar.UI.Helpers;
using CuentasCobrar.UI.Models;
using CuentasCobrar.UI.Models.Filters;
using CuentasCobrar.UI.Services.Interfaces;
using Microsoft.AspNetCore.Mvc;
using static CuentasCobrar.UI.Helpers.Enum;

namespace CuentasCobrar.UI.Controllers
{
    public class BancoController : BaseController
    {
        private readonly IBancoAPI _bancoAPI;
        private readonly IUsuarioAPI _usuarioAPI;


        public BancoController ( IUsuarioAPI usuarioAPI, IBancoAPI bancoAPI )
        {
            _usuarioAPI = usuarioAPI;
            _bancoAPI = bancoAPI;
        }

        public async Task<ActionResult> Index ( PaginacionFilterModel filtros )
        {
            List<BancoViewModel>? bancos = new List<BancoViewModel> ();
            try
            {
                var token = Request.Cookies["CookieToken"];
                if (token == null)
                {
                    string tokenUsuario = await CrearToken ( _usuarioAPI );
                    token = tokenUsuario;
                    CrearCookies ( tokenUsuario );
                }
                var rolesCookie = Request.Cookies["CookieRoles"];
                var listaRoles = new List<string> ( rolesCookie.Split ( "," ) );
                if (!listaRoles.Exists ( r => r == "ADMINISTRADOR" || r == "OPERATIVO" ))
                {
                    throw new AuthorizeException ( 403, "Usuario no autorizado" );
                }
                bancos = await _bancoAPI.ObtenerBancosPaginados ( token, filtros );
            }
            catch (Exception ex)
            {
                if (ex.GetType () == typeof ( AuthorizeException ))
                {
                    AuthorizeException excepcion = ex as AuthorizeException;
                    CustomNotification ( $"Error {excepcion.number}: {excepcion.Message}", TipoNotificacion.error, NotificationPosition.Center, "Usuario" );
                    return RedirectToAction ( "Index", "Home" );
                }
                else
                {
                    CustomNotification ( "Se produjo un error!", TipoNotificacion.error, NotificationPosition.Center, "Banco" );
                    return RedirectToAction ( "Index", "Home" );
                }
            }

            return View ( bancos );
        }

        public async Task<ActionResult> ActualizarBanco ( BancoViewModel banco, PaginacionFilterModel filtros )
        {
            bool respuesta = false;

            try
            {
                var token = Request.Cookies["CookieToken"];
                if (token == null)
                {
                    string tokenUsuario = await CrearToken ( _usuarioAPI );
                    token = tokenUsuario;
                    CrearCookies ( tokenUsuario );
                }
                if (ModelState.IsValid)
                {
                    respuesta = await _bancoAPI.ActualizarBanco ( token, banco );
                    if (respuesta)
                    {
                        CustomNotification ( "Se modificó el banco de manera exitosa", TipoNotificacion.success, NotificationPosition.Center, "Banco" );
                        return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );
                    }
                    else
                    {
                        CustomNotification ( "Se produjo un error!", TipoNotificacion.error, NotificationPosition.Center, "Banco" );
                        return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );
                    }
                }
                else
                {
                    ViewBag.Bancos = await _bancoAPI.ObtenerBancosPaginados ( token, filtros );
                    ViewBag.Filtros = filtros;
                    return View ( "Editar", banco );
                }
            }
            catch (Exception ex)
            {

                if (ex.GetType () == typeof ( AuthorizeException ))
                {
                    AuthorizeException excepcion = ex as AuthorizeException;
                    CustomNotification ( $"Error {excepcion.number}: {excepcion.Message}", TipoNotificacion.error, NotificationPosition.Center, "Usuario" );
                    return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );
                }
                else
                {
                    CustomNotification ( "Se produjo un error!", TipoNotificacion.error, NotificationPosition.Center, "Banco" );
                    return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );
                }
            }
        }


        public async Task<ActionResult> AgregarBanco ( BancoViewModel banco, PaginacionFilterModel filtros )
        {
            bool respuesta = false;
            try
            {
                var token = Request.Cookies["CookieToken"];
                if (token == null)
                {
                    string tokenUsuario = await CrearToken ( _usuarioAPI );
                    token = tokenUsuario;
                    CrearCookies ( tokenUsuario );
                }
                if (ModelState.IsValid)
                {
                    respuesta = await _bancoAPI.AgregarBanco ( token, banco );
                    if (respuesta)
                    {
                        CustomNotification ( "Se agregó el banco de manera exitosa", TipoNotificacion.success, NotificationPosition.Center, "Banco" );
                        return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );

                    }
                    else
                    {
                        CustomNotification ( "Se produjo un error!", TipoNotificacion.error, NotificationPosition.Center, "Banco" );
                        return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );

                    }
                }
                else
                {
                    ViewBag.Filtros = filtros;
                    return View ( "Agregar", banco );
                }
            }
            catch (Exception ex)
            {

                if (ex.GetType () == typeof ( AuthorizeException ))
                {
                    AuthorizeException excepcion = ex as AuthorizeException;
                    CustomNotification ( $"Error {excepcion.number}: {excepcion.Message}", TipoNotificacion.error, NotificationPosition.Center, "Usuario" );
                    return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );
                }
                else
                {
                    CustomNotification ( "Se produjo un error!", TipoNotificacion.error, NotificationPosition.Center, "Banco" );
                    return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );
                }
            }
        }


        public async Task EliminarBanco ( int id )
        {
            var token = Request.Cookies["CookieToken"];
            if (token == null)
            {
                string tokenUsuario = await CrearToken ( _usuarioAPI );
                token = tokenUsuario;
                CrearCookies ( tokenUsuario );
            }
            await _bancoAPI.EliminarBanco ( token, id );
        }

        public async Task<ActionResult> Editar ( int id, PaginacionFilterModel filtros )
        {
            BancoViewModel banco = new BancoViewModel ();
            try
            {
                var token = Request.Cookies["CookieToken"];
                if (token == null)
                {
                    string tokenUsuario = await CrearToken ( _usuarioAPI );
                    token = tokenUsuario;
                    CrearCookies ( tokenUsuario );
                }
                var rolesCookie = Request.Cookies["CookieRoles"];
                var listaRoles = new List<string> ( rolesCookie.Split ( "," ) );
                if (!listaRoles.Exists ( r => r == "ADMINISTRADOR" || r == "OPERATIVO" ))
                {
                    throw new AuthorizeException ( 403, "Usuario no autorizado" );
                }
                ViewBag.Bancos = await _bancoAPI.ObtenerBancosPaginados ( token, filtros );
                banco = await _bancoAPI.ObtenerBanco ( token, id );
            }
            catch (Exception ex)
            {
                if (ex.GetType () == typeof ( AuthorizeException ))
                {
                    AuthorizeException excepcion = ex as AuthorizeException;
                    CustomNotification ( $"Error {excepcion.number}: {excepcion.Message}", TipoNotificacion.error, NotificationPosition.Center, "Usuario" );
                    return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );
                }
                else
                {
                    CustomNotification ( "Se produjo un error!", TipoNotificacion.error, NotificationPosition.Center, "Banco" );
                    return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );
                }
            }

            return View ( banco );
        }

        public async Task<ActionResult> Agregar ( PaginacionFilterModel filtros )
        {
            try
            {
                var token = Request.Cookies["CookieToken"];
                if (token == null)
                {
                    string tokenUsuario = await CrearToken ( _usuarioAPI );
                    token = tokenUsuario;
                    CrearCookies ( tokenUsuario );
                }
                var rolesCookie = Request.Cookies["CookieRoles"];
                var listaRoles = new List<string> ( rolesCookie.Split ( "," ) );
                if (!listaRoles.Exists ( r => r == "ADMINISTRADOR" || r == "OPERATIVO" ))
                {
                    throw new AuthorizeException ( 403, "Usuario no autorizado" );
                }
                ViewBag.Bancos = await _bancoAPI.ObtenerBancosPaginados ( token, filtros );
            }
            catch (Exception ex)
            {
                if (ex.GetType () == typeof ( AuthorizeException ))
                {
                    AuthorizeException excepcion = ex as AuthorizeException;
                    CustomNotification ( $"Error {excepcion.number}: {excepcion.Message}", TipoNotificacion.error, NotificationPosition.Center, "Usuario" );
                    return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );
                }
                else
                {
                    CustomNotification ( "Se produjo un error!", TipoNotificacion.error, NotificationPosition.Center, "Banco" );
                    return RedirectToAction ( "Index", new RouteValueDictionary ( filtros ) );
                }
            }

            return View ();
        }

    }
}