< 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
69%
Covered lines: 485
Uncovered lines: 210
Coverable lines: 695
Total lines: 1068
Line coverage: 69.7%
Branch coverage
37%
Covered branches: 161
Total branches: 424
Branch coverage: 37.9%
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%543676%
UpdatePersonalAsync()37.06%271623264.13%
RegistrarBajaAsync()62.5%252486.44%
RegistrarAscensoAsync()75%333291.58%
ApplyOrdering(...)27.27%2262225%
DeterminarRegimenIdAsync()100%11100%
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                CategoriaViatico = relacionLaboral.CategoriaViatico,
 2236                UsaFonasa = relacionLaboral.UsaFonasa,
 2237                AniosServicioAnterior = relacionLaboral.AniosServicioAnterior,
 2238                PrimaTecnica = relacionLaboral.PrimaTecnica,
 2239                PrimaSolidariaFamiliar = relacionLaboral.PrimaSolidariaFamiliar,
 2240                AniosInactivos = relacionLaboral.AniosInactivos,
 2241                Observaciones = relacionLaboral.Observaciones
 2242            },
 2243            Historial = historial
 2244        };
 3245    }
 246
 247    public async Task<(bool success, long? personalId, string? error)> CreatePersonalAsync(CreatePersonalRequest request
 248    {
 249        try
 250        {
 251            // Validar y limpiar CI
 4252            var cedulaLimpia = CedulaValidator.Limpiar(request.Ci);
 4253            if (!CedulaValidator.Validar(cedulaLimpia))
 254            {
 1255                return (false, null, "La cédula ingresada no es válida.");
 256            }
 257
 258            // Validar que la fecha de ingreso no sea futura
 3259            var errorFechaIngreso = FechaIngresoValidator.ObtenerErrorSiEsFutura(request.FechaIngreso);
 3260            if (errorFechaIngreso != null)
 261            {
 1262                return (false, null, errorFechaIngreso);
 263            }
 264
 265            // Validar que no exista una relación laboral activa para esa cédula
 2266            var validadorRelacion = new RelacionLaboralValidator(_context);
 2267            var errorRelacionActiva = await validadorRelacion.ObtenerErrorSiExisteRelacionActiva(cedulaLimpia);
 2268            if (errorRelacionActiva != null)
 269            {
 1270                return (false, null, errorRelacionActiva);
 271            }
 272
 273            // Validar que el grado pertenece al escalafón indicado
 1274            var escalafonId = request.EscalafonId ?? 1;
 1275            var grado = await _context.Grados.FindAsync(request.GradoId);
 1276            if (grado == null)
 0277                return (false, null, "El grado seleccionado no existe.");
 278            // TODO: reactivar validación cuando el frontend envíe EscalafonId correctamente
 279            // if (grado.EscalafonId != escalafonId)
 280            //     return (false, null, "El grado seleccionado no pertenece al escalafón indicado.");
 281
 282            // Validar fecha de nacimiento
 1283            if (request.FechaNacimiento != default)
 284            {
 1285                var fechaNac = request.FechaNacimiento.Date;
 1286                if (fechaNac > DateTime.Now.Date)
 0287                    return (false, null, "La fecha de nacimiento no puede ser futura.");
 1288                if (fechaNac < new DateTime(1940, 1, 1))
 0289                    return (false, null, "La fecha de nacimiento no puede ser anterior a 01/01/1940.");
 290            }
 291
 292            // Buscar o crear persona
 1293            Persona? persona = await _context.Personas.FirstOrDefaultAsync(p => p.Cedula == cedulaLimpia);
 294
 1295            if (persona == null)
 296            {
 297                // Crear persona - Convertir fechas a UTC
 1298                var fechaNacimientoUtc = request.FechaNacimiento.Kind == DateTimeKind.Unspecified
 1299                    ? DateTime.SpecifyKind(request.FechaNacimiento.Date, DateTimeKind.Utc)
 1300                    : request.FechaNacimiento.Date.ToUniversalTime();
 301
 1302                persona = new Persona
 1303                {
 1304                    Cedula = cedulaLimpia,
 1305                    PrimerNombre = request.PrimerNombre,
 1306                    SegundoNombre = request.SegundoNombre,
 1307                    PrimerApellido = request.PrimerApellido,
 1308                    SegundoApellido = request.SegundoApellido,
 1309                    FechaNacimiento = fechaNacimientoUtc,
 1310                    Email = request.Email,
 1311                    Telefono = request.Telefono,
 1312                    Direccion = request.Direccion,
 1313                    CodigoPostal = request.CodigoPostal,
 1314                    Departamento = request.Departamento,
 1315                    Localidad = request.Localidad
 1316                };
 317
 1318                _context.Personas.Add(persona);
 1319                await _context.SaveChangesAsync();
 320            }
 321            else
 322            {
 323                // Persona ya existe: actualizar campos de dirección si vienen en el request
 0324                bool personaModificada = false;
 0325                if (request.CodigoPostal != null) { persona.CodigoPostal = request.CodigoPostal; personaModificada = tru
 0326                if (request.Departamento != null) { persona.Departamento = request.Departamento; personaModificada = tru
 0327                if (request.Localidad != null) { persona.Localidad = request.Localidad; personaModificada = true; }
 0328                if (personaModificada)
 329                {
 0330                    persona.FechaActualizacion = DateTime.Now;
 0331                    _context.Personas.Update(persona);
 0332                    await _context.SaveChangesAsync();
 333                }
 334            }
 335
 336            // Determinar régimen: explícito si se pasa, sino auto-calcular
 337            long regimenId;
 1338            if (!string.IsNullOrWhiteSpace(request.Ley))
 339            {
 0340                var regimenExplicito = await _context.Regimenes
 0341                    .FirstOrDefaultAsync(r => r.NumeroLey == request.Ley && r.Vigente);
 0342                if (regimenExplicito == null)
 0343                    return (false, null, $"No se encontró el régimen con ley {request.Ley}");
 0344                regimenId = regimenExplicito.Id;
 345            }
 346            else
 347            {
 1348                regimenId = await DeterminarRegimenIdAsync(request.FechaIngreso, request.EscalafonId);
 349            }
 350
 351            // Crear relación laboral - Convertir fechas a UTC
 1352            var fechaIngresoUtc = request.FechaIngreso.Kind == DateTimeKind.Unspecified
 1353                ? DateTime.SpecifyKind(request.FechaIngreso.Date, DateTimeKind.Utc)
 1354                : request.FechaIngreso.Date.ToUniversalTime();
 355
 1356            var relacionLaboral = new RelacionLaboral
 1357            {
 1358                PersonaId = persona.Id,
 1359                RegimenId = regimenId,
 1360                EscalafonId = request.EscalafonId ?? 1,
 1361                GradoId = request.GradoId,
 1362                SituacionId = request.SituacionId ?? 1,
 1363                ProgramaId = request.ProgramaId ?? 1,
 1364                UnidadId = request.UnidadId ?? 1,
 1365                SubUnidadId = request.SubUnidadId,
 1366                Estado = EstadoRelacion.Activo,
 1367                FechaInicio = fechaIngresoUtc,
 1368                Observaciones = request.Observaciones,
 1369                // Campos de compensación desde el alta
 1370                RiesgoVuelo = request.RiesgoVuelo,
 1371                PrimaTecnica = string.IsNullOrWhiteSpace(request.PrimaTecnica) ? null : request.PrimaTecnica.Trim(),
 1372                CategoriaViatico = request.CategoriaViatico ?? 0,
 1373                UsaFonasa = request.UsaFonasa ?? false,
 1374                AniosServicioAnterior = request.AniosServicioAnterior ?? 0,
 1375            };
 376
 1377            _context.RelacionesLaborales.Add(relacionLaboral);
 1378            await _context.SaveChangesAsync();
 379
 380            // Prima Solidaria Familiar NO se asigna automáticamente — no aplica a todos.
 381            // Se carga manualmente desde Beneficios Sociales cuando corresponde.
 382
 1383            await _auditoriaService.LogAuditoriaAsync(
 1384                usuarioId: _currentUser.UserId ?? 0,
 1385                AccionEnum.CrearPersonal,
 1386                ContextoEnum.Personal,
 1387                host: _currentUser.Host,
 1388                entidad: nameof(Persona),
 1389                entidadId: persona.Id,
 1390                detalle: new { relacionLaboralId = relacionLaboral.Id, personaId = persona.Id, cedula = persona.Cedula }
 391
 1392            return (true, persona.Id, null);
 393        }
 0394        catch (Exception ex)
 395        {
 0396            _logger.LogError(ex, "Error al crear personal");
 0397            var errorMessage = ex.Message;
 0398            var innerEx = ex.InnerException;
 0399            while (innerEx != null)
 400            {
 0401                errorMessage += $" | {innerEx.Message}";
 0402                innerEx = innerEx.InnerException;
 403            }
 0404            return (false, null, $"Error al crear personal: {errorMessage}");
 405        }
 4406    }
 407
 408    public async Task<(bool success, string? error)> UpdatePersonalAsync(long id, UpdatePersonalRequest request)
 409    {
 410        try
 411        {
 3412            var persona = await _context.Personas.FindAsync(id);
 3413            if (persona == null)
 1414                return (false, "Persona no encontrada");
 415
 416            // Validar campos de compensación si se proporcionan
 2417            var errorCompensacion = CompensacionValidator.ValidarCompensaciones(
 2418                request.RiesgoVuelo,
 2419                request.PrimaTecnica,
 2420                request.PrimaSolidariaFamiliar,
 2421                request.AniosInactivos);
 422
 2423            if (errorCompensacion != null)
 424            {
 0425                return (false, errorCompensacion);
 426            }
 427
 428            // Actualizar datos personales
 2429            if (!string.IsNullOrWhiteSpace(request.PrimerNombre))
 1430                persona.PrimerNombre = request.PrimerNombre.Trim();
 431
 2432            persona.SegundoNombre = string.IsNullOrWhiteSpace(request.SegundoNombre) ? null : request.SegundoNombre.Trim
 433
 2434            if (!string.IsNullOrWhiteSpace(request.PrimerApellido))
 1435                persona.PrimerApellido = request.PrimerApellido.Trim();
 436
 2437            persona.SegundoApellido = string.IsNullOrWhiteSpace(request.SegundoApellido) ? null : request.SegundoApellid
 438
 2439            if (request.FechaNacimiento.HasValue)
 440            {
 0441                var fechaNac = request.FechaNacimiento.Value;
 0442                persona.FechaNacimiento = fechaNac.Kind == DateTimeKind.Unspecified
 0443                    ? DateTime.SpecifyKind(fechaNac.Date, DateTimeKind.Utc)
 0444                    : fechaNac.Date.ToUniversalTime();
 445            }
 446
 2447            if (!string.IsNullOrWhiteSpace(request.Email))
 1448                persona.Email = request.Email.Trim();
 449
 2450            persona.Telefono = string.IsNullOrWhiteSpace(request.Telefono) ? null : request.Telefono.Trim();
 2451            persona.Direccion = string.IsNullOrWhiteSpace(request.Direccion) ? null : request.Direccion.Trim();
 2452            persona.CodigoPostal = string.IsNullOrWhiteSpace(request.CodigoPostal) ? null : request.CodigoPostal.Trim();
 2453            persona.Departamento = string.IsNullOrWhiteSpace(request.Departamento) ? null : request.Departamento.Trim();
 2454            persona.Localidad = string.IsNullOrWhiteSpace(request.Localidad) ? null : request.Localidad.Trim();
 455
 2456            if (persona.FechaNacimiento.HasValue)
 457            {
 1458                var fn = persona.FechaNacimiento.Value;
 1459                persona.FechaNacimiento = fn.Kind == DateTimeKind.Unspecified
 1460                    ? DateTime.SpecifyKind(fn.Date, DateTimeKind.Utc)
 1461                    : fn.ToUniversalTime();
 462            }
 463
 2464            persona.FechaActualizacion = DateTime.Now;
 2465            _context.Personas.Update(persona);
 466
 467            // Buscar relación activa para la persona
 2468            var relacionActiva = await _context.RelacionesLaborales
 2469                .FirstOrDefaultAsync(r => r.PersonaId == persona.Id && r.Estado == EstadoRelacion.Activo);
 470
 471            // Obtener la última relación (puede ser null)
 2472            var ultimaRelacion = await _context.RelacionesLaborales
 2473                .Where(r => r.PersonaId == persona.Id)
 2474                .OrderByDescending(r => r.FechaInicio)
 2475                .FirstOrDefaultAsync();
 476
 477            // Validar transición de estado usando la relación más relevante (activa si existe, sino la última)
 2478            var relacionParaValidacion = relacionActiva ?? ultimaRelacion;
 479
 2480            if (!string.IsNullOrWhiteSpace(request.Estado) && relacionParaValidacion != null)
 481            {
 0482                var errorTransicion = EstadoTransicionValidator.ObtenerErrorSiTransicionInvalida(
 0483                    relacionParaValidacion.Estado.ToString(),
 0484                    request.Estado);
 0485                if (errorTransicion != null)
 0486                    return (false, errorTransicion);
 487            }
 488
 489            // Determinar si se solicitaron cambios laborales
 2490            bool cambioLaboralSolicitado = request.GradoId.HasValue || request.RegimenId.HasValue || request.EscalafonId
 2491                request.SituacionId.HasValue || request.ProgramaId.HasValue || request.UnidadId.HasValue || request.SubU
 492
 2493            if (relacionActiva != null)
 494            {
 495                // Si hay relación activa, verificar si los cambios requieren crear una nueva relación
 2496                bool requiereNueva = false;
 3497                if (request.GradoId.HasValue && request.GradoId.Value != relacionActiva.GradoId) requiereNueva = true;
 2498                if (request.RegimenId.HasValue && request.RegimenId.Value != relacionActiva.RegimenId) requiereNueva = t
 2499                if (request.EscalafonId.HasValue && request.EscalafonId.Value != relacionActiva.EscalafonId) requiereNue
 2500                if (request.SituacionId.HasValue && request.SituacionId.Value != relacionActiva.SituacionId) requiereNue
 2501                if (request.ProgramaId.HasValue && request.ProgramaId.Value != relacionActiva.ProgramaId) requiereNueva 
 2502                if (request.UnidadId.HasValue && request.UnidadId.Value != relacionActiva.UnidadId) requiereNueva = true
 2503                if (request.SubUnidadId.HasValue && request.SubUnidadId.Value != relacionActiva.SubUnidadId) requiereNue
 504
 2505                if (requiereNueva)
 506                {
 507                    // Cerrar relación activa
 1508                    relacionActiva.FechaFin = DateTime.Now;
 1509                    relacionActiva.Estado = EstadoRelacion.Inactivo;
 1510                    relacionActiva.FechaActualizacion = DateTime.Now;
 511
 512                    // Crear nueva relación activa con los valores actualizados
 1513                    var nuevaRelacion = new RelacionLaboral
 1514                    {
 1515                        PersonaId = persona.Id,
 1516                        RegimenId = request.RegimenId ?? relacionActiva.RegimenId,
 1517                        EscalafonId = request.EscalafonId ?? relacionActiva.EscalafonId,
 1518                        GradoId = request.GradoId ?? relacionActiva.GradoId,
 1519                        SituacionId = request.SituacionId ?? relacionActiva.SituacionId,
 1520                        ProgramaId = request.ProgramaId ?? relacionActiva.ProgramaId,
 1521                        UnidadId = request.UnidadId ?? relacionActiva.UnidadId,
 1522                        SubUnidadId = request.SubUnidadId ?? relacionActiva.SubUnidadId,
 1523                        Estado = EstadoRelacion.Activo,
 1524                        FechaInicio = DateTime.Now,
 1525                        Observaciones = request.Observaciones ?? relacionActiva.Observaciones,
 1526                        FechaActualizacion = DateTime.Now,
 1527                        RiesgoVuelo = request.RiesgoVuelo ?? relacionActiva.RiesgoVuelo,
 1528                        PrimaTecnica = string.IsNullOrWhiteSpace(request.PrimaTecnica) ? relacionActiva.PrimaTecnica : r
 1529                        PrimaSolidariaFamiliar = string.IsNullOrWhiteSpace(request.PrimaSolidariaFamiliar) ? relacionAct
 1530                        AniosInactivos = request.AniosInactivos ?? relacionActiva.AniosInactivos
 1531                    };
 532
 1533                    _context.RelacionesLaborales.Add(nuevaRelacion);
 534                }
 535                else
 536                {
 537                    // Actualizar en sitio la relación activa
 1538                    if (!string.IsNullOrWhiteSpace(request.Estado))
 539                    {
 0540                        if (Enum.TryParse<EstadoRelacion>(request.Estado, true, out var est))
 0541                            relacionActiva.Estado = est;
 542                        else
 543                        {
 0544                            var estLower = request.Estado.Trim().ToLower();
 0545                            if (estLower == "activo") relacionActiva.Estado = EstadoRelacion.Activo;
 0546                            else if (estLower == "inactivo") relacionActiva.Estado = EstadoRelacion.Inactivo;
 547                        }
 548                    }
 549
 1550                    if (request.RegimenId.HasValue) relacionActiva.RegimenId = request.RegimenId.Value;
 1551                    if (request.EscalafonId.HasValue) relacionActiva.EscalafonId = request.EscalafonId.Value;
 1552                    if (request.GradoId.HasValue) relacionActiva.GradoId = request.GradoId.Value;
 1553                    if (request.SituacionId.HasValue) relacionActiva.SituacionId = request.SituacionId.Value;
 1554                    if (request.ProgramaId.HasValue) relacionActiva.ProgramaId = request.ProgramaId.Value;
 1555                    if (request.UnidadId.HasValue) relacionActiva.UnidadId = request.UnidadId.Value;
 1556                    if (request.SubUnidadId.HasValue) relacionActiva.SubUnidadId = request.SubUnidadId.Value;
 557
 1558                    if (request.RiesgoVuelo.HasValue) relacionActiva.RiesgoVuelo = request.RiesgoVuelo;
 1559                    if (request.CategoriaViatico.HasValue) relacionActiva.CategoriaViatico = request.CategoriaViatico.Va
 1560                    if (request.UsaFonasa.HasValue) relacionActiva.UsaFonasa = request.UsaFonasa.Value;
 1561                    if (request.AniosServicioAnterior.HasValue) relacionActiva.AniosServicioAnterior = request.AniosServ
 1562                    if (request.PrimaTecnica != null) relacionActiva.PrimaTecnica = string.IsNullOrWhiteSpace(request.Pr
 1563                    if (request.PrimaSolidariaFamiliar != null) relacionActiva.PrimaSolidariaFamiliar = string.IsNullOrW
 1564                    if (request.AniosInactivos.HasValue) relacionActiva.AniosInactivos = request.AniosInactivos;
 1565                    if (request.Observaciones != null) relacionActiva.Observaciones = request.Observaciones;
 566
 1567                    relacionActiva.FechaActualizacion = DateTime.Now;
 568                }
 569            }
 570            else
 571            {
 572                // No hay relación activa
 0573                if (cambioLaboralSolicitado)
 574                {
 575                    // Crear nueva relación activa basándose en la última relación si existe
 0576                    var plantilla = ultimaRelacion;
 577
 0578                    var nuevaRelacion = new RelacionLaboral
 0579                    {
 0580                        PersonaId = persona.Id,
 0581                        RegimenId = request.RegimenId ?? plantilla?.RegimenId ?? 0,
 0582                        EscalafonId = request.EscalafonId ?? plantilla?.EscalafonId ?? 0,
 0583                        GradoId = request.GradoId ?? plantilla?.GradoId ?? 0,
 0584                        SituacionId = request.SituacionId ?? plantilla?.SituacionId ?? 0,
 0585                        ProgramaId = request.ProgramaId ?? plantilla?.ProgramaId ?? 0,
 0586                        UnidadId = request.UnidadId ?? plantilla?.UnidadId ?? 0,
 0587                        SubUnidadId = request.SubUnidadId ?? plantilla?.SubUnidadId,
 0588                        Estado = EstadoRelacion.Activo,
 0589                        FechaInicio = DateTime.Now,
 0590                        Observaciones = request.Observaciones ?? plantilla?.Observaciones,
 0591                        FechaActualizacion = DateTime.Now,
 0592                        RiesgoVuelo = request.RiesgoVuelo ?? plantilla?.RiesgoVuelo,
 0593                        CategoriaViatico = request.CategoriaViatico ?? plantilla?.CategoriaViatico ?? 0,
 0594                        UsaFonasa = request.UsaFonasa ?? plantilla?.UsaFonasa ?? false,
 0595                        AniosServicioAnterior = request.AniosServicioAnterior ?? plantilla?.AniosServicioAnterior ?? 0,
 0596                        PrimaTecnica = string.IsNullOrWhiteSpace(request.PrimaTecnica) ? plantilla?.PrimaTecnica : reque
 0597                        PrimaSolidariaFamiliar = string.IsNullOrWhiteSpace(request.PrimaSolidariaFamiliar) ? plantilla?.
 0598                        AniosInactivos = request.AniosInactivos ?? plantilla?.AniosInactivos
 0599                    };
 600
 0601                    _context.RelacionesLaborales.Add(nuevaRelacion);
 602                }
 603                else
 604                {
 605                    // Solo actualizar estado u observaciones de la última relación si existe
 0606                    if (ultimaRelacion != null)
 607                    {
 0608                        if (!string.IsNullOrWhiteSpace(request.Estado))
 609                        {
 0610                            if (Enum.TryParse<EstadoRelacion>(request.Estado, true, out var est))
 0611                                ultimaRelacion.Estado = est;
 612                            else
 613                            {
 0614                                var estLower = request.Estado.Trim().ToLower();
 0615                                if (estLower == "activo") ultimaRelacion.Estado = EstadoRelacion.Activo;
 0616                                else if (estLower == "inactivo") ultimaRelacion.Estado = EstadoRelacion.Inactivo;
 617                            }
 618                        }
 619
 0620                        if (request.Observaciones != null) ultimaRelacion.Observaciones = request.Observaciones;
 0621                        ultimaRelacion.FechaActualizacion = DateTime.Now;
 622                    }
 623                }
 624            }
 625
 2626            await _context.SaveChangesAsync();
 627
 2628            return (true, null);
 629        }
 0630        catch (Exception ex)
 631        {
 0632            _logger.LogError(ex, "Error al actualizar personal");
 0633            return (false, $"Error al actualizar personal: {ex.Message}");
 634        }
 3635    }
 636
 637    public async Task<(bool success, string? error)> RegistrarBajaAsync(long id, RegistrarBajaRequest request)
 638    {
 639        try
 640        {
 641            // id is PersonaId: buscar la relación laboral activa de la persona
 4642            var relacionLaboral = await _context.RelacionesLaborales
 4643                .FirstOrDefaultAsync(r => r.PersonaId == id && r.Estado == EstadoRelacion.Activo);
 644
 4645            if (relacionLaboral == null)
 646            {
 1647                return (false, "Relación laboral no encontrada");
 648            }
 649
 650            // Validar y obtener el MotivoBaja (catálogo UCU)
 3651            if (request.MotivoBajaId <= 0)
 1652                return (false, "El motivo de baja (catálogo) es requerido");
 653
 2654            var motivoBaja = await _motivoBajaRepository.GetByIdAsync(request.MotivoBajaId);
 2655            if (motivoBaja == null)
 0656                return (false, "Motivo de baja (catálogo) no encontrado o no vigente");
 657
 658            // Determinar TipoMovimiento automáticamente según el motivo:
 659            //   RETIRO_OBL / RETIRO_VOL → "Retiro" | resto → "Baja"
 2660            var nombreTipo = motivoBaja.Codigo is "RETIRO_OBL" or "RETIRO_VOL" ? "Retiro" : "Baja";
 2661            var tipoMovimiento = await _context.TiposMovimiento
 2662                .FirstOrDefaultAsync(t => t.Nombre == nombreTipo && !t.EsAlta);
 663
 2664            if (tipoMovimiento == null)
 1665                return (false, $"Tipo de movimiento '{nombreTipo}' no encontrado en el catálogo");
 666
 667            // Validar que la fecha de baja no sea futura
 1668            var errorFechaBaja = FechaIngresoValidator.ObtenerErrorSiEsFutura(request.FechaBaja);
 1669            if (errorFechaBaja != null)
 670            {
 0671                return (false, errorFechaBaja);
 672            }
 673
 674            // Validar fecha de baja vs último movimiento y fecha de inicio
 1675            var validadorMovimiento = new MovimientoLaboralValidator(_context);
 1676            var errorFechaMovimiento = await validadorMovimiento.ValidarFechaMovimiento(relacionLaboral.Id, request.Fech
 1677            if (errorFechaMovimiento != null)
 678            {
 0679                return (false, errorFechaMovimiento);
 680            }
 681
 1682            var errorFechaBajaVsMovimiento = await validadorMovimiento.ValidarFechaBajaVsUltimoMovimiento(relacionLabora
 1683            if (errorFechaBajaVsMovimiento != null)
 684            {
 0685                return (false, errorFechaBajaVsMovimiento);
 686            }
 687
 688            // Validar transición de estado: debe ir de activo a inactivo
 1689            var errorTransicion = EstadoTransicionValidator.ObtenerErrorSiTransicionInvalida(
 1690                relacionLaboral.Estado.ToString(),
 1691                "Inactivo");
 692
 1693            if (errorTransicion != null)
 694            {
 0695                return (false, errorTransicion);
 696            }
 697
 698            // Cambiar estado a inactivo
 1699            relacionLaboral.Estado = EstadoRelacion.Inactivo;
 1700            var fechaBajaUtc = request.FechaBaja.Kind == DateTimeKind.Unspecified
 1701                ? DateTime.SpecifyKind(request.FechaBaja.Date, DateTimeKind.Utc)
 1702                : request.FechaBaja.Date.ToUniversalTime();
 1703            relacionLaboral.FechaFin = fechaBajaUtc;
 1704            relacionLaboral.MotivoBajaId = request.MotivoBajaId;
 1705            relacionLaboral.FechaActualizacion = DateTime.Now;
 706
 707            // Registrar movimiento de baja
 1708            var movimiento = new MovimientoLaboral
 1709            {
 1710                RelacionLaboralId = relacionLaboral.Id,
 1711                TipoMovimientoId = tipoMovimiento.Id,
 1712                FechaMovimiento = fechaBajaUtc,
 1713                UsuarioId = _currentUser.UserId ?? 0,
 1714                Observaciones = request.Observaciones
 1715            };
 716
 1717            _context.MovimientosLaborales.Add(movimiento);
 1718            await _context.SaveChangesAsync();
 719
 1720            await _auditoriaService.LogAuditoriaAsync(
 1721                usuarioId: _currentUser.UserId ?? 0,
 1722                AccionEnum.BajaPersonal,
 1723                ContextoEnum.Personal,
 1724                host: _currentUser.Host,
 1725                entidad: nameof(RelacionLaboral),
 1726                entidadId: relacionLaboral.Id,
 1727                detalle: new { personaId = id, relacionLaboralId = relacionLaboral.Id, request });
 728
 1729            return (true, null);
 730        }
 0731        catch (Exception ex)
 732        {
 0733            _logger.LogError(ex, "Error al registrar baja");
 0734            return (false, $"Error al registrar baja: {ex.Message}");
 735        }
 4736    }
 737
 738    public async Task<(bool success, string? error)> RegistrarAscensoAsync(long id, AscensoRequest request)
 739    {
 740        try
 741        {
 5742            var relacionLaboral = await _context.RelacionesLaborales
 5743                .FirstOrDefaultAsync(r => r.PersonaId == id && r.Estado == EstadoRelacion.Activo);
 744
 5745            if (relacionLaboral == null)
 1746                return (false, "Relación laboral no encontrada");
 747
 748            // Validar grado objetivo
 4749            var grado = await _context.Grados.FirstOrDefaultAsync(g => g.Id == request.NuevoGradoId && g.Vigente);
 4750            if (grado == null)
 1751                return (false, "Grado no encontrado");
 752
 753            // Calcular régimen automáticamente según fecha de ingreso y escalafón (igual que en el Alta)
 3754            var regimenAscensoId = await DeterminarRegimenIdAsync(relacionLaboral.FechaInicio, relacionLaboral.Escalafon
 3755            var regimenAscenso = await _context.Regimenes.FindAsync(regimenAscensoId);
 3756            if (regimenAscenso == null)
 0757                return (false, "No se pudo determinar el régimen para el ascenso");
 758
 759            // Validar que el grado objetivo
 3760            if (relacionLaboral.GradoId != 0)
 761            {
 3762                var gradoActual = await _context.Grados.FirstOrDefaultAsync(g => g.Id == relacionLaboral.GradoId);
 3763                if (gradoActual != null)
 764                {
 3765                    if (grado.Orden <= gradoActual.Orden)
 766                    {
 1767                        return (false, "El grado objetivo debe ser superior al grado actual");
 768                    }
 769                }
 770            }
 771
 2772            var fechaAscensoUtc = request.FechaAscenso.Kind == DateTimeKind.Unspecified
 2773                ? DateTime.SpecifyKind(request.FechaAscenso.Date, DateTimeKind.Utc)
 2774                : request.FechaAscenso.Date.ToUniversalTime();
 775
 776            // Validar unidad objetivo si se proporciona
 777            Unidad? unidadObj = null;
 2778            if (request.UnidadId.HasValue)
 779            {
 0780                unidadObj = await _context.Unidades.FirstOrDefaultAsync(u => u.Id == request.UnidadId.Value && u.Vigente
 0781                if (unidadObj == null)
 782                {
 0783                    return (false, "Unidad no válida o no vigente");
 784                }
 785            }
 786
 787            // Cerrar la relación laboral actual
 788            // Validar transición: debe estar activo para poder ascender
 2789            var errorTransicion = EstadoTransicionValidator.ObtenerErrorSiTransicionInvalida(
 2790                relacionLaboral.Estado.ToString(),
 2791                "Inactivo");
 792
 2793            if (errorTransicion != null)
 794            {
 0795                return (false, errorTransicion);
 796            }
 797
 2798            relacionLaboral.FechaFin = fechaAscensoUtc;
 2799            relacionLaboral.FechaActualizacion = DateTime.Now;
 2800            relacionLaboral.Estado = EstadoRelacion.Inactivo;
 2801            relacionLaboral.Observaciones = request.Observacion;
 802
 803            // Validar programa objetivo
 2804            var programaAscenso = await _context.Programas.FirstOrDefaultAsync(p => p.Id == request.ProgramaId && p.Vige
 2805            if (programaAscenso == null)
 1806                return (false, "Programa no válido o no vigente");
 807
 808            // Determinar prima técnica: al ascender a Sgto. 1° se desactiva la prima técnica variable
 1809            var primaTecnicaNueva = relacionLaboral.PrimaTecnica;
 1810            if (grado.Codigo == "SGTO_1RO")
 0811                primaTecnicaNueva = "VACIO";
 812
 813            // Crear nueva relación laboral con el nuevo grado
 1814            var nuevaRelacion = new RelacionLaboral
 1815            {
 1816                PersonaId = relacionLaboral.PersonaId,
 1817                RegimenId = regimenAscenso.Id,
 1818                EscalafonId = relacionLaboral.EscalafonId,
 1819                GradoId = request.NuevoGradoId,
 1820                SituacionId = relacionLaboral.SituacionId,
 1821                ProgramaId = request.ProgramaId,
 1822                UnidadId = request.UnidadId ?? relacionLaboral.UnidadId,
 1823                SubUnidadId = request.SubUnidadId ?? relacionLaboral.SubUnidadId,
 1824                Estado = EstadoRelacion.Activo,
 1825                FechaInicio = fechaAscensoUtc,
 1826                PrimaTecnica = primaTecnicaNueva,
 1827                PrimaSolidariaFamiliar = relacionLaboral.PrimaSolidariaFamiliar,
 1828                RiesgoVuelo = relacionLaboral.RiesgoVuelo,
 1829                CategoriaViatico = relacionLaboral.CategoriaViatico,
 1830                UsaFonasa = relacionLaboral.UsaFonasa,
 1831                AniosServicioAnterior = relacionLaboral.AniosServicioAnterior,
 1832                Observaciones = relacionLaboral.Observaciones,
 1833                FechaActualizacion = DateTime.Now
 1834            };
 835
 1836            _context.RelacionesLaborales.Add(nuevaRelacion);
 837
 838            // Registrar movimientos
 839            // Prefer specific tipo_movimiento ids: 6 = Cambio de Situacion (cierre), 7 = Ascenso (alta)
 1840            var tipoCierre = await _context.TiposMovimiento.FirstOrDefaultAsync(t => t.Nombre.ToLower().Contains("cambio
 1841            var tipoAlta = await _context.TiposMovimiento.FirstOrDefaultAsync(t => t.Nombre.ToLower().Contains("ascenso"
 842
 1843            if (tipoCierre == null)
 844            {
 1845                tipoCierre = new Entidades.TipoMovimiento { Nombre = "Cambio de Situacion", EsAlta = false };
 1846                _context.TiposMovimiento.Add(tipoCierre);
 1847                await _context.SaveChangesAsync();
 848            }
 849
 1850            if (tipoAlta == null)
 851            {
 1852                tipoAlta = new Entidades.TipoMovimiento { Nombre = "Ascenso", EsAlta = true };
 1853                _context.TiposMovimiento.Add(tipoAlta);
 1854                await _context.SaveChangesAsync();
 855            }
 856
 857            // Movimiento de cierre
 1858            var movimientoCierre = new Entidades.MovimientoLaboral
 1859            {
 1860                RelacionLaboralId = relacionLaboral.Id,
 1861                TipoMovimientoId = tipoCierre.Id,
 1862                FechaMovimiento = fechaAscensoUtc,
 1863                UsuarioId = _currentUser.UserId ?? 0,
 1864                Observaciones = request.Observacion,
 1865                Puesto = request.Puesto,
 1866                Plaza = request.Plaza
 1867            };
 868
 1869            _context.MovimientosLaborales.Add(movimientoCierre);
 870
 1871            await _context.SaveChangesAsync();
 872
 1873            var movimientoAlta = new Entidades.MovimientoLaboral
 1874            {
 1875                RelacionLaboralId = nuevaRelacion.Id,
 1876                TipoMovimientoId = tipoAlta.Id,
 1877                FechaMovimiento = fechaAscensoUtc,
 1878                UsuarioId = _currentUser.UserId ?? 0,
 1879                Observaciones = request.Observacion,
 1880                Puesto = request.Puesto,
 1881                Plaza = request.Plaza
 1882            };
 883
 1884            _context.MovimientosLaborales.Add(movimientoAlta);
 885
 1886            await _context.SaveChangesAsync();
 887
 1888            await _auditoriaService.LogAuditoriaAsync(
 1889                usuarioId: _currentUser.UserId ?? 0,
 1890                AccionEnum.AscensoPersonal,
 1891                ContextoEnum.Personal,
 1892                host: _currentUser.Host,
 1893                entidad: nameof(RelacionLaboral),
 1894                entidadId: nuevaRelacion.Id,
 1895                detalle: new { personaId = id, relacionAnteriorId = relacionLaboral.Id, relacionNuevaId = nuevaRelacion.
 896
 1897            return (true, null);
 898        }
 0899        catch (Exception ex)
 900        {
 0901            _logger.LogError(ex, "Error al registrar ascenso");
 0902            return (false, $"Error al registrar ascenso: {ex.Message}");
 903        }
 5904    }
 905
 906    private IQueryable<RelacionLaboral> ApplyOrdering(
 907        IQueryable<RelacionLaboral> query,
 908        string? orderBy,
 909        string sort)
 910    {
 1911        var ascending = sort.ToLower() == "asc";
 912
 1913        return orderBy?.ToLower() switch
 1914        {
 0915            "ci" => ascending
 0916                ? query.OrderBy(r => r.Persona.Cedula)
 0917                : query.OrderByDescending(r => r.Persona.Cedula),
 0918            "nombre" => ascending
 0919                ? query.OrderBy(r => r.Persona.PrimerNombre)
 0920                : query.OrderByDescending(r => r.Persona.PrimerNombre),
 0921            "apellido" => ascending
 0922                ? query.OrderBy(r => r.Persona.PrimerApellido)
 0923                : query.OrderByDescending(r => r.Persona.PrimerApellido),
 0924            "grado" => ascending
 0925                ? query.OrderBy(r => r.Grado.Orden)
 0926                : query.OrderByDescending(r => r.Grado.Orden),
 0927            "fechaingreso" => ascending
 0928                ? query.OrderBy(r => r.FechaInicio)
 0929                : query.OrderByDescending(r => r.FechaInicio),
 1930            _ => query.OrderByDescending(r => r.FechaInicio)
 1931        };
 932    }
 933
 934    #region Métodos Privados
 935
 936    /// <summary>
 937    /// Fallback cuando el alta no especifica la ley explícitamente.
 938    /// En el legacy (FoxPro), PERSONAL.Ley_Vieja es un campo manual por persona —
 939    /// no existe una regla automática confiable (depende de la situación previsional
 940    /// real del funcionario al momento de la reforma). Por eso siempre se retorna
 941    /// Ley Nueva (19.695) como fallback seguro, y se recomienda enviar el campo
 942    /// Ley explícitamente en el alta.
 943    /// </summary>
 944    private async Task<long> DeterminarRegimenIdAsync(DateTime fechaIngreso, long? escalafonId)
 945    {
 4946        var regimen = await _context.Regimenes
 4947            .FirstOrDefaultAsync(r => r.NumeroLey == "19.695" && r.Vigente);
 4948        return regimen!.Id;
 4949    }
 950
 951    #endregion
 952
 953    public async Task<List<MovimientoReporteDto>> ObtenerReporteMovimientosAsync(int mes, int anio, string? tipo)
 954    {
 0955        var tipoNorm = tipo?.ToLower();
 956
 957        // Traer movimientos del mes/año con sus relaciones
 0958        var movimientos = await _context.MovimientosLaborales
 0959            .Include(m => m.TipoMovimiento)
 0960            .Include(m => m.RelacionLaboral)
 0961                .ThenInclude(r => r.Persona)
 0962            .Include(m => m.RelacionLaboral)
 0963                .ThenInclude(r => r.Grado)
 0964            .Include(m => m.RelacionLaboral)
 0965                .ThenInclude(r => r.Escalafon)
 0966            .Include(m => m.RelacionLaboral)
 0967                .ThenInclude(r => r.Unidad)
 0968            .Include(m => m.RelacionLaboral)
 0969                .ThenInclude(r => r.Programa)
 0970            .Include(m => m.RelacionLaboral)
 0971                .ThenInclude(r => r.Regimen)
 0972            .Where(m => m.FechaMovimiento.Month == mes && m.FechaMovimiento.Year == anio)
 0973            .OrderBy(m => m.FechaMovimiento)
 0974            .ToListAsync();
 975
 976        // Para ascensos: agrupar los movimientos de cierre + alta para emitir un solo renglón
 0977        var resultado = new List<MovimientoReporteDto>();
 0978        var procesados = new HashSet<long>();
 979
 0980        foreach (var mov in movimientos)
 981        {
 0982            if (procesados.Contains(mov.Id)) continue;
 983
 0984            var nombreTipo = mov.TipoMovimiento.Nombre.ToLower();
 985            string categoriaReporte;
 986
 0987            if (nombreTipo.Contains("alta por ascenso") || nombreTipo.Contains("ascenso"))
 988            {
 0989                categoriaReporte = "Ascenso";
 0990                if (tipoNorm != null && tipoNorm != "ascenso" && tipoNorm != "todos") continue;
 991
 992                // Buscar el movimiento de cierre del mismo día para obtener grado anterior
 0993                var cierreRelacionado = movimientos.FirstOrDefault(m =>
 0994                    !procesados.Contains(m.Id) &&
 0995                    m.Id != mov.Id &&
 0996                    m.FechaMovimiento.Date == mov.FechaMovimiento.Date &&
 0997                    m.RelacionLaboral.PersonaId == mov.RelacionLaboral.PersonaId &&
 0998                    (m.TipoMovimiento.Nombre.ToLower().Contains("baja por ascenso") ||
 0999                     m.TipoMovimiento.Nombre.ToLower().Contains("cambio de situaci")));
 1000
 01001                var gradoAnterior = cierreRelacionado?.RelacionLaboral.Grado.Denominacion;
 01002                if (cierreRelacionado != null) procesados.Add(cierreRelacionado.Id);
 1003
 01004                resultado.Add(new MovimientoReporteDto
 01005                {
 01006                    TipoMovimiento = categoriaReporte,
 01007                    Grado = mov.RelacionLaboral.Grado.Denominacion,
 01008                    GradoAnterior = gradoAnterior,
 01009                    Escalafon = mov.RelacionLaboral.Escalafon.Denominacion,
 01010                    Cedula = mov.RelacionLaboral.Persona.Cedula,
 01011                    Nombre = mov.RelacionLaboral.Persona.PrimerNombre,
 01012                    Apellido = mov.RelacionLaboral.Persona.PrimerApellido,
 01013                    Unidad = mov.RelacionLaboral.Unidad.Denominacion,
 01014                    Programa = mov.RelacionLaboral.Programa.Denominacion,
 01015                    Ley = mov.RelacionLaboral.Regimen.NumeroLey,
 01016                    FechaMovimiento = mov.FechaMovimiento
 01017                });
 1018            }
 01019            else if (mov.TipoMovimiento.EsAlta &&
 01020                     !nombreTipo.Contains("baja por ascenso") &&
 01021                     !nombreTipo.Contains("cambio de situaci"))
 1022            {
 01023                categoriaReporte = "Alta";
 01024                if (tipoNorm != null && tipoNorm != "alta" && tipoNorm != "todos") continue;
 1025
 01026                resultado.Add(new MovimientoReporteDto
 01027                {
 01028                    TipoMovimiento = categoriaReporte,
 01029                    Grado = mov.RelacionLaboral.Grado.Denominacion,
 01030                    Escalafon = mov.RelacionLaboral.Escalafon.Denominacion,
 01031                    Cedula = mov.RelacionLaboral.Persona.Cedula,
 01032                    Nombre = mov.RelacionLaboral.Persona.PrimerNombre,
 01033                    Apellido = mov.RelacionLaboral.Persona.PrimerApellido,
 01034                    Unidad = mov.RelacionLaboral.Unidad.Denominacion,
 01035                    Programa = mov.RelacionLaboral.Programa.Denominacion,
 01036                    Ley = mov.RelacionLaboral.Regimen.NumeroLey,
 01037                    FechaMovimiento = mov.FechaMovimiento
 01038                });
 1039            }
 01040            else if (!mov.TipoMovimiento.EsAlta &&
 01041                     !nombreTipo.Contains("baja por ascenso") &&
 01042                     !nombreTipo.Contains("cambio de situaci") &&
 01043                     !nombreTipo.Contains("ascenso"))
 1044            {
 01045                categoriaReporte = "Baja";
 01046                if (tipoNorm != null && tipoNorm != "baja" && tipoNorm != "todos") continue;
 1047
 01048                resultado.Add(new MovimientoReporteDto
 01049                {
 01050                    TipoMovimiento = categoriaReporte,
 01051                    Grado = mov.RelacionLaboral.Grado.Denominacion,
 01052                    Escalafon = mov.RelacionLaboral.Escalafon.Denominacion,
 01053                    Cedula = mov.RelacionLaboral.Persona.Cedula,
 01054                    Nombre = mov.RelacionLaboral.Persona.PrimerNombre,
 01055                    Apellido = mov.RelacionLaboral.Persona.PrimerApellido,
 01056                    Unidad = mov.RelacionLaboral.Unidad.Denominacion,
 01057                    Programa = mov.RelacionLaboral.Programa.Denominacion,
 01058                    Ley = mov.RelacionLaboral.Regimen.NumeroLey,
 01059                    FechaMovimiento = mov.FechaMovimiento
 01060                });
 1061            }
 1062
 01063            procesados.Add(mov.Id);
 1064        }
 1065
 01066        return resultado;
 01067    }
 1068}
Generated by: ReportGenerator 5.5.10.0
06/24/2026 - 02:13:56
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()