@fleetbase/ember-core 0.3.11 → 0.3.12

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.12",
     "description": "Provides all the core services, decorators and utilities for building a Fleetbase extension for the Console.",
     "keywords": [
         "fleetbase-core",