< 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
73%
Covered lines: 59
Uncovered lines: 21
Coverable lines: 80
Total lines: 137
Line coverage: 73.7%
Branch coverage
58%
Covered branches: 21
Total branches: 36
Branch coverage: 58.3%
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%210%
CrearAsync()91.66%121290.9%
ActualizarAsync()41.66%592460.52%

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
 614    public GradoService(IGradoRepository gradoRepository, IEscalafonRepository escalafonRepository, IAuditoriaService au
 15    {
 616        _gradoRepository = gradoRepository;
 617        _escalafonRepository = escalafonRepository;
 618        _auditoriaService = auditoriaService;
 619        _currentUser = currentUser;
 620    }
 21
 22    public async Task<IEnumerable<GradoDto>> ObtenerTodosAsync()
 23    {
 024        var grados = await _gradoRepository.ObtenerTodosAsync();
 025        return grados.Select(g => new GradoDto { Id = g.Id, Codigo = g.Codigo, Denominacion = g.Denominacion, EscalafonI
 026    }
 27
 28    public async Task<(bool Exito, GradoDto? Resultado, string? Error)> CrearAsync(string codigo, string denominacion, s
 29    {
 30        try
 31        {
 432            if (string.IsNullOrWhiteSpace(codigo))
 133                return (false, null, "El código es requerido");
 34
 335            if (string.IsNullOrWhiteSpace(denominacion))
 036                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        }
 476    }
 77
 78    public async Task<(bool Exito, GradoDto? Resultado, string? Error)> ActualizarAsync(long id, string? codigo, string?
 79    {
 80        try
 81        {
 282            var grado = await _gradoRepository.ObtenerPorIdAsync(id);
 283            if (grado == null)
 184                return (false, null, "Grado no encontrado");
 85
 186            var snapshotAntes = new { id = grado.Id, codigo = grado.Codigo };
 87
 188            if (!string.IsNullOrWhiteSpace(codigo))
 89            {
 090                var codigoNormalizado = codigo.Trim();
 091                if (!string.Equals(grado.Codigo, codigoNormalizado, StringComparison.Ordinal) && await _gradoRepository.
 092                    return (false, null, "Ya existe un grado con ese código");
 093                grado.Codigo = codigoNormalizado;
 094            }
 95
 196            if (!string.IsNullOrWhiteSpace(denominacion))
 197                grado.Denominacion = denominacion.Trim();
 98
 199            if (orden.HasValue)
 0100                grado.Orden = orden.Value;
 101
 1102            if (escalafonId.HasValue)
 103            {
 0104                var escalafon = await _escalafonRepository.ObtenerPorIdAsync(escalafonId.Value);
 0105                if (escalafon == null || !escalafon.Vigente)
 0106                    return (false, null, "El escalafón no existe o no está vigente");
 0107                grado.EscalafonId = escalafonId.Value;
 108            }
 109
 1110            if (esOficial.HasValue)
 0111                grado.EsOficial = esOficial.Value;
 112
 1113            if (esSubalterno.HasValue)
 0114                grado.EsSubalterno = esSubalterno.Value;
 115
 1116            if (vigente.HasValue)
 0117                grado.Vigente = vigente.Value;
 118
 1119            var actualizado = await _gradoRepository.ActualizarAsync(grado);
 120
 1121            await _auditoriaService.LogAuditoriaAsync(
 1122                usuarioId: _currentUser.UserId ?? 0,
 1123                AccionEnum.ActualizarPersonal,
 1124                ContextoEnum.Personal,
 1125                host: _currentUser.Host,
 1126                entidad: nameof(Grado),
 1127                entidadId: actualizado.Id,
 1128                detalle: new { operacion = "actualizar", antes = snapshotAntes, despues = new { id = actualizado.Id, cod
 129
 1130            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        }
 2136    }
 137}
Generated by: ReportGenerator 5.5.10.0
06/07/2026 - 20:24:34
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()