@fleetbase/fleetops-engine 0.2.5 → 0.2.7

package/server/src/Integrations/Lalamove/LalamoveDeliveryStop.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace Fleetbase\FleetOps\Integrations\Lalamove;
+
+use Fleetbase\FleetOps\Models\Place;
+use Grimzy\LaravelMysqlSpatial\Eloquent\SpatialExpression;
+use Grimzy\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Support\Str;
+
+class LalamoveDeliveryStop
+{
+    public $latitude;
+    public $longitude;
+    public $address;
+    public $stopId;
+
+    public function __construct($latitude, $longitude = null, ?string $address = '')
+    {
+        $this->stopId = (string) Str::uuid();
+
+        if ($latitude instanceof Place) {
+            $place = $latitude;
+
+            $this->address = $place->address;
+
+            if ($place->location instanceof SpatialExpression) {
+                $wkt   = $place->location->getSpatialValue();
+                $point = Point::fromWKT($wkt);
+
+                $this->latitude  = $point->getLat();
+                $this->longitude = $point->getLng();
+            } else {
+                $this->latitude  = $place->location->getLat();
+                $this->longitude = $place->location->getLng();
+            }
+        } elseif ($latitude instanceof Point) {
+            $point = $latitude;
+
+            $this->latitude  = $point->getLat();
+            $this->longitude = $point->getLng();
+            $this->address   = $address ?? '';
+        } else {
+            $this->latitude  = $latitude;
+            $this->longitude = $longitude;
+            $this->address   = $address;
+        }
+    }
+
+    public function __get(string $key)
+    {
+        $key = strtolower($key);
+
+        if (isset($this->{$key})) {
+            return $this->{$key};
+        }
+
+        return null;
+    }
+
+    public static function createFromPlace(Place $place)
+    {
+        $latitude  = $place->location->getLat();
+        $longitude = $place->location->getLng();
+        $address   = $place->address;
+
+        return new static($latitude, $longitude, $address);
+    }
+
+    public static function createFromPoint(Point $point, string $address = '')
+    {
+        $latitude  = $point->getLat();
+        $longitude = $point->getLng();
+
+        return new static($latitude, $longitude, $address);
+    }
+
+    public function toPoint()
+    {
+        return new Point($this->latitude, $this->longitude);
+    }
+
+    public function toJson()
+    {
+        return json_encode($this->toArray());
+    }
+
+    public function toArray()
+    {
+        return [
+            'coordinates' => [
+                'lat' => (string) $this->latitude,
+                'lng' => (string) $this->longitude,
+            ],
+            'address' => $this->address,
+        ];
+    }
+}

package/server/src/Integrations/Lalamove/LalamoveMarket.php

@@ -0,0 +1,123 @@
+<?php
+
+namespace Fleetbase\FleetOps\Integrations\Lalamove;
+
+use Fleetbase\FleetOps\Support\Utils;
+
+class LalamoveMarket
+{
+    /**
+     * Available Markets for Lalamove.
+     *
+     * @var array
+     */
+    public const markets = [
+        [
+            'key'       => 'brazil',
+            'code'      => 'BR',
+            'languages' => ['en_BR', 'pr_BR'],
+        ],
+        [
+            'key'       => 'hong_kong',
+            'code'      => 'HK',
+            'languages' => ['en_HK', 'zh_HK'],
+        ],
+        [
+            'key'       => 'indonesia',
+            'code'      => 'ID',
+            'languages' => ['en_ID', 'id_ID'],
+        ],
+        [
+            'key'       => 'malaysia',
+            'code'      => 'MY',
+            'languages' => ['en_MY', 'ms_MY'],
+        ],
+        [
+            'key'       => 'mexico',
+            'code'      => 'MX',
+            'languages' => ['en_MX', 'es_MX'],
+        ],
+        [
+            'key'       => 'philippines',
+            'code'      => 'PH',
+            'languages' => ['en_PH'],
+        ],
+        [
+            'key'       => 'singapore',
+            'code'      => 'SG',
+            'languages' => ['en_SG'],
+        ],
+        [
+            'key'       => 'taiwan',
+            'code'      => 'TW',
+            'languages' => ['zh_TW'],
+        ],
+        [
+            'key'       => 'thailand',
+            'code'      => 'TH',
+            'languages' => ['th_TH', 'en_TH'],
+        ],
+        [
+            'key'       => 'vietnam',
+            'code'      => 'VN',
+            'languages' => ['en_VN', 'vi_VN'],
+        ],
+    ];
+
+    public function __construct(array $details)
+    {
+        foreach ($details as $key => $value) {
+            $this->{$key} = $value;
+        }
+    }
+
+    public function __get(string $key)
+    {
+        $key = strtolower($key);
+
+        if (isset($this->{$key})) {
+            return $this->{$key};
+        }
+
+        return null;
+    }
+
+    public function getCode()
+    {
+        return $this->code;
+    }
+
+    public function getLanguages()
+    {
+        return $this->languages;
+    }
+
+    public static function all()
+    {
+        return collect(static::markets)->mapInto(LalamoveMarket::class);
+    }
+
+    public static function find($key)
+    {
+        if (is_callable($key)) {
+            return static::all()->first($key);
+        }
+
+        if (is_string($key)) {
+            return static::all()->first(
+                function ($detail) use ($key) {
+                    return isset($detail->key) && strtolower($detail->key) === strtolower($key) || isset($detail->code) && strtolower($detail->code) === strtolower($key);
+                }
+            );
+        }
+    }
+
+    public static function codes()
+    {
+        return static::all()->map(
+            function ($market) {
+                return Utils::get($market, 'code');
+            }
+        );
+    }
+}

package/server/src/Integrations/Lalamove/LalamoveServiceType.php

@@ -0,0 +1,161 @@
+<?php
+
+namespace Fleetbase\FleetOps\Integrations\Lalamove;
+
+class LalamoveServiceType
+{
+    /**
+     * Available Service types for Lalamove.
+     */
+    private static array $serviceTypes = [
+        // [
+        //     'key' => 'WALKER',
+        //     'description' => 'Walker',
+        //     'restrictions' => [
+        //         'length' => '40cm',
+        //         'width' => '40cm',
+        //         'height' => '40cm',
+        //         'weight' => '10kg',
+        //     ],
+        // ],
+        [
+            'key'          => 'MOTORCYCLE',
+            'description'  => 'Motorcycle',
+            'restrictions' => [
+                'length' => '40cm',
+                'width'  => '40cm',
+                'height' => '40cm',
+                'weight' => '10kg',
+            ],
+        ],
+        [
+            'key'          => 'CAR',
+            'description'  => 'Car',
+            'restrictions' => [
+                'length' => '70cm',
+                'width'  => '50cm',
+                'height' => '50cm',
+                'weight' => '20kg',
+            ],
+        ],
+        // [
+        //     'key' => 'SEDAN',
+        //     'description' => 'Sedan',
+        //     'restrictions' => [
+        //         'length' => '150cm',
+        //         'width' => '80cm',
+        //         'height' => '80cm',
+        //         'weight' => '100kg',
+        //     ],
+        // ],
+        [
+            'key'          => 'VAN',
+            'description'  => 'Van',
+            'restrictions' => [
+                'length' => '182cm',
+                'width'  => '121cm',
+                'height' => '121cm',
+                'weight' => '800kg',
+            ],
+        ],
+        [
+            'key'          => 'SUV',
+            'description'  => 'SUV',
+            'restrictions' => [
+                'length' => '182cm',
+                'width'  => '121cm',
+                'height' => '121cm',
+                'weight' => '800kg',
+            ],
+        ],
+        // [
+        //     'key' => 'TRUCK175',
+        //     'description' => 'Pickup Truck',
+        //     'restrictions' => [
+        //         'length' => '200cm',
+        //         'width' => '160cm',
+        //         'height' => '120cm',
+        //         'weight' => '800kg',
+        //     ],
+        // ],
+        [
+            'key'          => 'TRUCK330',
+            'description'  => '1-Ton Lorry / Lori 1-Tan',
+            'restrictions' => [
+                'length' => '275cm',
+                'width'  => '152cm',
+                'height' => '152cm',
+                'weight' => '1000kg',
+            ],
+        ],
+        [
+            'key'          => 'TRUCK550',
+            'description'  => '5.5 Ton',
+            'restrictions' => [
+                'length' => '450cm',
+                'width'  => '195cm',
+                'height' => '195cm',
+                'weight' => '1200kg',
+            ],
+        ],
+    ];
+
+    public function __construct(array $details)
+    {
+        foreach ($details as $key => $value) {
+            $this->{$key} = $value;
+        }
+    }
+
+    public function __get(string $key)
+    {
+        $restrictions = ['length', 'width', 'height', 'weight'];
+        $key          = strtolower($key);
+
+        if (isset($this->{$key})) {
+            return $this->{$key};
+        }
+
+        if (in_array($key, $restrictions)) {
+            return $this->restrictions[$key];
+        }
+
+        return null;
+    }
+
+    public function __call(string $key, $arguments)
+    {
+        if ($key === 'all') {
+            return collect(static::$serviceTypes)->mapInto(LalamoveServiceType::class);
+        }
+
+        if (method_exists($this, $key)) {
+            $this->{$key}(...$arguments);
+        }
+
+        return null;
+    }
+
+    public function getKey()
+    {
+        return $this->key;
+    }
+
+    public static function all()
+    {
+        return collect(static::$serviceTypes)->mapInto(LalamoveServiceType::class);
+    }
+
+    public static function find($key)
+    {
+        if (is_callable($key)) {
+            return static::all()->first($key);
+        }
+
+        if (is_string($key)) {
+            return static::all()->first(function ($detail) use ($key) {
+                return isset($detail->key) && strtolower($detail->key) === strtolower($key);
+            });
+        }
+    }
+}

package/server/src/Jobs/SimulateDrivingRoute.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace Fleetbase\FleetOps\Jobs;
+
+use Fleetbase\FleetOps\Models\Driver;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Arr;
+
+/**
+ * Class SimulateDrivingRoute
+ * Simulates a driving route for a given driver by dispatching events at each waypoint.
+ */
+class SimulateDrivingRoute implements ShouldQueue
+{
+    use Dispatchable;
+    use InteractsWithQueue;
+    use Queueable;
+    use SerializesModels;
+
+    /**
+     * @var Driver the driver for whom the route is being simulated
+     */
+    public Driver $driver;
+
+    /**
+     * @var array the waypoints that make up the route
+     */
+    public array $waypoints = [];
+
+    /**
+     * The number of seconds the job can run before timing out.
+     *
+     * @var int
+     */
+    public $timeout = 60 * 15;
+
+    /**
+     * The number of times the job may be attempted.
+     *
+     * @var int
+     */
+    public $tries = 20;
+
+    /**
+     * Create a new job instance.
+     *
+     * @param \Fleetbase\FleetOps\Models\Driver $driver    the driver for whom the route is being simulated
+     * @param array                             $waypoints the waypoints that make up the route
+     */
+    public function __construct(Driver $driver, array $waypoints = [])
+    {
+        $this->driver    = $driver->withoutRelations();
+        $this->waypoints = $waypoints;
+    }
+
+    /**
+     * Execute the job.
+     * Dispatches an event for each waypoint, simulating the driver's movement along the route.
+     */
+    public function handle(): void
+    {
+        ini_set('memory_limit', '-1');
+        ini_set('max_execution_time', 0);
+
+        $firstWaypoint      = reset($this->waypoints);
+        $remainingWaypoints = array_slice($this->waypoints, 1, null, true);
+
+        SimulateWaypointReached::withChain(
+            Arr::map(
+                $remainingWaypoints,
+                function ($waypoint, $index) {
+                    return new SimulateWaypointReached($this->driver, $waypoint, ['index' => $index]);
+                }
+            )
+        )->dispatch($this->driver, $firstWaypoint, ['index' => 0]);
+    }
+}

package/server/src/Jobs/SimulateWaypointReached.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace Fleetbase\FleetOps\Jobs;
+
+use Fleetbase\FleetOps\Events\DriverSimulatedLocationChanged;
+use Fleetbase\FleetOps\Models\Driver;
+use Grimzy\LaravelMysqlSpatial\Types\Point;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+
+/**
+ * Class SimulateWaypointReached
+ * Simulates the reaching of a waypoint for a given driver by dispatching an event.
+ */
+class SimulateWaypointReached implements ShouldQueue
+{
+    use Dispatchable;
+    use InteractsWithQueue;
+    use Queueable;
+    use SerializesModels;
+
+    /**
+     * @var \Fleetbase\FleetOps\Models\Driver the driver for whom the waypoint is being simulated
+     */
+    public Driver $driver;
+
+    /**
+     * @var \Grimzy\LaravelMysqlSpatial\Types\Point the waypoint that the driver is simulated to have reached
+     */
+    public Point $waypoint;
+
+    /**
+     * @var array additional data
+     */
+    public array $additionalData = [];
+
+    /**
+     * The number of seconds the job can run before timing out.
+     *
+     * @var int
+     */
+    public $timeout = 60 * 15;
+
+    /**
+     * The number of times the job may be attempted.
+     *
+     * @var int
+     */
+    public $tries = 20;
+
+    /**
+     * Create a new job instance.
+     *
+     * @param Driver $driver   the driver for whom the waypoint is being simulated
+     * @param mixed  $waypoint the waypoint that the driver is simulated to have reached
+     */
+    public function __construct(Driver $driver, Point $waypoint, array $additionalData = [])
+    {
+        $this->driver         = $driver;
+        $this->waypoint       = $waypoint;
+        $this->additionalData = $additionalData;
+    }
+
+    /**
+     * Execute the job.
+     * Dispatches an event to notify that the driver has reached the simulated waypoint.
+     */
+    public function handle(): void
+    {
+        if (data_get($this->waypoint, 'heading')) {
+            $this->additionalData['heading'] = data_get($this->waypoint, 'heading');
+        }
+
+        event(new DriverSimulatedLocationChanged($this->driver, $this->waypoint, $this->additionalData));
+    }
+}

package/server/src/Listeners/HandleOrderCanceled.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Fleetbase\FleetOps\Listeners;
+
+use Fleetbase\FleetOps\Events\OrderCanceled;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Notifications\OrderCanceled as OrderCanceledNotification;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Queue\InteractsWithQueue;
+
+class HandleOrderCanceled implements ShouldQueue
+{
+    use InteractsWithQueue;
+
+    /**
+     * Handle the event.
+     *
+     * @param object $event
+     *
+     * @return void
+     */
+    public function handle(OrderCanceled $event)
+    {
+        /** @var \Fleetbase\FleetOps\Models\Order $order */
+        $order    = $event->getModelRecord();
+        $location = $order->getLastLocation();
+
+        // update order activity
+        $order->setStatus('canceled');
+        $order->createActivity('Order canceled', 'Order was canceled', $location, $order->status);
+
+        if ($order->isIntegratedVendorOrder()) {
+            $order->facilitator->provider()->callback('onCanceled', $order);
+        }
+
+        // notify driver assigned order was canceled
+        if ($order->hasDriverAssigned) {
+            /** @var \Fleetbase\Models\Driver */
+            $driver = Driver::where('uuid', $order->driver_assigned_uuid)->withoutGlobalScopes()->first();
+
+            if ($driver) {
+                $driver->notify(new OrderCanceledNotification($order));
+            }
+        }
+    }
+}

package/server/src/Listeners/HandleOrderCreated.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Fleetbase\FleetOps\Listeners;
+
+use Fleetbase\FleetOps\Models\Order;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Queue\InteractsWithQueue;
+
+class HandleOrderCreated implements ShouldQueue
+{
+    use InteractsWithQueue;
+
+    /**
+     * Handle the event.
+     *
+     * @return void
+     */
+    public function handle(Order $order)
+    {
+        // set google matrix based distance and time
+        $order->setDistanceAndTime();
+    }
+}

package/server/src/Listeners/HandleOrderDispatchFailed.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Fleetbase\FleetOps\Listeners;
+
+use Fleetbase\FleetOps\Events\OrderDispatchFailed;
+use Fleetbase\FleetOps\Notifications\OrderDispatchFailed as OrderDispatchFailedNotification;
+use Fleetbase\Models\User;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Queue\InteractsWithQueue;
+
+class HandleOrderDispatchFailed implements ShouldQueue
+{
+    use InteractsWithQueue;
+
+    /**
+     * Handle the event.
+     *
+     * @param object $event
+     *
+     * @return void
+     */
+    public function handle(OrderDispatchFailed $event)
+    {
+        /** @var \Fleetbase\FleetOps\Models\Order $order */
+        $order = $event->getModelRecord();
+
+        /** @var \Fleetbase\Models\User */
+        $createdBy = User::where('uuid', $order->created_by_uuid)->first();
+
+        // notify driver assigned order was canceled
+        if ($createdBy) {
+            $createdBy->notify(new OrderDispatchFailedNotification($order, $event));
+        }
+    }
+}