@fleetbase/storefront-engine 0.4.0 → 0.4.2

package/server/src/Notifications/StorefrontOrderPreparing.php

@@ -71,12 +71,20 @@ class StorefrontOrderPreparing extends Notification
 
     /**
      * Get the notification's delivery channels.
-     *
-     * @return array
      */
-    public function via($notifiable)
+    public function via($notifiable): array
     {
-        return ['mail', 'database', FcmChannel::class, ApnChannel::class];
+        $channels = ['mail', 'database'];
+
+        if (Storefront::hasNotificationChannelConfigured($this->storefront, 'apn')) {
+            $channels[] = ApnChannel::class;
+        }
+
+        if (Storefront::hasNotificationChannelConfigured($this->storefront, 'fcm')) {
+            $channels[] = FcmChannel::class;
+        }
+
+        return $channels;
     }
 
     /**

package/server/src/Notifications/StorefrontOrderReadyForPickup.php

@@ -71,12 +71,20 @@ class StorefrontOrderReadyForPickup extends Notification
 
     /**
      * Get the notification's delivery channels.
-     *
-     * @return array
      */
-    public function via($notifiable)
+    public function via($notifiable): array
     {
-        return ['mail', 'database', FcmChannel::class, ApnChannel::class];
+        $channels = ['mail', 'database'];
+
+        if (Storefront::hasNotificationChannelConfigured($this->storefront, 'apn')) {
+            $channels[] = ApnChannel::class;
+        }
+
+        if (Storefront::hasNotificationChannelConfigured($this->storefront, 'fcm')) {
+            $channels[] = FcmChannel::class;
+        }
+
+        return $channels;
     }
 
     /**

package/server/src/Observers/OrderObserver.php

@@ -14,10 +14,12 @@ class OrderObserver
      */
     public function creating(Order $order)
     {
-        // Set the storefront order config
-        $orderConfig = Storefront::getDefaultOrderConfig();
-        if ($orderConfig) {
-            $order->order_config_uuid = $orderConfig->uuid;
+        // Set the storefront order config if none is set already
+        if (!$order->order_config_uuid) {
+            $orderConfig = Storefront::getDefaultOrderConfig();
+            if ($orderConfig) {
+                $order->order_config_uuid = $orderConfig->uuid;
+            }
         }
     }
 }

package/server/src/Providers/StorefrontServiceProvider.php

@@ -58,6 +58,7 @@ class StorefrontServiceProvider extends CoreServiceProvider
         \Fleetbase\Storefront\Console\Commands\NotifyStorefrontOrderNearby::class,
         \Fleetbase\Storefront\Console\Commands\SendOrderNotification::class,
         \Fleetbase\Storefront\Console\Commands\PurgeExpiredCarts::class,
+        \Fleetbase\Storefront\Console\Commands\MigrateStripeSandboxCustomers::class,
     ];
 
     /**

package/server/src/Rules/IsValidLocation.php

@@ -3,7 +3,9 @@
 namespace Fleetbase\Storefront\Rules;
 
 use Fleetbase\FleetOps\Models\Place;
+use Fleetbase\FleetOps\Models\Vehicle;
 use Fleetbase\FleetOps\Support\Utils;
+use Fleetbase\Storefront\Models\FoodTruck;
 use Fleetbase\Storefront\Models\StoreLocation;
 use Illuminate\Contracts\Validation\Rule;
 use Illuminate\Support\Str;
@@ -29,6 +31,16 @@ class IsValidLocation implements Rule
             return StoreLocation::where('public_id', $value)->exists();
         }
 
+        // Validate Vehicle id
+        if (is_string($value) && Str::startsWith($value, 'vehicle_')) {
+            return Vehicle::where('public_id', $value)->exists();
+        }
+
+        // Validate FoodTruck id
+        if (is_string($value) && Str::startsWith($value, 'food_truck_')) {
+            return FoodTruck::where('public_id', $value)->exists();
+        }
+
         // Validate object with coordinates
         if (isset($value->coordinates)) {
             return Utils::isCoordinates($value->coordinates);

package/server/src/Support/PushNotification.php

@@ -17,10 +17,14 @@ use Pushok\Client as PushOkClient;
 
 class PushNotification
 {
-    public static function createApnMessage(Order $order, string $title, string $body, string $status, $notifiable = null): ApnMessage
+    public static function createApnMessage(Order $order, string $title, string $body, string $status, $notifiable = null): ?ApnMessage
     {
         $storefront = static::getStorefrontFromOrder($order);
         $client     = static::getApnClient($storefront, $order);
+        if (!$client) {
+            // create apn message anyway
+            return new ApnMessage($title, $body);
+        }
 
         return ApnMessage::create()
             ->badge(1)
@@ -33,10 +37,19 @@ class PushNotification
             ->via($client);
     }
 
-    public static function createFcmMessage(Order $order, string $title, string $body, string $status, $notifiable = null): FcmMessage
+    public static function createFcmMessage(Order $order, string $title, string $body, string $status, $notifiable = null): ?FcmMessage
     {
         $storefront          = static::getStorefrontFromOrder($order);
         $notificationChannel = static::getNotificationChannel('apn', $storefront, $order);
+        if (!$notificationChannel) {
+            // create fcm message anyway
+            return new FcmMessage(
+                notification: new FcmNotification(
+                    title: $title,
+                    body: $body
+                )
+            );
+        }
 
         // Configure FCM
         static::configureFcm($notificationChannel);
@@ -97,7 +110,7 @@ class PushNotification
         return $firebaseConfig;
     }
 
-    public static function getNotificationChannel(string $scheme, Network|Store $storefront, ?Order $order = null): NotificationChannel
+    public static function getNotificationChannel(string $scheme, Network|Store $storefront, ?Order $order = null): ?NotificationChannel
     {
         if ($order && $order->hasMeta('storefront_notification_channel')) {
             return NotificationChannel::where([
@@ -113,9 +126,12 @@ class PushNotification
         ])->first();
     }
 
-    public static function getApnClient(Network|Store $storefront, ?Order $order = null): PushOkClient
+    public static function getApnClient(Network|Store $storefront, ?Order $order = null): ?PushOkClient
     {
         $notificationChannel = static::getNotificationChannel('apn', $storefront, $order);
+        if (!$notificationChannel) {
+            return null;
+        }
         $config              = (array) $notificationChannel->config;
 
         $isProductionEnv = Utils::castBoolean(data_get($config, 'production', app()->isProduction()));

package/server/src/Support/Storefront.php

@@ -2,6 +2,7 @@
 
 namespace Fleetbase\Storefront\Support;
 
+use Fleetbase\FleetOps\Flow\Activity;
 use Fleetbase\FleetOps\Models\Contact;
 use Fleetbase\FleetOps\Models\Order;
 use Fleetbase\FleetOps\Models\OrderConfig;
@@ -9,11 +10,15 @@ use Fleetbase\Models\Company;
 use Fleetbase\Models\User;
 use Fleetbase\Storefront\Models\Gateway;
 use Fleetbase\Storefront\Models\Network;
+use Fleetbase\Storefront\Models\NotificationChannel;
 use Fleetbase\Storefront\Models\Product;
 use Fleetbase\Storefront\Models\Store;
+use Fleetbase\Storefront\Notifications\StorefrontOrderAccepted;
 use Fleetbase\Storefront\Notifications\StorefrontOrderCreated;
 use Fleetbase\Support\Auth;
 use Fleetbase\Support\Utils;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
 use Illuminate\Support\Facades\Notification;
 use Illuminate\Support\Facades\Redis;
 use Illuminate\Support\Str;
@@ -21,15 +26,20 @@ use Laravel\Sanctum\PersonalAccessToken;
 
 class Storefront
 {
+    /** @var string */
+    private const CONFIG_KEY = 'storefront';
+    /** @var string */
+    private const CONFIG_NS  = 'system:order-config:storefront';
+    /** @var array<string,OrderConfig> In-memory cache keyed by company UUID */
+    private static array $configCache = [];
+
     /**
      * Returns current store or network based on session `storefront_key`
      * with bare minimum columns, but can optionally pass in more columns to receive.
      *
      * @param array $columns
-     *
-     * @return \Fleetbase\Models\Storefront\Network|\Fleetbase\Models\Storefront\Store
      */
-    public static function about($columns = [], $with = [])
+    public static function about($columns = [], $with = []): Store|Network|null
     {
         $key = session('storefront_key');
 
@@ -38,7 +48,7 @@ class Storefront
         }
 
         if (is_array($columns)) {
-            $columns = array_merge(['uuid', 'public_id', 'company_uuid', 'backdrop_uuid', 'logo_uuid', 'name', 'description', 'translations', 'website', 'facebook', 'instagram', 'twitter', 'email', 'phone', 'tags', 'currency', 'timezone', 'pod_method', 'options'], $columns);
+            $columns = array_merge(['uuid', 'public_id', 'company_uuid', 'backdrop_uuid', 'logo_uuid', 'order_config_uuid', 'name', 'description', 'translations', 'website', 'facebook', 'instagram', 'twitter', 'email', 'phone', 'tags', 'currency', 'timezone', 'pod_method', 'options'], $columns);
         }
 
         if (Str::startsWith($key, 'store')) {
@@ -53,10 +63,16 @@ class Storefront
         return $about;
     }
 
-    public static function findAbout($id, $columns = [], $with = [])
+    /**
+     * Returns current store or network based ID param passed
+     * with bare minimum columns, but can optionally pass in more columns to receive.
+     *
+     * @param array $columns
+     */
+    public static function findAbout($id, $columns = [], $with = []): Store|Network|null
     {
         if (is_array($columns)) {
-            $columns = array_merge(['uuid', 'public_id', 'company_uuid', 'backdrop_uuid', 'logo_uuid', 'name', 'description', 'translations', 'website', 'facebook', 'instagram', 'twitter', 'email', 'phone', 'tags', 'currency', 'timezone', 'pod_method', 'options'], $columns);
+            $columns = array_merge(['uuid', 'public_id', 'company_uuid', 'backdrop_uuid', 'logo_uuid', 'order_config_uuid', 'name', 'description', 'translations', 'website', 'facebook', 'instagram', 'twitter', 'email', 'phone', 'tags', 'currency', 'timezone', 'pod_method', 'options'], $columns);
         }
 
         if (Str::startsWith($id, 'store')) {
@@ -204,57 +220,106 @@ class Storefront
         return $stripeCustomer;
     }
 
-    public static function patchOrderConfig(Order $order)
+    /**
+     * Ensure an Order has an effective OrderConfig.
+     * - If already set (FK or relation), return it.
+     * - Else resolve default for the order's company and patch the FK quietly.
+     *
+     * @param \Fleetbase\Storefront\Models\Order $order
+     *
+     * @return \Fleetbase\Storefront\Models\OrderConfig|null
+     */
+    public static function patchOrderConfig($order): ?OrderConfig
     {
-        $orderConfig = $order->config();
-        if (!$orderConfig) {
-            $orderConfig = Storefront::getDefaultOrderConfig();
-            if ($orderConfig) {
-                $order->update(['order_config_uuid' => $orderConfig->uuid]);
-            }
+        // FK fast-path
+        if (!empty($order->order_config_uuid)) {
+            return OrderConfig::where('uuid', $order->order_config_uuid)->first();
+        }
+
+        // Relation fast-path (if your Order has relation 'orderConfig')
+        $order->loadMissing('orderConfig');
+        if ($order->orderConfig instanceof OrderConfig) {
+            return $order->orderConfig;
+        }
+
+        // Resolve by company
+        $companyUuid = $order->company_uuid ?? ($order->company->uuid ?? null);
+        $orderConfig = static::getOrderConfig($companyUuid);
+
+        if ($orderConfig) {
+            // Quiet write to avoid events, if preferred
+            $order->forceFill(['order_config_uuid' => $orderConfig->uuid]);
+            method_exists($order, 'saveQuietly') ? $order->saveQuietly() : $order->save();
         }
 
         return $orderConfig;
     }
 
-    public static function getDefaultOrderConfig()
+    /**
+     * Get the default Storefront OrderConfig for the "current" company context.
+     *
+     * @return \Fleetbase\Storefront\Models\OrderConfig|null
+     */
+    public static function getDefaultOrderConfig(): ?OrderConfig
     {
-        $company = Auth::getCompany();
-        if ($company) {
-            return static::getOrderConfig($company);
-        }
+        $company = session('company') ?? (method_exists(Auth::class, 'getCompany') ? Auth::getCompany() : null);
 
-        return null;
+        return static::getOrderConfig($company);
     }
 
-    public static function getOrderConfig(Company $company)
+    /**
+     * Get (or lazily create) the Storefront OrderConfig for a company.
+     * Accepts Company model, UUID string, or null (falls back to session company).
+     *
+     * @return \Fleetbase\Storefront\Models\OrderConfig|null
+     */
+    public static function getOrderConfig(Company|string|null $company): ?OrderConfig
     {
-        $orderConfig = OrderConfig::where(['company_uuid' => $company->uuid, 'key' => 'storefront', 'namespace' => 'system:order-config:storefront'])->first();
-        if (!$orderConfig) {
-            $orderConfig = static::createStorefrontConfig($company);
+        $companyUuid = static::resolveCompanyUuid($company);
+        if (!$companyUuid) {
+            return null;
         }
 
-        return $orderConfig;
+        // Request-lifetime cache
+        if (isset(static::$configCache[$companyUuid])) {
+            return static::$configCache[$companyUuid];
+        }
+
+        $attrs = [
+            'company_uuid' => $companyUuid,
+            'key'          => self::CONFIG_KEY,
+            'namespace'    => self::CONFIG_NS,
+        ];
+
+        $config = OrderConfig::where($attrs)->first();
+        if (!$config) {
+            // Short transaction to avoid dupes under race
+            $config = DB::transaction(function () use ($attrs, $companyUuid) {
+                $existing = OrderConfig::where($attrs)->first();
+                if ($existing) {
+                    return $existing;
+                }
+
+                return static::createStorefrontConfig($companyUuid);
+            });
+        }
+
+        return static::$configCache[$companyUuid] = $config;
     }
 
     /**
-     * Creates or retrieves an existing storefront configuration for a given company.
-     *
-     * This method checks if a storefront configuration (OrderConfig) already exists for the given company.
-     * If it exists, the method returns the existing configuration. Otherwise, it creates a new configuration with
-     * predefined settings for a storefront order process. The configuration includes various stages like 'created',
-     * 'started', 'canceled', 'completed', etc., each defined with specific attributes like key, code, color, logic,
-     * events, status, actions, details, and more. These stages help manage the order lifecycle in a storefront context.
+     * Create (or retrieve) the Storefront config for a company.
+     * Accepts Company model or UUID string.
      *
-     * @param Company $company the company for which the storefront configuration is being created or retrieved
-     *
-     * @return OrderConfig the storefront order configuration associated with the specified company
+     * @return \Fleetbase\Storefront\Models\OrderConfig
      */
-    public static function createStorefrontConfig(Company $company): OrderConfig
+    public static function createStorefrontConfig(Company|string $company): OrderConfig
     {
+        $companyUuid = $company instanceof Company ? $company->uuid : $company;
+
         return OrderConfig::firstOrCreate(
             [
-                'company_uuid' => $company->uuid,
+                'company_uuid' => $companyUuid,
                 'key'          => 'storefront',
                 'namespace'    => 'system:order-config:storefront',
             ],
@@ -343,7 +408,7 @@ class Storefront
                         'require_pod' => false,
                     ],
                     'picked_up' => [
-                        'key'         => 'completed',
+                        'key'         => 'picked_up',
                         'code'        => 'picked_up',
                         'color'       => '#1f2937',
                         'logic'       => [],
@@ -483,4 +548,185 @@ class Storefront
             ]
         );
     }
+
+    /**
+     * Normalize a Company|UUID|null to a UUID string (or null if unresolved).
+     */
+    protected static function resolveCompanyUuid(Company|string|null $company): ?string
+    {
+        if ($company instanceof Company && !empty($company->uuid)) {
+            return (string) $company->uuid;
+        }
+        if (is_string($company) && $company !== '' && (method_exists(Str::class, 'isUuid') ? Str::isUuid($company) : true)) {
+            return $company;
+        }
+        $sessionCompany = session('company');
+
+        return !empty($sessionCompany) ? (string) $sessionCompany : null;
+    }
+
+    public static function createAcceptedActivity(?OrderConfig $orderConfig = null): Activity
+    {
+        return new Activity([
+            'key'         => 'accepted',
+            'code'        => 'accepted',
+            'color'       => '#1f2937',
+            'logic'       => [],
+            'events'      => [],
+            'status'      => 'Order has been accepted',
+            'actions'     => [],
+            'details'     => 'Order has been accepted by {storefront.name}',
+            'options'     => [],
+            'complete'    => false,
+            'entities'    => [],
+            'sequence'    => 0,
+            'activities'  => ['dispatched'],
+            'internalId'  => Str::uuid(),
+            'pod_method'  => 'scan',
+            'require_pod' => false,
+        ], $orderConfig ? $orderConfig->activities()->toArray() : []);
+    }
+
+    public static function autoAcceptOrder(Order $order)
+    {
+        // Patch order config
+        $orderConfig = static::patchOrderConfig($order);
+        $activity    = static::createAcceptedActivity($orderConfig);
+
+        // Dispatch already if order is a pickup
+        if ($order->isMeta('is_pickup')) {
+            $order->firstDispatchWithActivity();
+        }
+
+        // Set order as accepted
+        try {
+            $order->setStatus($activity->code);
+            $order->insertActivity($activity, $order->getLastLocation());
+        } catch (\Exception $e) {
+            Log::debug('[Storefront] was unable to accept an order.', ['order' => $order, 'activity' => $activity]);
+
+            return response()->error('Unable to accept order.');
+        }
+
+        // Notify customer order was accepted
+        try {
+            $order->customer->notify(new StorefrontOrderAccepted($order));
+        } catch (\Exception $e) {
+        }
+
+        return $order;
+    }
+
+    public static function autoDispatchOrder(Order $order, bool $adhoc = true)
+    {
+        // Patch order config
+        Storefront::patchOrderConfig($order);
+
+        if ($order->isMeta('is_pickup')) {
+            $order->updateStatus('pickup_ready');
+
+            return $order;
+        }
+
+        // toggle order to adhoc
+        if ($adhoc === true) {
+            $order->update(['adhoc' => true]);
+        } else {
+            // Find nearest driver and assign
+            $driver = $order->findClosestDrivers()->first();
+            if ($driver) {
+                $order->assignDriver($driver);
+            } else {
+                // no driver available to make adhoc
+                $order->update(['adhoc' => true]);
+            }
+        }
+
+        $order->dispatchWithActivity();
+
+        return $order;
+    }
+
+    /**
+     * Determine whether the given Store or Network has a configured notification channel.
+     *
+     * Accepts either a model instance (Store|Network) or an identifier string.
+     * When a string is provided, this method attempts to resolve it in the following order:
+     *   1) UUID        → `where('uuid', $id)`
+     *   2) public_id   → `where('public_id', $id)` (if your models use a public_id column)
+     *
+     * If resolution fails, the method returns false.
+     *
+     * @param Store|\Fleetbase\FleetOps\Models\Network|string|null $subject
+     *                                                                      Store/Network model instance or identifier (uuid/public_id)
+     * @param string                                               $channel Channel scheme/key (e.g., "email", "sms", "fcm").
+     *
+     * @return bool true if a NotificationChannel exists for the subject and scheme; otherwise false
+     *
+     * @example
+     *  YourClass::hasNotificationChannelConfigures($store, 'email');
+     *  YourClass::hasNotificationChannelConfigures($networkUuid, 'fcm');
+     *  YourClass::hasNotificationChannelConfigures('STO-12345', 'sms'); // public_id example
+     *
+     * @note The method name appears to have a typo; consider renaming to:
+     *       hasNotificationChannelConfigured() and keeping this as a BC alias.
+     */
+    public static function hasNotificationChannelConfigured(Store|Network|string|null $subject, string $channel): bool
+    {
+        $model = self::resolveSubjectToModel($subject);
+
+        if (!$model) {
+            return false;
+        }
+
+        return NotificationChannel::query()
+            ->where('owner_uuid', $model->uuid)
+            ->where('scheme', $channel)
+            ->exists();
+    }
+
+    /**
+     * Resolve the provided subject into a Store or Network model.
+     *
+     * Attempts resolution by uuid first, then by public_id (if present).
+     * Returns null if no matching model can be found.
+     *
+     * @param Store|\Fleetbase\FleetOps\Models\Network|string|null $subject
+     *
+     * @return Store|\Fleetbase\FleetOps\Models\Network|null
+     */
+    protected static function resolveSubjectToModel(Store|Network|string|null $subject): Store|Network|null
+    {
+        if ($subject instanceof Store || $subject instanceof Network) {
+            return $subject;
+        }
+
+        if (!is_string($subject) || $subject === '') {
+            return null;
+        }
+
+        // Try UUID
+        if (Str::isUuid($subject)) {
+            if ($found = Store::query()->where('uuid', $subject)->first()) {
+                return $found;
+            }
+            if ($found = Network::query()->where('uuid', $subject)->first()) {
+                return $found;
+            }
+        }
+
+        // Try public_id (optional; remove if you don't use it)
+        if (property_exists(Store::class, 'public_id') || Schema::hasColumn((new Store())->getTable(), 'public_id')) {
+            if ($found = Store::query()->where('public_id', $subject)->first()) {
+                return $found;
+            }
+        }
+        if (property_exists(Network::class, 'public_id') || Schema::hasColumn((new Network())->getTable(), 'public_id')) {
+            if ($found = Network::query()->where('public_id', $subject)->first()) {
+                return $found;
+            }
+        }
+
+        return null;
+    }
 }

package/server/src/routes.php

@@ -161,6 +161,7 @@ Route::prefix(config('storefront.api.routing.prefix', 'storefront'))->namespace(
                             function ($router, $controller) {
                                 $router->post('accept', $controller('acceptOrder'));
                                 $router->post('ready', $controller('markOrderAsReady'));
+                                $router->post('preparing', $controller('markOrderAsPreparing'));
                                 $router->post('completed', $controller('markOrderAsCompleted'));
                             }
                         );