@fleetbase/fleetops-engine 0.3.7 → 0.3.8

package/server/src/Models/Zone.php

@@ -2,7 +2,8 @@
 
 namespace Fleetbase\FleetOps\Models;
 
-use Fleetbase\FleetOps\Casts\Polygon;
+use Fleetbase\FleetOps\Casts\Polygon as PolygonCast;
+use Fleetbase\FleetOps\Support\Utils;
 use Fleetbase\Models\Model;
 use Fleetbase\Traits\HasApiModelBehavior;
 use Fleetbase\Traits\HasPublicId;
@@ -10,6 +11,10 @@ use Fleetbase\Traits\HasUuid;
 use Fleetbase\Traits\SendsWebhooks;
 use Fleetbase\Traits\TracksApiCredential;
 use Grimzy\LaravelMysqlSpatial\Eloquent\SpatialTrait;
+use Grimzy\LaravelMysqlSpatial\Types\LineString;
+use Grimzy\LaravelMysqlSpatial\Types\Point;
+use Grimzy\LaravelMysqlSpatial\Types\Polygon;
+use Illuminate\Support\Arr;
 
 class Zone extends Model
 {
@@ -61,7 +66,7 @@ class Zone extends Model
      * @var array
      */
     protected $casts = [
-        'border' => Polygon::class,
+        'border' => PolygonCast::class,
     ];
 
     /**
@@ -79,17 +84,139 @@ class Zone extends Model
     protected $hidden = [];
 
     /**
-     * Service area for rate.
-     *
-     * @var Model
+     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
      */
     public function serviceArea()
     {
         return $this->belongsTo(ServiceArea::class);
     }
 
+    /**
+     * The type of area.
+     *
+     * @return string
+     */
     public function getTypeAttribute()
     {
         return 'zone';
     }
+
+    /**
+     * Retrieves the location attribute as a point.
+     *
+     * @return \Grimzy\LaravelMysqlSpatial\Types\Point returns the centroid of the border as a Point object
+     */
+    public function getLocationAttribute(): Point
+    {
+        $centroid = $this->getCentroid();
+
+        return new Point($centroid->x(), $centroid->y());
+    }
+
+    /**
+     * Retrieves the latitude component of the location attribute.
+     *
+     * @return float returns the latitude value
+     */
+    public function getLatitudeAttribute(): float
+    {
+        return $this->location->getLat();
+    }
+
+    /**
+     * Retrieves the longitude component of the location attribute.
+     *
+     * @return float returns the longitude value
+     */
+    public function getLongitudeAttribute(): float
+    {
+        return $this->location->getLng();
+    }
+
+    /**
+     * Calculates the centroid of the border as a \Brick\Geo\Point.
+     *
+     * @return \Brick\Geo\Point the centroid of the border as a \Brick\Geo\Point object
+     */
+    public function getCentroid(): \Brick\Geo\Point
+    {
+        $geometryEngine  = new \Brick\Geo\Engine\GEOSEngine();
+        $borderAsPolygon = $this->toGeosPolygon();
+
+        if ($borderAsPolygon instanceof \Brick\Geo\Geometry) {
+            return $geometryEngine->centroid($borderAsPolygon);
+        }
+
+        return \Brick\Geo\Point::fromText('POINT (0 0)');
+    }
+
+    /**
+     * Converts the border's coordinates to an array of \Brick\Geo\LineString objects.
+     *
+     * @return \Brick\Geo\LineString[] an array of \Brick\Geo\LineString objects
+     */
+    public function toGeosLineStrings(): array
+    {
+        $lineStrings = [];
+
+        if (is_iterable($this->border)) {
+            foreach ($this->border as $lineString) {
+                $points = [];
+
+                foreach ($lineString as $point) {
+                    $points[] = \Brick\Geo\Point::fromText('POINT (' . $point->getLat() . ' ' . $point->getLng() . ')');
+                }
+
+                if ($points) {
+                    $lineStrings[] = \Brick\Geo\LineString::of(...$points);
+                }
+            }
+        }
+
+        return $lineStrings;
+    }
+
+    /**
+     * Converts the first LineString from the border into a \Brick\Geo\Polygon.
+     *
+     * @return \Brick\Geo\Polygon a \Brick\Geo\Polygon object created from the first line string of the border
+     */
+    public function toGeosPolygon(): ?\Brick\Geo\Polygon
+    {
+        $lineString = Arr::first($this->toGeosLineStrings());
+
+        if (empty($lineString)) {
+            return null;
+        }
+
+        return \Brick\Geo\Polygon::of($lineString);
+    }
+
+    /**
+     * Creates a polygon from a given point and radius.
+     *
+     * @param \Grimzy\LaravelMysqlSpatial\Types\Point $point  the central point from which to create the polygon
+     * @param int                                     $meters The radius in meters for the polygon. Default is 500 meters.
+     *
+     * @return \Grimzy\LaravelMysqlSpatial\Types\Polygon returns a Polygon object
+     */
+    public static function createPolygonFromPoint(Point $point, int $meters = 500): Polygon
+    {
+        $coordinates = Utils::coordsToCircle($point->getLat(), $point->getLng(), $meters);
+
+        // first and last positions should be equivalent
+        if (Arr::first($coordinates) !== Arr::last($coordinates)) {
+            $coordinates[] = Arr::first($coordinates);
+        }
+
+        // conver the coordinate pairs to points
+        $coordinates = array_map(
+            function ($coord) {
+                return new Point(...$coord);
+            },
+            $coordinates
+        );
+
+        return new Polygon([new LineString($coordinates)]);
+    }
 }

package/server/src/Support/Flow.php

@@ -177,7 +177,7 @@ class Flow
     {
         $config = static::getOrderConfig($order);
         $vars   = static::getOrderFlowVars($order);
-        $code   = strtolower($order->status);
+        $code   = strtolower(data_get($order, 'status'));
         $status = data_get($config, 'meta.flow.' . $code . '.events');
 
         $flow = static::bindVariablesToFlow($status, $vars);
@@ -235,11 +235,21 @@ class Flow
 
     /**
      * Returns a order type configuration by key.
+     *
+     * @param bool $force - If this method should always return dispatch activity
      */
-    public static function getDispatchActivity(Order $order): ?array
+    public static function getDispatchActivity(Order $order, bool $force = true): ?array
     {
         $flow = static::getOrderFlow($order);
 
+        if ($force === true) {
+            return [
+                'status'  => 'Order dispatched',
+                'details' => 'Order has been dispatched',
+                'code'    => 'dispatched',
+            ];
+        }
+
         return collect($flow)->first(function ($activity) {
             return isset($activity['code']) && $activity['code'] === 'dispatched';
         });
@@ -285,7 +295,7 @@ class Flow
     public static function getOrderFlowVars(Order $order, Waypoint $currentWaypoint = null): ?array
     {
         $vars         = [];
-        $allWaypoints = $order->payload->waypoints ?? collect();
+        $allWaypoints = data_get($order, 'payload.waypoints', collect());
 
         // set order vars
         $vars['order'] = ['public_id' => $order->public_id, 'internal_id' => $order->internal_id, 'tracking_number' => $order->tracking, 'meta' => $order->meta];
@@ -316,6 +326,10 @@ class Flow
         }
 
         // // storefront order add store or network about
+        // should patch with hook system
+        // storefront extension should register hook to add $vars
+        // Hook::register('\Fleetbase\FleetOps\Support\Flow@getOrderFlowVars', addStorefrontVars);
+        // here we will run Hook::run(__CLASS__ . '@' . __METHOD__);
         // if ($order->type === 'storefront' && $order->hasMeta('storefront_id')) {
         //     $storefront = Storefront::findAbout($order->getMeta('storefront_id'));
 

package/server/src/Support/Utils.php

@@ -202,14 +202,29 @@ class Utils extends FleetbaseUtils
             $latitude  = $coordinates->getLat();
             $longitude = $coordinates->getLng();
         } elseif (static::isGeoJson($coordinates)) {
-            $coordinatesJson = null;
+            $coordinatesJson             = null;
+            $coordinatesInGeoJson        = null;
+            $coordinatesInGeoJsonFeature = null;
 
             if (is_array($coordinates) || is_object($coordinates)) {
                 $coordinatesJson = json_encode($coordinates);
             }
 
+            $coordinatesInGeoJson        = data_get($coordinates, 'coordinates');
+            $coordinatesInGeoJsonFeature = data_get($coordinates, 'geometry.coordinates');
+
             if (static::isJson($coordinatesJson)) {
-                $coordinates = \Grimzy\LaravelMysqlSpatial\Types\Point::fromJson($coordinatesJson);
+                try {
+                    $coordinates = \Grimzy\LaravelMysqlSpatial\Types\Point::fromJson($coordinatesJson);
+                } catch (\Throwable $e) {
+                    if ($coordinatesInGeoJson) {
+                        return static::getPointFromMixed($coordinatesInGeoJson);
+                    }
+
+                    if ($coordinatesInGeoJsonFeature) {
+                        return static::getPointFromMixed($coordinatesInGeoJsonFeature);
+                    }
+                }
             }
         } elseif (is_array($coordinates) || is_object($coordinates)) {
             // if known location based record
@@ -997,27 +1012,121 @@ class Utils extends FleetbaseUtils
             $coords->push([rad2deg($lat_rad), rad2deg($lon_rad)]);
         }
 
+        // first and last positions should be equivalent
+        if ($coords->first() !== $coords->last()) {
+            $coords->push($coords->first());
+        }
+
         return $coords->toArray();
     }
 
     /**
      * Calculates the centroid (geometric center) of the provided coordinates.
      *
-     * @param array $coord an array of coordinates
+     * @param array $coordinates an array of coordinates
      *
      * @return array the centroid of the coordinates as an array [latitude, longitude]
      */
-    public static function getCentroid($coord)
+    public static function getCentroid(array $coordinates = []): array
+    {
+        // Check if the coordinates array is empty
+        if (count($coordinates) === 0) {
+            return [0, 0];
+        }
+
+        $sumX             = 0;
+        $sumY             = 0;
+        $validCoordsCount = 0;
+
+        foreach ($coordinates as $coord) {
+            // Ensure the coordinate has at least two elements and they are numeric
+            if (is_array($coord) && count($coord) >= 2 && is_numeric($coord[0]) && is_numeric($coord[1])) {
+                $sumX += $coord[0];
+                $sumY += $coord[1];
+                $validCoordsCount++;
+            }
+        }
+
+        // If no valid coordinates were found, return a default value
+        if ($validCoordsCount === 0) {
+            return [0, 0];
+        }
+
+        // Calculate the average for X and Y
+        return [$sumX / $validCoordsCount, $sumY / $validCoordsCount];
+    }
+
+    /**
+     * Calculates the centroid of a given GEOS polygon.
+     *
+     * @param \Brick\Geo\Polygon $polygon the GEOS Polygon from which to calculate the centroid
+     *
+     * @return \Brick\Geo\Point returns the centroid of the polygon as a GEOS Point object
+     */
+    public static function getCentroidFromGeosPolygon(\Brick\Geo\Polygon $polygon): \Brick\Geo\Point
+    {
+        $geometryEngine = new \Brick\Geo\Engine\GEOSEngine();
+
+        return $geometryEngine->centroid($polygon);
+    }
+
+    /**
+     * Calculates the centroid of a given GEOS multi-polygon.
+     *
+     * @param \Brick\Geo\MultiPolygon $multiPolygon the GEOS MultiPolygon from which to calculate the centroid
+     *
+     * @return \Brick\Geo\Point returns the centroid of the multi-polygon as a GEOS Point object
+     */
+    public static function getCentroidFromGeosMultiPolygon(\Brick\Geo\MultiPolygon $multiPolygon): \Brick\Geo\Point
+    {
+        $geometryEngine = new \Brick\Geo\Engine\GEOSEngine();
+
+        return $geometryEngine->centroid($multiPolygon);
+    }
+
+    /**
+     * Calculates the centroid of a polygon using the Grimzy Laravel MySQL spatial type.
+     *
+     * @param \Grimzy\LaravelMysqlSpatial\Types\Polygon $polygon the Polygon object from which to calculate the centroid
+     *
+     * @return array returns the centroid of the polygon as an array of coordinates
+     */
+    public static function getPolygonCentroid(\Grimzy\LaravelMysqlSpatial\Types\Polygon $polygon)
     {
-        $centroid = array_reduce($coord, function ($x, $y) use ($coord) {
-            $len = count($coord);
+        $polygonArray = $polygon->jsonSerialize()->getCoordinates();
+        $coordinates  = array_merge(...$polygonArray);
 
-            return [$x[0] + $y[0] / $len, $x[1] + $y[1] / $len];
-        }, [0, 0]);
+        return static::getCentroid($coordinates);
+    }
+
+    /**
+     * Calculates the centroid of a multi-polygon using the Grimzy Laravel MySQL spatial type.
+     *
+     * @param \Grimzy\LaravelMysqlSpatial\Types\MultiPolygon $multiPolygon the MultiPolygon object from which to calculate the centroid
+     *
+     * @return array returns the centroid of the multi-polygon as an array of coordinates
+     */
+    public static function getMultiPolygonCentroid(\Grimzy\LaravelMysqlSpatial\Types\MultiPolygon $multiPolygon)
+    {
+        $multiPolygonArray = $multiPolygon->jsonSerialize()->getCoordinates();
+        $coordinates       = [];
+
+        foreach ($multiPolygonArray as $polygonArray) {
+            foreach ($polygonArray as $lineStringArray) {
+                $coordinates = array_merge($coordinates, $lineStringArray);
+            }
+        }
 
-        return $centroid;
+        return static::getCentroid($coordinates);
     }
 
+    /**
+     * Extracts and returns the first set of coordinates from a given polygon.
+     *
+     * @param \Grimzy\LaravelMysqlSpatial\Types\Polygon|null $polygon the Polygon object from which to extract coordinates
+     *
+     * @return array Returns an array of the first set of coordinates in the polygon. Returns an empty array if the polygon is null.
+     */
     public static function getCoordinatesFromPolygon(?\Grimzy\LaravelMysqlSpatial\Types\Polygon $polygon): array
     {
         return Arr::first($polygon->jsonSerialize()->getCoordinates());
@@ -1106,6 +1215,31 @@ class Utils extends FleetbaseUtils
         return new \Grimzy\LaravelMysqlSpatial\Eloquent\SpatialExpression($geo);
     }
 
+    /**
+     * Creates a SpatialExpression object from a valid GeoJSON input.
+     *
+     * @param mixed $geoJson the GeoJSON input, which can be an array, object, or JSON string representing a valid GeoJSON object
+     *
+     * @return \Grimzy\LaravelMysqlSpatial\Eloquent\SpatialExpression|null returns a SpatialExpression object if the input is a valid GeoJSON, or null if the input is not valid
+     *
+     * @throws \InvalidArgumentException if the input is not a valid GeoJSON object
+     */
+    public static function createGeometryObjectFromGeoJson($geoJson): ?\Grimzy\LaravelMysqlSpatial\Types\Geometry
+    {
+        if (!static::isGeoJson($geoJson)) {
+            return null;
+        }
+
+        if (is_string($geoJson) && static::isJson($geoJson)) {
+            $geoJson = json_decode($geoJson, true);
+        }
+
+        // Convert the value to JSON and create a Geometry object
+        $json = json_encode($geoJson);
+
+        return \Grimzy\LaravelMysqlSpatial\Types\Geometry::fromJson($json);
+    }
+
     /**
      * Calculate the heading between two geographical points.
      *

package/server/src/routes.php

@@ -65,13 +65,14 @@ Route::prefix(config('fleetops.api.routing.prefix', null))->namespace('Fleetbase
                     $router->get('/', 'OrderController@query');
                     $router->get('{id}', 'OrderController@find');
                     $router->get('{id}/distance-and-time', 'OrderController@getDistanceMatrix');
-                    $router->post('{id}/dispatch', 'OrderController@dispatchOrder');
+                    $router->match(['post', 'patch'], '{id}/schedule', 'OrderController@scheduleOrder');
+                    $router->match(['post', 'patch'], '{id}/dispatch', 'OrderController@dispatchOrder');
                     $router->post('{id}/start', 'OrderController@startOrder');
                     $router->delete('{id}/cancel', 'OrderController@cancelOrder');
-                    $router->post('{id}/update-activity', 'OrderController@updateActivity');
+                    $router->match(['post', 'patch'], '{id}/update-activity', 'OrderController@updateActivity');
                     $router->post('{id}/complete', 'OrderController@completeOrder');
                     $router->get('{id}/next-activity', 'OrderController@getNextActivity');
-                    $router->post('{id}/set-destination/{placeId}', 'OrderController@setDestination');
+                    $router->match(['post', 'patch'], '{id}/set-destination/{placeId}', 'OrderController@setDestination');
                     $router->post('{id}/capture-signature/{subjectId?}', 'OrderController@captureSignature');
                     $router->post('{id}/capture-qr/{subjectId?}', 'OrderController@captureQrScan');
                     $router->put('{id}', 'OrderController@update');