arreglo exportar excel

Dockerfile

@@ -1,28 +0,0 @@
-FROM node:20.19.1-alpine AS build
-
-# Establecer directorio de trabajo
-WORKDIR /app
-
-# Copiar archivos de dependencias e instalar
-COPY package*.json ./
-RUN npm install
-
-# Copiar el resto de archivos de la aplicación
-COPY . .
-
-# Compilar la aplicación
-RUN npm run build:prod
-
-# Segunda etapa: Nginx
-FROM nginx:latest
-
-# Copiar la configuración de Nginx
-COPY nginx.conf /etc/nginx/nginx.conf
-
-# Copiar archivos compilados desde la etapa anterior
-COPY --from=build /app/dist/cronogramas-primeng/browser /usr/share/nginx/html
-
-# Exponer puerto
-EXPOSE 80
-
-# Comando para iniciar Nginx (usa el predeterminado de la imagen)

HU - definiciones(1).txt

@@ -1,276 +0,0 @@
-*********************************************************************
-EP01 – Ingresar al Sistema
-El objetivo es comprobar la autenticidad del usuario. Los usuarios serán los analistas técnicos de la unidad de concesiones, la jefatura de dicha unidad y un usuario de la Unidad de Información.
----------------------------------------------------------------------
-EP01.HU01 – Implementar servicio validación de usuario
-COMO Desarrollador
-QUIERO crear un servicio que valide usuario
-PARA Permitir acceder al sistema
-
-CRITERIOS DE ACEPTACIÓN
-- Debe recibir como parametros USUARIO (correo electronico) y CONTRASEÑA.
-- Debe validar formato correo electronico.
-- Se debe crear un endpoint accesible vía HTTP (por ejemplo, POST /api/login).
-- El servicio debe conectarse a una fuente de datos (LDAP).
-- La respuesta debe estar en formato (POR DEFINIR) con una estructura clara.
-- La respuesta debe entregar el ROL del usuario validado dentro del sistema.
-- El servicio debe retornar códigos HTTP de respuestas adecuados (200, 400, 500, etc.).
-- Los errores además, deben presentar mensajes descriptivos.
-- Considerar seguridad (token, roles, etc.) si aplica.
-- Aplicar principios de clean code y separación de responsabilidades.
----------------------------------------------------------------------
-EP01.HU02 – Autenticar usuario
-COMO Usuario
-QUIERO Ingresar mi correo electronico institucional y mi contraseña en un formulario de acceso  
-PARA Que el sistema valide mi identidad y me permita acceder a mi cuenta personal de manera segura.
-
-CRITERIOS DE ACEPTACIÓN
-1. Debe existir un formulario con campos obligatorios de usuario y contraseña.
-2. El sistema debe validar que ninguno de los campos esté vacío.
-3. Si el usuario o la contraseña son incorrectos, se mostrará un mensaje de error (por definir)
-4. Si las credenciales son válidas, el usuario será redirigido al panel principal del sistema.
-5. Si las credenciales son válidas, el sistema deberá desplegar las opciones de MENÚ habiltadas para el ROL del usuario logueado.
-*********************************************************************
-EP02 – Pantalla de Usuario Administrador Unidad de Concesiones
-El objetivo es mostrar de forma consolidada las cargas temporales del PR047, para que un usuario administrador asigne cronogramas a los analistas y se notifique. Además, que permita realizar solicitud de carga a la Unidad de Información y notifique a la empresa.
----------------------------------------------------------------------
-EP02.HU01. Implementar servicio asignación de cronograma
-COMO Desarrollador
-QUIERO Crear un servicio que asigne cronogramas
-PARA Perimtir asignar cronogramas a un analista.
-
-CRITERIOS DE ACEPTACIÓN
-- Debe recibir como parametros el identificador del cronograma y del analista.
-- Debe generar los registros que sean necesarios en la base de datos.
-- Se debe crear un endpoint accesible vía HTTP (por ejemplo, POST /api/cronogramas/asignar).
-- El servicio debe conectarse a la fuente de datos correspondiente (base de datos, API externa, etc.).
-- El servicio debe retornar códigos HTTP de respuestas adecuados (200, 400, 500, etc.).
-- Los errores además, deben presentar mensajes descriptivos.
-- Considerar seguridad (token, roles, etc.) si aplica.
-- Aplicar principios de clean code y separación de responsabilidades.
----------------------------------------------------------------------
-EP02.HU02. Implementar servicio de solicitudes de carga
-COMO Desarrollador
-QUIERO Crear un servicio que solicite la carga de ¿cronogramas?
-PARA Perimtir solicitar la carga de nuevos ¿cronogramas? a la unidad de información.
-
-CRITERIOS DE ACEPTACIÓN
-- Debe recibir como parametros el identificador del ¿cronograma? que se desea cargar.
-- Debe generar los registros que sean necesarios en la base de datos.
-- Se debe crear un endpoint accesible vía HTTP (por ejemplo, POST /api/cronogramas/solicitudcarga).
-- El servicio debe conectarse a la fuente de datos correspondiente (base de datos, API externa, etc.).
-- El servicio debe retornar códigos HTTP de respuestas adecuados (200, 400, 500, etc.).
-- Los errores además, deben presentar mensajes descriptivos.
-- Considerar seguridad (token, roles, etc.) si aplica.
-- Aplicar principios de clean code y separación de responsabilidades.
----------------------------------------------------------------------
-EP02.HU03. Cargar cronogramas
----------------------------------------------------------------------
-EP02.HU04. Implementar filtros
----------------------------------------------------------------------
-EP02.HU05. Asignar cronograma
----------------------------------------------------------------------
-EP02.HU06. Implementar semaforo
----------------------------------------------------------------------
-EP02.HU07. Solicitar carga de cronogramas
----------------------------------------------------------------------
-EP02.HU08. Notificar a Unidad de Información
-*********************************************************************
-EP03 – Vista de Carga de Cronograma Temporal por Actualización de PD
-El objetivo es desplegar la carga temporal de los cronogramas de actualización de PD o nuevas concesiones para cada analista, aprobar o rechazar la carga, añadir comentarios generales y/o por cada glosa, notificar a la empresa cuando se rechace la carga y exportar los datos a un archivo pdf.
----------------------------------------------------------------------
-EP03.HU01. Implementar servicio de gestión de glosas (aprobación/rechazo)
----------------------------------------------------------------------
-EP03.HU02. Implementar servicio para exportar datos a Excel
----------------------------------------------------------------------
-EP03.HU03. Cargar cronogramas
----------------------------------------------------------------------
-EP03.HU04. Implementar filtros
----------------------------------------------------------------------
-EP03.HU05. Aprobar carga
----------------------------------------------------------------------
-EP03.HU06. Rechazar carga
----------------------------------------------------------------------
-EP03.HU07. Ingresar observación
----------------------------------------------------------------------
-EP03.HU08. Exportar a Excel
----------------------------------------------------------------------
-EP03.HU09. Notificar a empresa
-*********************************************************************
-EP04 – Vista de Carga de Cronograma Temporal por Ajuste de PD
-EP04.01. Implementar servicio para obtener listado de ajustes y amplicaciones
----------------------------------------------------------------------
-EP04.HU02. Cargar cronogramas
----------------------------------------------------------------------
-EP04.HU03. Cargar ajustes PD y ampliación TO
----------------------------------------------------------------------
-EP04.HU04. Implementar filtros
----------------------------------------------------------------------
-EP04.HU05. Ingresar observación
----------------------------------------------------------------------
-EP04.HU06. Aprobar carga
----------------------------------------------------------------------
-EP04.HU07. Rechazar carga
----------------------------------------------------------------------
-EP04.HU08. Exportar a Excel
----------------------------------------------------------------------
-EP04.HU09. Exportar a PDF
----------------------------------------------------------------------
-EP04.HU10. Notificar a empresa
-*********************************************************************
-EP05 – Vista de Resumen
-EP05.HU01. Implementar switch vistas
----------------------------------------------------------------------
-EP05.HU02. Cargar cronogramas aprobados 
----------------------------------------------------------------------
-EP05.HU03. Cargar cronogramas rechazados
----------------------------------------------------------------------
-EP05.HU04. Implementar filtros
----------------------------------------------------------------------
-EP05.HU05. Generar PDF para firma digital (x2)
----------------------------------------------------------------------
-EP05.HU06. Notificar a empresa
-*********************************************************************
-EP06 – Vista para Usuario de Unidad de Información
-EP06.HU01. Cargar cronogramas pendientes de carga
----------------------------------------------------------------------
-EP06.HU02. Cargar cronogramas aprobados
----------------------------------------------------------------------
-EP06.HU03. Cargar cronogramas rechazados
-*********************************************************************
-EP07. Servicios transversales
-EP07.HU01. Implementar servicio listado de cronogramas por estado
-COMO Desarrollador
-QUIERO Crear un servicio que devuelva una lista de cronogramas por estado
-PARA Ser cargados/consultados por la funcionalidad que lo requiera.
-
-CRITERIOS DE ACEPTACIÓN
-- El servicio debe retornar todos los registros
-- El servicio debe retornar el registro completo (todos los campos y descripciones si corresponde)
-- Se debe crear un endpoint accesible vía HTTP (por ejemplo, GET /api/cronogramas/listado).
-- El servicio debe conectarse a la fuente de datos correspondiente.
-- La respuesta debe estar en formato (POR DEFINIR) con una estructura clara.
-- Debe implementar paginación para manejar grandes volúmenes de datos.
-- Debe permitir filtros opcionales mediante parámetros (por ejemplo, 'estado').
-- El servicio debe retornar códigos HTTP de respuestas adecuados (200, 400, 500, etc.).
-- Los errores además, deben presentar mensajes descriptivos.
-- Considerar seguridad (token, roles, etc.) si aplica.
-- Aplicar principios de clean code y separación de responsabilidades.
-- Evaluar rendimiento si el volumen de datos es alto (índices, consultas optimizadas, etc.).
----------------------------------------------------------------------
-EP07.HU02. Implementar servicio listado empresas
-COMO Desarrollador
-QUIERO Crear un servicio que devuelva una lista de empresas 
-PARA Ser cargados/consultados por la funcionalidad que lo requiera.
-
-CRITERIOS DE ACEPTACIÓN
-- El servicio debe retornar todos los registros
-- El servicio debe retornar el registro completo (todos los campos y descripciones si corresponde)
-- Se debe crear un endpoint accesible vía HTTP (por ejemplo, GET /api/ cronogramas /empresas).
-- El servicio debe conectarse a la fuente de datos correspondiente.
-- La respuesta debe estar en formato (POR DEFINIR) con una estructura clara.
-- Debe implementar paginación para manejar grandes volúmenes de datos.
-- Debe permitir filtros opcionales mediante parámetros (por ejemplo, 'estado').
-- El servicio debe retornar códigos HTTP de respuestas adecuados (200, 400, 500, etc.).
-- Los errores además, deben presentar mensajes descriptivos.
-- Considerar seguridad (token, roles, etc.) si aplica.
-- Aplicar principios de clean code y separación de responsabilidades.
-- Evaluar rendimiento si el volumen de datos es alto (índices, consultas optimizadas, etc.).
----------------------------------------------------------------------
-EP07.HU03. Implementar servicio listado ajustes PD
-COMO Desarrollador
-QUIERO Crear un servicio que devuelva una lista de ajustes de PD 
-PARA Ser cargados/consultados por la funcionalidad que lo requiera.
-
-CRITERIOS DE ACEPTACIÓN
-- El servicio debe retornar todos los registros
-- El servicio debe retornar el registro completo (todos los campos y descripciones si corresponde)
-- Se debe crear un endpoint accesible vía HTTP (por ejemplo, GET /api/ cronogramas /ajustespd).
-- El servicio debe conectarse a la fuente de datos correspondiente.
-- La respuesta debe estar en formato (POR DEFINIR) con una estructura clara.
-- Debe implementar paginación para manejar grandes volúmenes de datos.
-- El servicio debe retornar códigos HTTP de respuestas adecuados (200, 400, 500, etc.).
-- Los errores además, deben presentar mensajes descriptivos.
-- Considerar seguridad (token, roles, etc.) si aplica.
-- Aplicar principios de clean code y separación de responsabilidades.
-- Evaluar rendimiento si el volumen de datos es alto (índices, consultas optimizadas, etc.). 
----------------------------------------------------------------------
-EP07.HU04. Implementar servicio listado ampliación TO
-COMO Desarrollador
-QUIERO Crear un servicio que devuelva una lista de ampliación de TO 
-PARA Ser cargados/consultados por la funcionalidad que lo requiera.
-
-CRITERIOS DE ACEPTACIÓN
-- El servicio debe retornar todos los registros
-- El servicio debe retornar el registro completo (todos los campos y descripciones si corresponde)
-- Se debe crear un endpoint accesible vía HTTP (por ejemplo, GET /api/ cronogramas /ampliacionto).
-- El servicio debe conectarse a la fuente de datos correspondiente.
-- La respuesta debe estar en formato (POR DEFINIR) con una estructura clara.
-- Debe implementar paginación para manejar grandes volúmenes de datos.
-- El servicio debe retornar códigos HTTP de respuestas adecuados (200, 400, 500, etc.).
-- Los errores además, deben presentar mensajes descriptivos.
-- Considerar seguridad (token, roles, etc.) si aplica.
-- Aplicar principios de clean code y separación de responsabilidades.
-- Evaluar rendimiento si el volumen de datos es alto (índices, consultas optimizadas, etc.). 
----------------------------------------------------------------------
-EP07.HU05. Implementar servicio notificaciones
-COMO Desarrollador
-QUIERO Crear un servicio que envie correos electronicos
-PARA Notificar a quien corresponda respecto de alertas o confirmaciones.
-
-CRITERIOS DE ACEPTACIÓN
-- El servicio debe aceptar al menos los siguientes parámetros:
-  - Destinatario(s)
-  - Asunto
-  - Cuerpo del mensaje (HTML o texto plano)
-  - Remitente (opcional, configurable)
-- Debe realizar validaciones básicas (formato de email, campos requeridos).
-- Debe manejar errores como correos inválidos, errores de red, o problemas con el servidor SMTP.
-- El servicio debe retornar respuestas con códigos HTTP claros (200, 400, 500, etc.).
-- El envío debe ser asincrónico si se anticipa alto volumen (opcional).
-- Debe registrar los envíos en logs o base de datos (para trazabilidad, opcional).
-
----------------------------------------------------------------------
-*********************************************************************
-
-generar epica de servicios transversales
-por cada HU generar su propio exportar a excel
-generar servicio por cada pdf a generar
-no incluir botonera de switch de vistas
-generar matriz de autorizaciones (perfil, pantalla)
-
-
-
-
-
-
-
----
-
-### ✅ **Criterios de Aceptación:**
-
-- Se debe crear un endpoint (por ejemplo, `POST /api/email/send`) que reciba los datos del correo.
-
----
-
-### 🔁 **Flujo Básico de Desarrollo:**
-
-1. Diseñar el endpoint REST (por ejemplo, en .NET, Node.js, Spring Boot).
-2. Configurar un proveedor de correo (SMTP, SendGrid, Mailgun, etc.).
-3. Implementar la lógica de envío y validación.
-4. Manejar errores y respuestas.
-5. Agregar logs y/o almacenamiento de eventos.
-6. Probar con diferentes escenarios y correos de prueba.
-
----
-
-### 🛠️ **Notas Técnicas:**
-
-- Se recomienda usar una biblioteca estándar de envío de correo según el lenguaje (ej. Nodemailer en Node.js, MailKit en .NET, JavaMail en Java).
-- Usar plantillas de email si se requiere formato HTML.
-- Considerar seguridad: autenticación con el proveedor, evitar inyecciones, validar origen de llamadas.
-- Considerar colas de mensajes si se requiere alta disponibilidad (ej. RabbitMQ, Azure Service Bus).
-
----
-
-¿Te gustaría que prepare una versión adaptada para .NET Core, Node.js o algún otro stack específico?

docker-compose.yml

@@ -1,12 +0,0 @@
-version: '3.8'
-
-services:
-  web:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    ports:
-      - "80:80"
-    volumes:
-      - ./nginx.conf:/etc/nginx/nginx.conf
-    restart: unless-stopped

nginx.conf

@@ -1,27 +0,0 @@
-# the events block is required
-events{}
-
-http {
-    # include the default mime.types to map file extensions to MIME types
-    include /etc/nginx/mime.types;
-
-    server {
-        # set the root directory for the server (we need to copy our
-        # application files here)
-        root /usr/share/nginx/html;
-
-        # set the default index file for the server (Angular generates the
-        # index.html file for us and it will be in the above directory)
-        index index.html;
-
-        # specify the configuration for the '/' location
-        location / {
-            # try to serve the requested URI. if that fails then try to
-            # serve the URI with a trailing slash. if that fails, then
-            # serve the index.html file; this is needed in order to serve
-            # Angular routes--e.g.,'localhost:8080/customer' will serve
-            # the index.html file
-            try_files $uri $uri/ /index.html;
-        }
-    }
-}

src/app/README-ROUTE-ANIMATIONS.md

@@ -1,108 +0,0 @@
-# Animaciones de Ruta en PrimeNG Cronogramas
-
-Esta documentación explica cómo se implementaron las animaciones durante la navegación entre rutas en la aplicación.
-
-## Componentes Principales
-
-La solución consta de tres partes principales:
-
-1. **RouteAnimationsComponent**: Un componente contenedor para el router-outlet que aplica animaciones.
-2. **CustomRouteReuseStrategy**: Una estrategia personalizada que fuerza la recreación de componentes.
-3. **Configuración en app.config.ts**: Donde registramos la estrategia personalizada.
-
-## Cómo Funciona
-
-### 1. Componente de Animaciones de Ruta
-
-El `RouteAnimationsComponent` envuelve el router-outlet estándar y aplica una clase de animación aleatoria cada vez que ocurre una navegación. 
-
-```typescript
-// src/app/components/route-animations/route-animations.component.ts
-```
-
-Este componente:
-- Se suscribe a los eventos de navegación del router
-- Elimina brevemente la clase de animación
-- Aplica una nueva animación aleatoria
-- Todo esto crea un efecto de "reinicio" de la animación en cada navegación
-
-### 2. Estrategia de Reuso de Rutas
-
-Angular por defecto reutiliza componentes cuando navega entre rutas similares para optimizar el rendimiento. Sin embargo, para nuestras animaciones, necesitamos que los componentes se recreen.
-
-```typescript
-// src/app/utils/custom-route-reuse-strategy.ts
-```
-
-Esta clase implementa `RouteReuseStrategy` y:
-- Evita almacenar o recuperar componentes desactivados
-- Solo reutiliza componentes cuando son exactamente la misma ruta
-- Fuerza la recreación del componente en cada navegación
-
-### 3. Configuración en app.config.ts
-
-Registramos nuestra estrategia personalizada en el archivo de configuración de la aplicación:
-
-```typescript
-// src/app/app.config.ts
-{
-  provide: RouteReuseStrategy,
-  useClass: CustomRouteReuseStrategy
-}
-```
-
-### 4. Integración con el Layout
-
-En el layout principal, reemplazamos el router-outlet estándar con nuestro componente personalizado:
-
-```html
-<!-- src/app/components/layout/layout.component.html -->
-<div class="page-content">
-  <app-route-animations></app-route-animations>
-</div>
-```
-
-## Animaciones Disponibles
-
-Las animaciones que se aplican aleatoriamente incluyen:
-- fadeIn
-- fadeInDown
-- fadeInUp
-- slideInLeft
-- slideInRight
-- zoomIn
-
-## Personalización
-
-Para modificar las animaciones disponibles, edita el array `animations` en el `RouteAnimationsComponent`:
-
-```typescript
-private animations: string[] = [
-  'animate__fadeIn',
-  'animate__fadeInDown',
-  // Añade o elimina animaciones aquí
-];
-```
-
-Todas las animaciones disponibles vienen de [Animate.css](https://animate.style/), asegúrate de que el nombre que elijas comience con `animate__` y exista en la biblioteca.
-
-## Ajustes de Rendimiento
-
-Si notas problemas de rendimiento:
-
-1. Puedes reducir la duración de las animaciones modificando:
-   ```css
-   .animate__animated {
-     animation-duration: 0.6s; /* Ajusta a un valor menor */
-   }
-   ```
-
-2. Limita las animaciones a solo las más simples (como fade) en lugar de las más complejas (como bounce o flip).
-
-## Depuración
-
-Si las animaciones no funcionan:
-
-1. Verifica que `animate.css` esté correctamente importado en tu `angular.json`
-2. Asegúrate de que el componente `RouteAnimationsComponent` esté correctamente importado en el layout
-3. Comprueba que la estrategia de reuso de rutas esté registrada en `app.config.ts`

src/app/pages/ajuste-pd/ajuste-pd.component.html

@@ -59,7 +59,7 @@
   >
     <ng-template #header>
       <tr>
-        <th colspan="10" style="background-color: #f8f9fa; border: none"></th>
+        <th colspan="9" style="background-color: #f8f9fa; border: none"></th>
         <th colspan="3" class="tablaAzul text-white font-bold text-center">Cronograma base vigente</th>
         <th colspan="4" class="bg-blue-700 text-white font-bold text-center">Cronograma base ajustado</th>
       </tr>

src/app/pages/ajuste-pd/ajuste-pd.component.ts

@@ -142,30 +142,30 @@ export class AjustePdComponent {
   private addGroupedHeaders(worksheet: any): void {
     // Añadir fila de encabezados agrupados
     const groupHeaderRow = worksheet.addRow([
-      '', '', '', '', '', '', '', '', '', '',
+      '', '', '', '', '', '', '', '', '',
       'Cronograma base vigente', '', '',
       'Cronograma base ajustado', '', '', '',
-      '', ''
+      '', '', ''
     ]);
 
     // Combinar celdas para los grupos de encabezados
-    worksheet.mergeCells(1, 11, 1, 13); // Cronograma base vigente (columnas 11-13)
+    worksheet.mergeCells(1, 10, 1, 12); // Cronograma base vigente (columnas 10-12)
-    worksheet.mergeCells(1, 14, 1, 17); // Cronograma base ajustado (columnas 14-17)
+    worksheet.mergeCells(1, 13, 1, 16); // Cronograma base ajustado (columnas 13-16)
 
     // Dar formato a las celdas combinadas
-    groupHeaderRow.getCell(11).fill = {
+    groupHeaderRow.getCell(10).fill = {
       type: 'pattern',
       pattern: 'solid',
       fgColor: { argb: '0066CC' } // Color azul oscuro para "Cronograma base vigente"
     };
-    groupHeaderRow.getCell(14).fill = {
+    groupHeaderRow.getCell(13).fill = {
       type: 'pattern',
       pattern: 'solid',
       fgColor: { argb: '0000CC' } // Color azul más fuerte para "Cronograma base ajustado"
     };
 
     // Estilo de texto para encabezados agrupados
-    [11, 14].forEach(cellIndex => {
+    [10, 13].forEach(cellIndex => {
       const cell = groupHeaderRow.getCell(cellIndex);
       cell.font = {
         name: 'Arial',
@@ -213,26 +213,34 @@ export class AjustePdComponent {
   private populateWorksheet(worksheet: any, data: any[]): void {
     // Añadimos los datos
     data.forEach(item => {
+      // Determinar estado de aprobación basado en el valor
+      let estadoAprobacion;
+      if (typeof item.dato13 === 'boolean') {
+        estadoAprobacion = item.dato13 ? 'Aprobado' : 'Rechazado';
+      } else {
+        estadoAprobacion = item.dato13;
+      }
+      
       worksheet.addRow([
-        item.empresa,
+        item.empresa,                    // Empresa
-        item.codigoCronograma,
+        item.codigoCronograma,           // Código de cronograma
-        item.codigoCronogramaAjuste, // Etapa del Servicio
+        item.codigoCronogramaAjuste,     // Etapa del Servicio
-        item.tipoCarga, // Nombre sistema
+        item.tipoCarga,                  // Nombre sistema
-        item.estadoRevision, // Nombre localidad
+        item.estadoRevision,             // Nombre localidad
-        item.fechaIngreso, // Tipo de inversión
+        item.fechaIngreso,               // Tipo de inversión
-        item.estadoRevision, // Código de glosa PD
+        item.estadoRevision,             // Código de glosa PD
-        item.dato9, // Descripción glosa
+        item.dato9,                      // Descripción glosa
-        item.dato10, // Monto Inversión Total (UF)
+        item.dato10,                     // Monto Inversión Total (UF)
-        item.dato13, // Año de Inicio (Cronograma base vigente)
+        item.dato13,                     // Año de Inicio (Cronograma base vigente)
-        item.dato14, // Año de Término (Cronograma base vigente)
+        item.dato14,                     // Año de Término (Cronograma base vigente)
-        item.dato15, // Mes de Término (Cronograma base vigente)
+        item.dato15,                     // Mes de Término (Cronograma base vigente)
-        item.dato16, // Tipo de ajuste (Cronograma base ajustado)
+        item.dato16,                     // Tipo de ajuste (Cronograma base ajustado)
-        item.dato17, // Año de Inicio (Cronograma base ajustado)
+        item.dato17,                     // Año de Inicio (Cronograma base ajustado)
-        item.dato18, // Año de Término (Cronograma base ajustado)
+        item.dato18,                     // Año de Término (Cronograma base ajustado)
-        item.dato11, // Mes de Término (Cronograma base ajustado)
+        item.dato11,                     // Mes de Término (Cronograma base ajustado)
-        item.dato12, // Nota
+        item.dato12,                     // Nota
-        item.dato13, // Estado aprobación
+        estadoAprobacion,                // Estado aprobación
-        item.analista // Observación
+        item.analista                    // Observación
       ]);
     });
   }
@@ -277,8 +285,8 @@ export class AjustePdComponent {
     });
 
     // Aplicar colores específicos según el grupo de encabezados
-    // Cronograma base ajustado (columnas 14-17)
+    // Cronograma base ajustado (columnas 13-16)
-    for (let i = 14; i <= 17; i++) {
+    for (let i = 13; i <= 16; i++) {
       const cell = detailedHeaderRow.getCell(i);
       cell.fill = {
         type: 'pattern',
@@ -329,6 +337,30 @@ export class AjustePdComponent {
           column.width = maxLength < 10 ? 10 : maxLength + 2;
         }
       });
+    } else {
+      // Si no hay columnas definidas, establecemos valores predeterminados
+      const columnWidths = [
+        { width: 15 }, // Empresa
+        { width: 20 }, // Código de cronograma
+        { width: 18 }, // Etapa del Servicio
+        { width: 18 }, // Nombre sistema
+        { width: 18 }, // Nombre localidad
+        { width: 18 }, // Tipo de inversión
+        { width: 18 }, // Código de glosa PD
+        { width: 22 }, // Descripción glosa
+        { width: 18 }, // Monto Inversión Total (UF)
+        { width: 15 }, // Año de Inicio (vigente)
+        { width: 15 }, // Año de Término (vigente)
+        { width: 15 }, // Mes de Término (vigente)
+        { width: 15 }, // Tipo de ajuste
+        { width: 15 }, // Año de Inicio (ajustado)
+        { width: 15 }, // Año de Término (ajustado)
+        { width: 15 }, // Mes de Término (ajustado)
+        { width: 15 }, // Nota
+        { width: 18 }, // Estado aprobación
+        { width: 20 }  // Observación
+      ];
+      worksheet.columns = columnWidths;
     }
   }