@fleetbase/ember-core 0.3.10 → 0.3.12

package/addon/exports/host-services.js

@@ -19,6 +19,7 @@ export const hostServices = [
     'sidebar',
     'dashboard',
     'universe',
+    'events',
     'intl',
     'abilities',
     'language',

package/addon/exports/services.js

@@ -21,6 +21,7 @@ export const services = [
     'sidebar',
     'dashboard',
     'universe',
+    'events',
     'intl',
     'abilities',
     'language',

package/addon/services/app-cache.js

@@ -13,7 +13,8 @@ export default class AppCacheService extends Service {
 
     get cachePrefix() {
         const userId = this.currentUser.id ?? 'anon';
-        return `${userId}:${this.currentUser.companyId}:`;
+        const companyId = this.currentUser.companyId ?? 'no-org';
+        return `${userId}:${companyId}:`;
     }
 
     @action setEmberData(key, value, except = []) {

package/addon/services/crud.js

@@ -17,6 +17,8 @@ export default class CrudService extends Service {
     @service notifications;
     @service store;
     @service currentUser;
+    @service universe;
+    @service events;
 
     /**
      * Generic deletion modal with options
@@ -43,6 +45,10 @@ export default class CrudService extends Service {
                 try {
                     const response = await model.destroyRecord();
                     this.notifications.success(successNotification);
+
+                    // Track deletion event
+                    this.events.trackResourceDeleted(model);
+
                     if (typeof options.onSuccess === 'function') {
                         options.onSuccess(model);
                     }
@@ -161,6 +167,10 @@ export default class CrudService extends Service {
                     );
 
                     this.notifications.success(response.message ?? successMessage);
+
+                    // Track bulk action event
+                    this.events.trackBulkAction(verb, selected);
+
                     if (typeof options.onSuccess === 'function') {
                         options.onSuccess(selected);
                     }
@@ -224,6 +234,9 @@ export default class CrudService extends Service {
                         }
                     )
                     .then(() => {
+                        // Track export event
+                        this.events.trackResourceExported(modelName, format, exportParams);
+
                         later(
                             this,
                             () => {
@@ -248,6 +261,7 @@ export default class CrudService extends Service {
      * @param {Object} [options={}]
      * @memberof CrudService
      */
+
     @action import(modelName, options = {}) {
         // always lowercase modelname
         modelName = modelName.toLowerCase();
@@ -337,6 +351,11 @@ export default class CrudService extends Service {
 
                 try {
                     const response = await this.fetch.post(importEndpoint, { files }, fetchOptions);
+
+                    // Track import event
+                    const importCount = response?.imported?.length || response?.count || files.length;
+                    this.events.trackResourceImported(modelName, importCount);
+
                     if (typeof options.onImportCompleted === 'function') {
                         options.onImportCompleted(response, files);
                     }

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;
@@ -16,6 +17,7 @@ export default class CurrentUserService extends Service.extend(Evented) {
     @service theme;
     @service notifications;
     @service intl;
+    @service events;
 
     @tracked user = { id: 'anon' };
     @tracked userSnapshot = { id: 'anon' };
@@ -65,14 +67,9 @@ export default class CurrentUserService extends Service.extend(Evented) {
     async load() {
         if (this.session.isAuthenticated) {
             const user = await this.store.findRecord('user', 'me');
-            const snapshot = await this.getUserSnapshot(user);
 
-            this.set('user', user);
-            this.set('userSnapshot', snapshot);
-            this.trigger('user.loaded', user);
-
-            // Set permissions
-            this.permissions = this.getUserPermissions(user);
+            // set user
+            this.setUser(user);
 
             // Load preferences
             await this.loadPreferences();
@@ -91,25 +88,9 @@ export default class CurrentUserService extends Service.extend(Evented) {
 
         try {
             const user = await this.store.queryRecord('user', { me: true });
-            const snapshot = await this.getUserSnapshot(user);
-
-            // Set current user
-            this.set('user', user);
-            this.set('userSnapshot', snapshot);
-            this.trigger('user.loaded', user);
-
-            // Set permissions
-            this.permissions = this.getUserPermissions(user);
 
-            // Set environment from user option
-            this.theme.setEnvironment();
-
-            // Set locale
-            if (user.locale) {
-                this.setLocale(user.locale);
-            } else {
-                await this.loadLocale();
-            }
+            // set user
+            this.setUser(user);
 
             // Load user whois data
             await this.loadWhois();
@@ -159,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;
         }
     }
 
@@ -309,4 +301,26 @@ export default class CurrentUserService extends Service.extend(Evented) {
 
         return defaultValue;
     }
+
+    async setUser(user) {
+        const snapshot = await this.getUserSnapshot(user);
+
+        // Set current user
+        this.set('user', user);
+        this.set('userSnapshot', snapshot);
+        this.trigger('user.loaded', user);
+
+        // Set permissions
+        this.permissions = this.getUserPermissions(user);
+
+        // Set environment from user option
+        this.theme.setEnvironment();
+
+        // Set locale
+        if (user.locale) {
+            this.setLocale(user.locale);
+        } else {
+            await this.loadLocale();
+        }
+    }
 }

package/addon/services/events.js

@@ -0,0 +1,322 @@
+import Service, { inject as service } from '@ember/service';
+import Evented from '@ember/object/evented';
+import config from 'ember-get-config';
+
+/**
+ * Events Service
+ *
+ * Provides a centralized event tracking system for Fleetbase.
+ * This service emits standardized events on both its own event bus and the universe service,
+ * allowing components, services, and engines to subscribe and react to application events.
+ *
+ * @class EventsService
+ * @extends Service
+ */
+export default class EventsService extends Service.extend(Evented) {
+    @service universe;
+    @service currentUser;
+
+    /**
+     * Tracks the creation of a resource
+     *
+     * @param {Object} resource - The created resource/model
+     * @param {Object} [props={}] - Additional properties to include
+     */
+    trackResourceCreated(resource, props = {}) {
+        const events = this.#getResourceEvents(resource, 'created');
+        const properties = this.#enrichProperties({
+            ...this.#getSafeProperties(resource),
+            ...props,
+        });
+
+        events.forEach((eventName) => {
+            this.#trigger(eventName, resource, properties);
+        });
+    }
+
+    /**
+     * Tracks the update of a resource
+     *
+     * @param {Object} resource - The updated resource/model
+     * @param {Object} [props={}] - Additional properties to include
+     */
+    trackResourceUpdated(resource, props = {}) {
+        const events = this.#getResourceEvents(resource, 'updated');
+        const properties = this.#enrichProperties({
+            ...this.#getSafeProperties(resource),
+            ...props,
+        });
+
+        events.forEach((eventName) => {
+            this.#trigger(eventName, resource, properties);
+        });
+    }
+
+    /**
+     * Tracks the deletion of a resource
+     *
+     * @param {Object} resource - The deleted resource/model
+     * @param {Object} [props={}] - Additional properties to include
+     */
+    trackResourceDeleted(resource, props = {}) {
+        const events = this.#getResourceEvents(resource, 'deleted');
+        const properties = this.#enrichProperties({
+            ...this.#getSafeProperties(resource),
+            ...props,
+        });
+
+        events.forEach((eventName) => {
+            this.#trigger(eventName, resource, properties);
+        });
+    }
+
+    /**
+     * Tracks a bulk import of resources
+     *
+     * @param {String} modelName - The name of the model being imported
+     * @param {Number} count - Number of resources imported
+     * @param {Object} [props={}] - Additional properties to include
+     */
+    trackResourceImported(modelName, count, props = {}) {
+        const properties = this.#enrichProperties({
+            model_name: modelName,
+            count: count,
+            ...props,
+        });
+
+        this.#trigger('resource.imported', modelName, count, properties);
+    }
+
+    /**
+     * Tracks a resource export
+     *
+     * @param {String} modelName - The name of the model being exported
+     * @param {String} format - Export format (csv, xlsx, etc.)
+     * @param {Object} [params={}] - Export parameters/filters
+     * @param {Object} [props={}] - Additional properties to include
+     */
+    trackResourceExported(modelName, format, params = {}, props = {}) {
+        const properties = this.#enrichProperties({
+            model_name: modelName,
+            export_format: format,
+            has_filters: !!(params && Object.keys(params).length > 0),
+            ...props,
+        });
+
+        this.#trigger('resource.exported', modelName, format, params, properties);
+
+        // Also trigger model-specific export event
+        const specificEvent = `${modelName}.exported`;
+        this.#trigger(specificEvent, modelName, format, params, properties);
+    }
+
+    /**
+     * Tracks a bulk action on multiple resources
+     *
+     * @param {String} verb - The action verb (delete, archive, etc.)
+     * @param {Array} resources - Array of selected resources
+     * @param {Object} [props={}] - Additional properties to include
+     */
+    trackBulkAction(verb, resources, props = {}) {
+        const firstResource = resources && resources.length > 0 ? resources[0] : null;
+        const modelName = this.#getModelName(firstResource);
+
+        const properties = this.#enrichProperties({
+            action: verb,
+            count: resources?.length || 0,
+            model_name: modelName,
+            ...props,
+        });
+
+        this.#trigger('resource.bulk_action', verb, resources, firstResource, properties);
+    }
+
+    /**
+     * Tracks when the current user is loaded (session initialized)
+     *
+     * @param {Object} user - The user object
+     * @param {Object} organization - The organization object
+     * @param {Object} [props={}] - Additional properties to include
+     */
+    trackUserLoaded(user, organization, props = {}) {
+        const properties = this.#enrichProperties({
+            user_id: user?.id,
+            organization_id: organization?.id,
+            organization_name: organization?.name,
+            ...props,
+        });
+
+        this.#trigger('user.loaded', user, organization, properties);
+    }
+
+    /**
+     * Tracks when a user session is terminated
+     *
+     * @param {Number} duration - Session duration in seconds
+     * @param {Object} [props={}] - Additional properties to include
+     */
+    trackSessionTerminated(duration, props = {}) {
+        const properties = this.#enrichProperties({
+            session_duration: duration,
+            ...props,
+        });
+
+        this.#trigger('session.terminated', duration, properties);
+    }
+
+    /**
+     * Tracks a generic custom event
+     *
+     * @param {String} eventName - The event name (dot notation)
+     * @param {Object} [props={}] - Event properties
+     */
+    trackEvent(eventName, props = {}) {
+        const properties = this.#enrichProperties(props);
+        this.#trigger(eventName, properties);
+    }
+
+    /**
+     * Checks if event tracking is enabled
+     *
+     * @returns {Boolean}
+     */
+    isEnabled() {
+        const eventsConfig = config?.events || {};
+        return eventsConfig.enabled !== false; // Enabled by default
+    }
+
+    // =========================================================================
+    // Private Methods (using # syntax)
+    // =========================================================================
+
+    /**
+     * Triggers an event on both the events service and universe service
+     *
+     * This dual event system allows listeners to subscribe to events on either:
+     * - this.events.on('event.name', handler) - Local listeners
+     * - this.universe.on('event.name', handler) - Cross-engine listeners
+     *
+     * @private
+     * @param {String} eventName - The event name
+     * @param {...*} args - Arguments to pass to event listeners
+     */
+    #trigger(eventName, ...args) {
+        if (!this.isEnabled()) {
+            return;
+        }
+
+        // Debug logging if enabled
+        if (config?.events?.debug) {
+            console.log(`[Events] ${eventName}`, args);
+        }
+
+        // Trigger on events service (local listeners)
+        this.trigger(eventName, ...args);
+
+        // Trigger on universe service (cross-engine listeners)
+        if (this.universe) {
+            this.universe.trigger(eventName, ...args);
+        } else {
+            console.warn('[Events] Universe service not available');
+        }
+    }
+
+    /**
+     * Generates both generic and specific event names for a resource action
+     *
+     * @private
+     * @param {Object} resource - The resource/model
+     * @param {String} action - The action (created, updated, deleted)
+     * @returns {Array<String>} Array of event names
+     */
+    #getResourceEvents(resource, action) {
+        const modelName = this.#getModelName(resource);
+        return [`resource.${action}`, `${modelName}.${action}`];
+    }
+
+    /**
+     * Extracts safe, serializable properties from a resource
+     *
+     * @private
+     * @param {Object} resource - The resource/model
+     * @returns {Object} Safe properties object
+     */
+    #getSafeProperties(resource) {
+        if (!resource) {
+            return {};
+        }
+
+        const props = {
+            id: resource.id,
+            model_name: this.#getModelName(resource),
+        };
+
+        // Add common properties if available
+        const commonProps = ['name', 'status', 'type', 'slug', 'public_id'];
+        commonProps.forEach((prop) => {
+            if (resource[prop] !== undefined && resource[prop] !== null) {
+                props[prop] = resource[prop];
+            }
+        });
+
+        return props;
+    }
+
+    /**
+     * Enriches properties with user, organization, and timestamp context
+     *
+     * @private
+     * @param {Object} props - Base properties
+     * @returns {Object} Enriched properties
+     */
+    #enrichProperties(props = {}) {
+        const eventsConfig = config?.events || {};
+        const enrichConfig = eventsConfig.enrich || {};
+        const enriched = { ...props };
+
+        // Add user context if enabled
+        if (enrichConfig.user !== false && this.currentUser?.user) {
+            enriched.user_id = this.currentUser.user.id;
+        }
+
+        // Add organization context if enabled
+        if (enrichConfig.organization !== false && this.currentUser?.organization) {
+            enriched.organization_id = this.currentUser.organization.id;
+        }
+
+        // Add timestamp if enabled
+        if (enrichConfig.timestamp !== false) {
+            enriched.timestamp = new Date().toISOString();
+        }
+
+        return enriched;
+    }
+
+    /**
+     * Safely extracts the model name from a resource
+     *
+     * @private
+     * @param {Object} resource - The resource/model
+     * @returns {String} Model name or 'unknown'
+     */
+    #getModelName(resource) {
+        if (!resource) {
+            return 'unknown';
+        }
+
+        // Try multiple ways to get model name
+        if (resource.constructor?.modelName) {
+            return resource.constructor.modelName;
+        }
+
+        if (resource._internalModel?.modelName) {
+            return resource._internalModel.modelName;
+        }
+
+        if (resource.modelName) {
+            return resource.modelName;
+        }
+
+        return 'unknown';
+    }
+}

package/addon/services/resource-action.js

@@ -29,6 +29,8 @@ export default class ResourceActionService extends Service {
     @service abilities;
     @service tableContext;
     @service resourceContextPanel;
+    @service universe;
+    @service events;
 
     /**
      * Getter for router, attempt to use hostRouter if from engine
@@ -299,6 +301,9 @@ export default class ResourceActionService extends Service {
                 })
             );
 
+            // Track creation event
+            this.events.trackResourceCreated(record);
+
             if (options.refresh) {
                 this.refresh();
             }
@@ -329,6 +334,9 @@ export default class ResourceActionService extends Service {
                 })
             );
 
+            // Track update event
+            this.events.trackResourceUpdated(record);
+
             if (options.refresh) {
                 this.refresh();
             }
@@ -362,6 +370,13 @@ export default class ResourceActionService extends Service {
                 })
             );
 
+            // Track save event (create or update)
+            if (isNew) {
+                this.events.trackResourceCreated(record);
+            } else {
+                this.events.trackResourceUpdated(record);
+            }
+
             if (options.refresh) {
                 this.refresh();
             }
@@ -409,6 +424,9 @@ export default class ResourceActionService extends Service {
                 })
             );
 
+            // Track deletion event
+            this.events.trackResourceDeleted(record);
+
             if (options.refresh) {
                 this.refresh();
             }

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([]);