Patrón Chain of Responsibility

from abc import ABC, abstractmethod


class Aprobador(ABC):
    """Un eslabón de la cadena: aprueba lo que puede y pasa el resto al siguiente."""
    def __init__(self):
        self._siguiente = None

    def luego(self, siguiente):
        """Enlaza el siguiente y lo devuelve, para escribir la cadena de un tirón."""
        self._siguiente = siguiente
        return siguiente

    def aprobar(self, concepto, importe):
        if self.puede_aprobar(concepto, importe):
            print(f"  Lo aprueba {self.nombre()}")
        elif self._siguiente is not None:
            print(f"  {self.nombre()} no puede: lo pasa")
            self._siguiente.aprobar(concepto, importe)
        else:
            print(f"  {self.nombre()} tampoco puede: nadie lo aprueba")

    @abstractmethod
    def nombre(self): ...

    @abstractmethod
    def puede_aprobar(self, concepto, importe): ...


class JefeEquipo(Aprobador):
    def nombre(self):
        return "la jefa de equipo"

    def puede_aprobar(self, concepto, importe):
        return importe <= 500 and concepto != "viaje"


class Director(Aprobador):
    def nombre(self):
        return "el director"

    def puede_aprobar(self, concepto, importe):
        return importe <= 5000


class Consejo(Aprobador):
    def nombre(self):
        return "el consejo"

    def puede_aprobar(self, concepto, importe):
        return importe <= 50000


cadena = JefeEquipo()
cadena.luego(Director()).luego(Consejo())
for concepto, importe in [("material", 120), ("viaje", 300), ("servidor", 12000), ("edificio", 900000)]:
    print(f"Gasto de {importe:.2f} € ({concepto}):".replace(".", ","))
    cadena.aprobar(concepto, importe)          # el cliente solo conoce el primer eslabón

/** Un eslabón de la cadena: aprueba lo que puede y pasa el resto al siguiente. */
class Aprobador {
    #siguiente = null;

    /** Enlaza el siguiente y lo devuelve, para escribir la cadena de un tirón. */
    luego(siguiente) { this.#siguiente = siguiente; return siguiente; }

    aprobar(gasto) {
        if (this.puedeAprobar(gasto)) {
            console.log(`  Lo aprueba ${this.nombre()}`);
        } else if (this.#siguiente) {
            console.log(`  ${this.nombre()} no puede: lo pasa`);
            this.#siguiente.aprobar(gasto);
        } else {
            console.log(`  ${this.nombre()} tampoco puede: nadie lo aprueba`);
        }
    }
}

class JefeEquipo extends Aprobador {
    nombre() { return "la jefa de equipo"; }
    puedeAprobar(g) { return g.importe <= 500 && g.concepto !== "viaje"; }
}

class Director extends Aprobador {
    nombre() { return "el director"; }
    puedeAprobar(g) { return g.importe <= 5000; }
}

class Consejo extends Aprobador {
    nombre() { return "el consejo"; }
    puedeAprobar(g) { return g.importe <= 50000; }
}

const cadena = new JefeEquipo();
cadena.luego(new Director()).luego(new Consejo());
const gastos = [{ concepto: "material", importe: 120 }, { concepto: "viaje", importe: 300 }, { concepto: "servidor", importe: 12000 }, { concepto: "edificio", importe: 900000 }];
for (const g of gastos) {
    console.log(`Gasto de ${g.importe.toFixed(2).replace(".", ",")} € (${g.concepto}):`);
    cadena.aprobar(g);                         // el cliente solo conoce el primer eslabón
}

using System;
using System.Globalization;

record Gasto(string Concepto, decimal Importe);

// Un eslabón de la cadena: aprueba lo que puede y pasa el resto al siguiente.
abstract class Aprobador {
    private Aprobador? siguiente;

    // Enlaza el siguiente y lo devuelve, para escribir la cadena de un tirón.
    public Aprobador Luego(Aprobador siguiente) { this.siguiente = siguiente; return siguiente; }

    public void Aprobar(Gasto g) {
        if (PuedeAprobar(g)) {
            Console.WriteLine(
quot;  Lo aprueba {Nombre}");
        } else if (siguiente != null) {
            Console.WriteLine(
quot;  {Nombre} no puede: lo pasa");
            siguiente.Aprobar(g);
        } else {
            Console.WriteLine(
quot;  {Nombre} tampoco puede: nadie lo aprueba");
        }
    }

    protected abstract string Nombre { get; }
    protected abstract bool PuedeAprobar(Gasto g);
}

class JefeEquipo : Aprobador {
    protected override string Nombre => "la jefa de equipo";
    protected override bool PuedeAprobar(Gasto g) => g.Importe <= 500 && g.Concepto != "viaje";
}

class Director : Aprobador {
    protected override string Nombre => "el director";
    protected override bool PuedeAprobar(Gasto g) => g.Importe <= 5000;
}

class Consejo : Aprobador {
    protected override string Nombre => "el consejo";
    protected override bool PuedeAprobar(Gasto g) => g.Importe <= 50000;
}

class Program {
    static void Main() {
        Aprobador cadena = new JefeEquipo();
        cadena.Luego(new Director()).Luego(new Consejo());
        var gastos = new[] { new Gasto("material", 120), new Gasto("viaje", 300), new Gasto("servidor", 12000), new Gasto("edificio", 900000) };
        foreach (var g in gastos) {
            Console.WriteLine(
quot;Gasto de {g.Importe.ToString("F2", CultureInfo.InvariantCulture).Replace('.', ',')} € ({g.Concepto}):");
            cadena.Aprobar(g);                       // el cliente solo conoce el primer eslabón
        }
    }
}

<?php
/** Un eslabón de la cadena: aprueba lo que puede y pasa el resto al siguiente. */
abstract class Aprobador {
    private ?Aprobador $siguiente = null;

    /** Enlaza el siguiente y lo devuelve, para escribir la cadena de un tirón. */
    public function luego(Aprobador $siguiente): Aprobador {
        $this->siguiente = $siguiente;
        return $siguiente;
    }

    public function aprobar(string $concepto, float $importe): void {
        if ($this->puedeAprobar($concepto, $importe)) {
            echo "  Lo aprueba {$this->nombre()}\n";
        } elseif ($this->siguiente !== null) {
            echo "  {$this->nombre()} no puede: lo pasa\n";
            $this->siguiente->aprobar($concepto, $importe);
        } else {
            echo "  {$this->nombre()} tampoco puede: nadie lo aprueba\n";
        }
    }

    abstract protected function nombre(): string;
    abstract protected function puedeAprobar(string $concepto, float $importe): bool;
}

class JefeEquipo extends Aprobador {
    protected function nombre(): string { return "la jefa de equipo"; }
    protected function puedeAprobar(string $concepto, float $importe): bool { return $importe <= 500 && $concepto !== "viaje"; }
}

class Director extends Aprobador {
    protected function nombre(): string { return "el director"; }
    protected function puedeAprobar(string $concepto, float $importe): bool { return $importe <= 5000; }
}

class Consejo extends Aprobador {
    protected function nombre(): string { return "el consejo"; }
    protected function puedeAprobar(string $concepto, float $importe): bool { return $importe <= 50000; }
}

$cadena = new JefeEquipo();
$cadena->luego(new Director())->luego(new Consejo());
foreach ([["material", 120], ["viaje", 300], ["servidor", 12000], ["edificio", 900000]] as [$concepto, $importe]) {
    echo "Gasto de ", number_format($importe, 2, ",", ""), " € ($concepto):\n";
    $cadena->aprobar($concepto, $importe);          // el cliente solo conoce el primer eslabón
}

# Django: cada middleware recibe la petición, hace lo suyo y decide si llama al siguiente
def requiere_login(get_response):
    def middleware(request):
        if not request.user.is_authenticated:
            return redirect("/login")              # corta la cadena aquí
        return get_response(request)               # pasa al siguiente middleware (o a la vista)
    return middleware

// Express: cada middleware decide si llama a next() para seguir la cadena
app.use((req, res, next) => {
    if (!req.session.usuario) return res.redirect("/login");   // corta la cadena aquí
    next();                                                     // pasa al siguiente
});

// Los eventos del DOM suben de un elemento a sus padres hasta que alguien los para
boton.addEventListener("click", (e) => e.stopPropagation());

// ASP.NET Core: cada middleware recibe el siguiente y decide si lo llama
app.Use(async (contexto, siguiente) => {
    if (contexto.User.Identity?.IsAuthenticated != true) {
        contexto.Response.Redirect("/login");      // corta la cadena aquí
        return;
    }
    await siguiente();                              // pasa al siguiente middleware
});

<?php
// Laravel: un middleware recibe la petición y el siguiente eslabón ($next)
class RequiereLogin {
    public function handle(Request $peticion, Closure $next): Response {
        if (!auth()->check()) return redirect("/login");   // corta la cadena aquí
        return $next($peticion);                            // pasa al siguiente
    }
}