soft_usite/migrations/migrate.go

package migrations

import (
	"fmt"
	"log"
	"time"

	"github.com/sujit-baniya/fiber-boilerplate/app"
	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

// Session structure for managing sessions
type Session struct {
	ID        uint   `gorm:"primaryKey"`
	SessionID string `gorm:"unique;not null"`
	Data      string `gorm:"type:text"`
	CreatedAt time.Time
	UpdatedAt time.Time
	ExpireAt  time.Time
}

// Migrate performs the database migrations
func Migrate() {
	log.Println("Initiating migration...")

	// Migrate the main application models
	if err := app.Http.Database.DB.Migrator().AutoMigrate(
		&models.Roles{},
		&models.Users{},
		&models.Modules{},
		&models.Submodules{},
		&models.Inicio{},
		&models.TipoServidor{},
		&models.TipoDb{},
		&models.Servidor{},
		&models.ConxDb{},
		&models.ConxSsh{},
		&models.ProvServidor{},
		&models.QrVcard{},
		&models.OssApi{},
		&models.VcfVcard{},
		&models.DlocalApi{},
		// Módulo de Renovaciones
		&models.Servicio{},
		&models.Cliente{},
		&models.PlantillaCorreo{},
		&models.NotificacionRegla{},
		&models.Contrato{},
		&models.NotificacionLog{},
		&models.SmtpConfig{},
		// Integraciones externas
		&models.HostingerConfig{},
		&models.CloudflareConfig{},
	); err != nil {
		log.Fatalf("Error during main migration: %v", err)
	}

	// Open (or create) a SQLite database for sessions
	db, err := gorm.Open(sqlite.Open("session.db"), &gorm.Config{})
	if err != nil {
		log.Fatalf("Error connecting to the database: %v", err)
		return
	}

	// Migrate the Session structure
	if err := db.AutoMigrate(&Session{}); err != nil {
		log.Fatalf("Error migrating session database: %v", err)
		return
	}

	fmt.Println("Session database created and table migrated successfully.")

	// Insertar módulo y submódulos de Renovaciones
	SeedRenovaciones()

	log.Println("Migration Completed...")
}

// MigrateRenovaciones crea/actualiza las tablas del módulo de Renovaciones.
// Es idempotente: GORM AutoMigrate solo añade columnas/tablas nuevas, nunca las borra.
func MigrateRenovaciones() {
	db := app.Http.Database.DB
	if err := db.AutoMigrate(
		&models.Servicio{},
		&models.Cliente{},
		&models.PlantillaCorreo{},
		&models.NotificacionRegla{},
		&models.Contrato{},
		&models.NotificacionLog{},
		&models.SmtpConfig{},
	); err != nil {
		log.Printf("[MIGRATE] Error en MigrateRenovaciones: %v", err)
	} else {
		log.Println("[MIGRATE] Tablas de Renovaciones OK")
	}
}

// SeedRenovaciones inserta el módulo "Renovaciones" y sus submódulos si no existen,
// y los asigna a todos los roles presentes en la BD.
func SeedRenovaciones() {
	db := app.Http.Database.DB

	// 1. Crear/obtener módulo
	var modulo models.Modules
	result := db.Where("title = ?", "Renovaciones").First(&modulo)
	if result.Error != nil {
		modulo = models.Modules{
			Title:       "Renovaciones",
			Description: "Gestión de contratos, clientes y notificaciones de vencimiento",
			ModifiedAt:  time.Now(),
		}
		if err := db.Create(&modulo).Error; err != nil {
			log.Printf("[SEED] Error creando módulo Renovaciones: %v", err)
			return
		}
		log.Printf("[SEED] Módulo 'Renovaciones' creado con ID %d", modulo.ID)
	} else {
		log.Printf("[SEED] Módulo 'Renovaciones' ya existe (ID %d)", modulo.ID)
	}

	// 2. Definir submódulos
	entries := []struct{ title, desc, url string }{
		{"Contratos", "Gestión de contratos y vencimientos", "/app/contratos"},
		{"Clientes", "Clientes y datos de contacto", "/app/clientes"},
		{"Servicios", "Catálogo de servicios", "/app/servicios"},
		{"Plantillas Correo", "Editor de plantillas de correo", "/app/plantillas-correo"},
		{"Reglas de Aviso", "Reglas de notificación automática", "/app/reglas-notificacion"},
		{"Historial Notif.", "Historial de correos enviados", "/app/historial-notificaciones"},
		{"Config. SMTP", "Configuración del servidor de correo", "/app/smtp-config"},
	}

	var insertados []models.Submodules
	for _, e := range entries {
		var sub models.Submodules
		if err := db.Where("url = ?", e.url).First(&sub).Error; err != nil {
			sub = models.Submodules{
				Title:       e.title,
				Description: e.desc,
				Url:         e.url,
				ModuleId:    modulo.ID,
				ModifiedAt:  time.Now(),
			}
			if err := db.Create(&sub).Error; err != nil {
				log.Printf("[SEED] Error creando submódulo '%s': %v", e.title, err)
				continue
			}
			log.Printf("[SEED] Submódulo '%s' creado (ID %d)", e.title, sub.ID)
		} else {
			// Asegurar que el submódulo apunte al módulo correcto (Renovaciones)
			if sub.ModuleId != modulo.ID {
				if err := db.Model(&sub).Update("module_id", modulo.ID).Error; err != nil {
					log.Printf("[SEED] Error actualizando module_id de '%s': %v", sub.Title, err)
				} else {
					log.Printf("[SEED] Submódulo '%s' reasignado a módulo Renovaciones", sub.Title)
				}
			} else {
				log.Printf("[SEED] Submódulo '%s' ya existe (ID %d)", sub.Title, sub.ID)
			}
		}
		insertados = append(insertados, sub)
	}

	// 3. Asignar a todos los roles existentes
	var roles []models.Roles
	if err := db.Find(&roles).Error; err != nil {
		log.Printf("[SEED] Error obteniendo roles: %v", err)
		return
	}
	for _, rol := range roles {
		if err := db.Model(&rol).Association("Submodules").Append(&insertados); err != nil {
			log.Printf("[SEED] Error asignando submódulos al rol '%s': %v", rol.Name, err)
		} else {
			log.Printf("[SEED] Submódulos de Renovaciones asignados al rol '%s'", rol.Name)
		}
	}

	log.Println("[SEED] Seed de Renovaciones completado.")
}