@fleetbase/fleetops-engine 0.4.16 → 0.4.17

package/server/src/Flow/Condition.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace Fleetbase\FleetOps\Flow;
+
+use Fleetbase\FleetOps\Models\Order;
+use Illuminate\Support\Str;
+
+class Condition extends FlowResource
+{
+    /**
+     * Evaluate the condition against an order.
+     *
+     * @param Order $order the order to evaluate the condition against
+     *
+     * @return bool the result of the condition evaluation
+     *
+     * @throws \Exception if the operator is unknown
+     */
+    public function eval(Order $order)
+    {
+        $field       = $this->field;
+        $operator    = $this->operator;
+        $value       = $this->value;
+        $actualValue = strtolower($order->resolveDynamicValue($field));
+
+        // if value is string convert to lowercase
+        if (is_string($value)) {
+            $value = strtolower($value);
+        }
+
+        switch ($operator) {
+            case 'exists':
+                return isset($actualValue);
+
+            case 'in':
+            case 'has':
+                return is_array($actualValue) && in_array($actualValue, $value);
+
+            case 'notIn':
+            case 'doesntHave':
+                return is_array($actualValue) && !in_array($actualValue, $value);
+
+            case 'contains':
+                return is_string($value) && is_string($actualValue) && Str::contains($value, $actualValue);
+
+            case 'beginsWith':
+                return is_string($value) && is_string($actualValue) && Str::startsWith($value, $actualValue);
+
+            case 'endsWith':
+                return is_string($value) && is_string($actualValue) && Str::endsWith($value, $actualValue);
+
+            case 'equal':
+                return $actualValue == $value;
+
+            case 'and':
+                return $actualValue && $value;
+
+            case 'or':
+                return $actualValue || $value;
+
+            case 'not':
+                return !$actualValue;
+
+            case 'notEqual':
+                return $actualValue != $value;
+
+            case 'greaterThan':
+                return $actualValue > $value;
+
+            case 'greaterThanOrEqual':
+                return $actualValue >= $value;
+
+            case 'lessThan':
+                return $actualValue < $value;
+
+            case 'lessThanOrEqual':
+                return $actualValue <= $value;
+
+                // ... and so on for the other operators
+            default:
+                throw new \Exception("Unknown operator: {$operator}");
+        }
+    }
+}

package/server/src/Flow/Event.php

@@ -0,0 +1,88 @@
+<?php
+
+namespace Fleetbase\FleetOps\Flow;
+
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Support\Utils;
+use Illuminate\Support\Str;
+
+class Event
+{
+    /**
+     * The name of the event.
+     */
+    public string $name;
+
+    /**
+     * The order associated with the event, if any.
+     *
+     * @var ?Order
+     */
+    public ?Order $order = null;
+
+    /**
+     * Constructs a new Event instance.
+     *
+     * @param string $name  the name of the event
+     * @param ?Order $order the associated order, if any
+     */
+    public function __construct(string $name, ?Order $order = null)
+    {
+        $this->name  = $name;
+        $this->order = $order;
+    }
+
+    /**
+     * Sets the order for the event.
+     *
+     * @param Order $order the order to associate with this event
+     */
+    public function setOrder(Order $order)
+    {
+        $this->order = $order;
+    }
+
+    /**
+     * Triggers the event, optionally setting the order if not already set.
+     *
+     * Resolves the event class based on the event name and fires it using Laravel's event system.
+     * If the order is not set in the event, and an Order object is provided, it sets the order before firing.
+     *
+     * @param ?Order $order optional order to associate with the event
+     */
+    public function fire(?Order $order = null)
+    {
+        if (!$this->order && $order instanceof Order) {
+            $this->setOrder($order);
+        }
+
+        $eventClass = $this->resolve();
+        if ($eventClass) {
+            event(new $eventClass($this->order));
+        }
+    }
+
+    /**
+     * Resolves the class name of the event based on the event name.
+     *
+     * Tries to locate the class in predefined namespaces and returns the fully qualified name if found.
+     *
+     * @return string|null the resolved class name or null if not found
+     */
+    public function resolve()
+    {
+        $eventClassName = Str::studly(preg_replace('/[^a-zA-Z0-9]/', ' ', $this->name));
+        $eventClasses   = [
+            '\\Fleetbase\\FleetOps\Events\\' . $eventClassName,
+            '\\Fleetbase\\Events\\' . $eventClassName,
+        ];
+
+        foreach ($eventClasses as $eventClass) {
+            if (Utils::classExists($eventClass)) {
+                return $eventClass;
+            }
+        }
+
+        return null;
+    }
+}

package/server/src/Flow/Flow.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Fleetbase\FleetOps\Flow;
+
+class Flow extends FlowResource implements \IteratorAggregate
+{
+    /**
+     * Returns an iterator for the flow.
+     *
+     * @return \Traversable an iterator for the flow's activities
+     */
+    public function getIterator(): \Traversable
+    {
+        foreach ($this->attributes['activities'] as $activityAttributes) {
+            yield new Activity($activityAttributes, $this->serialize());
+        }
+    }
+
+    /**
+     * Retrieve the activity for a given code.
+     *
+     * @param string $code the unique code identifier for the activity
+     *
+     * @return Activity|null the Activity object if found, or null otherwise
+     */
+    public function getActivity(string $code): ?Activity
+    {
+        if (isset($this->{$code})) {
+            return new Activity($this->{$code}, $this->serialize());
+        }
+
+        return null;
+    }
+
+    /**
+     * Determines if a given object is an instance of Activity.
+     *
+     * This static method is used to check if a provided object is an
+     * instance of the Activity class. This can be useful in contexts where
+     * there is a need to verify the type of a given resource or object.
+     *
+     * @param mixed $activity the object to check
+     *
+     * @return bool returns true if the provided object is an instance of Activity, false otherwise
+     */
+    public static function isActivity($activity)
+    {
+        return $activity instanceof Activity;
+    }
+}

package/server/src/Flow/FlowResource.php

@@ -0,0 +1,143 @@
+<?php
+
+namespace Fleetbase\FleetOps\Flow;
+
+use Illuminate\Support\Str;
+
+/**
+ * Base class for flow resources which can serialize to JSON.
+ */
+class FlowResource implements \JsonSerializable
+{
+    /**
+     * The array of attributes for the flow resource.
+     */
+    public array $attributes = [];
+
+    /**
+     * Create a new flow resource instance.
+     *
+     * @param array $attributes attributes to set upon construction
+     */
+    public function __construct(array $attributes = [])
+    {
+        $this->attributes = $attributes;
+    }
+
+    /**
+     * Magic method to retrieve the value of a property.
+     * If a getter method exists for the property, it will be used; otherwise, it will access the property directly.
+     *
+     * @param string $name the name of the property to access
+     *
+     * @return mixed the value of the property
+     */
+    public function __get($name)
+    {
+        // if has special attribute `get_Attribute()` call first
+        $mutatorMethod = 'get' . Str::studly($name) . 'Attribute';
+        if (method_exists($this, $mutatorMethod)) {
+            return $this->{$mutatorMethod}();
+        }
+
+        if (array_key_exists($name, $this->attributes)) {
+            return $this->attributes[$name];
+        }
+
+        return $this->{$name};
+    }
+
+    /**
+     * Magic method to check if a property is set.
+     * This will return true if the property exists and is not null.
+     *
+     * @param string $name the name of the property to check
+     *
+     * @return bool true if the property is set, false otherwise
+     */
+    public function __isset($name)
+    {
+        if (array_key_exists($name, $this->attributes)) {
+            return isset($this->attributes[$name]);
+        }
+
+        return isset($this->{$name});
+    }
+
+    /**
+     * Get the value of a given key from the attributes.
+     * If the key does not exist, the default value will be returned.
+     *
+     * @param string $key          the key to retrieve
+     * @param mixed  $defaultValue the default value to return if the key does not exist
+     *
+     * @return mixed the value from the attributes or the default value
+     */
+    public function get($key, $defaultValue = null)
+    {
+        if (array_key_exists($key, $this->attributes)) {
+            return $this->attributes[$key];
+        }
+
+        if (isset($this->{$key})) {
+            return $this->{$key};
+        }
+
+        return data_get($this, $key, $defaultValue);
+    }
+
+    /**
+     * Set a given attribute on the resource.
+     *
+     * @param string $key   the key of the attribute to set
+     * @param mixed  $value the value to set for the attribute
+     *
+     * @return self returns instance of FlowResource for chaining
+     */
+    public function set(string $key, $value): self
+    {
+        $this->attributes[$key] = $value;
+
+        return $this;
+    }
+
+    /**
+     * Serialize the attributes to an array.
+     *
+     * @return array the array representation of the attributes
+     */
+    public function serialize(): array
+    {
+        return $this->attributes;
+    }
+
+    /**
+     * Convert the object into an array.
+     *
+     * @return array the array representation of the object
+     */
+    public function toArray(): array
+    {
+        return $this->serialize();
+    }
+
+    /**
+     * Convert the object into a JSON string.
+     *
+     * @return string the JSON representation of the object
+     */
+    public function toJson()
+    {
+        return json_encode($this->serialize());
+    }
+
+    /**
+     * Specify data which should be serialized to JSON.
+     *
+     * @return mixed data which can be serialized by json_encode, which is a value of any type other than a resource
+     */
+    public function jsonSerialize()
+    {
+        return $this->toArray();
+    }
+}

package/server/src/Flow/Logic.php

@@ -2,6 +2,62 @@
 
 namespace Fleetbase\FleetOps\Flow;
 
-class Logic
+use Fleetbase\FleetOps\Models\Order;
+
+class Logic extends FlowResource
 {
+    /**
+     * Accessor method to retrieve the 'conditions' attribute.
+     *
+     * This method maps each condition in the 'conditions' attribute to a new Condition object.
+     * It utilizes the array_map function to apply this transformation, ensuring each entry
+     * in the conditions array is converted to a Condition object.
+     *
+     * @return array an array of Condition objects derived from the 'conditions' attribute
+     */
+    public function getConditionsAttribute(): array
+    {
+        return array_map(
+            function ($condition) {
+                return new Condition($condition);
+            },
+            $this->get('conditions', [])
+        );
+    }
+
+    /**
+     * Evaluates the logic conditions against an order.
+     *
+     * @param Order $order the order to evaluate the logic against
+     *
+     * @return bool whether the logic passes based on the order's attributes
+     *
+     * @throws \Exception if the logic type is unknown
+     */
+    public function passes(Order $order)
+    {
+        $logicType  = $this->type;
+        $conditions = collect($this->conditions);
+
+        switch ($logicType) {
+            case 'and':
+                // All conditions must be true
+                return $conditions->every(fn ($condition) => $condition->eval($order));
+
+            case 'or':
+                // At least one condition must be true
+                return $conditions->contains(fn ($condition) => $condition->eval($order));
+
+            case 'not':
+                // None of the conditions must be true
+                return !$conditions->contains(fn ($condition) => $condition->eval($order));
+
+            case 'if':
+                // 'if' type logic can have multiple conditions; all must be true
+                return $conditions->every(fn ($condition) => $condition->eval($order));
+
+            default:
+                throw new \Exception("Unknown logic type: {$logicType}");
+        }
+    }
 }

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

@@ -527,7 +527,7 @@ class DriverController extends Controller
         }
 
         // Get the user account company
-        $company = Flow::getCompanySessionForUser($user);
+        $company = Auth::getCompanySessionForUser($user);
         if (!$company) {
             return response()->apiError('No company found for this driver.');
         }
@@ -752,7 +752,7 @@ class DriverController extends Controller
 
         // If unable to find company from driver profile, fallback to session flow
         if (!$company) {
-            $company = Flow::getCompanySessionForUser($user);
+            $company = Auth::getCompanySessionForUser($user);
         }
 
         return $company;

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

@@ -0,0 +1,132 @@
+<?php
+
+namespace Fleetbase\FleetOps\Http\Controllers\Api\v1;
+
+use Fleetbase\FleetOps\Http\Requests\CreateIssueRequest;
+use Fleetbase\FleetOps\Http\Requests\UpdateIssueRequest;
+use Fleetbase\FleetOps\Http\Resources\v1\Issue as DeletedIssue;
+use Fleetbase\FleetOps\Http\Resources\v1\Issue as IssueResource;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\FleetOps\Models\Issue;
+use Fleetbase\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+
+class IssueController extends Controller
+{
+    /**
+     * Creates a new Fleetbase Issue resource.
+     *
+     * @param \Fleetbase\Http\Requests\CreateIssueRequest $request
+     *
+     * @return \Fleetbase\Http\Resources\Entity
+     */
+    public function createRecord(CreateIssueRequest $request)
+    {
+        // get request input
+        $input = $request->only([
+            'driver',
+            'location',
+            'category',
+            'type',
+            'report',
+            'priority',
+        ]);
+
+        // Find driver who is reporting
+        try {
+            $driver = Driver::findRecordOrFail($request->input('driver'));
+        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+            return response()->json(
+                [
+                    'error' => 'Driver reporting issue not found.',
+                ],
+                404
+            );
+        }
+
+        // get the user uuid
+        $input['driver_uuid']      = $driver->uuid;
+        $input['reported_by_uuid'] = $driver->user_uuid;
+        $input['vehicle_uuid']     = $driver->vehicle_uuid;
+
+        // create the entity
+        $entity = Issue::create($input);
+
+        // response the driver resource
+        return new IssueResource($entity);
+    }
+
+    /**
+     * Updates new Fleetbase Issue resource.
+     *
+     * @param string                                      $id
+     * @param \Fleetbase\Http\Requests\UpdateIssueRequest $request
+     *
+     * @return \Fleetbase\Http\Resources\Issue
+     */
+    public function updateRecord($id, UpdateIssueRequest $request)
+    {
+        // find for the issue
+        try {
+            $issue = Issue::findRecordOrFail($id);
+        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+            return response()->json(
+                [
+                    'error' => 'Issue resource not found.',
+                ],
+                404
+            );
+        }
+
+        $input = $request->only([
+                'category',
+                'type',
+                'report',
+                'priority',
+            ]);
+
+        // update the issue
+        $issue->update($input);
+
+        // response the issue resource
+        return new IssueResource($issue);
+    }
+
+    /**
+     * Query for Fleetbase Issue resources.
+     *
+     * @return \Fleetbase\Http\Resources\FleetCollection
+     */
+    public function queryRecord(Request $request)
+    {
+        $results = Issue::queryWithRequest($request);
+
+        return IssueResource::collection($results);
+    }
+
+    /**
+     * Deletes a Fleetbase Issue resources.
+     *
+     * @return \Fleetbase\Http\Resources\FleetCollection
+     */
+    public function deleteRecord($id)
+    {
+        // find for the driver
+        try {
+            $issue = Issue::findRecordOrFail($id);
+        } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $exception) {
+            return response()->json(
+                [
+                    'error' => 'Issue resource not found.',
+                ],
+                404
+            );
+        }
+
+        // delete the issue
+        $issue->delete();
+
+        // response the issue resource
+        return new DeletedIssue($issue);
+    }
+}