whisper-money/app/Jobs/SyncBankingConnectionJob.php

<?php

namespace App\Jobs;

use App\Enums\BankingConnectionStatus;
use App\Mail\BankTransactionsSyncedEmail;
use App\Models\BankingConnection;
use App\Services\Banking\BalanceSyncService;
use App\Services\Banking\IndexaCapitalBalanceSyncService;
use App\Services\Banking\IndexaCapitalClient;
use App\Services\Banking\TransactionSyncService;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldBeUnique;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Mail;

class SyncBankingConnectionJob implements ShouldBeUnique, ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $tries = 3;

    public int $backoff = 30;

    public function __construct(
        public BankingConnection $bankingConnection,
    ) {}

    public function uniqueId(): string
    {
        return $this->bankingConnection->id;
    }

    public function handle(TransactionSyncService $transactionSync, BalanceSyncService $balanceSync): void
    {
        $connection = $this->bankingConnection;

        if ($connection->isEnableBanking() && $connection->isExpired()) {
            $connection->update(['status' => BankingConnectionStatus::Expired]);
            Log::info('Banking connection expired, skipping sync', ['connection_id' => $connection->id]);

            return;
        }

        if (! $connection->isActive()) {
            return;
        }

        try {
            if ($connection->isIndexaCapital()) {
                $this->syncIndexaCapital($connection);
            } else {
                $this->syncEnableBanking($connection, $transactionSync, $balanceSync);
            }

            $connection->update([
                'last_synced_at' => now(),
                'error_message' => null,
            ]);
        } catch (\Throwable $e) {
            Log::error('Banking sync failed', [
                'connection_id' => $connection->id,
                'error' => $e->getMessage(),
            ]);

            $connection->update([
                'status' => BankingConnectionStatus::Error,
                'error_message' => $e->getMessage(),
            ]);

            throw $e;
        }
    }

    private function syncIndexaCapital(BankingConnection $connection): void
    {
        $client = new IndexaCapitalClient($connection->api_token);
        $syncService = new IndexaCapitalBalanceSyncService;

        $connection->load('accounts');

        foreach ($connection->accounts as $account) {
            $syncService->sync($account, $client);
        }
    }

    private function syncEnableBanking(BankingConnection $connection, TransactionSyncService $transactionSync, BalanceSyncService $balanceSync): void
    {
        $isFirstSync = ! $connection->last_synced_at;
        $dateFrom = $isFirstSync
            ? now()->subYear()->toDateString()
            : $connection->last_synced_at->toDateString();
        $dateTo = now()->toDateString();
        $strategy = $isFirstSync ? 'longest' : null;

        $transactionsPerBank = [];

        $connection->load('accounts.bank');

        foreach ($connection->accounts as $account) {
            if ($account->isLinked()) {
                $lastTransaction = $account->transactions()
                    ->latest('transaction_date')
                    ->first();

                $linkedDateFrom = $lastTransaction
                    ? $lastTransaction->transaction_date->toDateString()
                    : $dateFrom;

                $created = $transactionSync->sync($account, $linkedDateFrom, $dateTo, $strategy, saveDailyBalances: false);
                $balanceSync->sync($account);
            } else {
                $created = $transactionSync->sync($account, $dateFrom, $dateTo, $strategy);
                $balanceSync->sync($account);

                if ($isFirstSync) {
                    $balanceSync->calculateHistoricalBalances($account);
                }
            }

            if ($created > 0) {
                $bankName = $account->bank?->name ?? __('Unknown Bank');
                $transactionsPerBank[$bankName] = ($transactionsPerBank[$bankName] ?? 0) + $created;
            }
        }

        $totalTransactions = array_sum($transactionsPerBank);

        if (! $isFirstSync && $totalTransactions > 0) {
            Mail::to($connection->user)->send(new BankTransactionsSyncedEmail(
                $connection->user,
                $totalTransactions,
                $transactionsPerBank,
            ));
        }
    }
}