@fleetbase/fleetops-engine 0.6.50 → 0.6.52

package/server/src/Http/Controllers/Internal/v1/IssueController.php

@@ -6,9 +6,15 @@ use Fleetbase\FleetOps\Exports\IssueExport;
 use Fleetbase\FleetOps\Http\Controllers\FleetOpsController;
 use Fleetbase\FleetOps\Imports\IssueImport;
 use Fleetbase\FleetOps\Models\Issue;
+use Fleetbase\FleetOps\Models\Order;
 use Fleetbase\Http\Requests\ExportRequest;
 use Fleetbase\Http\Requests\ImportRequest;
+use Fleetbase\Models\Activity;
+use Fleetbase\Models\Comment;
+use Fleetbase\Models\File;
+use Fleetbase\Models\User;
 use Illuminate\Http\Request;
+use Illuminate\Support\Collection;
 use Illuminate\Support\Str;
 use Maatwebsite\Excel\Facades\Excel;
 
@@ -26,10 +32,255 @@ class IssueController extends FleetOpsController
      */
     public function afterSave(Request $request, Issue $issue)
     {
+        if ($issue->assigned_to_uuid) {
+            $assignee = User::where('uuid', $issue->assigned_to_uuid)->first();
+
+            if ($assignee && $assignee->type === 'customer') {
+                $issue->assigned_to_uuid = null;
+                $issue->saveQuietly();
+            }
+        }
+
         $customFieldValues = $request->array('issue.custom_field_values');
         if ($customFieldValues) {
             $issue->syncCustomFieldValues($customFieldValues);
         }
+
+        $uploads = $request->array('issue.files');
+        if ($uploads) {
+            File::whereIn('uuid', $uploads)->get()->each(function (File $file) use ($issue) {
+                $file->setKey($issue);
+            });
+        }
+
+        if (!$issue->order_uuid && data_get($issue, 'meta.order_uuid')) {
+            $order = Order::where('uuid', data_get($issue, 'meta.order_uuid'))->where('company_uuid', $issue->company_uuid)->first();
+            if ($order) {
+                $issue->order_uuid = $order->uuid;
+                $issue->saveQuietly();
+            }
+        }
+    }
+
+    /**
+     * Return curated activity timeline entries for an issue.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function timeline($id)
+    {
+        $issue = Issue::findById($id, ['reporter', 'assignee']);
+
+        if (!$issue || $issue->company_uuid !== session('company')) {
+            return response()->error('Issue not found for this organization.', 404);
+        }
+
+        $events = collect([$this->makeIssueOpenedEvent($issue)])
+            ->merge($this->issueActivityEvents($issue))
+            ->merge($this->commentEvents($issue))
+            ->merge($this->fileEvents($issue))
+            ->sortByDesc('created_at')
+            ->values();
+
+        return response()->json(['events' => $events]);
+    }
+
+    protected function issueActivityEvents(Issue $issue): Collection
+    {
+        return Activity::with(['causer'])
+            ->where('subject_type', Issue::class)
+            ->where('subject_id', $issue->uuid)
+            ->latest()
+            ->get()
+            ->flatMap(function (Activity $activity) use ($issue) {
+                if ($activity->event === 'created') {
+                    return [];
+                }
+
+                $events = [];
+                foreach (['status', 'priority', 'assigned_to_uuid', 'vehicle_uuid', 'driver_uuid', 'order_uuid', 'type', 'category', 'tags', 'resolved_at'] as $field) {
+                    $from = data_get($activity->properties, "old.{$field}");
+                    $to   = data_get($activity->properties, "attributes.{$field}");
+
+                    if ($from === $to || $to === null) {
+                        continue;
+                    }
+
+                    $events[] = $this->makeFieldChangedEvent($activity, $issue, $field, $from, $to);
+                }
+
+                return $events ?: [$this->makeGenericActivityEvent($activity, $issue)];
+            });
+    }
+
+    protected function commentEvents(Issue $issue): Collection
+    {
+        return Comment::with(['author'])
+            ->where('subject_type', Issue::class)
+            ->where('subject_uuid', $issue->uuid)
+            ->latest()
+            ->get()
+            ->map(function (Comment $comment) {
+                return [
+                    'id'               => $comment->uuid,
+                    'type'             => 'correspondence_added',
+                    'label'            => 'Correspondence added',
+                    'description'      => Str::limit(strip_tags($comment->content ?? ''), 120),
+                    'actor_name'       => data_get($comment, 'author.name', 'Someone'),
+                    'actor_avatar_url' => data_get($comment, 'author.avatar_url'),
+                    'created_at'       => $comment->created_at,
+                    'icon'             => 'comment',
+                    'tone'             => 'blue',
+                    'meta'             => [
+                        'comment_id' => $comment->public_id ?? $comment->uuid,
+                    ],
+                ];
+            });
+    }
+
+    protected function fileEvents(Issue $issue): Collection
+    {
+        $currentFiles = File::with(['uploader'])
+            ->where('subject_type', Issue::class)
+            ->where('subject_uuid', $issue->uuid)
+            ->latest()
+            ->get()
+            ->map(function (File $file) {
+                return [
+                    'id'               => $file->uuid,
+                    'type'             => 'document_uploaded',
+                    'label'            => 'Document uploaded',
+                    'description'      => $file->original_filename,
+                    'actor_name'       => data_get($file, 'uploader.name', 'Someone'),
+                    'actor_avatar_url' => data_get($file, 'uploader.avatar_url'),
+                    'created_at'       => $file->created_at,
+                    'icon'             => 'file-arrow-up',
+                    'tone'             => 'purple',
+                    'meta'             => [
+                        'file_id'   => $file->public_id ?? $file->uuid,
+                        'file_name' => $file->original_filename,
+                        'file_url'  => $file->url,
+                    ],
+                ];
+            });
+
+        $fileActivities = Activity::with(['causer'])
+            ->where('subject_type', File::class)
+            ->where(function ($query) use ($issue) {
+                $query->where('properties->attributes->subject_uuid', $issue->uuid)
+                    ->orWhere('properties->old->subject_uuid', $issue->uuid);
+            })
+            ->latest()
+            ->get()
+            ->filter(fn (Activity $activity) => $activity->event === 'deleted')
+            ->map(function (Activity $activity) {
+                $fileName = data_get($activity->properties, 'old.original_filename')
+                    ?? data_get($activity->properties, 'attributes.original_filename')
+                    ?? 'Document';
+
+                return [
+                    'id'               => $activity->uuid ?? $activity->id,
+                    'type'             => 'document_removed',
+                    'label'            => 'Document removed',
+                    'description'      => $fileName,
+                    'actor_name'       => data_get($activity, 'causer.name', 'Someone'),
+                    'actor_avatar_url' => data_get($activity, 'causer.avatar_url'),
+                    'created_at'       => $activity->created_at,
+                    'icon'             => 'file-circle-xmark',
+                    'tone'             => 'red',
+                    'meta'             => [
+                        'file_name' => $fileName,
+                    ],
+                ];
+            });
+
+        return $currentFiles->merge($fileActivities);
+    }
+
+    protected function makeIssueOpenedEvent(Issue $issue): array
+    {
+        return [
+            'id'               => $issue->uuid . '-opened',
+            'type'             => 'issue_opened',
+            'label'            => 'Issue opened',
+            'description'      => 'Reported by ' . ($issue->reporter_name ?: 'Unknown reporter'),
+            'actor_name'       => $issue->reporter_name ?: 'Unknown reporter',
+            'actor_avatar_url' => data_get($issue, 'reporter.avatar_url'),
+            'created_at'       => $issue->created_at,
+            'icon'             => 'circle-plus',
+            'tone'             => 'green',
+            'meta'             => [
+                'issue_id' => $issue->public_id,
+            ],
+        ];
+    }
+
+    protected function makeFieldChangedEvent(Activity $activity, Issue $issue, string $field, $from, $to): array
+    {
+        $eventMap = [
+            'status'           => ['status_changed', 'Status changed', 'arrows-rotate', 'blue'],
+            'priority'         => ['priority_changed', 'Priority changed', 'flag', 'orange'],
+            'assigned_to_uuid' => ['assignee_changed', 'Assignee changed', 'user-check', 'indigo'],
+            'vehicle_uuid'     => ['vehicle_changed', 'Vehicle linked', 'truck', 'slate'],
+            'driver_uuid'      => ['driver_changed', 'Driver linked', 'id-card', 'slate'],
+            'order_uuid'       => ['order_changed', 'Order linked', 'box', 'slate'],
+            'resolved_at'      => [$to ? 'issue_closed' : 'issue_reopened', $to ? 'Issue closed' : 'Issue re-opened', $to ? 'circle-check' : 'rotate-left', $to ? 'green' : 'orange'],
+        ];
+
+        [$type, $label, $icon, $tone] = $eventMap[$field] ?? ['issue_updated', Str::headline(str_replace('_uuid', '', $field)) . ' changed', 'pen', 'slate'];
+
+        if ($field === 'status' && in_array($to, ['closed', 'resolved', 'completed'])) {
+            [$type, $label, $icon, $tone] = ['issue_closed', 'Issue closed', 'circle-check', 'green'];
+        }
+
+        if ($field === 'status' && $to === 're_opened') {
+            [$type, $label, $icon, $tone] = ['issue_reopened', 'Issue re-opened', 'rotate-left', 'orange'];
+        }
+
+        return [
+            'id'               => ($activity->uuid ?? $activity->id) . '-' . $field,
+            'type'             => $type,
+            'label'            => $label,
+            'description'      => $this->formatChangeDescription($field, $from, $to),
+            'actor_name'       => data_get($activity, 'causer.name', 'Someone'),
+            'actor_avatar_url' => data_get($activity, 'causer.avatar_url'),
+            'created_at'       => $activity->created_at,
+            'icon'             => $icon,
+            'tone'             => $tone,
+            'meta'             => [
+                'field'    => $field,
+                'from'     => $from,
+                'to'       => $to,
+                'issue_id' => $issue->public_id,
+            ],
+        ];
+    }
+
+    protected function makeGenericActivityEvent(Activity $activity, Issue $issue): array
+    {
+        return [
+            'id'               => $activity->uuid ?? $activity->id,
+            'type'             => 'issue_updated',
+            'label'            => 'Issue updated',
+            'description'      => $activity->description,
+            'actor_name'       => data_get($activity, 'causer.name', 'Someone'),
+            'actor_avatar_url' => data_get($activity, 'causer.avatar_url'),
+            'created_at'       => $activity->created_at,
+            'icon'             => 'pen',
+            'tone'             => 'slate',
+            'meta'             => [
+                'issue_id' => $issue->public_id,
+            ],
+        ];
+    }
+
+    protected function formatChangeDescription(string $field, $from, $to): string
+    {
+        $fieldLabel = Str::headline(str_replace('_uuid', '', $field));
+        $fromLabel  = blank($from) ? 'none' : Str::headline((string) $from);
+        $toLabel    = blank($to) ? 'none' : Str::headline((string) $to);
+
+        return "{$fieldLabel} changed from {$fromLabel} to {$toLabel}.";
     }
 
     /**

package/server/src/Http/Controllers/Internal/v1/OrderController.php

@@ -47,7 +47,6 @@ use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Storage;
 use Illuminate\Support\Facades\Validator;
 use Illuminate\Support\Str;
-use Illuminate\Validation\ValidationException;
 use Maatwebsite\Excel\Facades\Excel;
 
 class OrderController extends FleetOpsController
@@ -676,28 +675,9 @@ class OrderController extends FleetOpsController
         // get the next order activity
         $flow = $activity = $order->config()->nextFirstActivity();
 
-        /**
-         * @var \Fleetbase\LaravelMysqlSpatial\Types\Point
-         */
-        $location = $order->getLastLocation();
-
-        // if multi drop order set first destination
-        if ($payload->isMultipleDropOrder) {
-            $firstDestination = $payload->waypoints->first();
-
-            if ($firstDestination) {
-                $payload->current_waypoint_uuid = $firstDestination->uuid;
-                $payload->save();
-            }
-
-            // update activity for each waypoint and entity
-            foreach ($payload->waypointMarkers as $waypointMarker) {
-                $waypointMarker->insertActivity($activity, $location);
-            }
-
-            foreach ($payload->entities as $entity) {
-                $entity->insertActivity($activity, $location);
-            }
+        // if multi-stop route set first service stop destination
+        if ($this->payloadUsesServiceStopActivity($payload)) {
+            $this->ensurePayloadCurrentServiceStop($payload);
         }
 
         // update order activity
@@ -729,9 +709,16 @@ class OrderController extends FleetOpsController
             return response()->error('No order found.');
         }
 
-        $proof    = $request->input('proof');
-        $activity = $request->array('activity');
-        $activity = new Activity($activity, $order->getConfigFlow());
+        $proof       = $request->input('proof');
+        $bypassProof = $request->boolean('bypass_proof');
+        $activity    = $request->array('activity');
+        $activity    = new Activity($activity, $order->getConfigFlow());
+
+        $requiresProof = Utils::isActivity($activity)
+            && ($activity->get('require_pod') || ($activity->completesOrder() && $order->pod_required));
+        if ($requiresProof && !$proof && !$bypassProof) {
+            return response()->error('Proof of delivery is required for this activity or must be explicitly bypassed.', 422);
+        }
 
         // Handle pickup/dropoff order activity update as normal
         if (Utils::isActivity($activity) && $activity->is('dispatched')) {
@@ -751,15 +738,20 @@ class OrderController extends FleetOpsController
          * @var \Fleetbase\LaravelMysqlSpatial\Types\Point
          */
         $location                = $order->getLastLocation();
-        $isMultipleWaypointOrder = $this->payloadHasWaypoints($order->payload);
+        $usesServiceStopActivity = $this->payloadUsesServiceStopActivity($order->payload);
+        $isLifecycleActivity     = Utils::isActivity($activity) && in_array($activity->code, ['created', 'dispatched', 'started'], true);
 
-        if (!$isMultipleWaypointOrder) {
+        if (!$usesServiceStopActivity || $isLifecycleActivity) {
             $order->updateActivity($activity, $proof);
 
-            // also update for each order entities if not multiple drop order
-            // all entities will share the same activity status as is one drop order
-            foreach ($order->payload->entities as $entity) {
-                $entity->insertActivity($activity, $location, $proof);
+            if (!$usesServiceStopActivity) {
+                foreach ($order->payload->entities as $entity) {
+                    $entity->insertActivity($activity, $location, $proof);
+                }
+            }
+
+            if ($usesServiceStopActivity && $activity->is('started')) {
+                $this->ensurePayloadCurrentServiceStop($order->payload);
             }
 
             // Handle order completed
@@ -772,23 +764,6 @@ class OrderController extends FleetOpsController
             return new OrderResource($order->refresh());
         }
 
-        if ($activity->is('dispatched')) {
-            $order->updateActivity($activity, $proof);
-
-            return new OrderResource($order->refresh());
-        }
-
-        if ($activity->is('started')) {
-            $order->updateActivity($activity, $proof);
-
-            $this->ensurePayloadCurrentServiceStop($order->payload);
-            if (!$this->payloadHasCurrentServiceStopActivity($order->payload, $activity)) {
-                $this->updateCurrentServiceStopActivity($order, $activity, $location, $proof);
-            }
-
-            return new OrderResource($order->refresh());
-        }
-
         if (!$order->started && in_array($order->status, ['created', 'dispatched'])) {
             return response()->error('Order must be started before waypoint activity can be updated.', 422);
         }
@@ -836,18 +811,21 @@ class OrderController extends FleetOpsController
             return response()->error('No order found.');
         }
 
-        $canUpdateWaypointActivity = $order->started || $order->started_at || !in_array($order->status, ['created', 'dispatched']);
+        $order->loadMissing([
+            'payload.pickup',
+            'payload.dropoff',
+            'payload.waypoints',
+            'payload.waypointMarkers.place',
+            'payload.waypointMarkers.trackingNumber.status',
+        ]);
+
+        $canUpdateWaypointActivity = $this->payloadUsesServiceStopActivity($order->payload)
+            && ($order->started || $order->started_at || !in_array($order->status, ['created', 'dispatched']));
         $stop                      = null;
-        if ($request->filled('waypoint') && $canUpdateWaypointActivity) {
-            $order->loadMissing([
-                'payload.pickup',
-                'payload.dropoff',
-                'payload.return',
-                'payload.waypoints',
-                'payload.waypointMarkers.place',
-                'payload.waypointMarkers.trackingNumber.status',
-            ]);
-            $stop = $this->resolveServiceStopFromKey($order->payload, $request->input('waypoint'));
+        if ($canUpdateWaypointActivity) {
+            $stop = $request->filled('waypoint')
+                ? $this->resolveServiceStopFromKey($order->payload, $request->input('waypoint'))
+                : $this->payloadCurrentServiceStop($order->payload);
         }
         $orderConfig = $order->ensureOrderConfig();
         if (!$orderConfig) {
@@ -896,7 +874,7 @@ class OrderController extends FleetOpsController
             return response()->error('No order found.');
         }
 
-        if (!$this->payloadHasWaypoints($order->payload)) {
+        if (!$this->payloadUsesServiceStopActivity($order->payload)) {
             return response()->error('Destination can only be changed for multi-waypoint orders.', 422);
         }
 
@@ -917,35 +895,43 @@ class OrderController extends FleetOpsController
      */
     public function capturePhoto(Request $request, string $id, ?string $subjectId = null)
     {
-        try {
-            $request->validate([
-                'photos'   => 'required|array|min:1',
-                'photos.*' => [
-                    function ($attribute, $value, $fail) {
-                        if ($value instanceof UploadedFile) {
-                            if (
-                                !$value->isValid()
-                                || !in_array($value->extension(), ['jpg', 'jpeg', 'png', 'gif', 'webp'])
-                                || $value->getSize() > 10 * 1024 * 1024
-                            ) {
-                                $fail("{$attribute} must be a valid image file <= 10 MB.");
-                            }
-
-                            return;
+        $incoming  = $this->collectProofPhotoInputs($request);
+        $metadata  = $request->input('data', []);
+        $metadata  = is_array($metadata) ? $metadata : [];
+        $validator = Validator::make([
+            'photos'  => $incoming,
+            'remarks' => $request->input('remarks'),
+            'data'    => $metadata,
+        ], [
+            'photos'   => 'required|array|min:1',
+            'photos.*' => [
+                function ($attribute, $value, $fail) {
+                    if ($value instanceof UploadedFile) {
+                        $extension = strtolower($value->getClientOriginalExtension() ?: $value->extension());
+                        if (
+                            !$value->isValid()
+                            || !in_array($extension, ['jpg', 'jpeg', 'png', 'gif', 'webp'])
+                            || $value->getSize() > 10 * 1024 * 1024
+                        ) {
+                            $fail("{$attribute} must be a valid image file <= 10 MB.");
                         }
 
-                        if (is_string($value) && base64_decode($value, true) !== false) {
-                            return;
-                        }
+                        return;
+                    }
 
-                        $fail("{$attribute} must be an image file or a valid Base64 string.");
-                    },
-                ],
-                'remarks'  => 'sometimes|string|max:255',
-                'data'     => 'sometimes|array',
-            ]);
-        } catch (ValidationException $e) {
-            $errorMessage = collect($e->errors())->flatten()->first();
+                    if ($this->isValidBase64ProofPhoto($value)) {
+                        return;
+                    }
+
+                    $fail("{$attribute} must be an image file or a valid Base64 string.");
+                },
+            ],
+            'remarks'  => 'sometimes|string|max:255',
+            'data'     => 'sometimes|array',
+        ]);
+
+        if ($validator->fails()) {
+            $errorMessage = collect($validator->errors()->all())->first();
 
             return response()->error($errorMessage, 422);
         }
@@ -960,15 +946,10 @@ class OrderController extends FleetOpsController
             return response()->error('Unable to capture photo as proof.', 422);
         }
 
-        $disk         = $request->input('disk', config('filesystems.default'));
-        $bucket       = $request->input("filesystems.disks.{$disk}.bucket", config('filesystems.disks.s3.bucket'));
-        $rawInputs    = $request->file('photos', []);
-        $base64Inputs = array_filter($request->input('photos', []), function ($value) {
-            return is_string($value) && base64_decode($value, true) !== false;
-        });
-        $incoming     = array_merge($rawInputs, $base64Inputs);
-        $remarks      = $request->input('remarks', 'Verified by Photo');
-        $data         = $request->input('data', []);
+        $disk    = $request->input('disk', config('filesystems.default'));
+        $bucket  = $request->input("filesystems.disks.{$disk}.bucket", config('filesystems.disks.s3.bucket'));
+        $remarks = $request->input('remarks', 'Verified by Photo');
+        $data    = $metadata;
 
         if (empty($incoming)) {
             return response()->error('No photo data to capture.', 422);
@@ -992,13 +973,107 @@ class OrderController extends FleetOpsController
         return new ProofResource($proof);
     }
 
+    /**
+     * Normalize console proof upload payloads into one photo list before validation.
+     */
+    protected function collectProofPhotoInputs(Request $request): array
+    {
+        $incoming = [];
+        foreach (['photos', 'photo', 'files', 'file'] as $key) {
+            $this->appendProofPhotoInputs($incoming, $request->file($key));
+            $this->appendProofPhotoInputs($incoming, $request->input($key));
+        }
+
+        $incoming = array_values(array_filter($incoming, function ($value) {
+            return $value instanceof UploadedFile || is_string($value);
+        }));
+
+        return $this->dedupeProofPhotoInputs($incoming);
+    }
+
+    /**
+     * Append a nested file/input value to the proof input list.
+     */
+    protected function appendProofPhotoInputs(array &$incoming, mixed $value): void
+    {
+        if ($value === null) {
+            return;
+        }
+
+        if (is_array($value)) {
+            foreach ($value as $nested) {
+                $this->appendProofPhotoInputs($incoming, $nested);
+            }
+
+            return;
+        }
+
+        $incoming[] = $value;
+    }
+
+    /**
+     * Remove duplicate photo inputs exposed under multiple multipart aliases.
+     */
+    protected function dedupeProofPhotoInputs(array $incoming): array
+    {
+        $seen = [];
+
+        return array_values(array_filter($incoming, function ($value) use (&$seen) {
+            $fingerprint = $this->proofPhotoInputFingerprint($value);
+            if ($fingerprint === null || isset($seen[$fingerprint])) {
+                return false;
+            }
+
+            $seen[$fingerprint] = true;
+
+            return true;
+        }));
+    }
+
+    /**
+     * Build a stable fingerprint for an uploaded file or Base64 proof payload.
+     */
+    protected function proofPhotoInputFingerprint(mixed $value): ?string
+    {
+        if ($value instanceof UploadedFile) {
+            return hash('sha256', implode('|', [
+                $value->getRealPath(),
+                $value->getSize(),
+                $value->getClientOriginalName(),
+                $value->getClientMimeType(),
+            ]));
+        }
+
+        if (is_string($value)) {
+            $payload = Str::contains($value, 'base64,') ? Str::after($value, 'base64,') : $value;
+
+            return hash('sha256', $payload);
+        }
+
+        return null;
+    }
+
+    /**
+     * Determine whether a proof input is a usable Base64 image payload.
+     */
+    protected function isValidBase64ProofPhoto(mixed $value): bool
+    {
+        if (!is_string($value)) {
+            return false;
+        }
+
+        $payload = Str::contains($value, 'base64,') ? Str::after($value, 'base64,') : $value;
+
+        return base64_decode($payload, true) !== false;
+    }
+
     /**
      * Store a proof photo and create its file record.
      */
     protected function storeProofPhoto(Proof $proof, UploadedFile|string $photo, string $disk, string $bucket): File
     {
         $isFile      = $photo instanceof UploadedFile;
-        $contents    = $isFile ? file_get_contents($photo->getRealPath()) : base64_decode($photo);
+        $contents    = $isFile ? file_get_contents($photo->getRealPath()) : base64_decode(Str::contains($photo, 'base64,') ? Str::after($photo, 'base64,') : $photo);
         $extension   = $isFile ? $photo->getClientOriginalExtension() : 'png';
         $contentType = $isFile ? $photo->getClientMimeType() : 'image/png';
         $company     = session('company');