feat: add recurring transaction service

app/Console/Commands/ProcessRecurringTransactions.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Services\RecurringTransactionService;
+use Illuminate\Console\Command;
+
+class ProcessRecurringTransactions extends Command
+{
+    /**
+     * The name and signature of the console command.
+     */
+    protected $signature = 'transactions:process-recurring';
+
+    /**
+     * The console command description.
+     */
+    protected $description = 'Process and schedule recurring transactions that are due';
+
+    /**
+     * Execute the console command.
+     */
+    public function handle(RecurringTransactionService $service): void
+    {
+        $this->info('Starting to process recurring transactions ...');
+
+        try {
+            // call the service to process all transactions that are due
+            $service->processAllDueTransactions();
+            $this->info('Recurring transactions processing completed.');
+        } catch (\Exception $e) {
+            $this->error('Error processing recurring transactions: '.$e->getMessage());
+        }
+    }
+}

app/Console/Kernel.php

@@ -13,6 +13,7 @@ class Kernel extends ConsoleKernel
     protected function schedule(Schedule $schedule): void
     {
         // $schedule->command('inspire')->hourly();
+        $schedule->command('transactions:process-recurring')->daily();
     }
 
     /**

app/Http/Controllers/API/v1/TransactionController.php

@@ -284,9 +284,8 @@ public function store(Request $request): JsonResponse
                     // schedule next task.
                     $next_date = get_next_transaction_schedule_date($recurring_transaction);
                     RecurrentTransactionJob::dispatch(
-                        id: (int) $recurring_transaction->id,
-                        recurrence_period: $recurring_transaction->recurrence_period,
-                        recurrence_interval: $recurring_transaction->recurrence_interval,
+                        // id: (int) $recurring_transaction->id,
+                        (int) $recurring_transaction->ruleId
                     )->delay($next_date);
                 }
 
@@ -574,9 +573,9 @@ public function update(Request $request, $id): JsonResponse
                         // schedule next task.
                         $next_date = get_next_transaction_schedule_date($recurring_transaction);
                         RecurrentTransactionJob::dispatch(
-                            id: (int) $recurring_transaction->id,
-                            recurrence_period: $recurring_transaction->recurrence_period,
-                            recurrence_interval: $recurring_transaction->recurrence_interval)->delay($next_date);
+                            // id: (int) $recurring_transaction->id
+                            (int) $recurring_transaction->ruleId
+                        )->delay($next_date);
                     }
                 }
 

app/Jobs/RecurrentTransactionJob.php

@@ -2,7 +2,7 @@
 
 namespace App\Jobs;
 
-use App\Models\RecurringTransactionRule;
+use App\Services\RecurringTransactionService;
 use Illuminate\Bus\Queueable;
 use Illuminate\Contracts\Queue\ShouldQueue;
 use Illuminate\Foundation\Bus\Dispatchable;
@@ -13,69 +13,28 @@ class RecurrentTransactionJob implements ShouldQueue
 {
     use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
 
-    private int $id;
-
-    private string $recurrence_period;
-
-    private int $recurrence_interval;
+    public int $ruleId;
 
     /**
-     * Create a new job instance.
+     * The job only needs the ID of the rule to process.
      */
-    public function __construct(int $id, string $recurrence_period, int $recurrence_interval)
+    public function __construct(int $ruleId)
     {
-        $this->id = $id;
-        $this->recurrence_period = $recurrence_period;
-        $this->recurrence_interval = $recurrence_interval;
+        $this->ruleId = $ruleId;
     }
 
     /**
-     * Execute the job.
+     * The job's only purpose is to tell the service to do the work.
      */
-    public function handle(): void
+    public function handle(RecurringTransactionService $service): void
     {
-        try {
-            logger()->info('Handling recurrent transaction');
-            // 1. Check if the user might have cancelled this recurring transaction
-            $recurring_transaction = RecurringTransactionRule::find($this->id);
-            if ($recurring_transaction) {
-                // 2. Cancel this job if the recurrence period or recurrence interval has changed or  has exceeded the end date
-                if (
-                    ($this->recurrence_period == $recurring_transaction->recurrence_period)
-                    &&
-                    ($this->recurrence_interval == $recurring_transaction->recurrence_interval)
-                    &&
-                    ($recurring_transaction->recurrence_ends_at >= now() || is_null($recurring_transaction->recurrence_ends_at))
-                ) {
-                    logger()->info('Running recurrent transaction with id '.$this->id);
-                    $new_transaction = $recurring_transaction->transaction->replicate();
-                    $new_transaction->created_at = now();
-                    $new_transaction->updated_at = now();
-                    $new_transaction->save();
+        logger()->info('Handling recurrent transaction for rule ID: '.$this->ruleId);
 
-                    if ($recurring_transaction->transaction->categories->isNotEmpty()) {
-                        $new_transaction->categories()->sync($recurring_transaction->transaction->categories->pluck('id'));
-                    }
-
-                    // 3. schedule next transaction
-                    if ($recurring_transaction->recurrence_ends_at > now() || is_null($recurring_transaction->recurrence_ends_at)) {
-                        $next_date = get_next_transaction_schedule_date($recurring_transaction);
-                        logger()->info('Next transaction date for '.$this->id.": {$next_date}");
-                        RecurrentTransactionJob::dispatch(
-                            id: (int) $recurring_transaction->id,
-                            recurrence_period: $recurring_transaction->recurrence_period,
-                            recurrence_interval: $recurring_transaction->recurrence_interval
-                        )->delay($next_date);
-                    }
-                } else {
-                    logger()->info('Recurrent transaction details for '.$this->id.' have changed, skipping');
-                }
-            } else {
-                logger()->info('Recurrent transaction for '.$this->id.' not found');
-            }
+        try {
+            // Call the service to do all the work.
+            $service->generateNextTransaction($this->ruleId);
         } catch (\Exception $e) {
-            logger()->error('Exception occurred');
-            logger()->error($e->getMessage());
+            logger()->error('Error processing job for rule '.$this->ruleId.': '.$e->getMessage());
         }
     }
 }

app/Services/RecurringTransactionService.php

@@ -0,0 +1,104 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\RecurringTransactionRule;
+use App\Models\Transaction;
+use Carbon\Carbon;
+
+class RecurringTransactionService
+{
+    /**
+     * This method is called by the job. It finds a specific recurring rule
+     * and processes it.
+     */
+    public function generateNextTransaction(int $ruleId): void
+    {
+        // 1. Find the specific rule in the database by its ID.
+        // It's linked to the original transaction.
+        $rule = RecurringTransactionRule::with('transaction')->find($ruleId);
+
+        // 2. If the rule doesn't exist, we stop here.
+        if (! $rule) {
+            logger()->info('Recurring transaction rule '.$ruleId.' not found.');
+
+            return;
+        }
+
+        // 3. Make sure the rule is still active and hasn't expired.
+        if ($rule->recurrence_ends_at && $rule->recurrence_ends_at < now()) {
+            logger()->info('Rule '.$ruleId.' has expired. Skipping.');
+
+            return;
+        }
+
+        try {
+            // 4. Create a brand new transaction based on the rule.
+            $this->createTransactionFromRule($rule);
+
+            // 5. Calculate the next time this transaction should happen.
+            $nextRunDate = $this->calculateNextRunDate($rule);
+
+            // 6. Tell Laravel to run the job again at that future date.
+            dispatch(new \App\Jobs\RecurrentTransactionJob($rule->id))->delay($nextRunDate);
+            logger()->info('Scheduled next transaction for '.$rule->id.' at '.$nextRunDate);
+
+        } catch (\Exception $e) {
+            logger()->error('Error processing rule '.$ruleId.': '.$e->getMessage());
+        }
+    }
+
+    /**
+     * This method is called by the command. It finds ALL rules that are due
+     * and dispatches a separate job for each one.
+     */
+    public function processAllDueTransactions(): void
+    {
+        // 1. Find all rules that are due to be run.
+        $rules = RecurringTransactionRule::where('recurrence_ends_at', '>=', now())
+            ->orWhereNull('recurrence_ends_at')
+            ->get();
+
+        // 2. For each rule, dispatch a job to handle it.
+        foreach ($rules as $rule) {
+            // Dispatch a job for each rule. This is better than doing all the
+            // work at once, especially for many transactions.
+            dispatch(new \App\Jobs\RecurrentTransactionJob($rule->id));
+        }
+    }
+
+    /**
+     * Creates a new transaction record from a recurring rule.
+     */
+    private function createTransactionFromRule(RecurringTransactionRule $rule): Transaction
+    {
+        // Get the original transaction data.
+        $originalTransaction = $rule->transaction;
+
+        // Make a copy of the original transaction.
+        $newTransaction = $originalTransaction->replicate();
+
+        // Update the copy with today's date and time.
+        $newTransaction->created_at = now();
+        $newTransaction->updated_at = now();
+
+        // Save the new copy to the database and synced.
+        $newTransaction->save();
+        $newTransaction->markAsSynced();
+
+        if ($originalTransaction->categories->isNotEmpty()) {
+            $newTransaction->categories()->sync($originalTransaction->categories->pluck('id'));
+        }
+
+        return $newTransaction;
+    }
+
+    /**
+     * Calculates the date of the next transaction.
+     */
+    private function calculateNextRunDate(RecurringTransactionRule $rule): Carbon
+    {
+        // Use a function that exists in your project to calculate the next date.
+        return get_next_transaction_schedule_date($rule);
+    }
+}

docker-compose.yml

@@ -1,11 +1,9 @@
 services:
     app:
-        build:
-            context: .
-            dockerfile: Dockerfile
-            args:
-                HOST_UID: '${HOST_UID}'
-                HOST_GID: '${HOST_GID}'
+        image: shinsenter/laravel:php8.2
+        environment:
+            APP_UID: '${APP_UID:-1001}'
+            APP_GID: '${APP_GID:-1001}'
         ports:
             - '${APP_PORT:-8000}:80'
         tty: true
@@ -61,4 +59,4 @@ networks:
         driver: bridge
 volumes:
     sailmysql:
-        driver: local
+        driver: local