Agregar sistema de vinculaciones con registros externos de Metabase

- Nuevo schema BD para vinculaciones_externas con constraint único por período
- Cliente Metabase para consultar Ingresos, Carretas, Salidas y Rechazos
- Endpoints API para registros externos (/api/externos/*) y vinculaciones (/api/vinculaciones/*)
- Composable useRegistrosExternos con lógica de vinculación individual y masiva
- Componentes: TablaRegistros, ModalAsignar, ProgressDashboard
- Tab "Externos" en app.vue con sub-tabs y dashboard de progreso
- LotesCard.vue ahora muestra registros vinculados al lote

nuxt4/server/api/debug/reset-database.post.ts

@@ -23,13 +23,16 @@ export default defineEventHandler(async (event) => {
       await client.query('BEGIN')
 
       // Eliminar completamente las tablas (DROP) para que el workflow las recree
+      await client.query('DROP TABLE IF EXISTS vinculaciones_externas CASCADE')
       await client.query('DROP TABLE IF EXISTS operacion_lotes CASCADE')
       await client.query('DROP TABLE IF EXISTS operaciones CASCADE')
       await client.query('DROP TABLE IF EXISTS lotes CASCADE')
 
-      // También eliminar la función y vista si existen
+      // También eliminar las funciones y vistas si existen
       await client.query('DROP FUNCTION IF EXISTS get_trazabilidad CASCADE')
+      await client.query('DROP FUNCTION IF EXISTS get_estadisticas_vinculacion CASCADE')
       await client.query('DROP VIEW IF EXISTS vista_lotes_con_origen CASCADE')
+      await client.query('DROP VIEW IF EXISTS vista_lotes_con_vinculaciones CASCADE')
 
       await client.query('COMMIT')
 

nuxt4/server/api/debug/seed-database.post.ts

@@ -25,9 +25,11 @@ export default defineEventHandler(async (event) => {
       // Leer los archivos SQL
       const schemaPath = join(process.cwd(), 'server', 'database', '01_schema.sql')
       const seedPath = join(process.cwd(), 'server', 'database', '02_seed.sql')
+      const vinculacionesPath = join(process.cwd(), 'server', 'database', '03_vinculaciones_externas.sql')
 
       const schemaSQL = await readFile(schemaPath, 'utf-8')
       const seedSQL = await readFile(seedPath, 'utf-8')
+      const vinculacionesSQL = await readFile(vinculacionesPath, 'utf-8')
 
       await client.query('BEGIN')
 
@@ -46,12 +48,18 @@ export default defineEventHandler(async (event) => {
         // Si no existen las tablas, ejecutar schema completo
         console.log('📋 Las tablas no existen. Creando schema...')
         await client.query(schemaSQL)
+        console.log('📋 Creando schema de vinculaciones externas...')
+        await client.query(vinculacionesSQL)
       } else {
         console.log('📋 Las tablas ya existen. Limpiando datos existentes...')
         // Si las tablas existen, limpiar datos antes de cargar seed
+        await client.query('TRUNCATE TABLE vinculaciones_externas CASCADE')
         await client.query('TRUNCATE TABLE operacion_lotes CASCADE')
         await client.query('TRUNCATE TABLE operaciones CASCADE')
         await client.query('TRUNCATE TABLE lotes CASCADE')
+        // Asegurar que el schema de vinculaciones esté actualizado
+        console.log('📋 Actualizando schema de vinculaciones externas...')
+        await client.query(vinculacionesSQL)
       }
 
       // Ejecutar seed (inserta datos de ejemplo)

nuxt4/server/api/externos/carretas.get.ts

@@ -0,0 +1,52 @@
+/**
+ * GET /api/externos/carretas
+ *
+ * Obtiene las carretas del período de cosecha desde Metabase.
+ * Incluye información de estado de vinculación.
+ */
+
+import { getCarretas } from '../../utils/metabase'
+import { getRegistrosVinculados } from '../../utils/queries'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const query = getQuery(event)
+    const periodo = (query.periodo as string) || '25-26'
+    const soloSinVincular = query.sinVincular === 'true'
+
+    // Obtener carretas desde Metabase
+    const carretas = await getCarretas(periodo)
+
+    // Obtener IDs ya vinculados desde nuestra BD local
+    const vinculados = await getRegistrosVinculados('carreta', periodo)
+    const vinculadosSet = new Set(vinculados)
+
+    // Marcar cada carreta con su estado de vinculación
+    const carretasConEstado = carretas.map((carreta: any) => ({
+      ...carreta,
+      vinculado: vinculadosSet.has(carreta.id),
+    }))
+
+    // Filtrar si solo se quieren los no vinculados
+    const resultado = soloSinVincular
+      ? carretasConEstado.filter((c: any) => !c.vinculado)
+      : carretasConEstado
+
+    return {
+      success: true,
+      data: resultado,
+      meta: {
+        total: resultado.length,
+        vinculados: carretasConEstado.filter((c: any) => c.vinculado).length,
+        sinVincular: carretasConEstado.filter((c: any) => !c.vinculado).length,
+        periodo,
+      },
+    }
+  } catch (error: any) {
+    console.error('[API] Error obteniendo carretas:', error)
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.message || 'Error obteniendo carretas',
+    })
+  }
+})

nuxt4/server/api/externos/ingresos.get.ts

@@ -0,0 +1,52 @@
+/**
+ * GET /api/externos/ingresos
+ *
+ * Obtiene los ingresos del período de cosecha desde Metabase.
+ * Incluye información de estado de vinculación.
+ */
+
+import { getIngresos } from '../../utils/metabase'
+import { getRegistrosVinculados } from '../../utils/queries'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const query = getQuery(event)
+    const periodo = (query.periodo as string) || '25-26'
+    const soloSinVincular = query.sinVincular === 'true'
+
+    // Obtener ingresos desde Metabase
+    const ingresos = await getIngresos(periodo)
+
+    // Obtener IDs ya vinculados desde nuestra BD local
+    const vinculados = await getRegistrosVinculados('ingreso', periodo)
+    const vinculadosSet = new Set(vinculados)
+
+    // Marcar cada ingreso con su estado de vinculación
+    const ingresosConEstado = ingresos.map((ingreso: any) => ({
+      ...ingreso,
+      vinculado: vinculadosSet.has(ingreso.id),
+    }))
+
+    // Filtrar si solo se quieren los no vinculados
+    const resultado = soloSinVincular
+      ? ingresosConEstado.filter((i: any) => !i.vinculado)
+      : ingresosConEstado
+
+    return {
+      success: true,
+      data: resultado,
+      meta: {
+        total: resultado.length,
+        vinculados: ingresosConEstado.filter((i: any) => i.vinculado).length,
+        sinVincular: ingresosConEstado.filter((i: any) => !i.vinculado).length,
+        periodo,
+      },
+    }
+  } catch (error: any) {
+    console.error('[API] Error obteniendo ingresos:', error)
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.message || 'Error obteniendo ingresos',
+    })
+  }
+})

nuxt4/server/api/externos/rechazos.get.ts

@@ -0,0 +1,52 @@
+/**
+ * GET /api/externos/rechazos
+ *
+ * Obtiene los rechazos del período de cosecha desde Metabase.
+ * Incluye información de estado de vinculación.
+ */
+
+import { getRechazos } from '../../utils/metabase'
+import { getRegistrosVinculados } from '../../utils/queries'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const query = getQuery(event)
+    const periodo = (query.periodo as string) || '25-26'
+    const soloSinVincular = query.sinVincular === 'true'
+
+    // Obtener rechazos desde Metabase
+    const rechazos = await getRechazos(periodo)
+
+    // Obtener IDs ya vinculados desde nuestra BD local
+    const vinculados = await getRegistrosVinculados('rechazo', periodo)
+    const vinculadosSet = new Set(vinculados)
+
+    // Marcar cada rechazo con su estado de vinculación
+    const rechazosConEstado = rechazos.map((rechazo: any) => ({
+      ...rechazo,
+      vinculado: vinculadosSet.has(rechazo.id),
+    }))
+
+    // Filtrar si solo se quieren los no vinculados
+    const resultado = soloSinVincular
+      ? rechazosConEstado.filter((r: any) => !r.vinculado)
+      : rechazosConEstado
+
+    return {
+      success: true,
+      data: resultado,
+      meta: {
+        total: resultado.length,
+        vinculados: rechazosConEstado.filter((r: any) => r.vinculado).length,
+        sinVincular: rechazosConEstado.filter((r: any) => !r.vinculado).length,
+        periodo,
+      },
+    }
+  } catch (error: any) {
+    console.error('[API] Error obteniendo rechazos:', error)
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.message || 'Error obteniendo rechazos',
+    })
+  }
+})

nuxt4/server/api/externos/salidas.get.ts

@@ -0,0 +1,52 @@
+/**
+ * GET /api/externos/salidas
+ *
+ * Obtiene las salidas del período de cosecha desde Metabase.
+ * Incluye información de estado de vinculación.
+ */
+
+import { getSalidas } from '../../utils/metabase'
+import { getRegistrosVinculados } from '../../utils/queries'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const query = getQuery(event)
+    const periodo = (query.periodo as string) || '25-26'
+    const soloSinVincular = query.sinVincular === 'true'
+
+    // Obtener salidas desde Metabase
+    const salidas = await getSalidas(periodo)
+
+    // Obtener IDs ya vinculados desde nuestra BD local
+    const vinculados = await getRegistrosVinculados('salida', periodo)
+    const vinculadosSet = new Set(vinculados)
+
+    // Marcar cada salida con su estado de vinculación
+    const salidasConEstado = salidas.map((salida: any) => ({
+      ...salida,
+      vinculado: vinculadosSet.has(salida.id),
+    }))
+
+    // Filtrar si solo se quieren los no vinculados
+    const resultado = soloSinVincular
+      ? salidasConEstado.filter((s: any) => !s.vinculado)
+      : salidasConEstado
+
+    return {
+      success: true,
+      data: resultado,
+      meta: {
+        total: resultado.length,
+        vinculados: salidasConEstado.filter((s: any) => s.vinculado).length,
+        sinVincular: salidasConEstado.filter((s: any) => !s.vinculado).length,
+        periodo,
+      },
+    }
+  } catch (error: any) {
+    console.error('[API] Error obteniendo salidas:', error)
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.message || 'Error obteniendo salidas',
+    })
+  }
+})

nuxt4/server/api/externos/stats.get.ts

@@ -0,0 +1,81 @@
+/**
+ * GET /api/externos/stats
+ *
+ * Obtiene estadísticas de vinculación para el dashboard.
+ * Combina datos de Metabase (totales) con nuestra BD local (vinculados).
+ */
+
+import { getConteoRegistros } from '../../utils/metabase'
+import { getEstadisticasVinculacion } from '../../utils/queries'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const query = getQuery(event)
+    const periodo = (query.periodo as string) || '25-26'
+
+    // Obtener conteos totales desde Metabase
+    const totales = await getConteoRegistros(periodo)
+
+    // Obtener conteos de vinculados desde nuestra BD local
+    const vinculados = await getEstadisticasVinculacion(periodo)
+
+    // Calcular estadísticas completas
+    const stats = {
+      ingresos: {
+        total: totales.ingresos,
+        vinculados: vinculados.ingreso.vinculados,
+        sinVincular: totales.ingresos - vinculados.ingreso.vinculados,
+        porcentaje: totales.ingresos > 0
+          ? Math.round((vinculados.ingreso.vinculados / totales.ingresos) * 100)
+          : 0,
+      },
+      carretas: {
+        total: totales.carretas,
+        vinculados: vinculados.carreta.vinculados,
+        sinVincular: totales.carretas - vinculados.carreta.vinculados,
+        porcentaje: totales.carretas > 0
+          ? Math.round((vinculados.carreta.vinculados / totales.carretas) * 100)
+          : 0,
+      },
+      salidas: {
+        total: totales.salidas,
+        vinculados: vinculados.salida.vinculados,
+        sinVincular: totales.salidas - vinculados.salida.vinculados,
+        porcentaje: totales.salidas > 0
+          ? Math.round((vinculados.salida.vinculados / totales.salidas) * 100)
+          : 0,
+      },
+      rechazos: {
+        total: totales.rechazos,
+        vinculados: vinculados.rechazo.vinculados,
+        sinVincular: totales.rechazos - vinculados.rechazo.vinculados,
+        porcentaje: totales.rechazos > 0
+          ? Math.round((vinculados.rechazo.vinculados / totales.rechazos) * 100)
+          : 0,
+      },
+      resumen: {
+        total: totales.ingresos + totales.carretas + totales.salidas + totales.rechazos,
+        vinculados: vinculados.total_vinculados,
+        sinVincular: (totales.ingresos + totales.carretas + totales.salidas + totales.rechazos) - vinculados.total_vinculados,
+        porcentaje: 0,
+      },
+      periodo,
+    }
+
+    // Calcular porcentaje general
+    stats.resumen.porcentaje = stats.resumen.total > 0
+      ? Math.round((stats.resumen.vinculados / stats.resumen.total) * 100)
+      : 0
+
+    return {
+      success: true,
+      data: stats,
+    }
+  } catch (error: any) {
+    console.error('[API] Error obteniendo estadísticas:', error)
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.message || 'Error obteniendo estadísticas',
+    })
+  }
+})

nuxt4/server/api/vinculaciones/[id].delete.ts

@@ -0,0 +1,40 @@
+/**
+ * DELETE /api/vinculaciones/:id
+ *
+ * Elimina una vinculación por su ID.
+ */
+
+import { deleteVinculacion } from '../../utils/queries'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const id = getRouterParam(event, 'id')
+
+    if (!id) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: 'ID requerido',
+      })
+    }
+
+    const eliminado = await deleteVinculacion(id)
+
+    if (!eliminado) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: 'Vinculación no encontrada',
+      })
+    }
+
+    return {
+      success: true,
+      message: 'Vinculación eliminada exitosamente',
+    }
+  } catch (error: any) {
+    console.error('[API] Error eliminando vinculación:', error)
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || error.message || 'Error eliminando vinculación',
+    })
+  }
+})

nuxt4/server/api/vinculaciones/index.get.ts

@@ -0,0 +1,38 @@
+/**
+ * GET /api/vinculaciones
+ *
+ * Lista vinculaciones con filtros opcionales.
+ */
+
+import { getVinculaciones } from '../../utils/queries'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const query = getQuery(event)
+
+    const filtros = {
+      tipo_registro: query.tipo as string | undefined,
+      lote_id: query.lote_id as string | undefined,
+      periodo_cosecha: (query.periodo as string) || '25-26',
+      limit: query.limit ? parseInt(query.limit as string) : undefined,
+      offset: query.offset ? parseInt(query.offset as string) : undefined,
+    }
+
+    const vinculaciones = await getVinculaciones(filtros)
+
+    return {
+      success: true,
+      data: vinculaciones,
+      meta: {
+        total: vinculaciones.length,
+        filtros,
+      },
+    }
+  } catch (error: any) {
+    console.error('[API] Error obteniendo vinculaciones:', error)
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message || 'Error obteniendo vinculaciones',
+    })
+  }
+})

nuxt4/server/api/vinculaciones/index.post.ts

@@ -0,0 +1,131 @@
+/**
+ * POST /api/vinculaciones
+ *
+ * Crea una o múltiples vinculaciones.
+ *
+ * Body para vinculación individual:
+ * {
+ *   tipo_registro: 'ingreso' | 'carreta' | 'salida' | 'rechazo',
+ *   registro_id: number,
+ *   lote_id: string,
+ *   observaciones?: string,
+ *   datos_cache?: object
+ * }
+ *
+ * Body para vinculación masiva:
+ * {
+ *   masivo: true,
+ *   items: Array<{
+ *     tipo_registro: string,
+ *     registro_id: number,
+ *     lote_id: string,
+ *     observaciones?: string,
+ *     datos_cache?: object
+ *   }>
+ * }
+ */
+
+import { createVinculacion, createVinculacionesMasivas } from '../../utils/queries'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const body = await readBody(event)
+
+    // Obtener usuario de Authentik si está disponible
+    const headers = getHeaders(event)
+    const usuarioId = headers['x-authentik-username'] || headers['x-authentik-uid'] || null
+
+    // Validar body
+    if (!body) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: 'Body requerido',
+      })
+    }
+
+    // Vinculación masiva
+    if (body.masivo && Array.isArray(body.items)) {
+      if (body.items.length === 0) {
+        throw createError({
+          statusCode: 400,
+          statusMessage: 'Se requiere al menos un item para vinculación masiva',
+        })
+      }
+
+      // Validar cada item
+      for (const item of body.items) {
+        if (!item.tipo_registro || !item.registro_id || !item.lote_id) {
+          throw createError({
+            statusCode: 400,
+            statusMessage: 'Cada item requiere tipo_registro, registro_id y lote_id',
+          })
+        }
+      }
+
+      const vinculaciones = await createVinculacionesMasivas(
+        body.items.map((item: any) => ({
+          tipo_registro: item.tipo_registro,
+          registro_id: item.registro_id,
+          lote_id: item.lote_id,
+          usuario_id: usuarioId,
+          observaciones: item.observaciones,
+          datos_cache: item.datos_cache,
+          periodo_cosecha: item.periodo_cosecha || '25-26',
+        }))
+      )
+
+      return {
+        success: true,
+        data: vinculaciones,
+        message: `${vinculaciones.length} vinculaciones creadas exitosamente`,
+      }
+    }
+
+    // Vinculación individual
+    if (!body.tipo_registro || !body.registro_id || !body.lote_id) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: 'Se requiere tipo_registro, registro_id y lote_id',
+      })
+    }
+
+    const vinculacion = await createVinculacion({
+      tipo_registro: body.tipo_registro,
+      registro_id: body.registro_id,
+      lote_id: body.lote_id,
+      usuario_id: usuarioId,
+      observaciones: body.observaciones,
+      datos_cache: body.datos_cache,
+      periodo_cosecha: body.periodo_cosecha || '25-26',
+    })
+
+    return {
+      success: true,
+      data: vinculacion,
+      message: 'Vinculación creada exitosamente',
+    }
+  } catch (error: any) {
+    console.error('[API] Error creando vinculación:', error)
+
+    // Error de constraint único (registro ya vinculado)
+    if (error.code === '23505') {
+      throw createError({
+        statusCode: 409,
+        statusMessage: 'Este registro ya está vinculado a un lote en este período',
+      })
+    }
+
+    // Error de FK (lote no existe)
+    if (error.code === '23503') {
+      throw createError({
+        statusCode: 400,
+        statusMessage: 'El lote especificado no existe',
+      })
+    }
+
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || error.message || 'Error creando vinculación',
+    })
+  }
+})

nuxt4/server/api/vinculaciones/por-lote/[loteId].get.ts

@@ -0,0 +1,52 @@
+/**
+ * GET /api/vinculaciones/por-lote/:loteId
+ *
+ * Obtiene todas las vinculaciones de un lote específico.
+ */
+
+import { getVinculacionesByLote } from '../../../utils/queries'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const loteId = getRouterParam(event, 'loteId')
+
+    if (!loteId) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: 'loteId requerido',
+      })
+    }
+
+    const vinculaciones = await getVinculacionesByLote(loteId)
+
+    // Agrupar por tipo de registro
+    const agrupados = {
+      ingresos: vinculaciones.filter(v => v.tipo_registro === 'ingreso'),
+      carretas: vinculaciones.filter(v => v.tipo_registro === 'carreta'),
+      salidas: vinculaciones.filter(v => v.tipo_registro === 'salida'),
+      rechazos: vinculaciones.filter(v => v.tipo_registro === 'rechazo'),
+    }
+
+    return {
+      success: true,
+      data: vinculaciones,
+      agrupados,
+      meta: {
+        lote_id: loteId,
+        total: vinculaciones.length,
+        por_tipo: {
+          ingresos: agrupados.ingresos.length,
+          carretas: agrupados.carretas.length,
+          salidas: agrupados.salidas.length,
+          rechazos: agrupados.rechazos.length,
+        },
+      },
+    }
+  } catch (error: any) {
+    console.error('[API] Error obteniendo vinculaciones del lote:', error)
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message || 'Error obteniendo vinculaciones del lote',
+    })
+  }
+})