ตรวจสอบสลิปโอนเงินผ่าน SlipOK ด้วย Laravel ทำยังไง

<?php

namespace App\Enums;

enum SlipCheckStatus: string
{
    case Waiting = 'waiting';
    case Verified = 'verified';
    case NeedsReview = 'needs_review';
    case Duplicate = 'duplicate';
    case WrongReceiver = 'wrong_receiver';
}

<?php

namespace App\Enums;

enum SlipDecision: string
{
    case Used = 'used';
    case Rejected = 'rejected';
}

Schema::create('slips', function (Blueprint $table) {
    $table->id();
    $table->foreignId('customer_id')->constrained();
    $table->string('path');
    $table->string('check_status')->default('waiting');
    $table->string('decision')->nullable();
    $table->string('trans_ref')->nullable()->index();
    $table->decimal('amount', 12, 2)->nullable();
    $table->timestamp('transferred_at')->nullable();
    $table->unsignedSmallInteger('error_code')->nullable();
    $table->string('error_message')->nullable();
    $table->timestamps();
});

'slipok' => [
    'api_key' => env('SLIPOK_API_KEY'),
    'branch_id' => env('SLIPOK_BRANCH_ID'),
],

<?php

namespace App\Services;

use App\Models\Slip;
use App\Models\SlipOkLog;
use Illuminate\Http\Client\ConnectionException;
use Illuminate\Support\Facades\Context;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;

class SlipOk
{
    /**
     * @return array<string, mixed>
     */
    public function check(Slip $slip): array
    {
        Context::add('slip_id', $slip->id);

        $startedAt = hrtime(true);

        try {
            $response = Http::timeout(20)
                ->withHeader('x-authorization', config('services.slipok.api_key'))
                ->attach('files', Storage::disk('slips')->get($slip->path), basename($slip->path))
                ->post('https://api.slipok.com/api/line/apikey/'.config('services.slipok.branch_id'));
        } catch (ConnectionException $exception) {
            $this->log($slip, null, ['exception' => $exception->getMessage()], $startedAt);

            throw $exception;
        }

        $payload = $response->json() ?? ['raw' => Str::limit($response->body(), 2000)];

        $this->log($slip, $response->status(), $payload, $startedAt);

        return $payload;
    }

    /**
     * @param  array<string, mixed>  $payload
     */
    private function log(Slip $slip, ?int $httpStatus, array $payload, int $startedAt): void
    {
        SlipOkLog::create([
            'slip_id' => $slip->id,
            'http_status' => $httpStatus,
            'payload' => $payload,
            'milliseconds' => intdiv(hrtime(true) - $startedAt, 1_000_000),
        ]);
    }
}

public function store(StoreSlipRequest $request): RedirectResponse
{
    $slip = $request->user()->slips()->create([
        'path' => $request->file('slip')->store('uploads', 'slips'),
    ]);

    CheckSlip::dispatch($slip)->delay(now()->addMinute());

    return back()->with('status', 'ร้านได้รับสลิปแล้ว จะตรวจและยืนยันให้เร็วที่สุด');
}

<?php

namespace App\Jobs;

use App\Enums\SlipCheckStatus;
use App\Models\ShopAccount;
use App\Models\Slip;
use App\Services\SlipOk;
use Illuminate\Contracts\Queue\ShouldBeUnique;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Queue\Queueable;
use Illuminate\Support\Facades\Date;
use Illuminate\Support\Facades\Log;

class CheckSlip implements ShouldBeUnique, ShouldQueue
{
    use Queueable;

    private const array SETUP_ERRORS = [1000, 1001, 1002, 1003, 1004];

    private const array NEEDS_HUMAN = [1005, 1006, 1007, 1008];

    public function __construct(public Slip $slip) {}

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

    public function handle(SlipOk $slipOk): void
    {
        if ($this->slip->decision !== null || $this->slip->check_status !== SlipCheckStatus::Waiting) {
            return;
        }

        $result = $slipOk->check($this->slip);

        if (($result['success'] ?? false) !== true) {
            $this->recordError((int) ($result['code'] ?? 0), (string) ($result['message'] ?? ''));

            return;
        }

        $this->recordVerified($result['data']);
    }

    private function recordError(int $code, string $message): void
    {
        if (in_array($code, self::SETUP_ERRORS, true)) {
            Log::error('SlipOK ตอบว่าการตั้งค่าหรือแพ็กเกจมีปัญหา', ['code' => $code, 'message' => $message]);
        }

        $this->slip->update([
            'error_code' => $code,
            'error_message' => $message,
            'check_status' => in_array($code, self::NEEDS_HUMAN, true)
                ? SlipCheckStatus::NeedsReview
                : SlipCheckStatus::Waiting,
        ]);
    }

    /**
     * @param  array<string, mixed>  $data
     */
    private function recordVerified(array $data): void
    {
        $this->slip->update([
            'trans_ref' => $data['transRef'],
            'amount' => $data['amount'],
            'transferred_at' => Date::parse($data['transTimestamp'])->setTimezone(config('app.timezone')),
            'error_code' => null,
            'error_message' => null,
            'check_status' => match (true) {
                $this->slip->hasDuplicateOf($data['transRef']) => SlipCheckStatus::Duplicate,
                ! ShopAccount::receives($data['receiver'] ?? []) => SlipCheckStatus::WrongReceiver,
                default => SlipCheckStatus::Verified,
            },
        ]);
    }
}

public function hasDuplicateOf(string $transRef): bool
{
    return self::query()
        ->whereKeyNot($this->id)
        ->where('trans_ref', $transRef)
        ->where(fn (Builder $query) => $query
            ->whereNull('decision')
            ->orWhere('decision', SlipDecision::Used))
        ->exists();
}

/**
 * @param  array{account?: array{value?: string}, proxy?: array{value?: string}}  $receiver
 */
public static function receives(array $receiver): bool
{
    $maskedNumbers = array_filter([
        $receiver['account']['value'] ?? null,
        $receiver['proxy']['value'] ?? null,
    ]);

    return self::query()
        ->where('is_active', true)
        ->get()
        ->contains(fn (ShopAccount $account) => collect($maskedNumbers)
            ->contains(fn (string $masked) => $account->matchesMasked($masked)));
}

public function matchesMasked(string $masked): bool
{
    $masked = preg_replace('/[^0-9x]/i', '', $masked);

    if (preg_match_all('/\d/', $masked) < 4) {
        return false;
    }

    $pattern = '/^'.str_ireplace('x', '\d', $masked).'$/';

    return collect([$this->account_no, $this->promptpay_id])
        ->filter()
        ->contains(fn (string $number) => preg_match($pattern, preg_replace('/\D/', '', $number)) === 1);
}

use App\Enums\SlipCheckStatus;
use App\Jobs\CheckSlip;
use App\Models\Slip;
use Illuminate\Support\Facades\Schedule;

Schedule::call(function () {
    Slip::query()
        ->whereNull('decision')
        ->where('check_status', SlipCheckStatus::Waiting)
        ->each(function (Slip $slip) {
            if ($slip->created_at->lt(now()->subDay())) {
                $slip->update(['check_status' => SlipCheckStatus::NeedsReview]);

                return;
            }

            CheckSlip::dispatch($slip);
        });
})->everyFiveMinutes()->name('recheck-waiting-slips')->withoutOverlapping();

use App\Enums\SlipCheckStatus;
use App\Enums\SlipDecision;
use App\Jobs\CheckSlip;
use App\Models\ShopAccount;
use App\Models\Slip;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Storage;

beforeEach(function () {
    Http::preventStrayRequests();
    Storage::fake('slips');
});

function uploadedSlip(): Slip
{
    return Slip::factory()->create([
        'path' => UploadedFile::fake()->image('slip.jpg')->store('uploads', 'slips'),
    ]);
}

test('a slip SlipOK cannot find yet stays waiting instead of being rejected', function () {
    Http::fake(['api.slipok.com/*' => Http::response([
        'success' => false,
        'code' => 1011,
        'message' => 'QR Code หมดอายุ หรือ ไม่มีรายการอยู่จริง',
    ])]);

    $slip = uploadedSlip();

    CheckSlip::dispatchSync($slip);

    expect($slip->fresh())
        ->check_status->toBe(SlipCheckStatus::Waiting)
        ->decision->toBeNull()
        ->error_code->toBe(1011);
});

test('a rejected slip with the same reference does not make a resend a duplicate', function () {
    ShopAccount::factory()->create(['account_no' => '123-4-51234-6', 'is_active' => true]);
    Slip::factory()->create(['trans_ref' => 'REF0001', 'decision' => SlipDecision::Rejected]);

    Http::fake(['api.slipok.com/*' => Http::response([
        'success' => true,
        'data' => [
            'transRef' => 'REF0001',
            'amount' => 1000,
            'transTimestamp' => '2026-10-01T04:52:46.000Z',
            'receiver' => ['account' => ['value' => 'xxx-x-x1234-x']],
        ],
    ])]);

    $slip = uploadedSlip();

    CheckSlip::dispatchSync($slip);

    expect($slip->fresh()->check_status)->toBe(SlipCheckStatus::Verified);
});