Apigateway/Microservicios/MsUsuarios/Controllers/PerfilesController.cs

using MSAdminUsuarios.Context;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MSAdminUsuarios.Dto;
using MSAdminUsuarios.Models;

namespace MSAdminUsuarios.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class PerfilesController : ControllerBase
    {
        private readonly ModelContext _context;

        public PerfilesController(ModelContext context)
        {
            _context = context;
        }

        [HttpGet]
        public async Task<IActionResult> GetPerfiles()
        {
            try
            {
                //List<PERFIL> consulta = await _context.PERFILESMs.OrderBy(p => p.NU_PK_PFL).Where(p=>p.BL_ESTADO_PFL > 0).ToListAsync();

                List<PERFIL> consulta = await _context.PERFILESMs.OrderBy(p => p.NU_PK_PFL).Where(p => p.BL_ESTADO_PFL >= 0).ToListAsync();

                //var consulta = from dm in _context.PERFILESMs
                //               where dm.BL_ESTADO_PFL>=0
                //               orderby dm.NU_PK_PFL ascending
                //               select dm;

                return Ok(consulta);
            }
            catch (Exception ex)
            {
                return BadRequest(ex);
            }
        }

        [HttpPost]
        public async Task<IActionResult> GuardarPerfiles(PERFIL guardado)
        {
            try
            {

                if (guardado == null) return ValidationProblem();

                if (guardado.TX_UUID_PFL == null)
                {
                    Guid uuid = Guid.NewGuid();
                    var UUID = uuid.ToString();
                    guardado.TX_UUID_PFL = UUID;
                }

                _context.PERFILESMs.Add(guardado);
                await _context.SaveChangesAsync();
                return Ok();

            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpPatch]
        public async Task<IActionResult> EditarPerfiles(PERFIL editado)
        {
            try
            {
                if (editado == null) return ValidationProblem();

                var existe = _context.PERFILESMs.Find(editado.NU_PK_PFL);

                if (existe == null)
                {
                    return BadRequest("Perfil no encontrado");
                }

                existe.TX_PERFIL_PFL = editado.TX_PERFIL_PFL;
                existe.NU_ROL_PFL = editado.NU_ROL_PFL;
                existe.BL_ESTADO_PFL = editado.BL_ESTADO_PFL;

                _context.PERFILESMs.Update(existe);
                await _context.SaveChangesAsync();
                return Ok();
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpPost("PerfilPermisos")]
        public async Task<IActionResult> PostPerfilPermisos(PerfilPermisosDTO nuevo)
        {
            ErrorModel _errorModel = new ErrorModel();
            using (var transaccion = _context.Database.BeginTransaction())
            {
                try
                {
                    if (nuevo == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Sin datos a guardar.");
                        return Conflict(_errorModel);
                    }

                    transaccion.CreateSavepoint("InicioCreacionPerfilPermisos");

                    if (nuevo.perfil == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Sin perfil a guardar.");
                        return Conflict(_errorModel);
                    }

                    if (nuevo.perfil.TX_UUID_PFL == null)
                    {
                        Guid uuid = Guid.NewGuid();
                        var UUID = uuid.ToString();
                        nuevo.perfil.TX_UUID_PFL = UUID;
                        _context.PERFILESMs.Add(nuevo.perfil);
                        await _context.SaveChangesAsync();
                    }
                    else
                    {
                        PERFIL? existe = _context.PERFILESMs.FirstOrDefault(prfl => prfl.TX_UUID_PFL == nuevo.perfil.TX_UUID_PFL);
                        if (existe == null)
                        {
                            _errorModel.error = true;
                            _errorModel.cuerpo.Add("El perfil no existe.");
                            return Conflict(_errorModel);
                        }

                        existe.TX_PERFIL_PFL = nuevo.perfil.TX_PERFIL_PFL;
                        existe.NU_ROL_PFL = nuevo.perfil.NU_ROL_PFL;
                        existe.BL_ESTADO_PFL = nuevo.perfil.BL_ESTADO_PFL;

                        _context.PERFILESMs.Update(existe);
                        await _context.SaveChangesAsync();
                    }

                    PERFIL? perfilCreado = await _context.PERFILESMs.FirstOrDefaultAsync(prfl => prfl.TX_UUID_PFL == nuevo.perfil.TX_UUID_PFL);

                    if (nuevo.permisos != null && perfilCreado != null)
                    {
                        // Se ordena los permisos enviados para agregar los padres primero
                        List<PERMISO> permisosOrdenados = nuevo.permisos.OrderBy(p => p.NU_FK_MS).ToList();
                        // Se cambia a estado 0 todos los perfiles por usuario existentes
                        List<PERMISO> permisosExistentes = _context.PERMISOSMs.Where(x => x.BL_ESTADO_PMS == 1 && x.NU_FK_PFL == perfilCreado.NU_PK_PFL).ToList();
                        // Se inactivan los permisos existentes
                        foreach (var permiso in permisosExistentes)
                        {
                            permiso.BL_ESTADO_PMS = 0;
                        }
                        _context.PERMISOSMs.UpdateRange(permisosExistentes);
                        await _context.SaveChangesAsync();
                        // Se recorre los nuevos permisos ordenados por FK_MS
                        int idxPermisoNuevo = (-2) * permisosOrdenados.Count();
                        foreach (PERMISO permiso in permisosOrdenados)
                        {
                            if (permiso != null)
                            {
                                MICROSERVICIO? msSeleccionado = _context.MICROSERVICIOs.FirstOrDefault(m => m.NU_PK_MS == permiso.NU_FK_MS);
                                if (msSeleccionado != null) 
                                {
                                    if (msSeleccionado.NU_PADRE_MS != null)
                                    {
                                        PERMISO? permisoPadre = _context.PERMISOSMs.FirstOrDefault(pm => pm.NU_FK_PFL == perfilCreado.NU_PK_PFL && pm.NU_FK_MS == msSeleccionado.NU_PADRE_MS);
                                        if (permisoPadre != null)
                                        {
                                            permisoPadre.BL_ESTADO_PMS = 1;
                                            _context.Update(permisoPadre);
                                            await _context.SaveChangesAsync();
                                        }
                                        else
                                        {
                                            PERMISO nuevoPermisoPadre = new PERMISO
                                            {
                                                NU_PK_PMS = idxPermisoNuevo,
                                                NU_FK_PFL = perfilCreado.NU_PK_PFL,
                                                NU_FK_MS = msSeleccionado.NU_PADRE_MS,
                                                BL_ESTADO_PMS = 1
                                            };
                                            _context.PERMISOSMs.Add(nuevoPermisoPadre);
                                            await _context.SaveChangesAsync();
                                            idxPermisoNuevo--;
                                        }
                                    }

                                    PERMISO? existe = _context.PERMISOSMs.FirstOrDefault(pm => pm.NU_FK_PFL == perfilCreado.NU_PK_PFL && pm.NU_FK_MS == permiso.NU_FK_MS);

                                    if (existe != null)
                                    {
                                        existe.BL_ESTADO_PMS = 1;
                                        _context.Update(existe);
                                        await _context.SaveChangesAsync();
                                    }
                                    else
                                    {
                                        permiso.BL_ESTADO_PMS = 1;
                                        permiso.NU_FK_PFL = perfilCreado.NU_PK_PFL;
                                        _context.PERMISOSMs.Add(permiso);
                                        await _context.SaveChangesAsync();
                                    }
                                }
                            }
                        }

                        /*List<PERMISO> permisosEliminados = _context.PERMISOSMs.Where(pm => pm.NU_FK_PFL == perfilCreado.NU_PK_PFL && pm.BL_ESTADO_PMS == 0).ToList();
                        _context.PERMISOSMs.RemoveRange(permisosEliminados);
                        await _context.SaveChangesAsync();*/

                    }

                    transaccion.Commit();

                    _errorModel.error = false;
                    _errorModel.cuerpo.Add("Perfil creado correctamente");
                    return Ok(_errorModel);
                }
                catch (Exception e)
                {
                    transaccion.RollbackToSavepoint("InicioCreacionPerfilPermisos");
                    return BadRequest(e.Message);
                }
            }
        }

    }
}