@fleetbase/fleetops-engine 0.6.42 → 0.6.44

package/server/src/Events/GeofenceExited.php

@@ -0,0 +1,213 @@
+<?php
+
+namespace Fleetbase\FleetOps\Events;
+
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Broadcasting\Channel;
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+/**
+ * GeofenceExited.
+ *
+ * Fired when a driver's location update causes them to cross out of a
+ * geofence boundary (Zone or ServiceArea) that they were previously inside.
+ *
+ * Listeners:
+ *   - HandleGeofenceExited  (event log)
+ *   - SendResourceLifecycleWebhook  (webhook delivery)
+ */
+class GeofenceExited implements ShouldBroadcast
+{
+    use Dispatchable;
+    use InteractsWithSockets;
+    use SerializesModels;
+
+    public string $modelHumanName   = 'Geofence';
+    public ?string $modelRecordName = null;
+    public string $eventName        = 'exited';
+    public $userSession;
+    public $companySession;
+    public $requestMethod;
+    public $apiCredential;
+    public $apiSecret;
+    public $apiKey;
+    public $apiEnvironment;
+    public $isSandbox;
+    public array $data = [];
+
+    /**
+     * The driver who exited the geofence.
+     */
+    public ?Driver $driver = null;
+
+    /**
+     * The vehicle associated with the geofence event, if any.
+     */
+    public ?Vehicle $vehicle = null;
+
+    /**
+     * The geofence that was exited (Zone or ServiceArea model instance).
+     *
+     * @var \Fleetbase\FleetOps\Models\Zone|\Fleetbase\FleetOps\Models\ServiceArea
+     */
+    public $geofence;
+
+    /**
+     * The type of geofence: 'zone' or 'service_area'.
+     */
+    public string $geofenceType;
+
+    /**
+     * The driver's location at the time of exit.
+     */
+    public Point $location;
+
+    /**
+     * The timestamp when the exit was detected.
+     */
+    public \Carbon\Carbon $timestamp;
+
+    /**
+     * How many minutes the driver was inside the geofence before exiting.
+     * Null if the entry time was not recorded.
+     */
+    public ?int $dwellDurationMinutes;
+
+    /**
+     * The subject that triggered the event: 'driver' or 'vehicle'.
+     */
+    public string $subjectType;
+
+    /**
+     * Create a new GeofenceExited event.
+     *
+     * @param mixed  $geofence     Zone or ServiceArea
+     * @param string $geofenceType 'zone' | 'service_area'
+     */
+    public function __construct(Driver|Vehicle $subject, $geofence, string $geofenceType, Point $location, ?int $dwellDurationMinutes = null)
+    {
+        if ($subject instanceof Driver) {
+            $this->driver      = $subject;
+            $this->vehicle     = $subject->vehicle;
+            $this->subjectType = 'driver';
+        } else {
+            $subject->loadMissing('driver');
+            $this->vehicle     = $subject;
+            $this->driver      = $subject->driver;
+            $this->subjectType = 'vehicle';
+        }
+
+        $this->geofence             = $geofence;
+        $this->geofenceType         = $geofenceType;
+        $this->location             = $location;
+        $this->timestamp            = now();
+        $this->dwellDurationMinutes = $dwellDurationMinutes;
+        $this->modelRecordName      = $geofence->name ?? $geofence->public_id ?? $geofence->uuid ?? null;
+        $this->userSession          = session('user');
+        $this->companySession       = session('company', $this->getCompanyUuid());
+        $this->requestMethod        = request()?->method() ?? 'CLI';
+        $this->apiCredential        = session('api_credential', 'console');
+        $this->apiSecret            = session('api_secret', 'internal');
+        $this->apiKey               = session('api_key');
+        $this->apiEnvironment       = session('api_environment', 'live');
+        $this->isSandbox            = session('is_sandbox', false);
+        $this->data                 = $this->getEventData();
+    }
+
+    /**
+     * Returns the company UUID for this event.
+     */
+    public function getCompanyUuid(): string
+    {
+        return $this->vehicle?->company_uuid ?? $this->driver->company_uuid;
+    }
+
+    public function broadcastOn(): array
+    {
+        $channels = [new Channel('company.' . $this->getCompanyUuid())];
+
+        if ($this->driver) {
+            $channels[] = new Channel('driver.' . $this->driver->public_id);
+            $channels[] = new Channel('driver.' . $this->driver->uuid);
+        }
+
+        if ($this->vehicle) {
+            $channels[] = new Channel('vehicle.' . $this->vehicle->public_id);
+            $channels[] = new Channel('vehicle.' . $this->vehicle->uuid);
+        }
+
+        return $channels;
+    }
+
+    public function broadcastAs(): string
+    {
+        return 'geofence.exited';
+    }
+
+    /**
+     * Returns the standardised webhook payload for this event.
+     */
+    public function broadcastWith(): array
+    {
+        return $this->getEventData();
+    }
+
+    public function getEventData(): array
+    {
+        $driver   = $this->driver;
+        $vehicle  = $this->vehicle;
+        $geofence = $this->geofence;
+        $subject  = $this->subjectType === 'vehicle' ? $vehicle : $driver;
+
+        $payload = [
+            'event'                  => $this->broadcastAs(),
+            'event_type'             => 'geofence.exited',
+            'occurred_at'            => $this->timestamp->toIso8601String(),
+            'dwell_duration_minutes' => $this->dwellDurationMinutes,
+            'subject'                => [
+                'type' => $this->subjectType,
+                'id'   => $subject?->public_id ?? null,
+                'uuid' => $subject?->uuid ?? null,
+                'name' => $this->subjectType === 'vehicle' ? ($vehicle?->display_name ?? $vehicle?->plate_number) : $driver?->name,
+            ],
+            'driver'                 => $driver ? [
+                'id'    => $driver->public_id,
+                'uuid'  => $driver->uuid,
+                'name'  => $driver->name,
+                'phone' => $driver->phone,
+            ] : null,
+            'vehicle'                => $vehicle ? [
+                'id'    => $vehicle->public_id,
+                'uuid'  => $vehicle->uuid,
+                'name'  => $vehicle->display_name ?? null,
+                'plate' => $vehicle->plate_number ?? null,
+            ] : null,
+            'geofence' => [
+                'id'   => $geofence->public_id,
+                'uuid' => $geofence->uuid,
+                'name' => $geofence->name,
+                'type' => $this->geofenceType,
+            ],
+            'location' => [
+                'latitude'  => $this->location->getLat(),
+                'longitude' => $this->location->getLng(),
+            ],
+        ];
+
+        $order = $driver?->getCurrentOrder();
+        if ($order) {
+            $payload['order'] = [
+                'id'     => $order->public_id,
+                'uuid'   => $order->uuid,
+                'status' => $order->status,
+            ];
+        }
+
+        return $payload;
+    }
+}

package/server/src/Http/Controllers/Api/v1/DriverController.php

@@ -3,15 +3,20 @@
 namespace Fleetbase\FleetOps\Http\Controllers\Api\v1;
 
 use Fleetbase\FleetOps\Events\DriverLocationChanged;
+use Fleetbase\FleetOps\Events\GeofenceEntered;
+use Fleetbase\FleetOps\Events\GeofenceExited;
 use Fleetbase\FleetOps\Events\VehicleLocationChanged;
 use Fleetbase\FleetOps\Http\Requests\CreateDriverRequest;
 use Fleetbase\FleetOps\Http\Requests\DriverSimulationRequest;
 use Fleetbase\FleetOps\Http\Requests\UpdateDriverRequest;
 use Fleetbase\FleetOps\Http\Resources\v1\DeletedResource;
 use Fleetbase\FleetOps\Http\Resources\v1\Driver as DriverResource;
+use Fleetbase\FleetOps\Jobs\CheckGeofenceDwell;
 use Fleetbase\FleetOps\Jobs\SimulateDrivingRoute;
 use Fleetbase\FleetOps\Models\Driver;
 use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Models\Vehicle;
+use Fleetbase\FleetOps\Support\GeofenceIntersectionService;
 use Fleetbase\FleetOps\Support\OSRM;
 use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\Http\Controllers\Controller;
@@ -374,6 +379,29 @@ class DriverController extends Controller
 
         broadcast(new DriverLocationChanged($driver));
 
+        // ----------------------------------------------------------------
+        // Geofence intersection detection
+        //
+        // After broadcasting the location change, run the geofence engine
+        // asynchronously. We catch all exceptions so that a geofence error
+        // never prevents the location update response from being returned.
+        // ----------------------------------------------------------------
+        try {
+            $newLocation     = new Point($latitude, $longitude);
+            $geofenceService = app(GeofenceIntersectionService::class);
+            $this->processSubjectGeofenceCrossings($driver, $newLocation, 'driver_geofence_states', 'driver_uuid', $geofenceService->detectDriverCrossings($driver, $newLocation));
+
+            if ($vehicle) {
+                $vehicle->loadMissing('driver');
+                $this->processSubjectGeofenceCrossings($vehicle, $newLocation, 'vehicle_geofence_states', 'vehicle_uuid', $geofenceService->detectVehicleCrossings($vehicle, $newLocation));
+            }
+        } catch (\Throwable $geofenceException) {
+            // Log the error but never let geofence processing block the response
+            if (app()->bound('sentry')) {
+                app('sentry')->captureException($geofenceException);
+            }
+        }
+
         return new DriverResource($driver);
     }
 
@@ -917,4 +945,76 @@ class DriverController extends Controller
 
         return $phone;
     }
+
+    private function processSubjectGeofenceCrossings(Driver|Vehicle $subject, Point $newLocation, string $stateTable, string $subjectColumn, array $crossings): void
+    {
+        foreach ($crossings as $crossing) {
+            $geofence     = $crossing['geofence'];
+            $geofenceType = $crossing['geofence_type'];
+
+            if ($crossing['type'] === 'entered') {
+                if (!$geofence->trigger_on_entry && empty($geofence->dwell_threshold_minutes)) {
+                    continue;
+                }
+
+                DB::table($stateTable)->upsert(
+                    [
+                        $subjectColumn   => $subject->uuid,
+                        'geofence_uuid'  => $geofence->uuid,
+                        'geofence_type'  => $geofenceType,
+                        'is_inside'      => true,
+                        'entered_at'     => now(),
+                        'exited_at'      => null,
+                        'dwell_job_id'   => null,
+                        'created_at'     => now(),
+                        'updated_at'     => now(),
+                    ],
+                    [$subjectColumn, 'geofence_uuid'],
+                    ['is_inside', 'entered_at', 'exited_at', 'dwell_job_id', 'updated_at']
+                );
+
+                if ($geofence->trigger_on_entry) {
+                    event(new GeofenceEntered($subject, $geofence, $geofenceType, $newLocation));
+                }
+
+                if ($geofence->dwell_threshold_minutes > 0) {
+                    $dwellJob = CheckGeofenceDwell::dispatch(
+                        $subject->uuid,
+                        $geofence->uuid,
+                        $geofenceType,
+                        $subjectColumn === 'vehicle_uuid' ? 'vehicle' : 'driver'
+                    )->delay(now()->addMinutes($geofence->dwell_threshold_minutes));
+
+                    DB::table($stateTable)
+                        ->where($subjectColumn, $subject->uuid)
+                        ->where('geofence_uuid', $geofence->uuid)
+                        ->update(['dwell_job_id' => (string) $dwellJob]);
+                }
+            } elseif ($crossing['type'] === 'exited') {
+                $state = DB::table($stateTable)
+                    ->where($subjectColumn, $subject->uuid)
+                    ->where('geofence_uuid', $geofence->uuid)
+                    ->first();
+
+                $dwellMinutes = null;
+                if ($state && $state->entered_at) {
+                    $dwellMinutes = (int) Carbon::parse($state->entered_at)->diffInMinutes(now());
+                }
+
+                DB::table($stateTable)
+                    ->where($subjectColumn, $subject->uuid)
+                    ->where('geofence_uuid', $geofence->uuid)
+                    ->update([
+                        'is_inside'    => false,
+                        'exited_at'    => now(),
+                        'dwell_job_id' => null,
+                        'updated_at'   => now(),
+                    ]);
+
+                if ($geofence->trigger_on_exit) {
+                    event(new GeofenceExited($subject, $geofence, $geofenceType, $newLocation, $dwellMinutes));
+                }
+            }
+        }
+    }
 }

package/server/src/Http/Controllers/Api/v1/GeofenceController.php

@@ -0,0 +1,263 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Api\v1;
+
+use Fleetbase\FleetOps\Models\GeofenceEventLog;
+use Fleetbase\Http\Controllers\Controller;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\DB;
+
+/**
+ * GeofenceController.
+ *
+ * Exposes read-only API endpoints for querying geofence event data:
+ *   - Event log (paginated, filterable history of all geofence events)
+ *   - Real-time inventory (which drivers are currently inside which geofences)
+ *   - Dwell report (aggregated dwell time statistics per geofence)
+ */
+class GeofenceController extends Controller
+{
+    /**
+     * GET /api/v1/geofences/events.
+     *
+     * Returns a paginated log of geofence events for the authenticated company.
+     *
+     * Query parameters:
+     *   - driver_uuid   (string)  Filter by driver UUID
+     *   - geofence_uuid (string)  Filter by geofence UUID
+     *   - event_type    (string)  Filter by event type: entered | exited | dwelled
+     *   - from          (string)  Filter events after this ISO 8601 datetime
+     *   - to            (string)  Filter events before this ISO 8601 datetime
+     *   - per_page      (int)     Number of results per page (default: 50, max: 200)
+     */
+    public function events(Request $request): JsonResponse
+    {
+        $companyUuid = session('company');
+
+        $query = GeofenceEventLog::where('company_uuid', $companyUuid)
+            ->with(['driver.vehicle', 'vehicle', 'order'])
+            ->orderBy('occurred_at', 'desc');
+
+        if ($request->filled('driver_uuid')) {
+            $query->where('driver_uuid', $request->input('driver_uuid'));
+        }
+
+        if ($request->filled('geofence_uuid')) {
+            $query->where('geofence_uuid', $request->input('geofence_uuid'));
+        }
+
+        if ($request->filled('vehicle_uuid')) {
+            $query->where('vehicle_uuid', $request->input('vehicle_uuid'));
+        }
+
+        if ($request->filled('subject_type')) {
+            $query->where('subject_type', $request->input('subject_type'));
+        }
+
+        if ($request->filled('event_type')) {
+            $query->where('event_type', str_replace('geofence.', '', $request->input('event_type')));
+        }
+
+        if ($request->filled('from')) {
+            $query->where('occurred_at', '>=', $request->input('from'));
+        }
+
+        if ($request->filled('to')) {
+            $query->where('occurred_at', '<=', $request->input('to'));
+        }
+
+        $perPage = min((int) $request->input('per_page', 50), 200);
+
+        $events = $query->paginate($perPage);
+        $events->getCollection()->transform(fn (GeofenceEventLog $event) => $this->serializeEvent($event));
+
+        return response()->json($events);
+    }
+
+    /**
+     * GET /api/v1/geofences/inventory.
+     *
+     * Returns a real-time snapshot of which drivers are currently inside
+     * which geofences for the authenticated company.
+     */
+    public function inventory(): JsonResponse
+    {
+        $companyUuid = session('company');
+
+        $driverStates = DB::table('driver_geofence_states as dgs')
+            ->join('drivers as d', 'd.uuid', '=', 'dgs.driver_uuid')
+            ->leftJoin('zones as z', function ($join) {
+                $join->on('z.uuid', '=', 'dgs.geofence_uuid')
+                     ->where('dgs.geofence_type', '=', 'zone');
+            })
+            ->leftJoin('service_areas as sa', function ($join) {
+                $join->on('sa.uuid', '=', 'dgs.geofence_uuid')
+                     ->where('dgs.geofence_type', '=', 'service_area');
+            })
+            ->where('d.company_uuid', $companyUuid)
+            ->where('dgs.is_inside', true)
+            ->whereNull('d.deleted_at')
+            ->select([
+                DB::raw("'driver' as subject_type"),
+                'd.public_id as subject_id',
+                'd.uuid as subject_uuid',
+                'd.name as subject_name',
+                'dgs.driver_uuid',
+                'd.name as driver_name',
+                'dgs.entered_at',
+                'dgs.geofence_uuid',
+                DB::raw('COALESCE(z.name, sa.name) as geofence_name'),
+                'dgs.geofence_type',
+                DB::raw('TIMESTAMPDIFF(MINUTE, dgs.entered_at, NOW()) as minutes_inside'),
+            ])
+            ->get();
+
+        $vehicleStates = DB::table('vehicle_geofence_states as vgs')
+            ->join('vehicles as v', 'v.uuid', '=', 'vgs.vehicle_uuid')
+            ->leftJoin('zones as z', function ($join) {
+                $join->on('z.uuid', '=', 'vgs.geofence_uuid')
+                    ->where('vgs.geofence_type', '=', 'zone');
+            })
+            ->leftJoin('service_areas as sa', function ($join) {
+                $join->on('sa.uuid', '=', 'vgs.geofence_uuid')
+                    ->where('vgs.geofence_type', '=', 'service_area');
+            })
+            ->where('v.company_uuid', $companyUuid)
+            ->where('vgs.is_inside', true)
+            ->whereNull('v.deleted_at')
+            ->select([
+                DB::raw("'vehicle' as subject_type"),
+                'v.public_id as subject_id',
+                'v.uuid as subject_uuid',
+                DB::raw('COALESCE(v.name, v.plate_number, v.public_id) as subject_name'),
+                DB::raw('NULL as driver_uuid'),
+                DB::raw('NULL as driver_name'),
+                'vgs.entered_at',
+                'vgs.geofence_uuid',
+                DB::raw('COALESCE(z.name, sa.name) as geofence_name'),
+                'vgs.geofence_type',
+                DB::raw('TIMESTAMPDIFF(MINUTE, vgs.entered_at, NOW()) as minutes_inside'),
+            ])
+            ->get();
+
+        $states = $driverStates->merge($vehicleStates)->sortBy('entered_at')->values();
+
+        return response()->json([
+            'data'  => $states,
+            'total' => $states->count(),
+        ]);
+    }
+
+    /**
+     * GET /api/v1/geofences/dwell-report.
+     *
+     * Returns aggregated dwell time statistics per geofence for the
+     * authenticated company.
+     *
+     * Query parameters:
+     *   - from (string) Start of reporting period (ISO 8601)
+     *   - to   (string) End of reporting period (ISO 8601)
+     */
+    public function dwellReport(Request $request): JsonResponse
+    {
+        $companyUuid = session('company');
+
+        $query = GeofenceEventLog::where('company_uuid', $companyUuid)
+            ->where('event_type', 'exited')
+            ->whereNotNull('dwell_duration_minutes');
+
+        if ($request->filled('from')) {
+            $query->where('occurred_at', '>=', $request->input('from'));
+        }
+
+        if ($request->filled('to')) {
+            $query->where('occurred_at', '<=', $request->input('to'));
+        }
+
+        $report = $query
+            ->groupBy('geofence_uuid', 'geofence_name', 'geofence_type')
+            ->select([
+                'geofence_uuid',
+                'geofence_name',
+                'geofence_type',
+                DB::raw('COUNT(*) as visit_count'),
+                DB::raw('ROUND(AVG(dwell_duration_minutes), 1) as avg_dwell_minutes'),
+                DB::raw('MAX(dwell_duration_minutes) as max_dwell_minutes'),
+                DB::raw('MIN(dwell_duration_minutes) as min_dwell_minutes'),
+                DB::raw('SUM(dwell_duration_minutes) as total_dwell_minutes'),
+            ])
+            ->orderBy('visit_count', 'desc')
+            ->get();
+
+        return response()->json(['data' => $report]);
+    }
+
+    /**
+     * GET /api/v1/geofences/driver/{driverUuid}/history.
+     *
+     * Returns the geofence event history for a specific driver.
+     */
+    public function driverHistory(Request $request, string $driverUuid): JsonResponse
+    {
+        $companyUuid = session('company');
+        $perPage     = min((int) $request->input('per_page', 50), 200);
+
+        $events = GeofenceEventLog::where('company_uuid', $companyUuid)
+            ->where('driver_uuid', $driverUuid)
+            ->with(['driver.vehicle', 'vehicle', 'order'])
+            ->orderBy('occurred_at', 'desc')
+            ->paginate($perPage);
+
+        $events->getCollection()->transform(fn (GeofenceEventLog $event) => $this->serializeEvent($event));
+
+        return response()->json($events);
+    }
+
+    protected function serializeEvent(GeofenceEventLog $event): array
+    {
+        $driver      = $event->driver;
+        $vehicle     = $event->vehicle ?? $driver?->vehicle;
+        $subjectType = $event->subject_type ?? ($driver ? 'driver' : 'vehicle');
+        $subject     = $subjectType === 'vehicle' ? $vehicle : $driver;
+
+        return [
+            'id'                     => $event->uuid,
+            'event_type'             => 'geofence.' . $event->event_type,
+            'occurred_at'            => optional($event->occurred_at)->toIso8601String(),
+            'dwell_duration_minutes' => $event->dwell_duration_minutes,
+            'subject'                => [
+                'type' => $subjectType,
+                'id'   => $subject?->public_id,
+                'uuid' => $event->subject_uuid ?? $subject?->uuid,
+                'name' => $event->subject_name ?? ($subjectType === 'vehicle' ? ($vehicle?->display_name ?? $vehicle?->plate_number) : $driver?->name),
+            ],
+            'driver' => $driver ? [
+                'id'    => $driver->public_id,
+                'uuid'  => $driver->uuid,
+                'name'  => $driver->name,
+                'phone' => $driver->phone,
+            ] : null,
+            'vehicle' => $vehicle ? [
+                'id'    => $vehicle->public_id,
+                'uuid'  => $vehicle->uuid,
+                'name'  => $vehicle->display_name ?? $vehicle->name,
+                'plate' => $vehicle->plate_number,
+            ] : null,
+            'geofence' => [
+                'uuid' => $event->geofence_uuid,
+                'name' => $event->geofence_name,
+                'type' => $event->geofence_type,
+            ],
+            'location' => [
+                'latitude'  => $event->latitude,
+                'longitude' => $event->longitude,
+            ],
+            'order' => $event->order ? [
+                'id'     => $event->order->public_id,
+                'uuid'   => $event->order->uuid,
+                'status' => $event->order->status,
+            ] : null,
+        ];
+    }
+}

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

@@ -46,7 +46,7 @@ class OrderController extends Controller
     /**
      * Creates a new Fleetbase Order resource.
      *
-     * @param Request|\Fleetbase\Http\Requests\CreateOrderRequest $request
+     * @param Request|CreateOrderRequest $request
      *
      * @return \Fleetbase\Http\Resources\Order
      */
@@ -354,8 +354,7 @@ class OrderController extends Controller
     /**
      * Updates a Fleetbase Order resource.
      *
-     * @param string                                      $id
-     * @param \Fleetbase\Http\Requests\UpdateOrderRequest $request
+     * @param string $id
      *
      * @return \Fleetbase\Http\Resources\Order
      */
@@ -528,6 +527,12 @@ class OrderController extends Controller
             }
         }
 
+        // If adding a service quote for a purchase
+        $serviceQuote = ServiceQuote::resolveFromRequest($request);
+        if ($serviceQuote) {
+            $order->purchaseServiceQuote($serviceQuote);
+        }
+
         // dispatch if flagged true
         if ($request->boolean('dispatch')) {
             $order->dispatch();

package/server/src/Http/Controllers/Api/v1/ServiceAreaController.php

@@ -24,7 +24,7 @@ class ServiceAreaController extends Controller
     public function create(CreateServiceAreaRequest $request)
     {
         // get request input
-        $input = $request->only(['name', 'type', 'status']);
+        $input = $request->only(['name', 'type', 'status', 'country', 'color', 'stroke_color', 'trigger_on_entry', 'trigger_on_exit', 'dwell_threshold_minutes', 'speed_limit_kmh']);
 
         // get radius for creating service area border - default to 500 meters
         $radius = (int) $request->input('radius', 500);
@@ -98,7 +98,7 @@ class ServiceAreaController extends Controller
         }
 
         // get request input
-        $input = $request->only(['name', 'type', 'status']);
+        $input = $request->only(['name', 'type', 'status', 'country', 'color', 'stroke_color', 'trigger_on_entry', 'trigger_on_exit', 'dwell_threshold_minutes', 'speed_limit_kmh']);
 
         // get radius for creating service area border - default to 500 meters
         $radius = $request->input('radius', 500);