@fleetbase/fleetops-engine 0.6.49 → 0.6.51

package/server/src/Support/Metrics/AbstractMetric.php

@@ -14,12 +14,12 @@ use Illuminate\Support\Carbon;
 abstract class AbstractMetric
 {
     protected Company $company;
-    protected ?\DateTimeInterface $start = null;
-    protected ?\DateTimeInterface $end   = null;
+    protected ?\DateTimeInterface $start        = null;
+    protected ?\DateTimeInterface $end          = null;
     protected ?\DateTimeInterface $compareStart = null;
     protected ?\DateTimeInterface $compareEnd   = null;
-    protected int $sparklineBuckets = 0;
-    protected string $sparklineUnit = 'day';
+    protected int $sparklineBuckets             = 0;
+    protected string $sparklineUnit             = 'day';
 
     /**
      * Period boundaries for the currently-executing aggregate call.

package/server/src/Support/PlaceSearch.php

@@ -0,0 +1,282 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support;
+
+use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Geocoder\Laravel\Facades\Geocoder;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Str;
+
+class PlaceSearch
+{
+    public static function search(Builder $query, ?string $searchQuery = null, array $options = []): Collection
+    {
+        $searchQuery  = static::normalizeSearchQuery($searchQuery);
+        $limit        = (int) data_get($options, 'limit', 30);
+        $geo          = filter_var(data_get($options, 'geo', false), FILTER_VALIDATE_BOOLEAN);
+        $latitude     = data_get($options, 'latitude');
+        $longitude    = data_get($options, 'longitude');
+        $noQueryOrder = data_get($options, 'no_query_order', 'name_desc');
+
+        static::applySavedPlaceSearch($query, $searchQuery, $latitude, $longitude, $noQueryOrder);
+
+        if ($limit > 0) {
+            $query->limit($limit);
+        }
+
+        $savedPlaces = $query->get();
+        $geoPlaces   = $geo ? static::geocode($searchQuery, $latitude, $longitude) : collect();
+
+        return static::mergeResults($geoPlaces, $savedPlaces, $searchQuery);
+    }
+
+    public static function geocode(?string $searchQuery = null, $latitude = null, $longitude = null): Collection
+    {
+        $searchQuery = static::normalizeSearchQuery($searchQuery);
+
+        if (!$searchQuery && (!$latitude || !$longitude)) {
+            return collect();
+        }
+
+        try {
+            if (Geocoding::canGoogleGeocode()) {
+                $results = collect();
+
+                try {
+                    if ($searchQuery) {
+                        $results = $results->merge(Geocoding::geocode($searchQuery, $latitude, $longitude));
+                    } elseif ($latitude && $longitude) {
+                        $results = $results->merge(Geocoding::reverseFromCoordinates($latitude, $longitude));
+                    }
+                } catch (\Throwable) {
+                    // Fall through to any nearby results already collected.
+                }
+
+                if ($searchQuery && $latitude && $longitude) {
+                    try {
+                        $results = $results->merge(Geocoding::reverseFromQuery($searchQuery, $latitude, $longitude));
+                    } catch (\Throwable) {
+                        // Text geocoding results should still be usable if nearby lookup fails.
+                    }
+                }
+
+                return static::rankPlacesByQuery(static::uniquePlaces($results), $searchQuery);
+            }
+
+            if (!$searchQuery) {
+                return collect();
+            }
+
+            $results = Geocoder::geocode($searchQuery)
+                ->get()
+                ->map(fn ($googleAddress) => Place::createFromGoogleAddress($googleAddress))
+                ->values();
+
+            return static::rankPlacesByQuery($results, $searchQuery);
+        } catch (\Throwable) {
+            return collect();
+        }
+    }
+
+    protected static function applySavedPlaceSearch(Builder $query, ?string $searchQuery, $latitude = null, $longitude = null, string $noQueryOrder = 'name_desc'): void
+    {
+        $query->addSelect('places.*');
+
+        if ($searchQuery) {
+            $query->where(function ($query) use ($searchQuery) {
+                $contains = '%' . $searchQuery . '%';
+
+                $query->orWhereRaw('LOWER(COALESCE(places.name, "")) LIKE ?', [$contains])
+                    ->orWhereRaw('LOWER(COALESCE(places.street1, "")) LIKE ?', [$contains])
+                    ->orWhereRaw('LOWER(COALESCE(places.street2, "")) LIKE ?', [$contains])
+                    ->orWhereRaw('LOWER(COALESCE(places.city, "")) LIKE ?', [$contains])
+                    ->orWhereRaw('LOWER(COALESCE(places.province, "")) LIKE ?', [$contains])
+                    ->orWhereRaw('LOWER(COALESCE(places.postal_code, "")) LIKE ?', [$contains]);
+            });
+
+            $prefix   = $searchQuery . '%';
+            $contains = '%' . $searchQuery . '%';
+
+            $query->selectRaw(
+                'CASE
+                    WHEN LOWER(COALESCE(places.name, "")) = ? OR LOWER(COALESCE(places.street1, "")) = ? OR LOWER(COALESCE(places.postal_code, "")) = ? THEN 0
+                    WHEN LOWER(COALESCE(places.name, "")) LIKE ? OR LOWER(COALESCE(places.street1, "")) LIKE ? OR LOWER(COALESCE(places.postal_code, "")) LIKE ? THEN 1
+                    WHEN LOWER(COALESCE(places.name, "")) LIKE ? OR LOWER(COALESCE(places.street1, "")) LIKE ? OR LOWER(COALESCE(places.street2, "")) LIKE ? OR LOWER(COALESCE(places.city, "")) LIKE ? OR LOWER(COALESCE(places.province, "")) LIKE ? OR LOWER(COALESCE(places.postal_code, "")) LIKE ? THEN 2
+                    ELSE 3
+                END AS place_search_relevance',
+                [$searchQuery, $searchQuery, $searchQuery, $prefix, $prefix, $prefix, $contains, $contains, $contains, $contains, $contains, $contains]
+            );
+            $query->orderBy('place_search_relevance', 'asc');
+        }
+
+        if ($latitude && $longitude) {
+            $point = new Point($latitude, $longitude);
+
+            $query->whereNotNull('places.location')->whereRaw('
+                ST_Y(places.location) BETWEEN -90 AND 90
+                AND ST_X(places.location) BETWEEN -180 AND 180
+                AND NOT (ST_X(places.location) = 0 AND ST_Y(places.location) = 0)
+            ');
+            $query->orderByDistanceSphere('location', $point, 'asc');
+        } elseif (!$searchQuery && $noQueryOrder === 'latest') {
+            $query->orderBy('places.created_at', 'desc');
+        } else {
+            $query->orderBy('places.name', 'desc');
+        }
+    }
+
+    protected static function mergeResults(Collection $geoPlaces, Collection $savedPlaces, ?string $searchQuery = null): Collection
+    {
+        $merged  = [];
+        $indexes = [];
+
+        foreach ($geoPlaces as $place) {
+            static::pushUniquePlace($merged, $indexes, $place);
+        }
+
+        foreach ($savedPlaces as $place) {
+            $key = static::placeKey($place);
+
+            if ($key && isset($indexes[$key])) {
+                if (static::isStrongSavedMatch($place, $searchQuery)) {
+                    $merged[$indexes[$key]] = $place;
+                }
+
+                continue;
+            }
+
+            static::pushUniquePlace($merged, $indexes, $place);
+        }
+
+        return collect($merged)->values();
+    }
+
+    protected static function pushUniquePlace(array &$merged, array &$indexes, ?Place $place): void
+    {
+        if (!$place instanceof Place) {
+            return;
+        }
+
+        $key = static::placeKey($place);
+
+        if ($key && isset($indexes[$key])) {
+            return;
+        }
+
+        if ($key) {
+            $indexes[$key] = count($merged);
+        }
+
+        $merged[] = $place;
+    }
+
+    protected static function uniquePlaces(Collection $places): Collection
+    {
+        $merged  = [];
+        $indexes = [];
+
+        foreach ($places as $place) {
+            static::pushUniquePlace($merged, $indexes, $place);
+        }
+
+        return collect($merged)->values();
+    }
+
+    protected static function rankPlacesByQuery(Collection $places, ?string $searchQuery = null): Collection
+    {
+        if (!$searchQuery) {
+            return $places->values();
+        }
+
+        return $places
+            ->values()
+            ->map(fn ($place, $index) => [
+                'place' => $place,
+                'rank'  => static::placeQueryRank($place, $searchQuery),
+                'index' => $index,
+            ])
+            ->sortBy([
+                ['rank', 'asc'],
+                ['index', 'asc'],
+            ])
+            ->pluck('place')
+            ->values();
+    }
+
+    protected static function placeQueryRank(Place $place, ?string $searchQuery = null): int
+    {
+        if (!$searchQuery) {
+            return 4;
+        }
+
+        $query  = static::normalizeSearchQuery($searchQuery);
+        $values = collect([
+            $place->name,
+            $place->street1,
+            $place->postal_code,
+            $place->toAddressString(['name']),
+            $place->address,
+        ])
+            ->filter()
+            ->map(fn ($value) => static::normalizeSearchQuery($value));
+
+        if ($values->contains($query)) {
+            return 0;
+        }
+
+        if ($values->contains(fn ($value) => Str::startsWith($value, $query))) {
+            return 1;
+        }
+
+        if ($values->contains(fn ($value) => Str::contains($value, $query))) {
+            return 2;
+        }
+
+        return 3;
+    }
+
+    protected static function isStrongSavedMatch(Place $place, ?string $searchQuery = null): bool
+    {
+        if (!$searchQuery) {
+            return false;
+        }
+
+        $query = static::normalizeSearchQuery($searchQuery);
+
+        return collect([$place->name, $place->street1, $place->postal_code])
+            ->filter()
+            ->map(fn ($value) => static::normalizeSearchQuery($value))
+            ->contains($query);
+    }
+
+    protected static function placeKey(Place $place): ?string
+    {
+        $address = static::normalizeSearchQuery($place->toAddressString(['name']) ?: $place->address ?: $place->street1 ?: $place->name);
+        $lat     = data_get($place, 'latitude');
+        $lng     = data_get($place, 'longitude');
+
+        if (!$lat && $place->location && method_exists($place->location, 'getLat')) {
+            $lat = $place->location->getLat();
+            $lng = $place->location->getLng();
+        }
+
+        $coordinates = $lat && $lng ? round((float) $lat, 5) . ',' . round((float) $lng, 5) : null;
+
+        if (!$address && !$coordinates) {
+            return null;
+        }
+
+        return trim($address . '|' . $coordinates, '|');
+    }
+
+    protected static function normalizeSearchQuery(?string $searchQuery): ?string
+    {
+        if (!is_string($searchQuery)) {
+            return null;
+        }
+
+        return (string) Str::of($searchQuery)->lower()->squish();
+    }
+}