640 lines
23 KiB
Ruby
640 lines
23 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
# adn/tools/db/importers/md_importer.rb — Importador de bitácoras .md a PostgreSQL
|
|
# ================================================================================
|
|
# Esta clase convierte bitácoras en formato Markdown al esquema de base de datos
|
|
# dtic-BITACORAs. Procesa la estructura jerárquica:
|
|
# Archivo .md → Bitácora → Nodos → Temas → Entradas (I-F-D-E)
|
|
#
|
|
# Formato de entrada (.md):
|
|
# # Bitácora 2026-02-28
|
|
# ## Control de Gestión
|
|
# ### 📝 Resumen de Actividades
|
|
# | NODO | RESUMEN INTEGRAL |
|
|
# | :--- | :--- |
|
|
# | srv-ns8 | Resumen del día... |
|
|
#
|
|
# ## 📂 Actividades Detalladas
|
|
# ### srv-ns8
|
|
# #### ✅ - SEC01 - Refactorización ns8-candados
|
|
# | I | F | Descripción | E |
|
|
# | :--- | :--- | :--- | :--- |
|
|
# | 08:00 | 08:34 | Refactorización ns8-candados... | [P] ✅ |
|
|
#
|
|
# Uso:
|
|
# importer = MDImporter.new(db_connection)
|
|
# resultado = importer.importar_bitacora('bitacoras/2026-02-28.md')
|
|
# resultado = importer.importar_todo_directorio('bitacoras/')
|
|
#
|
|
# Dependencias: Clase BitacoraDB del módulo BitacorasDB
|
|
|
|
require 'date'
|
|
require 'time'
|
|
require 'yaml'
|
|
require 'digest'
|
|
|
|
module BitacorasDB
|
|
module Importers
|
|
class MDImporter
|
|
# Estados posibles en archivos .md y su mapeo a BD
|
|
ESTADOS_MD = {
|
|
'✅' => '✅',
|
|
'❌' => '❌',
|
|
'⚠️' => '⚠️',
|
|
'⏸️' => '⏸️',
|
|
'⏳' => '⏳',
|
|
'👁️' => '⏳', # Sincronización mapea a ⏳
|
|
'➡️' => '⏳', # Tarea continúa en otro día
|
|
'🎭' => '✅' # Evento/Servicio
|
|
}.freeze
|
|
|
|
# Modos posibles en archivos .md
|
|
MODOS_MD = {
|
|
'[P]' => 'P', # Presencial
|
|
'[R]' => 'R', # Remoto
|
|
'[P/R]' => 'P', # Presencial/Remoto -> Presencial por defecto
|
|
'[S]' => 'S' # Servicio (No nodo técnico)
|
|
}.freeze
|
|
|
|
# Tipos de nodo inferidos del nombre
|
|
TIPOS_NODO = {
|
|
/^srv-/ => 'servidor',
|
|
/^dc-/ => 'vm',
|
|
/^sql-/ => 'vm',
|
|
/^pcv-/ => 'vm',
|
|
/^pc-/ => 'pc',
|
|
/^srvv-/ => 'vm',
|
|
/^dtic-/ => 'servicio',
|
|
/-pmox\d+$/ => 'hipervisor',
|
|
/-xen\d+$/ => 'hipervisor'
|
|
}.freeze
|
|
|
|
# Inicializa el importador con conexión a base de datos
|
|
#
|
|
# @param db [BitacoraDB] Instancia de BitacoraDB para operaciones
|
|
# @param logger [Object] Logger para registro (opcional)
|
|
def initialize(db, logger = nil)
|
|
@db = db
|
|
@logger = logger || default_logger
|
|
@estadisticas = {
|
|
archivos_procesados: 0,
|
|
bitacoras_creadas: 0,
|
|
nodos_creados: 0,
|
|
temas_creados: 0,
|
|
entradas_creadas: 0,
|
|
errores: []
|
|
}
|
|
end
|
|
|
|
# Importa una bitácora específica desde archivo .md
|
|
#
|
|
# @param ruta_md [String] Ruta al archivo .md
|
|
# @param opciones [Hash] Opciones de importación
|
|
# :sobrescribir [Boolean] Sobrescribir bitácora si ya existe (default: false)
|
|
# :crear_nodos [Boolean] Crear nodos automáticamente si no existen (default: true)
|
|
# @return [Hash] Resultado de la importación con estadísticas
|
|
def importar_bitacora(ruta_md, opciones = {})
|
|
defaults = { sobrescribir: false, crear_nodos: true }
|
|
opciones = defaults.merge(opciones)
|
|
|
|
@estadisticas[:archivos_procesados] += 1
|
|
|
|
begin
|
|
# Leer y parsear archivo
|
|
contenido = File.read(ruta_md, encoding: 'UTF-8')
|
|
fecha = extraer_fecha_desde_ruta(ruta_md) || extraer_fecha_desde_contenido(contenido)
|
|
|
|
if fecha.nil?
|
|
error = "No se pudo determinar fecha del archivo: #{ruta_md}"
|
|
@logger.error(error)
|
|
@estadisticas[:errores] << error
|
|
return { error: error }
|
|
end
|
|
|
|
@logger.info("Importando bitácora #{fecha} desde #{ruta_md}")
|
|
|
|
# Verificar si ya existe bitácora
|
|
bitacora_existente = @db.find_bitacora_by_fecha(fecha)
|
|
if bitacora_existente && !opciones[:sobrescribir]
|
|
@logger.advertencia("Bitácora #{fecha} ya existe, omitiendo (use --sobrescribir)")
|
|
return {
|
|
skip: true,
|
|
mensaje: "Bitácora ya existe",
|
|
bitacora_id: bitacora_existente['id'],
|
|
estadisticas: @estadisticas
|
|
}
|
|
end
|
|
|
|
# Parsear contenido
|
|
estructura = parsear_contenido(contenido, fecha)
|
|
|
|
# Importar a base de datos
|
|
resultado = importar_estructura(estructura, opciones)
|
|
|
|
resultado.merge(
|
|
exitoso: resultado[:errores].empty?,
|
|
fecha: fecha,
|
|
estadisticas: @estadisticas.dup
|
|
)
|
|
|
|
rescue => e
|
|
error = "Error importando #{ruta_md}: #{e.message}"
|
|
@logger.error(error)
|
|
@estadisticas[:errores] << error
|
|
{
|
|
error: error,
|
|
backtrace: e.backtrace,
|
|
estadisticas: @estadisticas
|
|
}
|
|
end
|
|
end
|
|
|
|
# Importa todas las bitácoras de un directorio
|
|
#
|
|
# @param directorio [String] Ruta al directorio con archivos .md
|
|
# @param opciones [Hash] Opciones de importación
|
|
# @return [Hash] Resultado consolidado
|
|
def importar_directorio(directorio, opciones = {})
|
|
archivos = Dir.glob(File.join(directorio, '*.md')).sort
|
|
resultados = []
|
|
|
|
@logger.info("Importando #{archivos.length} archivos desde #{directorio}")
|
|
|
|
archivos.each do |archivo|
|
|
@logger.info("Procesando: #{File.basename(archivo)}")
|
|
resultado = importar_bitacora(archivo, opciones)
|
|
resultados << resultado.merge(archivo: archivo)
|
|
end
|
|
|
|
consolidar_resultados(resultados)
|
|
end
|
|
|
|
# Obtiene estadísticas de importación
|
|
#
|
|
# @return [Hash] Estadísticas acumuladas
|
|
def estadisticas
|
|
@estadisticas
|
|
end
|
|
|
|
private
|
|
|
|
# Extrae fecha desde la ruta del archivo (ej: bitacoras/2026-02-28.md)
|
|
def extraer_fecha_desde_ruta(ruta)
|
|
nombre = File.basename(ruta, '.md')
|
|
begin
|
|
Date.parse(nombre)
|
|
rescue Date::Error
|
|
nil
|
|
end
|
|
end
|
|
|
|
# Extrae fecha desde el contenido del archivo
|
|
def extraer_fecha_desde_contenido(contenido)
|
|
# Buscar patrón: # Bitácora 2026-02-28
|
|
match = contenido.match(/# Bitácora (\d{4}-\d{2}-\d{2})/)
|
|
return Date.parse(match[1]) if match
|
|
|
|
# Buscar patrón: # Bitácora de Operaciones - 28/02/2026
|
|
match = contenido.match(/# Bitácora de Operaciones - (\d{2}\/\d{2}\/\d{4})/)
|
|
if match
|
|
fecha_str = match[1]
|
|
dia, mes, anio = fecha_str.split('/')
|
|
return Date.parse("#{anio}-#{mes}-#{dia}")
|
|
end
|
|
|
|
nil
|
|
end
|
|
|
|
# Parsea el contenido del archivo .md a estructura jerárquica
|
|
def parsear_contenido(contenido, fecha)
|
|
lineas = contenido.lines.map(&:chomp)
|
|
|
|
estructura = {
|
|
fecha: fecha,
|
|
resumen: extraer_resumen(contenido),
|
|
nodos: {},
|
|
secciones: {}
|
|
}
|
|
|
|
nodo_actual = nil
|
|
tema_actual = nil
|
|
en_actividades_detalladas = false
|
|
en_tabla_entradas = false
|
|
encabezados_tabla = []
|
|
entradas_tabla = []
|
|
|
|
lineas.each_with_index do |linea, idx|
|
|
# Detectar sección de actividades detalladas (con cualquier emoji o sin él)
|
|
if linea.match?(/^## .*Actividades Detalladas/)
|
|
en_actividades_detalladas = true
|
|
next
|
|
end
|
|
|
|
# Detectar fin de sección (siguiente ##)
|
|
if en_actividades_detalladas && linea.start_with?('## ') && !linea.match?(/.*Actividades Detalladas/)
|
|
en_actividades_detalladas = false
|
|
end
|
|
|
|
# Solo procesar dentro de actividades detalladas
|
|
next unless en_actividades_detalladas
|
|
|
|
# Detectar nodo (### srv-ns8)
|
|
if linea.start_with?('### ') && !linea.start_with?('####')
|
|
nodo_nombre = linea.sub('### ', '').strip
|
|
nodo_actual = nodo_nombre
|
|
estructura[:nodos][nodo_actual] ||= {
|
|
nombre: nodo_nombre,
|
|
temas: {}
|
|
}
|
|
next
|
|
end
|
|
|
|
# Detectar tema (#### ✅ - SEC01 - Refactorización ns8-candados)
|
|
if linea.start_with?('#### ')
|
|
tema_linea = linea.sub('#### ', '').strip
|
|
tema_info = parsear_tema(tema_linea)
|
|
|
|
if tema_info && nodo_actual
|
|
tema_actual = tema_info[:id_tema]
|
|
estructura[:nodos][nodo_actual][:temas][tema_actual] = {
|
|
id_tema: tema_info[:id_tema],
|
|
titulo: tema_info[:titulo],
|
|
estado: tema_info[:estado],
|
|
descripcion: tema_info[:descripcion],
|
|
entradas: []
|
|
}
|
|
end
|
|
next
|
|
end
|
|
|
|
# Detectar inicio de tabla de entradas
|
|
if linea.match?(/^\| I \| F \| Descripción \| (?:J \| )?E \|$/)
|
|
en_tabla_entradas = true
|
|
encabezados_tabla = linea.split('|').map(&:strip).reject(&:empty?)
|
|
entradas_tabla = []
|
|
next
|
|
end
|
|
|
|
# Detectar fin de tabla
|
|
if en_tabla_entradas && (linea.empty? || linea.start_with?('#') || linea.start_with?('####'))
|
|
# Procesar entradas acumuladas
|
|
if tema_actual && nodo_actual && !entradas_tabla.empty?
|
|
entradas_parseadas = parsear_entradas_tabla(entradas_tabla, encabezados_tabla)
|
|
# Verificar que exista el tema antes de asignar entradas
|
|
if estructura[:nodos][nodo_actual] && estructura[:nodos][nodo_actual][:temas][tema_actual]
|
|
estructura[:nodos][nodo_actual][:temas][tema_actual][:entradas] = entradas_parseadas
|
|
else
|
|
@logger.advertencia("Tema #{tema_actual} no encontrado en nodo #{nodo_actual}, omitiendo entradas")
|
|
end
|
|
end
|
|
|
|
en_tabla_entradas = false
|
|
encabezados_tabla = []
|
|
entradas_tabla = []
|
|
end
|
|
|
|
# Acumular líneas de tabla
|
|
if en_tabla_entradas && linea.start_with?('|')
|
|
entradas_tabla << linea
|
|
end
|
|
end
|
|
|
|
# Procesar última tabla si estaba activa al final del archivo
|
|
if en_tabla_entradas && tema_actual && nodo_actual && !entradas_tabla.empty?
|
|
entradas_parseadas = parsear_entradas_tabla(entradas_tabla, encabezados_tabla)
|
|
# Verificar que exista el tema antes de asignar entradas
|
|
if estructura[:nodos][nodo_actual] && estructura[:nodos][nodo_actual][:temas][tema_actual]
|
|
estructura[:nodos][nodo_actual][:temas][tema_actual][:entradas] = entradas_parseadas
|
|
else
|
|
@logger.advertencia("Tema #{tema_actual} no encontrado en nodo #{nodo_actual}, omitiendo entradas")
|
|
end
|
|
end
|
|
|
|
estructura
|
|
end
|
|
|
|
# Extrae resumen general del contenido
|
|
def extraer_resumen(contenido)
|
|
# Buscar en sección "Resumen de Actividades" con cualquier emoji o sin él
|
|
patron_resumen = /### .*Resumen de Actividades/
|
|
match_resumen = contenido.match(patron_resumen)
|
|
|
|
if match_resumen
|
|
seccion = contenido.split(match_resumen[0])[1]
|
|
if seccion
|
|
# Tomar las primeras líneas después de la tabla
|
|
lineas = seccion.lines.map(&:chomp)
|
|
resumen_lineas = []
|
|
en_tabla = false
|
|
|
|
lineas.each do |linea|
|
|
if linea.match?(/^\|.*\|$/)
|
|
en_tabla = true
|
|
elsif en_tabla && !linea.match?(/^\|.*\|$/)
|
|
# Fin de tabla, empezar a capturar resumen
|
|
if linea.strip.length > 10 # Ignorar líneas muy cortas
|
|
resumen_lineas << linea.strip
|
|
end
|
|
end
|
|
end
|
|
|
|
return resumen_lineas.join(' ') if resumen_lineas.any?
|
|
end
|
|
end
|
|
|
|
nil
|
|
end
|
|
|
|
# Parsea línea de tema (ej: "✅ - SEC01 - Refactorización ns8-candados")
|
|
def parsear_tema(linea)
|
|
# Intentar formato estándar: estado - id - título (ej: ✅ - ADN01 - Título)
|
|
match_std = linea.match(/^([^\s-]+)\s*-\s*([A-Z0-9.]+)\s*-\s*(.+)$/)
|
|
if match_std
|
|
return {
|
|
id_tema: match_std[2],
|
|
titulo: match_std[3].strip,
|
|
estado: ESTADOS_MD[match_std[1]] || '⏳',
|
|
descripcion: match_std[3].strip
|
|
}
|
|
end
|
|
|
|
# Intentar formato simplificado: estado - título (ej: 🎭 - Servicio Auditorio)
|
|
match_simple = linea.match(/^([^\s-]+)\s*-\s*(.+)$/)
|
|
if match_simple
|
|
titulo = match_simple[2].strip
|
|
# Generar un ID determinista basado en el título para estabilidad
|
|
id_gen = "GEN" + Digest::MD5.hexdigest(titulo)[0..5].upcase
|
|
return {
|
|
id_tema: id_gen,
|
|
titulo: titulo,
|
|
estado: ESTADOS_MD[match_simple[1]] || '⏳',
|
|
descripcion: titulo
|
|
}
|
|
end
|
|
|
|
nil
|
|
end
|
|
|
|
# Parsea líneas de tabla de entradas
|
|
def parsear_entradas_tabla(lineas_tabla, encabezados)
|
|
entradas = []
|
|
|
|
# Mapeo de columnas basado en encabezados
|
|
columnas = {}
|
|
encabezados.each_with_index do |encabezado, idx|
|
|
case encabezado.downcase
|
|
when 'i' then columnas[:inicio] = idx
|
|
when 'f' then columnas[:fin] = idx
|
|
when 'descripción' then columnas[:descripcion] = idx
|
|
when 'j' then columnas[:jornada] = idx
|
|
when 'e' then columnas[:estado] = idx
|
|
end
|
|
end
|
|
|
|
lineas_tabla.each do |linea|
|
|
# Saltar separadores de tabla Markdown (ej: | :--- | :--- | :--- | :--- |)
|
|
next if linea.match?(/^[\|\s:-]+$/) # Solo pipes, espacios, guiones y dos puntos
|
|
next if linea.match?(/^\|?\s*:?-+:?\s*\|/) # Separadores con :---, ---, :-:, etc.
|
|
|
|
# Limpiar pipes iniciales y finales antes de split
|
|
linea_limpia = linea.strip.gsub(/^\||\|$/, '')
|
|
celdas = linea_limpia.split('|').map(&:strip)
|
|
next if celdas.length < 3 # Mínimo: inicio, descripción, estado
|
|
|
|
# Validar que la celda de inicio tenga contenido
|
|
valor_inicio = celdas[columnas[:inicio]]
|
|
next if valor_inicio.nil? || valor_inicio.empty? || valor_inicio.match?(/^:?-+:?$/)
|
|
|
|
fin_valor = nil
|
|
if columnas[:fin] && !celdas[columnas[:fin]].nil?
|
|
raw_fin = celdas[columnas[:fin]].strip
|
|
fin_valor = raw_fin if !raw_fin.empty? && raw_fin != '-'
|
|
end
|
|
|
|
entrada = {
|
|
inicio: valor_inicio.gsub(/\s*\(.*?\)\s*/, '').strip,
|
|
fin: fin_valor ? fin_valor.gsub(/\s*\(.*?\)\s*/, '').strip : nil,
|
|
descripcion: celdas[columnas[:descripcion]],
|
|
estado_modo: celdas[columnas[:estado]]
|
|
}
|
|
|
|
# Parsear estado y modo
|
|
if columnas[:jornada] && columnas[:estado]
|
|
# Nuevo formato: J y E separados
|
|
# Unimos temporalmente para usar parsear_estado_modo existente
|
|
campo_combinado = "[#{celdas[columnas[:jornada]]}] #{celdas[columnas[:estado]]}"
|
|
estado_modo = parsear_estado_modo(campo_combinado)
|
|
entrada[:estado] = estado_modo[:estado]
|
|
entrada[:modo] = estado_modo[:modo]
|
|
elsif columnas[:estado]
|
|
# Formato viejo o solo E
|
|
estado_modo = parsear_estado_modo(celdas[columnas[:estado]])
|
|
entrada[:estado] = estado_modo[:estado]
|
|
entrada[:modo] = estado_modo[:modo]
|
|
end
|
|
|
|
entradas << entrada
|
|
end
|
|
|
|
entradas
|
|
end
|
|
|
|
# Parsea campo estado/modo (ej: "[P] ✅")
|
|
def parsear_estado_modo(campo)
|
|
estado = '⏳'
|
|
modo = 'P'
|
|
|
|
# Buscar estado en el campo
|
|
ESTADOS_MD.each do |md_estado, bd_estado|
|
|
if campo.include?(md_estado)
|
|
estado = bd_estado
|
|
break
|
|
end
|
|
end
|
|
|
|
# Buscar modo en el campo
|
|
MODOS_MD.each do |md_modo, bd_modo|
|
|
if campo.include?(md_modo)
|
|
modo = bd_modo
|
|
break
|
|
end
|
|
end
|
|
|
|
{ estado: estado, modo: modo }
|
|
end
|
|
|
|
# Importa estructura parseada a base de datos
|
|
def importar_estructura(estructura, opciones)
|
|
errores = []
|
|
|
|
begin
|
|
# 1. Crear o actualizar bitácora
|
|
bitacora = @db.find_bitacora_by_fecha(estructura[:fecha])
|
|
|
|
if bitacora
|
|
@logger.info("Bitácora #{estructura[:fecha]} ya existe (ID: #{bitacora['id']})")
|
|
else
|
|
bitacora = @db.create_bitacora(
|
|
fecha: estructura[:fecha],
|
|
resumen: estructura[:resumen]
|
|
)
|
|
@estadisticas[:bitacoras_creadas] += 1
|
|
@logger.info("Bitácora creada: #{estructura[:fecha]} (ID: #{bitacora['id']})")
|
|
end
|
|
|
|
bitacora_id = bitacora['id']
|
|
|
|
# 1b. Si se solicita sobrescribir, limpiar entradas previas de esta bitácora
|
|
if opciones[:sobrescribir]
|
|
@logger.info("Limpiando datos previos de la bitácora #{estructura[:fecha]}...")
|
|
# Borrar entradas primero (FK)
|
|
@db.execute("DELETE FROM bitacoras.entradas WHERE bitacora_id = $1", [bitacora_id])
|
|
# Borrar temas (FK)
|
|
@db.execute("DELETE FROM bitacoras.temas WHERE bitacora_id = $1", [bitacora_id])
|
|
@estadisticas[:datos_limpiados] = true
|
|
end
|
|
|
|
# 2. Procesar cada nodo
|
|
estructura[:nodos].each do |nombre_nodo, datos_nodo|
|
|
# Buscar o crear nodo
|
|
nodo = @db.find_nodo_by_nombre(nombre_nodo)
|
|
|
|
if nodo.nil? && opciones[:crear_nodos]
|
|
tipo = inferir_tipo_nodo(nombre_nodo)
|
|
nodo = @db.create_nodo(
|
|
nombre: nombre_nodo,
|
|
tipo: tipo,
|
|
descripcion: "Importado desde bitácora #{estructura[:fecha]}"
|
|
)
|
|
@estadisticas[:nodos_creados] += 1
|
|
@logger.info("Nodo creado: #{nombre_nodo} (ID: #{nodo['id']})")
|
|
elsif nodo.nil?
|
|
@logger.advertencia("Nodo #{nombre_nodo} no existe y crear_nodos=false, omitiendo")
|
|
next
|
|
end
|
|
|
|
nodo_id = nodo['id']
|
|
|
|
# 3. Procesar temas del nodo
|
|
datos_nodo[:temas].each do |id_tema, datos_tema|
|
|
# Buscar tema por id_tema y bitácora
|
|
temas = @db.list_temas(bitacora_id: bitacora_id, nodo_id: nodo_id, limit: 100)
|
|
tema_existente = temas.find { |t| t['id_tema'] == id_tema }
|
|
|
|
if tema_existente
|
|
@logger.info("Tema #{id_tema} ya existe (ID: #{tema_existente['id']})")
|
|
tema_id = tema_existente['id']
|
|
else
|
|
tema = @db.create_tema(
|
|
id_tema: id_tema,
|
|
titulo: datos_tema[:titulo],
|
|
estado: datos_tema[:estado],
|
|
descripcion: datos_tema[:descripcion],
|
|
bitacora_id: bitacora_id,
|
|
nodo_id: nodo_id
|
|
)
|
|
tema_id = tema['id']
|
|
@estadisticas[:temas_creados] += 1
|
|
@logger.info("Tema creado: #{id_tema} (ID: #{tema_id})")
|
|
end
|
|
|
|
# 4. Procesar entradas del tema
|
|
datos_tema[:entradas].each do |entrada_md|
|
|
# Validar campos requeridos
|
|
next unless entrada_md[:inicio] && entrada_md[:descripcion]
|
|
|
|
# Intentar buscar entrada existente para evitar duplicados (Upsert)
|
|
# Buscamos por: bitacora_id, nodo_id y hora de inicio (única para un nodo en un día)
|
|
entradas_nodo = @db.list_entradas(bitacora_id: bitacora_id, nodo_id: nodo_id, limit: 100)
|
|
# Normalizar hora para comparación
|
|
inicio_norm = @db.send(:parse_time, entrada_md[:inicio])
|
|
|
|
existente = entradas_nodo.find { |e| e['inicio'] == inicio_norm }
|
|
|
|
begin
|
|
if existente
|
|
# Actualizar si ya existe
|
|
@db.update_entrada(existente['id'], {
|
|
fin: entrada_md[:fin],
|
|
descripcion: entrada_md[:descripcion],
|
|
estado: entrada_md[:estado] || '⏳',
|
|
modo: entrada_md[:modo] || 'P'
|
|
})
|
|
@estadisticas[:entradas_actualizadas] ||= 0
|
|
@estadisticas[:entradas_actualizadas] += 1
|
|
else
|
|
# Crear si no existe
|
|
@db.create_entrada(
|
|
inicio: entrada_md[:inicio],
|
|
fin: entrada_md[:fin],
|
|
descripcion: entrada_md[:descripcion],
|
|
estado: entrada_md[:estado] || '⏳',
|
|
modo: entrada_md[:modo] || 'P',
|
|
es_ia: false,
|
|
tema_id: tema_id,
|
|
bitacora_id: bitacora_id,
|
|
nodo_id: nodo_id
|
|
)
|
|
@estadisticas[:entradas_creadas] += 1
|
|
end
|
|
rescue => e
|
|
@logger.error("Error procesando entrada '#{entrada_md[:inicio]} - #{entrada_md[:descripcion]}': #{e.message}")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
rescue => e
|
|
error = "Error importando estructura: #{e.message}"
|
|
@logger.error(error)
|
|
errores << error
|
|
end
|
|
|
|
{ errores: errores }
|
|
end
|
|
|
|
# Infiere tipo de nodo basado en su nombre
|
|
def inferir_tipo_nodo(nombre)
|
|
TIPOS_NODO.each do |patron, tipo|
|
|
return tipo if nombre.match?(patron)
|
|
end
|
|
'servidor' # Tipo por defecto
|
|
end
|
|
|
|
# Consolida resultados de múltiples importaciones
|
|
def consolidar_resultados(resultados)
|
|
totales = {
|
|
archivos: resultados.length,
|
|
exitosos: resultados.count { |r| r[:exitoso] == true },
|
|
omitidos: resultados.count { |r| r[:skip] == true },
|
|
errores: resultados.count { |r| r[:error] }
|
|
}
|
|
|
|
estadisticas_consolidadas = {
|
|
archivos_procesados: resultados.length,
|
|
bitacoras_creadas: resultados.sum { |r| r.dig(:estadisticas, :bitacoras_creadas) || 0 },
|
|
nodos_creados: resultados.sum { |r| r.dig(:estadisticas, :nodos_creados) || 0 },
|
|
temas_creados: resultados.sum { |r| r.dig(:estadisticas, :temas_creados) || 0 },
|
|
entradas_creadas: resultados.sum { |r| r.dig(:estadisticas, :entradas_creadas) || 0 },
|
|
errores: resultados.flat_map { |r| r.dig(:estadisticas, :errores) || [] }.compact
|
|
}
|
|
|
|
{
|
|
totales: totales,
|
|
estadisticas: estadisticas_consolidadas,
|
|
detalles: resultados
|
|
}
|
|
end
|
|
|
|
# Logger por defecto
|
|
def default_logger
|
|
Class.new do
|
|
def info(msg); puts "[INFO] #{msg}"; end
|
|
def advertencia(msg); puts "[ADVERTENCIA] #{msg}"; end
|
|
def error(msg); puts "[ERROR] #{msg}"; end
|
|
end.new
|
|
end
|
|
end
|
|
end
|
|
end
|