@botonic/plugin-hubtype-analytics 0.22.0-alpha.3 → 0.22.0-alpha.5

package/src/event-models/ht-event-bot-keyword-model.ts

@@ -0,0 +1,17 @@
+import {
+  BaseEventData,
+  EventBotKeywordModel,
+  EventDataBotKeywordModel,
+  RequestData,
+} from '../types'
+import { HtEvent } from './ht-event'
+
+export class HtEventBotKeywordModel extends HtEvent {
+  event_data: BaseEventData & EventDataBotKeywordModel
+
+  constructor(event: EventBotKeywordModel, requestData: RequestData) {
+    super(event, requestData)
+    this.event_data.confidence_successful =
+      event.event_data.confidence_successful
+  }
+}

package/src/event-models/ht-event-bot-rating.ts

@@ -0,0 +1,18 @@
+import {
+  BaseEventData,
+  EventBotRating,
+  EventDataBotRating,
+  RequestData,
+} from '../types'
+import { HtEvent } from './ht-event'
+
+export class HtEventBotRating extends HtEvent {
+  event_data: BaseEventData & EventDataBotRating
+
+  constructor(event: EventBotRating, requestData: RequestData) {
+    super(event, requestData)
+    this.event_data.rating = event.event_data.rating
+    this.event_data.free_comment = event.event_data.free_comment
+    this.event_data.selected_options = event.event_data.selected_options
+  }
+}

package/src/event-models/ht-event-channel-rating.ts

@@ -0,0 +1,16 @@
+import {
+  BaseEventData,
+  EventChannelRating,
+  EventDataRating,
+  RequestData,
+} from '../types'
+import { HtEvent } from './ht-event'
+
+export class HtEventChannelRating extends HtEvent {
+  event_data: BaseEventData & EventDataRating
+
+  constructor(event: EventChannelRating, requestData: RequestData) {
+    super(event, requestData)
+    this.event_data.rating = event.event_data.rating
+  }
+}

package/src/event-models/ht-event-faq-useful.ts

@@ -0,0 +1,17 @@
+import {
+  BaseEventData,
+  EventDataUseful,
+  EventFaqUseful,
+  RequestData,
+} from '../types'
+import { HtEvent } from './ht-event'
+
+export class HtEventFaqUseful extends HtEvent {
+  event_data: BaseEventData & EventDataUseful
+
+  constructor(event: EventFaqUseful, requestData: RequestData) {
+    super(event, requestData)
+    this.event_data.faq_name = event.event_data.faq_name
+    this.event_data.useful = event.event_data.useful
+  }
+}

package/src/event-models/ht-event-handoff-fail.ts

@@ -0,0 +1,18 @@
+import {
+  BaseEventData,
+  EventDataHandoff,
+  EventHandoffFail,
+  RequestData,
+} from '../types'
+import { HtEvent } from './ht-event'
+
+export class HtEventHandoffFail extends HtEvent {
+  event_data: BaseEventData & EventDataHandoff
+
+  constructor(event: EventHandoffFail, requestData: RequestData) {
+    super(event, requestData)
+    this.event_data.queue_open = event.event_data.queue_open
+    this.event_data.available_agents = event.event_data.available_agents
+    this.event_data.threshold_reached = event.event_data.threshold_reached
+  }
+}

package/src/event-models/ht-event-handoff-success.ts

@@ -0,0 +1,18 @@
+import {
+  BaseEventData,
+  EventDataHandoff,
+  EventHandoffSuccess,
+  RequestData,
+} from '../types'
+import { HtEvent } from './ht-event'
+
+export class HtEventHandoffSuccess extends HtEvent {
+  event_data: BaseEventData & EventDataHandoff
+
+  constructor(event: EventHandoffSuccess, requestData: RequestData) {
+    super(event, requestData)
+    this.event_data.queue_open = event.event_data.queue_open
+    this.event_data.available_agents = event.event_data.available_agents
+    this.event_data.threshold_reached = event.event_data.threshold_reached
+  }
+}

package/src/event-models/ht-event.ts

@@ -0,0 +1,20 @@
+import { BaseEventData, EventName, HtEventProps, RequestData } from '../types'
+
+export class HtEvent {
+  chat: string
+  event_type: EventName
+  event_data: BaseEventData
+
+  constructor(event: HtEventProps, requestData: RequestData) {
+    this.chat = requestData.userId
+    this.event_type = event.event_type
+    this.event_data = {
+      channel: requestData.provider,
+      event_datetime: new Date().toISOString(),
+      enduser_language: requestData.language,
+      enduser_country: requestData.country,
+      format_version: 1,
+      // flow_version?: string
+    }
+  }
+}

package/src/index.ts

@@ -1,20 +1,30 @@
 import { BotRequest, Plugin } from '@botonic/core'
 import axios from 'axios'
 
-import { HtEvent } from './types'
+import { HtEventProps, RequestData } from './types'
+import { createHtEvent } from './utils'
 
 export interface HubtypeAnalyticsOptions {
-  baseUrl: string
+  getLaguange?: (request: BotRequest) => string
+  getCountry?: (request: BotRequest) => string
+}
+
+function getDefaultLanguage(request: BotRequest): string {
+  return request.session.user.extra_data.language
+}
+
+function getDefaultCountry(request: BotRequest): string {
+  return request.session.user.extra_data.country
 }
 
 export default class BotonicPluginHubtypeAnalytics implements Plugin {
   baseUrl: string
+  getLaguange: (request: BotRequest) => string
+  getCountry: (request: BotRequest) => string
   constructor(options: HubtypeAnalyticsOptions) {
-    this.baseUrl = options.baseUrl
-  }
-
-  pre(): void {
-    return
+    this.baseUrl = process.env.HUBTYPE_API_URL || 'https://api.hubtype.com'
+    this.getLaguange = options.getLaguange || getDefaultLanguage
+    this.getCountry = options.getCountry || getDefaultCountry
   }
 
   post(): void {
@@ -25,19 +35,21 @@ export default class BotonicPluginHubtypeAnalytics implements Plugin {
     return `${this.baseUrl}/external/v1/conversational_apps/${request.session.bot.id}/bot_event/`
   }
 
-  async trackEvent(request: BotRequest, event: HtEvent) {
-    const url = this.getUrl(request)
-    const data = {
-      chat: request.session.user.id,
-      event_type: event.event_type,
-      event_data: {
-        ...event.event_data,
-        event_datetime: new Date().toISOString(),
-        channel: request.session.user.provider,
-      },
+  getRequestData(request: BotRequest): RequestData {
+    return {
+      language: this.getLaguange(request),
+      country: this.getCountry(request),
+      provider: request.session.user.provider,
+      userId: request.session.user.id,
     }
+  }
+
+  async trackEvent(request: BotRequest, htEventProps: HtEventProps) {
+    const url = this.getUrl(request)
+    const requestData = this.getRequestData(request)
+    const event = createHtEvent(requestData, htEventProps)
     const headers = { Authorization: `Bearer ${request.session._access_token}` }
     const config = { headers }
-    return axios.post(url, data, config)
+    return axios.post(url, event, config)
   }
 }

package/src/types.ts

@@ -1,3 +1,11 @@
+import { PROVIDER } from '@botonic/core'
+
+export interface Event {
+  chat: string
+  event_type: EventName
+  event_data: BaseEventData
+}
+
 export enum EventName {
   botAgentRating = 'bot_agent_rating',
   botChannelRating = 'bot_channel_rating',
@@ -13,101 +21,113 @@ export enum EventName {
   handoffSuccess = 'handoff_success',
   handoffFail = 'handoff_fail',
 }
-
-interface EventData {
-  enduser_country?: string
+export interface BaseEventData {
+  channel: string
+  event_datetime: string
   enduser_language: string
+  enduser_country?: string
   format_version?: number
   bot_version?: string
   flow_version?: string
 }
 
-export interface EventAgentRating {
-  event_type: EventName.botAgentRating
-  event_data: EventData & { rating: number }
+export interface HtBaseEventProps {
+  event_type: EventName
 }
 
-export interface EventChannelRating {
+export interface EventAgentRating extends HtBaseEventProps {
+  event_type: EventName.botAgentRating
+  event_data: EventDataRating
+}
+export interface EventChannelRating extends HtBaseEventProps {
   event_type: EventName.botChannelRating
-  event_data: EventData & { rating: number }
+  event_data: EventDataRating
+}
+
+export interface EventDataRating {
+  rating: number
 }
 
-export interface EventFaqUseful {
+export interface EventFaqUseful extends HtBaseEventProps {
   event_type: EventName.botFaqUseful
-  event_data: EventData & { faq_name: string; useful: boolean }
+  event_data: EventDataUseful
 }
 
-export interface EventBotRating {
+export interface EventDataUseful {
+  faq_name: string
+  useful: boolean
+}
+export interface EventBotRating extends HtBaseEventProps {
   event_type: EventName.botRating
-  event_data: EventData & {
-    faq_name: string
-    useful: boolean
-    rating: number
-    free_comment: string
-    selected_options: string[]
-  }
+  event_data: EventDataBotRating
+}
+
+export interface EventDataBotRating {
+  rating: number
+  free_comment?: string
+  selected_options?: string[]
 }
 
-export interface EventBotFaq {
+export interface EventBotFaq extends HtBaseEventProps {
   event_type: EventName.botFaq
-  event_data: EventData & { faq_name: string }
+  event_data: EventDataBotFaq
 }
 
-export interface EventBotStart {
+export interface EventDataBotFaq {
+  faq_name: string
+}
+export interface EventBotStart extends HtBaseEventProps {
   event_type: EventName.botStart
-  event_data: EventData
 }
 
 export interface EventBotOpen {
   event_type: EventName.botOpen
-  event_data: EventData
 }
 
 export interface EventBotAiModel {
   event_type: EventName.botAiModel
-  event_data: EventData & {
-    intent: string
-    confidence: number
-    confidence_successful: boolean
-  }
+  event_data: EventDataBotAiModel
+}
+
+export interface EventDataBotAiModel {
+  intent: string
+  confidence: number
+  confidence_successful: boolean
 }
 
-export interface EventBotKeywordModel {
+export interface EventBotKeywordModel extends HtBaseEventProps {
   event_type: EventName.botKeywordsModel
-  event_data: EventData & {
-    confidence_successful: boolean
-  }
+  event_data: EventDataBotKeywordModel
 }
 
-export interface EventFallback {
+export interface EventDataBotKeywordModel {
+  confidence_successful: boolean
+}
+export interface EventFallback extends HtBaseEventProps {
   event_type: EventName.fallback
-  event_data: EventData
 }
 
-export interface EventHandoffOption {
+export interface EventHandoffOption extends HtBaseEventProps {
   event_type: EventName.handoffOption
-  event_data: EventData
 }
 
-export interface EventHandoffSuccess {
+export interface EventHandoffSuccess extends HtBaseEventProps {
   event_type: EventName.handoffSuccess
-  event_data: EventData & {
-    queue_open: boolean
-    available_agents: boolean
-    threshold_reached: boolean
-  }
+  event_data: EventDataHandoff
 }
 
-export interface EventHandoffFail {
+export interface EventHandoffFail extends HtBaseEventProps {
   event_type: EventName.handoffFail
-  event_data: EventData & {
-    queue_open: boolean
-    available_agents: boolean
-    threshold_reached: boolean
-  }
+  event_data: EventDataHandoff
+}
+
+export interface EventDataHandoff {
+  queue_open: boolean
+  available_agents: boolean
+  threshold_reached: boolean
 }
 
-export type HtEvent =
+export type HtEventProps =
   | EventAgentRating
   | EventChannelRating
   | EventFaqUseful
@@ -121,3 +141,10 @@ export type HtEvent =
   | EventHandoffOption
   | EventHandoffSuccess
   | EventHandoffFail
+
+export interface RequestData {
+  language: string
+  country: string
+  provider: PROVIDER
+  userId: string
+}

package/src/utils.ts

@@ -0,0 +1,46 @@
+import { HtEvent } from './event-models/ht-event'
+import { HtEventAgentRating } from './event-models/ht-event-agent-rating'
+import { HtEventBotAiModel } from './event-models/ht-event-bot-ai-model'
+import { HtEventBotFaq } from './event-models/ht-event-bot-faq'
+import { HtEventBotKeywordModel } from './event-models/ht-event-bot-keyword-model'
+import { HtEventBotRating } from './event-models/ht-event-bot-rating'
+import { HtEventChannelRating } from './event-models/ht-event-channel-rating'
+import { HtEventFaqUseful } from './event-models/ht-event-faq-useful'
+import { HtEventHandoffFail } from './event-models/ht-event-handoff-fail'
+import { HtEventHandoffSuccess } from './event-models/ht-event-handoff-success'
+import { EventName, HtEventProps, RequestData } from './types'
+
+export function createHtEvent(
+  requestData: RequestData,
+  htEventProps: HtEventProps
+): HtEvent {
+  if (htEventProps.event_type === EventName.botAgentRating) {
+    return new HtEventAgentRating(htEventProps, requestData)
+  }
+  if (htEventProps.event_type === EventName.botChannelRating) {
+    return new HtEventChannelRating(htEventProps, requestData)
+  }
+  if (htEventProps.event_type === EventName.botFaqUseful) {
+    return new HtEventFaqUseful(htEventProps, requestData)
+  }
+  if (htEventProps.event_type === EventName.botRating) {
+    return new HtEventBotRating(htEventProps, requestData)
+  }
+  if (htEventProps.event_type === EventName.botFaq) {
+    return new HtEventBotFaq(htEventProps, requestData)
+  }
+  if (htEventProps.event_type === EventName.botAiModel) {
+    return new HtEventBotAiModel(htEventProps, requestData)
+  }
+  if (htEventProps.event_type === EventName.botKeywordsModel) {
+    return new HtEventBotKeywordModel(htEventProps, requestData)
+  }
+  if (htEventProps.event_type === EventName.handoffSuccess) {
+    return new HtEventHandoffSuccess(htEventProps, requestData)
+  }
+  if (htEventProps.event_type === EventName.handoffFail) {
+    return new HtEventHandoffFail(htEventProps, requestData)
+  }
+
+  return new HtEvent(htEventProps, requestData)
+}