< Summary

Information
Class: FAU.Logica.Services.PersonalService
Assembly: FAU.Logica
File(s): /home/runner/work/Sistema.Liquidacion.BE/Sistema.Liquidacion.BE/FAU.Logica/Services/PersonalService.cs
Line coverage
67%
Covered lines: 477
Uncovered lines: 230
Coverable lines: 707
Total lines: 1095
Line coverage: 67.4%
Branch coverage
38%
Covered branches: 160
Total branches: 420
Branch coverage: 38%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
GetPersonalListAsync()50%201468.29%
GetDetalleAsync()75%88100%
CreatePersonalAsync()47.22%853666.36%
UpdatePersonalAsync()38.78%222221464.74%
RegistrarBajaAsync()62.5%252486.44%
RegistrarAscensoAsync()75%333291.34%
ApplyOrdering(...)27.27%2262225%
DeterminarRegimenIdAsync()14.28%481444.44%
ObtenerReporteMovimientosAsync()0%2162460%

File(s)

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

#LineLine coverage
 1using FAU.DataAccess;
 2using FAU.DataAccess.Repositories;
 3using FAU.Entidades;
 4using FAU.Logica.DTOs;
 5using FAU.Logica.Validadores;
 6using Microsoft.EntityFrameworkCore;
 7using Microsoft.Extensions.Logging;
 8
 9namespace FAU.Logica.Services;
 10
 11/// <summary>
 12/// Servicio de gestión de Personal
 13/// </summary>
 14public class PersonalService : IPersonalService
 15{
 16    private readonly IPersonalRepository _personalRepository;
 17    private readonly IMotivoBajaRepository _motivoBajaRepository;
 18    private readonly ApplicationDbContext _context;
 19    private readonly ILogger<PersonalService> _logger;
 20    private readonly IAuditoriaService _auditoriaService;
 21    private readonly ICurrentUserContext _currentUser;
 22
 2023    public PersonalService(
 2024        IPersonalRepository personalRepository,
 2025        IMotivoBajaRepository motivoBajaRepository,
 2026        ApplicationDbContext context,
 2027        ILogger<PersonalService> logger,
 2028        IAuditoriaService auditoriaService,
 2029        ICurrentUserContext currentUser)
 30    {
 2031        _personalRepository = personalRepository;
 2032        _motivoBajaRepository = motivoBajaRepository;
 2033        _context = context;
 2034        _logger = logger;
 2035        _auditoriaService = auditoriaService;
 2036        _currentUser = currentUser;
 2037    }
 38
 39    public async Task<object> GetPersonalListAsync(
 40        string? buscar,
 41        long? cargoId,
 42        string? estado,
 43        string? ley,
 44        int page,
 45        int pageSize,
 46        string? orderBy,
 47        string sort)
 48    {
 149        var query = _context.RelacionesLaborales
 150            .Include(r => r.Persona)
 151            .Include(r => r.Regimen)
 152            .Include(r => r.Escalafon)
 153            .Include(r => r.Grado)
 154            .Include(r => r.Situacion)
 155            .AsQueryable();
 56
 57        // Filtro por búsqueda (CI, nombre o apellido)
 158        if (!string.IsNullOrWhiteSpace(buscar))
 59        {
 060            var buscarLower = buscar.ToLower();
 061            query = query.Where(r =>
 062                r.Persona.Cedula.Contains(buscarLower) ||
 063                r.Persona.PrimerNombre.ToLower().Contains(buscarLower) ||
 064                r.Persona.PrimerApellido.ToLower().Contains(buscarLower) ||
 065                (r.Persona.SegundoNombre != null && r.Persona.SegundoNombre.ToLower().Contains(buscarLower)) ||
 066                (r.Persona.SegundoApellido != null && r.Persona.SegundoApellido.ToLower().Contains(buscarLower)));
 67        }
 68
 69        // Filtro por cargo (grado)
 170        if (cargoId.HasValue)
 71        {
 072            query = query.Where(r => r.GradoId == cargoId.Value);
 73        }
 74
 75        // Filtro por estado (parse string to enum)
 176        if (!string.IsNullOrWhiteSpace(estado))
 77        {
 178            if (Enum.TryParse<EstadoRelacion>(estado, true, out var estadoEnum))
 79            {
 180                query = query.Where(r => r.Estado == estadoEnum);
 81            }
 82            else
 83            {
 84                // Si no se puede parsear, intentar aceptar valores comunes
 085                var estLower = estado.Trim().ToLower();
 086                if (estLower == "activo") query = query.Where(r => r.Estado == EstadoRelacion.Activo);
 087                else if (estLower == "inactivo") query = query.Where(r => r.Estado == EstadoRelacion.Inactivo);
 88            }
 89        }
 90
 91        // Filtro por ley (régimen)
 192        if (!string.IsNullOrWhiteSpace(ley))
 93        {
 094            var leyLower = ley.ToLower();
 095            query = query.Where(r => r.Regimen.NumeroLey.ToLower().Contains(leyLower));
 96        }
 97
 198        var total = await query.CountAsync();
 99
 1100        query = ApplyOrdering(query, orderBy, sort);
 101
 102        // Paginación: obtener entidades y luego proyectar a DTO en memoria para poder convertir enums a string
 1103        var relacionesPage = await query
 1104            .Skip((page - 1) * pageSize)
 1105            .Take(pageSize)
 1106            .ToListAsync();
 107
 2108        var items = relacionesPage.Select(r => new PersonalListDto
 2109        {
 2110            Id = r.Id,
 2111            Ci = r.Persona.Cedula,
 2112            personalId = r.PersonaId,
 2113            PrimerNombre = r.Persona.PrimerNombre,
 2114            SegundoNombre = r.Persona.SegundoNombre,
 2115            PrimerApellido = r.Persona.PrimerApellido,
 2116            SegundoApellido = r.Persona.SegundoApellido,
 2117            Grado = r.Grado.Denominacion,
 2118            Ley = r.Regimen.NumeroLey,
 2119            Estado = r.Estado.ToString(),
 2120            FechaIngreso = r.FechaInicio
 2121        }).ToList();
 122
 1123        return new
 1124        {
 1125            items,
 1126            total,
 1127            page,
 1128            pageSize,
 1129            totalPages = (int)Math.Ceiling((double)total / pageSize)
 1130        };
 1131    }
 132
 133    public async Task<PersonalDetalleDto?> GetDetalleAsync(long id)
 134    {
 135        // id is PersonaId: obtener la relación laboral activa o la última relación laboral
 3136        var relacionLaboral = await _context.RelacionesLaborales
 3137            .Include(r => r.Persona)
 3138            .Include(r => r.Regimen)
 3139            .Include(r => r.Escalafon)
 3140            .Include(r => r.Grado)
 3141            .Include(r => r.Situacion)
 3142            .Include(r => r.Programa)
 3143            .Include(r => r.Unidad)
 3144            .Include(r => r.SubUnidad)
 3145            .Include(r => r.MotivoBaja)
 3146            .FirstOrDefaultAsync(r => r.PersonaId == id && r.Estado == EstadoRelacion.Activo);
 147
 3148        if (relacionLaboral == null)
 149        {
 2150            relacionLaboral = await _context.RelacionesLaborales
 2151                .Include(r => r.Persona)
 2152                .Include(r => r.Regimen)
 2153                .Include(r => r.Escalafon)
 2154                .Include(r => r.Grado)
 2155                .Include(r => r.Situacion)
 2156                .Include(r => r.Programa)
 2157                .Include(r => r.Unidad)
 2158                .Include(r => r.SubUnidad)
 2159                .Include(r => r.MotivoBaja)
 2160                .Where(r => r.PersonaId == id)
 2161                .OrderByDescending(r => r.FechaInicio)
 2162                .FirstOrDefaultAsync();
 163        }
 164
 3165        if (relacionLaboral == null)
 1166            return null;
 167
 168        // Obtener todos los ids de relación laboral de la persona y luego el historial de movimientos para cualquiera d
 2169        var relacionIds = await _context.RelacionesLaborales
 2170            .Where(r => r.PersonaId == relacionLaboral.PersonaId)
 2171            .Select(r => r.Id)
 2172            .ToListAsync();
 173
 2174        var historial = await _context.MovimientosLaborales
 2175            .Include(m => m.TipoMovimiento)
 2176            .Include(m => m.Usuario)
 2177                .ThenInclude(u => u.Persona)
 2178            .Where(m => relacionIds.Contains(m.RelacionLaboralId))
 2179            .OrderByDescending(m => m.Id)
 2180            .Select(m => new HistorialMovimientoDto
 2181            {
 2182                Id = m.Id,
 2183                TipoMovimiento = m.TipoMovimiento.Nombre,
 2184                EsAlta = m.TipoMovimiento.EsAlta,
 2185                FechaMovimiento = m.FechaMovimiento,
 2186                Observaciones = m.Observaciones,
 2187                RegistradoPor = m.Usuario != null ? m.Usuario.Username : null,
 2188                FechaRegistro = m.FechaMovimiento
 2189            })
 2190            .ToListAsync();
 191
 2192        return new PersonalDetalleDto
 2193        {
 2194            Id = relacionLaboral.Id,
 2195            DatosPersonales = new DatosPersonalesDto
 2196            {
 2197                PersonaId = relacionLaboral.PersonaId,
 2198                Ci = relacionLaboral.Persona.Cedula,
 2199                PrimerNombre = relacionLaboral.Persona.PrimerNombre,
 2200                SegundoNombre = relacionLaboral.Persona.SegundoNombre,
 2201                PrimerApellido = relacionLaboral.Persona.PrimerApellido,
 2202                SegundoApellido = relacionLaboral.Persona.SegundoApellido,
 2203                FechaNacimiento = relacionLaboral.Persona.FechaNacimiento,
 2204                Email = relacionLaboral.Persona.Email,
 2205                Telefono = relacionLaboral.Persona.Telefono,
 2206                Direccion = relacionLaboral.Persona.Direccion,
 2207                CodigoPostal = relacionLaboral.Persona.CodigoPostal,
 2208                Departamento = relacionLaboral.Persona.Departamento,
 2209                Localidad = relacionLaboral.Persona.Localidad
 2210            },
 2211            DatosLaborales = new DatosLaboralesDto
 2212            {
 2213                RelacionLaboralId = relacionLaboral.Id,
 2214                Estado = relacionLaboral.Estado.ToString(),
 2215                FechaInicio = relacionLaboral.FechaInicio,
 2216                FechaFin = relacionLaboral.FechaFin,
 2217                RegimenId = relacionLaboral.RegimenId,
 2218                Regimen = relacionLaboral.Regimen.Denominacion,
 2219                Ley = relacionLaboral.Regimen.NumeroLey,
 2220                EscalafonId = relacionLaboral.EscalafonId,
 2221                Escalafon = relacionLaboral.Escalafon.Denominacion,
 2222                GradoId = relacionLaboral.GradoId,
 2223                Grado = relacionLaboral.Grado.Denominacion,
 2224                SituacionId = relacionLaboral.SituacionId,
 2225                Situacion = relacionLaboral.Situacion.Denominacion,
 2226                ProgramaId = relacionLaboral.ProgramaId,
 2227                Programa = relacionLaboral.Programa.Denominacion,
 2228                UnidadId = relacionLaboral.UnidadId,
 2229                Unidad = relacionLaboral.Unidad.Denominacion,
 2230                SubUnidadId = relacionLaboral.SubUnidadId,
 2231                SubUnidad = relacionLaboral.SubUnidad?.Denominacion,
 2232                MotivoBajaId = relacionLaboral.MotivoBajaId,
 2233                MotivoBaja = relacionLaboral.MotivoBaja?.Denominacion,
 2234                RiesgoVuelo = relacionLaboral.RiesgoVuelo,
 2235                PrimaTecnica = relacionLaboral.PrimaTecnica,
 2236                PrimaSolidariaFamiliar = relacionLaboral.PrimaSolidariaFamiliar,
 2237                AniosInactivos = relacionLaboral.AniosInactivos,
 2238                Observaciones = relacionLaboral.Observaciones
 2239            },
 2240            Historial = historial
 2241        };
 3242    }
 243
 244    public async Task<(bool success, long? personalId, string? error)> CreatePersonalAsync(CreatePersonalRequest request
 245    {
 246        try
 247        {
 248            // Validar y limpiar CI
 4249            var cedulaLimpia = CedulaValidator.Limpiar(request.Ci);
 4250            if (!CedulaValidator.Validar(cedulaLimpia))
 251            {
 1252                return (false, null, "La cédula ingresada no es válida.");
 253            }
 254
 255            // Validar que la fecha de ingreso no sea futura
 3256            var errorFechaIngreso = FechaIngresoValidator.ObtenerErrorSiEsFutura(request.FechaIngreso);
 3257            if (errorFechaIngreso != null)
 258            {
 1259                return (false, null, errorFechaIngreso);
 260            }
 261
 262            // Validar que no exista una relación laboral activa para esa cédula
 2263            var validadorRelacion = new RelacionLaboralValidator(_context);
 2264            var errorRelacionActiva = await validadorRelacion.ObtenerErrorSiExisteRelacionActiva(cedulaLimpia);
 2265            if (errorRelacionActiva != null)
 266            {
 1267                return (false, null, errorRelacionActiva);
 268            }
 269
 270            // Validar que el grado pertenece al escalafón indicado
 1271            var escalafonId = request.EscalafonId ?? 1;
 1272            var grado = await _context.Grados.FindAsync(request.GradoId);
 1273            if (grado == null)
 0274                return (false, null, "El grado seleccionado no existe.");
 275            // TODO: reactivar validación cuando el frontend envíe EscalafonId correctamente
 276            // if (grado.EscalafonId != escalafonId)
 277            //     return (false, null, "El grado seleccionado no pertenece al escalafón indicado.");
 278
 279            // Validar fecha de nacimiento
 1280            if (request.FechaNacimiento != default)
 281            {
 1282                var fechaNac = request.FechaNacimiento.Date;
 1283                if (fechaNac > DateTime.UtcNow.Date)
 0284                    return (false, null, "La fecha de nacimiento no puede ser futura.");
 1285                if (fechaNac < new DateTime(1940, 1, 1))
 0286                    return (false, null, "La fecha de nacimiento no puede ser anterior a 01/01/1940.");
 287            }
 288
 289            // Buscar o crear persona
 1290            Persona? persona = await _context.Personas.FirstOrDefaultAsync(p => p.Cedula == cedulaLimpia);
 291
 1292            if (persona == null)
 293            {
 294                // Crear persona - Convertir fechas a UTC
 1295                var fechaNacimientoUtc = request.FechaNacimiento.Kind == DateTimeKind.Unspecified
 1296                    ? DateTime.SpecifyKind(request.FechaNacimiento.Date, DateTimeKind.Utc)
 1297                    : request.FechaNacimiento.Date.ToUniversalTime();
 298
 1299                persona = new Persona
 1300                {
 1301                    Cedula = cedulaLimpia,
 1302                    PrimerNombre = request.PrimerNombre,
 1303                    SegundoNombre = request.SegundoNombre,
 1304                    PrimerApellido = request.PrimerApellido,
 1305                    SegundoApellido = request.SegundoApellido,
 1306                    FechaNacimiento = fechaNacimientoUtc,
 1307                    Email = request.Email,
 1308                    Telefono = request.Telefono,
 1309                    Direccion = request.Direccion,
 1310                    CodigoPostal = request.CodigoPostal,
 1311                    Departamento = request.Departamento,
 1312                    Localidad = request.Localidad
 1313                };
 314
 1315                _context.Personas.Add(persona);
 1316                await _context.SaveChangesAsync();
 317            }
 318            else
 319            {
 320                // Persona ya existe: actualizar campos de dirección si vienen en el request
 0321                bool personaModificada = false;
 0322                if (request.CodigoPostal != null) { persona.CodigoPostal = request.CodigoPostal; personaModificada = tru
 0323                if (request.Departamento != null) { persona.Departamento = request.Departamento; personaModificada = tru
 0324                if (request.Localidad != null) { persona.Localidad = request.Localidad; personaModificada = true; }
 0325                if (personaModificada)
 326                {
 0327                    persona.FechaActualizacion = DateTime.UtcNow;
 0328                    _context.Personas.Update(persona);
 0329                    await _context.SaveChangesAsync();
 330                }
 331            }
 332
 333            // Determinar régimen: explícito si se pasa, sino auto-calcular
 334            long regimenId;
 1335            if (!string.IsNullOrWhiteSpace(request.Ley))
 336            {
 0337                var regimenExplicito = await _context.Regimenes
 0338                    .FirstOrDefaultAsync(r => r.NumeroLey == request.Ley && r.Vigente);
 0339                if (regimenExplicito == null)
 0340                    return (false, null, $"No se encontró el régimen con ley {request.Ley}");
 0341                regimenId = regimenExplicito.Id;
 342            }
 343            else
 344            {
 1345                regimenId = await DeterminarRegimenIdAsync(request.FechaIngreso, request.EscalafonId);
 346            }
 347
 348            // Crear relación laboral - Convertir fechas a UTC
 1349            var fechaIngresoUtc = request.FechaIngreso.Kind == DateTimeKind.Unspecified
 1350                ? DateTime.SpecifyKind(request.FechaIngreso.Date, DateTimeKind.Utc)
 1351                : request.FechaIngreso.Date.ToUniversalTime();
 352
 1353            var relacionLaboral = new RelacionLaboral
 1354            {
 1355                PersonaId = persona.Id,
 1356                RegimenId = regimenId,
 1357                EscalafonId = request.EscalafonId ?? 1,
 1358                GradoId = request.GradoId,
 1359                SituacionId = request.SituacionId ?? 1,
 1360                ProgramaId = request.ProgramaId ?? 1,
 1361                UnidadId = request.UnidadId ?? 1,
 1362                SubUnidadId = request.SubUnidadId,
 1363                Estado = EstadoRelacion.Activo,
 1364                FechaInicio = fechaIngresoUtc,
 1365                Observaciones = request.Observaciones
 1366            };
 367
 1368            _context.RelacionesLaborales.Add(relacionLaboral);
 1369            await _context.SaveChangesAsync();
 370
 371            // Al dar de alta, asignar automáticamente Prima Solidaria Familiar como "Sin hijos"
 1372            var tipoPrimaSolidaria = await _context.TiposBeneficio
 1373                .FirstOrDefaultAsync(t => t.Codigo == "PRIMA_SOLIDARIA_FAMILIAR" && t.Activo);
 1374            if (tipoPrimaSolidaria != null)
 375            {
 0376                var primaSolidaria = new BeneficioSocial
 0377                {
 0378                    PersonaId = persona.Id,
 0379                    TipoBeneficioId = tipoPrimaSolidaria.Id,
 0380                    ClaveEvento = "SIN_HIJOS",
 0381                    VigenteDesde = fechaIngresoUtc,
 0382                    Estado = "activo",
 0383                    RetroactividadPendiente = false,
 0384                    Cantidad = 1,
 0385                    CreadoPor = _currentUser.UserId
 0386                };
 0387                _context.BeneficiosSociales.Add(primaSolidaria);
 0388                await _context.SaveChangesAsync();
 389            }
 390
 1391            await _auditoriaService.LogAuditoriaAsync(
 1392                usuarioId: _currentUser.UserId ?? 0,
 1393                AccionEnum.CrearPersonal,
 1394                ContextoEnum.Personal,
 1395                host: _currentUser.Host,
 1396                entidad: nameof(Persona),
 1397                entidadId: persona.Id,
 1398                detalle: new { relacionLaboralId = relacionLaboral.Id, personaId = persona.Id, cedula = persona.Cedula }
 399
 1400            return (true, relacionLaboral.Id, null);
 401        }
 0402        catch (Exception ex)
 403        {
 0404            _logger.LogError(ex, "Error al crear personal");
 0405            var errorMessage = ex.Message;
 0406            var innerEx = ex.InnerException;
 0407            while (innerEx != null)
 408            {
 0409                errorMessage += $" | {innerEx.Message}";
 0410                innerEx = innerEx.InnerException;
 411            }
 0412            return (false, null, $"Error al crear personal: {errorMessage}");
 413        }
 4414    }
 415
 416    public async Task<(bool success, string? error)> UpdatePersonalAsync(long id, UpdatePersonalRequest request)
 417    {
 418        try
 419        {
 3420            var persona = await _context.Personas.FindAsync(id);
 3421            if (persona == null)
 1422                return (false, "Persona no encontrada");
 423
 424            // Validar campos de compensación si se proporcionan
 2425            var errorCompensacion = CompensacionValidator.ValidarCompensaciones(
 2426                request.RiesgoVuelo,
 2427                request.PrimaTecnica,
 2428                request.PrimaSolidariaFamiliar,
 2429                request.AniosInactivos);
 430
 2431            if (errorCompensacion != null)
 432            {
 0433                return (false, errorCompensacion);
 434            }
 435
 436            // Actualizar datos personales
 2437            if (!string.IsNullOrWhiteSpace(request.PrimerNombre))
 1438                persona.PrimerNombre = request.PrimerNombre.Trim();
 439
 2440            persona.SegundoNombre = string.IsNullOrWhiteSpace(request.SegundoNombre) ? null : request.SegundoNombre.Trim
 441
 2442            if (!string.IsNullOrWhiteSpace(request.PrimerApellido))
 1443                persona.PrimerApellido = request.PrimerApellido.Trim();
 444
 2445            persona.SegundoApellido = string.IsNullOrWhiteSpace(request.SegundoApellido) ? null : request.SegundoApellid
 446
 2447            if (request.FechaNacimiento.HasValue)
 448            {
 0449                var fechaNac = request.FechaNacimiento.Value;
 0450                persona.FechaNacimiento = fechaNac.Kind == DateTimeKind.Unspecified
 0451                    ? DateTime.SpecifyKind(fechaNac.Date, DateTimeKind.Utc)
 0452                    : fechaNac.Date.ToUniversalTime();
 453            }
 454
 2455            if (!string.IsNullOrWhiteSpace(request.Email))
 1456                persona.Email = request.Email.Trim();
 457
 2458            persona.Telefono = string.IsNullOrWhiteSpace(request.Telefono) ? null : request.Telefono.Trim();
 2459            persona.Direccion = string.IsNullOrWhiteSpace(request.Direccion) ? null : request.Direccion.Trim();
 2460            persona.CodigoPostal = string.IsNullOrWhiteSpace(request.CodigoPostal) ? null : request.CodigoPostal.Trim();
 2461            persona.Departamento = string.IsNullOrWhiteSpace(request.Departamento) ? null : request.Departamento.Trim();
 2462            persona.Localidad = string.IsNullOrWhiteSpace(request.Localidad) ? null : request.Localidad.Trim();
 463
 2464            if (persona.FechaNacimiento.HasValue)
 465            {
 1466                var fn = persona.FechaNacimiento.Value;
 1467                persona.FechaNacimiento = fn.Kind == DateTimeKind.Unspecified
 1468                    ? DateTime.SpecifyKind(fn.Date, DateTimeKind.Utc)
 1469                    : fn.ToUniversalTime();
 470            }
 471
 2472            persona.FechaActualizacion = DateTime.UtcNow;
 2473            _context.Personas.Update(persona);
 474
 475            // Buscar relación activa para la persona
 2476            var relacionActiva = await _context.RelacionesLaborales
 2477                .FirstOrDefaultAsync(r => r.PersonaId == persona.Id && r.Estado == EstadoRelacion.Activo);
 478
 479            // Obtener la última relación (puede ser null)
 2480            var ultimaRelacion = await _context.RelacionesLaborales
 2481                .Where(r => r.PersonaId == persona.Id)
 2482                .OrderByDescending(r => r.FechaInicio)
 2483                .FirstOrDefaultAsync();
 484
 485            // Validar transición de estado usando la relación más relevante (activa si existe, sino la última)
 2486            var relacionParaValidacion = relacionActiva ?? ultimaRelacion;
 487
 2488            if (!string.IsNullOrWhiteSpace(request.Estado) && relacionParaValidacion != null)
 489            {
 0490                var errorTransicion = EstadoTransicionValidator.ObtenerErrorSiTransicionInvalida(
 0491                    relacionParaValidacion.Estado.ToString(),
 0492                    request.Estado);
 0493                if (errorTransicion != null)
 0494                    return (false, errorTransicion);
 495            }
 496
 497            // Determinar si se solicitaron cambios laborales
 2498            bool cambioLaboralSolicitado = request.GradoId.HasValue || request.RegimenId.HasValue || request.EscalafonId
 2499                request.SituacionId.HasValue || request.ProgramaId.HasValue || request.UnidadId.HasValue || request.SubU
 500
 2501            if (relacionActiva != null)
 502            {
 503                // Si hay relación activa, verificar si los cambios requieren crear una nueva relación
 2504                bool requiereNueva = false;
 3505                if (request.GradoId.HasValue && request.GradoId.Value != relacionActiva.GradoId) requiereNueva = true;
 2506                if (request.RegimenId.HasValue && request.RegimenId.Value != relacionActiva.RegimenId) requiereNueva = t
 2507                if (request.EscalafonId.HasValue && request.EscalafonId.Value != relacionActiva.EscalafonId) requiereNue
 2508                if (request.SituacionId.HasValue && request.SituacionId.Value != relacionActiva.SituacionId) requiereNue
 2509                if (request.ProgramaId.HasValue && request.ProgramaId.Value != relacionActiva.ProgramaId) requiereNueva 
 2510                if (request.UnidadId.HasValue && request.UnidadId.Value != relacionActiva.UnidadId) requiereNueva = true
 2511                if (request.SubUnidadId.HasValue && request.SubUnidadId.Value != relacionActiva.SubUnidadId) requiereNue
 512
 2513                if (requiereNueva)
 514                {
 515                    // Cerrar relación activa
 1516                    relacionActiva.FechaFin = DateTime.UtcNow;
 1517                    relacionActiva.Estado = EstadoRelacion.Inactivo;
 1518                    relacionActiva.FechaActualizacion = DateTime.UtcNow;
 519
 520                    // Crear nueva relación activa con los valores actualizados
 1521                    var nuevaRelacion = new RelacionLaboral
 1522                    {
 1523                        PersonaId = persona.Id,
 1524                        RegimenId = request.RegimenId ?? relacionActiva.RegimenId,
 1525                        EscalafonId = request.EscalafonId ?? relacionActiva.EscalafonId,
 1526                        GradoId = request.GradoId ?? relacionActiva.GradoId,
 1527                        SituacionId = request.SituacionId ?? relacionActiva.SituacionId,
 1528                        ProgramaId = request.ProgramaId ?? relacionActiva.ProgramaId,
 1529                        UnidadId = request.UnidadId ?? relacionActiva.UnidadId,
 1530                        SubUnidadId = request.SubUnidadId ?? relacionActiva.SubUnidadId,
 1531                        Estado = EstadoRelacion.Activo,
 1532                        FechaInicio = DateTime.UtcNow,
 1533                        Observaciones = request.Observaciones ?? relacionActiva.Observaciones,
 1534                        FechaActualizacion = DateTime.UtcNow,
 1535                        RiesgoVuelo = request.RiesgoVuelo ?? relacionActiva.RiesgoVuelo,
 1536                        PrimaTecnica = string.IsNullOrWhiteSpace(request.PrimaTecnica) ? relacionActiva.PrimaTecnica : r
 1537                        PrimaSolidariaFamiliar = string.IsNullOrWhiteSpace(request.PrimaSolidariaFamiliar) ? relacionAct
 1538                        AniosInactivos = request.AniosInactivos ?? relacionActiva.AniosInactivos
 1539                    };
 540
 1541                    _context.RelacionesLaborales.Add(nuevaRelacion);
 542                }
 543                else
 544                {
 545                    // Actualizar en sitio la relación activa
 1546                    if (!string.IsNullOrWhiteSpace(request.Estado))
 547                    {
 0548                        if (Enum.TryParse<EstadoRelacion>(request.Estado, true, out var est))
 0549                            relacionActiva.Estado = est;
 550                        else
 551                        {
 0552                            var estLower = request.Estado.Trim().ToLower();
 0553                            if (estLower == "activo") relacionActiva.Estado = EstadoRelacion.Activo;
 0554                            else if (estLower == "inactivo") relacionActiva.Estado = EstadoRelacion.Inactivo;
 555                        }
 556                    }
 557
 1558                    if (request.RegimenId.HasValue) relacionActiva.RegimenId = request.RegimenId.Value;
 1559                    if (request.EscalafonId.HasValue) relacionActiva.EscalafonId = request.EscalafonId.Value;
 1560                    if (request.GradoId.HasValue) relacionActiva.GradoId = request.GradoId.Value;
 1561                    if (request.SituacionId.HasValue) relacionActiva.SituacionId = request.SituacionId.Value;
 1562                    if (request.ProgramaId.HasValue) relacionActiva.ProgramaId = request.ProgramaId.Value;
 1563                    if (request.UnidadId.HasValue) relacionActiva.UnidadId = request.UnidadId.Value;
 1564                    if (request.SubUnidadId.HasValue) relacionActiva.SubUnidadId = request.SubUnidadId.Value;
 565
 1566                    if (request.RiesgoVuelo.HasValue) relacionActiva.RiesgoVuelo = request.RiesgoVuelo;
 1567                    if (request.PrimaTecnica != null) relacionActiva.PrimaTecnica = string.IsNullOrWhiteSpace(request.Pr
 1568                    if (request.PrimaSolidariaFamiliar != null) relacionActiva.PrimaSolidariaFamiliar = string.IsNullOrW
 1569                    if (request.AniosInactivos.HasValue) relacionActiva.AniosInactivos = request.AniosInactivos;
 1570                    if (request.Observaciones != null) relacionActiva.Observaciones = request.Observaciones;
 571
 1572                    relacionActiva.FechaActualizacion = DateTime.UtcNow;
 573                }
 574            }
 575            else
 576            {
 577                // No hay relación activa
 0578                if (cambioLaboralSolicitado)
 579                {
 580                    // Crear nueva relación activa basándose en la última relación si existe
 0581                    var plantilla = ultimaRelacion;
 582
 0583                    var nuevaRelacion = new RelacionLaboral
 0584                    {
 0585                        PersonaId = persona.Id,
 0586                        RegimenId = request.RegimenId ?? plantilla?.RegimenId ?? 0,
 0587                        EscalafonId = request.EscalafonId ?? plantilla?.EscalafonId ?? 0,
 0588                        GradoId = request.GradoId ?? plantilla?.GradoId ?? 0,
 0589                        SituacionId = request.SituacionId ?? plantilla?.SituacionId ?? 0,
 0590                        ProgramaId = request.ProgramaId ?? plantilla?.ProgramaId ?? 0,
 0591                        UnidadId = request.UnidadId ?? plantilla?.UnidadId ?? 0,
 0592                        SubUnidadId = request.SubUnidadId ?? plantilla?.SubUnidadId,
 0593                        Estado = EstadoRelacion.Activo,
 0594                        FechaInicio = DateTime.UtcNow,
 0595                        Observaciones = request.Observaciones ?? plantilla?.Observaciones,
 0596                        FechaActualizacion = DateTime.UtcNow,
 0597                        RiesgoVuelo = request.RiesgoVuelo ?? plantilla?.RiesgoVuelo,
 0598                        PrimaTecnica = string.IsNullOrWhiteSpace(request.PrimaTecnica) ? plantilla?.PrimaTecnica : reque
 0599                        PrimaSolidariaFamiliar = string.IsNullOrWhiteSpace(request.PrimaSolidariaFamiliar) ? plantilla?.
 0600                        AniosInactivos = request.AniosInactivos ?? plantilla?.AniosInactivos
 0601                    };
 602
 0603                    _context.RelacionesLaborales.Add(nuevaRelacion);
 604                }
 605                else
 606                {
 607                    // Solo actualizar estado u observaciones de la última relación si existe
 0608                    if (ultimaRelacion != null)
 609                    {
 0610                        if (!string.IsNullOrWhiteSpace(request.Estado))
 611                        {
 0612                            if (Enum.TryParse<EstadoRelacion>(request.Estado, true, out var est))
 0613                                ultimaRelacion.Estado = est;
 614                            else
 615                            {
 0616                                var estLower = request.Estado.Trim().ToLower();
 0617                                if (estLower == "activo") ultimaRelacion.Estado = EstadoRelacion.Activo;
 0618                                else if (estLower == "inactivo") ultimaRelacion.Estado = EstadoRelacion.Inactivo;
 619                            }
 620                        }
 621
 0622                        if (request.Observaciones != null) ultimaRelacion.Observaciones = request.Observaciones;
 0623                        ultimaRelacion.FechaActualizacion = DateTime.UtcNow;
 624                    }
 625                }
 626            }
 627
 2628            await _context.SaveChangesAsync();
 629
 2630            return (true, null);
 631        }
 0632        catch (Exception ex)
 633        {
 0634            _logger.LogError(ex, "Error al actualizar personal");
 0635            return (false, $"Error al actualizar personal: {ex.Message}");
 636        }
 3637    }
 638
 639    public async Task<(bool success, string? error)> RegistrarBajaAsync(long id, RegistrarBajaRequest request)
 640    {
 641        try
 642        {
 643            // id is PersonaId: buscar la relación laboral activa de la persona
 4644            var relacionLaboral = await _context.RelacionesLaborales
 4645                .FirstOrDefaultAsync(r => r.PersonaId == id && r.Estado == EstadoRelacion.Activo);
 646
 4647            if (relacionLaboral == null)
 648            {
 1649                return (false, "Relación laboral no encontrada");
 650            }
 651
 652            // Validar y obtener el MotivoBaja (catálogo UCU)
 3653            if (request.MotivoBajaId <= 0)
 1654                return (false, "El motivo de baja (catálogo) es requerido");
 655
 2656            var motivoBaja = await _motivoBajaRepository.GetByIdAsync(request.MotivoBajaId);
 2657            if (motivoBaja == null)
 0658                return (false, "Motivo de baja (catálogo) no encontrado o no vigente");
 659
 660            // Determinar TipoMovimiento automáticamente según el motivo:
 661            //   RETIRO_OBL / RETIRO_VOL â†’ "Retiro" | resto â†’ "Baja"
 2662            var nombreTipo = motivoBaja.Codigo is "RETIRO_OBL" or "RETIRO_VOL" ? "Retiro" : "Baja";
 2663            var tipoMovimiento = await _context.TiposMovimiento
 2664                .FirstOrDefaultAsync(t => t.Nombre == nombreTipo && !t.EsAlta);
 665
 2666            if (tipoMovimiento == null)
 1667                return (false, $"Tipo de movimiento '{nombreTipo}' no encontrado en el catálogo");
 668
 669            // Validar que la fecha de baja no sea futura
 1670            var errorFechaBaja = FechaIngresoValidator.ObtenerErrorSiEsFutura(request.FechaBaja);
 1671            if (errorFechaBaja != null)
 672            {
 0673                return (false, errorFechaBaja);
 674            }
 675
 676            // Validar fecha de baja vs último movimiento y fecha de inicio
 1677            var validadorMovimiento = new MovimientoLaboralValidator(_context);
 1678            var errorFechaMovimiento = await validadorMovimiento.ValidarFechaMovimiento(relacionLaboral.Id, request.Fech
 1679            if (errorFechaMovimiento != null)
 680            {
 0681                return (false, errorFechaMovimiento);
 682            }
 683
 1684            var errorFechaBajaVsMovimiento = await validadorMovimiento.ValidarFechaBajaVsUltimoMovimiento(relacionLabora
 1685            if (errorFechaBajaVsMovimiento != null)
 686            {
 0687                return (false, errorFechaBajaVsMovimiento);
 688            }
 689
 690            // Validar transición de estado: debe ir de activo a inactivo
 1691            var errorTransicion = EstadoTransicionValidator.ObtenerErrorSiTransicionInvalida(
 1692                relacionLaboral.Estado.ToString(),
 1693                "Inactivo");
 694
 1695            if (errorTransicion != null)
 696            {
 0697                return (false, errorTransicion);
 698            }
 699
 700            // Cambiar estado a inactivo
 1701            relacionLaboral.Estado = EstadoRelacion.Inactivo;
 1702            var fechaBajaUtc = request.FechaBaja.Kind == DateTimeKind.Unspecified
 1703                ? DateTime.SpecifyKind(request.FechaBaja.Date, DateTimeKind.Utc)
 1704                : request.FechaBaja.Date.ToUniversalTime();
 1705            relacionLaboral.FechaFin = fechaBajaUtc;
 1706            relacionLaboral.MotivoBajaId = request.MotivoBajaId;
 1707            relacionLaboral.FechaActualizacion = DateTime.UtcNow;
 708
 709            // Registrar movimiento de baja
 1710            var movimiento = new MovimientoLaboral
 1711            {
 1712                RelacionLaboralId = relacionLaboral.Id,
 1713                TipoMovimientoId = tipoMovimiento.Id,
 1714                FechaMovimiento = fechaBajaUtc,
 1715                UsuarioId = _currentUser.UserId ?? 0,
 1716                Observaciones = request.Observaciones
 1717            };
 718
 1719            _context.MovimientosLaborales.Add(movimiento);
 1720            await _context.SaveChangesAsync();
 721
 1722            await _auditoriaService.LogAuditoriaAsync(
 1723                usuarioId: _currentUser.UserId ?? 0,
 1724                AccionEnum.BajaPersonal,
 1725                ContextoEnum.Personal,
 1726                host: _currentUser.Host,
 1727                entidad: nameof(RelacionLaboral),
 1728                entidadId: relacionLaboral.Id,
 1729                detalle: new { personaId = id, relacionLaboralId = relacionLaboral.Id, request });
 730
 1731            return (true, null);
 732        }
 0733        catch (Exception ex)
 734        {
 0735            _logger.LogError(ex, "Error al registrar baja");
 0736            return (false, $"Error al registrar baja: {ex.Message}");
 737        }
 4738    }
 739
 740    public async Task<(bool success, string? error)> RegistrarAscensoAsync(long id, AscensoRequest request)
 741    {
 742        try
 743        {
 5744            var relacionLaboral = await _context.RelacionesLaborales
 5745                .FirstOrDefaultAsync(r => r.PersonaId == id && r.Estado == EstadoRelacion.Activo);
 746
 5747            if (relacionLaboral == null)
 1748                return (false, "Relación laboral no encontrada");
 749
 750            // Validar grado objetivo
 4751            var grado = await _context.Grados.FirstOrDefaultAsync(g => g.Id == request.NuevoGradoId && g.Vigente);
 4752            if (grado == null)
 1753                return (false, "Grado no encontrado");
 754
 755            // Calcular régimen automáticamente según fecha de ingreso y escalafón (igual que en el Alta)
 3756            var regimenAscensoId = await DeterminarRegimenIdAsync(relacionLaboral.FechaInicio, relacionLaboral.Escalafon
 3757            var regimenAscenso = await _context.Regimenes.FindAsync(regimenAscensoId);
 3758            if (regimenAscenso == null)
 0759                return (false, "No se pudo determinar el régimen para el ascenso");
 760
 761            // Validar que el grado objetivo
 3762            if (relacionLaboral.GradoId != 0)
 763            {
 3764                var gradoActual = await _context.Grados.FirstOrDefaultAsync(g => g.Id == relacionLaboral.GradoId);
 3765                if (gradoActual != null)
 766                {
 3767                    if (grado.Orden <= gradoActual.Orden)
 768                    {
 1769                        return (false, "El grado objetivo debe ser superior al grado actual");
 770                    }
 771                }
 772            }
 773
 2774            var fechaAscensoUtc = request.FechaAscenso.Kind == DateTimeKind.Unspecified
 2775                ? DateTime.SpecifyKind(request.FechaAscenso.Date, DateTimeKind.Utc)
 2776                : request.FechaAscenso.Date.ToUniversalTime();
 777
 778            // Validar unidad objetivo si se proporciona
 779            Unidad? unidadObj = null;
 2780            if (request.UnidadId.HasValue)
 781            {
 0782                unidadObj = await _context.Unidades.FirstOrDefaultAsync(u => u.Id == request.UnidadId.Value && u.Vigente
 0783                if (unidadObj == null)
 784                {
 0785                    return (false, "Unidad no válida o no vigente");
 786                }
 787            }
 788
 789            // Cerrar la relación laboral actual
 790            // Validar transición: debe estar activo para poder ascender
 2791            var errorTransicion = EstadoTransicionValidator.ObtenerErrorSiTransicionInvalida(
 2792                relacionLaboral.Estado.ToString(),
 2793                "Inactivo");
 794
 2795            if (errorTransicion != null)
 796            {
 0797                return (false, errorTransicion);
 798            }
 799
 2800            relacionLaboral.FechaFin = fechaAscensoUtc;
 2801            relacionLaboral.FechaActualizacion = DateTime.UtcNow;
 2802            relacionLaboral.Estado = EstadoRelacion.Inactivo;
 2803            relacionLaboral.Observaciones = request.Observacion;
 804
 805            // Validar programa objetivo
 2806            var programaAscenso = await _context.Programas.FirstOrDefaultAsync(p => p.Id == request.ProgramaId && p.Vige
 2807            if (programaAscenso == null)
 1808                return (false, "Programa no válido o no vigente");
 809
 810            // Determinar prima técnica: al ascender a Sgto. 1° se desactiva la prima técnica variable
 1811            var primaTecnicaNueva = relacionLaboral.PrimaTecnica;
 1812            if (grado.Codigo == "SGTO_1RO")
 0813                primaTecnicaNueva = "VACIO";
 814
 815            // Crear nueva relación laboral con el nuevo grado
 1816            var nuevaRelacion = new RelacionLaboral
 1817            {
 1818                PersonaId = relacionLaboral.PersonaId,
 1819                RegimenId = regimenAscenso.Id,
 1820                EscalafonId = relacionLaboral.EscalafonId,
 1821                GradoId = request.NuevoGradoId,
 1822                SituacionId = relacionLaboral.SituacionId,
 1823                ProgramaId = request.ProgramaId,
 1824                UnidadId = request.UnidadId ?? relacionLaboral.UnidadId,
 1825                SubUnidadId = request.SubUnidadId ?? relacionLaboral.SubUnidadId,
 1826                Estado = EstadoRelacion.Activo,
 1827                FechaInicio = fechaAscensoUtc,
 1828                PrimaTecnica = primaTecnicaNueva,
 1829                PrimaSolidariaFamiliar = relacionLaboral.PrimaSolidariaFamiliar,
 1830                RiesgoVuelo = relacionLaboral.RiesgoVuelo,
 1831                Observaciones = relacionLaboral.Observaciones,
 1832                FechaActualizacion = DateTime.UtcNow
 1833            };
 834
 1835            _context.RelacionesLaborales.Add(nuevaRelacion);
 836
 837            // Registrar movimientos
 838            // Prefer specific tipo_movimiento ids: 6 = Cambio de Situacion (cierre), 7 = Ascenso (alta)
 1839            var tipoCierre = await _context.TiposMovimiento.FirstOrDefaultAsync(t => t.Nombre.ToLower().Contains("cambio
 1840            var tipoAlta = await _context.TiposMovimiento.FirstOrDefaultAsync(t => t.Nombre.ToLower().Contains("ascenso"
 841
 1842            if (tipoCierre == null)
 843            {
 1844                tipoCierre = new Entidades.TipoMovimiento { Nombre = "Cambio de Situacion", EsAlta = false };
 1845                _context.TiposMovimiento.Add(tipoCierre);
 1846                await _context.SaveChangesAsync();
 847            }
 848
 1849            if (tipoAlta == null)
 850            {
 1851                tipoAlta = new Entidades.TipoMovimiento { Nombre = "Ascenso", EsAlta = true };
 1852                _context.TiposMovimiento.Add(tipoAlta);
 1853                await _context.SaveChangesAsync();
 854            }
 855
 856            // Movimiento de cierre
 1857            var movimientoCierre = new Entidades.MovimientoLaboral
 1858            {
 1859                RelacionLaboralId = relacionLaboral.Id,
 1860                TipoMovimientoId = tipoCierre.Id,
 1861                FechaMovimiento = fechaAscensoUtc,
 1862                UsuarioId = _currentUser.UserId ?? 0,
 1863                Observaciones = request.Observacion,
 1864                Puesto = request.Puesto,
 1865                Plaza = request.Plaza
 1866            };
 867
 1868            _context.MovimientosLaborales.Add(movimientoCierre);
 869
 1870            await _context.SaveChangesAsync();
 871
 1872            var movimientoAlta = new Entidades.MovimientoLaboral
 1873            {
 1874                RelacionLaboralId = nuevaRelacion.Id,
 1875                TipoMovimientoId = tipoAlta.Id,
 1876                FechaMovimiento = fechaAscensoUtc,
 1877                UsuarioId = _currentUser.UserId ?? 0,
 1878                Observaciones = request.Observacion,
 1879                Puesto = request.Puesto,
 1880                Plaza = request.Plaza
 1881            };
 882
 1883            _context.MovimientosLaborales.Add(movimientoAlta);
 884
 1885            await _context.SaveChangesAsync();
 886
 1887            await _auditoriaService.LogAuditoriaAsync(
 1888                usuarioId: _currentUser.UserId ?? 0,
 1889                AccionEnum.AscensoPersonal,
 1890                ContextoEnum.Personal,
 1891                host: _currentUser.Host,
 1892                entidad: nameof(RelacionLaboral),
 1893                entidadId: nuevaRelacion.Id,
 1894                detalle: new { personaId = id, relacionAnteriorId = relacionLaboral.Id, relacionNuevaId = nuevaRelacion.
 895
 1896            return (true, null);
 897        }
 0898        catch (Exception ex)
 899        {
 0900            _logger.LogError(ex, "Error al registrar ascenso");
 0901            return (false, $"Error al registrar ascenso: {ex.Message}");
 902        }
 5903    }
 904
 905    private IQueryable<RelacionLaboral> ApplyOrdering(
 906        IQueryable<RelacionLaboral> query,
 907        string? orderBy,
 908        string sort)
 909    {
 1910        var ascending = sort.ToLower() == "asc";
 911
 1912        return orderBy?.ToLower() switch
 1913        {
 0914            "ci" => ascending
 0915                ? query.OrderBy(r => r.Persona.Cedula)
 0916                : query.OrderByDescending(r => r.Persona.Cedula),
 0917            "nombre" => ascending
 0918                ? query.OrderBy(r => r.Persona.PrimerNombre)
 0919                : query.OrderByDescending(r => r.Persona.PrimerNombre),
 0920            "apellido" => ascending
 0921                ? query.OrderBy(r => r.Persona.PrimerApellido)
 0922                : query.OrderByDescending(r => r.Persona.PrimerApellido),
 0923            "grado" => ascending
 0924                ? query.OrderBy(r => r.Grado.Orden)
 0925                : query.OrderByDescending(r => r.Grado.Orden),
 0926            "fechaingreso" => ascending
 0927                ? query.OrderBy(r => r.FechaInicio)
 0928                : query.OrderByDescending(r => r.FechaInicio),
 1929            _ => query.OrderByDescending(r => r.FechaInicio)
 1930        };
 931    }
 932
 933    #region Métodos Privados
 934
 935    /// <summary>
 936    /// Determina el régimen (Ley Vieja 14.157 / Ley Nueva 19.695) según la lógica del legacy MONTEPIO.PRG.
 937    /// Fecha límite de la reforma: 28/02/2019.
 938    /// - Escalafón AV (Oficiales): >= 15 años al 28/02/2019 â†’ Ley Vieja
 939    /// - Otros escalafones (Subalternos): >= 3 años al 28/02/2019 â†’ Ley Vieja
 940    /// - Ingreso posterior a la reforma â†’ siempre Ley Nueva
 941    /// </summary>
 942    private async Task<long> DeterminarRegimenIdAsync(DateTime fechaIngreso, long? escalafonId)
 943    {
 4944        var fechaReforma = new DateTime(2019, 2, 28);
 945        string numeroLey;
 946
 4947        if (fechaIngreso.Date >= fechaReforma)
 948        {
 4949            numeroLey = "19.695";
 950        }
 951        else
 952        {
 0953            int aniosAlLimite = fechaReforma.Year - fechaIngreso.Year;
 0954            if (fechaIngreso.Date > fechaReforma.AddYears(-aniosAlLimite)) aniosAlLimite--;
 955
 0956            var escalafon = escalafonId.HasValue
 0957                ? await _context.Escalafones.FindAsync(escalafonId.Value)
 0958                : null;
 0959            bool esOficial = escalafon?.Codigo == "AV";
 0960            int umbral = esOficial ? 15 : 3;
 961
 0962            numeroLey = aniosAlLimite >= umbral ? "14.157" : "19.695";
 963        }
 964
 4965        var regimen = await _context.Regimenes
 4966            .FirstOrDefaultAsync(r => r.NumeroLey == numeroLey && r.Vigente);
 967
 968        // Fallback a Ley Nueva si no se encuentra (no debería ocurrir)
 4969        if (regimen == null)
 970        {
 0971            regimen = await _context.Regimenes
 0972                .FirstOrDefaultAsync(r => r.NumeroLey == "19.695" && r.Vigente);
 973        }
 974
 4975        return regimen!.Id;
 4976    }
 977
 978    #endregion
 979
 980    public async Task<List<MovimientoReporteDto>> ObtenerReporteMovimientosAsync(int mes, int anio, string? tipo)
 981    {
 0982        var tipoNorm = tipo?.ToLower();
 983
 984        // Traer movimientos del mes/año con sus relaciones
 0985        var movimientos = await _context.MovimientosLaborales
 0986            .Include(m => m.TipoMovimiento)
 0987            .Include(m => m.RelacionLaboral)
 0988                .ThenInclude(r => r.Persona)
 0989            .Include(m => m.RelacionLaboral)
 0990                .ThenInclude(r => r.Grado)
 0991            .Include(m => m.RelacionLaboral)
 0992                .ThenInclude(r => r.Escalafon)
 0993            .Include(m => m.RelacionLaboral)
 0994                .ThenInclude(r => r.Unidad)
 0995            .Include(m => m.RelacionLaboral)
 0996                .ThenInclude(r => r.Programa)
 0997            .Include(m => m.RelacionLaboral)
 0998                .ThenInclude(r => r.Regimen)
 0999            .Where(m => m.FechaMovimiento.Month == mes && m.FechaMovimiento.Year == anio)
 01000            .OrderBy(m => m.FechaMovimiento)
 01001            .ToListAsync();
 1002
 1003        // Para ascensos: agrupar los movimientos de cierre + alta para emitir un solo renglón
 01004        var resultado = new List<MovimientoReporteDto>();
 01005        var procesados = new HashSet<long>();
 1006
 01007        foreach (var mov in movimientos)
 1008        {
 01009            if (procesados.Contains(mov.Id)) continue;
 1010
 01011            var nombreTipo = mov.TipoMovimiento.Nombre.ToLower();
 1012            string categoriaReporte;
 1013
 01014            if (nombreTipo.Contains("alta por ascenso") || nombreTipo.Contains("ascenso"))
 1015            {
 01016                categoriaReporte = "Ascenso";
 01017                if (tipoNorm != null && tipoNorm != "ascenso" && tipoNorm != "todos") continue;
 1018
 1019                // Buscar el movimiento de cierre del mismo día para obtener grado anterior
 01020                var cierreRelacionado = movimientos.FirstOrDefault(m =>
 01021                    !procesados.Contains(m.Id) &&
 01022                    m.Id != mov.Id &&
 01023                    m.FechaMovimiento.Date == mov.FechaMovimiento.Date &&
 01024                    m.RelacionLaboral.PersonaId == mov.RelacionLaboral.PersonaId &&
 01025                    (m.TipoMovimiento.Nombre.ToLower().Contains("baja por ascenso") ||
 01026                     m.TipoMovimiento.Nombre.ToLower().Contains("cambio de situaci")));
 1027
 01028                var gradoAnterior = cierreRelacionado?.RelacionLaboral.Grado.Denominacion;
 01029                if (cierreRelacionado != null) procesados.Add(cierreRelacionado.Id);
 1030
 01031                resultado.Add(new MovimientoReporteDto
 01032                {
 01033                    TipoMovimiento = categoriaReporte,
 01034                    Grado = mov.RelacionLaboral.Grado.Denominacion,
 01035                    GradoAnterior = gradoAnterior,
 01036                    Escalafon = mov.RelacionLaboral.Escalafon.Denominacion,
 01037                    Cedula = mov.RelacionLaboral.Persona.Cedula,
 01038                    Nombre = mov.RelacionLaboral.Persona.PrimerNombre,
 01039                    Apellido = mov.RelacionLaboral.Persona.PrimerApellido,
 01040                    Unidad = mov.RelacionLaboral.Unidad.Denominacion,
 01041                    Programa = mov.RelacionLaboral.Programa.Denominacion,
 01042                    Ley = mov.RelacionLaboral.Regimen.NumeroLey,
 01043                    FechaMovimiento = mov.FechaMovimiento
 01044                });
 1045            }
 01046            else if (mov.TipoMovimiento.EsAlta &&
 01047                     !nombreTipo.Contains("baja por ascenso") &&
 01048                     !nombreTipo.Contains("cambio de situaci"))
 1049            {
 01050                categoriaReporte = "Alta";
 01051                if (tipoNorm != null && tipoNorm != "alta" && tipoNorm != "todos") continue;
 1052
 01053                resultado.Add(new MovimientoReporteDto
 01054                {
 01055                    TipoMovimiento = categoriaReporte,
 01056                    Grado = mov.RelacionLaboral.Grado.Denominacion,
 01057                    Escalafon = mov.RelacionLaboral.Escalafon.Denominacion,
 01058                    Cedula = mov.RelacionLaboral.Persona.Cedula,
 01059                    Nombre = mov.RelacionLaboral.Persona.PrimerNombre,
 01060                    Apellido = mov.RelacionLaboral.Persona.PrimerApellido,
 01061                    Unidad = mov.RelacionLaboral.Unidad.Denominacion,
 01062                    Programa = mov.RelacionLaboral.Programa.Denominacion,
 01063                    Ley = mov.RelacionLaboral.Regimen.NumeroLey,
 01064                    FechaMovimiento = mov.FechaMovimiento
 01065                });
 1066            }
 01067            else if (!mov.TipoMovimiento.EsAlta &&
 01068                     !nombreTipo.Contains("baja por ascenso") &&
 01069                     !nombreTipo.Contains("cambio de situaci") &&
 01070                     !nombreTipo.Contains("ascenso"))
 1071            {
 01072                categoriaReporte = "Baja";
 01073                if (tipoNorm != null && tipoNorm != "baja" && tipoNorm != "todos") continue;
 1074
 01075                resultado.Add(new MovimientoReporteDto
 01076                {
 01077                    TipoMovimiento = categoriaReporte,
 01078                    Grado = mov.RelacionLaboral.Grado.Denominacion,
 01079                    Escalafon = mov.RelacionLaboral.Escalafon.Denominacion,
 01080                    Cedula = mov.RelacionLaboral.Persona.Cedula,
 01081                    Nombre = mov.RelacionLaboral.Persona.PrimerNombre,
 01082                    Apellido = mov.RelacionLaboral.Persona.PrimerApellido,
 01083                    Unidad = mov.RelacionLaboral.Unidad.Denominacion,
 01084                    Programa = mov.RelacionLaboral.Programa.Denominacion,
 01085                    Ley = mov.RelacionLaboral.Regimen.NumeroLey,
 01086                    FechaMovimiento = mov.FechaMovimiento
 01087                });
 1088            }
 1089
 01090            procesados.Add(mov.Id);
 1091        }
 1092
 01093        return resultado;
 01094    }
 1095}
Generated by: ReportGenerator 5.5.10.0
06/07/2026 - 23:10:45
GitHub | reportgenerator.io

Methods/Properties

.ctor(FAU.DataAccess.Repositories.IPersonalRepository,FAU.DataAccess.Repositories.IMotivoBajaRepository,FAU.DataAccess.ApplicationDbContext,Microsoft.Extensions.Logging.ILogger`1<FAU.Logica.Services.PersonalService>,FAU.Logica.Services.IAuditoriaService,FAU.Logica.Services.ICurrentUserContext)
GetPersonalListAsync()
GetDetalleAsync()
CreatePersonalAsync()
UpdatePersonalAsync()
RegistrarBajaAsync()
RegistrarAscensoAsync()
ApplyOrdering(System.Linq.IQueryable`1<FAU.Entidades.RelacionLaboral>,System.String,System.String)
DeterminarRegimenIdAsync()
ObtenerReporteMovimientosAsync()