Implementación del patrón Chain of Responsibility en validaciones de pago

El \*\*Patrón Chain of Responsibility\*\* es ideal para implementar un flujo flexible de validaciones donde cada paso puede aceptar, rechazar o delegar una solicitud al siguiente manejador en la cadena. Supongamos que estamos construyendo un sistema para validar formularios de usuario con múltiples pasos de validación, como comprobar si los datos están completos, si el email tiene un formato válido y si la contraseña cumple los criterios de seguridad. \### Paso 1: Clase Base para los Manejadores La clase base define una estructura común para todos los pasos de validación. ```pythonfrom abc import ABC, abstractmethod class Validador(ABC):    def \_\_init\_\_(self):        self.siguiente = None     def establecer\_siguiente(self, validador):        """Establece el siguiente validador en la cadena."""        self.siguiente = validador        return validador     @abstractmethod    def manejar(self, datos):        """Intenta validar los datos o pasa al siguiente validador."""        pass``` \### Paso 2: Validadores Concretos Cada validador implementa su propia lógica de validación. ```pythonclass ValidadorDatosCompletos(Validador):    def manejar(self, datos):        if not datos.get("email") or not datos.get("password"):            return "Error: Datos incompletos."        elif self.siguiente:            return self.siguiente.manejar(datos)        return "Validación completada." class ValidadorFormatoEmail(Validador):    def manejar(self, datos):        if "@" not in datos.get("email", ""):            return "Error: Formato de email inválido."        elif self.siguiente:            return self.siguiente.manejar(datos)        return "Validación completada." class ValidadorSeguridadPassword(Validador):    def manejar(self, datos):        password = datos.get("password", "")        if len(password) < 8 or not any(char.isdigit() for char in password):            return "Error: Contraseña no cumple los criterios de seguridad."        elif self.siguiente:            return self.siguiente.manejar(datos)        return "Validación completada."``` \### Paso 3: Configuración de la Cadena de Validación Conectamos los validadores en un flujo secuencial. ```python# Crear los validadoresvalidador\_datos\_completos = ValidadorDatosCompletos()validador\_formato\_email = ValidadorFormatoEmail()validador\_seguridad\_password = ValidadorSeguridadPassword() \# Configurar la cadenavalidador\_datos\_completos.establecer\_siguiente(validador\_formato\_email).establecer\_siguiente(validador\_seguridad\_password)``` \### Paso 4: Probar el Sistema de Validación Validamos diferentes conjuntos de datos usando la cadena configurada. ```python# Datos de pruebacasos = \[    {"email": "", "password": ""},  # Datos incompletos    {"email": "usuario", "password": "12345678"},  # Formato de email inválido    {"email": "[email protected]", "password": "short"},  # Contraseña insegura    {"email": "[email protected]", "password": "secure123"}  # Datos válidos] \# Probar cada casofor i, caso in enumerate(casos, start=1):    print(f"Caso {i}: {caso}")    resultado = validador\_datos\_completos.manejar(caso)    print(f"Resultado: {resultado}\n")``` \### Salida Esperada ```Caso 1: {'email': '', 'password': ''}Resultado: Error: Datos incompletos. Caso 2: {'email': 'usuario', 'password': '12345678'}Resultado: Error: Formato de email inválido. Caso 3: {'email': '[email protected]', 'password': 'short'}Resultado: Error: Contraseña no cumple los criterios de seguridad. Caso 4: {'email': '[email protected]', 'password': 'secure123'}Resultado: Validación completada.``` \### Ventajas del Patrón Chain of Responsibility para Validaciones 1\. \*\*Modularidad\*\*: Cada validador tiene una única responsabilidad, facilitando la lectura y el mantenimiento.2. \*\*Flexibilidad\*\*: Es fácil agregar o quitar validadores sin afectar el sistema general.3. \*\*Reutilización\*\*: Los validadores pueden ser usados en otras cadenas de validación. \### Casos de Uso Reales \- Validación de formularios de usuario.- Procesamiento de reglas de negocio en sistemas complejos.- Flujos de autorización en aplicaciones. \### Conclusión El \*\*Patrón Chain of Responsibility\*\* es una solución elegante para implementar flujos de validación escalables y flexibles. En este ejemplo, los datos pasan por una serie de validadores, cada uno con la posibilidad de manejar la solicitud o delegarla al siguiente en la cadena. Este enfoque mejora la modularidad y el mantenimiento del código.

Hola, esta fue mi solución al reto: ```python from chain_handler import ChainHandler from payment import PaymentDataValidator from commons import Request class PaymentHandler(ChainHandler): def handle(self, request:Request): validator = PaymentDataValidator() #tomar la decisión de pasar al siguiente eslabón o no try: valid = validator.validate(request.payment_data) # si no levanta una excepción, pasa al siguiente eslabón if self._next_handler: # solo si el siguiente eslabón existe: self._next_handler.handle(request) except Exception as e: print(e) # payment_validator ya levanta las excepciones. raise e `````` Y así lo implementé el **builder.py:** ```python def set_payment_validation(self) -> Self: customer = CustomerHandler() payment = PaymentDataValidator() handle = ChainHandler() handle.handle(customer) handle.set_next(payment) self.validators = handle return self `````` @camilocsoto