@fleetbase/storefront-engine 0.4.0 → 0.4.2

package/addon/utils/commerce-date-ranges.js

@@ -0,0 +1,263 @@
+import {
+    startOfDay,
+    endOfDay,
+    startOfWeek,
+    endOfWeek,
+    startOfMonth,
+    endOfMonth,
+    startOfQuarter,
+    endOfQuarter,
+    startOfYear,
+    endOfYear,
+    subDays,
+    subWeeks,
+    subMonths,
+    subQuarters,
+    subYears,
+    format,
+} from 'date-fns';
+
+/**
+ * Predefined date range buttons for ecommerce analytics dashboard
+ * Each button contains a label and a function that returns [startDate, endDate]
+ */
+export const predefinedDateRanges = [
+    // Recent periods - most commonly used for daily monitoring
+    {
+        label: 'Today',
+        getValue: () => {
+            const today = new Date();
+            return [startOfDay(today), endOfDay(today)];
+        },
+    },
+    {
+        label: 'Yesterday',
+        getValue: () => {
+            const yesterday = subDays(new Date(), 1);
+            return [startOfDay(yesterday), endOfDay(yesterday)];
+        },
+    },
+    {
+        label: 'Last 7 Days',
+        getValue: () => {
+            const today = new Date();
+            const sevenDaysAgo = subDays(today, 6); // 6 days ago + today = 7 days
+            return [startOfDay(sevenDaysAgo), endOfDay(today)];
+        },
+    },
+    {
+        label: 'Last 14 Days',
+        getValue: () => {
+            const today = new Date();
+            const fourteenDaysAgo = subDays(today, 13);
+            return [startOfDay(fourteenDaysAgo), endOfDay(today)];
+        },
+    },
+    {
+        label: 'Last 30 Days',
+        getValue: () => {
+            const today = new Date();
+            const thirtyDaysAgo = subDays(today, 29);
+            return [startOfDay(thirtyDaysAgo), endOfDay(today)];
+        },
+    },
+
+    // Weekly periods
+    {
+        label: 'This Week',
+        getValue: () => {
+            const today = new Date();
+            return [startOfWeek(today, { weekStartsOn: 1 }), endOfWeek(today, { weekStartsOn: 1 })]; // Monday start
+        },
+    },
+    {
+        label: 'Last Week',
+        getValue: () => {
+            const lastWeek = subWeeks(new Date(), 1);
+            return [startOfWeek(lastWeek, { weekStartsOn: 1 }), endOfWeek(lastWeek, { weekStartsOn: 1 })];
+        },
+    },
+
+    // Monthly periods - crucial for monthly reporting
+    {
+        label: 'This Month',
+        getValue: () => {
+            const today = new Date();
+            return [startOfMonth(today), endOfMonth(today)];
+        },
+    },
+    {
+        label: 'Last Month',
+        getValue: () => {
+            const lastMonth = subMonths(new Date(), 1);
+            return [startOfMonth(lastMonth), endOfMonth(lastMonth)];
+        },
+    },
+    {
+        label: 'Last 3 Months',
+        getValue: () => {
+            const today = new Date();
+            const threeMonthsAgo = subMonths(today, 3);
+            return [startOfMonth(threeMonthsAgo), endOfMonth(today)];
+        },
+    },
+    {
+        label: 'Last 6 Months',
+        getValue: () => {
+            const today = new Date();
+            const sixMonthsAgo = subMonths(today, 6);
+            return [startOfMonth(sixMonthsAgo), endOfMonth(today)];
+        },
+    },
+
+    // Quarterly periods - important for business reporting
+    {
+        label: 'This Quarter',
+        getValue: () => {
+            const today = new Date();
+            return [startOfQuarter(today), endOfQuarter(today)];
+        },
+    },
+    {
+        label: 'Last Quarter',
+        getValue: () => {
+            const lastQuarter = subQuarters(new Date(), 1);
+            return [startOfQuarter(lastQuarter), endOfQuarter(lastQuarter)];
+        },
+    },
+    {
+        label: 'Q1 2024',
+        getValue: () => {
+            const q1Start = new Date(2024, 0, 1); // January 1, 2024
+            return [startOfQuarter(q1Start), endOfQuarter(q1Start)];
+        },
+    },
+    {
+        label: 'Q2 2024',
+        getValue: () => {
+            const q2Start = new Date(2024, 3, 1); // April 1, 2024
+            return [startOfQuarter(q2Start), endOfQuarter(q2Start)];
+        },
+    },
+    {
+        label: 'Q3 2024',
+        getValue: () => {
+            const q3Start = new Date(2024, 6, 1); // July 1, 2024
+            return [startOfQuarter(q3Start), endOfQuarter(q3Start)];
+        },
+    },
+    {
+        label: 'Q4 2024',
+        getValue: () => {
+            const q4Start = new Date(2024, 9, 1); // October 1, 2024
+            return [startOfQuarter(q4Start), endOfQuarter(q4Start)];
+        },
+    },
+
+    // Yearly periods - essential for annual analysis
+    {
+        label: 'This Year',
+        getValue: () => {
+            const today = new Date();
+            return [startOfYear(today), endOfYear(today)];
+        },
+    },
+    {
+        label: 'Last Year',
+        getValue: () => {
+            const lastYear = subYears(new Date(), 1);
+            return [startOfYear(lastYear), endOfYear(lastYear)];
+        },
+    },
+    {
+        label: '2024',
+        getValue: () => {
+            const year2024 = new Date(2024, 0, 1);
+            return [startOfYear(year2024), endOfYear(year2024)];
+        },
+    },
+    {
+        label: '2023',
+        getValue: () => {
+            const year2023 = new Date(2023, 0, 1);
+            return [startOfYear(year2023), endOfYear(year2023)];
+        },
+    },
+
+    // Special ecommerce periods
+    {
+        label: 'Black Friday Week',
+        getValue: () => {
+            // Assuming Black Friday 2024 is November 29th
+            const blackFriday = new Date(2024, 10, 29); // November 29, 2024
+            const weekStart = subDays(blackFriday, 3); // Tuesday before
+            const weekEnd = subDays(blackFriday, -3); // Monday after
+            return [startOfDay(weekStart), endOfDay(weekEnd)];
+        },
+    },
+    {
+        label: 'Holiday Season 2024',
+        getValue: () => {
+            // November 1st to December 31st
+            const seasonStart = new Date(2024, 10, 1); // November 1, 2024
+            const seasonEnd = new Date(2024, 11, 31); // December 31, 2024
+            return [startOfDay(seasonStart), endOfDay(seasonEnd)];
+        },
+    },
+    {
+        label: 'Back to School 2024',
+        getValue: () => {
+            // August 1st to September 15th
+            const seasonStart = new Date(2024, 7, 1); // August 1, 2024
+            const seasonEnd = new Date(2024, 8, 15); // September 15, 2024
+            return [startOfDay(seasonStart), endOfDay(seasonEnd)];
+        },
+    },
+];
+
+/**
+ * Convert predefined date ranges to AirDatepicker buttons format
+ * @param {Function} onRangeSelect - Callback function when a range is selected
+ * @returns {Array} Array of button objects for AirDatepicker
+ */
+export function createDateRangeButtons(onRangeSelect) {
+    return predefinedDateRanges.map((range) => ({
+        content: range.label,
+        className: 'custom-date-range-btn',
+        onClick: (datepicker) => {
+            const [startDate, endDate] = range.getValue();
+            datepicker.selectDate([startDate, endDate]);
+            datepicker.hide();
+
+            // Call the callback if provided
+            if (typeof onRangeSelect === 'function') {
+                onRangeSelect({
+                    label: range.label,
+                    startDate,
+                    endDate,
+                    formattedRange: `${format(startDate, 'MMM dd, yyyy')} - ${format(endDate, 'MMM dd, yyyy')}`,
+                });
+            }
+        },
+    }));
+}
+
+/**
+ * Get a specific date range by label
+ * @param {string} label - The label of the date range
+ * @returns {Array|null} [startDate, endDate] or null if not found
+ */
+export function getDateRangeByLabel(label) {
+    const range = predefinedDateRanges.find((r) => r.label === label);
+    return range ? range.getValue() : null;
+}
+
+/**
+ * Format date range for display
+ * @param {Date} startDate
+ * @param {Date} endDate
+ * @returns {string} Formatted date range string
+ */
+export function formatDateRange(startDate, endDate) {
+    return `${format(startDate, 'MMM dd, yyyy')} - ${format(endDate, 'MMM dd, yyyy')}`;
+}

package/app/utils/commerce-date-ranges.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/storefront-engine/utils/commerce-date-ranges';

package/composer.json

@@ -1,6 +1,6 @@
 {
     "name": "fleetbase/storefront-api",
-    "version": "0.4.0",
+    "version": "0.4.2",
     "description": "Headless Commerce & Marketplace Extension for Fleetbase",
     "keywords": [
         "fleetbase-extension",

package/extension.json

@@ -1,6 +1,6 @@
 {
     "name": "Storefront",
-    "version": "0.4.0",
+    "version": "0.4.2",
     "description": "Headless Commerce & Marketplace Extension for Fleetbase",
     "repository": "https://github.com/fleetbase/storefront",
     "license": "AGPL-3.0-or-later",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fleetbase/storefront-engine",
-    "version": "0.4.0",
+    "version": "0.4.2",
     "description": "Headless Commerce & Marketplace Extension for Fleetbase",
     "fleetbase": {
         "route": "storefront",
@@ -44,9 +44,9 @@
     },
     "dependencies": {
         "@babel/core": "^7.23.2",
-        "@fleetbase/ember-core": "latest",
-        "@fleetbase/ember-ui": "latest",
-        "@fleetbase/fleetops-data": "^0.1.19",
+        "@fleetbase/ember-core": "^0.3.3",
+        "@fleetbase/ember-ui": "^0.3.5",
+        "@fleetbase/fleetops-data": "^0.1.20",
         "@fortawesome/ember-fontawesome": "^2.0.0",
         "@fortawesome/fontawesome-svg-core": "6.4.0",
         "@fortawesome/free-brands-svg-icons": "6.4.0",

package/server/migrations/2025_09_01_041353_add_default_order_config_column.php

@@ -0,0 +1,110 @@
+<?php
+
+use Fleetbase\Storefront\Support\Storefront;
+use Fleetbase\Support\Utils;
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Query\Expression;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        $databaseName   = Utils::getFleetbaseDatabaseName();
+        $sfConnection   = config('storefront.connection.db');
+
+        Schema::connection($sfConnection)->table('stores', function (Blueprint $table) use ($databaseName) {
+            // nullable because we’ll backfill after
+            $table->foreignUuid('order_config_uuid')
+                ->nullable()
+                ->after('backdrop_uuid')
+                ->constrained(new Expression($databaseName . '.order_configs'), 'uuid')
+                ->nullOnDelete();
+        });
+
+        Schema::connection($sfConnection)->table('networks', function (Blueprint $table) use ($databaseName) {
+            $table->foreignUuid('order_config_uuid')
+                ->nullable()
+                ->after('backdrop_uuid')
+                ->constrained(new Expression($databaseName . '.order_configs'), 'uuid')
+                ->nullOnDelete();
+        });
+
+        DB::connection($sfConnection)->transaction(function () use ($sfConnection) {
+            // Pull valid company UUIDs from core.companies
+            $validCompanyUuids = DB::connection(config('database.default'))
+            ->table('companies')
+            ->pluck('uuid')
+            ->all();
+
+            // STORES: distinct companies missing an order_config_uuid
+            $storeCompanyIds = DB::connection($sfConnection)
+                ->table('stores')
+                ->whereNull('order_config_uuid')
+                ->whereNotNull('company_uuid')
+                ->distinct()
+                ->pluck('company_uuid')
+                ->filter(fn ($uuid) => in_array($uuid, $validCompanyUuids, true))
+                ->values();
+
+            foreach ($storeCompanyIds as $companyUuid) {
+                // Resolve company-scoped default config
+                $config = Storefront::getOrderConfig($companyUuid);
+                if ($config) {
+                    DB::connection($sfConnection)
+                        ->table('stores')
+                        ->where('company_uuid', $companyUuid)
+                        ->whereNull('order_config_uuid')
+                        ->update(['order_config_uuid' => $config->uuid]);
+                }
+            }
+
+            // NETWORKS: distinct companies missing an order_config_uuid
+            $networkCompanyIds = DB::connection($sfConnection)
+                ->table('networks')
+                ->whereNull('order_config_uuid')
+                ->whereNotNull('company_uuid')
+                ->distinct()
+                ->pluck('company_uuid')
+                ->filter(fn ($uuid) => in_array($uuid, $validCompanyUuids, true))
+                ->values();
+
+            foreach ($networkCompanyIds as $companyUuid) {
+                $config = Storefront::getOrderConfig($companyUuid);
+                if ($config) {
+                    DB::connection($sfConnection)
+                        ->table('networks')
+                        ->where('company_uuid', $companyUuid)
+                        ->whereNull('order_config_uuid')
+                        ->update(['order_config_uuid' => $config->uuid]);
+                }
+            }
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        $sfConnection = config('storefront.connection.db');
+
+        // Drop FK and column for stores
+        Schema::connection($sfConnection)->table('stores', function (Blueprint $table) {
+            // Drop the foreign key constraint first, then the column
+            // Default FK name pattern: {table}_{column}_foreign
+            $table->dropForeign(['order_config_uuid']);
+            $table->dropColumn('order_config_uuid');
+        });
+
+        // Drop FK and column for networks
+        Schema::connection($sfConnection)->table('networks', function (Blueprint $table) {
+            $table->dropForeign(['order_config_uuid']);
+            $table->dropColumn('order_config_uuid');
+        });
+    }
+};

package/server/src/Console/Commands/MigrateStripeSandboxCustomers.php

@@ -0,0 +1,165 @@
+<?php
+
+namespace Fleetbase\Storefront\Console\Commands;
+
+use Fleetbase\Storefront\Models\Customer;
+use Fleetbase\Storefront\Models\Gateway;
+use Fleetbase\Storefront\Models\Store;
+use Illuminate\Console\Command;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\App;
+use Illuminate\Support\Facades\Session;
+use Stripe\Customer as StripeCustomer;
+use Stripe\Exception\InvalidRequestException;
+use Stripe\Stripe;
+
+class MigrateStripeSandboxCustomers extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * Added a --store option to allow running the migration for a single store by UUID or public_id.
+     */
+    protected $signature = 'storefront:migrate-stripe-customers 
+                            {--dry-run : Don\'t actually create or update anything}
+                            {--store= : Specify a store UUID or public_id to migrate only that store}';
+
+    /** The console command description. */
+    protected $description = 'Migrates Stripe customers created in test mode to live mode and updates contact metadata.';
+
+    /** Execute the console command. */
+    public function handle(): int
+    {
+        $dryRun     = $this->option('dry-run');
+        $storeInput = $this->option('store');
+
+        $this->startSession();
+        $this->info('Starting Stripe customer migration...');
+
+        // If a single store is specified, load that store by UUID or public_id.
+        if ($storeInput) {
+            $store = Store::where('uuid', $storeInput)
+                ->orWhere('public_id', $storeInput)
+                ->first();
+
+            if (!$store) {
+                $this->error("Store '{$storeInput}' not found.");
+
+                return Command::FAILURE;
+            }
+
+            $this->migrateCustomers($store, $dryRun);
+        } else {
+            // Otherwise, load all stores.
+            $stores = Store::all();
+            foreach ($stores as $store) {
+                $this->migrateCustomers($store, $dryRun);
+            }
+        }
+
+        $this->info('Stripe customer migration complete.');
+
+        return Command::SUCCESS;
+    }
+
+    /**
+     * Migrates all customers for a given store whose stripe_id is still pointing at test mode.
+     *
+     * Only runs when the store's gateway is configured for live mode; skips migration for sandbox gateways.
+     */
+    public function migrateCustomers(Store $store, bool $dryRun): int
+    {
+        // Find the Stripe gateway for this store (there is only one gateway per store).
+        $gateway = Gateway::where([
+            'code'      => 'stripe',
+            'owner_uuid'=> $store->uuid,
+        ])->first();
+
+        if (!$gateway) {
+            $this->warn("Store {$store->name}: no Stripe gateway configured.");
+
+            return Command::SUCCESS;
+        }
+
+        // If the gateway is still sandbox, skip migration because we can't create live customers yet.
+        if ($gateway->sandbox) {
+            $this->warn("Store {$store->name} is using a sandbox gateway. Migration will only run when the gateway is switched to live.");
+
+            return Command::SUCCESS;
+        }
+
+        // Inform the store being migrated
+        $this->info("Store {$store->name}: Will have sandbox customers migrated...");
+
+        $secretKey = $gateway->config->secret_key;
+
+        // Process customers in chunks to conserve memory.
+        Customer::where('company_uuid', $store->company_uuid)->chunk(50, function ($customers) use ($dryRun, $secretKey, $store) {
+            foreach ($customers as $customer) {
+                $stripeId = $customer->getMeta('stripe_id');
+                if (!$stripeId) {
+                    continue;
+                }
+
+                // Set the Stripe API key to the store's live secret key.
+                Stripe::setApiKey($secretKey);
+
+                $current = null;
+
+                try {
+                    // Attempt to retrieve the customer using the current key.
+                    // If found and livemode is true, no migration needed.
+                    $current = StripeCustomer::retrieve($stripeId);
+                    if ($current && $current->livemode === true) {
+                        $this->line("Customer {$customer->id}: Stripe ID {$stripeId} is already a live customer.");
+                        continue;
+                    }
+                } catch (InvalidRequestException $e) {
+                    // The existing ID was not found with the live key, so it likely belongs to the test environment.
+                }
+
+                // If we're doing a dry run, just report what would happen.
+                if ($dryRun) {
+                    $this->info("Customer {$customer->id}: Would migrate test Stripe ID {$stripeId} to live.");
+                    continue;
+                }
+
+                // Create a new live customer using the contact details.
+                $metadata = [
+                    'contact_id'    => $customer->public_id,
+                    'storefront_id' => $store->public_id,
+                    'company_id'    => $store->company_uuid,
+                ];
+
+                $params = [
+                    'description' => 'Customer migrated from sandbox',
+                    'email'       => $customer->email,
+                    'name'        => $customer->name,
+                    'phone'       => $customer->phone,
+                    'metadata'    => $metadata,
+                ];
+
+                $newCustomer = StripeCustomer::create($params);
+
+                // Save the old test ID and update the live ID.
+                $customer->updateMeta('stripe_id_sandbox', $stripeId);
+                $customer->updateMeta('stripe_id', $newCustomer->id);
+
+                $this->info("Customer {$customer->id}: Migrated test ID {$stripeId} to live Stripe ID {$newCustomer->id}.");
+            }
+        });
+
+        return Command::SUCCESS;
+    }
+
+    private function startSession()
+    {
+        if (!App::bound('request')) {
+            App::instance('request', Request::create('/'));
+        }
+        if (!Session::isStarted()) {
+            Session::start();
+            request()->setLaravelSession(Session::getFacadeRoot());
+        }
+    }
+}

package/server/src/Expansions/OrderExpansion.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Fleetbase\Storefront\Expansions;
+
+use Fleetbase\Build\Expansion;
+use Fleetbase\FleetOps\Models\Order;
+use Fleetbase\Storefront\Models\Network;
+use Fleetbase\Storefront\Models\Store;
+
+class OrderExpansion implements Expansion
+{
+    /**
+     * Get the target class to expand.
+     *
+     * @return string|Class
+     */
+    public static function target()
+    {
+        return Order::class;
+    }
+
+    /**
+     * Get the current storefront for the order created.
+     */
+    public static function getStorefrontAttribute(): \Closure
+    {
+        return function (): Store|Network|null {
+            /** @var Order $this */
+            $storefrontId        = $this->getMeta('storefront_id');
+            $storefrontNetworkId = $this->getMeta('storefront_network_id');
+
+            if ($storefrontId) {
+                return Store::where('public_id', $storefrontId)->first();
+            }
+
+            if ($storefrontNetworkId) {
+                return Network::where('public_id', $storefrontNetworkId)->first();
+            }
+
+            return null;
+        };
+    }
+}

package/server/src/Http/Controllers/NetworkController.php

@@ -121,7 +121,7 @@ class NetworkController extends StorefrontController
     }
 
     /**
-     * Add a store to a network category
+     * Add a store to a network category.
      *
      * @return \Illuminate\Http\Response
      */