< Summary

Information
Class: FAU.Logica.Services.CompPersonal048018Service
Assembly: FAU.Logica
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.Logica/Services/CompPersonal048018Service.cs
Line coverage
88%
Covered lines: 114
Uncovered lines: 15
Coverable lines: 129
Total lines: 193
Line coverage: 88.3%
Branch coverage
68%
Covered branches: 22
Total branches: 32
Branch coverage: 68.7%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
ObtenerPaginadoAsync()0%620%
ObtenerPorIdAsync()0%620%
CrearAsync()87.5%88100%
ActualizarAsync()83.33%66100%
DarBajaAsync()83.33%66100%
NormalizarCedula(...)50%4475%
RedondearImporte(...)100%11100%
ValidarImporte(...)100%22100%
UsuarioValido(...)50%22100%
MapearDto(...)100%11100%

File(s)

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

#LineLine coverage
 1using System.Text.RegularExpressions;
 2using FAU.DataAccess.Repositories;
 3using FAU.Entidades;
 4using FAU.Logica.DTOs;
 5using FAU.Logica.Validadores;
 6
 7namespace FAU.Logica.Services;
 8
 9public class CompPersonal048018Service : ICompPersonal048018Service
 10{
 11    private readonly ICompPersonal048018Repository _repositorio;
 12    private readonly IPersonalRepository _repositorioPersonal;
 13    private readonly IAuditoriaService _auditoria;
 14
 1215    public CompPersonal048018Service(
 1216        ICompPersonal048018Repository repositorio,
 1217        IPersonalRepository repositorioPersonal,
 1218        IAuditoriaService auditoria)
 19    {
 1220        _repositorio = repositorio;
 1221        _repositorioPersonal = repositorioPersonal;
 1222        _auditoria = auditoria;
 1223    }
 24
 25    public async Task<PagedResult<CompPersonal048018Dto>> ObtenerPaginadoAsync(
 26        int pagina,
 27        int tamano,
 28        string? busqueda,
 29        string? estado)
 30    {
 031        pagina = Math.Max(1, pagina);
 032        tamano = Math.Clamp(tamano, 1, 100);
 33
 034        var (items, total) = await _repositorio.ObtenerPaginadoAsync(pagina, tamano, busqueda, estado);
 35
 036        return new PagedResult<CompPersonal048018Dto>
 037        {
 038            Items = items.Select(MapearDto),
 039            Page = pagina,
 040            PageSize = tamano,
 041            TotalCount = total
 042        };
 043    }
 44
 45    public async Task<CompPersonal048018Dto?> ObtenerPorIdAsync(long id)
 46    {
 047        var entidad = await _repositorio.ObtenerPorIdAsync(id);
 048        return entidad is null ? null : MapearDto(entidad);
 049    }
 50
 51    public async Task<CompPersonal048018Dto> CrearAsync(
 52        CrearCompPersonal048018Request request,
 53        long usuarioId,
 54        string? host)
 55    {
 1456        ValidarImporte(request.Importe);
 1357        var cedula = NormalizarCedula(request.CedulaTitular);
 1358        var relacion = await _repositorioPersonal.GetByCedulaAsync(cedula)
 1359            ?? throw new ArgumentException($"No se encontró personal activo con cédula {cedula}.");
 60
 1261        var existente = await _repositorio.ObtenerActivoPorPersonaAsync(relacion.PersonaId);
 1262        if (existente is not null)
 163            throw new InvalidOperationException(
 164                "La persona ya tiene una Compensación Personal (048.018) activa. Dela de baja antes de cargar una nueva.
 65
 1166        var entidad = new CompPersonal048018
 1167        {
 1168            PersonaId = relacion.PersonaId,
 1169            Importe = RedondearImporte(request.Importe),
 1170            Estado = "activo",
 1171            VigenteDesde = (request.VigenteDesde ?? DateTime.Today).Date,
 1172            CreadoPor = UsuarioValido(usuarioId),
 1173            CreadoEn = DateTime.Now
 1174        };
 75
 1176        await _repositorio.CrearAsync(entidad);
 1177        await _auditoria.LogAuditoriaAsync(
 1178            usuarioId,
 1179            AccionEnum.CrearCompPersonal,
 1180            ContextoEnum.Compensaciones,
 1181            host,
 1182            nameof(CompPersonal048018),
 1183            entidad.Id,
 1184            new
 1185            {
 1186                entidad.PersonaId,
 1187                Cedula = cedula,
 1188                entidad.Importe,
 1189                entidad.VigenteDesde
 1190            });
 91
 1192        var completo = await _repositorio.ObtenerPorIdAsync(entidad.Id)
 1193            ?? throw new InvalidOperationException("No fue posible recuperar la Compensación Personal creada.");
 1194        return MapearDto(completo);
 1195    }
 96
 97    public async Task<CompPersonal048018Dto> ActualizarAsync(
 98        long id,
 99        ActualizarCompPersonal048018Request request,
 100        long usuarioId,
 101        string? host)
 102    {
 5103        ValidarImporte(request.Importe);
 4104        var entidad = await _repositorio.ObtenerPorIdAsync(id)
 4105            ?? throw new ArgumentException($"Compensación Personal {id} no encontrada.");
 4106        if (entidad.Estado != "activo")
 1107            throw new InvalidOperationException(
 1108                "No se puede editar una Compensación Personal dada de baja. Cargue una nueva.");
 109
 3110        var importeAnterior = entidad.Importe;
 3111        var vigenteDesdeAnterior = entidad.VigenteDesde;
 3112        entidad.Importe = RedondearImporte(request.Importe);
 3113        if (request.VigenteDesde.HasValue)
 1114            entidad.VigenteDesde = request.VigenteDesde.Value.Date;
 3115        await _repositorio.ActualizarAsync(entidad);
 116
 3117        await _auditoria.LogAuditoriaAsync(
 3118            usuarioId,
 3119            AccionEnum.ActualizarCompPersonal,
 3120            ContextoEnum.Compensaciones,
 3121            host,
 3122            nameof(CompPersonal048018),
 3123            entidad.Id,
 3124            new
 3125            {
 3126                entidad.PersonaId,
 3127                ImporteAnterior = importeAnterior,
 3128                ImporteNuevo = entidad.Importe,
 3129                VigenteDesdeAnterior = vigenteDesdeAnterior,
 3130                VigenteDesdeNuevo = entidad.VigenteDesde
 3131            });
 132
 3133        return MapearDto(entidad);
 3134    }
 135
 136    public async Task DarBajaAsync(long id, long usuarioId, string? host)
 137    {
 5138        var entidad = await _repositorio.ObtenerPorIdAsync(id)
 5139            ?? throw new ArgumentException($"Compensación Personal {id} no encontrada.");
 5140        if (entidad.Estado != "activo")
 1141            throw new InvalidOperationException("La Compensación Personal ya está dada de baja.");
 142
 4143        entidad.Estado = "anulado";
 4144        entidad.VigenteHasta ??= DateTime.Today.Date;
 4145        await _repositorio.ActualizarAsync(entidad);
 146
 4147        await _auditoria.LogAuditoriaAsync(
 4148            usuarioId,
 4149            AccionEnum.DarBajaCompPersonal,
 4150            ContextoEnum.Compensaciones,
 4151            host,
 4152            nameof(CompPersonal048018),
 4153            entidad.Id,
 4154            new
 4155            {
 4156                entidad.PersonaId,
 4157                entidad.Importe,
 4158                entidad.VigenteHasta
 4159            });
 4160    }
 161
 162    private static string NormalizarCedula(string cedula)
 163    {
 13164        var normalizada = CedulaValidator.Limpiar(cedula ?? string.Empty);
 13165        if (!Regex.IsMatch(normalizada, @"^\d{7,8}$"))
 0166            throw new ArgumentException("La cédula debe contener 7 u 8 dígitos.");
 13167        return normalizada;
 168    }
 169
 170    private static decimal RedondearImporte(decimal importe) =>
 14171        Math.Round(importe, 2, MidpointRounding.AwayFromZero);
 172
 173    private static void ValidarImporte(decimal importe)
 174    {
 19175        if (importe <= 0)
 2176            throw new ArgumentException("El importe debe ser mayor a cero.");
 17177    }
 178
 11179    private static long? UsuarioValido(long usuarioId) => usuarioId > 0 ? usuarioId : null;
 180
 14181    private static CompPersonal048018Dto MapearDto(CompPersonal048018 entidad) => new()
 14182    {
 14183        Id = entidad.Id,
 14184        PersonaId = entidad.PersonaId,
 14185        Cedula = entidad.Persona.Cedula,
 14186        NombreCompleto = entidad.Persona.NombreCompleto,
 14187        Importe = entidad.Importe,
 14188        Estado = entidad.Estado,
 14189        VigenteDesde = entidad.VigenteDesde,
 14190        VigenteHasta = entidad.VigenteHasta,
 14191        CreadoEn = entidad.CreadoEn
 14192    };
 193}
Generated by: ReportGenerator 5.5.10.0
07/10/2026 - 13:26:03
GitHub | reportgenerator.io

Methods/Properties

.ctor(FAU.DataAccess.Repositories.ICompPersonal048018Repository,FAU.DataAccess.Repositories.IPersonalRepository,FAU.Logica.Services.IAuditoriaService)
ObtenerPaginadoAsync()
ObtenerPorIdAsync()
CrearAsync()
ActualizarAsync()
DarBajaAsync()
NormalizarCedula(System.String)
RedondearImporte(System.Decimal)
ValidarImporte(System.Decimal)
UsuarioValido(System.Int64)
MapearDto(FAU.Entidades.CompPersonal048018)