🗄️ Bases de Datos NoSQL

# GUARDA ESTOS DATOS EN UN LUGAR SEGURO (Notepad, bloc de notas)

Username: biblioteca_admin
Password: Biblioteca2026!  # Usa esta o crea una más segura

# IMPORTANTE: Copia EXACTAMENTE como los escribiste
# La contraseña es CASE-SENSITIVE (distingue mayúsculas)

mongodb+srv://biblioteca_admin:<password>@bibliotecacluster.xxxxx.mongodb.net/?retryWrites=true&w=majority

# ANTES (incorrecto):
mongodb+srv://biblioteca_admin:<password>@bibliotecacluster.xxxxx.mongodb.net/?retryWrites=true&w=majority

# DESPUÉS (correcto):
mongodb+srv://biblioteca_admin:Biblioteca2026!@bibliotecacluster.xxxxx.mongodb.net/biblioteca_logs?retryWrites=true&w=majority

# Componentes explicados:
# mongodb+srv://       → Protocolo de conexión (SRV para Atlas)
# biblioteca_admin:   → Tu usuario de BD
# Biblioteca2026!     → Tu contraseña (SIN los símbolos < >)
# @bibliotecacluster  → Nombre de tu cluster
# .xxxxx.mongodb.net  → Servidor de Atlas (único para tu cluster)
# /biblioteca_logs    → Nombre de la base de datos (la que crearemos)
# ?retryWrites=true   → Parámetros de configuración

from pymongo import MongoClient

# Connection string SIN nombre de BD específico:
MONGO_URI = "mongodb+srv://biblioteca_admin:Biblioteca2026!@bibliotecacluster.xxxxx.mongodb.net/?retryWrites=true&w=majority"

client = MongoClient(MONGO_URI)

# ✅ Método 1: Acceder a múltiples bases de datos
db_logs = client['biblioteca_logs']             # Para logs del sistema
db_catalogo = client['biblioteca_catalogo']     # Para catálogo de libros
db_usuarios = client['biblioteca_usuarios']     # Para datos de usuarios
db_estadisticas = client['biblioteca_estadisticas']  # Para analytics y reportes

# ✅ Método 2: Usar notación punto (alternativa)
db_logs = client.biblioteca_logs
db_catalogo = client.biblioteca_catalogo
db_usuarios = client.biblioteca_usuarios
db_estadisticas = client.biblioteca_estadisticas

# 🗄️ Insertar dato en cada BD (esto las crea automáticamente):
db_logs['logs_actividad'].insert_one({
    "evento": "inicio", 
    "fecha": "2026-01-30",
    "usuario": "admin"
})

db_catalogo['libros'].insert_one({
    "libro_id": 1,
    "titulo": "Cien Años de Soledad", 
    "isbn": "978-0307474728",
    "autor": {"nombre": "Gabriel García Márquez"}
})

db_usuarios['usuarios'].insert_one({
    "nombre": "Admin", 
    "rol": "admin",
    "email": "admin@biblioteca.com"
})

db_estadisticas['visitas'].insert_one({
    "fecha": "2026-01-30",
    "total_visitas": 120,
    "libros_prestados": 15
})

# 📋 Ver todas las bases de datos creadas:
print("Bases de datos en el cluster:", client.list_database_names())
# Output: ['admin', 'biblioteca_logs', 'biblioteca_catalogo', 'biblioteca_usuarios', 'biblioteca_estadisticas', 'local']

# Configuración para usar múltiples BD en el mismo cluster

from pymongo import MongoClient

# Connection string BASE (sin nombre de BD específico):
MONGODB_BASE_URI = "mongodb+srv://biblioteca_admin:Biblioteca2026!@bibliotecacluster.xxxxx.mongodb.net/?retryWrites=true&w=majority"

# Cliente MongoDB compartido:
mongo_client = MongoClient(MONGODB_BASE_URI)

# Acceso a diferentes bases de datos:
MONGODB_DATABASES = {
    'logs': mongo_client['biblioteca_logs'],
    'catalogo': mongo_client['biblioteca_catalogo'],
    'usuarios': mongo_client['biblioteca_usuarios'],
    'estadisticas': mongo_client['biblioteca_estadisticas'],
}

# Uso en views.py:
# from django.conf import settings
# db_logs = settings.MONGODB_DATABASES['logs']
# db_catalogo = settings.MONGODB_DATABASES['catalogo']
# db_estadisticas = settings.MONGODB_DATABASES['estadisticas']

"""
Script para inicializar la estructura completa de MongoDB Atlas
Crea las 4 bases de datos con sus colecciones y documentos de ejemplo
"""

from pymongo import MongoClient
from datetime import datetime
from bson.objectid import ObjectId

# ========================================
# 1. CONEXIÓN A MONGODB ATLAS
# ========================================

# Reemplaza con tu connection string real
MONGO_URI = "mongodb+srv://biblioteca_admin:Biblioteca2026!@bibliotecacluster.xxxxx.mongodb.net/?retryWrites=true&w=majority"

print("🔌 Conectando a MongoDB Atlas...")
client = MongoClient(MONGO_URI)

# Probar conexión
try:
    client.admin.command('ping')
    print("✅ Conexión exitosa a MongoDB Atlas")
except Exception as e:
    print(f"❌ Error de conexión: {e}")
    exit(1)

# ========================================
# 2. BASE DE DATOS 1: biblioteca_logs
# ========================================

print("\n📁 Creando Base de Datos: biblioteca_logs")
db_logs = client['biblioteca_logs']

# Colección 1: logs_actividad
logs_actividad = db_logs['logs_actividad']
logs_actividad.insert_many([
    {
        "timestamp": datetime.now(),
        "usuario": "admin",
        "accion": "LOGIN",
        "ip": "192.168.1.100",
        "detalles": "Inicio de sesión exitoso"
    },
    {
        "timestamp": datetime.now(),
        "usuario": "admin",
        "accion": "PRESTAMO_CREADO",
        "libro_id": 1,  # ← Campo común con MySQL
        "detalles": "Préstamo registrado"
    }
])
print("  ✅ logs_actividad creada (2 documentos)")

# Colección 2: logs_errores
logs_errores = db_logs['logs_errores']
logs_errores.insert_one({
    "timestamp": datetime.now(),
    "nivel": "ERROR",
    "modulo": "prestamos",
    "mensaje": "Libro no disponible en stock",
    "libro_id": 5,
    "stack_trace": "..."
})
print("  ✅ logs_errores creada")

# Colección 3: logs_auditoria
logs_auditoria = db_logs['logs_auditoria']
logs_auditoria.insert_one({
    "timestamp": datetime.now(),
    "usuario": "admin",
    "tabla": "prestamos",
    "accion": "UPDATE",
    "registro_id": 10,
    "cambios": {
        "campo": "estado",
        "valor_anterior": "activo",
        "valor_nuevo": "devuelto"
    }
})
print("  ✅ logs_auditoria creada")

# ========================================
# 3. BASE DE DATOS 2: biblioteca_catalogo
# ========================================

print("\n📁 Creando Base de Datos: biblioteca_catalogo")
db_catalogo = client['biblioteca_catalogo']

# Colección 1: libros (⚠️ IMPORTANTE: Campo libro_id para conectar con MySQL)
libros = db_catalogo['libros']
libros_data = [
    {
        "libro_id": 1,  # ← CAMPO COMÚN con MySQL (INT)
        "titulo": "Cien Años de Soledad",
        "isbn": "978-0307474728",
        "autor": {  # Subdocumento
            "nombre": "Gabriel García Márquez",
            "pais": "Colombia",
            "fecha_nacimiento": datetime(1927, 3, 6)
        },
        "categorias": ["Realismo Mágico", "Literatura Latinoamericana"],
        "editorial": "Penguin Random House",
        "año_publicacion": 1967,
        "stock": 10,
        "precio": 15.99,
        "disponible": True,
        "portada_url": "https://example.com/cien-anos.jpg",
        "descripcion": "Historia de la familia Buendía...",
        "paginas": 417,
        "idioma": "Español"
    },
    {
        "libro_id": 2,  # ← CAMPO COMÚN
        "titulo": "Don Quijote de la Mancha",
        "isbn": "978-0060934347",
        "autor": {
            "nombre": "Miguel de Cervantes",
            "pais": "España",
            "fecha_nacimiento": datetime(1547, 9, 29)
        },
        "categorias": ["Clásicos", "Novela"],
        "editorial": "Editorial Planeta",
        "año_publicacion": 1605,
        "stock": 5,
        "precio": 18.99,
        "disponible": True,
        "formato_ebook": True,  # Campo flexible (no todos lo tienen)
        "paginas": 863,
        "idioma": "Español"
    },
    {
        "libro_id": 3,
        "titulo": "1984",
        "isbn": "978-0451524935",
        "autor": {
            "nombre": "George Orwell",
            "pais": "Reino Unido"
        },
        "categorias": ["Distopía", "Ciencia Ficción"],
        "stock": 8,
        "precio": 12.99,
        "disponible": True,
        "audiobook_disponible": True  # Otro campo flexible
    }
]
libros.insert_many(libros_data)
print(f"  ✅ libros creada ({len(libros_data)} documentos)")

# Colección 2: autores
autores = db_catalogo['autores']
autores.insert_many([
    {
        "nombre_completo": "Gabriel García Márquez",
        "pais": "Colombia",
        "biografia": "Premio Nobel de Literatura 1982...",
        "libros_escritos": [1]  # Referencias a libro_id
    },
    {
        "nombre_completo": "Miguel de Cervantes",
        "pais": "España",
        "biografia": "Autor del Quijote...",
        "libros_escritos": [2]
    }
])
print("  ✅ autores creada")

# Colección 3: categorias
categorias = db_catalogo['categorias']
categorias.insert_many([
    {"nombre": "Realismo Mágico", "descripcion": "Narrativa con elementos mágicos"},
    {"nombre": "Clásicos", "descripcion": "Obras literarias atemporales"},
    {"nombre": "Distopía", "descripcion": "Sociedades futuras opresivas"}
])
print("  ✅ categorias creada")

# Colección 4: reseñas
reseñas = db_catalogo['reseñas']
reseñas.insert_many([
    {
        "libro_id": 1,  # ← CAMPO COMÚN
        "usuario": "juan123",
        "calificacion": 5,
        "comentario": "Una obra maestra de la literatura",
        "fecha": datetime.now(),
        "likes": 15
    },
    {
        "libro_id": 2,
        "usuario": "maria456",
        "calificacion": 4,
        "comentario": "Clásico imprescindible",
        "fecha": datetime.now()
    }
])
print("  ✅ reseñas creada")

# ========================================
# 4. BASE DE DATOS 3: biblioteca_usuarios
# ========================================

print("\n📁 Creando Base de Datos: biblioteca_usuarios")
db_usuarios = client['biblioteca_usuarios']

# Colección 1: usuarios
usuarios = db_usuarios['usuarios']
usuarios.insert_many([
    {
        "usuario_id": 1,  # Referencia al auth_user de MySQL
        "username": "admin",
        "perfil": {
            "foto_url": "https://example.com/admin.jpg",
            "biografia": "Administrador del sistema",
            "generos_favoritos": ["Realismo Mágico", "Ciencia Ficción"]
        },
        "historial_lectura": [
            {"libro_id": 1, "fecha_inicio": datetime(2026, 1, 15), "terminado": True},
            {"libro_id": 3, "fecha_inicio": datetime(2026, 1, 20), "terminado": False}
        ]
    }
])
print("  ✅ usuarios creada")

# Colección 2: sesiones
sesiones = db_usuarios['sesiones']
sesiones.insert_one({
    "usuario_id": 1,
    "token": "abc123xyz789",
    "inicio": datetime.now(),
    "activa": True,
    "ip": "192.168.1.100"
})
print("  ✅ sesiones creada")

# Colección 3: preferencias
preferencias = db_usuarios['preferencias']
preferencias.insert_one({
    "usuario_id": 1,
    "notificaciones_email": True,
    "tema": "oscuro",
    "idioma": "es"
})
print("  ✅ preferencias creada")

# ========================================
# 5. BASE DE DATOS 4: biblioteca_estadisticas
# ========================================

print("\n📁 Creando Base de Datos: biblioteca_estadisticas")
db_estadisticas = client['biblioteca_estadisticas']

# Colección 1: visitas
visitas = db_estadisticas['visitas']
visitas.insert_many([
    {
        "fecha": datetime(2026, 1, 29),
        "total_visitas": 120,
        "paginas_vistas": 450,
        "usuarios_unicos": 85
    },
    {
        "fecha": datetime(2026, 1, 30),
        "total_visitas": 135,
        "paginas_vistas": 480,
        "usuarios_unicos": 95
    }
])
print("  ✅ visitas creada")

# Colección 2: prestamos (estadísticas de préstamos)
prestamos_stats = db_estadisticas['prestamos']
prestamos_stats.insert_many([
    {
        "fecha": datetime(2026, 1, 30),
        "libro_id": 1,  # ← CAMPO COMÚN
        "total_prestamos": 15,
        "promedio_dias_prestamo": 12
    },
    {
        "fecha": datetime(2026, 1, 30),
        "libro_id": 2,
        "total_prestamos": 8,
        "promedio_dias_prestamo": 10
    }
])
print("  ✅ prestamos (stats) creada")

# Colección 3: tendencias
tendencias = db_estadisticas['tendencias']
tendencias.insert_one({
    "periodo": "enero_2026",
    "libros_mas_prestados": [
        {"libro_id": 1, "cantidad": 15},
        {"libro_id": 3, "cantidad": 12},
        {"libro_id": 2, "cantidad": 8}
    ],
    "categorias_populares": ["Realismo Mágico", "Distopía"]
})
print("  ✅ tendencias creada")

# ========================================
# 6. RESUMEN FINAL
# ========================================

print("\n" + "="*60)
print("✅ INICIALIZACIÓN COMPLETADA")
print("="*60)

# Listar todas las bases de datos creadas
dbs = client.list_database_names()
print(f"\n📊 Bases de datos en el cluster: {len(dbs)}")
for db in dbs:
    if 'biblioteca' in db:
        collections = client[db].list_collection_names()
        print(f"  📁 {db}")
        for col in collections:
            count = client[db][col].count_documents({})
            print(f"     ├── {col} ({count} documentos)")

# Calcular uso de almacenamiento
print("\n💾 Uso de Almacenamiento:")
total_size = 0
for db_name in ['biblioteca_logs', 'biblioteca_catalogo', 
                 'biblioteca_usuarios', 'biblioteca_estadisticas']:
    stats = client[db_name].command("dbStats")
    size_mb = stats['dataSize'] / (1024 * 1024)
    total_size += size_mb
    print(f"  📊 {db_name}: {size_mb:.2f} MB")

print(f"\n  🎯 Total usado: {total_size:.2f} MB / 512 MB ({(total_size/512)*100:.1f}%)")

client.close()
print("\n🔒 Conexión cerrada")

# Asegúrate de estar en la carpeta del proyecto
cd C:\PRADODIAZ\biblioteca_project

# Ejecuta el script
python init_mongodb.py

🔌 Conectando a MongoDB Atlas...
✅ Conexión exitosa a MongoDB Atlas

📁 Creando Base de Datos: biblioteca_logs
  ✅ logs_actividad creada (2 documentos)
  ✅ logs_errores creada
  ✅ logs_auditoria creada

📁 Creando Base de Datos: biblioteca_catalogo
  ✅ libros creada (3 documentos)
  ✅ autores creada
  ✅ categorias creada
  ✅ reseñas creada

📁 Creando Base de Datos: biblioteca_usuarios
  ✅ usuarios creada
  ✅ sesiones creada
  ✅ preferencias creada

📁 Creando Base de Datos: biblioteca_estadisticas
  ✅ visitas creada
  ✅ prestamos (stats) creada
  ✅ tendencias creada

============================================================
✅ INICIALIZACIÓN COMPLETADA
============================================================

📊 Bases de datos en el cluster: 7
  📁 biblioteca_logs
     ├── logs_actividad (2 documentos)
     ├── logs_errores (1 documentos)
     └── logs_auditoria (1 documentos)
  📁 biblioteca_catalogo
     ├── libros (3 documentos)
     ├── autores (2 documentos)
     ├── categorias (3 documentos)
     └── reseñas (2 documentos)
  📁 biblioteca_usuarios
     ├── usuarios (1 documentos)
     ├── sesiones (1 documentos)
     └── preferencias (1 documentos)
  📁 biblioteca_estadisticas
     ├── visitas (2 documentos)
     ├── prestamos (2 documentos)
     └── tendencias (1 documentos)

💾 Uso de Almacenamiento:
  📊 biblioteca_logs: 0.03 MB
  📊 biblioteca_catalogo: 0.05 MB
  📊 biblioteca_usuarios: 0.02 MB
  📊 biblioteca_estadisticas: 0.02 MB

  🎯 Total usado: 0.12 MB / 512 MB (0.0%)

🔒 Conexión cerrada

# Crear carpeta del proyecto
mkdir C:\PRADODIAZ\biblioteca_project
cd C:\PRADODIAZ\biblioteca_project

# Crear entorno virtual
python -m venv venv

# Activar entorno virtual
.\venv\Scripts\Activate

# Instalar Django y dependencias
pip install django pymongo dnspython mysqlclient

# Crear proyecto Django
django-admin startproject biblioteca_project .

# Crear app
python manage.py startapp biblioteca

from pathlib import Path
import os
from pymongo import MongoClient

# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'django-insecure-tu-secret-key-aqui'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []

# Application definition
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'biblioteca',  # ← Tu app
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'biblioteca_project.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'biblioteca_project.wsgi.application'

# ========================================
# CONFIGURACIÓN MYSQL (BASE DE DATOS LOCAL)
# ========================================

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'biblioteca_db',  # Nombre de tu base de datos MySQL
        'USER': 'root',  # Usuario de MySQL
        'PASSWORD': '',  # Contraseña de MySQL (vacía en XAMPP por defecto)
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

# ========================================
# CONFIGURACIÓN MONGODB ATLAS (NUBE)
# ========================================

# ⚠️ IMPORTANTE: REEMPLAZA CON TU CONNECTION STRING REAL DE MONGODB ATLAS
# Obtén tu string desde: MongoDB Atlas → Connect → Drivers
# Debe verse así (con TU cluster real):
# mongodb+srv://usuario:password@cluster0.ab12cd.mongodb.net/

MONGODB_URI = "mongodb+srv://biblioteca_admin:TuPasswordReal@cluster0.xxxxx.mongodb.net/?retryWrites=true&w=majority"

# EJEMPLO REAL (cambia cluster0.ab12cd por tu cluster):
# MONGODB_URI = "mongodb+srv://biblioteca_admin:Biblioteca2026!@cluster0.ab12cd.mongodb.net/?retryWrites=true&w=majority"

# Crear cliente MongoDB global
MONGO_CLIENT = MongoClient(MONGODB_URI)

# Diccionario de bases de datos de MongoDB
MONGODB_DATABASES = {
    'logs': MONGO_CLIENT['biblioteca_logs'],
    'catalogo': MONGO_CLIENT['biblioteca_catalogo'],
    'usuarios': MONGO_CLIENT['biblioteca_usuarios'],
    'estadisticas': MONGO_CLIENT['biblioteca_estadisticas'],
}

# Password validation
AUTH_PASSWORD_VALIDATORS = [
    {'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator'},
    {'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator'},
    {'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator'},
    {'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator'},
]

# Internationalization
LANGUAGE_CODE = 'es-mx'
TIME_ZONE = 'America/Mexico_City'
USE_I18N = True
USE_TZ = True

# Static files (CSS, JavaScript, Images)
STATIC_URL = '/static/'

# Default primary key field type
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

# Crear archivo test_mongo.py en la raíz del proyecto
notepad test_mongo.py

from pymongo import MongoClient

# ⚠️ IMPORTANTE: Pega TU connection string real aquí
# Obtén desde: MongoDB Atlas → Connect → Drivers
MONGODB_URI = "mongodb+srv://biblioteca_admin:TuPassword@cluster0.xxxxx.mongodb.net/?retryWrites=true&w=majority"

print("🔄 Intentando conectar a MongoDB Atlas...")
print(f"📡 URI: {MONGODB_URI[:50]}...")
print("-" * 60)

try:
    # Intentar conectar al cluster
    client = MongoClient(MONGODB_URI, serverSelectionTimeoutMS=5000)
    
    # Forzar la conexión con un comando
    client.admin.command('ping')
    
    print("✅ ¡CONEXIÓN EXITOSA!")
    print("-" * 60)
    
    # Listar todas las bases de datos disponibles
    databases = client.list_database_names()
    print(f"📚 Bases de datos encontradas ({len(databases)}):")
    for db in databases:
        print(f"   - {db}")
    
    print("-" * 60)
    
    # Verificar las 4 bases de datos del proyecto (si ya existen)
    expected_dbs = [
        "biblioteca_logs",
        "biblioteca_catalogo",
        "biblioteca_usuarios",
        "biblioteca_estadisticas"
    ]
    
    print("🔍 Verificando bases de datos del proyecto:")
    for db_name in expected_dbs:
        if db_name in databases:
            # Contar colecciones
            db = client[db_name]
            collections = db.list_collection_names()
            print(f"   ✅ {db_name}: {len(collections)} colecciones")
            if collections:
                for col in collections:
                    count = db[col].count_documents({})
                    print(f"      → {col}: {count} documentos")
        else:
            print(f"   ⚠️  {db_name}: No existe (se creará con init_mongodb.py)")
    
    print("-" * 60)
    print("✅ Prueba completada exitosamente")
    print("👉 Puedes continuar con las migraciones de Django")
    
except Exception as e:
    print("❌ ERROR DE CONEXIÓN:")
    print("-" * 60)
    print(str(e))
    print("-" * 60)
    print("\n🔧 SOLUCIONES POSIBLES:")
    print("1. Verifica que el connection string sea correcto")
    print("2. Reemplaza 'xxxxx' con el código de tu cluster")
    print("3. Reemplaza '<password>' con tu contraseña real")
    print("4. Verifica que tu IP esté en la lista blanca (0.0.0.0/0)")
    print("5. Verifica que el usuario tenga permisos de lectura/escritura")

# Ejecutar el script de prueba
python test_mongo.py

-- Abre phpMyAdmin (http://localhost/phpmyadmin/)
-- O usa la consola MySQL:

mysql -u root -p

-- Crear base de datos:
CREATE DATABASE biblioteca_db CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- Verificar:
SHOW DATABASES;

-- Salir:
EXIT;

from django.db import models
from django.contrib.auth.models import User

class Prestamo(models.Model):
    """
    Modelo para préstamos (se guarda en MySQL)
    ⚠️ IMPORTANTE: libro_id es el campo común con MongoDB
    """
    
    # Campo común con MongoDB (INT)
    libro_id = models.IntegerField(
        verbose_name="ID del Libro",
        help_text="ID del libro en MongoDB (colección libros)"
    )
    
    # Relación con usuario de Django
    usuario = models.ForeignKey(
        User,
        on_delete=models.CASCADE,
        verbose_name="Usuario"
    )
    
    # Fechas del préstamo
    fecha_prestamo = models.DateTimeField(
        auto_now_add=True,
        verbose_name="Fecha de Préstamo"
    )
    
    fecha_devolucion = models.DateTimeField(
        null=True,
        blank=True,
        verbose_name="Fecha de Devolución"
    )
    
    # Estado del préstamo
    ESTADOS = [
        ('ACTIVO', 'Activo'),
        ('DEVUELTO', 'Devuelto'),
        ('VENCIDO', 'Vencido'),
    ]
    
    estado = models.CharField(
        max_length=10,
        choices=ESTADOS,
        default='ACTIVO',
        verbose_name="Estado"
    )
    
    # Días de préstamo (se calculará desde MongoDB)
    dias_prestamo = models.IntegerField(
        default=14,
        verbose_name="Días de Préstamo"
    )
    
    class Meta:
        db_table = 'biblioteca_prestamo'
        verbose_name = 'Préstamo'
        verbose_name_plural = 'Préstamos'
        ordering = ['-fecha_prestamo']
    
    def __str__(self):
        return f"Préstamo #{self.id} - Libro ID: {self.libro_id}"


class Multa(models.Model):
    """Modelo para multas por retraso en devolución"""
    
    prestamo = models.ForeignKey(
        Prestamo,
        on_delete=models.CASCADE,
        verbose_name="Préstamo"
    )
    
    monto = models.DecimalField(
        max_digits=6,
        decimal_places=2,
        verbose_name="Monto"
    )
    
    pagada = models.BooleanField(
        default=False,
        verbose_name="Pagada"
    )
    
    fecha_creacion = models.DateTimeField(
        auto_now_add=True,
        verbose_name="Fecha de Creación"
    )
    
    class Meta:
        db_table = 'biblioteca_multa'
        verbose_name = 'Multa'
        verbose_name_plural = 'Multas'
    
    def __str__(self):
        return f"Multa ${self.monto} - Préstamo #{self.prestamo.id}"

# Crear archivos de migración
python manage.py makemigrations

# Aplicar migraciones a MySQL
python manage.py migrate

# Crear superusuario
python manage.py createsuperuser
# Username: admin
# Email: admin@biblioteca.com
# Password: admin123

from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.contrib import messages
from django.conf import settings
from django.utils import timezone
from .models import Prestamo, Multa
from datetime import datetime, timedelta

# ========================================
# 1. LISTAR LIBROS (Solo MongoDB)
# ========================================

def listar_libros(request):
    """
    Lista todos los libros desde MongoDB Atlas
    """
    # Obtener base de datos de MongoDB desde settings
    db_catalogo = settings.MONGODB_DATABASES['catalogo']
    
    # Buscar parámetro de búsqueda
    query = request.GET.get('q', '')
    
    if query:
        # Búsqueda con regex (case-insensitive)
        libros = db_catalogo.libros.find({
            "$or": [
                {"titulo": {"$regex": query, "$options": "i"}},
                {"autor.nombre": {"$regex": query, "$options": "i"}},
            ]
        })
    else:
        # Obtener todos los libros
        libros = db_catalogo.libros.find()
    
    # Convertir cursor a lista
    libros_list = list(libros)
    
    context = {
        'libros': libros_list,
        'query': query,
        'total_libros': len(libros_list)
    }
    
    return render(request, 'biblioteca/listar_libros.html', context)


# ========================================
# 2. DETALLE DE LIBRO (MongoDB + MySQL)
# ========================================

def detalle_libro(request, libro_id):
    """
    Muestra detalle de un libro combinando datos de:
    - MongoDB: Información del libro (titulo, autor, etc.)
    - MySQL: Préstamos activos de este libro
    """
    # 1. Obtener información del libro desde MongoDB
    db_catalogo = settings.MONGODB_DATABASES['catalogo']
    libro = db_catalogo.libros.find_one({"libro_id": libro_id})
    
    if not libro:
        messages.error(request, "Libro no encontrado")
        return redirect('listar_libros')
    
    # 2. Obtener préstamos activos de este libro desde MySQL
    prestamos_activos = Prestamo.objects.filter(
        libro_id=libro_id,
        estado='ACTIVO'
    ).select_related('usuario')
    
    # 3. Obtener reseñas desde MongoDB
    reseñas = db_catalogo.reseñas.find({"libro_id": libro_id})
    
    context = {
        'libro': libro,  # MongoDB
        'prestamos_activos': prestamos_activos,  # MySQL
        'reseñas': list(reseñas),  # MongoDB
        'disponible': libro.get('stock', 0) > 0
    }
    
    return render(request, 'biblioteca/detalle_libro.html', context)


# ========================================
# 3. PRESTAR LIBRO (MySQL + MongoDB)
# ========================================

@login_required
def prestar_libro(request, libro_id):
    """
    Crea un préstamo en MySQL y actualiza stock en MongoDB
    ⚠️ Esta es la operación crítica del sistema híbrido
    """
    if request.method == 'POST':
        db_catalogo = settings.MONGODB_DATABASES['catalogo']
        db_logs = settings.MONGODB_DATABASES['logs']
        db_estadisticas = settings.MONGODB_DATABASES['estadisticas']
        
        # 1. Buscar libro en MongoDB
        libro = db_catalogo.libros.find_one({"libro_id": libro_id})
        
        if not libro:
            messages.error(request, "Libro no encontrado")
            return redirect('listar_libros')
        
        # 2. Verificar stock disponible (MongoDB)
        if libro.get('stock', 0) <= 0:
            messages.error(request, f"El libro '{libro['titulo']}' no tiene stock disponible")
            return redirect('detalle_libro', libro_id=libro_id)
        
        # 3. Verificar que el usuario no tenga préstamos activos del mismo libro
        prestamo_existente = Prestamo.objects.filter(
            libro_id=libro_id,
            usuario=request.user,
            estado='ACTIVO'
        ).exists()
        
        if prestamo_existente:
            messages.warning(request, "Ya tienes un préstamo activo de este libro")
            return redirect('detalle_libro', libro_id=libro_id)
        
        try:
            # 4. Crear préstamo en MySQL
            prestamo = Prestamo.objects.create(
                libro_id=libro_id,  # ← CAMPO COMÚN
                usuario=request.user,
                dias_prestamo=14
            )
            
            # 5. Actualizar stock en MongoDB
            db_catalogo.libros.update_one(
                {"libro_id": libro_id},
                {"$inc": {"stock": -1}}  # Restar 1 al stock
            )
            
            # 6. Registrar log en MongoDB
            db_logs.logs_actividad.insert_one({
                "timestamp": datetime.now(),
                "usuario": request.user.username,
                "accion": "PRESTAMO_CREADO",
                "libro_id": libro_id,  # ← CAMPO COMÚN
                "prestamo_id": prestamo.id,
                "detalles": f"Préstamo del libro '{libro['titulo']}'"
            })
            
            # 7. Actualizar estadísticas en MongoDB
            db_estadisticas.prestamos.insert_one({
                "fecha": datetime.now(),
                "libro_id": libro_id,  # ← CAMPO COMÚN
                "usuario": request.user.username,
                "accion": "PRESTADO"
            })
            
            messages.success(
                request, 
                f"✅ Préstamo registrado exitosamente. Fecha de devolución: "
                f"{(timezone.now() + timedelta(days=14)).strftime('%d/%m/%Y')}"
            )
            
            return redirect('mis_prestamos')
            
        except Exception as e:
            # Si hay error, registrar en logs de MongoDB
            db_logs.logs_errores.insert_one({
                "timestamp": datetime.now(),
                "nivel": "ERROR",
                "modulo": "prestamos",
                "mensaje": str(e),
                "usuario": request.user.username,
                "libro_id": libro_id
            })
            
            messages.error(request, f"Error al crear préstamo: {str(e)}")
            return redirect('detalle_libro', libro_id=libro_id)
    
    return redirect('detalle_libro', libro_id=libro_id)


# ========================================
# 4. DEVOLVER LIBRO (MySQL + MongoDB)
# ========================================

@login_required
def devolver_libro(request, prestamo_id):
    """
    Marca préstamo como devuelto en MySQL y actualiza stock en MongoDB
    """
    prestamo = get_object_or_404(Prestamo, id=prestamo_id, usuario=request.user)
    
    if prestamo.estado != 'ACTIVO':
        messages.warning(request, "Este préstamo ya fue devuelto")
        return redirect('mis_prestamos')
    
    db_catalogo = settings.MONGODB_DATABASES['catalogo']
    db_logs = settings.MONGODB_DATABASES['logs']
    
    try:
        # 1. Actualizar préstamo en MySQL
        prestamo.estado = 'DEVUELTO'
        prestamo.fecha_devolucion = timezone.now()
        prestamo.save()
        
        # 2. Restaurar stock en MongoDB
        db_catalogo.libros.update_one(
            {"libro_id": prestamo.libro_id},  # ← CAMPO COMÚN
            {"$inc": {"stock": 1}}  # Sumar 1 al stock
        )
        
        # 3. Registrar devolución en logs
        db_logs.logs_actividad.insert_one({
            "timestamp": datetime.now(),
            "usuario": request.user.username,
            "accion": "DEVOLUCION",
            "libro_id": prestamo.libro_id,  # ← CAMPO COMÚN
            "prestamo_id": prestamo.id
        })
        
        messages.success(request, "✅ Libro devuelto exitosamente")
        
    except Exception as e:
        messages.error(request, f"Error al devolver libro: {str(e)}")
    
    return redirect('mis_prestamos')


# ========================================
# 5. MIS PRÉSTAMOS (Consulta Híbrida)
# ========================================

@login_required
def mis_prestamos(request):
    """
    Lista préstamos del usuario combinando datos de MySQL y MongoDB
    """
    # 1. Obtener préstamos del usuario desde MySQL
    prestamos = Prestamo.objects.filter(usuario=request.user).order_by('-fecha_prestamo')
    
    # 2. Obtener base de datos MongoDB
    db_catalogo = settings.MONGODB_DATABASES['catalogo']
    
    # 3. Para cada préstamo, obtener datos del libro desde MongoDB
    prestamos_completos = []
    
    for prestamo in prestamos:
        # Buscar libro en MongoDB usando el campo común
        libro = db_catalogo.libros.find_one({"libro_id": prestamo.libro_id})
        
        # Combinar datos
        prestamos_completos.append({
            'prestamo': prestamo,  # MySQL
            'libro': libro if libro else {'titulo': 'Libro no encontrado'}  # MongoDB
        })
    
    context = {
        'prestamos_completos': prestamos_completos,
        'total_prestamos': prestamos.count()
    }
    
    return render(request, 'biblioteca/mis_prestamos.html', context)


# ========================================
# 6. DASHBOARD (Estadísticas Híbridas)
# ========================================

def dashboard(request):
    """
    Dashboard con estadísticas de MySQL y MongoDB
    """
    db_catalogo = settings.MONGODB_DATABASES['catalogo']
    db_estadisticas = settings.MONGODB_DATABASES['estadisticas']
    
    # Estadísticas de MySQL
    total_prestamos_activos = Prestamo.objects.filter(estado='ACTIVO').count()
    total_prestamos_historico = Prestamo.objects.count()
    
    # Estadísticas de MongoDB
    total_libros = db_catalogo.libros.count_documents({})
    libros_disponibles = db_catalogo.libros.count_documents({"disponible": True})
    
    # Libros más prestados (MongoDB estadísticas)
    tendencia = db_estadisticas.tendencias.find_one(
        {"periodo": "enero_2026"}
    )
    
    context = {
        'total_prestamos_activos': total_prestamos_activos,
        'total_prestamos_historico': total_prestamos_historico,
        'total_libros': total_libros,
        'libros_disponibles': libros_disponibles,
        'tendencia': tendencia
    }
    
    return render(request, 'biblioteca/dashboard.html', context)

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('biblioteca.urls')),  # URLs de la app
]

from django.urls import path
from . import views

urlpatterns = [
    # Dashboard
    path('', views.dashboard, name='dashboard'),
    
    # Libros (MongoDB)
    path('libros/', views.listar_libros, name='listar_libros'),
    path('libros/<int:libro_id>/', views.detalle_libro, name='detalle_libro'),
    
    # Préstamos (MySQL + MongoDB)
    path('prestamos/crear/<int:libro_id>/', views.prestar_libro, name='prestar_libro'),
    path('prestamos/devolver/<int:prestamo_id>/', views.devolver_libro, name='devolver_libro'),
    path('prestamos/mis-prestamos/', views.mis_prestamos, name='mis_prestamos'),
]

# Desde la carpeta del proyecto
mkdir biblioteca\templates\biblioteca

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}Biblioteca - Sistema Híbrido{% endblock %}</title>
    
    <!-- Bootstrap 5 -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.0/font/bootstrap-icons.css">
    
    <style>
        body {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }
        .container {
            background: white;
            border-radius: 15px;
            padding: 30px;
            margin-top: 30px;
            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
        }
        .badge-mysql {
            background: #00758f;
        }
        .badge-mongodb {
            background: #00ed64;
            color: #000;
        }
    </style>
    
    {% block extra_css %}{% endblock %}
</head>
<body>
    <!-- Navbar -->
    <nav class="navbar navbar-expand-lg navbar-dark" style="background: rgba(0,0,0,0.3);">
        <div class="container-fluid">
            <a class="navbar-brand" href="{% url 'dashboard' %}">
                <i class="bi bi-book"></i> Biblioteca Híbrida
            </a>
            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav">
                <span class="navbar-toggler-icon"></span>
            </button>
            <div class="collapse navbar-collapse" id="navbarNav">
                <ul class="navbar-nav ms-auto">
                    <li class="nav-item">
                        <a class="nav-link" href="{% url 'dashboard' %}">Dashboard</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link" href="{% url 'listar_libros' %}">
                            <span class="badge badge-mongodb">MongoDB</span> Libros
                        </a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link" href="{% url 'mis_prestamos' %}">
                            <span class="badge badge-mysql">MySQL</span> Mis Préstamos
                        </a>
                    </li>
                    {% if user.is_authenticated %}
                    <li class="nav-item">
                        <span class="nav-link">👤 {{ user.username }}</span>
                    </li>
                    {% endif %}
                </ul>
            </div>
        </div>
    </nav>
    
    <!-- Mensajes -->
    <div class="container mt-3">
        {% if messages %}
            {% for message in messages %}
            <div class="alert alert-{{ message.tags }} alert-dismissible fade show" role="alert">
                {{ message }}
                <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
            </div>
            {% endfor %}
        {% endif %}
    </div>
    
    <!-- Contenido -->
    <div class="container">
        {% block content %}{% endblock %}
    </div>
    
    <!-- Footer -->
    <footer class="text-center text-white mt-5 pb-3">
        <p>
            <span class="badge badge-mysql">MySQL</span> + 
            <span class="badge badge-mongodb">MongoDB Atlas</span> 
            Sistema Híbrido 2026
        </p>
    </footer>
    
    <!-- Bootstrap JS -->
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
    {% block extra_js %}{% endblock %}
</body>
</html>

# Navega a tu carpeta de proyecto (ApellidoPaternoApellidoMaterno):
cd C:\PRADODIAZ\biblioteca_project

# Crea entorno virtual:
python -m venv venv

# Activa el entorno virtual:
.\venv\Scripts\Activate

# Deberías ver (venv) al inicio del prompt:
# (venv) PS C:\PRADODIAZ\biblioteca_project>

pip install pymongo==4.6.0

# Deberías ver al final:
# Successfully installed pymongo-4.6.0

python -c "import pymongo; print('✅ PyMongo version:', pymongo.version)"

# Debe mostrar: ✅ PyMongo version: 4.6.0

pip install dnspython==2.4.2

# También instala el soporte SRV completo:
pip install "pymongo[srv]"

# Deberías ver:
# Successfully installed dnspython-2.4.2

python -c "import dns; print('✅ dnspython instalado correctamente')"

# Debe mostrar: ✅ dnspython instalado correctamente

# Nota: Djongo puede tener problemas de compatibilidad con Django 4.x
# Solo instálalo si quieres usar modelos Django con MongoDB

pip install djongo==1.3.6

# Alternativa moderna (usa PyMongo directamente):
# En lugar de djongo, puedes usar PyMongo en las views directamente

pip install djangorestframework==3.14.0

# Deberías ver:
# Successfully installed djangorestframework-3.14.0

pip freeze > requirements.txt

# Verifica el contenido:
cat requirements.txt

# Deberías ver (entre otras):
# Django==4.2.x
# pymongo==4.6.0
# dnspython==2.4.2
# djangorestframework==3.14.0