< Summary

Information
Class: FAU.Logica.Services.GradoService
Assembly: FAU.Logica
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.Logica/Services/GradoService.cs
Line coverage
91%
Covered lines: 73
Uncovered lines: 7
Coverable lines: 80
Total lines: 137
Line coverage: 91.2%
Branch coverage
94%
Covered branches: 34
Total branches: 36
Branch coverage: 94.4%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
ObtenerTodosAsync()100%11100%
CrearAsync()100%121293.93%
ActualizarAsync()91.66%252486.84%

File(s)

/home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.Logica/Services/GradoService.cs

#LineLine coverage
 1using FAU.DataAccess.Repositories;
 2using FAU.Entidades;
 3using FAU.Logica.DTOs;
 4
 5namespace FAU.Logica.Services;
 6
 7public class GradoService : IGradoService
 8{
 9    private readonly IGradoRepository _gradoRepository;
 10    private readonly IEscalafonRepository _escalafonRepository;
 11    private readonly IAuditoriaService _auditoriaService;
 12    private readonly ICurrentUserContext _currentUser;
 13
 1114    public GradoService(IGradoRepository gradoRepository, IEscalafonRepository escalafonRepository, IAuditoriaService au
 15    {
 1116        _gradoRepository = gradoRepository;
 1117        _escalafonRepository = escalafonRepository;
 1118        _auditoriaService = auditoriaService;
 1119        _currentUser = currentUser;
 1120    }
 21
 22    public async Task<IEnumerable<GradoDto>> ObtenerTodosAsync()
 23    {
 124        var grados = await _gradoRepository.ObtenerTodosAsync();
 325        return grados.Select(g => new GradoDto { Id = g.Id, Codigo = g.Codigo, Denominacion = g.Denominacion, EscalafonI
 126    }
 27
 28    public async Task<(bool Exito, GradoDto? Resultado, string? Error)> CrearAsync(string codigo, string denominacion, s
 29    {
 30        try
 31        {
 532            if (string.IsNullOrWhiteSpace(codigo))
 133                return (false, null, "El código es requerido");
 34
 435            if (string.IsNullOrWhiteSpace(denominacion))
 136                return (false, null, "La denominación es requerida");
 37
 338            if (await _gradoRepository.ExisteCodigoAsync(codigo.Trim()))
 139                return (false, null, "Ya existe un grado con ese código");
 40
 241            if (escalafonId.HasValue)
 42            {
 243                var escalafon = await _escalafonRepository.ObtenerPorIdAsync(escalafonId.Value);
 244                if (escalafon == null || !escalafon.Vigente)
 145                    return (false, null, "El escalafón no existe o no está vigente");
 46            }
 47
 148            var nuevo = new Grado
 149            {
 150                Codigo = codigo.Trim(),
 151                Denominacion = denominacion.Trim(),
 152                Orden = orden,
 153                EscalafonId = escalafonId,
 154                EsOficial = esOficial,
 155                EsSubalterno = esSubalterno,
 156                Vigente = vigente
 157            };
 58
 159            var creado = await _gradoRepository.CrearAsync(nuevo);
 60
 161            await _auditoriaService.LogAuditoriaAsync(
 162                usuarioId: _currentUser.UserId ?? 0,
 163                AccionEnum.CrearPersonal,
 164                ContextoEnum.Personal,
 165                host: _currentUser.Host,
 166                entidad: nameof(Grado),
 167                entidadId: creado.Id,
 168                detalle: new { operacion = "crear", id = creado.Id, codigo = creado.Codigo });
 69
 170            return (true, new GradoDto { Id = creado.Id, Codigo = creado.Codigo, Denominacion = creado.Denominacion, Esc
 71        }
 072        catch (Exception ex)
 73        {
 074            return (false, null, $"Error al crear grado: {ex.Message}");
 75        }
 576    }
 77
 78    public async Task<(bool Exito, GradoDto? Resultado, string? Error)> ActualizarAsync(long id, string? codigo, string?
 79    {
 80        try
 81        {
 582            var grado = await _gradoRepository.ObtenerPorIdAsync(id);
 583            if (grado == null)
 184                return (false, null, "Grado no encontrado");
 85
 486            var snapshotAntes = new { id = grado.Id, codigo = grado.Codigo };
 87
 488            if (!string.IsNullOrWhiteSpace(codigo))
 89            {
 190                var codigoNormalizado = codigo.Trim();
 191                if (!string.Equals(grado.Codigo, codigoNormalizado, StringComparison.Ordinal) && await _gradoRepository.
 192                    return (false, null, "Ya existe un grado con ese código");
 093                grado.Codigo = codigoNormalizado;
 094            }
 95
 396            if (!string.IsNullOrWhiteSpace(denominacion))
 197                grado.Denominacion = denominacion.Trim();
 98
 399            if (orden.HasValue)
 1100                grado.Orden = orden.Value;
 101
 3102            if (escalafonId.HasValue)
 103            {
 1104                var escalafon = await _escalafonRepository.ObtenerPorIdAsync(escalafonId.Value);
 1105                if (escalafon == null || !escalafon.Vigente)
 1106                    return (false, null, "El escalafón no existe o no está vigente");
 0107                grado.EscalafonId = escalafonId.Value;
 108            }
 109
 2110            if (esOficial.HasValue)
 1111                grado.EsOficial = esOficial.Value;
 112
 2113            if (esSubalterno.HasValue)
 1114                grado.EsSubalterno = esSubalterno.Value;
 115
 2116            if (vigente.HasValue)
 1117                grado.Vigente = vigente.Value;
 118
 2119            var actualizado = await _gradoRepository.ActualizarAsync(grado);
 120
 2121            await _auditoriaService.LogAuditoriaAsync(
 2122                usuarioId: _currentUser.UserId ?? 0,
 2123                AccionEnum.ActualizarPersonal,
 2124                ContextoEnum.Personal,
 2125                host: _currentUser.Host,
 2126                entidad: nameof(Grado),
 2127                entidadId: actualizado.Id,
 2128                detalle: new { operacion = "actualizar", antes = snapshotAntes, despues = new { id = actualizado.Id, cod
 129
 2130            return (true, new GradoDto { Id = actualizado.Id, Codigo = actualizado.Codigo, Denominacion = actualizado.De
 131        }
 0132        catch (Exception ex)
 133        {
 0134            return (false, null, $"Error al actualizar grado: {ex.Message}");
 135        }
 5136    }
 137}
Generated by: ReportGenerator 5.5.10.0
07/08/2026 - 05:14:32
GitHub | reportgenerator.io

Methods/Properties

.ctor(FAU.DataAccess.Repositories.IGradoRepository,FAU.DataAccess.Repositories.IEscalafonRepository,FAU.Logica.Services.IAuditoriaService,FAU.Logica.Services.ICurrentUserContext)
ObtenerTodosAsync()
CrearAsync()
ActualizarAsync()