Chain of Responsibility en servicios de pagos

Curso de Patrones de Diseño y SOLID en Python

Contenido del curso

Patrones de Diseño y Principios SOLID

1
Patrones de diseño y SOLID en Python
02:07 min

Principios SOLID

Reestructuración del proyecto

13
Reestructuración con módulos de Python y SOLID
13:32 min

Patrones de Diseño

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0016:27

Chain of Responsibility en servicios de pagos

Curso de Patrones de Diseño y SOLID en Python

Clase 26 de 27

Clase 26 / 27

Recursos

Aplicar el patrón Chain of Responsibility a un servicio de pagos en Python mejora la organización de validaciones y facilita la extensión. Aquí verás cómo encapsular datos con Pydantic, crear un chain handler abstracto con ABC y dataclass, implementar un CustomerHandler y ajustar el servicio y el builder para validar en cadena.

¿Cómo estructurar el request y por qué usar Pydantic?

Encapsular en un solo objeto los datos que participan en la validación simplifica la firma de métodos y estandariza la entrada. Se define una clase request que hereda de BaseModel para asegurar tipos y validación básica.

Encapsulación en un único request para customer y payment.
Uso de Pydantic BaseModel: tipado fuerte y validación declarativa.
Menos acoplamiento: validadores reciben el mismo contrato.

from pydantic import BaseModel

# Declarada en el módulo commons
class Request(BaseModel):
    customer_data: CustomerData
    payment_data: PaymentData

¿Cómo definir el chain handler abstracto con ABC y dataclass?

La cadena requiere un eslabón común con comportamiento compartido: establecer el siguiente handler y un método handle obligado. Se combina ABC para el contrato, dataclass para el atributo next_handler, y Self para tipos recursivos. El método set_next retorna el propio siguiente eslabón para encadenar con fluidez.

Clase abstracta con @abstractmethod para handle.
Atributo next_handler opcional para el siguiente eslabón.
set_next uniforme en toda la cadena.

from __future__ import annotations
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Optional, Self
from commons import Request

@dataclass
class ChainHandler(ABC):
    next_handler: Optional[Self] = None

    def set_next(self, handler: Self) -> Self:
        self.next_handler = handler
        return handler

    @abstractmethod
    def handle(self, request: Request) -> None:
        ...

¿Cómo implementar CustomerHandler y conectar la cadena en el builder?

Este eslabón valida el customer con un validador existente. Si todo es correcto, delega al siguiente handler. Si ocurre un error, lo propaga. Se usa try/except porque el validador lanza excepciones cuando hay datos inválidos.

Delegación al siguiente eslabón solo si existe next_handler.
Propagación de excepciones para detener el flujo ante fallas.
Separación de responsabilidades: cada handler valida una cosa.

from commons import Request
from validators.handler import ChainHandler
from Customer import CustomerValidator  # Validador existente

class CustomerHandler(ChainHandler):
    def handle(self, request: Request) -> None:
        validator = CustomerValidator()
        try:
            validator.validate(request.customer_data)
            if self.next_handler:
                self.next_handler.handle(request)
        except Exception as exc:
            print("Fallo en validación de customer.")
            raise exc

¿Cómo se adapta el servicio y el protocolo?

El servicio deja de depender de múltiples validadores y recibe un único ChainHandler. Construye el request y ejecuta la cadena. Ante error, imprime y relanza la excepción para frenar el proceso.

from commons import Request

# Dentro del servicio
req = Request(customer_data=customer_data, payment_data=payment_data)
try:
    self.validator.handle(req)
except Exception as exc:
    print("Fallo en las validaciones.")
    raise exc

Protocolo actualizado: depende de ChainHandler, no de una lista de validadores.
Implementación alineada: un único punto de entrada handle.
Flujo claro: construir Request y ejecutar la cadena.

¿Cómo configurar la cadena en el builder?

El builder expone un método para armar la cadena. El primer eslabón se guarda como self.validator. El método retorna self para encadenar configuraciones y el build inyecta el validador en el servicio.

from typing import Optional, Self
from validators.handler import ChainHandler
from validators.customer_handler import CustomerHandler

class PaymentServiceBuilder:
    validator: Optional[ChainHandler] = None

    def set_chain_of_validations(self) -> Self:
        ch1 = CustomerHandler()
        ch2 = CustomerHandler()  # Ejemplo: encadenar otro eslabón
        ch1.set_next(ch2)
        self.validator = ch1
        return self

    def build(self) -> PaymentService:
        return PaymentService(validator=self.validator)

Método fluido: retorna self para continuar la configuración.
Primer eslabón: punto de entrada de la cadena.
Opcionalidad: validator puede ser None hasta configurarlo.

¿Cómo implementarías el handler para payment_data y cómo encadenarías toda la validación en el builder? Comparte tu enfoque y decisiones en los comentarios.

Mario Alexander Vargas Celis

Hace 2 años

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.

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": "usuario@example.com", "password": "short"},  # Contraseña insegura    {"email": "usuario@example.com", "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': 'usuario@example.com', 'password': 'short'}Resultado: Error: Contraseña no cumple los criterios de seguridad.
Caso 4: {'email': 'usuario@example.com', '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.

José Alexander Márquez Rivera

Hace un año

¡Saludos! 👋🏻

Me tomé el atrevimiento de recrear tu código y volverlo a colocar acá para que sea más fácil su lectura. Aquí lo comparto:

from abc import ABC, abstractmethod

# Paso 1: Clase Base para los Manejadores
# La clase base define una estructura común para todos los pasos de validación.

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.

class 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.

# Crear los validadores
validador_datos_completos = ValidadorDatosCompletos()
validador_formato_email = ValidadorFormatoEmail()
validador_seguridad_password = ValidadorSeguridadPassword()

# Configurar la cadena
validador_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.

# Datos de prueba
casos = [
    {"email": "", "password": ""},
    {"email": "usuario", "password": "12345678"},
    {"email": "usuario@example.com", "password": "short"},
    {"email": "usuario@example.com", "password": "secure123"}
    ]

# {"email": "", "password": ""} Datos incompletos
# {"email": "usuario", "password": "12345678"} Formato de email inválido
# {"email": "usuario@example.com", "password": "short"} Contraseña insegura
# {"email": "usuario@example.com", "password": "secure123"} Datos válidos

# Probar cada caso 
for 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': 'usuario@example.com', 'password': 'short'} Resultado: Error: Contraseña no cumple los criterios de seguridad.
#Caso 4: {'email': 'usuario@example.com', '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.

Esta muy buena esta explicación. 👏🏻

Patrones de Diseño y Principios SOLID

Patrones de diseño y SOLID en Python

Principios SOLID

Qué es el principio de responsabilidad única

Procesador de pagos en Python con Stripe

Cómo aplicar SRP en un procesador de pagos con Stripe

Principio open-closed en Python

Clases abstractas y principio abierto-cerrado

Principio de Liskov en S.O.L.I.D.

Principio de sustitución de Liskov en Python

Principio de segregación de interfaces en SOLID

Segregación de interfaces en procesadores de pagos

Principio de inversión de dependencias en SOLID

Principio de inversión de dependencias: servicio de pagos flexible

Reestructuración del proyecto

Reestructuración con módulos de Python y SOLID

Patrones de Diseño

Qué son los patrones de diseño: definición y categorías

Strategy Pattern con Python y setprocessor

Strategy Pattern para pagos en Python

Factory Pattern: centralizar creación de objetos

Patrón Factory para procesar pagos con match

Qué es el patrón Decorator

Patrón decorador en servicios de pagos

Builder Pattern: construcción paso a paso

Builder Pattern aplicado a un servicio de pagos

Observer Pattern en sistemas de eventos

Observer en sistemas de pagos con Python

Chain of Responsibility para validar pagos

Chain of Responsibility en servicios de pagos

Código funcional vs código mantenible en Python

Chain of Responsibility en servicios de pagos

Progreso del curso

Patrones de Diseño y Principios SOLID

Principios SOLID

Reestructuración del proyecto

Patrones de Diseño

Recursos

Recursos