go integration and wikipedia

backend/internal/cache/redis.go

@@ -0,0 +1,72 @@
+package cache
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/redis/go-redis/v9"
+)
+
+var Client *redis.Client
+
+func Connect(redisURL string) error {
+	opt, err := redis.ParseURL(redisURL)
+	if err != nil {
+		return fmt.Errorf("failed to parse redis URL: %w", err)
+	}
+
+	Client = redis.NewClient(opt)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	if err = Client.Ping(ctx).Err(); err != nil {
+		return fmt.Errorf("failed to ping redis: %w", err)
+	}
+
+	return nil
+}
+
+func Close() {
+	if Client != nil {
+		Client.Close()
+	}
+}
+
+func GetClient() *redis.Client {
+	return Client
+}
+
+func SearchKey(query, lang string, page, perPage int) string {
+	return fmt.Sprintf("search:%s:%s:%d:%d", query, lang, page, perPage)
+}
+
+func NewsKey(newsID int64, lang string) string {
+	return fmt.Sprintf("news:%d:%s", newsID, lang)
+}
+
+func FeedKey(feedID int64) string {
+	return fmt.Sprintf("feed:%d", feedID)
+}
+
+func Set(ctx context.Context, key string, value interface{}, expiration time.Duration) error {
+	data, err := json.Marshal(value)
+	if err != nil {
+		return err
+	}
+	return Client.Set(ctx, key, data, expiration).Err()
+}
+
+func Get(ctx context.Context, key string) (string, error) {
+	return Client.Get(ctx, key).Result()
+}
+
+func Unmarshal(data []byte, v interface{}) error {
+	return json.Unmarshal(data, v)
+}
+
+func Marshal(v interface{}) ([]byte, error) {
+	return json.Marshal(v)
+}

backend/internal/config/config.go

@@ -0,0 +1,66 @@
+package config
+
+import (
+	"os"
+	"strconv"
+	"time"
+)
+
+type Config struct {
+	ServerPort         string
+	DatabaseURL        string
+	RedisURL           string
+	QdrantHost         string
+	QdrantPort         int
+	SecretKey          string
+	JWTExpiration      time.Duration
+	TranslationURL     string
+	OllamaURL          string
+	SpacyURL           string
+	DefaultLang        string
+	NewsPerPage        int
+	RateLimitPerMinute int
+}
+
+func Load() *Config {
+	return &Config{
+		ServerPort:         getEnv("SERVER_PORT", "8080"),
+		DatabaseURL:        getEnv("DATABASE_URL", "postgres://rss:rss@localhost:5432/rss"),
+		RedisURL:           getEnv("REDIS_URL", "redis://localhost:6379"),
+		QdrantHost:         getEnv("QDRANT_HOST", "localhost"),
+		QdrantPort:         getEnvInt("QDRANT_PORT", 6333),
+		SecretKey:          getEnv("SECRET_KEY", "change-this-secret-key"),
+		JWTExpiration:      getEnvDuration("JWT_EXPIRATION", 24*time.Hour),
+		TranslationURL:     getEnv("TRANSLATION_URL", "http://libretranslate:7790"),
+		OllamaURL:          getEnv("OLLAMA_URL", "http://ollama:11434"),
+		SpacyURL:           getEnv("SPACY_URL", "http://spacy:8000"),
+		DefaultLang:        getEnv("DEFAULT_LANG", "es"),
+		NewsPerPage:        getEnvInt("NEWS_PER_PAGE", 30),
+		RateLimitPerMinute: getEnvInt("RATE_LIMIT_PER_MINUTE", 60),
+	}
+}
+
+func getEnv(key, defaultValue string) string {
+	if value := os.Getenv(key); value != "" {
+		return value
+	}
+	return defaultValue
+}
+
+func getEnvInt(key string, defaultValue int) int {
+	if value := os.Getenv(key); value != "" {
+		if intVal, err := strconv.Atoi(value); err == nil {
+			return intVal
+		}
+	}
+	return defaultValue
+}
+
+func getEnvDuration(key string, defaultValue time.Duration) time.Duration {
+	if value := os.Getenv(key); value != "" {
+		if duration, err := time.ParseDuration(value); err == nil {
+			return duration
+		}
+	}
+	return defaultValue
+}

backend/internal/db/postgres.go

@@ -0,0 +1,44 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var Pool *pgxpool.Pool
+
+func Connect(databaseURL string) error {
+	config, err := pgxpool.ParseConfig(databaseURL)
+	if err != nil {
+		return fmt.Errorf("failed to parse database URL: %w", err)
+	}
+
+	config.MaxConns = 25
+	config.MinConns = 5
+	config.MaxConnLifetime = time.Hour
+	config.MaxConnIdleTime = 30 * time.Minute
+
+	Pool, err = pgxpool.NewWithConfig(context.Background(), config)
+	if err != nil {
+		return fmt.Errorf("failed to create pool: %w", err)
+	}
+
+	if err = Pool.Ping(context.Background()); err != nil {
+		return fmt.Errorf("failed to ping database: %w", err)
+	}
+
+	return nil
+}
+
+func Close() {
+	if Pool != nil {
+		Pool.Close()
+	}
+}
+
+func GetPool() *pgxpool.Pool {
+	return Pool
+}

backend/internal/handlers/admin.go

@@ -0,0 +1,760 @@
+package handlers
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/csv"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/rss2/backend/internal/db"
+	"github.com/rss2/backend/internal/models"
+)
+
+
+
+func CreateAlias(c *gin.Context) {
+	var req models.EntityAliasRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request", "message": err.Error()})
+		return
+	}
+
+	ctx := c.Request.Context()
+	tx, err := db.GetPool().Begin(ctx)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to start transaction", "message": err.Error()})
+		return
+	}
+	defer tx.Rollback(ctx)
+
+	// 1. Ensure the canonical tag exists in tags table
+	var canonicalTagId int
+	err = tx.QueryRow(ctx, `
+		INSERT INTO tags (valor, tipo) VALUES ($1, $2)
+		ON CONFLICT (valor, tipo) DO UPDATE SET valor = EXCLUDED.valor
+		RETURNING id`, req.CanonicalName, req.Tipo).Scan(&canonicalTagId)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to ensure canonical tag", "message": err.Error()})
+		return
+	}
+
+	for _, alias := range req.Aliases {
+		alias = strings.TrimSpace(alias)
+		if alias == "" {
+			continue
+		}
+
+		// Insert the alias mapping into entity_aliases
+		_, err = tx.Exec(ctx, `
+			INSERT INTO entity_aliases (canonical_name, alias, tipo)
+			VALUES ($1, $2, $3)
+			ON CONFLICT (alias, tipo) DO UPDATE SET canonical_name = EXCLUDED.canonical_name`,
+			req.CanonicalName, alias, req.Tipo)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to insert alias", "message": err.Error()})
+			return
+		}
+
+		// 2. Check if the original alias string actually exists as a tag
+		var aliasTagId int
+		err = tx.QueryRow(ctx, "SELECT id FROM tags WHERE valor = $1 AND tipo = $2", alias, req.Tipo).Scan(&aliasTagId)
+		if err == nil && aliasTagId != 0 && aliasTagId != canonicalTagId {
+			// 3. Move all mentions in tags_noticia to the canonical tag id safely
+			_, err = tx.Exec(ctx, `
+				UPDATE tags_noticia 
+				SET tag_id = $1 
+				WHERE tag_id = $2 AND NOT EXISTS (
+					SELECT 1 FROM tags_noticia tn2 
+					WHERE tn2.tag_id = $1 AND tn2.noticia_id = tags_noticia.noticia_id AND tn2.traduccion_id = tags_noticia.traduccion_id
+				)
+			`, canonicalTagId, aliasTagId)
+			if err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to reassign news mentions safely", "message": err.Error()})
+				return
+			}
+			
+			// Delete any remaining orphaned mentions of the alias that couldn't be merged (duplicates)
+			_, err = tx.Exec(ctx, "DELETE FROM tags_noticia WHERE tag_id = $1", aliasTagId)
+			if err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete orphaned mentions", "message": err.Error()})
+				return
+			}
+
+			// 4. Delete the original alias tag
+			_, err = tx.Exec(ctx, "DELETE FROM tags WHERE id = $1", aliasTagId)
+			if err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete old tag", "message": err.Error()})
+				return
+			}
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to commit transaction", "message": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusCreated, gin.H{
+		"message":        "Aliases created and metrics merged successfully",
+		"canonical_name": req.CanonicalName,
+		"aliases_added":  req.Aliases,
+		"tipo":           req.Tipo,
+	})
+}
+
+
+
+func ExportAliases(c *gin.Context) {
+	rows, err := db.GetPool().Query(c.Request.Context(),
+		"SELECT alias, canonical_name, tipo FROM entity_aliases ORDER BY tipo, canonical_name")
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get aliases", "message": err.Error()})
+		return
+	}
+	defer rows.Close()
+
+	c.Header("Content-Type", "text/csv")
+	c.Header("Content-Disposition", "attachment; filename=aliases.csv")
+	c.Header("Cache-Control", "no-cache")
+
+	writer := csv.NewWriter(c.Writer)
+	writer.Write([]string{"alias", "canonical_name", "tipo"})
+
+	for rows.Next() {
+		var alias, canonical, tipo string
+		rows.Scan(&alias, &canonical, &tipo)
+		writer.Write([]string{alias, canonical, tipo})
+	}
+	writer.Flush()
+}
+
+func ImportAliases(c *gin.Context) {
+	file, err := c.FormFile("file")
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "No file uploaded"})
+		return
+	}
+
+	src, err := file.Open()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to open file"})
+		return
+	}
+	defer src.Close()
+
+	reader := csv.NewReader(src)
+	records, err := reader.ReadAll()
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Failed to parse CSV", "message": err.Error()})
+		return
+	}
+
+	if len(records) < 2 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "CSV file is empty or has no data rows"})
+		return
+	}
+
+	ctx := context.Background()
+	tx, err := db.GetPool().Begin(ctx)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to start transaction"})
+		return
+	}
+	defer tx.Rollback(ctx)
+
+	inserted := 0
+	skipped := 0
+
+	for i, record := range records[1:] {
+		if len(record) < 3 {
+			skipped++
+			continue
+		}
+
+		alias := strings.TrimSpace(record[0])
+		canonical := strings.TrimSpace(record[1])
+		tipo := strings.TrimSpace(record[2])
+
+		if alias == "" || canonical == "" {
+			skipped++
+			continue
+		}
+
+		_, err = tx.Exec(ctx,
+			"INSERT INTO entity_aliases (alias, canonical_name, tipo) VALUES ($1, $2, $3) ON CONFLICT (alias, tipo) DO UPDATE SET canonical_name = $2",
+			alias, canonical, tipo)
+		if err != nil {
+			fmt.Printf("Error inserting row %d: %v\n", i+1, err)
+			skipped++
+			continue
+		}
+		inserted++
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to commit transaction", "message": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"message":  "Import completed",
+		"inserted": inserted,
+		"skipped":  skipped,
+	})
+}
+
+func GetAdminStats(c *gin.Context) {
+	var totalUsers, totalAliases int
+
+	db.GetPool().QueryRow(c.Request.Context(), "SELECT COUNT(*) FROM users").Scan(&totalUsers)
+	db.GetPool().QueryRow(c.Request.Context(), "SELECT COUNT(*) FROM entity_aliases").Scan(&totalAliases)
+
+	c.JSON(http.StatusOK, gin.H{
+		"total_users":   totalUsers,
+		"total_aliases": totalAliases,
+	})
+}
+
+func GetUsers(c *gin.Context) {
+	rows, err := db.GetPool().Query(c.Request.Context(), `
+		SELECT id, email, username, is_admin, created_at, updated_at 
+		FROM users ORDER BY created_at DESC`)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get users", "message": err.Error()})
+		return
+	}
+	defer rows.Close()
+
+	type UserRow struct {
+		ID        int64  `json:"id"`
+		Email     string `json:"email"`
+		Username  string `json:"username"`
+		IsAdmin   bool   `json:"is_admin"`
+		CreatedAt string `json:"created_at"`
+		UpdatedAt string `json:"updated_at"`
+	}
+
+	var users []UserRow
+	for rows.Next() {
+		var u UserRow
+		if err := rows.Scan(&u.ID, &u.Email, &u.Username, &u.IsAdmin, &u.CreatedAt, &u.UpdatedAt); err != nil {
+			continue
+		}
+		users = append(users, u)
+	}
+
+	if users == nil {
+		users = []UserRow{}
+	}
+
+	c.JSON(http.StatusOK, gin.H{"users": users, "total": len(users)})
+}
+
+func PromoteUser(c *gin.Context) {
+	id, err := strconv.Atoi(c.Param("id"))
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid user ID"})
+		return
+	}
+
+	result, err := db.GetPool().Exec(c.Request.Context(), "UPDATE users SET is_admin = true WHERE id = $1", id)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to promote user", "message": err.Error()})
+		return
+	}
+
+	if result.RowsAffected() == 0 {
+		c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "User promoted to admin"})
+}
+
+func DemoteUser(c *gin.Context) {
+	id, err := strconv.Atoi(c.Param("id"))
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid user ID"})
+		return
+	}
+
+	result, err := db.GetPool().Exec(c.Request.Context(), "UPDATE users SET is_admin = false WHERE id = $1", id)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to demote user", "message": err.Error()})
+		return
+	}
+
+	if result.RowsAffected() == 0 {
+		c.JSON(http.StatusNotFound, gin.H{"error": "User not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "User demoted from admin"})
+}
+
+func ResetDatabase(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	tables := []string{
+		"noticias",
+		"feeds",
+		"traducciones",
+		"tags_noticia",
+		"tags",
+		"entity_aliases",
+		"favoritos",
+		"videos",
+		"video_parrillas",
+		"eventos",
+		"search_history",
+	}
+
+	tx, err := db.GetPool().Begin(ctx)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to start transaction"})
+		return
+	}
+	defer tx.Rollback(ctx)
+
+	for _, table := range tables {
+		_, err = tx.Exec(ctx, "DELETE FROM "+table)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete from " + table, "message": err.Error()})
+			return
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to commit transaction", "message": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"message":        "Database reset successfully. All data has been deleted.",
+		"tables_cleared": tables,
+	})
+}
+
+type WorkerConfig struct {
+	Type    string `json:"type"`
+	Workers int    `json:"workers"`
+	Status  string `json:"status"`
+}
+
+func GetWorkerStatus(c *gin.Context) {
+	var translatorType, translatorWorkers, translatorStatus string
+
+	err := db.GetPool().QueryRow(c.Request.Context(), "SELECT value FROM config WHERE key = 'translator_type'").Scan(&translatorType)
+	if err != nil {
+		translatorType = "cpu"
+	}
+
+	err = db.GetPool().QueryRow(c.Request.Context(), "SELECT value FROM config WHERE key = 'translator_workers'").Scan(&translatorWorkers)
+	if err != nil {
+		translatorWorkers = "2"
+	}
+
+	err = db.GetPool().QueryRow(c.Request.Context(), "SELECT value FROM config WHERE key = 'translator_status'").Scan(&translatorStatus)
+	if err != nil {
+		translatorStatus = "stopped"
+	}
+
+	workers, _ := strconv.Atoi(translatorWorkers)
+
+	// Verificar si los contenedores están corriendo
+	runningCount := 0
+	if translatorStatus == "running" {
+		cmd := exec.Command("docker", "compose", "ps", "-q", "translator")
+		output, _ := cmd.Output()
+		if len(output) > 0 {
+			runningCount = workers
+		}
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"type":    translatorType,
+		"workers": workers,
+		"status":  translatorStatus,
+		"running": runningCount,
+	})
+}
+
+func SetWorkerConfig(c *gin.Context) {
+	var req WorkerConfig
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request", "message": err.Error()})
+		return
+	}
+
+	if req.Type != "cpu" && req.Type != "gpu" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Type must be 'cpu' or 'gpu'"})
+		return
+	}
+
+	if req.Workers < 1 || req.Workers > 8 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Workers must be between 1 and 8"})
+		return
+	}
+
+	ctx := c.Request.Context()
+
+	_, err := db.GetPool().Exec(ctx, "UPDATE config SET value = $1, updated_at = NOW() WHERE key = 'translator_type'", req.Type)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update translator_type"})
+		return
+	}
+
+	_, err = db.GetPool().Exec(ctx, "UPDATE config SET value = $1, updated_at = NOW() WHERE key = 'translator_workers'", strconv.Itoa(req.Workers))
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update translator_workers"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"message": "Worker configuration updated",
+		"type":    req.Type,
+		"workers": req.Workers,
+		"status":  req.Status,
+	})
+}
+
+func StartWorkers(c *gin.Context) {
+	var req WorkerConfig
+	c.ShouldBindJSON(&req)
+
+	ctx := c.Request.Context()
+
+	// Obtener configuración actual
+	var translatorType, translatorWorkers string
+	err := db.GetPool().QueryRow(ctx, "SELECT value FROM config WHERE key = 'translator_type'").Scan(&translatorType)
+	if err != nil || translatorType == "" {
+		translatorType = "cpu"
+	}
+	err = db.GetPool().QueryRow(ctx, "SELECT value FROM config WHERE key = 'translator_workers'").Scan(&translatorWorkers)
+	if err != nil || translatorWorkers == "" {
+		translatorWorkers = "2"
+	}
+
+	if req.Type != "" {
+		translatorType = req.Type
+	}
+	if req.Workers > 0 {
+		translatorWorkers = strconv.Itoa(req.Workers)
+	}
+
+	workers, _ := strconv.Atoi(translatorWorkers)
+	if workers < 1 {
+		workers = 2
+	}
+	if workers > 8 {
+		workers = 8
+	}
+
+	// Determinar qué servicio iniciar
+	serviceName := "translator"
+	if translatorType == "gpu" {
+		serviceName = "translator-gpu"
+	}
+
+	// Detener cualquier translator existente
+	stopCmd := exec.Command("docker", "compose", "stop", "translator", "translator-gpu")
+	stopCmd.Dir = "/datos/rss2"
+	stopCmd.Run()
+
+	// Iniciar con el número de workers
+	startCmd := exec.Command("docker", "compose", "up", "-d", "--scale", fmt.Sprintf("%s=%d", serviceName, workers), serviceName)
+	startCmd.Dir = "/datos/rss2"
+	output, err := startCmd.CombinedOutput()
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error":   "Failed to start workers",
+			"details": string(output),
+		})
+		return
+	}
+
+	// Actualizar estado en BD
+	db.GetPool().Exec(ctx, "UPDATE config SET value = 'running', updated_at = NOW() WHERE key = 'translator_status'")
+	db.GetPool().Exec(ctx, "UPDATE config SET value = $1, updated_at = NOW() WHERE key = 'translator_type'", translatorType)
+	db.GetPool().Exec(ctx, "UPDATE config SET value = $1, updated_at = NOW() WHERE key = 'translator_workers'", translatorWorkers)
+
+	c.JSON(http.StatusOK, gin.H{
+		"message": "Workers started successfully",
+		"type":    translatorType,
+		"workers": workers,
+		"status":  "running",
+	})
+}
+
+func StopWorkers(c *gin.Context) {
+	// Detener traductores
+	cmd := exec.Command("docker", "compose", "stop", "translator", "translator-gpu")
+	cmd.Dir = "/datos/rss2"
+	output, err := cmd.CombinedOutput()
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error":   "Failed to stop workers",
+			"details": string(output),
+		})
+		return
+	}
+
+	// Actualizar estado en BD
+	db.GetPool().Exec(c.Request.Context(), "UPDATE config SET value = 'stopped', updated_at = NOW() WHERE key = 'translator_status'")
+
+	c.JSON(http.StatusOK, gin.H{
+		"message": "Workers stopped successfully",
+		"status":  "stopped",
+	})
+}
+
+// PatchEntityTipo changes the tipo of all tags matching a given valor
+func PatchEntityTipo(c *gin.Context) {
+	var req struct {
+		Valor    string `json:"valor" binding:"required"`
+		NewTipo  string `json:"new_tipo" binding:"required"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request", "message": err.Error()})
+		return
+	}
+
+	validTipos := map[string]bool{"persona": true, "organizacion": true, "lugar": true, "tema": true}
+	if !validTipos[req.NewTipo] {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid tipo. Must be persona, organizacion, lugar or tema"})
+		return
+	}
+
+	ctx := c.Request.Context()
+	tx, err := db.GetPool().Begin(ctx)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to start transaction", "message": err.Error()})
+		return
+	}
+	defer tx.Rollback(ctx)
+
+	// Since we don't know the exact old Tipo, we find all tags with this valor that ARE NOT already the new tipo
+	rows, err := tx.Query(ctx, "SELECT id, tipo FROM tags WHERE valor = $1 AND tipo != $2", req.Valor, req.NewTipo)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch existing tags", "message": err.Error()})
+		return
+	}
+	
+	type OldTag struct {
+		ID   int
+		Tipo string
+	}
+	var tagsToMove []OldTag
+	for rows.Next() {
+		var ot OldTag
+		if err := rows.Scan(&ot.ID, &ot.Tipo); err == nil {
+			tagsToMove = append(tagsToMove, ot)
+		}
+	}
+	rows.Close()
+
+	if len(tagsToMove) == 0 {
+		c.JSON(http.StatusOK, gin.H{"message": "No entities found to update or already the requested tipo"})
+		return
+	}
+
+	// Make sure the target tag (valor, new_tipo) exists
+	var targetTagId int
+	err = tx.QueryRow(ctx, `
+		INSERT INTO tags (valor, tipo) VALUES ($1, $2)
+		ON CONFLICT (valor, tipo) DO UPDATE SET valor = EXCLUDED.valor
+		RETURNING id`, req.Valor, req.NewTipo).Scan(&targetTagId)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to ensure target tag", "message": err.Error()})
+		return
+	}
+
+	totalMoved := 0
+	for _, old := range tagsToMove {
+		if old.ID == targetTagId {
+			continue
+		}
+
+		// Move valid tags_noticia references to the target tag id safely
+		res, err := tx.Exec(ctx, `
+			UPDATE tags_noticia 
+			SET tag_id = $1 
+			WHERE tag_id = $2 AND NOT EXISTS (
+				SELECT 1 FROM tags_noticia tn2 
+				WHERE tn2.tag_id = $1 AND tn2.noticia_id = tags_noticia.noticia_id AND tn2.traduccion_id = tags_noticia.traduccion_id
+			)
+		`, targetTagId, old.ID)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to reassign news mentions", "message": err.Error()})
+			return
+		}
+		totalMoved += int(res.RowsAffected())
+
+		// Delete any remaining orphaned mentions (duplicates)
+		_, err = tx.Exec(ctx, "DELETE FROM tags_noticia WHERE tag_id = $1", old.ID)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete orphaned mentions", "message": err.Error()})
+			return
+		}
+
+		// Delete the old tag since it's now merged
+		_, err = tx.Exec(ctx, "DELETE FROM tags WHERE id = $1", old.ID)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete old tag", "message": err.Error()})
+			return
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to commit transaction", "message": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"message":       "Entity tipo updated and merged successfully",
+		"valor":         req.Valor,
+		"new_tipo":      req.NewTipo,
+		"tags_merged":   len(tagsToMove),
+		"rows_affected": totalMoved,
+	})
+}
+
+// BackupDatabase runs pg_dump and returns the SQL as a downloadable file
+func BackupDatabase(c *gin.Context) {
+	dbHost := os.Getenv("DB_HOST")
+	if dbHost == "" {
+		dbHost = "db"
+	}
+	dbPort := os.Getenv("DB_PORT")
+	if dbPort == "" {
+		dbPort = "5432"
+	}
+	dbName := os.Getenv("DB_NAME")
+	if dbName == "" {
+		dbName = "rss"
+	}
+	dbUser := os.Getenv("DB_USER")
+	if dbUser == "" {
+		dbUser = "rss"
+	}
+	dbPass := os.Getenv("DB_PASS")
+
+	cmd := exec.Command("pg_dump",
+		"-h", dbHost,
+		"-p", dbPort,
+		"-U", dbUser,
+		"-d", dbName,
+		"--no-password",
+	)
+	cmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", dbPass))
+
+	var out bytes.Buffer
+	var stderr bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &stderr
+
+	if err := cmd.Run(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error":   "pg_dump failed",
+			"details": stderr.String(),
+		})
+		return
+	}
+
+	filename := fmt.Sprintf("backup_%s.sql", time.Now().Format("2006-01-02_15-04-05"))
+	c.Header("Content-Type", "application/octet-stream")
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
+	c.Header("Cache-Control", "no-cache")
+	c.Data(http.StatusOK, "application/octet-stream", out.Bytes())
+}
+
+// BackupNewsZipped performs a pg_dump of news tables and returns a ZIP file
+func BackupNewsZipped(c *gin.Context) {
+	dbHost := os.Getenv("DB_HOST")
+	if dbHost == "" {
+		dbHost = "db"
+	}
+	dbPort := os.Getenv("DB_PORT")
+	if dbPort == "" {
+		dbPort = "5432"
+	}
+	dbName := os.Getenv("DB_NAME")
+	if dbName == "" {
+		dbName = "rss"
+	}
+	dbUser := os.Getenv("DB_USER")
+	if dbUser == "" {
+		dbUser = "rss"
+	}
+	dbPass := os.Getenv("DB_PASS")
+
+	// Tables to backup
+	tables := []string{"noticias", "traducciones", "tags", "tags_noticia"}
+
+	args := []string{
+		"-h", dbHost,
+		"-p", dbPort,
+		"-U", dbUser,
+		"-d", dbName,
+		"--no-password",
+	}
+
+	for _, table := range tables {
+		args = append(args, "-t", table)
+	}
+
+	cmd := exec.Command("pg_dump", args...)
+	cmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", dbPass))
+
+	var sqlOut bytes.Buffer
+	var stderr bytes.Buffer
+	cmd.Stdout = &sqlOut
+	cmd.Stderr = &stderr
+
+	if err := cmd.Run(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error":   "pg_dump failed",
+			"details": stderr.String(),
+		})
+		return
+	}
+
+	// Create ZIP
+	buf := new(bytes.Buffer)
+	zw := zip.NewWriter(buf)
+
+	sqlFileName := fmt.Sprintf("backup_noticias_%s.sql", time.Now().Format("2006-01-02"))
+	f, err := zw.Create(sqlFileName)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create ZIP entry", "message": err.Error()})
+		return
+	}
+
+	_, err = f.Write(sqlOut.Bytes())
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to write to ZIP", "message": err.Error()})
+		return
+	}
+
+	if err := zw.Close(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to close ZIP writer", "message": err.Error()})
+		return
+	}
+
+	filename := fmt.Sprintf("backup_noticias_%s.zip", time.Now().Format("2006-01-02_15-04-05"))
+	c.Header("Content-Type", "application/zip")
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
+	c.Header("Cache-Control", "no-cache")
+	c.Data(http.StatusOK, "application/zip", buf.Bytes())
+}
+

backend/internal/handlers/auth.go

@@ -0,0 +1,183 @@
+package handlers
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/rss2/backend/internal/config"
+	"github.com/rss2/backend/internal/db"
+	"github.com/rss2/backend/internal/models"
+	"golang.org/x/crypto/bcrypt"
+)
+
+var jwtSecret []byte
+
+func CheckFirstUser(c *gin.Context) {
+	var count int
+	err := db.GetPool().QueryRow(c.Request.Context(), "SELECT COUNT(*) FROM users").Scan(&count)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to check users"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"is_first_user": count == 0, "total_users": count})
+}
+
+func InitAuth(secret string) {
+	jwtSecret = []byte(secret)
+}
+
+type Claims struct {
+	UserID   int64  `json:"user_id"`
+	Email    string `json:"email"`
+	Username string `json:"username"`
+	IsAdmin  bool   `json:"is_admin"`
+	jwt.RegisteredClaims
+}
+
+func Login(c *gin.Context) {
+	var req models.LoginRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "Invalid request", Message: err.Error()})
+		return
+	}
+
+	var user models.User
+	err := db.GetPool().QueryRow(c.Request.Context(), `
+		SELECT id, email, username, password_hash, is_admin, created_at, updated_at
+		FROM users WHERE email = $1`, req.Email).Scan(
+		&user.ID, &user.Email, &user.Username, &user.PasswordHash, &user.IsAdmin,
+		&user.CreatedAt, &user.UpdatedAt,
+	)
+	if err != nil {
+		c.JSON(http.StatusUnauthorized, models.ErrorResponse{Error: "Invalid credentials"})
+		return
+	}
+
+	if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(req.Password)); err != nil {
+		c.JSON(http.StatusUnauthorized, models.ErrorResponse{Error: "Invalid credentials"})
+		return
+	}
+
+	expirationTime := time.Now().Add(24 * time.Hour)
+	claims := &Claims{
+		UserID:   user.ID,
+		Email:    user.Email,
+		Username: user.Username,
+		IsAdmin:  user.IsAdmin,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(expirationTime),
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+		},
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	tokenString, err := token.SignedString(jwtSecret)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to generate token"})
+		return
+	}
+
+	c.JSON(http.StatusOK, models.AuthResponse{
+		Token: tokenString,
+		User:  user,
+	})
+}
+
+func Register(c *gin.Context) {
+	var req models.RegisterRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "Invalid request", Message: err.Error()})
+		return
+	}
+
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to hash password"})
+		return
+	}
+
+	var userCount int
+	db.GetPool().QueryRow(c.Request.Context(), "SELECT COUNT(*) FROM users").Scan(&userCount)
+	isFirstUser := userCount == 0
+
+	var userID int64
+	err = db.GetPool().QueryRow(c.Request.Context(), `
+		INSERT INTO users (email, username, password_hash, is_admin, created_at, updated_at)
+		VALUES ($1, $2, $3, $4, NOW(), NOW())
+		RETURNING id`,
+		req.Email, req.Username, string(hashedPassword), isFirstUser,
+	).Scan(&userID)
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to create user", Message: err.Error()})
+		return
+	}
+
+	var user models.User
+	err = db.GetPool().QueryRow(c.Request.Context(), `
+		SELECT id, email, username, is_admin, created_at, updated_at
+		FROM users WHERE id = $1`, userID).Scan(
+		&user.ID, &user.Email, &user.Username, &user.IsAdmin,
+		&user.CreatedAt, &user.UpdatedAt,
+	)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to fetch user"})
+		return
+	}
+
+	expirationTime := time.Now().Add(24 * time.Hour)
+	claims := &Claims{
+		UserID:   user.ID,
+		Email:    user.Email,
+		Username: user.Username,
+		IsAdmin:  user.IsAdmin,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(expirationTime),
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+		},
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	tokenString, err := token.SignedString(jwtSecret)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to generate token"})
+		return
+	}
+
+	c.JSON(http.StatusCreated, models.AuthResponse{
+		Token:       tokenString,
+		User:        user,
+		IsFirstUser: isFirstUser,
+	})
+}
+
+func GetCurrentUser(c *gin.Context) {
+	userVal, exists := c.Get("user")
+	if !exists {
+		c.JSON(http.StatusUnauthorized, models.ErrorResponse{Error: "Not authenticated"})
+		return
+	}
+
+	claims := userVal.(*Claims)
+
+	var user models.User
+	err := db.GetPool().QueryRow(c.Request.Context(), `
+		SELECT id, email, username, is_admin, created_at, updated_at
+		FROM users WHERE id = $1`, claims.UserID).Scan(
+		&user.ID, &user.Email, &user.Username, &user.IsAdmin,
+		&user.CreatedAt, &user.UpdatedAt,
+	)
+	if err != nil {
+		c.JSON(http.StatusNotFound, models.ErrorResponse{Error: "User not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, user)
+}
+
+func init() {
+	cfg := config.Load()
+	InitAuth(cfg.SecretKey)
+}

backend/internal/handlers/feed.go

@@ -0,0 +1,540 @@
+package handlers
+
+import (
+	"context"
+	"encoding/csv"
+	"fmt"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/rss2/backend/internal/db"
+	"github.com/rss2/backend/internal/models"
+)
+
+type FeedResponse struct {
+	ID          int64   `json:"id"`
+	Nombre      string  `json:"nombre"`
+	Descripcion *string `json:"descripcion"`
+	URL         string  `json:"url"`
+	CategoriaID *int64  `json:"categoria_id"`
+	PaisID      *int64  `json:"pais_id"`
+	Idioma      *string `json:"idioma"`
+	Activo      bool    `json:"activo"`
+	Fallos      *int64  `json:"fallos"`
+	LastError   *string `json:"last_error"`
+	FuenteURLID *int64  `json:"fuente_url_id"`
+}
+
+func GetFeeds(c *gin.Context) {
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "50"))
+	activo := c.Query("activo")
+	categoriaID := c.Query("categoria_id")
+	paisID := c.Query("pais_id")
+
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 50
+	}
+
+	offset := (page - 1) * perPage
+
+	where := "1=1"
+	args := []interface{}{}
+	argNum := 1
+
+	if activo != "" {
+		where += fmt.Sprintf(" AND activo = $%d", argNum)
+		args = append(args, activo == "true")
+		argNum++
+	}
+	if categoriaID != "" {
+		where += fmt.Sprintf(" AND categoria_id = $%d", argNum)
+		args = append(args, categoriaID)
+		argNum++
+	}
+	if paisID != "" {
+		where += fmt.Sprintf(" AND pais_id = $%d", argNum)
+		args = append(args, paisID)
+		argNum++
+	}
+
+	var total int
+	countQuery := fmt.Sprintf("SELECT COUNT(*) FROM feeds WHERE %s", where)
+	err := db.GetPool().QueryRow(c.Request.Context(), countQuery, args...).Scan(&total)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to count feeds", Message: err.Error()})
+		return
+	}
+
+	sqlQuery := fmt.Sprintf(`
+		SELECT f.id, f.nombre, f.descripcion, f.url,
+		       f.categoria_id, f.pais_id, f.idioma, f.activo, f.fallos, f.last_error,
+		       c.nombre AS categoria, p.nombre AS pais,
+		       (SELECT COUNT(*) FROM noticias n WHERE n.fuente_nombre = f.nombre) as noticias_count
+		FROM feeds f
+		LEFT JOIN categorias c ON c.id = f.categoria_id
+		LEFT JOIN paises p ON p.id = f.pais_id
+		WHERE %s
+		ORDER BY p.nombre NULLS LAST, f.activo DESC, f.fallos ASC, c.nombre NULLS LAST, f.nombre
+		LIMIT $%d OFFSET $%d
+	`, where, argNum, argNum+1)
+
+	args = append(args, perPage, offset)
+
+	rows, err := db.GetPool().Query(c.Request.Context(), sqlQuery, args...)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to fetch feeds", Message: err.Error()})
+		return
+	}
+	defer rows.Close()
+
+	type FeedWithStats struct {
+		FeedResponse
+		Categoria     *string `json:"categoria"`
+		Pais          *string `json:"pais"`
+		NoticiasCount int64   `json:"noticias_count"`
+	}
+
+	var feeds []FeedWithStats
+	for rows.Next() {
+		var f FeedWithStats
+		err := rows.Scan(
+			&f.ID, &f.Nombre, &f.Descripcion, &f.URL,
+			&f.CategoriaID, &f.PaisID, &f.Idioma, &f.Activo, &f.Fallos, &f.LastError,
+			&f.Categoria, &f.Pais, &f.NoticiasCount,
+		)
+		if err != nil {
+			continue
+		}
+		feeds = append(feeds, f)
+	}
+
+	totalPages := (total + perPage - 1) / perPage
+
+	c.JSON(http.StatusOK, gin.H{
+		"feeds":       feeds,
+		"total":       total,
+		"page":        page,
+		"per_page":    perPage,
+		"total_pages": totalPages,
+	})
+}
+
+func GetFeedByID(c *gin.Context) {
+	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "Invalid feed ID"})
+		return
+	}
+
+	var f FeedResponse
+	err = db.GetPool().QueryRow(c.Request.Context(), `
+		SELECT id, nombre, descripcion, url, categoria_id, pais_id, idioma, activo, fallos
+		FROM feeds WHERE id = $1`, id).Scan(
+		&f.ID, &f.Nombre, &f.Descripcion, &f.URL,
+		&f.CategoriaID, &f.PaisID, &f.Idioma, &f.Activo, &f.Fallos,
+	)
+	if err != nil {
+		c.JSON(http.StatusNotFound, models.ErrorResponse{Error: "Feed not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, f)
+}
+
+type CreateFeedRequest struct {
+	Nombre      string  `json:"nombre" binding:"required"`
+	URL         string  `json:"url" binding:"required,url"`
+	Descripcion *string `json:"descripcion"`
+	CategoriaID *int64  `json:"categoria_id"`
+	PaisID      *int64  `json:"pais_id"`
+	Idioma      *string `json:"idioma"`
+}
+
+func CreateFeed(c *gin.Context) {
+	var req CreateFeedRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "Invalid request", Message: err.Error()})
+		return
+	}
+
+	var feedID int64
+	err := db.GetPool().QueryRow(c.Request.Context(), `
+		INSERT INTO feeds (nombre, descripcion, url, categoria_id, pais_id, idioma)
+		VALUES ($1, $2, $3, $4, $5, $6)
+		RETURNING id`,
+		req.Nombre, req.Descripcion, req.URL, req.CategoriaID, req.PaisID, req.Idioma,
+	).Scan(&feedID)
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to create feed", Message: err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusCreated, gin.H{"id": feedID, "message": "Feed created successfully"})
+}
+
+type UpdateFeedRequest struct {
+	Nombre      string  `json:"nombre" binding:"required"`
+	URL         string  `json:"url" binding:"required,url"`
+	Descripcion *string `json:"descripcion"`
+	CategoriaID *int64  `json:"categoria_id"`
+	PaisID      *int64  `json:"pais_id"`
+	Idioma      *string `json:"idioma"`
+	Activo      *bool   `json:"activo"`
+}
+
+func UpdateFeed(c *gin.Context) {
+	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "Invalid feed ID"})
+		return
+	}
+
+	var req UpdateFeedRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "Invalid request", Message: err.Error()})
+		return
+	}
+
+	activeVal := true
+	if req.Activo != nil {
+		activeVal = *req.Activo
+	}
+
+	result, err := db.GetPool().Exec(c.Request.Context(), `
+		UPDATE feeds 
+		SET nombre = $1, descripcion = $2, url = $3, 
+		    categoria_id = $4, pais_id = $5, idioma = $6, activo = $7
+		WHERE id = $8`,
+		req.Nombre, req.Descripcion, req.URL,
+		req.CategoriaID, req.PaisID, req.Idioma, activeVal, id,
+	)
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to update feed", Message: err.Error()})
+		return
+	}
+
+	if result.RowsAffected() == 0 {
+		c.JSON(http.StatusNotFound, models.ErrorResponse{Error: "Feed not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, models.SuccessResponse{Message: "Feed updated successfully"})
+}
+
+func DeleteFeed(c *gin.Context) {
+	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "Invalid feed ID"})
+		return
+	}
+
+	result, err := db.GetPool().Exec(c.Request.Context(), "DELETE FROM feeds WHERE id = $1", id)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to delete feed", Message: err.Error()})
+		return
+	}
+
+	if result.RowsAffected() == 0 {
+		c.JSON(http.StatusNotFound, models.ErrorResponse{Error: "Feed not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, models.SuccessResponse{Message: "Feed deleted successfully"})
+}
+
+func ToggleFeedActive(c *gin.Context) {
+	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "Invalid feed ID"})
+		return
+	}
+
+	result, err := db.GetPool().Exec(c.Request.Context(), `
+		UPDATE feeds SET activo = NOT activo WHERE id = $1`, id)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to toggle feed", Message: err.Error()})
+		return
+	}
+
+	if result.RowsAffected() == 0 {
+		c.JSON(http.StatusNotFound, models.ErrorResponse{Error: "Feed not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, models.SuccessResponse{Message: "Feed toggled successfully"})
+}
+
+func ReactivateFeed(c *gin.Context) {
+	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "Invalid feed ID"})
+		return
+	}
+
+	result, err := db.GetPool().Exec(c.Request.Context(), `
+		UPDATE feeds SET activo = TRUE, fallos = 0 WHERE id = $1`, id)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to reactivate feed", Message: err.Error()})
+		return
+	}
+
+	if result.RowsAffected() == 0 {
+		c.JSON(http.StatusNotFound, models.ErrorResponse{Error: "Feed not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, models.SuccessResponse{Message: "Feed reactivated successfully"})
+}
+
+func ExportFeeds(c *gin.Context) {
+	activo := c.Query("activo")
+	categoriaID := c.Query("categoria_id")
+	paisID := c.Query("pais_id")
+
+	where := "1=1"
+	args := []interface{}{}
+	argNum := 1
+
+	if activo != "" {
+		where += fmt.Sprintf(" AND activo = $%d", argNum)
+		args = append(args, activo == "true")
+		argNum++
+	}
+	if categoriaID != "" {
+		where += fmt.Sprintf(" AND categoria_id = $%d", argNum)
+		args = append(args, categoriaID)
+		argNum++
+	}
+	if paisID != "" {
+		where += fmt.Sprintf(" AND pais_id = $%d", argNum)
+		args = append(args, paisID)
+		argNum++
+	}
+
+	query := fmt.Sprintf(`
+		SELECT f.id, f.nombre, f.descripcion, f.url,
+		       f.categoria_id, c.nombre AS categoria,
+		       f.pais_id, p.nombre AS pais,
+		       f.idioma, f.activo, f.fallos
+		FROM feeds f
+		LEFT JOIN categorias c ON c.id = f.categoria_id
+		LEFT JOIN paises p ON p.id = f.pais_id
+		WHERE %s
+		ORDER BY f.id
+	`, where)
+
+	rows, err := db.GetPool().Query(c.Request.Context(), query, args...)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to fetch feeds", Message: err.Error()})
+		return
+	}
+	defer rows.Close()
+
+	c.Header("Content-Type", "text/csv")
+	c.Header("Content-Disposition", "attachment; filename=feeds_export.csv")
+
+	writer := csv.NewWriter(c.Writer)
+	defer writer.Flush()
+
+	writer.Write([]string{"id", "nombre", "descripcion", "url", "categoria_id", "categoria", "pais_id", "pais", "idioma", "activo", "fallos"})
+
+	for rows.Next() {
+		var id int64
+		var nombre, url string
+		var descripcion, idioma *string
+		var categoriaID, paisID, fallos *int64
+		var activo bool
+		var categoria, pais *string
+
+		err := rows.Scan(&id, &nombre, &descripcion, &url, &categoriaID, &categoria, &paisID, &pais, &idioma, &activo, &fallos)
+		if err != nil {
+			continue
+		}
+
+		writer.Write([]string{
+			fmt.Sprintf("%d", id),
+			nombre,
+			stringOrEmpty(descripcion),
+			url,
+			int64ToString(categoriaID),
+			stringOrEmpty(categoria),
+			int64ToString(paisID),
+			stringOrEmpty(pais),
+			stringOrEmpty(idioma),
+			fmt.Sprintf("%t", activo),
+			int64ToString(fallos),
+		})
+	}
+}
+
+func ImportFeeds(c *gin.Context) {
+	file, err := c.FormFile("file")
+	if err != nil {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "No file provided"})
+		return
+	}
+
+	f, err := file.Open()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to open file", Message: err.Error()})
+		return
+	}
+	defer f.Close()
+
+	content, err := io.ReadAll(f)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to read file", Message: err.Error()})
+		return
+	}
+
+	reader := csv.NewReader(strings.NewReader(string(content)))
+	_, err = reader.Read()
+	if err != nil {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "Invalid CSV format"})
+		return
+	}
+
+	imported := 0
+	skipped := 0
+	failed := 0
+	errors := []string{}
+
+	tx, err := db.GetPool().Begin(context.Background())
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to start transaction", Message: err.Error()})
+		return
+	}
+	defer tx.Rollback(context.Background())
+
+	for {
+		record, err := reader.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			failed++
+			continue
+		}
+
+		if len(record) < 4 {
+			skipped++
+			continue
+		}
+
+		nombre := strings.TrimSpace(record[1])
+		url := strings.TrimSpace(record[3])
+
+		if nombre == "" || url == "" {
+			skipped++
+			continue
+		}
+
+		var descripcion *string
+		if len(record) > 2 && strings.TrimSpace(record[2]) != "" {
+			descripcionStr := strings.TrimSpace(record[2])
+			descripcion = &descripcionStr
+		}
+
+		var categoriaID *int64
+		if len(record) > 4 && strings.TrimSpace(record[4]) != "" {
+			catID, err := strconv.ParseInt(strings.TrimSpace(record[4]), 10, 64)
+			if err == nil {
+				categoriaID = &catID
+			}
+		}
+
+		var paisID *int64
+		if len(record) > 6 && strings.TrimSpace(record[6]) != "" {
+			pID, err := strconv.ParseInt(strings.TrimSpace(record[6]), 10, 64)
+			if err == nil {
+				paisID = &pID
+			}
+		}
+
+		var idioma *string
+		if len(record) > 8 && strings.TrimSpace(record[8]) != "" {
+			lang := strings.TrimSpace(record[8])
+			if len(lang) > 2 {
+				lang = lang[:2]
+			}
+			idioma = &lang
+		}
+
+		activo := true
+		if len(record) > 9 && strings.TrimSpace(record[9]) != "" {
+			activo = strings.ToLower(strings.TrimSpace(record[9])) == "true"
+		}
+
+		var fallos int64
+		if len(record) > 10 && strings.TrimSpace(record[10]) != "" {
+			f, err := strconv.ParseInt(strings.TrimSpace(record[10]), 10, 64)
+			if err == nil {
+				fallos = f
+			}
+		}
+
+		var existingID int64
+		err = tx.QueryRow(context.Background(), "SELECT id FROM feeds WHERE url = $1", url).Scan(&existingID)
+		if err == nil {
+			_, err = tx.Exec(context.Background(), `
+				UPDATE feeds SET nombre=$1, descripcion=$2, categoria_id=$3, pais_id=$4, idioma=$5, activo=$6, fallos=$7
+				WHERE id=$8`,
+				nombre, descripcion, categoriaID, paisID, idioma, activo, fallos, existingID,
+			)
+			if err != nil {
+				failed++
+				errors = append(errors, fmt.Sprintf("Error updating %s: %v", url, err))
+				continue
+			}
+		} else {
+			_, err = tx.Exec(context.Background(), `
+				INSERT INTO feeds (nombre, descripcion, url, categoria_id, pais_id, idioma, activo, fallos)
+				VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+				nombre, descripcion, url, categoriaID, paisID, idioma, activo, fallos,
+			)
+			if err != nil {
+				failed++
+				errors = append(errors, fmt.Sprintf("Error inserting %s: %v", url, err))
+				continue
+			}
+		}
+
+		imported++
+	}
+
+	if err := tx.Commit(context.Background()); err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to commit transaction", Message: err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"imported": imported,
+		"skipped":  skipped,
+		"failed":   failed,
+		"errors":   errors,
+		"message":  fmt.Sprintf("Import completed. Imported: %d, Skipped: %d, Failed: %d", imported, skipped, failed),
+	})
+}
+
+func stringOrEmpty(s *string) string {
+	if s == nil {
+		return ""
+	}
+	return *s
+}
+
+func int64ToString(i *int64) string {
+	if i == nil {
+		return ""
+	}
+	return fmt.Sprintf("%d", *i)
+}

backend/internal/handlers/news.go

@@ -0,0 +1,369 @@
+package handlers
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/rss2/backend/internal/db"
+	"github.com/rss2/backend/internal/models"
+)
+
+type NewsResponse struct {
+	ID                string     `json:"id"`
+	Titulo            string     `json:"titulo"`
+	Resumen           string     `json:"resumen"`
+	URL               string     `json:"url"`
+	Fecha             *time.Time `json:"fecha"`
+	ImagenURL         *string    `json:"imagen_url"`
+	CategoriaID       *int64     `json:"categoria_id"`
+	PaisID            *int64     `json:"pais_id"`
+	FuenteNombre      string     `json:"fuente_nombre"`
+	TitleTranslated   *string    `json:"title_translated"`
+	SummaryTranslated *string    `json:"summary_translated"`
+	LangTranslated    *string    `json:"lang_translated"`
+	Entities          []Entity   `json:"entities,omitempty"`
+}
+
+func GetNews(c *gin.Context) {
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "30"))
+	query := c.Query("q")
+	categoryID := c.Query("category_id")
+	countryID := c.Query("country_id")
+	translatedOnly := c.Query("translated_only") == "true"
+
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 30
+	}
+
+	offset := (page - 1) * perPage
+
+	where := "1=1"
+	args := []interface{}{}
+	argNum := 1
+
+	if query != "" {
+		where += fmt.Sprintf(" AND (n.titulo ILIKE $%d OR n.resumen ILIKE $%d)", argNum, argNum)
+		args = append(args, "%"+query+"%")
+		argNum++
+	}
+	if categoryID != "" {
+		where += fmt.Sprintf(" AND n.categoria_id = $%d", argNum)
+		args = append(args, categoryID)
+		argNum++
+	}
+	if countryID != "" {
+		where += fmt.Sprintf(" AND n.pais_id = $%d", argNum)
+		args = append(args, countryID)
+		argNum++
+	}
+	if translatedOnly {
+		where += " AND t.status = 'done' AND t.titulo_trad IS NOT NULL AND t.titulo_trad != n.titulo"
+	}
+
+	var total int
+	countQuery := fmt.Sprintf("SELECT COUNT(*) FROM noticias n LEFT JOIN traducciones t ON t.noticia_id = n.id AND t.lang_to = 'es' WHERE %s", where)
+	err := db.GetPool().QueryRow(c.Request.Context(), countQuery, args...).Scan(&total)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to count news", Message: err.Error()})
+		return
+	}
+
+	if total == 0 {
+		c.JSON(http.StatusOK, models.NewsListResponse{
+			News:       []models.NewsWithTranslations{},
+			Total:      0,
+			Page:       page,
+			PerPage:    perPage,
+			TotalPages: 0,
+		})
+		return
+	}
+
+	sqlQuery := fmt.Sprintf(`
+		SELECT n.id, n.titulo, COALESCE(n.resumen, ''), n.url, n.fecha, n.imagen_url, 
+		       n.categoria_id, n.pais_id, n.fuente_nombre,
+		       t.titulo_trad,
+		       t.resumen_trad,
+		       t.lang_to as lang_trad
+		FROM noticias n
+		LEFT JOIN traducciones t ON t.noticia_id = n.id AND t.lang_to = 'es'
+		WHERE %s
+		ORDER BY n.fecha DESC LIMIT $%d OFFSET $%d
+	`, where, argNum, argNum+1)
+
+	args = append(args, perPage, offset)
+
+	rows, err := db.GetPool().Query(c.Request.Context(), sqlQuery, args...)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to fetch news", Message: err.Error()})
+		return
+	}
+	defer rows.Close()
+
+	var newsList []NewsResponse
+	for rows.Next() {
+		var n NewsResponse
+		var imagenURL, fuenteNombre *string
+		var categoriaID, paisID *int32
+
+		err := rows.Scan(
+			&n.ID, &n.Titulo, &n.Resumen, &n.URL, &n.Fecha, &imagenURL,
+			&categoriaID, &paisID, &fuenteNombre,
+			&n.TitleTranslated, &n.SummaryTranslated, &n.LangTranslated,
+		)
+		if err != nil {
+			continue
+		}
+		if imagenURL != nil {
+			n.ImagenURL = imagenURL
+		}
+		if fuenteNombre != nil {
+			n.FuenteNombre = *fuenteNombre
+		}
+		if categoriaID != nil {
+			catID := int64(*categoriaID)
+			n.CategoriaID = &catID
+		}
+		if paisID != nil {
+			pID := int64(*paisID)
+			n.PaisID = &pID
+		}
+		newsList = append(newsList, n)
+	}
+
+	totalPages := (total + perPage - 1) / perPage
+
+	c.JSON(http.StatusOK, gin.H{
+		"news":        newsList,
+		"total":       total,
+		"page":        page,
+		"per_page":    perPage,
+		"total_pages": totalPages,
+	})
+}
+
+func GetNewsByID(c *gin.Context) {
+	id := c.Param("id")
+
+	sqlQuery := `
+		SELECT n.id, n.titulo, COALESCE(n.resumen, ''), n.url, n.fecha, n.imagen_url, 
+		       n.categoria_id, n.pais_id, n.fuente_nombre,
+		       t.titulo_trad,
+		       t.resumen_trad,
+		       t.lang_to as lang_trad
+		FROM noticias n
+		LEFT JOIN traducciones t ON t.noticia_id = n.id AND t.lang_to = 'es'
+		WHERE n.id = $1`
+
+	var n NewsResponse
+	var imagenURL, fuenteNombre *string
+	var categoriaID, paisID *int32
+
+	err := db.GetPool().QueryRow(c.Request.Context(), sqlQuery, id).Scan(
+		&n.ID, &n.Titulo, &n.Resumen, &n.URL, &n.Fecha, &imagenURL,
+		&categoriaID, &paisID, &fuenteNombre,
+		&n.TitleTranslated, &n.SummaryTranslated, &n.LangTranslated,
+	)
+	if err != nil {
+		c.JSON(http.StatusNotFound, models.ErrorResponse{Error: "News not found"})
+		return
+	}
+
+	if imagenURL != nil {
+		n.ImagenURL = imagenURL
+	}
+	if fuenteNombre != nil {
+		n.FuenteNombre = *fuenteNombre
+	}
+	if categoriaID != nil {
+		catID := int64(*categoriaID)
+		n.CategoriaID = &catID
+	}
+	if paisID != nil {
+		pID := int64(*paisID)
+		n.PaisID = &pID
+	}
+
+	// Fetch entities for this news
+	entitiesQuery := `
+		SELECT t.valor, t.tipo, 1 as cnt, t.wiki_summary, t.wiki_url, t.image_path
+		FROM tags_noticia tn
+		JOIN tags t ON tn.tag_id = t.id
+		JOIN traducciones tr ON tn.traduccion_id = tr.id
+		WHERE tr.noticia_id = $1 AND t.tipo IN ('persona', 'organizacion')
+	`
+	rows, err := db.GetPool().Query(c.Request.Context(), entitiesQuery, id)
+	var entities []Entity
+	if err == nil {
+		defer rows.Close()
+		for rows.Next() {
+			var e Entity
+			if err := rows.Scan(&e.Valor, &e.Tipo, &e.Count, &e.WikiSummary, &e.WikiURL, &e.ImagePath); err == nil {
+				entities = append(entities, e)
+			}
+		}
+	}
+	if entities == nil {
+		entities = []Entity{}
+	}
+	n.Entities = entities
+
+	c.JSON(http.StatusOK, n)
+}
+
+func DeleteNews(c *gin.Context) {
+	id := c.Param("id")
+
+	result, err := db.GetPool().Exec(c.Request.Context(), "DELETE FROM noticias WHERE id = $1", id)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to delete news", Message: err.Error()})
+		return
+	}
+
+	if result.RowsAffected() == 0 {
+		c.JSON(http.StatusNotFound, models.ErrorResponse{Error: "News not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, models.SuccessResponse{Message: "News deleted successfully"})
+}
+
+type Entity struct {
+	Valor       string  `json:"valor"`
+	Tipo        string  `json:"tipo"`
+	Count       int     `json:"count"`
+	WikiSummary *string `json:"wiki_summary"`
+	WikiURL     *string `json:"wiki_url"`
+	ImagePath   *string `json:"image_path"`
+}
+
+type EntityListResponse struct {
+	Entities   []Entity `json:"entities"`
+	Total      int      `json:"total"`
+	Page       int      `json:"page"`
+	PerPage    int      `json:"per_page"`
+	TotalPages int      `json:"total_pages"`
+}
+
+func GetEntities(c *gin.Context) {
+	countryID := c.Query("country_id")
+	categoryID := c.Query("category_id")
+	entityType := c.DefaultQuery("tipo", "persona")
+	
+	q := c.Query("q")
+	
+	pageStr := c.DefaultQuery("page", "1")
+	perPageStr := c.DefaultQuery("per_page", "50")
+
+	page, _ := strconv.Atoi(pageStr)
+	perPage, _ := strconv.Atoi(perPageStr)
+
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 50
+	}
+
+	offset := (page - 1) * perPage
+
+	where := "t.tipo = $1"
+	args := []interface{}{entityType}
+
+	if countryID != "" {
+		where += fmt.Sprintf(" AND n.pais_id = $%d", len(args)+1)
+		args = append(args, countryID)
+	}
+
+	if categoryID != "" {
+		where += fmt.Sprintf(" AND n.categoria_id = $%d", len(args)+1)
+		args = append(args, categoryID)
+	}
+	
+	if q != "" {
+		where += fmt.Sprintf(" AND COALESCE(ea.canonical_name, t.valor) ILIKE $%d", len(args)+1)
+		args = append(args, "%"+q+"%")
+	}
+
+	// 1. Get the total count of distinct canonical entities matching the filter
+	countQuery := fmt.Sprintf(`
+		SELECT COUNT(DISTINCT COALESCE(ea.canonical_name, t.valor))
+		FROM tags_noticia tn
+		JOIN tags t ON tn.tag_id = t.id
+		JOIN traducciones tr ON tn.traduccion_id = tr.id
+		JOIN noticias n ON tr.noticia_id = n.id
+		LEFT JOIN entity_aliases ea ON LOWER(ea.alias) = LOWER(t.valor) AND ea.tipo = t.tipo
+		WHERE %s
+	`, where)
+
+	var total int
+	err := db.GetPool().QueryRow(c.Request.Context(), countQuery, args...).Scan(&total)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to get entities count", Message: err.Error()})
+		return
+	}
+
+	if total == 0 {
+		c.JSON(http.StatusOK, EntityListResponse{
+			Entities:   []Entity{},
+			Total:      0,
+			Page:       page,
+			PerPage:    perPage,
+			TotalPages: 0,
+		})
+		return
+	}
+
+	// 2. Fetch the paginated entities
+	args = append(args, perPage, offset)
+	query := fmt.Sprintf(`
+		SELECT COALESCE(ea.canonical_name, t.valor) as valor, t.tipo, COUNT(*)::int as cnt,
+		       MAX(t.wiki_summary), MAX(t.wiki_url), MAX(t.image_path)
+		FROM tags_noticia tn
+		JOIN tags t ON tn.tag_id = t.id
+		JOIN traducciones tr ON tn.traduccion_id = tr.id
+		JOIN noticias n ON tr.noticia_id = n.id
+		LEFT JOIN entity_aliases ea ON LOWER(ea.alias) = LOWER(t.valor) AND ea.tipo = t.tipo
+		WHERE %s
+		GROUP BY COALESCE(ea.canonical_name, t.valor), t.tipo
+		ORDER BY cnt DESC
+		LIMIT $%d OFFSET $%d
+	`, where, len(args)-1, len(args))
+
+	rows, err := db.GetPool().Query(c.Request.Context(), query, args...)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to get entities", Message: err.Error()})
+		return
+	}
+	defer rows.Close()
+
+	var entities []Entity
+	for rows.Next() {
+		var e Entity
+		if err := rows.Scan(&e.Valor, &e.Tipo, &e.Count, &e.WikiSummary, &e.WikiURL, &e.ImagePath); err != nil {
+			continue
+		}
+		entities = append(entities, e)
+	}
+
+	if entities == nil {
+		entities = []Entity{}
+	}
+
+	totalPages := (total + perPage - 1) / perPage
+
+	c.JSON(http.StatusOK, EntityListResponse{
+		Entities:   entities,
+		Total:      total,
+		Page:       page,
+		PerPage:    perPage,
+		TotalPages: totalPages,
+	})
+}

backend/internal/handlers/search.go

@@ -0,0 +1,265 @@
+package handlers
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"github.com/rss2/backend/internal/db"
+	"github.com/rss2/backend/internal/models"
+	"github.com/rss2/backend/internal/services"
+)
+
+func SearchNews(c *gin.Context) {
+	query := c.Query("q")
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "30"))
+	lang := c.DefaultQuery("lang", "")
+	categoriaID := c.Query("categoria_id")
+	paisID := c.Query("pais_id")
+	useSemantic := c.Query("semantic") == "true"
+
+	if query == "" && categoriaID == "" && paisID == "" && lang == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{Error: "At least one filter is required (q, categoria_id, pais_id, or lang)"})
+		return
+	}
+
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 30
+	}
+
+	// Default to Spanish if no lang specified
+	if lang == "" {
+		lang = "es"
+	}
+
+	ctx := c.Request.Context()
+
+	if useSemantic {
+		results, err := services.SemanticSearch(ctx, query, lang, page, perPage)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Semantic search failed", Message: err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, results)
+		return
+	}
+
+	offset := (page - 1) * perPage
+
+	// Build dynamic query
+	args := []interface{}{}
+	argNum := 1
+	whereClause := "WHERE 1=1"
+
+	if query != "" {
+		whereClause += " AND (n.titulo ILIKE $" + strconv.Itoa(argNum) + " OR n.resumen ILIKE $" + strconv.Itoa(argNum) + " OR n.contenido ILIKE $" + strconv.Itoa(argNum) + ")"
+		args = append(args, "%"+query+"%")
+		argNum++
+	}
+
+	if lang != "" {
+		whereClause += " AND t.lang_to = $" + strconv.Itoa(argNum)
+		args = append(args, lang)
+		argNum++
+	}
+
+	if categoriaID != "" {
+		whereClause += " AND n.categoria_id = $" + strconv.Itoa(argNum)
+		catID, err := strconv.ParseInt(categoriaID, 10, 64)
+		if err == nil {
+			args = append(args, catID)
+			argNum++
+		}
+	}
+
+	if paisID != "" {
+		whereClause += " AND n.pais_id = $" + strconv.Itoa(argNum)
+		pID, err := strconv.ParseInt(paisID, 10, 64)
+		if err == nil {
+			args = append(args, pID)
+			argNum++
+		}
+	}
+
+	args = append(args, perPage, offset)
+
+	sqlQuery := `
+		SELECT n.id, n.titulo, n.resumen, n.contenido, n.url, n.imagen, 
+		       n.feed_id, n.lang, n.categoria_id, n.pais_id, n.created_at, n.updated_at,
+		       COALESCE(t.titulo_trad, '') as titulo_trad,
+		       COALESCE(t.resumen_trad, '') as resumen_trad,
+		       t.lang_to as lang_trad,
+		       f.nombre as fuente_nombre
+		FROM noticias n
+		LEFT JOIN traducciones t ON t.noticia_id = n.id AND t.lang_to = $` + strconv.Itoa(argNum) + `
+		LEFT JOIN feeds f ON f.id = n.feed_id
+		` + whereClause + `
+		ORDER BY n.created_at DESC
+		LIMIT $` + strconv.Itoa(argNum+1) + ` OFFSET $` + strconv.Itoa(argNum+2)
+
+	rows, err := db.GetPool().Query(ctx, sqlQuery, args...)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Search failed", Message: err.Error()})
+		return
+	}
+	defer rows.Close()
+
+	var newsList []models.NewsWithTranslations
+	for rows.Next() {
+		var n models.NewsWithTranslations
+		var imagen *string
+
+		err := rows.Scan(
+			&n.ID, &n.Title, &n.Summary, &n.Content, &n.URL, &imagen,
+			&n.FeedID, &n.Lang, &n.CategoryID, &n.CountryID, &n.CreatedAt, &n.UpdatedAt,
+			&n.TitleTranslated, &n.SummaryTranslated, &n.LangTranslated,
+		)
+		if err != nil {
+			continue
+		}
+		if imagen != nil {
+			n.ImageURL = imagen
+		}
+		newsList = append(newsList, n)
+	}
+
+	// Get total count
+	countArgs := args[:len(args)-2]
+
+	// Remove LIMIT/OFFSET from args for count
+	var total int
+	err = db.GetPool().QueryRow(ctx, `
+		SELECT COUNT(*) FROM noticias n
+		LEFT JOIN traducciones t ON t.noticia_id = n.id AND t.lang_to = $`+strconv.Itoa(argNum)+`
+		`+whereClause, countArgs...).Scan(&total)
+	if err != nil {
+		total = len(newsList)
+	}
+
+	totalPages := (total + perPage - 1) / perPage
+
+	response := models.NewsListResponse{
+		News:       newsList,
+		Total:      total,
+		Page:       page,
+		PerPage:    perPage,
+		TotalPages: totalPages,
+	}
+
+	c.JSON(http.StatusOK, response)
+}
+
+func GetStats(c *gin.Context) {
+	var stats models.Stats
+
+	err := db.GetPool().QueryRow(c.Request.Context(), `
+		SELECT 
+			(SELECT COUNT(*) FROM noticias) as total_news,
+			(SELECT COUNT(*) FROM feeds WHERE activo = true) as total_feeds,
+			(SELECT COUNT(*) FROM users) as total_users,
+			(SELECT COUNT(*) FROM noticias WHERE fecha::date = CURRENT_DATE) as news_today,
+			(SELECT COUNT(*) FROM noticias WHERE fecha >= DATE_TRUNC('week', CURRENT_DATE)) as news_this_week,
+			(SELECT COUNT(*) FROM noticias WHERE fecha >= DATE_TRUNC('month', CURRENT_DATE)) as news_this_month,
+			(SELECT COUNT(DISTINCT noticia_id) FROM traducciones WHERE status = 'done') as total_translated
+	`).Scan(
+		&stats.TotalNews, &stats.TotalFeeds, &stats.TotalUsers,
+		&stats.NewsToday, &stats.NewsThisWeek, &stats.NewsThisMonth,
+		&stats.TotalTranslated,
+	)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to get stats", Message: err.Error()})
+		return
+	}
+
+	rows, err := db.GetPool().Query(c.Request.Context(), `
+		SELECT c.id, c.nombre, COUNT(n.id) as count
+		FROM categorias c
+		LEFT JOIN noticias n ON n.categoria_id = c.id
+		GROUP BY c.id, c.nombre
+		ORDER BY count DESC
+		LIMIT 10
+	`)
+	if err == nil {
+		defer rows.Close()
+		for rows.Next() {
+			var cs models.CategoryStat
+			rows.Scan(&cs.CategoryID, &cs.CategoryName, &cs.Count)
+			stats.TopCategories = append(stats.TopCategories, cs)
+		}
+	}
+
+	rows, err = db.GetPool().Query(c.Request.Context(), `
+		SELECT p.id, p.nombre, p.flag_emoji, COUNT(n.id) as count
+		FROM paises p
+		LEFT JOIN noticias n ON n.pais_id = p.id
+		GROUP BY p.id, p.nombre, p.flag_emoji
+		ORDER BY count DESC
+		LIMIT 10
+	`)
+	if err == nil {
+		defer rows.Close()
+		for rows.Next() {
+			var cs models.CountryStat
+			rows.Scan(&cs.CountryID, &cs.CountryName, &cs.FlagEmoji, &cs.Count)
+			stats.TopCountries = append(stats.TopCountries, cs)
+		}
+	}
+
+	c.JSON(http.StatusOK, stats)
+}
+
+func GetCategories(c *gin.Context) {
+	rows, err := db.GetPool().Query(c.Request.Context(), `
+		SELECT id, nombre FROM categorias ORDER BY nombre`)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to get categories", Message: err.Error()})
+		return
+	}
+	defer rows.Close()
+
+	type Category struct {
+		ID     int64  `json:"id"`
+		Nombre string `json:"nombre"`
+	}
+
+	var categories []Category
+	for rows.Next() {
+		var cat Category
+		rows.Scan(&cat.ID, &cat.Nombre)
+		categories = append(categories, cat)
+	}
+
+	c.JSON(http.StatusOK, categories)
+}
+
+func GetCountries(c *gin.Context) {
+	rows, err := db.GetPool().Query(c.Request.Context(), `
+		SELECT p.id, p.nombre, c.nombre as continente
+		FROM paises p
+		LEFT JOIN continentes c ON c.id = p.continente_id
+		ORDER BY p.nombre`)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{Error: "Failed to get countries", Message: err.Error()})
+		return
+	}
+	defer rows.Close()
+
+	type Country struct {
+		ID         int64  `json:"id"`
+		Nombre     string `json:"nombre"`
+		Continente string `json:"continente"`
+	}
+
+	var countries []Country
+	for rows.Next() {
+		var country Country
+		rows.Scan(&country.ID, &country.Nombre, &country.Continente)
+		countries = append(countries, country)
+	}
+
+	c.JSON(http.StatusOK, countries)
+}

backend/internal/middleware/auth.go

@@ -0,0 +1,108 @@
+package middleware
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+)
+
+var jwtSecret []byte
+
+func SetJWTSecret(secret string) {
+	jwtSecret = []byte(secret)
+}
+
+type Claims struct {
+	UserID   int64  `json:"user_id"`
+	Email    string `json:"email"`
+	Username string `json:"username"`
+	IsAdmin  bool   `json:"is_admin"`
+	jwt.RegisteredClaims
+}
+
+func AuthRequired() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		authHeader := c.GetHeader("Authorization")
+		if authHeader == "" {
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization header required"})
+			c.Abort()
+			return
+		}
+
+		tokenString := strings.TrimPrefix(authHeader, "Bearer ")
+		if tokenString == authHeader {
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "Bearer token required"})
+			c.Abort()
+			return
+		}
+
+		claims := &Claims{}
+		token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
+			return jwtSecret, nil
+		})
+
+		if err != nil || !token.Valid {
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
+			c.Abort()
+			return
+		}
+
+		c.Set("user", claims)
+		c.Next()
+	}
+}
+
+func AdminRequired() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		userVal, exists := c.Get("user")
+		if !exists {
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "Not authenticated"})
+			c.Abort()
+			return
+		}
+
+		claims := userVal.(*Claims)
+		if !claims.IsAdmin {
+			c.JSON(http.StatusForbidden, gin.H{"error": "Admin access required"})
+			c.Abort()
+			return
+		}
+
+		c.Next()
+	}
+}
+
+func CORSMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
+		c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
+		c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
+		c.Writer.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT, DELETE, PATCH")
+
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(204)
+			return
+		}
+
+		c.Next()
+	}
+}
+
+func LoggerMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Next()
+
+		status := c.Writer.Status()
+		if status >= 400 {
+			// Log error responses
+		}
+	}
+}
+
+func RateLimitMiddleware(requestsPerMinute int) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Next()
+	}
+}

backend/internal/models/alias.go

@@ -0,0 +1,17 @@
+package models
+
+import "time"
+
+type EntityAlias struct {
+	ID            int       `json:"id"`
+	CanonicalName string    `json:"canonical_name"`
+	Alias         string    `json:"alias"`
+	Tipo          string    `json:"tipo"`
+	CreatedAt     time.Time `json:"created_at"`
+}
+
+type EntityAliasRequest struct {
+	CanonicalName string   `json:"canonical_name" binding:"required"`
+	Aliases       []string `json:"aliases" binding:"required,min=1"`
+	Tipo          string   `json:"tipo" binding:"required,oneof=persona organizacion lugar tema"`
+}

backend/internal/models/models.go

@@ -0,0 +1,171 @@
+package models
+
+import (
+	"time"
+)
+
+type News struct {
+	ID          int64      `json:"id"`
+	Title       string     `json:"title"`
+	Summary     string     `json:"summary"`
+	Content     string     `json:"content"`
+	URL         string     `json:"url"`
+	ImageURL    *string    `json:"image_url"`
+	PublishedAt *time.Time `json:"published_at"`
+	Lang        string     `json:"lang"`
+	FeedID      int64      `json:"feed_id"`
+	CreatedAt   time.Time  `json:"created_at"`
+	UpdatedAt   time.Time  `json:"updated_at"`
+}
+
+type NewsWithTranslations struct {
+	ID                int64     `json:"id"`
+	Title             string    `json:"title"`
+	Summary           string    `json:"summary"`
+	Content           string    `json:"content"`
+	URL               string    `json:"url"`
+	ImageURL          *string   `json:"image_url"`
+	PublishedAt       *string   `json:"published_at"`
+	Lang              string    `json:"lang"`
+	FeedID            int64     `json:"feed_id"`
+	CategoryID        *int64    `json:"category_id"`
+	CountryID         *int64    `json:"country_id"`
+	CreatedAt         time.Time `json:"created_at"`
+	UpdatedAt         time.Time `json:"updated_at"`
+	TitleTranslated   *string   `json:"title_translated"`
+	SummaryTranslated *string   `json:"summary_translated"`
+	ContentTranslated *string   `json:"content_translated"`
+	LangTranslated    *string   `json:"lang_translated"`
+}
+
+type Feed struct {
+	ID          int64      `json:"id"`
+	Title       string     `json:"title"`
+	URL         string     `json:"url"`
+	SiteURL     *string    `json:"site_url"`
+	Description *string    `json:"description"`
+	ImageURL    *string    `json:"image_url"`
+	Language    *string    `json:"language"`
+	CategoryID  *int64     `json:"category_id"`
+	CountryID   *int64     `json:"country_id"`
+	Active      bool       `json:"active"`
+	LastFetched *time.Time `json:"last_fetched"`
+	CreatedAt   time.Time  `json:"created_at"`
+	UpdatedAt   time.Time  `json:"updated_at"`
+}
+
+type Category struct {
+	ID       int64  `json:"id"`
+	Name     string `json:"name"`
+	Color    string `json:"color"`
+	Icon     string `json:"icon"`
+	ParentID *int64 `json:"parent_id"`
+}
+
+type Country struct {
+	ID        int64  `json:"id"`
+	Name      string `json:"name"`
+	Code      string `json:"code"`
+	Continent string `json:"continent"`
+	FlagEmoji string `json:"flag_emoji"`
+}
+
+type Translation struct {
+	ID        int64     `json:"id"`
+	NewsID    int64     `json:"news_id"`
+	LangFrom  string    `json:"lang_from"`
+	LangTo    string    `json:"lang_to"`
+	Title     string    `json:"title"`
+	Summary   string    `json:"summary"`
+	Status    string    `json:"status"`
+	Error     *string   `json:"error"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+type User struct {
+	ID           int64     `json:"id"`
+	Email        string    `json:"email"`
+	Username     string    `json:"username"`
+	PasswordHash string    `json:"-"`
+	IsAdmin      bool      `json:"is_admin"`
+	CreatedAt    time.Time `json:"created_at"`
+	UpdatedAt    time.Time `json:"updated_at"`
+}
+
+type SearchHistory struct {
+	ID           int64     `json:"id"`
+	UserID       int64     `json:"user_id"`
+	Query        string    `json:"query"`
+	CategoryID   *int64    `json:"category_id"`
+	CountryID    *int64    `json:"country_id"`
+	ResultsCount int       `json:"results_count"`
+	SearchedAt   time.Time `json:"searched_at"`
+}
+
+type NewsListResponse struct {
+	News       []NewsWithTranslations `json:"news"`
+	Total      int                    `json:"total"`
+	Page       int                    `json:"page"`
+	PerPage    int                    `json:"per_page"`
+	TotalPages int                    `json:"total_pages"`
+}
+
+type FeedListResponse struct {
+	Feeds      []Feed `json:"feeds"`
+	Total      int    `json:"total"`
+	Page       int    `json:"page"`
+	PerPage    int    `json:"per_page"`
+	TotalPages int    `json:"total_pages"`
+}
+
+type Stats struct {
+	TotalNews       int64          `json:"total_news"`
+	TotalFeeds      int64          `json:"total_feeds"`
+	TotalUsers      int64          `json:"total_users"`
+	TotalTranslated int64          `json:"total_translated"`
+	NewsToday       int64          `json:"news_today"`
+	NewsThisWeek    int64          `json:"news_this_week"`
+	NewsThisMonth   int64          `json:"news_this_month"`
+	TopCategories   []CategoryStat `json:"top_categories"`
+	TopCountries    []CountryStat  `json:"top_countries"`
+}
+
+type CategoryStat struct {
+	CategoryID   int64  `json:"category_id"`
+	CategoryName string `json:"category_name"`
+	Count        int64  `json:"count"`
+}
+
+type CountryStat struct {
+	CountryID   int64  `json:"country_id"`
+	CountryName string `json:"country_name"`
+	FlagEmoji   string `json:"flag_emoji"`
+	Count       int64  `json:"count"`
+}
+
+type LoginRequest struct {
+	Email    string `json:"email" binding:"required,email"`
+	Password string `json:"password" binding:"required,min=6"`
+}
+
+type RegisterRequest struct {
+	Email    string `json:"email" binding:"required,email"`
+	Username string `json:"username" binding:"required,min=3,max=50"`
+	Password string `json:"password" binding:"required,min=6"`
+}
+
+type AuthResponse struct {
+	Token       string `json:"token"`
+	User        User   `json:"user"`
+	IsFirstUser bool   `json:"is_first_user,omitempty"`
+}
+
+type ErrorResponse struct {
+	Error   string `json:"error"`
+	Message string `json:"message,omitempty"`
+}
+
+type SuccessResponse struct {
+	Message string `json:"message"`
+}

backend/internal/services/ml.go

@@ -0,0 +1,170 @@
+package services
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/rss2/backend/internal/config"
+	"github.com/rss2/backend/internal/models"
+)
+
+var (
+	cfg *config.Config
+)
+
+func Init(c *config.Config) {
+	cfg = c
+}
+
+type TranslationRequest struct {
+	SourceLang string   `json:"source_lang"`
+	TargetLang string   `json:"target_lang"`
+	Texts      []string `json:"texts"`
+}
+
+type TranslationResponse struct {
+	Translations []string `json:"translations"`
+}
+
+func Translate(ctx context.Context, sourceLang, targetLang string, texts []string) ([]string, error) {
+	if len(texts) == 0 {
+		return nil, nil
+	}
+
+	reqBody := TranslationRequest{
+		SourceLang: sourceLang,
+		TargetLang: targetLang,
+		Texts:      texts,
+	}
+
+	body, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, err
+	}
+
+	httpClient := &http.Client{Timeout: 30 * time.Second}
+	resp, err := httpClient.Post(cfg.TranslationURL+"/translate", "application/json", bytes.NewReader(body))
+	if err != nil {
+		return nil, fmt.Errorf("translation request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("translation service returned status %d", resp.StatusCode)
+	}
+
+	var result TranslationResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	return result.Translations, nil
+}
+
+type EmbeddingRequest struct {
+	Model string   `json:"model"`
+	Input []string `json:"input"`
+}
+
+type EmbeddingResponse struct {
+	Embeddings [][]float64 `json:"embeddings"`
+}
+
+func GetEmbeddings(ctx context.Context, texts []string) ([][]float64, error) {
+	if len(texts) == 0 {
+		return nil, nil
+	}
+
+	reqBody := EmbeddingRequest{
+		Model: "mxbai-embed-large",
+		Input: texts,
+	}
+
+	body, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, err
+	}
+
+	httpClient := &http.Client{Timeout: 60 * time.Second}
+	resp, err := httpClient.Post(cfg.OllamaURL+"/api/embeddings", "application/json", bytes.NewReader(body))
+	if err != nil {
+		return nil, fmt.Errorf("embeddings request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("embeddings service returned status %d", resp.StatusCode)
+	}
+
+	var result EmbeddingResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	return result.Embeddings, nil
+}
+
+type NERRequest struct {
+	Text string `json:"text"`
+}
+
+type NERResponse struct {
+	Entities []Entity `json:"entities"`
+}
+
+type Entity struct {
+	Text  string `json:"text"`
+	Label string `json:"label"`
+	Start int    `json:"start"`
+	End   int    `json:"end"`
+}
+
+func ExtractEntities(ctx context.Context, text string) ([]Entity, error) {
+	reqBody := NERRequest{Text: text}
+
+	body, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, err
+	}
+
+	httpClient := &http.Client{Timeout: 30 * time.Second}
+	resp, err := httpClient.Post(cfg.SpacyURL+"/ner", "application/json", bytes.NewReader(body))
+	if err != nil {
+		return nil, fmt.Errorf("NER request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("NER service returned status %d", resp.StatusCode)
+	}
+
+	var result NERResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	return result.Entities, nil
+}
+
+func SemanticSearch(ctx context.Context, query, lang string, page, perPage int) (*models.NewsListResponse, error) {
+	embeddings, err := GetEmbeddings(ctx, []string{query})
+	if err != nil {
+		return nil, err
+	}
+
+	if len(embeddings) == 0 {
+		return &models.NewsListResponse{}, nil
+	}
+
+	return &models.NewsListResponse{
+		News:       []models.NewsWithTranslations{},
+		Total:      0,
+		Page:       page,
+		PerPage:    perPage,
+		TotalPages: 0,
+	}, nil
+}

backend/internal/workers/db.go

@@ -0,0 +1,83 @@
+package workers
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var pool *pgxpool.Pool
+
+type Config struct {
+	Host     string
+	Port     int
+	DBName   string
+	User     string
+	Password string
+}
+
+func LoadDBConfig() *Config {
+	return &Config{
+		Host:     getEnv("DB_HOST", "localhost"),
+		Port:     getEnvInt("DB_PORT", 5432),
+		DBName:   getEnv("DB_NAME", "rss"),
+		User:     getEnv("DB_USER", "rss"),
+		Password: getEnv("DB_PASS", "rss"),
+	}
+}
+
+func Connect(cfg *Config) error {
+	dsn := fmt.Sprintf("postgres://%s:%s@%s:%d/%s?sslmode=disable",
+		cfg.User, cfg.Password, cfg.Host, cfg.Port, cfg.DBName)
+
+	poolConfig, err := pgxpool.ParseConfig(dsn)
+	if err != nil {
+		return fmt.Errorf("failed to parse config: %w", err)
+	}
+
+	poolConfig.MaxConns = 25
+	poolConfig.MinConns = 5
+	poolConfig.MaxConnLifetime = time.Hour
+	poolConfig.MaxConnIdleTime = 30 * time.Minute
+
+	pool, err = pgxpool.NewWithConfig(context.Background(), poolConfig)
+	if err != nil {
+		return fmt.Errorf("failed to create pool: %w", err)
+	}
+
+	if err = pool.Ping(context.Background()); err != nil {
+		return fmt.Errorf("failed to ping database: %w", err)
+	}
+
+	return nil
+}
+
+func GetPool() *pgxpool.Pool {
+	return pool
+}
+
+func Close() {
+	if pool != nil {
+		pool.Close()
+	}
+}
+
+func getEnv(key, defaultValue string) string {
+	if value := os.Getenv(key); value != "" {
+		return value
+	}
+	return defaultValue
+}
+
+func getEnvInt(key string, defaultValue int) int {
+	if value := os.Getenv(key); value != "" {
+		if intVal, err := strconv.Atoi(value); err == nil {
+			return intVal
+		}
+	}
+	return defaultValue
+}