Vmeda.Online/src/core/services/analytics.ts

219 lines
7.0 KiB
TypeScript
Raw Normal View History

// (C) Copyright 2015 Moodle Pty Ltd.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import { Injectable } from '@angular/core';
import { CoreDelegate, CoreDelegateHandler } from '@classes/delegate';
import { CorePushNotificationsNotificationBasicData } from '@features/pushnotifications/services/pushnotifications';
import { makeSingleton } from '@singletons';
import { CoreEvents } from '@singletons/events';
import { CoreSites } from './sites';
import { CoreConfig, CoreConfigProvider } from './config';
import { CoreConstants } from '../constants';
import { CoreUrlUtils } from './utils/url';
import { CoreTextUtils } from '@services/utils/text';
/**
* Helper service to support analytics.
*/
@Injectable({ providedIn: 'root' })
export class CoreAnalyticsService extends CoreDelegate<CoreAnalyticsHandler> {
constructor() {
super('CoreAnalyticsService', true);
CoreEvents.on(CoreConfigProvider.ENVIRONMENT_UPDATED, () => this.updateHandlers());
CoreEvents.on(CoreEvents.LOGOUT, () => this.clearSiteHandlers());
}
/**
* Clear current site handlers. Reserved for core use.
*/
protected clearSiteHandlers(): void {
this.enabledHandlers = {};
}
/**
* Enable or disable analytics for all handlers.
*
* @param enable Whether to enable or disable.
* @returns Promise resolved when done.
*/
async enableAnalytics(enable: boolean): Promise<void> {
try {
await Promise.all(Object.values(this.handlers).map(handler => handler.enableAnalytics?.(enable)));
} catch (error) {
this.logger.error(`Error ${enable ? 'enabling' : 'disabling'} analytics`, error);
}
}
/**
* Check if analytics is available for the app/site.
*
* @returns True if available, false otherwise.
*/
async isAnalyticsAvailable(): Promise<boolean> {
if (Object.keys(this.enabledHandlers).length > 0) {
// There is an enabled handler, analytics is available.
return true;
}
// Check if there is a handler that is enabled at app level (enabled handlers are only set when logged in).
const enabledList = await Promise.all(Object.values(this.handlers).map(handler => {
if (!handler.appLevelEnabled) {
return false;
}
return handler.isEnabled();
}));
return enabledList.includes(true);
}
/**
* Log an event for the current site.
*
* @param event Event data.
*/
async logEvent(event: CoreAnalyticsAnyEvent): Promise<void> {
const site = CoreSites.getCurrentSite();
if (!site) {
return;
}
// Check if analytics is enabled by the user.
const enabled = await CoreConfig.get<boolean>(CoreConstants.SETTINGS_ANALYTICS_ENABLED, true);
if (!enabled) {
return;
}
const treatedEvent: CoreAnalyticsEvent = {
...event,
siteId: site.getId(),
};
if (treatedEvent.type === CoreAnalyticsEventType.VIEW_ITEM || treatedEvent.type === CoreAnalyticsEventType.VIEW_ITEM_LIST) {
treatedEvent.name = CoreTextUtils.cleanTags(treatedEvent.name);
}
if ('url' in treatedEvent && treatedEvent.url) {
if (!CoreUrlUtils.isAbsoluteURL(treatedEvent.url)) {
treatedEvent.url = site.createSiteUrl(treatedEvent.url);
} else if (!site.containsUrl(treatedEvent.url)) {
// URL belongs to a different site, ignore the event.
return;
}
}
try {
await Promise.all(Object.values(this.enabledHandlers).map(handler => handler.logEvent(treatedEvent)));
} catch (error) {
this.logger.error('Error logging event', event, error);
}
}
}
export const CoreAnalytics = makeSingleton(CoreAnalyticsService);
/**
* Interface that all analytics handlers must implement.
*/
export interface CoreAnalyticsHandler extends CoreDelegateHandler {
/**
* If true it means that the handler is enabled or not for the whole app, it doesn't depend on the site.
*/
appLevelEnabled?: boolean;
/**
* Log an event.
*
* @param event Event data.
*/
logEvent(event: CoreAnalyticsEvent): Promise<void>;
/**
* Enable or disable analytics.
*
* @param enable Whether to enable or disable.
* @returns Promise resolved when done.
*/
enableAnalytics?(enable: boolean): Promise<void>;
}
/**
* Possible types of events.
*/
export enum CoreAnalyticsEventType {
VIEW_ITEM = 'view_item', // View some page or data that mainly contains one item.
VIEW_ITEM_LIST = 'view_item_list', // View some page or data that mainly contains a list of items.
PUSH_NOTIFICATION = 'push_notification', // Event related to push notifications.
DOWNLOAD_FILE = 'download_file', // A file was downloaded.
OPEN_LINK = 'open_link', // A link was opened in browser or InAppBrowser.
}
/**
* Any type of event data.
*/
export type CoreAnalyticsAnyEvent = CoreAnalyticsViewEvent | CoreAnalyticsPushEvent | CoreAnalyticsDownloadFileEvent |
CoreAnalyticsOpenLinkEvent;
/**
* Event data, including calculated data.
*/
export type CoreAnalyticsEvent = CoreAnalyticsAnyEvent & {
siteId: string;
};
/**
* Data specific for the VIEW_ITEM and VIEW_LIST events.
*/
export type CoreAnalyticsViewEvent = {
type: CoreAnalyticsEventType.VIEW_ITEM | CoreAnalyticsEventType.VIEW_ITEM_LIST;
ws: string; // Name of the WS used to log the data in LMS or to obtain the data if there is no log WS.
name: string; // Name of the item or page viewed.
url?: string; // Moodle URL. You can use the URL without the domain, e.g. /mod/foo/view.php.
data?: {
id?: number | string; // ID of the item viewed (if any).
category?: string; // Category of the data viewed (if any).
[key: string]: string | number | boolean | undefined;
};
};
/**
* Data specific for the PUSH_NOTIFICATION events.
*/
export type CoreAnalyticsPushEvent = {
type: CoreAnalyticsEventType.PUSH_NOTIFICATION;
eventName: string; // Name of the event.
data: CorePushNotificationsNotificationBasicData;
};
/**
* Data specific for the DOWNLOAD_FILE events.
*/
export type CoreAnalyticsDownloadFileEvent = {
type: CoreAnalyticsEventType.DOWNLOAD_FILE;
fileUrl: string;
};
/**
* Data specific for the OPEN_LINK events.
*/
export type CoreAnalyticsOpenLinkEvent = {
type: CoreAnalyticsEventType.OPEN_LINK;
link: string;
};