@fleetbase/fleetops-engine 0.6.44 → 0.6.46

package/server/src/Orchestration/Engines/VroomOrchestrationEngine.php

@@ -20,13 +20,16 @@ use Illuminate\Support\Facades\Log;
  *
  * Resolution order for configuration:
  *
- *   1. Company-level setting  — `Setting::lookupCompany('vroom', 'api_key')`
- *      (written by the fleetbase/vroom extension settings page, if installed)
- *   2. Environment variable   — `VROOM_API_KEY`
- *   3. No key                 — requests are sent without an api_key parameter
+ *   1. Company-level setting  — organization override
+ *   2. System-level setting   — admin default
+ *   3. Environment/config fallback
+ *   4. No key                 — requests are sent without an api_key parameter
  *      (works for self-hosted VROOM instances that do not require auth)
  *
- *   Base URI: `config('vroom.base_uri')` → `VROOM_HOST` env → default production URL
+ *   Base URI and endpoint mode follow the same precedence, with endpoint mode
+ *   controlling whether requests are posted to `/solve` or directly to the
+ *   configured binary host.
+ *
  *   Timeout:  `VROOM_TIMEOUT` env (default 30 s)
  *
  * The VROOM HTTP API endpoint used is `POST {base_uri}/solve`, matching the
@@ -101,27 +104,17 @@ class VroomOrchestrationEngine implements OrchestrationEngineInterface
         unset($job);
 
         // ── Resolve connection config ─────────────────────────────────────────
-        // Base URI: prefer the vroom extension config, then VROOM_HOST env, then
-        // the production verso-optim.com hosted service.
-        $baseUri = config('vroom.base_uri', env('VROOM_HOST', 'https://api.verso-optim.com/vrp/v1'));
+        $baseUri = $this->resolveVroomBaseUri();
+        $endpointMode = $this->resolveVroomEndpointMode();
         $timeout = (int) env('VROOM_TIMEOUT', 30);
 
-        // ── Resolve API key ───────────────────────────────────────────────────
-        // 1. Company-level setting (written by fleetbase/vroom extension UI)
-        // 2. VROOM_API_KEY env var
-        // 3. null — no key appended (for self-hosted instances)
-        $apiKey = null;
-        try {
-            $apiKey = Setting::lookupCompany('vroom', ['api_key' => null])['api_key'] ?? null;
-        } catch (\Throwable) {
-            // Setting table may not exist in minimal installs — ignore
-        }
-        if (!$apiKey) {
-            $apiKey = env('VROOM_API_KEY');
-        }
+        $apiKey = $this->resolveVroomApiKey();
 
-        // Build the solve URL — append api_key as query param when present
-        $solveUrl = rtrim($baseUri, '/') . '/solve';
+        // Build the solve URL — append api_key as query param when present.
+        $solveUrl = rtrim($baseUri, '/');
+        if ($endpointMode !== 'binary') {
+            $solveUrl .= '/solve';
+        }
         if ($apiKey) {
             $solveUrl .= '?api_key=' . urlencode($apiKey);
         }
@@ -189,4 +182,47 @@ class VroomOrchestrationEngine implements OrchestrationEngineInterface
             'summary'     => $vroomResult['summary'] ?? [],
         ];
     }
+
+    protected function resolveVroomBaseUri(): string
+    {
+        return $this->resolveVroomSetting('api_host', config('vroom.base_uri', env('VROOM_HOST', 'https://api.verso-optim.com/vrp/v1')));
+    }
+
+    protected function resolveVroomApiKey(): ?string
+    {
+        return $this->resolveVroomSetting('api_key', env('VROOM_API_KEY'));
+    }
+
+    protected function resolveVroomEndpointMode(): string
+    {
+        return $this->resolveVroomSetting('endpoint_mode', config('vroom.endpoint_mode', env('VROOM_ENDPOINT_MODE', 'saas')));
+    }
+
+    protected function resolveVroomSetting(string $key, $default = null)
+    {
+        try {
+            $organizationValue = data_get(Setting::lookupCompany('vroom', []), $key);
+            if ($this->hasConfiguredValue($organizationValue)) {
+                return $organizationValue;
+            }
+
+            $systemValue = data_get(Setting::lookup('vroom', []), $key);
+            if ($this->hasConfiguredValue($systemValue)) {
+                return $systemValue;
+            }
+        } catch (\Throwable) {
+            // Setting table may not exist in minimal installs — ignore
+        }
+
+        return $default;
+    }
+
+    protected function hasConfiguredValue($value): bool
+    {
+        if (is_string($value)) {
+            return trim($value) !== '';
+        }
+
+        return $value !== null;
+    }
 }

package/server/src/Rules/ComputableAlgo.php

@@ -16,9 +16,7 @@ class ComputableAlgo implements Rule
      */
     public function passes($attribute, $value)
     {
-        $distanceAndTime = Algo::calculateDrivingDistanceAndTime('1.3506853', '103.87199110000006', '1.3621663', '103.88450490000002');
-
-        return Algo::exec($value, $distanceAndTime) > 0;
+        return Algo::isComputable($value);
     }
 
     /**

package/server/src/Support/Algo.php

@@ -6,6 +6,8 @@ use Webit\Util\EvalMath\EvalMath;
 
 class Algo
 {
+    protected const FUNCTION_PATTERN = '/\b(max|min|ceil|floor|round)\(([^()]*)\)/';
+
     /**
      * Execute an algorithm strig.
      *
@@ -16,11 +18,18 @@ class Algo
         $m                  = new EvalMath();
         $m->suppress_errors = true;
 
+        $variables = static::normalizeVariables($variables);
+
         foreach ($variables as $key => $value) {
             $algorithm = str_replace('{' . $key . '}', $value, $algorithm);
         }
 
-        $result = $m->evaluate($algorithm);
+        $algorithm = static::evaluateFunctions($algorithm);
+        $result    = $m->evaluate($algorithm);
+
+        if ($result === false || $result === null || !is_numeric($result)) {
+            return null;
+        }
 
         if ($round) {
             return round($result, 2); // precision 2 cuz most likely dealing with $
@@ -28,4 +37,81 @@ class Algo
 
         return $result;
     }
+
+    public static function isComputable($algorithm): bool
+    {
+        $result = static::exec($algorithm, static::validationFixture(), true);
+
+        return $result !== null && is_numeric($result);
+    }
+
+    public static function normalizeVariables($variables = []): array
+    {
+        $variables = collect($variables)->all();
+
+        $distanceM = (float) ($variables['distance_m'] ?? $variables['distance'] ?? 0);
+        $timeS     = (float) ($variables['time_s'] ?? $variables['time'] ?? 0);
+
+        $normalized = [
+            'distance_m' => $distanceM,
+            'distance'   => $distanceM,
+            'distance_km'=> $distanceM / 1000,
+            'distance_mi'=> $distanceM / 1609.344,
+            'time_s'     => $timeS,
+            'time'       => $timeS,
+            'time_min'   => $timeS / 60,
+            'stops'      => (int) ($variables['stops'] ?? 0),
+            'waypoints'  => (int) ($variables['waypoints'] ?? 0),
+            'parcels'    => (int) ($variables['parcels'] ?? 0),
+            'entities'   => (int) ($variables['entities'] ?? 0),
+            'base_fee'   => (float) ($variables['base_fee'] ?? 0),
+        ];
+
+        return array_merge($normalized, $variables);
+    }
+
+    protected static function validationFixture(): array
+    {
+        return static::normalizeVariables([
+            'distance_m' => 25000,
+            'time_s'     => 5400,
+            'stops'      => 4,
+            'waypoints'  => 2,
+            'parcels'    => 3,
+            'entities'   => 5,
+            'base_fee'   => 100,
+        ]);
+    }
+
+    protected static function evaluateFunctions(string $algorithm): string
+    {
+        while (preg_match(static::FUNCTION_PATTERN, $algorithm)) {
+            $algorithm = preg_replace_callback(static::FUNCTION_PATTERN, function ($matches) {
+                $function           = $matches[1];
+                $args               = array_map('trim', explode(',', $matches[2]));
+                $m                  = new EvalMath();
+                $m->suppress_errors = true;
+                $numbers            = array_map(function ($arg) use ($m) {
+                    $result = $m->evaluate($arg);
+
+                    if ($result === false || $result === null || !is_numeric($result)) {
+                        return (float) $arg;
+                    }
+
+                    return (float) $result;
+                }, $args);
+
+                return match ($function) {
+                    'max'   => (string) max($numbers[0] ?? 0, $numbers[1] ?? 0),
+                    'min'   => (string) min($numbers[0] ?? 0, $numbers[1] ?? 0),
+                    'ceil'  => (string) ceil($numbers[0] ?? 0),
+                    'floor' => (string) floor($numbers[0] ?? 0),
+                    'round' => (string) round($numbers[0] ?? 0, (int) ($numbers[1] ?? 0)),
+                    default => $matches[0],
+                };
+            }, $algorithm);
+        }
+
+        return $algorithm;
+    }
 }

package/server/src/Support/Utils.php

@@ -4,6 +4,8 @@ namespace Fleetbase\FleetOps\Support;
 
 use Fleetbase\FleetOps\Flow\Activity;
 use Fleetbase\LaravelMysqlSpatial\Types\Point;
+use Fleetbase\Models\Company;
+use Fleetbase\Models\Setting;
 use Fleetbase\Support\Utils as FleetbaseUtils;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Facades\DB;
@@ -20,6 +22,39 @@ class Utils extends FleetbaseUtils
      */
     public const DRIVING_TIME_MULTIPLIER = 7.2;
 
+    /**
+     * Resolve the preferred transaction currency for a company.
+     *
+     * Resolution order:
+     * 1. Organization/company configured currency
+     * 2. Ledger accounting base currency
+     * 3. USD
+     */
+    public static function getCompanyTransactionCurrency(string|Company|null $company = null): string
+    {
+        $companyModel = $company instanceof Company
+            ? $company
+            : (filled($company) ? Company::where('uuid', $company)->first() : null);
+
+        $companyUuid = $companyModel?->uuid ?? (is_string($company) ? $company : null);
+
+        $companyCurrency = data_get($companyModel, 'currency');
+        if (filled($companyCurrency)) {
+            return strtoupper($companyCurrency);
+        }
+
+        if (filled($companyUuid)) {
+            $accountingSettings = Setting::lookup('company.' . $companyUuid . '.ledger.accounting-settings', []);
+            $baseCurrency       = data_get($accountingSettings, 'base_currency');
+
+            if (filled($baseCurrency)) {
+                return strtoupper($baseCurrency);
+            }
+        }
+
+        return 'USD';
+    }
+
     /**
      * Get a formatted string representation of a place's address.
      *
@@ -209,6 +244,10 @@ class Utils extends FleetbaseUtils
             $coordinates = $coordinates->getSpatialValue();
         }
 
+        if ($coordinates instanceof \Illuminate\Database\Query\Expression) {
+            $coordinates = static::extractPointWktFromQueryExpression($coordinates) ?? $coordinates;
+        }
+
         if ($coordinates instanceof Point) {
             $latitude  = $coordinates->getLat();
             $longitude = $coordinates->getLng();
@@ -334,6 +373,32 @@ class Utils extends FleetbaseUtils
         return new Point((float) $latitude, (float) $longitude);
     }
 
+    /**
+     * Attempts to extract a WKT POINT string from a query expression.
+     */
+    protected static function extractPointWktFromQueryExpression(\Illuminate\Database\Query\Expression $expression): ?string
+    {
+        $expressionValue = null;
+
+        if (method_exists($expression, 'getValue')) {
+            try {
+                $expressionValue = $expression->getValue(DB::connection()->getQueryGrammar());
+            } catch (\Throwable $e) {
+                $expressionValue = null;
+            }
+        }
+
+        if (!is_string($expressionValue) || blank($expressionValue)) {
+            return null;
+        }
+
+        if (preg_match("/POINT\\(\\s*([-+]?\\d*\\.?\\d+)\\s+([-+]?\\d*\\.?\\d+)\\s*\\)/i", $expressionValue, $matches)) {
+            return sprintf('POINT(%s %s)', $matches[1], $matches[2]);
+        }
+
+        return null;
+    }
+
     /**
      * Always return spatial point.
      *
@@ -379,6 +444,10 @@ class Utils extends FleetbaseUtils
             $coordinates = $coordinates->getSpatialValue();
         }
 
+        if ($coordinates instanceof \Illuminate\Database\Query\Expression) {
+            $coordinates = static::extractPointWktFromQueryExpression($coordinates) ?? $coordinates;
+        }
+
         if ($coordinates instanceof Point) {
             return $coordinates;
         }

package/server/src/routes.php

@@ -546,6 +546,10 @@ Route::prefix(config('fleetops.api.routing.prefix', null))->namespace('Fleetbase
                                         $router->post('notification-settings', 'SettingController@saveNotificationSettings');
                                         $router->get('routing-settings', 'SettingController@getRoutingSettings');
                                         $router->post('routing-settings', 'SettingController@saveRoutingSettings');
+                                        $router->get('map', 'SettingController@getMapSettings');
+                                        $router->post('map', 'SettingController@saveMapSettings');
+                                        $router->get('admin-map', 'SettingController@getAdminMapSettings');
+                                        $router->post('admin-map', 'SettingController@saveAdminMapSettings');
                                         $router->get('scheduling-settings', 'SettingController@getSchedulingSettings');
                                         $router->post('scheduling-settings', 'SettingController@saveSchedulingSettings');
                                         $router->get('orchestrator-settings', 'SettingController@getOrchestratorSettings');