src documentation
  1. Injectables
  2. TelemetryService

File

src/app/modules/telemetry/services/telemetry/telemetry.service.ts

Description

Service for telemetry v3 event methods

Constructor

constructor()

Methods

Public initialize
initialize(context: ITelemetryContext)

Initializes the service

Parameters :
  • context : ITelemetryContext
Returns: void
getDeviceId
getDeviceId(callback: any)
Returns: void
Public syncEvents
syncEvents(async: Boolean)

Telemetry data sync method

Returns: void
Public start
start(startEventInput: IStartEventInput)
Parameters :
  • startEventInput : IStartEventInput
Returns: void
Public impression
impression(impressionEventInput: IImpressionEventInput)

service method to trigger impression event telemetry

Parameters :
  • impressionEventInput : IImpressionEventInput
Returns: void
Public interact
interact(interactEventInput: IInteractEventInput)

Logs 'interact' telemetry event

Parameters :
  • interactEventInput : IInteractEventInput
Returns: void
Public share
share(shareEventInput: IShareEventInput)

Logs 'share' telemetry event

Parameters :
  • shareEventInput : IShareEventInput
Returns: void
Public error
error(errorEventInput: IErrorEventInput)

Logs 'error' telemetry event

Parameters :
  • errorEventInput : IErrorEventInput
Returns: void
Public generateErrorEvent
generateErrorEvent(data: any)
Returns: void
Public end
end(endEventInput: IEndEventInput)

Logs 'end' telemetry event

Parameters :
  • endEventInput : IEndEventInput
Returns: void
Public log
log(logEventInput: ILogEventInput)

Logs 'log' telemetry event

Parameters :
  • logEventInput : ILogEventInput
Returns: void
Public exData
exData(exDataEventInput: IExDataEventInput)

Logs 'exdata' telemetry event

Parameters :
  • exDataEventInput : IExDataEventInput
Returns: void
Public feedback
feedback(feedbackEventInput: IFeedBackEventInput)

Feedback 'feedback' telemetry event

Parameters :
  • IFeedBackEventInput : IFeedBackEventInput
Returns: void
Private getEventData
getEventData(eventInput: any)
Parameters :
  • eventInput
Returns: void

*

Private getEventObject
getEventObject(eventInput: any)
Parameters :
  • eventInput
Returns: void

*

Private getEventContext
getEventContext(eventInput: any)
Parameters :
  • eventInput
Returns: void

*

Public getRollUpData
getRollUpData(data: string[])
Parameters :
  • data : Array

    *

Returns: void

*

Public getUserAgent
getUserAgent()

returns client machine details

Returns: void

*

Properties

Private context
context: ITelemetryContext
Private isInitialized
isInitialized: Boolean
Default value: false
sessionId
sessionId: any

Creates an instance of TelemetryService.
Private telemetryProvider
telemetryProvider: any 
import { Injectable, Inject, InjectionToken } from '@angular/core';
import * as _ from 'lodash-es';
import {
  ITelemetryEvent, ITelemetryContextData, TelemetryObject,
  IStartEventInput, IImpressionEventInput, IExDataEventInput,
  IInteractEventInput, IShareEventInput, IErrorEventInput, IEndEventInput, ILogEventInput, ITelemetryContext, IFeedBackEventInput
} from './../../interfaces/telemetry';
import { environment } from '@sunbird/environment';
declare const EkTelemetry;

export const TELEMETRY_PROVIDER = new InjectionToken('telemetryProvider');
/**
* Service for telemetry v3 event methods
*/

@Injectable()
export class TelemetryService {

  /**
   *
   *
   * @private
   * @type {ITelemetryContext}
   * @memberof TelemetryService
   */
  private context: ITelemetryContext;

  /**
   *
   *
   * @private
   * @type {*}
   * @memberof TelemetryService
   */
  private telemetryProvider: any;

  /**
   *
   *
   * @private
   * @type {Boolean}
   * @memberof TelemetryService
   */
  private isInitialized: Boolean = false;

  /**
   * Creates an instance of TelemetryService.
   * @param {*} telemetryProvider
   * @memberof TelemetryService
   */

  sessionId;

  constructor() {
    // , { provide: TELEMETRY_PROVIDER, useValue: EkTelemetry }
    this.telemetryProvider = EkTelemetry;
    this.sessionId = (<HTMLInputElement>document.getElementById('sessionId'))
    ? (<HTMLInputElement>document.getElementById('sessionId')).value : undefined;
  }

  /**
   *
   * Initializes the service
   * @param {ITelemetryContext} context
   * @memberof TelemetryService
   */
  public initialize(context: ITelemetryContext) {
    if (environment.isOffline && !(_.isEmpty(this.sessionId))) {
      context.config.sid = this.sessionId;
    }
    this.context = _.cloneDeep(context);
    this.telemetryProvider.initialize(this.context.config);
    this.isInitialized = true;
  }
  getDeviceId(callback) {
    EkTelemetry.getFingerPrint(callback);
  }
  /**
   *
   * Telemetry data sync method
   * @memberof TelemetryService
   */
  public syncEvents(async: Boolean = true) {
    this.telemetryProvider.syncEvents(async);
    console.log('Telemetry data is Synced!');
  }

  /**
   *
   *
   * @param {IStartEventInput} startEventInput
   * @memberof TelemetryService
   */
  public start(startEventInput: IStartEventInput) {
    if (this.isInitialized) {
      const eventData: ITelemetryEvent = this.getEventData(startEventInput);
      this.telemetryProvider.start(this.context.config, eventData.options.object.id, eventData.options.object.ver,
        eventData.edata, eventData.options);
    }
  }

  /**
   *
   * service method to trigger impression event telemetry
   * @param {IImpressionEventInput} impressionEventInput
   * @memberof TelemetryService
   */
  public impression(impressionEventInput: IImpressionEventInput) {
    if (this.isInitialized) {
      const eventData: ITelemetryEvent = this.getEventData(impressionEventInput);
      this.telemetryProvider.impression(eventData.edata, eventData.options);
    }
  }
  /**
   *
   * Logs 'interact' telemetry event
   * @param {IInteractEventInput} interactEventInput
   * @memberof TelemetryService
   */
  public interact(interactEventInput: IInteractEventInput) {
    if (this.isInitialized) {
      const eventData: ITelemetryEvent = this.getEventData(interactEventInput);
      this.telemetryProvider.interact(eventData.edata, eventData.options);
    }
  }

  /**
   * Logs 'share' telemetry event
   *
   * @param {IShareEventInput} shareEventInput
   * @memberof TelemetryService
   */
  public share(shareEventInput: IShareEventInput) {
    if (this.isInitialized) {
      const eventData: ITelemetryEvent = this.getEventData(shareEventInput);
      this.telemetryProvider.share(eventData.edata, eventData.options);
    }
  }
  /**
   * Logs 'error' telemetry event
   *
   * @param {IErrorEventInput} errorEventInput
   * @memberof TelemetryService
   */
  public error(errorEventInput: IErrorEventInput) {
    if (this.isInitialized) {
      const eventData: ITelemetryEvent = this.getEventData(errorEventInput);
      this.telemetryProvider.error(eventData.edata, eventData.options);
    }
  }

  public generateErrorEvent(data) {
    const telemetryErrorData = {
      context: {env: data.env},
      edata: {
        err: data.errorMessage,
        errtype: data.errorType,
        stacktrace: data.stackTrace,
        pageid: data.pageid
      }
    };
    this.error(telemetryErrorData);
  }

  /**
   * Logs 'end' telemetry event
   *
   * @param {IEndEventInput} endEventInput
   * @memberof TelemetryService
   */
  public end(endEventInput: IEndEventInput) {
    if (this.isInitialized) {
      const eventData: ITelemetryEvent = this.getEventData(endEventInput);
      this.telemetryProvider.end(eventData.edata, eventData.options);
    }
  }

  /**
   * Logs 'log' telemetry event
   *
   * @param {ILogEventInput} logEventInput
   * @memberof TelemetryService
   */
  public log(logEventInput: ILogEventInput) {
    if (this.isInitialized) {
      const eventData: ITelemetryEvent = this.getEventData(logEventInput);
      this.telemetryProvider.log(eventData.edata, eventData.options);
    }
  }

  /**
   * Logs 'exdata' telemetry event
   *
   * @param {IExDataEventInput} exDataEventInput
   * @memberof TelemetryService
   */
  public exData(exDataEventInput: IExDataEventInput) {
    if (this.isInitialized) {
      const eventData: ITelemetryEvent = this.getEventData(exDataEventInput);
      this.telemetryProvider.exdata(eventData.edata, eventData.options);
    }
  }

  /**
   * Feedback 'feedback' telemetry event
   *
   * @param {IFeedBackEventInput} IFeedBackEventInput
   * @memberof TelemetryService
   */
  public feedback(feedbackEventInput: IFeedBackEventInput) {
    if (this.isInitialized) {
      const eventData: ITelemetryEvent = this.getEventData(feedbackEventInput);
      this.telemetryProvider.feedback(eventData.edata, eventData.options);
    }
  }

  /**
   *
   *
   * @private
   * @param {*} eventInput
   * @returns
   * @memberof TelemetryService
   */
  private getEventData(eventInput: any) {
    const event: ITelemetryEvent = {
      edata: eventInput.edata,
      options: {
        context: this.getEventContext(eventInput),
        object: this.getEventObject(eventInput),
        tags: _.compact(this.context.userOrgDetails.organisationIds)
      }
    };
    return event;
  }

  /**
   *
   *
   * @private
   * @param {*} eventInput
   * @returns
   * @memberof TelemetryService
   */
  private getEventObject(eventInput: any) {
    if (eventInput.object) {
      const eventObjectData: TelemetryObject = {
        id: eventInput.object.id || '',
        type: eventInput.object.type || '',
        ver: eventInput.object.ver || '',
        rollup: eventInput.object.rollup || {}
      };
      return eventObjectData;
    } else { // telemetry.min.js will take last sent object is not sent.
      return {};
    }
  }

  /**
   *
   *
   * @private
   * @param {*} eventInput
   * @returns
   * @memberof TelemetryService
   */
  private getEventContext(eventInput: any) {
    const eventContextData: ITelemetryContextData = {
      channel: eventInput.edata.channel || eventInput.context.channel || this.context.config.channel,
      pdata: eventInput.context.pdata || this.context.config.pdata,
      env: eventInput.context.env || this.context.config.env,
      sid: eventInput.sid || this.context.config.sid,
      uid: this.context.config.uid,
      cdata: eventInput.context.cdata || [],
      rollup: this.getRollUpData(this.context.userOrgDetails.organisationIds)
    };
    if (eventInput.did) {
      eventContextData['did'] = eventInput.did;
    }
    return eventContextData;
  }

  /**
   *
   *
   * @private
   * @param {Array<string>} [data=[]]
   * @returns
   * @memberof TelemetryService
   */
  public getRollUpData(data: Array<string> = []) {
    const rollUp = {};
    data.forEach((element, index) => rollUp['l' + (index + 1)] = element);
    return rollUp;
  }
  /**
   * returns client machine details
   *
   * @returns
   * @memberof TelemetryService
   */
  public getUserAgent() {
    return {
      agent: window.navigator.appCodeName,
      ver: window.navigator.appVersion.split(' (')[0],
      system: '',
      platform: window.navigator.platform,
      raw: window.navigator.userAgent
    };
  }
}

results matching ""

    No results matching ""