@fleetbase/fleetops-engine 0.2.5 → 0.2.7

package/server/src/Http/Filter/ContactFilter.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Http\Filter\Filter;
+
+class ContactFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder->where(
+            function ($query) {
+                $query->where('company_uuid', $this->session->get('company'));
+                $query->orWhereHas(
+                    'user',
+                    function ($query) {
+                        $query->where('company_uuid', $this->session->get('company'));
+                    }
+                );
+            }
+        );
+    }
+
+    public function query(?string $searchQuery)
+    {
+        $this->builder->search($searchQuery);
+    }
+
+    public function internalId(?string $internalId)
+    {
+        $this->builder->searchWhere('internal_id', $internalId);
+    }
+
+    public function publicId(?string $publicId)
+    {
+        $this->builder->searchWhere('public_id', $publicId);
+    }
+
+    public function type(?string $type)
+    {
+        $this->builder->searchWhere('type', $type);
+    }
+
+    public function email(?string $email)
+    {
+        $this->builder->searchWhere('email', $email);
+    }
+
+    public function phone(?string $phone)
+    {
+        $this->builder->searchWhere('phone', $phone);
+    }
+
+    public function address(?string $address)
+    {
+        $this->builder->whereHas(
+            'addresses',
+            function ($query) use ($address) {
+                $query->search($address);
+            }
+        );
+    }
+
+    public function createdAt($createdAt)
+    {
+        $createdAt = Utils::dateRange($createdAt);
+
+        if (is_array($createdAt)) {
+            $this->builder->whereBetween('created_at', $createdAt);
+        } else {
+            $this->builder->whereDate('created_at', $createdAt);
+        }
+    }
+
+    public function updatedAt($updatedAt)
+    {
+        $updatedAt = Utils::dateRange($updatedAt);
+
+        if (is_array($updatedAt)) {
+            $this->builder->whereBetween('updated_at', $updatedAt);
+        } else {
+            $this->builder->whereDate('updated_at', $updatedAt);
+        }
+    }
+}

package/server/src/Http/Filter/DriverFilter.php

@@ -0,0 +1,148 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Http\Filter\Filter;
+use Illuminate\Support\Str;
+
+class DriverFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder->where(
+            function ($query) {
+                $query->where('company_uuid', $this->session->get('company'));
+                $query->orWhereHas(
+                    'user',
+                    function ($query) {
+                        $query->where('company_uuid', $this->session->get('company'));
+                    }
+                );
+            }
+        );
+    }
+
+    public function query(?string $searchQuery)
+    {
+        $this->builder->where(function ($query) use ($searchQuery) {
+            $query->orWhereHas(
+                'user',
+                function ($query) use ($searchQuery) {
+                    $query->searchWhere(['name', 'email', 'phone'], $searchQuery);
+                }
+            );
+
+            $query->orWhere(
+                function ($query) use ($searchQuery) {
+                    $query->searchWhere(['drivers_license_number'], $searchQuery);
+                }
+            );
+        });
+    }
+
+    public function internalId(?string $internalId)
+    {
+        $this->builder->searchWhere('internal_id', $internalId);
+    }
+
+    public function name(?string $name)
+    {
+        $this->builder->whereHas(
+            'user',
+            function ($query) use ($name) {
+                $query->searchWhere('name', $name);
+            }
+        );
+    }
+
+    public function publicId(?string $publicId)
+    {
+        $this->builder->searchWhere('public_id', $publicId);
+    }
+
+    public function facilitator(string $facilitator)
+    {
+        $this->builder->where('vendor_uuid', $facilitator);
+    }
+
+    public function vehicle(string $vehicle)
+    {
+        if (Str::isUuid($vehicle)) {
+            $this->builder->where('vehicle_uuid', $vehicle);
+        } else {
+            $this->builder->whereHas(
+                'vehicle',
+                function ($query) use ($vehicle) {
+                    $query->search($vehicle);
+                }
+            );
+        }
+    }
+
+    public function driversLicenseNumber(?string $driversLicenseNumber)
+    {
+        $this->builder->searchWhere('drivers_license_number', $driversLicenseNumber);
+    }
+
+    public function phone(string $phone)
+    {
+        $this->builder->whereHas(
+            'phone',
+            function ($query) use ($phone) {
+                $query->search($phone);
+            }
+        );
+    }
+
+    public function country(?string $country)
+    {
+        if (strpos($country, ',') !== false) {
+            $this->builder->whereIn('country', explode(',', $country));
+        } else {
+            $this->builder->searchWhere('country', $country);
+        }
+    }
+
+    public function status(?string $status)
+    {
+        $this->builder->searchWhere('status', $status);
+    }
+
+    public function vendor(string $vendor)
+    {
+        $this->facilitator($vendor);
+    }
+
+    public function fleet(string $fleet)
+    {
+        $this->builder->whereHas(
+            'fleets',
+            function ($q) use ($fleet) {
+                $q->where('fleet_uuid', $fleet);
+            }
+        );
+    }
+
+    public function createdAt($createdAt)
+    {
+        $createdAt = Utils::dateRange($createdAt);
+
+        if (is_array($createdAt)) {
+            $this->builder->whereBetween('created_at', $createdAt);
+        } else {
+            $this->builder->whereDate('created_at', $createdAt);
+        }
+    }
+
+    public function updatedAt($updatedAt)
+    {
+        $updatedAt = Utils::dateRange($updatedAt);
+
+        if (is_array($updatedAt)) {
+            $this->builder->whereBetween('updated_at', $updatedAt);
+        } else {
+            $this->builder->whereDate('updated_at', $updatedAt);
+        }
+    }
+}

package/server/src/Http/Filter/FleetFilter.php

@@ -0,0 +1,108 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Http\Filter\Filter;
+
+class FleetFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder->where('company_uuid', $this->session->get('company'))->with(['serviceArea', 'zone']);
+    }
+
+    public function query(?string $searchQuery)
+    {
+        $this->builder->where(function ($query) use ($searchQuery) {
+            $query->orWhereHas(
+                'user',
+                function ($query) use ($searchQuery) {
+                    $query->searchWhere(['name', 'email', 'phone'], $searchQuery);
+                }
+            );
+        });
+    }
+
+    public function serviceArea(?string $serviceArea)
+    {
+        $this->builder->whereHas(
+            'serviceArea',
+            function ($query) use ($serviceArea) {
+                $query->where('uuid', $serviceArea);
+            }
+        );
+    }
+
+    public function zone(?string $zone)
+    {
+        $this->builder->whereHas(
+            'zone',
+            function ($query) use ($zone) {
+                $query->where('uuid', $zone);
+            }
+        );
+    }
+
+    public function parentFleet(?string $fleet)
+    {
+        $this->builder->whereHas(
+            'parent_fleet',
+            function ($query) use ($fleet) {
+                $query->where('uuid', $fleet);
+            }
+        );
+    }
+
+    public function vendor(?string $vendor)
+    {
+        $this->builder->whereHas(
+            'vendor',
+            function ($query) use ($vendor) {
+                $query->where('uuid', $vendor);
+            }
+        );
+    }
+
+    public function internalId(?string $internalId)
+    {
+        $this->builder->searchWhere('internal_id', $internalId);
+    }
+
+    public function publicId(?string $publicId)
+    {
+        $this->builder->searchWhere('public_id', $publicId);
+    }
+
+    public function task(?string $task)
+    {
+        $this->builder->searchWhere('task', $task);
+    }
+
+    public function status(?string $status)
+    {
+        $this->builder->searchWhere('status', $status);
+    }
+
+    public function createdAt($createdAt)
+    {
+        $createdAt = Utils::dateRange($createdAt);
+
+        if (is_array($createdAt)) {
+            $this->builder->whereBetween('created_at', $createdAt);
+        } else {
+            $this->builder->whereDate('created_at', $createdAt);
+        }
+    }
+
+    public function updatedAt($updatedAt)
+    {
+        $updatedAt = Utils::dateRange($updatedAt);
+
+        if (is_array($updatedAt)) {
+            $this->builder->whereBetween('updated_at', $updatedAt);
+        } else {
+            $this->builder->whereDate('updated_at', $updatedAt);
+        }
+    }
+}

package/server/src/Http/Filter/IntegratedVendorFilter.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\Http\Filter\Filter;
+
+class IntegratedVendorFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder->where('company_uuid', $this->session->get('company'));
+    }
+}

package/server/src/Http/Filter/OrderFilter.php

@@ -0,0 +1,242 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\Http\Filter\Filter;
+use Fleetbase\Support\Http;
+use Illuminate\Support\Str;
+
+class OrderFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder
+            ->where('company_uuid', $this->request->session()->get('company'))
+            ->whereHas(
+                'payload',
+                function ($q) {
+                    $q->where(
+                        function ($q) {
+                            $q->whereHas('waypoints');
+                            $q->orWhereHas('pickup');
+                            $q->orWhereHas('dropoff');
+                        }
+                    );
+                    $q->with(['entities', 'waypoints', 'dropoff', 'pickup', 'return']);
+                }
+            )
+            ->whereHas('trackingNumber')
+            ->whereHas('trackingStatuses')
+            ->with(
+                [
+                    'payload',
+                    'trackingNumber',
+                    'trackingStatuses',
+                ]
+            );
+    }
+
+    public function unassigned(bool $unassigned)
+    {
+        if ($unassigned) {
+            $this->builder->where(
+                function ($q) {
+                    $q->whereNull('driver_assigned_uuid');
+                    $q->whereNotIn('status', ['completed', 'canceled', 'expired']);
+                }
+            );
+        }
+    }
+
+    public function tracking(string $tracking)
+    {
+        $this->builder->whereHas(
+            'trackingNumber',
+            function ($query) use ($tracking) {
+                $query->where('tracking_number', $tracking);
+            }
+        );
+    }
+
+    public function active(bool $active = false)
+    {
+        if ($active) {
+            $this->builder->where(
+                function ($q) {
+                    $q->whereNotIn('status', ['created', 'dispatched', 'pending', 'canceled', 'completed']);
+                    $q->whereNotNull('driver_assigned_uuid');
+                }
+            );
+        }
+    }
+
+    public function status(string $status)
+    {
+        // handle `active` alias status
+        if ($status === 'active') {
+            // active status is anything that is not these values
+            $this->builder->whereNotIn('status', ['completed', 'expired', 'canceled']);
+            // remove the searchBuilder where clause
+            $this->builder->removeWhereFromQuery('status', 'active');
+        } elseif (is_string($status)) {
+            $this->builder->where('status', $status);
+        }
+
+        // if status is array
+        if ($this->request->isArray('status')) {
+            $this->builder->whereIn('status', $status);
+        }
+    }
+
+    public function customer(string $customer)
+    {
+        $this->builder->where('customer_uuid', $customer);
+    }
+
+    public function facilitator(string $facilitator)
+    {
+        $this->builder->where('facilitator_uuid', $facilitator);
+    }
+
+    public function type(string $type)
+    {
+        $this->builder->where('type', $type);
+    }
+
+    public function payload(string $payload)
+    {
+        if (Str::isUuid($payload)) {
+            $this->builder->where('payload_uuid', $payload);
+        } else {
+            $this->builder->whereHas(
+                'payload',
+                function ($query) use ($payload) {
+                    $query->where('public_id', $payload);
+                }
+            );
+        }
+    }
+
+    public function pickup(string $pickup)
+    {
+        $this->builder->whereHas(
+            'payload',
+            function ($query) use ($pickup) {
+                if (Str::isUuid($pickup)) {
+                    $query->where('pickup_uuid', $pickup);
+                } else {
+                    $query->whereHas(
+                        'dropoff',
+                        function ($query) use ($pickup) {
+                            $query->where('public_id', $pickup);
+                            $query->orWhere('internal_id', $pickup);
+                        }
+                    );
+                }
+            }
+        );
+    }
+
+    public function dropoff(string $dropoff)
+    {
+        $this->builder->whereHas(
+            'payload',
+            function ($query) use ($dropoff) {
+                if (Str::isUuid($dropoff)) {
+                    $query->where('dropoff_uuid', $dropoff);
+                } else {
+                    $query->whereHas(
+                        'dropoff',
+                        function ($query) use ($dropoff) {
+                            $query->where('public_id', $dropoff);
+                            $query->orWhere('internal_id', $dropoff);
+                        }
+                    );
+                }
+            }
+        );
+    }
+
+    public function return(string $return)
+    {
+        $this->builder->whereHas(
+            'payload',
+            function ($query) use ($return) {
+                if (Str::isUuid($return)) {
+                    $query->where('return_uuid', $return);
+                } else {
+                    $query->whereHas(
+                        'return',
+                        function ($query) use ($return) {
+                            $query->where('public_id', $return);
+                            $query->orWhere('internal_id', $return);
+                        }
+                    );
+                }
+            }
+        );
+    }
+
+    public function driver(string $driver)
+    {
+        if (Str::isUuid($driver)) {
+            $this->builder->where('driver_assigned_uuid', $driver);
+        } else {
+            $this->builder->whereHas(
+                'driverAssigned',
+                function ($query) use ($driver) {
+                    $query->where('public_id', $driver);
+                    $query->orWhere('internal_id', $driver);
+                }
+            );
+            // include entities which can be assigned drivers
+            $this->builder->orWhereHas('payload.entities', function ($query) use ($driver) {
+                $query->whereNotNull('driver_assigned_uuid');
+                $query->whereHas(
+                    'driver',
+                    function ($query) use ($driver) {
+                        $query->where('public_id', $driver);
+                        $query->orWhere('internal_id', $driver);
+                    }
+                );
+            });
+        }
+    }
+
+    public function sort(string $sort)
+    {
+        list($param, $direction) = Http::useSort($sort);
+
+        switch ($param) {
+            case 'tracking':
+            case 'tracking_number':
+                $this->builder->addSelect(['tns.tracking_number as tracking']);
+                $this->builder->join('tracking_numbers as tns', 'tns.uuid', '=', 'orders.tracking_number_uuid')->orderBy('tracking', $direction);
+                break;
+
+            case 'customer':
+                $this->builder->select(['orders.*', 'vendors.name as customer_name']);
+                $this->builder->join('contacts', 'contacts.uuid', '=', 'orders.customer_uuid')->orderBy('customer_name', $direction);
+                break;
+
+            case 'facilitator':
+                $this->builder->select(['orders.*', 'vendors.name as facilitator_name']);
+                $this->builder->join('vendors', 'vendors.uuid', '=', 'orders.facilitator_uuid')->orderBy('facilitator_name', $direction);
+                break;
+
+            case 'pickup':
+                $this->builder->select(['orders.*', 'places.name as pickup_name']);
+                $this->builder->join('payloads', 'payloads.uuid', '=', 'orders.payload_uuid');
+                $this->builder->join('places', 'places.uuid', '=', 'payloads.pickup_uuid')->orderBy('pickup_name', $direction);
+                break;
+
+            case 'dropoff':
+                $this->builder->select(['orders.*', 'places.name as dropoff_name']);
+                $this->builder->join('payloads', 'payloads.uuid', '=', 'orders.payload_uuid');
+                $this->builder->join('places', 'places.uuid', '=', 'payloads.dropoff_uuid')->orderBy('dropoff_name', $direction);
+                break;
+        }
+
+        return $this->builder;
+    }
+}

package/server/src/Http/Filter/PlaceFilter.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Filter;
+
+use Fleetbase\FleetOps\Models\ServiceArea;
+use Fleetbase\FleetOps\Models\Zone;
+use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Http\Filter\Filter;
+use Grimzy\LaravelMysqlSpatial\Types\Geometry;
+
+class PlaceFilter extends Filter
+{
+    public function queryForInternal()
+    {
+        $this->builder->where('company_uuid', $this->session->get('company'));
+    }
+
+    public function query(?string $searchQuery)
+    {
+        $this->builder->search($searchQuery);
+    }
+
+    public function internalId(?string $internalId)
+    {
+        $this->builder->searchWhere('internal_id', $internalId);
+    }
+
+    public function publicId(?string $publicId)
+    {
+        $this->builder->searchWhere('public_id', $publicId);
+    }
+
+    public function phone(?string $phone)
+    {
+        $this->builder->searchWhere('phone', $phone);
+    }
+
+    public function email(?string $email)
+    {
+        $this->builder->searchWhere('email', $email);
+    }
+
+    public function country(?string $country)
+    {
+        $this->builder->where('country', $country);
+    }
+
+    public function within($within)
+    {
+        // search for places within a radius of center coordinates
+        $center = Utils::getPointFromMixed($within);
+
+        // get the radius
+        $radius = data_get($within, 'radius', 20); // 20km
+
+        // Convert the radius to degrees if using geographical coordinates
+        $radiusInDegrees = $radius / 111.32;
+
+        // Create a query to find places within the circle
+        $this->builder->whereRaw('ST_Within(location, ST_Buffer(ST_GeomFromText(?), ?))', [
+            $center->toWKT(),
+            $radiusInDegrees,
+        ]);
+    }
+
+    public function nearby($nearby)
+    {
+        // search for places within a radius of center coordinates
+        $center = Utils::getPointFromMixed($nearby);
+
+        // get the radius
+        $radius = data_get($nearby, 'radius', 5); // 5km
+
+        // Convert the radius to degrees if using geographical coordinates
+        $radiusInDegrees = $radius / 111.32;
+
+        // Create a query to find places within the circle
+        $this->builder->whereRaw('ST_Within(location, ST_Buffer(ST_GeomFromText(?), ?))', [
+            $center->toWKT(),
+            $radiusInDegrees,
+        ]);
+    }
+
+    public function withinServiceArea($serviceAreaId)
+    {
+        $serviceArea = ServiceArea::where('uuid', $serviceAreaId)->orWhere('public_id', $serviceAreaId)->first('border');
+
+        if ($serviceArea->border instanceof Geometry) {
+            $this->builder->within('location', $serviceArea->border);
+        }
+    }
+
+    public function serviceArea($serviceAreaId)
+    {
+        $this->withinServiceArea($serviceAreaId);
+    }
+
+    public function withinZone($zoneId)
+    {
+        $zone = Zone::where('uuid', $zoneId)->orWhere('public_id', $zoneId)->first('border');
+
+        if ($zone->border instanceof Geometry) {
+            $this->builder->within('location', $zone->border);
+        }
+    }
+
+    public function zone($zoneId)
+    {
+        $this->withinZone($zoneId);
+    }
+}