delete batch

Author: goshasafonov

config/processable.php

@@ -92,6 +92,9 @@
     ],
 
     'actions' => [
+        'job' => [
+            'create' => Yuges\Processable\Actions\CreateJobAction::class,
+        ],
         'stage' => [
             'update' => Yuges\Processable\Actions\UpdateProcessStageAction::class,
             'create' => Yuges\Processable\Actions\CreateProcessStagesAction::class,
@@ -106,6 +109,7 @@
     'job' => [
         'class' => Yuges\Processable\Jobs\ProcessStageJob::class,
         'handler' => [
+            'event' => Yuges\Processable\Handlers\EventHandler::class,
             'stage' => Yuges\Processable\Handlers\StageEventHandler::class,
             'process' => Yuges\Processable\Handlers\ProcessEventHandler::class,
         ],

database/migrations/000_create_processes_table.php

@@ -1,7 +1,6 @@
 <?php
 
 use Yuges\Package\Enums\KeyType;
-use Yuges\Processable\Models\Batch;
 use Yuges\Processable\Config\Config;
 use Yuges\Processable\Models\Process;
 use Yuges\Processable\Enums\ProcessState;
@@ -40,18 +39,6 @@ public function up(): void
                 );
             }
 
-            if (Config::getBatchKeyHas(true)) {
-                $batch = new (Config::getBatchClass(Batch::class));
-
-                $table->string($batch->getForeignKey())->nullable();
-                $table
-                    ->foreign($batch->getForeignKey())
-                    ->references('id')
-                    ->on(Config::getBatchClass(Batch::class)::getTableName())
-                    ->cascadeOnUpdate()
-                    ->nullOnDelete();
-            }
-
             $table->timestamp('started_at')->nullable();
             $table->timestamp('finished_at')->nullable();
             $table->timestamp('failed_at')->nullable();

src/Abstracts/Process.php

@@ -2,6 +2,7 @@
 
 namespace Yuges\Processable\Abstracts;
 
+use Illuminate\Support\Collection;
 use Yuges\Processable\Models\Process as ProcessModel;
 
 abstract class Process implements \Yuges\Processable\Interfaces\Process
@@ -13,9 +14,41 @@ public function stages(): array
         return [];
     }
 
+    public function stageCollection(): Collection
+    {
+        return Collection::make($this->stages());
+    }
+
+    public function firstStage(): ?string
+    {
+        return $this->stageCollection()->first();
+    }
+
+    public function lastStage(): ?string
+    {
+        return $this->stageCollection()->last();
+    }
+
+    public function nextStage(?string $stage = null): ?string
+    {
+        $stages = $this->stageCollection();
+
+        if (! $stage) {
+            return $stages->first();
+        }
+
+        $key = $stages->search($stage);
+
+        if ($key === false) {
+            return null;
+        }
+
+        return $stages->get($key + 1);
+    }
+
     static function process(): ProcessModel
     {
-        return self::createProcess();
+        return static::createProcess();
     }
 
     public static function createProcess(): ProcessModel
@@ -28,7 +61,7 @@ public function getName(): string
         return $this->name;
     }
 
-    public function setName(string $name): self
+    public function setName(string $name): static
     {
         $this->name = $name;
 

src/Actions/CreateJobAction.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Yuges\Processable\Actions;
+
+use Exception;
+use Yuges\Processable\Config\Config;
+use Yuges\Processable\Models\Process;
+use Yuges\Processable\Jobs\ProcessStageJob;
+use Yuges\Processable\Interfaces\Processable;
+use Yuges\Processable\Interfaces\Stage as StageInterface;
+
+class CreateJobAction
+{
+    public function __construct(
+        protected Process $process,
+        protected Processable $processable,
+    ) {
+    }
+
+    public static function create(Process $process, Processable $processable): self
+    {
+        return new static($process, $processable);
+    }
+
+    /**
+     * @param class-string<StageInterface>|null $stage
+     */
+    public function execute(?string $stage): ProcessStageJob
+    {
+        if (! $stage) {
+            throw new Exception('Empty stage');
+        }
+
+        $stage = new $stage;
+
+        if (! $stage instanceof StageInterface) {
+            throw new Exception('Error stage type');
+        }
+
+        $stage = $this->process->stages->firstOrFail('class', '=', $stage::class);
+
+        return Config::getProcessStageJob(
+            $stage,
+            $this->process,
+            $this->processable,
+            ProcessStageJob::class
+        );
+    }
+}

src/Actions/RunProcessAction.php

@@ -2,18 +2,9 @@
 
 namespace Yuges\Processable\Actions;
 
-use Exception;
-use Throwable;
-use Carbon\Carbon;
-use Illuminate\Bus\Batch;
-use Illuminate\Support\Collection;
-use Illuminate\Support\Facades\Bus;
 use Yuges\Processable\Config\Config;
 use Yuges\Processable\Models\Process;
-use Yuges\Processable\Enums\ProcessState;
-use Yuges\Processable\Jobs\ProcessStageJob;
 use Yuges\Processable\Interfaces\Processable;
-use Yuges\Processable\Interfaces\Stage as InterfacesStage;
 
 class RunProcessAction
 {
@@ -27,46 +18,16 @@ public static function create(Processable $processable): self
         return new static($processable);
     }
 
-    public function execute(Process $model): Process
+    public function execute(Process $process): Process
     {
-        $process = new $model->class;
+        $stage = (new $process->class)->firstStage();
 
-        $jobs = Collection::make($process->stages())->map(function (string $stage) use ($model) {
-            $stage = new $stage;
+        $job = Config::getCreateJobAction($process, $this->processable)->execute($stage);
 
-            if (! $stage instanceof InterfacesStage) {
-                throw new Exception('Error stage type');
-            }
+        dispatch($job)
+            ->onConnection(Config::getQueueConnection())
+            ->onQueue(Config::getQueueName());
 
-            $stage = $model->stages->firstOrFail('class', '=', $stage::class);
-
-            return Config::getProcessStageJob(
-                $stage,
-                $model,
-                $this->processable,
-                ProcessStageJob::class
-            );
-        });
-
-        $action = Config::getUpdateProcessAction($model, UpdateProcessAction::class);
-
-        Bus::batch([$jobs->toArray()])
-        ->before(function (Batch $batch) use ($action) {
-            $action->execute(Config::getProcessStateClass(ProcessState::class)::Started, $batch);
-        })
-        ->progress(function (Batch $batch) use ($action) {
-            $action->execute(Config::getProcessStateClass(ProcessState::class)::Processing, $batch);
-        })
-        ->catch(function (Batch $batch, Throwable $e) use ($action) {
-            $action->execute(Config::getProcessStateClass(ProcessState::class)::Failed, $batch, $e);
-        })
-        ->finally(function (Batch $batch) use ($action) {
-            $action->execute(Config::getProcessStateClass(ProcessState::class)::Finished, $batch);
-        })
-        ->onConnection(Config::getQueueConnection())
-        ->onQueue(Config::getQueueName())
-        ->dispatch();
-
-        return $model;
+        return $process;
     }
 }

src/Actions/UpdateProcessAction.php

@@ -2,9 +2,8 @@
 
 namespace Yuges\Processable\Actions;
 
-use Throwable;
 use Carbon\Carbon;
-use Illuminate\Bus\Batch;
+use Illuminate\Contracts\Queue\Job;
 use Yuges\Processable\Models\Process;
 use Yuges\Processable\Enums\ProcessState;
 use Yuges\Processable\Interfaces\ProcessState as ProcessStateInterface;
@@ -21,11 +20,10 @@ public static function create(Process $process): self
         return new static($process);
     }
 
-    public function execute(ProcessStateInterface $state, ?Batch $batch = null, ?Throwable $e = null): Process
+    public function execute(ProcessStateInterface $state, ?Job $job = null): Process
     {
         $attributes = [
             'state' => $state,
-            'batch_id' => $batch->id ?? $this->process->batch_id,
         ];
 
         match ($state->value) {

src/Config/Config.php

@@ -12,13 +12,16 @@
 use Yuges\Processable\Models\FailedJob;
 use Yuges\Processable\Enums\ProcessState;
 use Yuges\Processable\Jobs\ProcessStageJob;
+use Yuges\Processable\Handlers\EventHandler;
 use Yuges\Processable\Interfaces\Processable;
+use Yuges\Processable\Actions\CreateJobAction;
 use Yuges\Processable\Observers\StageObserver;
 use Yuges\Processable\Actions\RunProcessAction;
 use Yuges\Processable\Observers\ProcessObserver;
 use Yuges\Processable\Handlers\StageEventHandler;
 use Yuges\Processable\Actions\UpdateProcessAction;
 use Yuges\Processable\Actions\CreateProcessAction;
+use Yuges\Processable\Handlers\ProcessEventHandler;
 use Yuges\Processable\Observers\ProcessableObserver;
 use Yuges\Processable\Actions\UpdateProcessStageAction;
 use Yuges\Processable\Actions\CreateProcessStagesAction;
@@ -228,6 +231,21 @@ public static function getProcessStateClass(mixed $default = null): string
         return self::get('process.state', $default);
     }
 
+    public static function getCreateJobAction(
+        Process $process,
+        Processable $processable,
+        mixed $default = null
+    ): CreateJobAction
+    {
+        return self::getCreateJobActionClass($default)::create($process, $processable);
+    }
+
+    /** @return class-string<CreateJobAction> */
+    public static function getCreateJobActionClass(mixed $default = null): string
+    {
+        return self::get('actions.job.create', $default);
+    }
+
     public static function getRunProcessAction(
         Processable $processable,
         mixed $default = null
@@ -316,6 +334,17 @@ public static function getProcessStageJobClass(mixed $default = null): string
         return self::get('job.class', $default);
     }
 
+    public static function getEventHandler(mixed $default = null): EventHandler
+    {
+        return self::getEventHandlerClass($default)::create();
+    }
+
+    /** @return class-string<EventHandler> */
+    public static function getEventHandlerClass(mixed $default = null): string
+    {
+        return self::get('job.handler.event', $default);
+    }
+
     public static function getStageEventHandler(mixed $default = null): StageEventHandler
     {
         return self::getStageEventHandlerClass($default)::create();
@@ -327,6 +356,17 @@ public static function getStageEventHandlerClass(mixed $default = null): string
         return self::get('job.handler.stage', $default);
     }
 
+    public static function getProcessEventHandler(mixed $default = null): ProcessEventHandler
+    {
+        return self::getProcessEventHandlerClass($default)::create();
+    }
+
+    /** @return class-string<ProcessEventHandler> */
+    public static function getProcessEventHandlerClass(mixed $default = null): string
+    {
+        return self::get('job.handler.process', $default);
+    }
+
     public static function getQueueName(mixed $default = null): string
     {
         return self::get('job.queue.name', $default);