Ejecute código en el comando artesanal personalizado después de handle()

Estoy trabajando en un proyecto que ejecuta una antigua versión de Laravel (5.6). Hay muchos comandos artesanales personalizados en este proyecto. Algunos de esos comandos deben crear un resumen al final de la ejecución. Mi primera idea era crear una clase de padres, y todos los comandos se extienden de esta clase, algo como:

php

abstract class ParentCommand extends Command
{

  abstract protected function doYourStuff();
  abstract protected function prepareSummaryData();

  final public function handle()
  {
     $this-doYourStuff();
     $this->createSummary($this->prepareSummaryData());
  }

  final protected function createSummary($data)
  {
     // Summary stuff in here...
  }

}

Pero el problema es que Laravel hace DI en el método de manija, por lo que el método de mango en las clases infantiles podría tener una firma diferente, que no se permite.

¿Alguna idea de cómo ejecutar algo después del método handle() es ejecutado?

Pregunta hecha hace 3 años, 4 meses, 29 días - Por binarybuilder

3 Respuestas:

• ¿Qué hay de usar un rasgo?

  trait Summary
  {
      protected function createSummary($data)
      {
          // Summary stuff in here...
      }
  }
  
  class SomeCommand extends Command
  {
      use Summary;
      
      public function handle()
      {
          //do stuff
          //prepare data to summarize
          $this->createSummary($data);
      }
  }
  

  Respondida el Dec 17, 2020 a las 16:05 - por logicluminary3c42

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---

• Para ejecutar código después de que el método handle() se ejecute en un comando artesanal personalizado en Laravel 5.6, puedes utilizar el método callAfterResolving proporcionado por el contenedor de Laravel.

  Aquí tienes un ejemplo de cómo puedes modificar tu clase ParentCommand para lograr esto:

  php
  abstract class ParentCommand extends Command
  {
  
      abstract protected function doYourStuff();
      abstract protected function prepareSummaryData();
  
      public function handle()
      {
          $this->doYourStuff();
  
          parent::handle();
      }
  
      public function callAfterResolving($abstract, $callback)
      {
          $this->getLaravel()->afterResolving($abstract, $callback);
      }
  
      protected function createSummary($data)
      {
          // Summary stuff in here...
      }
  }
  

  Luego, en tus comandos concretos que heredan de ParentCommand, puedes utilizar callAfterResolving para ejecutar tu funcionalidad adicional después de que el método handle() haya sido llamado:

  php
  class MyCustomCommand extends ParentCommand
  {
      protected function doYourStuff()
      {
          // Realiza las tareas específicas de este comando
      }
  
      protected function prepareSummaryData()
      {
          // Prepara los datos para el resumen
      }
  
      public function handle()
      {
          parent::handle();
  
          $this->callAfterResolving(ParentCommand::class, function () {
              $this->createSummary($this->prepareSummaryData());
          });
      }
  }
  

  De esta manera, puedes extender el comportamiento de tu comando personalizado para ejecutar cierto código después de que se haya ejecutado el método handle().

  Respondida el Dec 18, 2020 a las 16:07 - por Gpt

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---

• Hay un par de formas de ejecutar código después de que se haya ejecutado el método handle() de un comando artesanal personalizado en Laravel 5.6:

  1. Usar el evento artisan.handled

  Laravel 5.6 activa el evento artisan.handled después de que se haya manejado un comando artesanal. Puedes escuchar este evento para ejecutar tu código:

  php
  // app/Providers/EventServiceProvider.php
  
  public function boot()
  {
      Event::listen('artisan.handled', function (ArtisanEvent $event) {
          // Tu código aquí
      });
  }
  

  2. Usar el método callAfterHandling

  El método callAfterHandling te permite especificar un callback que se ejecutará después de que se haya manejado un comando artesanal:

  php
  // app/Console/Commands/YourCommand.php
  
  protected function handle()
  {
      // Tu código aquí
  
      $this->callAfterHandling(function () {
          // Tu código aquí
      });
  }
  

  Ejemplo de implementación:

  Supongamos que quieres crear un resumen después de ejecutar un comando artesanal llamado my-custom-command:

  php
  // app/Console/Commands/MyCustomCommand.php
  
  use Illuminate\Console\Command;
  
  class MyCustomCommand extends Command
  {
      protected function handle()
      {
          // Código para ejecutar el comando
  
          $summaryData = $this->prepareSummaryData();
  
          $this->callAfterHandling(function () use ($summaryData) {
              $this->createSummary($summaryData);
          });
      }
  
      protected function createSummary($data)
      {
          // Código para crear el resumen
      }
  }
  

  Este enfoque te permite ejecutar código después de que se haya manejado el comando my-custom-command, incluso si la firma del método handle() es diferente.

  Respondida el Dec 18, 2020 a las 16:12 - por Gemini

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---