@fleetbase/ember-core 0.3.11 → 0.3.13

package/addon/contracts/menu-item.js

@@ -35,6 +35,16 @@ import isObject from '../utils/is-object';
  *   .onClick((menuItem, router) => {
  *     router.transitionTo('virtual', menuItem.slug);
  *   })
+ *
+ * @example
+ * // Menu item with description and shortcuts (Phase 2)
+ * new MenuItem('Fleet-Ops', 'console.fleet-ops')
+ *   .withIcon('route')
+ *   .withDescription('Manage fleets, drivers, and live orders')
+ *   .withShortcuts([
+ *     { title: 'Scheduler', route: 'console.fleet-ops.scheduler', icon: 'calendar' },
+ *     { title: 'Order Config', route: 'console.fleet-ops.order-configs', icon: 'gear' },
+ *   ])
  */
 export default class MenuItem extends BaseContract {
     /**
@@ -102,6 +112,17 @@ export default class MenuItem extends BaseContract {
 
             // Nested items
             this.items = definition.items || null;
+
+            // ── Phase 2 additions ──────────────────────────────────────────
+            // A short human-readable description of the extension shown in the
+            // overflow dropdown.  Optional – defaults to null.
+            this.description = definition.description || null;
+
+            // An array of shortcut items (sub-menu links) displayed beneath the
+            // extension name in the multi-column dropdown.  Each shortcut is a
+            // plain object with at minimum { title, route } and optionally
+            // { icon, iconPrefix, id }.  Optional – defaults to null.
+            this.shortcuts = definition.shortcuts || null;
         } else {
             // Handle string title with optional route (chaining pattern)
             this.title = titleOrDefinition;
@@ -153,6 +174,10 @@ export default class MenuItem extends BaseContract {
 
             // Nested items
             this.items = null;
+
+            // ── Phase 2 additions ──────────────────────────────────────────
+            this.description = null;
+            this.shortcuts = null;
         }
 
         // Call setup() to trigger validation after properties are set
@@ -342,6 +367,75 @@ export default class MenuItem extends BaseContract {
         return this;
     }
 
+    // ── Phase 2 builder methods ────────────────────────────────────────────
+
+    /**
+     * Set a short human-readable description for the extension.
+     * Displayed beneath the extension title in the overflow dropdown.
+     *
+     * @method withDescription
+     * @param {String} description Short description text
+     * @returns {MenuItem} This instance for chaining
+     *
+     * @example
+     * new MenuItem('Fleet-Ops', 'console.fleet-ops')
+     *   .withDescription('Manage fleets, drivers, and live orders')
+     */
+    withDescription(description) {
+        this.description = description;
+        this._options.description = description;
+        return this;
+    }
+
+    /**
+     * Set an array of shortcut items displayed beneath the extension in the
+     * multi-column overflow dropdown.  Each shortcut is a plain object:
+     *
+     *   { title, route, icon?, iconPrefix?, id? }
+     *
+     * Shortcuts are purely navigational – they do not support onClick handlers.
+     * They are rendered as compact links inside the extension card in the
+     * dropdown and can be individually pinned to the navigation bar.
+     *
+     * @method withShortcuts
+     * @param {Array<Object>} shortcuts Array of shortcut definition objects
+     * @returns {MenuItem} This instance for chaining
+     *
+     * @example
+     * new MenuItem('Fleet-Ops', 'console.fleet-ops')
+     *   .withShortcuts([
+     *     { title: 'Scheduler', route: 'console.fleet-ops.scheduler', icon: 'calendar' },
+     *     { title: 'Order Config', route: 'console.fleet-ops.order-configs', icon: 'gear' },
+     *   ])
+     */
+    withShortcuts(shortcuts) {
+        this.shortcuts = Array.isArray(shortcuts) ? shortcuts : null;
+        this._options.shortcuts = this.shortcuts;
+        return this;
+    }
+
+    /**
+     * Add a single shortcut to the existing shortcuts array.
+     * Creates the array if it does not yet exist.
+     *
+     * @method addShortcut
+     * @param {Object} shortcut Shortcut definition object { title, route, icon?, iconPrefix?, id? }
+     * @returns {MenuItem} This instance for chaining
+     *
+     * @example
+     * new MenuItem('Fleet-Ops', 'console.fleet-ops')
+     *   .addShortcut({ title: 'Scheduler', route: 'console.fleet-ops.scheduler' })
+     *   .addShortcut({ title: 'Order Config', route: 'console.fleet-ops.order-configs' })
+     */
+    addShortcut(shortcut) {
+        if (!Array.isArray(this.shortcuts)) {
+            this.shortcuts = [];
+        }
+        this.shortcuts = [...this.shortcuts, shortcut];
+        this._options.shortcuts = this.shortcuts;
+        return this;
+    }
+
     /**
      * Get the plain object representation
      *
@@ -401,6 +495,13 @@ export default class MenuItem extends BaseContract {
             // Nested items
             items: this.items,
 
+            // ── Phase 2 additions ──────────────────────────────────────────
+            // Optional short description shown in the overflow dropdown card
+            description: this.description,
+
+            // Optional array of shortcut sub-links shown inside the extension card
+            shortcuts: this.shortcuts,
+
             // Indicator flag
             _isMenuItem: true,
 

package/addon/services/current-user.js

@@ -8,6 +8,7 @@ import { isBlank } from '@ember/utils';
 import { alias } from '@ember/object/computed';
 import { storageFor } from 'ember-local-storage';
 import { debug } from '@ember/debug';
+import lookupUserIp from '../utils/lookup-user-ip';
 
 export default class CurrentUserService extends Service.extend(Evented) {
     @service session;
@@ -139,23 +140,34 @@ export default class CurrentUserService extends Service.extend(Evented) {
     }
 
     async loadWhois() {
-        this.fetch.shouldResetCache();
-
         try {
-            const whois = await this.fetch.cachedGet(
-                'lookup/whois',
-                {},
-                {
-                    expirationInterval: 60,
-                    expirationIntervalUnit: 'minutes',
-                }
-            );
+            // Use frontend IP lookup to get accurate user location
+            // This avoids the issue of server-side lookup returning server IP instead of user IP
+            const whois = await lookupUserIp({
+                timeout: 5000,
+                cache: true,
+            });
+
             this.setOption('whois', whois);
             this.whoisData = whois;
 
             return whois;
         } catch (error) {
-            this.notifications.serverError(error);
+            console.error('[currentUser] Failed to load whois:', error);
+            this.notifications.warning('Unable to detect your location. Some features may use default settings.');
+
+            // Return fallback data with browser timezone
+            const fallback = {
+                city: null,
+                country_code: null,
+                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+                _source: 'fallback',
+            };
+
+            this.setOption('whois', fallback);
+            this.whoisData = fallback;
+
+            return fallback;
         }
     }
 

package/addon/services/universe.js

@@ -33,7 +33,6 @@ export default class UniverseService extends Service.extend(Evented) {
     @service router;
     @service intl;
     @service urlSearchParams;
-
     @tracked applicationInstance;
     @tracked initialLocation = { ...window.location };
     @tracked bootCallbacks = A([]);

package/addon/utils/lookup-user-ip.js

@@ -0,0 +1,221 @@
+/**
+ * Lookup user's IP address and geolocation information using geoiplookup.io
+ *
+ * This method calls the geoiplookup.io API directly from the browser to get
+ * accurate user location data, avoiding the issue of server-side IP lookup
+ * returning the server's location instead of the user's location.
+ *
+ * @param {Object} options - Configuration options
+ * @param {number} options.timeout - Request timeout in milliseconds (default: 5000)
+ * @param {boolean} options.cache - Whether to cache the result (default: true)
+ * @returns {Promise<Object>} User's IP and geolocation data
+ *
+ * @example
+ * const whois = await lookupUserIp();
+ * console.log(whois.city); // "New York"
+ * console.log(whois.country_code); // "US"
+ */
+export default async function lookupUserIp(options = {}) {
+    const { timeout = 5000, cache = true } = options;
+
+    // Check cache first if enabled
+    if (cache) {
+        const cached = getCachedWhois();
+        if (cached) {
+            return cached;
+        }
+    }
+
+    // Try multiple APIs with fallback
+    const apis = [
+        {
+            url: 'https://json.geoiplookup.io/',
+            normalize: normalizeGeoIPLookup,
+        },
+        {
+            url: 'https://ipapi.co/json/',
+            normalize: normalizeIPApi,
+        },
+    ];
+
+    for (const api of apis) {
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+            const response = await fetch(api.url, {
+                signal: controller.signal,
+                headers: {
+                    Accept: 'application/json',
+                },
+            });
+
+            clearTimeout(timeoutId);
+
+            if (!response.ok) {
+                console.warn(`[lookupUserIp] ${api.url} returned ${response.status}`);
+                continue;
+            }
+
+            const data = await response.json();
+            const normalized = api.normalize(data);
+
+            // Cache the result if enabled
+            if (cache) {
+                cacheWhois(normalized);
+            }
+
+            return normalized;
+        } catch (error) {
+            console.warn(`[lookupUserIp] ${api.url} failed:`, error.message);
+            // Continue to next API
+        }
+    }
+
+    // All APIs failed, return fallback
+    console.error('[lookupUserIp] All IP lookup APIs failed, using fallback data');
+    return getFallbackWhois();
+}
+
+/**
+ * Normalize geoiplookup.io response to match Fleetbase whois format
+ */
+function normalizeGeoIPLookup(data) {
+    return {
+        ip: data.ip,
+        city: data.city,
+        region: data.region,
+        country_code: data.country_code,
+        country_name: data.country_name,
+        continent_code: data.continent_code,
+        continent_name: data.continent_name,
+        latitude: data.latitude,
+        longitude: data.longitude,
+        postal_code: data.postal_code,
+        timezone: data.timezone_name,
+        currency: {
+            code: data.currency_code,
+            name: data.currency_name,
+        },
+        languages: [
+            {
+                code: data.language_code,
+                name: data.language_name,
+            },
+        ],
+        isp: data.isp,
+        org: data.org,
+        asn: data.asn,
+        connection_type: data.connection_type,
+        // Metadata
+        _source: 'geoiplookup.io',
+        _timestamp: Date.now(),
+    };
+}
+
+/**
+ * Normalize ipapi.co response to match Fleetbase whois format
+ */
+function normalizeIPApi(data) {
+    return {
+        ip: data.ip,
+        city: data.city,
+        region: data.region,
+        country_code: data.country_code,
+        country_name: data.country_name,
+        continent_code: data.continent_code,
+        continent_name: null,
+        latitude: data.latitude,
+        longitude: data.longitude,
+        postal_code: data.postal,
+        timezone: data.timezone,
+        currency: {
+            code: data.currency,
+            name: data.currency_name,
+        },
+        languages: data.languages ? data.languages.split(',').map((lang) => ({ code: lang.trim(), name: lang.trim() })) : [],
+        isp: data.org,
+        org: data.org,
+        asn: data.asn,
+        connection_type: null,
+        // Metadata
+        _source: 'ipapi.co',
+        _timestamp: Date.now(),
+    };
+}
+
+/**
+ * Get cached whois data from localStorage
+ */
+function getCachedWhois() {
+    try {
+        const cached = localStorage.getItem('fleetbase:whois');
+        if (!cached) {
+            return null;
+        }
+
+        const data = JSON.parse(cached);
+        const age = Date.now() - data._timestamp;
+        const maxAge = 60 * 60 * 1000; // 1 hour
+
+        if (age > maxAge) {
+            localStorage.removeItem('fleetbase:whois');
+            return null;
+        }
+
+        return data;
+    } catch (error) {
+        console.error('[getCachedWhois] Error reading cache:', error);
+        return null;
+    }
+}
+
+/**
+ * Cache whois data to localStorage
+ */
+function cacheWhois(data) {
+    try {
+        localStorage.setItem('fleetbase:whois', JSON.stringify(data));
+    } catch (error) {
+        console.error('[cacheWhois] Error writing cache:', error);
+    }
+}
+
+/**
+ * Get fallback whois data when all APIs fail
+ */
+function getFallbackWhois() {
+    // Try to get browser language and timezone as fallback
+    const browserLang = navigator.language || 'en-US';
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+    return {
+        ip: null,
+        city: null,
+        region: null,
+        country_code: null,
+        country_name: null,
+        continent_code: null,
+        continent_name: null,
+        latitude: null,
+        longitude: null,
+        postal_code: null,
+        timezone: timezone,
+        currency: {
+            code: null,
+            name: null,
+        },
+        languages: [
+            {
+                code: browserLang.split('-')[0],
+                name: browserLang,
+            },
+        ],
+        isp: null,
+        org: null,
+        asn: null,
+        connection_type: null,
+        _source: 'fallback',
+        _timestamp: Date.now(),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fleetbase/ember-core",
-    "version": "0.3.11",
+    "version": "0.3.13",
     "description": "Provides all the core services, decorators and utilities for building a Fleetbase extension for the Console.",
     "keywords": [
         "fleetbase-core",