@fleetbase/fleetops-engine 0.4.16 → 0.4.18

package/server/src/Flow/Activity.php

@@ -2,12 +2,238 @@
 
 namespace Fleetbase\FleetOps\Flow;
 
-use Fleetbase\Models\Model;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\FleetOps\Support\Utils;
 
-class Activity
+class Activity extends FlowResource
 {
-    protected string $status;
-    protected string $code;
-    protected string $details;
-    protected Model $owner;
+    /**
+     * The Flow context for the activity.
+     */
+    public Flow $flow;
+
+    /**
+     * Create a new Activity instance.
+     *
+     * @param array $attributes initial attributes of the activity
+     * @param array $flow       the flow configuration for this activity
+     */
+    public function __construct(array $attributes = [], array $flow = [])
+    {
+        parent::__construct($attributes);
+        $this->flow = new Flow($flow);
+    }
+
+    /**
+     * Retrieves the logic attribute of the Activity.
+     *
+     * @return array an array of Logic instances associated with the Activity
+     */
+    public function getLogicAttribute(): array
+    {
+        return array_map(
+            function ($logic) {
+                return new Logic($logic);
+            },
+            $this->get('logic', [])
+        );
+    }
+
+    /**
+     * Retrieves the events attribute of the Activity.
+     *
+     * @return array an array of Event instances associated with the Activity
+     */
+    public function getEventsAttribute(): array
+    {
+        return array_map(
+            function ($eventName) {
+                return new Event($eventName);
+            },
+            $this->get('events', [])
+        );
+    }
+
+    /**
+     * Determines if the Activity passes based on the provided Order.
+     *
+     * @param Order $order the order to evaluate against the Activity's logic
+     *
+     * @return bool true if all the logic associated with the Activity passes; False otherwise
+     */
+    public function passes(Order $order)
+    {
+        $logicCollection = collect($this->logic);
+
+        return $logicCollection->every(function ($logic) use ($order) {
+            $conditionCollection = collect($logic->conditions);
+
+            switch ($logic->type) {
+                case 'and':
+                    // All conditions must be true
+                    return $conditionCollection->every(fn ($condition) => $condition->eval($order));
+
+                case 'or':
+                    // At least one condition must be true
+                    return $conditionCollection->contains(fn ($condition) => $condition->eval($order));
+
+                case 'not':
+                    // None of the conditions must be true (assuming 'not' can have multiple conditions)
+                    return !$conditionCollection->contains(fn ($condition) => $condition->eval($order));
+
+                case 'if':
+                    // Only one condition in 'if', and it must be true (typically, 'if' has only one condition)
+                    return $conditionCollection->first()->eval($order);
+
+                default:
+                    // Unrecognized logic type
+                    throw new \Exception("Unsupported logic type '{$logic->type}' provided.");
+            }
+        });
+    }
+
+    /**
+     * Fires a series of events associated with an order.
+     *
+     * Iterates over the events array and triggers each event, passing the order as a parameter.
+     * This function is typically used to execute a sequence of events as part of a workflow process.
+     *
+     * @param Order $order the order object to be passed to each event
+     */
+    public function fireEvents(Order $order)
+    {
+        foreach ($this->events as $event) {
+            $event->fire($order);
+        }
+    }
+
+    /**
+     * Retrieves the child activities of this Activity.
+     *
+     * @return \Illuminate\Support\Collection a collection of child activities
+     */
+    public function getChildActivities()
+    {
+        $children = collect();
+        if (is_array($this->activities)) {
+            foreach ($this->activities as $childActivityCode) {
+                $childActivity = $this->flow->getActivity($childActivityCode);
+                if ($childActivity) {
+                    $children->push($childActivity);
+                }
+            }
+        }
+
+        return $children;
+    }
+
+    /**
+     * Retrieves the children activities of this Activity.
+     *
+     * This is a shorthand method for `getChildActivities`.
+     *
+     * @return \Illuminate\Support\Collection the collection of child activities
+     */
+    public function children()
+    {
+        return $this->getChildActivities();
+    }
+
+    /**
+     * Checks whether this Activity has a child activity with a specified code.
+     *
+     * @param string $code the unique code identifier for the child activity
+     *
+     * @return bool true if the child activity is found; otherwise, False
+     */
+    public function hasChildActivity(string $code)
+    {
+        return $this->children()->contains(
+            function ($activity) use ($code) {
+                return $activity->code === $code;
+            }
+        );
+    }
+
+    /**
+     * Determines the next set of activities based on the provided Order.
+     *
+     * @param Order $order the order to determine the next activities for
+     *
+     * @return \Illuminate\Support\Collection a collection of the next activities
+     */
+    public function getNext(Order $order)
+    {
+        $children       = $this->getChildActivities();
+        $nextActivities = collect();
+
+        foreach ($children as $childActivity) {
+            if ($childActivity->passes($order)) {
+                $nextActivities->push($childActivity);
+            }
+        }
+
+        return $nextActivities;
+    }
+
+    /**
+     * Retrieves the previous activities of this Activity in the Flow.
+     *
+     * This method iterates over the flow to find activities that list this Activity as a child.
+     *
+     * @return \Illuminate\Support\Collection a collection of previous activities
+     */
+    public function getPrevious()
+    {
+        $previous = collect();
+        foreach ($this->flow as $activity) {
+            if ($activity->hasChildActivity($this->code)) {
+                $previous->push($activity);
+            }
+        }
+
+        return $previous;
+    }
+
+    /**
+     * Checks if the activity's code matches a specified code.
+     *
+     * This method is used to determine if the current activity instance
+     * has a specific code, which is useful for identifying the activity.
+     *
+     * @param string $code the code to compare against the activity's code
+     *
+     * @return bool returns true if the activity's code matches the specified code, false otherwise
+     */
+    public function is(string $code)
+    {
+        return $this->code === $code;
+    }
+
+    /**
+     * Determines if the activity is marked as complete.
+     *
+     * This method checks the 'complete' property of the activity. It's typically used
+     * to verify if the activity has been completed as part of the workflow process.
+     *
+     * @return bool returns true if the activity is marked as complete, false otherwise
+     */
+    public function complete(): bool
+    {
+        return Utils::isTrue($this->complete);
+    }
+
+    /**
+     * Checks if completing this activity leads to the completion of the order.
+     *
+     * This method uses the `complete` method to determine if the completion of
+     * this activity signifies the completion of the associated order. It is useful
+     * for workflows where the finalization of an activity concludes the entire order process.
+     *
+     * @return bool returns true if completing this activity completes the order, false otherwise
+     */
+    public function completesOrder(): bool
+    {
+        return $this->complete();
+    }
 }

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;