error fixing

src/infrastructure/adapters/persistence/db.py

@@ -14,9 +14,13 @@ SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 Base = declarative_base()
 
 def get_db():
-    """Obtiene una sesión de base de datos"""
+    """Obtiene una sesión de base de datos con manejo de rollback"""
     db = SessionLocal()
     try:
         yield db
+        db.commit()  # Commit explícito si no hubo errores
+    except Exception as e:
+        db.rollback()  # Rollback si ocurre cualquier error
+        raise e
     finally:
-        db.close()
+        db.close()  # Siempre cerrar la sesión

src/infrastructure/adapters/persistence/user_repository_sql.py

@@ -3,6 +3,9 @@ from domain.users import User
 from infrastructure.adapters.persistence.models import UserModel
 from infrastructure.adapters.persistence.db import SessionLocal
 from typing import List, Optional
+import logging
+
+logger = logging.getLogger(__name__)
 
 class UserRepositorySQL(UserRepository):
     """Implementación del repositorio de Usuarios usando SQLAlchemy (MySQL)"""
@@ -11,48 +14,68 @@ class UserRepositorySQL(UserRepository):
         self.db = db_session or SessionLocal()
     
     def save(self, user: User) -> User:
-        """Guarda un nuevo usuario"""
-        db_user = UserModel(
-            nombre=user.nombre,
-            apellido=user.apellido,
-            email=user.email,
-            fecha_nacimiento=user.fecha_nacimiento,
-            fecha_creacion=user.fecha_creacion,
-            calificacion=user.calificacion,
-            numero_reportes=user.numero_reportes,
-            url_foto_perfil=user.url_foto_perfil,
-            biografia=user.biografia
-        )
-        self.db.add(db_user)
-        self.db.commit()
-        self.db.refresh(db_user)
-        
-        # Convertir de vuelta a dominio
-        return self._to_domain(db_user)
+        """Guarda un nuevo usuario con manejo de transacciones"""
+        try:
+            db_user = UserModel(
+                nombre=user.nombre,
+                apellido=user.apellido,
+                email=user.email,
+                fecha_nacimiento=user.fecha_nacimiento,
+                fecha_creacion=user.fecha_creacion,
+                calificacion=user.calificacion,
+                numero_reportes=user.numero_reportes,
+                url_foto_perfil=user.url_foto_perfil,
+                biografia=user.biografia
+            )
+            self.db.add(db_user)
+            self.db.commit()
+            self.db.refresh(db_user)
+            logger.info(f"Usuario guardado exitosamente: {db_user.user_id}")
+            return self._to_domain(db_user)
+        except Exception as e:
+            self.db.rollback()
+            logger.error(f"Error al guardar usuario: {e}", exc_info=True)
+            raise
     
     def find_by_id(self, user_id: int) -> Optional[User]:
         """Obtiene un usuario por ID"""
-        db_user = self.db.query(UserModel).filter(UserModel.user_id == user_id).first()
-        if db_user:
-            return self._to_domain(db_user)
-        return None
+        try:
+            db_user = self.db.query(UserModel).filter(UserModel.user_id == user_id).first()
+            if db_user:
+                return self._to_domain(db_user)
+            return None
+        except Exception as e:
+            logger.error(f"Error al buscar usuario por ID {user_id}: {e}", exc_info=True)
+            raise
     
     def find_by_email(self, email: str) -> Optional[User]:
         """Obtiene un usuario por email"""
-        db_user = self.db.query(UserModel).filter(UserModel.email == email).first()
-        if db_user:
-            return self._to_domain(db_user)
-        return None
+        try:
+            db_user = self.db.query(UserModel).filter(UserModel.email == email).first()
+            if db_user:
+                return self._to_domain(db_user)
+            return None
+        except Exception as e:
+            logger.error(f"Error al buscar usuario por email {email}: {e}", exc_info=True)
+            raise
     
     def find_all(self) -> List[User]:
         """Obtiene todos los usuarios"""
-        db_users = self.db.query(UserModel).all()
-        return [self._to_domain(user) for user in db_users]
+        try:
+            db_users = self.db.query(UserModel).all()
+            return [self._to_domain(user) for user in db_users]
+        except Exception as e:
+            logger.error(f"Error al obtener todos los usuarios: {e}", exc_info=True)
+            raise
     
     def update(self, user: User) -> User:
-        """Actualiza un usuario"""
-        db_user = self.db.query(UserModel).filter(UserModel.user_id == user.user_id).first()
-        if db_user:
+        """Actualiza un usuario con manejo de transacciones"""
+        try:
+            db_user = self.db.query(UserModel).filter(UserModel.user_id == user.user_id).first()
+            if not db_user:
+                logger.warning(f"Usuario no encontrado para actualizar: {user.user_id}")
+                return user
+                
             db_user.nombre = user.nombre
             db_user.apellido = user.apellido
             db_user.calificacion = user.calificacion
@@ -61,32 +84,59 @@ class UserRepositorySQL(UserRepository):
             db_user.biografia = user.biografia
             self.db.commit()
             self.db.refresh(db_user)
+            logger.info(f"Usuario actualizado exitosamente: {user.user_id}")
             return self._to_domain(db_user)
-        return user
+        except Exception as e:
+            self.db.rollback()
+            logger.error(f"Error al actualizar usuario {user.user_id}: {e}", exc_info=True)
+            raise
     
     def delete(self, user_id: int) -> bool:
-        """Elimina un usuario"""
-        db_user = self.db.query(UserModel).filter(UserModel.user_id == user_id).first()
-        if db_user:
-            self.db.delete(db_user)
-            self.db.commit()
-            return True
-        return False
+        """Elimina un usuario con manejo de transacciones"""
+        try:
+            db_user = self.db.query(UserModel).filter(UserModel.user_id == user_id).first()
+            if db_user:
+                self.db.delete(db_user)
+                self.db.commit()
+                logger.info(f"Usuario eliminado exitosamente: {user_id}")
+                return True
+            logger.warning(f"Usuario no encontrado para eliminar: {user_id}")
+            return False
+        except Exception as e:
+            self.db.rollback()
+            logger.error(f"Error al eliminar usuario {user_id}: {e}", exc_info=True)
+            raise
     
     def increment_reports(self, user_id: int) -> None:
-        """Incrementa el contador de reportes de un usuario"""
-        db_user = self.db.query(UserModel).filter(UserModel.user_id == user_id).first()
-        if db_user:
-            db_user.numero_reportes += 1
-            self.db.commit()
+        """Incrementa el contador de reportes con manejo de transacciones"""
+        try:
+            db_user = self.db.query(UserModel).filter(UserModel.user_id == user_id).first()
+            if db_user:
+                db_user.numero_reportes += 1
+                self.db.commit()
+                logger.info(f"Contador de reportes incrementado para usuario: {user_id}")
+            else:
+                logger.warning(f"Usuario no encontrado para incrementar reportes: {user_id}")
+        except Exception as e:
+            self.db.rollback()
+            logger.error(f"Error al incrementar reportes del usuario {user_id}: {e}", exc_info=True)
+            raise
     
     def update_rating(self, user_id: int, new_rating: float) -> None:
-        """Actualiza la calificación de un usuario"""
-        db_user = self.db.query(UserModel).filter(UserModel.user_id == user_id).first()
-        if db_user:
-            # Asegurar que la calificación esté en el rango 0-100
-            db_user.calificacion = max(0, min(100, new_rating))
-            self.db.commit()
+        """Actualiza la calificación de un usuario con manejo de transacciones"""
+        try:
+            db_user = self.db.query(UserModel).filter(UserModel.user_id == user_id).first()
+            if db_user:
+                # Asegurar que la calificación esté en el rango 0-100
+                db_user.calificacion = max(0, min(100, new_rating))
+                self.db.commit()
+                logger.info(f"Calificación actualizada para usuario {user_id}: {db_user.calificacion}")
+            else:
+                logger.warning(f"Usuario no encontrado para actualizar calificación: {user_id}")
+        except Exception as e:
+            self.db.rollback()
+            logger.error(f"Error al actualizar calificación del usuario {user_id}: {e}", exc_info=True)
+            raise
     
     def _to_domain(self, db_user: UserModel) -> User:
         """Convierte un modelo SQLAlchemy a un objeto de dominio"""