📚 Guía Completa de Instalación Examen U3

import pymysql

pymysql.install_as_MySQLdb()

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    
    # Apps de terceros
    'rest_framework',
    'django_filters',
    'spyne',
    
    # Apps del proyecto
    'libros',
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'biblioteca_dbutres',
        'USER': 'root',
        'PASSWORD': 'TU_CONTRASEÑA_MYSQL',  # ← Cambia esto por tu contraseña
        'HOST': 'localhost',
        'PORT': '3306',
        'OPTIONS': {
            'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
            'charset': 'utf8mb4',
        },
    }
}

USE_TZ = False
TIME_ZONE = 'America/Hermosillo'  # O tu zona horaria

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'biblioteca_project' / 'templates'],  # ← Agregar esta línea
        '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',
            ],
        },
    },
]

STATIC_URL = '/static/'
STATIC_ROOT = BASE_DIR / 'staticfiles'
STATICFILES_DIRS = [
    BASE_DIR / 'static',
]

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 10,
    'DEFAULT_FILTER_BACKENDS': [
        'django_filters.rest_framework.DjangoFilterBackend',
        'rest_framework.filters.SearchFilter',
        'rest_framework.filters.OrderingFilter',
    ],
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticatedOrReadOnly',
    ],
}

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

# Create your models here.

class Autor(models.Model):
    """Modelo para autores de libros"""
    nombre = models.CharField(max_length=100)
    apellido = models.CharField(max_length=100)
    fecha_nacimiento = models.DateField(null=True, blank=True)
    nacionalidad = models.CharField(max_length=50, blank=True)
    biografia = models.TextField(blank=True)
    
    class Meta:
        verbose_name = "Autor"
        verbose_name_plural = "Autores"
        ordering = ['apellido', 'nombre']
    
    def __str__(self):
        return f"{self.nombre} {self.apellido}"


class Editorial(models.Model):
    """Modelo para editoriales"""
    nombre = models.CharField(max_length=200)
    pais = models.CharField(max_length=50)
    sitio_web = models.URLField(blank=True)
    fecha_fundacion = models.DateField(null=True, blank=True)
    
    class Meta:
        verbose_name = "Editorial"
        verbose_name_plural = "Editoriales"
        ordering = ['nombre']
    
    def __str__(self):
        return self.nombre


class Categoria(models.Model):
    """Modelo para categorías de libros"""
    nombre = models.CharField(max_length=100, unique=True)
    descripcion = models.TextField(blank=True)
    
    class Meta:
        verbose_name = "Categoría"
        verbose_name_plural = "Categorías"
        ordering = ['nombre']
    
    def __str__(self):
        return self.nombre


class Libro(models.Model):
    """Modelo principal para libros"""
    ESTADO_CHOICES = [
        ('disponible', 'Disponible'),
        ('prestado', 'Prestado'),
        ('reservado', 'Reservado'),
        ('mantenimiento', 'En Mantenimiento'),
    ]
    
    titulo = models.CharField(max_length=200)
    isbn = models.CharField(max_length=13, unique=True)
    autor = models.ForeignKey(Autor, on_delete=models.CASCADE, related_name='libros')
    editorial = models.ForeignKey(Editorial, on_delete=models.SET_NULL, null=True, related_name='libros')
    categoria = models.ForeignKey(Categoria, on_delete=models.SET_NULL, null=True, related_name='libros')
    fecha_publicacion = models.DateField()
    numero_paginas = models.IntegerField()
    idioma = models.CharField(max_length=50, default='Español')
    descripcion = models.TextField(blank=True)
    estado = models.CharField(max_length=20, choices=ESTADO_CHOICES, default='disponible')
    stock_total = models.IntegerField(default=1)
    stock_disponible = models.IntegerField(default=1)
    ubicacion_fisica = models.CharField(max_length=50, blank=True, help_text="Ej: Estante A-12")
    fecha_registro = models.DateTimeField(auto_now_add=True)
    ultima_actualizacion = models.DateTimeField(auto_now=True)
    
    class Meta:
        verbose_name = "Libro"
        verbose_name_plural = "Libros"
        ordering = ['titulo']
    
    def __str__(self):
        return f"{self.titulo} - {self.autor}"
    
    def esta_disponible(self):
        """Verifica si el libro está disponible para préstamo"""
        return self.estado == 'disponible' and self.stock_disponible > 0


class Prestamo(models.Model):
    """Modelo para préstamos de libros"""
    ESTADO_CHOICES = [
        ('activo', 'Activo'),
        ('devuelto', 'Devuelto'),
        ('vencido', 'Vencido'),
        ('renovado', 'Renovado'),
    ]
    
    libro = models.ForeignKey(Libro, on_delete=models.CASCADE, related_name='prestamos')
    usuario = models.ForeignKey(User, on_delete=models.CASCADE, related_name='prestamos')
    fecha_prestamo = models.DateField(auto_now_add=True)
    fecha_devolucion_esperada = models.DateField()
    fecha_devolucion_real = models.DateField(null=True, blank=True)
    estado = models.CharField(max_length=20, choices=ESTADO_CHOICES, default='activo')
    renovaciones = models.IntegerField(default=0)
    multa = models.DecimalField(max_digits=10, decimal_places=2, default=0.00)
    notas = models.TextField(blank=True)
    
    class Meta:
        verbose_name = "Préstamo"
        verbose_name_plural = "Préstamos"
        ordering = ['-fecha_prestamo']
    
    def __str__(self):
        return f"{self.libro.titulo} - {self.usuario.username} ({self.estado})"
    
    def esta_vencido(self):
        """Verifica si el préstamo está vencido"""
        from datetime import date
        return self.estado == 'activo' and self.fecha_devolucion_esperada < date.today()

from rest_framework import serializers
from .models import Libro, Autor, Categoria, Editorial, Prestamo

class AutorSerializer(serializers.ModelSerializer):
    nombre_completo = serializers.CharField(read_only=True)
    
    class Meta:
        model = Autor
        fields = ['id', 'nombre', 'apellido', 'nombre_completo', 
                  'nacionalidad', 'biografia', 'fecha_nacimiento']

class CategoriaSerializer(serializers.ModelSerializer):
    class Meta:
        model = Categoria
        fields = ['id', 'nombre', 'descripcion']

class EditorialSerializer(serializers.ModelSerializer):
    class Meta:
        model = Editorial
        fields = ['id', 'nombre', 'pais', 'sitio_web']

class LibroSerializer(serializers.ModelSerializer):
    autor_nombre = serializers.CharField(source='autor.nombre_completo', read_only=True)
    categoria_nombre = serializers.CharField(source='categoria.nombre', read_only=True)
    editorial_nombre = serializers.CharField(source='editorial.nombre', read_only=True)
    
    class Meta:
        model = Libro
        fields = [
            'id', 'titulo', 'isbn', 'descripcion', 'fecha_publicacion',
            'numero_paginas', 'idioma', 'stock_total', 'stock_disponible',
            'estado', 'autor', 'autor_nombre', 'categoria', 'categoria_nombre',
            'editorial', 'editorial_nombre', 'fecha_creacion'
        ]
        read_only_fields = ['fecha_creacion']

class PrestamoSerializer(serializers.ModelSerializer):
    libro_titulo = serializers.CharField(source='libro.titulo', read_only=True)
    usuario_nombre = serializers.CharField(source='usuario.username', read_only=True)
    
    class Meta:
        model = Prestamo
        fields = [
            'id', 'libro', 'libro_titulo', 'usuario', 'usuario_nombre',
            'fecha_prestamo', 'fecha_devolucion_esperada', 'fecha_devolucion_real',
            'estado', 'observaciones'
        ]
        read_only_fields = ['fecha_prestamo']

from django.shortcuts import render
from rest_framework import viewsets, filters
from rest_framework.permissions import IsAuthenticatedOrReadOnly
from django_filters.rest_framework import DjangoFilterBackend

from .models import Libro, Autor, Categoria, Editorial, Prestamo
from .serializers import (
    LibroSerializer, AutorSerializer, CategoriaSerializer,
    EditorialSerializer, PrestamoSerializer
)

class LibroViewSet(viewsets.ModelViewSet):
    """ViewSet para gestión de libros via API REST"""
    queryset = Libro.objects.all()
    serializer_class = LibroSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_fields = ['categoria', 'autor', 'editorial', 'estado']
    search_fields = ['titulo', 'isbn', 'autor__nombre', 'autor__apellido']
    ordering_fields = ['titulo', 'fecha_publicacion', 'stock_disponible']
    ordering = ['titulo']

class AutorViewSet(viewsets.ModelViewSet):
    """ViewSet para gestión de autores"""
    queryset = Autor.objects.all()
    serializer_class = AutorSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]
    filter_backends = [filters.SearchFilter, filters.OrderingFilter]
    search_fields = ['nombre', 'apellido', 'nacionalidad']
    ordering_fields = ['nombre', 'apellido']
    ordering = ['apellido']

class CategoriaViewSet(viewsets.ModelViewSet):
    """ViewSet para gestión de categorías"""
    queryset = Categoria.objects.all()
    serializer_class = CategoriaSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]

class EditorialViewSet(viewsets.ModelViewSet):
    """ViewSet para gestión de editoriales"""
    queryset = Editorial.objects.all()
    serializer_class = EditorialSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]

class PrestamoViewSet(viewsets.ModelViewSet):
    """ViewSet para gestión de préstamos"""
    queryset = Prestamo.objects.all()
    serializer_class = PrestamoSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]
    filter_backends = [DjangoFilterBackend, filters.OrderingFilter]
    filterset_fields = ['estado', 'usuario', 'libro']
    ordering_fields = ['fecha_prestamo', 'fecha_devolucion_esperada']
    ordering = ['-fecha_prestamo']

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from . import views

# Router para API REST
router = DefaultRouter()
router.register(r'libros', views.LibroViewSet)
router.register(r'autores', views.AutorViewSet)
router.register(r'categorias', views.CategoriaViewSet)
router.register(r'editoriales', views.EditorialViewSet)
router.register(r'prestamos', views.PrestamoViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

"""
Servicios SOAP para el Sistema de Biblioteca
"""
from spyne import Application, rpc, ServiceBase, Integer, Unicode, Boolean, DateTime, Array, ComplexModel
from spyne.protocol.soap import Soap11
from spyne.server.django import DjangoApplication
from django.views.decorators.csrf import csrf_exempt
from datetime import datetime, timedelta
from libros.models import Libro, Autor, Categoria, Editorial, Prestamo
from django.contrib.auth.models import User


# ===== MODELOS COMPLEJOS SOAP =====

class AutorModel(ComplexModel):
    """Modelo SOAP para Autor"""
    id = Integer
    nombre = Unicode
    apellido = Unicode
    nacionalidad = Unicode
    biografia = Unicode


class CategoriaModel(ComplexModel):
    """Modelo SOAP para Categoría"""
    id = Integer
    nombre = Unicode
    descripcion = Unicode


class EditorialModel(ComplexModel):
    """Modelo SOAP para Editorial"""
    id = Integer
    nombre = Unicode
    pais = Unicode
    sitio_web = Unicode


class LibroModel(ComplexModel):
    """Modelo SOAP para Libro"""
    id = Integer
    titulo = Unicode
    isbn = Unicode
    autor_nombre = Unicode
    editorial_nombre = Unicode
    categoria_nombre = Unicode
    fecha_publicacion = Unicode
    numero_paginas = Integer
    idioma = Unicode
    descripcion = Unicode
    estado = Unicode
    stock_total = Integer
    stock_disponible = Integer
    ubicacion_fisica = Unicode
    fecha_registro = DateTime
    ultima_actualizacion = DateTime


class LibroDetalladoModel(ComplexModel):
    """Modelo SOAP extendido para Libro con relaciones"""
    id = Integer
    titulo = Unicode
    isbn = Unicode
    numero_paginas = Integer
    idioma = Unicode
    descripcion = Unicode
    estado = Unicode
    stock_total = Integer
    stock_disponible = Integer
    ubicacion_fisica = Unicode
    fecha_publicacion = Unicode
    fecha_registro = DateTime
    ultima_actualizacion = DateTime
    # Objetos completos de relaciones
    autor = AutorModel
    editorial = EditorialModel
    categoria = CategoriaModel


class PrestamoModel(ComplexModel):
    """Modelo SOAP para Préstamo"""
    id = Integer
    libro_titulo = Unicode
    usuario_nombre = Unicode
    fecha_prestamo = DateTime
    fecha_devolucion_esperada = Unicode
    fecha_devolucion_real = Unicode
    estado = Unicode
    multa = Unicode


class ResultadoOperacion(ComplexModel):
    """Modelo para respuestas de operaciones"""
    exito = Boolean
    mensaje = Unicode
    id = Integer

# ===== SERVICIOS SOAP =====

class BibliotecaService(ServiceBase):
    """
    Servicios SOAP para gestión de biblioteca digital
    """
    
    # ===== SERVICIOS DE LIBROS =====
    
    @rpc(Integer, _returns=LibroDetalladoModel)
    def obtener_libro(ctx, libro_id):
        """
        Obtiene información completa de un libro por ID
        """
        try:
            libro = Libro.objects.select_related('autor', 'editorial', 'categoria').get(id=libro_id)
            
            # Crear modelo de autor
            autor_model = AutorModel(
                id=libro.autor.id,
                nombre=libro.autor.nombre,
                apellido=libro.autor.apellido,
                nacionalidad=libro.autor.nacionalidad or '',
                biografia=libro.autor.biografia or ''
            )
            
            # Crear modelo de editorial
            editorial_model = EditorialModel(
                id=libro.editorial.id if libro.editorial else 0,
                nombre=libro.editorial.nombre if libro.editorial else 'Sin editorial',
                pais=libro.editorial.pais if libro.editorial else '',
                sitio_web=libro.editorial.sitio_web if libro.editorial else ''
            )
            
            # Crear modelo de categoría
            categoria_model = CategoriaModel(
                id=libro.categoria.id if libro.categoria else 0,
                nombre=libro.categoria.nombre if libro.categoria else 'Sin categoría',
                descripcion=libro.categoria.descripcion if libro.categoria else ''
            )
            
            return LibroDetalladoModel(
                id=libro.id,
                titulo=libro.titulo,
                isbn=libro.isbn,
                numero_paginas=libro.numero_paginas,
                idioma=libro.idioma,
                descripcion=libro.descripcion or '',
                estado=libro.estado,
                stock_total=libro.stock_total,
                stock_disponible=libro.stock_disponible,
                ubicacion_fisica=libro.ubicacion_fisica or '',
                fecha_publicacion=str(libro.fecha_publicacion),
                fecha_registro=libro.fecha_registro,
                ultima_actualizacion=libro.ultima_actualizacion,
                autor=autor_model,
                editorial=editorial_model,
                categoria=categoria_model
            )
        except Libro.DoesNotExist:
            return None
    
    @rpc(_returns=Array(LibroModel))
    def listar_libros(ctx):
        """Lista todos los libros disponibles"""
        libros = Libro.objects.select_related('autor', 'editorial', 'categoria').all()
        resultado = []
        
        for libro in libros:
            resultado.append(LibroModel(
                id=libro.id,
                titulo=libro.titulo,
                isbn=libro.isbn,
                autor_nombre=f"{libro.autor.nombre} {libro.autor.apellido}",
                editorial_nombre=libro.editorial.nombre if libro.editorial else 'Sin editorial',
                categoria_nombre=libro.categoria.nombre if libro.categoria else 'Sin categoría',
                fecha_publicacion=str(libro.fecha_publicacion),
                numero_paginas=libro.numero_paginas,
                idioma=libro.idioma,
                descripcion=libro.descripcion or '',
                estado=libro.estado,
                stock_total=libro.stock_total,
                stock_disponible=libro.stock_disponible,
                ubicacion_fisica=libro.ubicacion_fisica or '',
                fecha_registro=libro.fecha_registro,
                ultima_actualizacion=libro.ultima_actualizacion
            ))
        
        return resultado
    
    @rpc(Unicode, _returns=Array(LibroModel))
    def buscar_libros_por_titulo(ctx, titulo):
        """Busca libros por título (búsqueda parcial)"""
        libros = Libro.objects.filter(titulo__icontains=titulo).select_related('autor', 'editorial', 'categoria')
        resultado = []
        
        for libro in libros:
            resultado.append(LibroModel(
                id=libro.id,
                titulo=libro.titulo,
                isbn=libro.isbn,
                autor_nombre=f"{libro.autor.nombre} {libro.autor.apellido}",
                editorial_nombre=libro.editorial.nombre if libro.editorial else 'Sin editorial',
                categoria_nombre=libro.categoria.nombre if libro.categoria else 'Sin categoría',
                fecha_publicacion=str(libro.fecha_publicacion),
                numero_paginas=libro.numero_paginas,
                idioma=libro.idioma,
                descripcion=libro.descripcion or '',
                estado=libro.estado,
                stock_total=libro.stock_total,
                stock_disponible=libro.stock_disponible,
                ubicacion_fisica=libro.ubicacion_fisica or '',
                fecha_registro=libro.fecha_registro,
                ultima_actualizacion=libro.ultima_actualizacion
            ))
        
        return resultado
    
    @rpc(Unicode, _returns=Array(LibroModel))
    def buscar_libros_por_autor(ctx, autor_apellido):
        """Busca libros por apellido del autor"""
        libros = Libro.objects.filter(
            autor__apellido__icontains=autor_apellido
        ).select_related('autor', 'editorial', 'categoria')
        
        resultado = []
        for libro in libros:
            resultado.append(LibroModel(
                id=libro.id,
                titulo=libro.titulo,
                isbn=libro.isbn,
                autor_nombre=f"{libro.autor.nombre} {libro.autor.apellido}",
                editorial_nombre=libro.editorial.nombre if libro.editorial else 'Sin editorial',
                categoria_nombre=libro.categoria.nombre if libro.categoria else 'Sin categoría',
                fecha_publicacion=str(libro.fecha_publicacion),
                numero_paginas=libro.numero_paginas,
                idioma=libro.idioma,
                descripcion=libro.descripcion or '',
                estado=libro.estado,
                stock_total=libro.stock_total,
                stock_disponible=libro.stock_disponible,
                ubicacion_fisica=libro.ubicacion_fisica or '',
                fecha_registro=libro.fecha_registro,
                ultima_actualizacion=libro.ultima_actualizacion
            ))
        
        return resultado
    
    @rpc(_returns=Array(LibroModel))
    def listar_libros_disponibles(ctx):
        """Lista solo los libros disponibles para préstamo"""
        libros = Libro.objects.filter(
            estado='disponible',
            stock_disponible__gt=0
        ).select_related('autor', 'editorial', 'categoria')
        
        resultado = []
        for libro in libros:
            resultado.append(LibroModel(
                id=libro.id,
                titulo=libro.titulo,
                isbn=libro.isbn,
                autor_nombre=f"{libro.autor.nombre} {libro.autor.apellido}",
                editorial_nombre=libro.editorial.nombre if libro.editorial else 'Sin editorial',
                categoria_nombre=libro.categoria.nombre if libro.categoria else 'Sin categoría',
                fecha_publicacion=str(libro.fecha_publicacion),
                numero_paginas=libro.numero_paginas,
                idioma=libro.idioma,
                descripcion=libro.descripcion or '',
                estado=libro.estado,
                stock_total=libro.stock_total,
                stock_disponible=libro.stock_disponible,
                ubicacion_fisica=libro.ubicacion_fisica or '',
                fecha_registro=libro.fecha_registro,
                ultima_actualizacion=libro.ultima_actualizacion
            ))
        
        return resultado
    
    @rpc(Unicode, _returns=Array(LibroModel))
    def buscar_libros_por_categoria(ctx, categoria_nombre):
        """Busca libros por categoría"""
        libros = Libro.objects.filter(
            categoria__nombre__icontains=categoria_nombre
        ).select_related('autor', 'editorial', 'categoria')
        
        resultado = []
        for libro in libros:
            resultado.append(LibroModel(
                id=libro.id,
                titulo=libro.titulo,
                isbn=libro.isbn,
                autor_nombre=f"{libro.autor.nombre} {libro.autor.apellido}",
                editorial_nombre=libro.editorial.nombre if libro.editorial else 'Sin editorial',
                categoria_nombre=libro.categoria.nombre if libro.categoria else 'Sin categoría',
                fecha_publicacion=str(libro.fecha_publicacion),
                numero_paginas=libro.numero_paginas,
                idioma=libro.idioma,
                descripcion=libro.descripcion or '',
                estado=libro.estado,
                stock_total=libro.stock_total,
                stock_disponible=libro.stock_disponible,
                ubicacion_fisica=libro.ubicacion_fisica or '',
                fecha_registro=libro.fecha_registro,
                ultima_actualizacion=libro.ultima_actualizacion
            ))
        
        return resultado

    # ===== SERVICIOS DE PRÉSTAMOS =====
    
    @rpc(Integer, Integer, Integer, _returns=ResultadoOperacion)
    def crear_prestamo(ctx, libro_id, usuario_id, dias_prestamo):
        """Crea un nuevo préstamo de libro"""
        try:
            libro = Libro.objects.get(id=libro_id)
            usuario = User.objects.get(id=usuario_id)
            
            # Verificar disponibilidad
            if not libro.esta_disponible():
                return ResultadoOperacion(
                    exito=False,
                    mensaje=f"El libro '{libro.titulo}' no está disponible",
                    id=0
                )
            
            # Calcular fecha de devolución
            fecha_devolucion = (datetime.now() + timedelta(days=dias_prestamo)).date()
            
            # Crear préstamo
            prestamo = Prestamo.objects.create(
                libro=libro,
                usuario=usuario,
                fecha_devolucion_esperada=fecha_devolucion,
                estado='activo'
            )
            
            # Actualizar stock del libro
            libro.stock_disponible -= 1
            if libro.stock_disponible == 0:
                libro.estado = 'prestado'
            libro.save()
            
            return ResultadoOperacion(
                exito=True,
                mensaje=f"Préstamo creado exitosamente. Devolver antes del {fecha_devolucion}",
                id=prestamo.id
            )
            
        except Libro.DoesNotExist:
            return ResultadoOperacion(exito=False, mensaje="Libro no encontrado", id=0)
        except User.DoesNotExist:
            return ResultadoOperacion(exito=False, mensaje="Usuario no encontrado", id=0)
        except Exception as e:
            return ResultadoOperacion(exito=False, mensaje=f"Error: {str(e)}", id=0)
    
    @rpc(Integer, _returns=ResultadoOperacion)
    def devolver_libro(ctx, prestamo_id):
        """Registra la devolución de un libro"""
        try:
            prestamo = Prestamo.objects.get(id=prestamo_id)
            
            if prestamo.estado != 'activo':
                return ResultadoOperacion(
                    exito=False,
                    mensaje="El préstamo ya fue devuelto o está inactivo",
                    id=prestamo_id
                )
            
            # Registrar devolución
            from datetime import date
            prestamo.fecha_devolucion_real = date.today()
            prestamo.estado = 'devuelto'
            
            # Calcular multa si está vencido
            if prestamo.esta_vencido():
                dias_retraso = (date.today() - prestamo.fecha_devolucion_esperada).days
                prestamo.multa = dias_retraso * 10.00  # $10 por día
                prestamo.estado = 'vencido'
            
            prestamo.save()
            
            # Actualizar stock del libro
            libro = prestamo.libro
            libro.stock_disponible += 1
            if libro.stock_disponible > 0:
                libro.estado = 'disponible'
            libro.save()
            
            mensaje = f"Libro devuelto exitosamente"
            if prestamo.multa > 0:
                mensaje += f". Multa: ${prestamo.multa}"
            
            return ResultadoOperacion(
                exito=True,
                mensaje=mensaje,
                id=prestamo_id
            )
            
        except Prestamo.DoesNotExist:
            return ResultadoOperacion(exito=False, mensaje="Préstamo no encontrado", id=0)
        except Exception as e:
            return ResultadoOperacion(exito=False, mensaje=f"Error: {str(e)}", id=0)
    
    @rpc(Integer, _returns=Array(PrestamoModel))
    def obtener_prestamos_usuario(ctx, usuario_id):
        """Obtiene todos los préstamos de un usuario"""
        prestamos = Prestamo.objects.filter(usuario_id=usuario_id).select_related('libro', 'usuario')
        resultado = []
        
        for prestamo in prestamos:
            resultado.append(PrestamoModel(
                id=prestamo.id,
                libro_titulo=prestamo.libro.titulo,
                usuario_nombre=prestamo.usuario.get_full_name() or prestamo.usuario.username,
                fecha_prestamo=prestamo.fecha_prestamo,
                fecha_devolucion_esperada=str(prestamo.fecha_devolucion_esperada),
                fecha_devolucion_real=str(prestamo.fecha_devolucion_real) if prestamo.fecha_devolucion_real else '',
                estado=prestamo.estado,
                multa=str(prestamo.multa)
            ))
        
        return resultado
    
    @rpc(_returns=Array(PrestamoModel))
    def listar_prestamos_activos(ctx):
        """Lista todos los préstamos activos"""
        prestamos = Prestamo.objects.filter(estado='activo').select_related('libro', 'usuario')
        resultado = []
        
        for prestamo in prestamos:
            resultado.append(PrestamoModel(
                id=prestamo.id,
                libro_titulo=prestamo.libro.titulo,
                usuario_nombre=prestamo.usuario.get_full_name() or prestamo.usuario.username,
                fecha_prestamo=prestamo.fecha_prestamo,
                fecha_devolucion_esperada=str(prestamo.fecha_devolucion_esperada),
                fecha_devolucion_real='',
                estado=prestamo.estado,
                multa=str(prestamo.multa)
            ))
        
        return resultado
    
    # ===== SERVICIOS DE AUTORES =====
    
    @rpc(_returns=Array(AutorModel))
    def listar_autores(ctx):
        """Lista todos los autores"""
        autores = Autor.objects.all()
        resultado = []
        
        for autor in autores:
            resultado.append(AutorModel(
                id=autor.id,
                nombre=autor.nombre,
                apellido=autor.apellido,
                nacionalidad=autor.nacionalidad or '',
                biografia=autor.biografia or ''
            ))
        
        return resultado
    
    # ===== SERVICIOS DE CATEGORÍAS =====
    
    @rpc(_returns=Array(CategoriaModel))
    def listar_categorias(ctx):
        """Lista todas las categorías"""
        categorias = Categoria.objects.all()
        resultado = []
        
        for categoria in categorias:
            resultado.append(CategoriaModel(
                id=categoria.id,
                nombre=categoria.nombre,
                descripcion=categoria.descripcion or ''
            ))
        
        return resultado


# ===== CONFIGURACIÓN DE LA APLICACIÓN SOAP =====

soap_app = Application(
    [BibliotecaService],
    tns='biblioteca.soap.services',
    in_protocol=Soap11(validator='lxml'),
    out_protocol=Soap11()
)

# Vista Django para el servicio SOAP
django_soap_application = csrf_exempt(DjangoApplication(soap_app))

from django.shortcuts import render
from libros.models import Libro, Autor, Categoria, Prestamo

def home(request):
    """Vista de la página principal"""
    context = {
        'total_libros': Libro.objects.count(),
        'total_autores': Autor.objects.count(),
        'total_categorias': Categoria.objects.count(),
        'total_prestamos': Prestamo.objects.filter(estado='activo').count(),
    }
    return render(request, 'home.html', context)

def ejemplos_rest(request):
    return render(request, 'ejemplos_rest.html')

def ejemplos_soap(request):
    return render(request, 'ejemplos_soap.html')

def ejemplos_admin(request):
    return render(request, 'ejemplos_admin.html')

from django.contrib import admin
from .models import Autor, Categoria, Editorial, Libro, Prestamo

@admin.register(Autor)
class AutorAdmin(admin.ModelAdmin):
    list_display = ['nombre', 'apellido', 'nacionalidad', 'fecha_nacimiento']
    search_fields = ['nombre', 'apellido', 'nacionalidad']
    list_filter = ['nacionalidad']

@admin.register(Categoria)
class CategoriaAdmin(admin.ModelAdmin):
    list_display = ['nombre', 'descripcion']
    search_fields = ['nombre']

@admin.register(Editorial)
class EditorialAdmin(admin.ModelAdmin):
    list_display = ['nombre', 'pais', 'sitio_web']
    search_fields = ['nombre', 'pais']
    list_filter = ['pais']

@admin.register(Libro)
class LibroAdmin(admin.ModelAdmin):
    list_display = ['titulo', 'autor', 'categoria', 'stock_disponible', 'estado']
    search_fields = ['titulo', 'isbn', 'autor__nombre', 'autor__apellido']
    list_filter = ['categoria', 'editorial', 'estado', 'idioma']
    readonly_fields = ['fecha_registro']

@admin.register(Prestamo)
class PrestamoAdmin(admin.ModelAdmin):
    list_display = ['libro', 'usuario', 'fecha_prestamo', 
                    'fecha_devolucion_esperada', 'estado']
    search_fields = ['libro__titulo', 'usuario__username']
    list_filter = ['estado', 'fecha_prestamo']
    readonly_fields = ['fecha_prestamo']

from django.contrib import admin
from django.urls import path, include, re_path
from libros.soap_services import django_soap_application
from . import views

urlpatterns = [
    # Página principal
    path('', views.home, name='home'),
    
    # Páginas de ejemplos
    path('ejemplos/rest/', views.ejemplos_rest, name='ejemplos_rest'),
    path('ejemplos/soap/', views.ejemplos_soap, name='ejemplos_soap'),
    path('ejemplos/admin/', views.ejemplos_admin, name='ejemplos_admin'),
    
    # Admin
    path('admin/', admin.site.urls),
    
    # Servicio SOAP
    re_path(r'^soap/', django_soap_application),
    
    # API REST
    path('api/', include('libros.urls')),
]

"""
Script para poblar la base de datos con datos de prueba
Ejecutar con: python populate_db.py
"""
import os
import django
from datetime import date, timedelta

# Configurar Django
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'biblioteca_project.settings')
django.setup()

from django.contrib.auth.models import User
from libros.models import Autor, Editorial, Categoria, Libro, Prestamo


def crear_usuarios():
    """Crear usuarios de prueba"""
    print("Creando usuarios...")
    
    # Crear superusuario si no existe
    if not User.objects.filter(username='admin').exists():
        User.objects.create_superuser(
            username='admin',
            email='admin@biblioteca.com',
            password='admin123',
            first_name='Administrador',
            last_name='Sistema'
        )
        print("  ✓ Superusuario 'admin' creado (password: admin123)")
    
    # Crear usuarios normales
    usuarios_data = [
        {'username': 'juan_perez', 'email': 'juan@email.com', 'first_name': 'Juan', 'last_name': 'Pérez'},
        {'username': 'maria_lopez', 'email': 'maria@email.com', 'first_name': 'María', 'last_name': 'López'},
        {'username': 'carlos_ruiz', 'email': 'carlos@email.com', 'first_name': 'Carlos', 'last_name': 'Ruiz'},
    ]
    
    for user_data in usuarios_data:
        if not User.objects.filter(username=user_data['username']).exists():
            User.objects.create_user(
                password='user123',
                **user_data
            )
            print(f"  ✓ Usuario '{user_data['username']}' creado")


def crear_autores():
    """Crear autores de prueba"""
    print("\nCreando autores...")
    
    autores_data = [
        {
            'nombre': 'Gabriel',
            'apellido': 'García Márquez',
            'fecha_nacimiento': date(1927, 3, 6),
            'nacionalidad': 'Colombiano',
            'biografia': 'Premio Nobel de Literatura 1982. Autor de Cien años de soledad.'
        },
        {
            'nombre': 'Isabel',
            'apellido': 'Allende',
            'fecha_nacimiento': date(1942, 8, 2),
            'nacionalidad': 'Chilena',
            'biografia': 'Una de las novelistas más leídas en español. Autora de La casa de los espíritus.'
        },
        {
            'nombre': 'Jorge Luis',
            'apellido': 'Borges',
            'fecha_nacimiento': date(1899, 8, 24),
            'nacionalidad': 'Argentino',
            'biografia': 'Uno de los escritores más importantes del siglo XX en lengua española.'
        },
        {
            'nombre': 'Octavio',
            'apellido': 'Paz',
            'fecha_nacimiento': date(1914, 3, 31),
            'nacionalidad': 'Mexicano',
            'biografia': 'Premio Nobel de Literatura 1990. Ensayista y poeta mexicano.'
        },
        {
            'nombre': 'Mario',
            'apellido': 'Vargas Llosa',
            'fecha_nacimiento': date(1936, 3, 28),
            'nacionalidad': 'Peruano',
            'biografia': 'Premio Nobel de Literatura 2010. Autor de La ciudad y los perros.'
        },
    ]
    
    for autor_data in autores_data:
        autor, created = Autor.objects.get_or_create(
            nombre=autor_data['nombre'],
            apellido=autor_data['apellido'],
            defaults=autor_data
        )
        if created:
            print(f"  ✓ Autor '{autor}' creado")


def crear_editoriales():
    """Crear editoriales de prueba"""
    print("\nCreando editoriales...")
    
    editoriales_data = [
        {
            'nombre': 'Editorial Sudamericana',
            'pais': 'Argentina',
            'sitio_web': 'https://www.megustaleer.com.ar',
            'fecha_fundacion': date(1939, 1, 1)
        },
        {
            'nombre': 'Planeta',
            'pais': 'España',
            'sitio_web': 'https://www.planetadelibros.com',
            'fecha_fundacion': date(1949, 1, 1)
        },
        {
            'nombre': 'Alfaguara',
            'pais': 'España',
            'sitio_web': 'https://www.penguinrandomhouse.com',
            'fecha_fundacion': date(1964, 1, 1)
        },
        {
            'nombre': 'Anagrama',
            'pais': 'España',
            'sitio_web': 'https://www.anagrama-ed.es',
            'fecha_fundacion': date(1969, 1, 1)
        },
    ]
    
    for editorial_data in editoriales_data:
        editorial, created = Editorial.objects.get_or_create(
            nombre=editorial_data['nombre'],
            defaults=editorial_data
        )
        if created:
            print(f"  ✓ Editorial '{editorial}' creada")


def crear_categorias():
    """Crear categorías de prueba"""
    print("\nCreando categorías...")
    
    categorias_data = [
        {'nombre': 'Ficción', 'descripcion': 'Novelas y cuentos de ficción literaria'},
        {'nombre': 'Fantasía', 'descripcion': 'Literatura fantástica y de mundos imaginarios'},
        {'nombre': 'Ciencia Ficción', 'descripcion': 'Narrativa especulativa y futurista'},
        {'nombre': 'Romance', 'descripcion': 'Novelas románticas y de amor'},
        {'nombre': 'Misterio', 'descripcion': 'Novelas policiacas y de suspenso'},
        {'nombre': 'Terror', 'descripcion': 'Literatura de horror y terror'},
        {'nombre': 'Aventura', 'descripcion': 'Historias de aventuras y acción'},
        {'nombre': 'Historia', 'descripcion': 'Libros de historia y biografías'},
        {'nombre': 'Poesía', 'descripcion': 'Obras poéticas y antologías'},
        {'nombre': 'Ensayo', 'descripcion': 'Ensayos literarios y filosóficos'},
    ]
    
    for categoria_data in categorias_data:
        categoria, created = Categoria.objects.get_or_create(
            nombre=categoria_data['nombre'],
            defaults=categoria_data
        )
        if created:
            print(f"  ✓ Categoría '{categoria}' creada")


def crear_libros():
    """Crear libros de prueba"""
    print("\nCreando libros...")
    
    # Obtener datos existentes
    garcia_marquez = Autor.objects.get(apellido='García Márquez')
    allende = Autor.objects.get(apellido='Allende')
    borges = Autor.objects.get(apellido='Borges')
    paz = Autor.objects.get(apellido='Paz')
    vargas_llosa = Autor.objects.get(apellido='Vargas Llosa')
    
    sudamericana = Editorial.objects.get(nombre='Editorial Sudamericana')
    planeta = Editorial.objects.get(nombre='Planeta')
    alfaguara = Editorial.objects.get(nombre='Alfaguara')
    
    ficcion = Categoria.objects.get(nombre='Ficción')
    poesia = Categoria.objects.get(nombre='Poesía')
    ensayo = Categoria.objects.get(nombre='Ensayo')
    
    libros_data = [
        {
            'titulo': 'Cien años de soledad',
            'isbn': '9780307474728',
            'autor': garcia_marquez,
            'editorial': sudamericana,
            'categoria': ficcion,
            'fecha_publicacion': date(1967, 5, 30),
            'numero_paginas': 471,
            'idioma': 'Español',
            'descripcion': 'Obra maestra del realismo mágico que narra la historia de la familia Buendía.',
            'estado': 'disponible',
            'stock_total': 5,
            'stock_disponible': 3,
            'ubicacion_fisica': 'Estante A-12'
        },
        {
            'titulo': 'El amor en los tiempos del cólera',
            'isbn': '9780307387738',
            'autor': garcia_marquez,
            'editorial': sudamericana,
            'categoria': ficcion,
            'fecha_publicacion': date(1985, 1, 1),
            'numero_paginas': 368,
            'idioma': 'Español',
            'descripcion': 'Historia de amor que transcurre a lo largo de más de cincuenta años.',
            'estado': 'disponible',
            'stock_total': 3,
            'stock_disponible': 2,
            'ubicacion_fisica': 'Estante A-13'
        },
        {
            'titulo': 'La casa de los espíritus',
            'isbn': '9788401242281',
            'autor': allende,
            'editorial': planeta,
            'categoria': ficcion,
            'fecha_publicacion': date(1982, 1, 1),
            'numero_paginas': 433,
            'idioma': 'Español',
            'descripcion': 'Saga familiar chilena que mezcla lo cotidiano con lo maravilloso.',
            'estado': 'disponible',
            'stock_total': 4,
            'stock_disponible': 4,
            'ubicacion_fisica': 'Estante B-05'
        },
        {
            'titulo': 'Ficciones',
            'isbn': '9780802130303',
            'autor': borges,
            'editorial': sudamericana,
            'categoria': ficcion,
            'fecha_publicacion': date(1944, 1, 1),
            'numero_paginas': 174,
            'idioma': 'Español',
            'descripcion': 'Colección de cuentos que explora temas filosóficos y metafísicos.',
            'estado': 'disponible',
            'stock_total': 3,
            'stock_disponible': 1,
            'ubicacion_fisica': 'Estante C-08'
        },
        {
            'titulo': 'El laberinto de la soledad',
            'isbn': '9786071613578',
            'autor': paz,
            'editorial': sudamericana,
            'categoria': ensayo,
            'fecha_publicacion': date(1950, 1, 1),
            'numero_paginas': 191,
            'idioma': 'Español',
            'descripcion': 'Ensayo sobre la identidad mexicana y latinoamericana.',
            'estado': 'disponible',
            'stock_total': 2,
            'stock_disponible': 2,
            'ubicacion_fisica': 'Estante D-15'
        },
        {
            'titulo': 'La ciudad y los perros',
            'isbn': '9788420412146',
            'autor': vargas_llosa,
            'editorial': alfaguara,
            'categoria': ficcion,
            'fecha_publicacion': date(1963, 1, 1),
            'numero_paginas': 399,
            'idioma': 'Español',
            'descripcion': 'Novela ambientada en un colegio militar de Lima.',
            'estado': 'disponible',
            'stock_total': 4,
            'stock_disponible': 3,
            'ubicacion_fisica': 'Estante E-20'
        },
        {
            'titulo': 'Conversación en La Catedral',
            'isbn': '9788420412153',
            'autor': vargas_llosa,
            'editorial': alfaguara,
            'categoria': ficcion,
            'fecha_publicacion': date(1969, 1, 1),
            'numero_paginas': 729,
            'idioma': 'Español',
            'descripcion': 'Retrato crítico de la sociedad peruana bajo dictadura.',
            'estado': 'disponible',
            'stock_total': 2,
            'stock_disponible': 2,
            'ubicacion_fisica': 'Estante E-21'
        },
    ]
    
    for libro_data in libros_data:
        libro, created = Libro.objects.get_or_create(
            isbn=libro_data['isbn'],
            defaults=libro_data
        )
        if created:
            print(f"  ✓ Libro '{libro.titulo}' creado")


def crear_prestamos():
    """Crear préstamos de prueba"""
    print("\nCreando préstamos...")
    
    # Obtener usuarios y libros
    juan = User.objects.get(username='juan_perez')
    maria = User.objects.get(username='maria_lopez')
    
    cien_anos = Libro.objects.get(isbn='9780307474728')
    ficciones = Libro.objects.get(isbn='9780802130303')
    
    # Crear préstamos
    prestamos_data = [
        {
            'libro': cien_anos,
            'usuario': juan,
            'fecha_devolucion_esperada': date.today() + timedelta(days=14),
            'estado': 'activo'
        },
        {
            'libro': ficciones,
            'usuario': maria,
            'fecha_devolucion_esperada': date.today() + timedelta(days=7),
            'estado': 'activo'
        },
    ]
    
    for prestamo_data in prestamos_data:
        prestamo, created = Prestamo.objects.get_or_create(
            libro=prestamo_data['libro'],
            usuario=prestamo_data['usuario'],
            estado='activo',
            defaults=prestamo_data
        )
        if created:
            # Actualizar stock del libro
            libro = prestamo_data['libro']
            libro.stock_disponible -= 1
            if libro.stock_disponible == 0:
                libro.estado = 'prestado'
            libro.save()
            print(f"  ✓ Préstamo '{prestamo}' creado")


def main():
    """Función principal"""
    print("="*60)
    print("📚 POBLANDO BASE DE DATOS - Sistema de Biblioteca")
    print("="*60)
    
    try:
        crear_usuarios()
        crear_autores()
        crear_editoriales()
        crear_categorias()
        crear_libros()
        crear_prestamos()
        
        print("\n" + "="*60)
        print("✅ BASE DE DATOS POBLADA EXITOSAMENTE")
        print("="*60)
        print("\n📊 Resumen:")
        print(f"  • Usuarios: {User.objects.count()}")
        print(f"  • Autores: {Autor.objects.count()}")
        print(f"  • Editoriales: {Editorial.objects.count()}")
        print(f"  • Categorías: {Categoria.objects.count()}")
        print(f"  • Libros: {Libro.objects.count()}")
        print(f"  • Préstamos: {Prestamo.objects.count()}")
        print("\n🔑 Credenciales de acceso:")
        print("  Admin: username='admin', password='admin123'")
        print("  Usuarios: password='user123'")
        print("\n🌐 Accede al panel de administración en:")
        print("  http://localhost:8000/admin/")
        
    except Exception as e:
        print(f"\n❌ ERROR: {e}")
        import traceback
        traceback.print_exc()


if __name__ == '__main__':
    main()

================================================================================
🏛️  SISTEMA DE BIBLIOTECA - CLIENTE SOAP INTERACTIVO
================================================================================

📚 OPERACIONES DE LIBROS:
  1. Listar todos los libros
  2. Obtener libro por ID
  3. Buscar libros por título
  4. Buscar libros por autor (apellido)
  5. Buscar libros por categoría
  6. Listar libros disponibles

📋 OPERACIONES DE PRÉSTAMOS:
  7. Crear préstamo
  8. Devolver libro
  9. Ver préstamos de un usuario
 10. Listar préstamos activos

👥 OPERACIONES DE CATÁLOGOS:
 11. Listar autores
 12. Listar categorías

  0. Salir
================================================================================

📚 LISTANDO TODOS LOS LIBROS
--------------------------------------------------------------------------------
Total de libros: 7

ID:   1 | Cien años de soledad                       | Gabriel García Márquez    | Stock: 3
ID:   2 | El amor en los tiempos del cólera          | Gabriel García Márquez    | Stock: 2
ID:   3 | La casa de los espíritus                   | Isabel Allende            | Stock: 4
...

✅ Operación completada

🔍 BUSCAR LIBROS POR TÍTULO
--------------------------------------------------------------------------------
Ingrese el título o parte del título a buscar: soledad

✅ Se encontraron 1 libro(s):

ID:   1 | Cien años de soledad
       Autor: Gabriel García Márquez           | Stock: 3
--------------------------------------------------------------------------------

🔍 OBTENER LIBRO POR ID
--------------------------------------------------------------------------------
Ingrese el ID del libro: 1

📖 INFORMACIÓN DEL LIBRO:
  ID: 1
  Título: Cien años de soledad
  ISBN: 9780307474728
  Autor: Gabriel García Márquez
  Nacionalidad autor: Colombiano
  Editorial: Editorial Sudamericana
  País editorial: Argentina
  Categoría: Ficción
  Fecha publicación: 1967-05-30
  Páginas: 471
  Idioma: Español
  Estado: disponible
  Stock total: 5
  Stock disponible: 3
  Ubicación: Estante A-12
  Descripción: Obra maestra del realismo mágico...

✅ Libro encontrado

👤 BUSCAR LIBROS POR AUTOR
--------------------------------------------------------------------------------
Ingrese el apellido del autor: García Márquez

✅ Se encontraron 2 libro(s) del autor 'García Márquez':

ID:   1 | Cien años de soledad
       Autor: Gabriel García Márquez           | Stock: 3
       Editorial: Editorial Sudamericana      | Categoría: Ficción
--------------------------------------------------------------------------------
ID:   2 | El amor en los tiempos del cólera
       Autor: Gabriel García Márquez           | Stock: 2
       Editorial: Editorial Sudamericana      | Categoría: Ficción
--------------------------------------------------------------------------------

➕ CREAR PRÉSTAMO
--------------------------------------------------------------------------------
Ingrese el ID del libro: 3
Ingrese el ID del usuario: 2
Días de préstamo (7, 14, 21, 30): 14

✅ PRÉSTAMO CREADO EXITOSAMENTE
  ID Préstamo: 3
  Mensaje: Préstamo creado exitosamente

📋 PRÉSTAMOS ACTIVOS
--------------------------------------------------------------------------------
Total de préstamos activos: 3

ID:   1 | Cien años de soledad
       Usuario: juan_perez
       Prestado: 2026-02-02 | Devolver: 2026-02-16
--------------------------------------------------------------------------------
ID:   2 | Ficciones
       Usuario: maria_lopez
       Prestado: 2026-02-02 | Devolver: 2026-02-09
--------------------------------------------------------------------------------

{
    "titulo": "El principito",
    "isbn": "9788478887194",
    "autor": 1,
    "categoria": 1,
    "editorial": 1,
    "fecha_publicacion": "1943-04-06",
    "numero_paginas": 96,
    "idioma": "Español",
    "descripcion": "Novela corta del escritor francés Antoine de Saint-Exupéry",
    "stock_total": 5,
    "stock_disponible": 5,
    "estado": "disponible"
}

{
    "titulo": "Cien años de soledad",
    "isbn": "9780307474728",
    "autor": 1,
    "categoria": 1,
    "editorial": 1,
    "fecha_publicacion": "1967-05-30",
    "numero_paginas": 471,
    "idioma": "Español",
    "descripcion": "Obra maestra del realismo mágico",
    "stock_total": 5,
    "stock_disponible": 2,
    "estado": "disponible"
}

{
    "stock_disponible": 4,
    "estado": "disponible"
}

<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
               xmlns:bib="biblioteca.soap.services">
    <soap:Body>
        <bib:listar_libros/>
    </soap:Body>
</soap:Envelope>

<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
               xmlns:bib="biblioteca.soap.services">
    <soap:Body>
        <bib:obtener_libro>
            <bib:libro_id>1</bib:libro_id>
        </bib:obtener_libro>
    </soap:Body>
</soap:Envelope>

<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
               xmlns:bib="biblioteca.soap.services">
    <soap:Body>
        <bib:crear_prestamo>
            <bib:libro_id>2</bib:libro_id>
            <bib:usuario_id>1</bib:usuario_id>
            <bib:dias_prestamo>14</bib:dias_prestamo>
        </bib:crear_prestamo>
    </soap:Body>
</soap:Envelope>

# Dockerfile para Sistema de Biblioteca
# Basado en Python 3.11 (compatible con Spyne)

FROM python:3.11-slim

# Variables de entorno
ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1 \
    PIP_NO_CACHE_DIR=1 \
    PIP_DISABLE_PIP_VERSION_CHECK=1

# Información del mantenedor
LABEL maintainer="Sistema de Biblioteca U3"
LABEL description="Sistema de gestión de biblioteca con SOAP y REST API"

# Crear directorio de trabajo
WORKDIR /app

# Instalar dependencias del sistema necesarias para lxml y otras bibliotecas
RUN apt-get update && apt-get install -y \
    gcc \
    libxml2-dev \
    libxslt-dev \
    python3-dev \
    default-libmysqlclient-dev \
    pkg-config \
    && rm -rf /var/lib/apt/lists/*

# Copiar requirements primero (para aprovechar cache de Docker)
COPY requirements.txt .

# Instalar dependencias Python
RUN pip install --upgrade pip && \
    pip install -r requirements.txt

# Copiar el resto del código
COPY . .

# Crear directorio para archivos estáticos
RUN mkdir -p /app/staticfiles

# Recolectar archivos estáticos
RUN python manage.py collectstatic --noinput || true

# Exponer puerto
EXPOSE 8000

# Script de inicio que ejecuta migraciones y inicia el servidor
CMD ["sh", "-c", "python manage.py migrate && python manage.py runserver 0.0.0.0:8000"]

asgiref==3.11.0
attrs==25.4.0
certifi==2026.1.4
charset-normalizer==3.4.4
Django==5.2.10
django-filter==25.2
djangorestframework==3.14.0
idna==3.11
isodate==0.7.2
lxml==6.0.2
platformdirs==4.5.1
pytz==2025.2
requests==2.31.0
requests-file==3.0.1
requests-toolbelt==1.0.0
spyne==2.14.0
sqlparse==0.5.5
tzdata==2025.3
urllib3==2.6.3
zeep==4.2.1
pymysql==1.1.1
mysql-connector-python==9.5.0

# docker-compose.yml
# Orquestación multi-contenedor para Sistema de Biblioteca

version: '3.8'

services:
  # Base de datos MySQL
  db:
    image: mysql:8.0
    container_name: biblioteca_mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: root_password_123
      MYSQL_DATABASE: biblioteca_db
      MYSQL_USER: biblioteca_user
      MYSQL_PASSWORD: biblioteca_pass_123
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - biblioteca_network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-proot_password_123"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Aplicación Django
  web:
    build: .
    container_name: biblioteca_web
    restart: always
    command: sh -c "python manage.py migrate && python manage.py runserver 0.0.0.0:8000"
    volumes:
      - .:/app
      - static_volume:/app/staticfiles
    ports:
      - "8000:8000"
    environment:
      - DJANGO_SETTINGS_MODULE=biblioteca_project.settings
      - PYTHONUNBUFFERED=1
    depends_on:
      - db
    networks:
      - biblioteca_network

  # Nginx como balanceador de carga y servidor de archivos estáticos
  nginx:
    image: nginx:alpine
    container_name: biblioteca_nginx
    restart: always
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - static_volume:/usr/share/nginx/html/static:ro
    depends_on:
      - web
    networks:
      - biblioteca_network

  # Servicio adicional: Redis para caché (opcional pero útil)
  redis:
    image: redis:7-alpine
    container_name: biblioteca_redis
    restart: always
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - biblioteca_network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 3s
      retries: 3

# Volúmenes persistentes
volumes:
  mysql_data:
    driver: local
  static_volume:
    driver: local
  redis_data:
    driver: local

# Red personalizada
networks:
  biblioteca_network:
    driver: bridge

# Configuración de Nginx como balanceador de carga y proxy reverso

user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;

events {
    worker_connections 1024;
}

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';

    access_log /var/log/nginx/access.log main;

    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;

    # Compresión
    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;

    # Upstream para balanceo de carga
    upstream django_backend {
        least_conn;
        server web:8000 weight=1 max_fails=3 fail_timeout=30s;
    }

    # Servidor principal
    server {
        listen 80;
        server_name localhost;
        client_max_body_size 20M;

        # Health check endpoint
        location /health {
            access_log off;
            return 200 "healthy\n";
            add_header Content-Type text/plain;
        }

        # Archivos estáticos
        location /static/ {
            alias /usr/share/nginx/html/static/;
            expires 30d;
            add_header Cache-Control "public, immutable";
        }

        # Admin de Django
        location /admin/ {
            proxy_pass http://django_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_redirect off;
        }

        # API REST
        location /api/ {
            proxy_pass http://django_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_redirect off;
        }

        # Servicio SOAP
        location /soap/ {
            proxy_pass http://django_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_redirect off;
        }

        # Todas las demás solicitudes
        location / {
            proxy_pass http://django_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_redirect off;
        }

        # Página de error
        error_page 500 502 503 504 /50x.html;
        location = /50x.html {
            root /usr/share/nginx/html;
        }
    }
}

# docker-compose.scale.yml
# Configuración para escalar múltiples instancias de Django

version: '3.8'

services:
  db:
    image: mysql:8.0
    container_name: biblioteca_mysql
    restart: always
    command: --default-authentication-plugin=mysql_native_password
    environment:
      MYSQL_ROOT_PASSWORD: root_password_123
      MYSQL_DATABASE: biblioteca_db
      MYSQL_USER: biblioteca_user
      MYSQL_PASSWORD: biblioteca_pass_123
    ports:
      - "3307:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - biblioteca_network

  web:
    build: .
    restart: always
    command: sh -c "python manage.py migrate && python manage.py runserver 0.0.0.0:8000"
    volumes:
      - .:/app
      - static_volume:/app/staticfiles
    environment:
      - DJANGO_SETTINGS_MODULE=biblioteca_project.settings
      - PYTHONUNBUFFERED=1
    depends_on:
      - db
      - redis
    networks:
      - biblioteca_network
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '0.5'
          memory: 512M

  nginx:
    image: nginx:alpine
    container_name: biblioteca_nginx_lb
    restart: always
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - static_volume:/usr/share/nginx/html/static:ro
    depends_on:
      - web
    networks:
      - biblioteca_network

  redis:
    image: redis:7-alpine
    container_name: biblioteca_redis
    restart: always
    command: redis-server --appendonly yes
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - biblioteca_network

volumes:
  mysql_data:
  static_volume:
  redis_data:

networks:
  biblioteca_network:
    driver: bridge

USE_TZ = False
TIME_ZONE = 'America/Hermosillo'

#!/usr/bin/env python3
"""
Cliente SOAP Visual - Sistema de Biblioteca
Ejecuta operaciones y muestra XML en navegador
"""

from zeep import Client, Settings
from zeep.exceptions import Fault
from zeep.plugins import HistoryPlugin
import sys
import webbrowser
import os
import tempfile
from datetime import datetime
from lxml import etree

WSDL_URL = 'http://127.0.0.1:8000/soap/?wsdl'

# Plugin para capturar mensajes SOAP
history = HistoryPlugin()

def crear_cliente():
    """Crea cliente SOAP con configuración optimizada"""
    try:
        settings = Settings(strict=False, xml_huge_tree=True, xsd_ignore_sequence_order=True)
        client = Client(WSDL_URL, settings=settings, plugins=[history])
        return client
    except Exception as e:
        print(f"❌ Error al conectar con el servidor SOAP: {e}")
        print("\n💡 Asegúrate de que el servidor Django esté corriendo:")
        print("   python manage.py runserver")
        sys.exit(1)

def formatear_xml(xml_string):
    """Formatea XML para mejor visualización"""
    try:
        parser = etree.XMLParser(remove_blank_text=True)
        root = etree.fromstring(xml_string, parser)
        return etree.tostring(root, pretty_print=True, encoding='unicode')
    except:
        return xml_string

def mostrar_xml_en_navegador(request_xml, response_xml, operacion):
    """Genera HTML con XML SOAP y lo abre en navegador"""
    import html
    
    request_formatted = formatear_xml(request_xml)
    response_formatted = formatear_xml(response_xml)
    
    request_escaped = html.escape(request_formatted)
    response_escaped = html.escape(response_formatted)
    
    html_content = f"""
<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <title>🔍 XML SOAP - {operacion}</title>
    <style>
        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
        body {{ font-family: 'Segoe UI', sans-serif; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 20px; min-height: 100vh; }}
        .container {{ max-width: 1600px; margin: 0 auto; background: white; border-radius: 15px; box-shadow: 0 20px 60px rgba(0,0,0,0.3); overflow: hidden; }}
        .header {{ background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px 40px; text-align: center; }}
        .header h1 {{ font-size: 2.5em; margin-bottom: 10px; text-shadow: 2px 2px 4px rgba(0,0,0,0.2); }}
        .header .info {{ font-size: 1.1em; opacity: 0.95; margin: 5px 0; }}
        .content {{ padding: 40px; }}
        .section {{ margin-bottom: 40px; }}
        .section-title {{ background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 15px 25px; border-radius: 10px; font-size: 1.5em; margin-bottom: 20px; display: flex; align-items: center; box-shadow: 0 4px 15px rgba(102, 126, 234, 0.3); }}
        .section-title .icon {{ margin-right: 15px; font-size: 1.5em; }}
        .xml-container {{ background: #1e1e1e; border-radius: 10px; padding: 25px; overflow-x: auto; box-shadow: inset 0 2px 10px rgba(0,0,0,0.3); max-height: 600px; overflow-y: auto; }}
        pre {{ margin: 0; color: #d4d4d4; font-family: 'Consolas', 'Monaco', monospace; font-size: 0.95em; line-height: 1.6; white-space: pre-wrap; word-wrap: break-word; }}
        .copy-btn {{ background: #4CAF50; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; font-size: 1em; margin-top: 15px; transition: all 0.3s; box-shadow: 0 4px 10px rgba(76, 175, 80, 0.3); }}
        .copy-btn:hover {{ background: #45a049; transform: translateY(-2px); box-shadow: 0 6px 15px rgba(76, 175, 80, 0.4); }}
        .stats {{ display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin-bottom: 30px; }}
        .stat-card {{ background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 10px; text-align: center; box-shadow: 0 4px 15px rgba(102, 126, 234, 0.3); }}
        .stat-card .value {{ font-size: 2em; font-weight: bold; margin-bottom: 5px; }}
        .stat-card .label {{ font-size: 0.9em; opacity: 0.9; }}
        .footer {{ text-align: center; padding: 20px; background: #f5f5f5; color: #666; font-size: 0.9em; }}
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>🔍 Visualizador de XML SOAP</h1>
            <div class="info"><strong>Operación:</strong> {operacion}</div>
            <div class="info"><strong>Timestamp:</strong> {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</div>
            <div class="info"><strong>Servidor:</strong> {WSDL_URL}</div>
        </div>
        <div class="content">
            <div class="stats">
                <div class="stat-card"><div class="value">{len(request_xml)}</div><div class="label">Bytes Request</div></div>
                <div class="stat-card"><div class="value">{len(response_xml)}</div><div class="label">Bytes Response</div></div>
                <div class="stat-card"><div class="value">{request_formatted.count('<')}</div><div class="label">Tags Request</div></div>
                <div class="stat-card"><div class="value">{response_formatted.count('<')}</div><div class="label">Tags Response</div></div>
            </div>
            <div class="section">
                <div class="section-title"><span class="icon">📤</span><span>SOAP Request</span></div>
                <div class="xml-container"><pre id="request-xml">{request_escaped}</pre></div>
                <button class="copy-btn" onclick="copyToClipboard('request-xml')">📋 Copiar Request</button>
            </div>
            <div class="section">
                <div class="section-title"><span class="icon">📥</span><span>SOAP Response</span></div>
                <div class="xml-container"><pre id="response-xml">{response_escaped}</pre></div>
                <button class="copy-btn" onclick="copyToClipboard('response-xml')">📋 Copiar Response</button>
            </div>
        </div>
        <div class="footer">Sistema de Biblioteca - Cliente SOAP Visual<br>Universidad Tecnológica de Hermosillo</div>
    </div>
    <script>
        function copyToClipboard(elementId) {{
            const text = document.getElementById(elementId).textContent;
            navigator.clipboard.writeText(text).then(() => {{
                const btn = event.target;
                const originalText = btn.textContent;
                btn.textContent = '✅ Copiado!';
                btn.style.background = '#2196F3';
                setTimeout(() => {{ btn.textContent = originalText; btn.style.background = '#4CAF50'; }}, 2000);
            }}).catch(err => {{ alert('Error al copiar: ' + err); }});
        }}
    </script>
</body>
</html>
"""
    
    # Guardar HTML en archivo temporal y abrirlo
    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.html', encoding='utf-8') as f:
        f.write(html_content)
        temp_file = f.name
    
    print(f"\n🌐 Abriendo visualizador XML en el navegador...")
    webbrowser.open('file://' + os.path.abspath(temp_file))

def preguntar_ver_xml():
    """Pregunta si desea ver el XML"""
    print("\n" + "="*80)
    respuesta = input("¿Desea ver el XML SOAP en el navegador? (s/n): ").strip().lower()
    return respuesta in ['s', 'si', 'sí', 'y', 'yes']

# ===== FUNCIONES DE OPERACIONES =====

def listar_libros(client):
    """Lista todos los libros"""
    print("\n" + "="*80)
    print("📚 LISTANDO TODOS LOS LIBROS")
    print("="*80)
    
    try:
        result = client.service.listar_libros()
        
        if not result:
            print("\n⚠️  No hay libros registrados en la biblioteca")
            return
        
        print(f"\n✅ Se encontraron {len(result)} libros:\n")
        
        for i, libro in enumerate(result, 1):
            print(f"\n{i}. 📖 {libro.titulo}")
            print(f"   ID: {libro.id}")
            print(f"   📝 ISBN: {libro.isbn}")
            print(f"   ✍️  Autor: {libro.autor_nombre}")
            print(f"   📚 Editorial: {libro.editorial_nombre}")
            print(f"   🏷️  Categoría: {libro.categoria_nombre}")
            print(f"   📅 Publicación: {libro.fecha_publicacion}")
            print(f"   📄 Páginas: {libro.numero_paginas}")
            print(f"   🌐 Idioma: {libro.idioma}")
            print(f"   📊 Estado: {libro.estado}")
            print(f"   📦 Disponibles: {libro.stock_disponible}")
            if libro.ubicacion_fisica:
                print(f"   📍 Ubicación: {libro.ubicacion_fisica}")
            if libro.descripcion:
                print(f"   📖 Descripción: {libro.descripcion[:100]}...")
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, "listar_libros")
            
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def obtener_libro(client):
    """Obtiene detalles de un libro por ID"""
    print("\n" + "="*80)
    print("🔍 OBTENER LIBRO POR ID")
    print("="*80)
    
    try:
        libro_id = int(input("\nIngrese el ID del libro: "))
        result = client.service.obtener_libro(libro_id)
        
        if not result:
            print(f"\n⚠️  No se encontró libro con ID {libro_id}")
            return
        
        print(f"\n✅ Libro encontrado:\n")
        print(f"📖 {result.titulo}")
        print(f"ID: {result.id}")
        print(f"📝 ISBN: {result.isbn}")
        print(f"\n👤 AUTOR:")
        print(f"   Nombre: {result.autor.nombre} {result.autor.apellido}")
        print(f"   Nacionalidad: {result.autor.nacionalidad}")
        print(f"   Biografía: {result.autor.biografia[:100] if result.autor.biografia else 'N/A'}...")
        print(f"\n🏢 EDITORIAL:")
        print(f"   Nombre: {result.editorial.nombre}")
        print(f"   País: {result.editorial.pais}")
        print(f"   Web: {result.editorial.sitio_web}")
        print(f"\n🏷️  CATEGORÍA:")
        print(f"   Nombre: {result.categoria.nombre}")
        print(f"   Descripción: {result.categoria.descripcion}")
        print(f"\n📄 DETALLES:")
        print(f"   Páginas: {result.numero_paginas}")
        print(f"   Idioma: {result.idioma}")
        print(f"   Publicación: {result.fecha_publicacion}")
        print(f"   Registro: {result.fecha_registro}")
        print(f"   Estado: {result.estado}")
        print(f"   Stock Total: {result.stock_total}")
        print(f"   Stock Disponible: {result.stock_disponible}")
        print(f"   Ubicación: {result.ubicacion_fisica}")
        print(f"\n📖 Descripción:")
        print(f"   {result.descripcion}")
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, f"obtener_libro (ID: {libro_id})")
            
    except ValueError:
        print("\n❌ Error: Debe ingresar un número válido")
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def buscar_libros_por_titulo(client):
    """Busca libros por título"""
    print("\n" + "="*80)
    print("🔍 BUSCAR LIBROS POR TÍTULO")
    print("="*80)
    
    titulo = input("\nIngrese texto a buscar en el título: ").strip()
    
    if not titulo:
        print("\n❌ Debe ingresar un texto para buscar")
        return
    
    try:
        result = client.service.buscar_libros_por_titulo(titulo)
        
        if not result:
            print(f"\n⚠️  No se encontraron libros con '{titulo}' en el título")
            return
        
        print(f"\n✅ Se encontraron {len(result)} libros:\n")
        
        for i, libro in enumerate(result, 1):
            print(f"{i}. 📖 {libro.titulo}")
            print(f"   Autor: {libro.autor_nombre} | Categoría: {libro.categoria_nombre}")
            print(f"   Estado: {libro.estado} | Disponibles: {libro.stock_disponible}")
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, f"buscar_libros_por_titulo ('{titulo}')")
            
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def buscar_libros_por_autor(client):
    """Busca libros por apellido del autor"""
    print("\n" + "="*80)
    print("🔍 BUSCAR LIBROS POR AUTOR")
    print("="*80)
    
    apellido = input("\nIngrese el apellido del autor: ").strip()
    
    if not apellido:
        print("\n❌ Debe ingresar un apellido")
        return
    
    try:
        result = client.service.buscar_libros_por_autor(apellido)
        
        if not result:
            print(f"\n⚠️  No se encontraron libros del autor '{apellido}'")
            return
        
        print(f"\n✅ Se encontraron {len(result)} libros:\n")
        
        for i, libro in enumerate(result, 1):
            print(f"{i}. 📖 {libro.titulo}")
            print(f"   Autor: {libro.autor_nombre}")
            print(f"   Categoría: {libro.categoria_nombre} | Año: {libro.fecha_publicacion}")
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, f"buscar_libros_por_autor ('{apellido}')")
            
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def buscar_libros_por_categoria(client):
    """Busca libros por categoría"""
    print("\n" + "="*80)
    print("🔍 BUSCAR LIBROS POR CATEGORÍA")
    print("="*80)
    
    categoria = input("\nIngrese el nombre de la categoría: ").strip()
    
    if not categoria:
        print("\n❌ Debe ingresar una categoría")
        return
    
    try:
        result = client.service.buscar_libros_por_categoria(categoria)
        
        if not result:
            print(f"\n⚠️  No se encontraron libros en la categoría '{categoria}'")
            return
        
        print(f"\n✅ Se encontraron {len(result)} libros:\n")
        
        for i, libro in enumerate(result, 1):
            print(f"{i}. 📖 {libro.titulo}")
            print(f"   Autor: {libro.autor_nombre}")
            print(f"   Disponibles: {libro.stock_disponible} | Estado: {libro.estado}")
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, f"buscar_libros_por_categoria ('{categoria}')")
            
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def listar_libros_disponibles(client):
    """Lista libros disponibles"""
    print("\n" + "="*80)
    print("📚 LIBROS DISPONIBLES PARA PRÉSTAMO")
    print("="*80)
    
    try:
        result = client.service.listar_libros_disponibles()
        
        if not result:
            print("\n⚠️  No hay libros disponibles actualmente")
            return
        
        print(f"\n✅ Se encontraron {len(result)} libros disponibles:\n")
        
        for i, libro in enumerate(result, 1):
            print(f"{i}. 📖 {libro.titulo}")
            print(f"   ID: {libro.id} | Autor: {libro.autor_nombre}")
            print(f"   Disponibles: {libro.stock_disponible} unidades")
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, "listar_libros_disponibles")
            
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def crear_prestamo(client):
    """Crea un nuevo préstamo"""
    print("\n" + "="*80)
    print("➕ CREAR NUEVO PRÉSTAMO")
    print("="*80)
    
    try:
        libro_id = int(input("\nID del libro: "))
        usuario_id = int(input("ID del usuario: "))
        dias = int(input("Días de préstamo (ej: 14): "))
        
        result = client.service.crear_prestamo(libro_id, usuario_id, dias)
        
        if result.exito:
            print(f"\n✅ {result.mensaje}")
            print(f"   ID del préstamo: {result.id}")
        else:
            print(f"\n❌ {result.mensaje}")
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, "crear_prestamo")
            
    except ValueError:
        print("\n❌ Error: Debe ingresar números válidos")
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def devolver_libro(client):
    """Registra devolución de libro"""
    print("\n" + "="*80)
    print("📥 DEVOLVER LIBRO")
    print("="*80)
    
    try:
        prestamo_id = int(input("\nID del préstamo: "))
        
        result = client.service.devolver_libro(prestamo_id)
        
        if result.exito:
            print(f"\n✅ {result.mensaje}")
        else:
            print(f"\n❌ {result.mensaje}")
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, "devolver_libro")
            
    except ValueError:
        print("\n❌ Error: Debe ingresar un número válido")
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def ver_prestamos_usuario(client):
    """Ver préstamos de un usuario"""
    print("\n" + "="*80)
    print("👤 PRÉSTAMOS DE USUARIO")
    print("="*80)
    
    try:
        usuario_id = int(input("\nID del usuario: "))
        
        result = client.service.obtener_prestamos_usuario(usuario_id)
        
        if not result:
            print(f"\n⚠️  El usuario no tiene préstamos registrados")
            return
        
        print(f"\n✅ Se encontraron {len(result)} préstamos:\n")
        
        for i, prestamo in enumerate(result, 1):
            print(f"{i}. 📖 {prestamo.libro_titulo}")
            print(f"   ID: {prestamo.id} | Usuario: {prestamo.usuario_nombre}")
            print(f"   Préstamo: {prestamo.fecha_prestamo}")
            print(f"   Devolución esperada: {prestamo.fecha_devolucion_esperada}")
            if prestamo.fecha_devolucion_real:
                print(f"   Devuelto: {prestamo.fecha_devolucion_real}")
            print(f"   Estado: {prestamo.estado}")
            if prestamo.multa and float(prestamo.multa) > 0:
                print(f"   💰 Multa: ${prestamo.multa}")
            print()
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, f"obtener_prestamos_usuario (ID: {usuario_id})")
            
    except ValueError:
        print("\n❌ Error: Debe ingresar un número válido")
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def listar_prestamos_activos(client):
    """Lista préstamos activos"""
    print("\n" + "="*80)
    print("📋 PRÉSTAMOS ACTIVOS")
    print("="*80)
    
    try:
        result = client.service.listar_prestamos_activos()
        
        if not result:
            print("\n⚠️  No hay préstamos activos")
            return
        
        print(f"\n✅ Se encontraron {len(result)} préstamos activos:\n")
        
        for i, prestamo in enumerate(result, 1):
            print(f"{i}. 📖 {prestamo.libro_titulo}")
            print(f"   Usuario: {prestamo.usuario_nombre}")
            print(f"   Debe devolver: {prestamo.fecha_devolucion_esperada}")
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, "listar_prestamos_activos")
            
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def listar_autores(client):
    """Lista todos los autores"""
    print("\n" + "="*80)
    print("👥 LISTADO DE AUTORES")
    print("="*80)
    
    try:
        result = client.service.listar_autores()
        
        if not result:
            print("\n⚠️  No hay autores registrados")
            return
        
        print(f"\n✅ Se encontraron {len(result)} autores:\n")
        
        for i, autor in enumerate(result, 1):
            print(f"{i}. {autor.nombre} {autor.apellido}")
            print(f"   ID: {autor.id} | Nacionalidad: {autor.nacionalidad}")
            if autor.biografia:
                print(f"   Bio: {autor.biografia[:80]}...")
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, "listar_autores")
            
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def listar_categorias(client):
    """Lista todas las categorías"""
    print("\n" + "="*80)
    print("🏷️  LISTADO DE CATEGORÍAS")
    print("="*80)
    
    try:
        result = client.service.listar_categorias()
        
        if not result:
            print("\n⚠️  No hay categorías registradas")
            return
        
        print(f"\n✅ Se encontraron {len(result)} categorías:\n")
        
        for i, cat in enumerate(result, 1):
            print(f"{i}. {cat.nombre}")
            print(f"   ID: {cat.id}")
            if cat.descripcion:
                print(f"   Descripción: {cat.descripcion}")
        
        if preguntar_ver_xml():
            request_xml = etree.tostring(history.last_sent['envelope'], encoding='unicode', pretty_print=True)
            response_xml = etree.tostring(history.last_received['envelope'], encoding='unicode', pretty_print=True)
            mostrar_xml_en_navegador(request_xml, response_xml, "listar_categorias")
            
    except Fault as e:
        print(f"\n❌ Error SOAP: {e}")
    except Exception as e:
        print(f"\n❌ Error: {e}")

def mostrar_menu():
    """Muestra el menú principal"""
    print("\n" + "="*80)
    print("🏛️  SISTEMA DE BIBLIOTECA - CLIENTE SOAP INTERACTIVO")
    print("="*80)
    print("\n📚 OPERACIONES DE LIBROS:")
    print("  1. Listar todos los libros")
    print("  2. Obtener libro por ID")
    print("  3. Buscar libros por título")
    print("  4. Buscar libros por autor (apellido)")
    print("  5. Buscar libros por categoría")
    print("  6. Listar libros disponibles")
    print("\n📋 OPERACIONES DE PRÉSTAMOS:")
    print("  7. Crear préstamo")
    print("  8. Devolver libro")
    print("  9. Ver préstamos de un usuario")
    print(" 10. Listar préstamos activos")
    print("\n👥 OPERACIONES DE CATÁLOGOS:")
    print(" 11. Listar autores")
    print(" 12. Listar categorías")
    print("\n  0. Salir")
    print("="*80)

def main():
    """Función principal"""
    print("\n🔌 Conectando al servidor SOAP...")
    client = crear_cliente()
    print("✅ Conexión establecida")
    
    operaciones = {
        '1': listar_libros,
        '2': obtener_libro,
        '3': buscar_libros_por_titulo,
        '4': buscar_libros_por_autor,
        '5': buscar_libros_por_categoria,
        '6': listar_libros_disponibles,
        '7': crear_prestamo,
        '8': devolver_libro,
        '9': ver_prestamos_usuario,
        '10': listar_prestamos_activos,
        '11': listar_autores,
        '12': listar_categorias,
    }
    
    while True:
        mostrar_menu()
        opcion = input("\nSeleccione una opción: ").strip()
        
        if opcion == '0':
            print("\n👋 ¡Hasta luego!")
            break
        
        if opcion in operaciones:
            operaciones[opcion](client)
        else:
            print("\n❌ Opción inválida")
        
        input("\n⏎ Presione Enter para continuar...")

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        print("\n\n👋 ¡Hasta luego!")
        sys.exit(0)

"""
Script para arreglar el problema del módulo cgi en Spyne para Python 3.13+
El módulo cgi fue eliminado en Python 3.13, este script lo reemplaza con email.message
"""
import os
import sys

def find_spyne_path():
    """Encuentra la ruta del paquete spyne"""
    try:
        import spyne
        return os.path.dirname(spyne.__file__)
    except ImportError:
        print("❌ Error: Spyne no está instalado")
        sys.exit(1)

def patch_wsgi_file(spyne_path):
    """Parchea el archivo wsgi.py que usa cgi"""
    wsgi_file = os.path.join(spyne_path, 'server', 'wsgi.py')
    
    if not os.path.exists(wsgi_file):
        print(f"❌ No se encontró: {wsgi_file}")
        return False
    
    print(f"📝 Parcheando: {wsgi_file}")
    
    with open(wsgi_file, 'r', encoding='utf-8') as f:
        content = f.read()
    
    # Reemplazar import cgi
    if 'import cgi' in content:
        # Agregar el import de email.message al inicio si no existe
        if 'from email.message import Message' not in content:
            content = content.replace(
                'import cgi',
                'from email.message import Message'
            )
        
        # Reemplazar cgi.parse_header con parse_header_value
        content = content.replace(
            'cgi.parse_header(',
            'parse_header_value('
        )
        
        # Agregar la función parse_header_value si no existe
        if 'def parse_header_value' not in content:
            helper_function = '''

def parse_header_value(value):
    """Parse header value like cgi.parse_header() did"""
    if not value:
        return '', {}
    
    msg = Message()
    msg['content-type'] = value
    params = msg.get_params()
    
    if params:
        maintype = params[0][0]
        pdict = dict(params[1:])
        return maintype, pdict
    else:
        return value.strip(), {}

'''
            # Insertar la función helper después de los imports
            import_end = content.find('\n\nclass') if '\n\nclass' in content else content.find('\n\ndef')
            if import_end != -1:
                content = content[:import_end] + helper_function + content[import_end:]
        
        # Guardar archivo modificado
        with open(wsgi_file, 'w', encoding='utf-8') as f:
            f.write(content)
        
        print(f"✅ Archivo parcheado exitosamente")
        return True
    else:
        print(f"ℹ️  El archivo ya no usa 'import cgi'")
        return False

def patch_soap11_file(spyne_path):
    """Parchea el archivo soap11.py si es necesario"""
    soap11_file = os.path.join(spyne_path, 'protocol', 'soap', 'soap11.py')
    
    if not os.path.exists(soap11_file):
        print(f"⚠️  No se encontró: {soap11_file}")
        return False
    
    print(f"📝 Verificando: {soap11_file}")
    
    with open(soap11_file, 'r', encoding='utf-8') as f:
        content = f.read()
    
    if 'import cgi' in content and 'from email.message import Message' not in content:
        content = content.replace(
            'import cgi',
            'from email.message import Message'
        )
        
        # Si se usa cgi.parse_header, agregar la función helper
        if 'cgi.parse_header' in content:
            content = content.replace('cgi.parse_header(', 'parse_header_value(')
            
            helper_function = '''

def parse_header_value(value):
    """Parse header value like cgi.parse_header() did"""
    if not value:
        return '', {}
    
    msg = Message()
    msg['content-type'] = value
    params = msg.get_params()
    
    if params:
        maintype = params[0][0]
        pdict = dict(params[1:])
        return maintype, pdict
    else:
        return value.strip(), {}

'''
            import_end = content.find('\n\nclass') if '\n\nclass' in content else content.find('\n\ndef')
            if import_end != -1:
                content = content[:import_end] + helper_function + content[import_end:]
        
        with open(soap11_file, 'w', encoding='utf-8') as f:
            f.write(content)
        
        print(f"✅ Archivo parcheado exitosamente")
        return True
    else:
        print(f"ℹ️  El archivo no necesita parches")
        return False

def main():
    print("="*70)
    print("🔧 PARCHE PARA SPYNE - Python 3.13+ (Problema del módulo cgi)")
    print("="*70)
    
    spyne_path = find_spyne_path()
    print(f"\n📦 Spyne encontrado en: {spyne_path}")
    print(f"🐍 Python: {sys.version}\n")
    
    patched_count = 0
    
    # Parchear wsgi.py
    if patch_wsgi_file(spyne_path):
        patched_count += 1
    
    print()
    
    # Parchear soap11.py
    if patch_soap11_file(spyne_path):
        patched_count += 1
    
    print("\n" + "="*70)
    if patched_count > 0:
        print(f"✅ {patched_count} archivo(s) parcheado(s) exitosamente")
        print("\n💡 Reinicia el servidor Django para aplicar los cambios:")
        print("   python manage.py runserver")
    else:
        print("ℹ️  No se encontraron archivos que necesiten parches")
    print("="*70)

if __name__ == '__main__':
    main()

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Visualizador SOAP - Obtener libro por ID (1)</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }

        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            padding: 20px;
            color: #333;
        }

        .container {
            max-width: 1400px;
            margin: 0 auto;
            background: white;
            border-radius: 15px;
            box-shadow: 0 20px 60px rgba(0,0,0,0.3);
            overflow: hidden;
        }

        .header {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 30px 40px;
            text-align: center;
        }

        .header h1 {
            font-size: 2.5em;
            margin-bottom: 10px;
            text-shadow: 2px 2px 4px rgba(0,0,0,0.2);
        }

        .section-title {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 15px 25px;
            border-radius: 10px;
            font-size: 1.5em;
            margin-bottom: 20px;
            display: flex;
            align-items: center;
            justify-content: space-between;
        }

        .xml-container {
            background: #1e1e1e;
            border-radius: 10px;
            padding: 25px;
            overflow-x: auto;
        }

        pre {
            margin: 0;
            color: #f8f8f2;
            font-family: 'Consolas', 'Monaco', monospace;
            font-size: 0.9em;
            line-height: 1.6;
        }

        .btn-copy {
            background: white;
            color: #667eea;
            border: 2px solid #667eea;
            padding: 8px 20px;
            border-radius: 20px;
            cursor: pointer;
            font-weight: 600;
        }

        .stats {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 20px;
            margin-bottom: 30px;
        }

        .stat-card {
            background: #f8f9fa;
            padding: 20px;
            border-radius: 10px;
            text-align: center;
        }

        .stat-card .value {
            color: #667eea;
            font-size: 1.8em;
            font-weight: bold;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>📡 Visualizador de Mensajes SOAP</h1>
            <p>⏰ Generado: 03/02/2026 17:40:32</p>
        </div>

        <div style="padding: 40px;">
            <div class="stats">
                <div class="stat-card">
                    <div>Tamaño Request</div>
                    <div class="value">260</div>
                    <div>bytes</div>
                </div>
                <div class="stat-card">
                    <div>Tamaño Response</div>
                    <div class="value">1760</div>
                    <div>bytes</div>
                </div>
                <div class="stat-card">
                    <div>Protocolo</div>
                    <div class="value">SOAP</div>
                    <div>1.1</div>
                </div>
                <div class="stat-card">
                    <div>Formato</div>
                    <div class="value">XML</div>
                    <div>UTF-8</div>
                </div>
            </div>

            <div style="margin-bottom: 40px;">
                <div class="section-title">
                    <span>📤 Solicitud SOAP (Request)</span>
                    <button class="btn-copy" onclick="copiarTexto('request-xml')">📋 Copiar</button>
                </div>
                <div class="xml-container">
                    <pre id="request-xml">&lt;soap-env:Envelope xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/"&gt;
  &lt;soap-env:Body&gt;
    &lt;ns0:obtener_libro xmlns:ns0="biblioteca.soap.services"&gt;
      &lt;ns0:libro_id&gt;1&lt;/ns0:libro_id&gt;
    &lt;/ns0:obtener_libro&gt;
  &lt;/soap-env:Body&gt;
&lt;/soap-env:Envelope&gt;</pre>
                </div>
            </div>

            <div>
                <div class="section-title">
                    <span>📥 Respuesta SOAP (Response)</span>
                    <button class="btn-copy" onclick="copiarTexto('response-xml')">📋 Copiar</button>
                </div>
                <div class="xml-container">
                    <pre id="response-xml">&lt;soap11env:Envelope xmlns:soap11env="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tns="biblioteca.soap.services" xmlns:s0="libros.soap_services"&gt;
  &lt;soap11env:Body&gt;
    &lt;tns:obtener_libroResponse&gt;
      &lt;tns:obtener_libroResult&gt;
        &lt;s0:id&gt;1&lt;/s0:id&gt;
        &lt;s0:titulo&gt;Cien años de soledad&lt;/s0:titulo&gt;
        &lt;s0:isbn&gt;9780307474728&lt;/s0:isbn&gt;
        &lt;s0:numero_paginas&gt;471&lt;/s0:numero_paginas&gt;
        &lt;s0:idioma&gt;Español&lt;/s0:idioma&gt;
        &lt;s0:descripcion&gt;Obra maestra del realismo mágico.&lt;/s0:descripcion&gt;
        &lt;s0:estado&gt;prestado&lt;/s0:estado&gt;
        &lt;s0:stock_total&gt;5&lt;/s0:stock_total&gt;
        &lt;s0:stock_disponible&gt;0&lt;/s0:stock_disponible&gt;
        &lt;s0:autor&gt;
          &lt;s0:id&gt;1&lt;/s0:id&gt;
          &lt;s0:nombre&gt;Gabriel&lt;/s0:nombre&gt;
          &lt;s0:apellido&gt;García Márquez&lt;/s0:apellido&gt;
          &lt;s0:nacionalidad&gt;Colombiano&lt;/s0:nacionalidad&gt;
          &lt;s0:biografia&gt;Premio Nobel de Literatura 1982.&lt;/s0:biografia&gt;
        &lt;/s0:autor&gt;
        &lt;s0:editorial&gt;
          &lt;s0:id&gt;1&lt;/s0:id&gt;
          &lt;s0:nombre&gt;Editorial Sudamericana&lt;/s0:nombre&gt;
          &lt;s0:pais&gt;Argentina&lt;/s0:pais&gt;
        &lt;/s0:editorial&gt;
        &lt;s0:categoria&gt;
          &lt;s0:id&gt;1&lt;/s0:id&gt;
          &lt;s0:nombre&gt;Ficción&lt;/s0:nombre&gt;
        &lt;/s0:categoria&gt;
      &lt;/tns:obtener_libroResult&gt;
    &lt;/tns:obtener_libroResponse&gt;
  &lt;/soap11env:Body&gt;
&lt;/soap11env:Envelope&gt;</pre>
                </div>
            </div>
        </div>

        <div style="background: #2d3436; color: white; padding: 20px; text-align: center;">
            <p>🎓 Sistema de Biblioteca - Cliente SOAP Interactivo</p>
            <p>📚 Guía de Servicios Web - 2026</p>
        </div>
    </div>

    <script>
        function copiarTexto(elementId) {
            const elemento = document.getElementById(elementId);
            const texto = elemento.textContent;
            
            navigator.clipboard.writeText(texto).then(() => {
                alert('✅ XML copiado al portapapeles');
            }).catch(err => {
                console.error('Error al copiar:', err);
            });
        }
    </script>
</body>
</html>