feat: complete approval workflow

2026-08-04 16:51:51 +01:00
parent c2136bc250
commit 809eab9d4a
26 changed files with 1156 additions and 41 deletions
--- a/app/Domain/Approvals/Services/ApprovalService.php
+++ b/app/Domain/Approvals/Services/ApprovalService.php
@@ -9,8 +9,10 @@ use App\Domain\Inventory\Models\SnipeAsset;
 use App\Domain\Reservations\Enums\ReservationItemStatus;
 use App\Domain\Reservations\Enums\ReservationStatus;
 use App\Domain\Reservations\Models\Reservation;
+use App\Domain\Reservations\Models\ReservationItem;
 use App\Domain\Reservations\Services\AvailabilityService;
 use App\Models\User;
+use App\Notifications\ReservationDecisionNotification;
 use Illuminate\Auth\Access\AuthorizationException;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Validation\ValidationException;
@@ -23,7 +25,7 @@ class ApprovalService
    {
        $this->authorize($actor);

-        return DB::transaction(function () use ($reservation, $actor, $comment): Reservation {
+        $approved = DB::transaction(function () use ($reservation, $actor, $comment): Reservation {
            $locked = $this->lockPending($reservation);
            $items = $locked->items()->with('asset')->get();
            SnipeAsset::query()->whereKey($items->pluck('snipe_asset_id'))->orderBy('id')->lockForUpdate()->get();
@@ -51,13 +53,17 @@ class ApprovalService

            return $locked->load('requester', 'items.asset');
        }, 3);
+
+        $approved->requester->notify(new ReservationDecisionNotification($approved, 'approved', $comment));
+
+        return $approved;
    }

    public function reject(Reservation $reservation, User $actor, string $reason): Reservation
    {
        $this->authorize($actor);

-        return DB::transaction(function () use ($reservation, $actor, $reason): Reservation {
+        $rejected = DB::transaction(function () use ($reservation, $actor, $reason): Reservation {
            $locked = $this->lockPending($reservation);
            $this->transition($locked, $actor, ReservationStatus::Rejected, 'rejected', $reason, [
                'rejected_by' => $actor->id,
@@ -70,13 +76,17 @@ class ApprovalService

            return $locked->load('requester', 'items.asset');
        }, 3);
+
+        $rejected->requester->notify(new ReservationDecisionNotification($rejected, 'rejected', $reason));
+
+        return $rejected;
    }

    public function requestInformation(Reservation $reservation, User $actor, string $comment): Reservation
    {
        $this->authorize($actor);

-        return DB::transaction(function () use ($reservation, $actor, $comment): Reservation {
+        $awaitingInformation = DB::transaction(function () use ($reservation, $actor, $comment): Reservation {
            $locked = $this->lockPending($reservation);
            $this->transition($locked, $actor, ReservationStatus::AwaitingInformation, 'information_requested', $comment, [
                'decision_reason' => $comment,
@@ -85,6 +95,81 @@ class ApprovalService

            return $locked->load('requester', 'items.asset');
        }, 3);
+
+        $awaitingInformation->requester->notify(
+            new ReservationDecisionNotification($awaitingInformation, 'information_requested', $comment)
+        );
+
+        return $awaitingInformation;
+    }
+
+    public function substituteAsset(
+        Reservation $reservation,
+        ReservationItem $item,
+        SnipeAsset $replacement,
+        User $actor,
+        string $reason,
+    ): Reservation {
+        $this->authorize($actor);
+
+        $updated = DB::transaction(function () use ($reservation, $item, $replacement, $actor, $reason): Reservation {
+            $locked = $this->lockPending($reservation);
+            $lockedItem = ReservationItem::query()->whereKey($item->id)->lockForUpdate()->firstOrFail();
+            if ($lockedItem->reservation_id !== $locked->id || $lockedItem->status !== ReservationItemStatus::Held) {
+                throw ValidationException::withMessages(['replacement_asset_id' => 'O item já não pode ser substituído.']);
+            }
+
+            $assets = SnipeAsset::query()
+                ->whereKey([$lockedItem->snipe_asset_id, $replacement->id])
+                ->orderBy('id')
+                ->lockForUpdate()
+                ->get()
+                ->keyBy('id');
+            $original = $assets->get($lockedItem->snipe_asset_id);
+            $newAsset = $assets->get($replacement->id);
+
+            if ($original === null || $newAsset === null || ! $this->sameCategory($original, $newAsset)) {
+                throw ValidationException::withMessages(['replacement_asset_id' => 'Selecione um equipamento da mesma categoria.']);
+            }
+            if ($locked->items()->where('snipe_asset_id', $newAsset->id)->exists()
+                || ! $this->availability->isAvailable($newAsset, $lockedItem->starts_at, $lockedItem->ends_at)) {
+                throw ValidationException::withMessages(['replacement_asset_id' => 'O equipamento substituto não está disponível.']);
+            }
+
+            $lockedItem->update(['status' => ReservationItemStatus::Cancelled]);
+            $locked->items()->create([
+                'snipe_asset_id' => $newAsset->id,
+                'starts_at' => $lockedItem->starts_at,
+                'ends_at' => $lockedItem->ends_at,
+                'status' => ReservationItemStatus::Held,
+                'notes' => "Substitui {$original->asset_tag}: {$reason}",
+            ]);
+            ApprovalAction::create([
+                'reservation_id' => $locked->id,
+                'actor_id' => $actor->id,
+                'action' => 'asset_substituted',
+                'previous_status' => $locked->status->value,
+                'new_status' => $locked->status->value,
+                'comment' => $reason,
+            ]);
+            AuditLog::create([
+                'actor_id' => $actor->id,
+                'event' => 'reservation.asset_substituted',
+                'auditable_type' => $locked->getMorphClass(),
+                'auditable_id' => $locked->id,
+                'metadata' => [
+                    'original_asset_id' => $original->id,
+                    'replacement_asset_id' => $newAsset->id,
+                    'reason' => $reason,
+                ],
+            ]);
+
+            return $locked->load('requester', 'items.asset');
+        }, 3);
+
+        $updated->requester->notify(new ReservationDecisionNotification($updated, 'asset_substituted', $reason));
+
+        return $updated;
    }

    private function authorize(User $actor): void
@@ -94,6 +179,15 @@ class ApprovalService
        }
    }

+    private function sameCategory(SnipeAsset $original, SnipeAsset $replacement): bool
+    {
+        if ($original->category_id !== null && $replacement->category_id !== null) {
+            return $original->category_id === $replacement->category_id;
+        }
+
+        return filled($original->category_name) && $original->category_name === $replacement->category_name;
+    }
+
    private function lockPending(Reservation $reservation): Reservation
    {
        $locked = Reservation::query()->whereKey($reservation->id)->lockForUpdate()->firstOrFail();
--- a/app/Domain/Reservations/Models/Reservation.php
+++ b/app/Domain/Reservations/Models/Reservation.php
@@ -2,6 +2,7 @@

 namespace App\Domain\Reservations\Models;

+use App\Domain\Approvals\Models\ApprovalAction;
 use App\Domain\Reservations\Enums\ReservationStatus;
 use App\Models\User;
 use Carbon\CarbonImmutable;
@@ -57,4 +58,10 @@ class Reservation extends Model
    {
        return $this->hasMany(ReservationItem::class);
    }
+
+    /** @return HasMany<ApprovalAction, $this> */
+    public function approvalActions(): HasMany
+    {
+        return $this->hasMany(ApprovalAction::class)->latest('created_at');
+    }
 }
--- a/app/Domain/Reservations/Services/ReservationService.php
+++ b/app/Domain/Reservations/Services/ReservationService.php
@@ -2,15 +2,19 @@

 namespace App\Domain\Reservations\Services;

+use App\Domain\Approvals\Models\ApprovalAction;
 use App\Domain\Audit\Models\AuditLog;
+use App\Domain\Identity\Enums\RoleName;
 use App\Domain\Inventory\Models\SnipeAsset;
 use App\Domain\Reservations\Enums\ReservationItemStatus;
 use App\Domain\Reservations\Enums\ReservationStatus;
 use App\Domain\Reservations\Models\Reservation;
 use App\Models\User;
+use App\Notifications\ReservationSubmittedNotification;
 use Carbon\CarbonImmutable;
 use Illuminate\Auth\Access\AuthorizationException;
 use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Notification;
 use Illuminate\Support\Str;
 use Illuminate\Validation\ValidationException;

@@ -26,7 +30,7 @@ class ReservationService
        $startsAt = CarbonImmutable::parse($data['starts_at']);
        $endsAt = CarbonImmutable::parse($data['ends_at']);

-        return DB::transaction(function () use ($requester, $data, $startsAt, $endsAt): Reservation {
+        $reservation = DB::transaction(function () use ($requester, $data, $startsAt, $endsAt): Reservation {
            $assets = SnipeAsset::query()
                ->whereKey($data['asset_ids'])
                ->lockForUpdate()
@@ -75,8 +79,19 @@ class ReservationService
                'metadata' => ['asset_ids' => $assets->modelKeys()],
            ]);

-            return $reservation->load('items.asset');
+            return $reservation->load('requester', 'items.asset');
        }, 3);
+
+        $approvers = User::query()
+            ->where('active', true)
+            ->whereHas('roles', fn ($query) => $query->whereIn('name', [
+                RoleName::Approver->value,
+                RoleName::Administrator->value,
+            ]))
+            ->get();
+        Notification::send($approvers, new ReservationSubmittedNotification($reservation));
+
+        return $reservation;
    }

    public function cancel(Reservation $reservation, User $actor, string $reason): Reservation
@@ -124,6 +139,61 @@ class ReservationService
        }, 3);
    }

+    public function respondToInformation(Reservation $reservation, User $actor, string $response): Reservation
+    {
+        if ($reservation->requester_id !== $actor->id) {
+            throw new AuthorizationException('Apenas o requisitante pode responder a este pedido.');
+        }
+
+        $updated = DB::transaction(function () use ($reservation, $actor, $response): Reservation {
+            $locked = Reservation::query()->whereKey($reservation->id)->lockForUpdate()->firstOrFail();
+            if (! $locked->status->canTransitionTo(ReservationStatus::PendingApproval)
+                || $locked->status !== ReservationStatus::AwaitingInformation) {
+                throw ValidationException::withMessages([
+                    'response' => 'Esta requisição não aguarda esclarecimentos.',
+                ]);
+            }
+
+            $locked->update([
+                'status' => ReservationStatus::PendingApproval,
+                'approval_deadline' => now()->addHours(48),
+            ]);
+            ApprovalAction::create([
+                'reservation_id' => $locked->id,
+                'actor_id' => $actor->id,
+                'action' => 'information_provided',
+                'previous_status' => ReservationStatus::AwaitingInformation->value,
+                'new_status' => ReservationStatus::PendingApproval->value,
+                'comment' => $response,
+            ]);
+            AuditLog::create([
+                'actor_id' => $actor->id,
+                'event' => 'reservation.information_provided',
+                'auditable_type' => $locked->getMorphClass(),
+                'auditable_id' => $locked->id,
+                'before' => ['status' => ReservationStatus::AwaitingInformation->value],
+                'after' => ['status' => ReservationStatus::PendingApproval->value],
+                'metadata' => ['response' => $response],
+            ]);
+
+            return $locked->load('requester', 'items.asset');
+        }, 3);
+
+        $approvers = User::query()
+            ->where('active', true)
+            ->whereHas('roles', fn ($query) => $query->whereIn('name', [
+                RoleName::Approver->value,
+                RoleName::Administrator->value,
+            ]))
+            ->get();
+        Notification::send(
+            $approvers,
+            new ReservationSubmittedNotification($updated, 'information_provided'),
+        );
+
+        return $updated;
+    }
+
    public function expirePending(int $limit = 100): int
    {
        $reservationIds = Reservation::query()