coveo.analytics 2.18.52 → 2.18.56

package/src/caseAssist/caseAssistClient.spec.ts

@@ -0,0 +1,262 @@
+import {CaseAssistClient} from './caseAssistClient';
+import {
+    CaseAssistActions,
+    CaseAssistEvents,
+    CaseCancelledReasons,
+    DocumentSuggestion,
+    FieldSuggestion,
+} from './caseAssistActions';
+
+import {mockFetch} from '../../tests/fetchMock';
+import {TicketProperties} from '../plugins/svc';
+
+const {fetchMock, fetchMockBeforeEach} = mockFetch();
+
+describe('CaseAssistClient', () => {
+    let client: CaseAssistClient;
+
+    beforeEach(() => {
+        fetchMockBeforeEach();
+
+        client = initClient();
+        fetchMock.mock(/.*/, {
+            visitorId: 'visitor-id',
+        });
+    });
+
+    afterEach(() => {
+        fetchMock.reset();
+    });
+
+    const initClient = () => {
+        return new CaseAssistClient({
+            enableAnalytics: true,
+        });
+    };
+
+    const noTicket: Record<string, unknown> = undefined;
+    const noActionData: Record<string, unknown> = undefined;
+    const emptyTicket: TicketProperties = {};
+
+    const fakeTicket: TicketProperties = {
+        id: 'the-ticket-id',
+        subject: 'the ticket subject',
+        description: 'the ticket description',
+        category: 'ticket-category',
+        productId: 'some-product-id',
+        custom: {
+            customA: 'custom-a-value',
+            customB: 'custom-b-value',
+        },
+    };
+
+    const fakeFieldSuggestion: FieldSuggestion = {
+        classification: {
+            value: 'some-field-value',
+            confidence: 0.5,
+        },
+        classificationId: 'field-suggestion-id',
+        fieldName: 'some-field',
+        responseId: 'field-suggestion-response-id',
+    };
+
+    const fakeDocumentSuggestion: DocumentSuggestion = {
+        responseId: 'document-suggestion-response-id',
+        suggestionId: 'document-suggestion-id',
+        suggestion: {
+            documentPosition: 0,
+            documentTitle: 'the document title',
+            documentUri: 'some-document-uri',
+            documentUriHash: 'documenturihash',
+            documentUrl: 'some-document-url',
+        },
+    };
+
+    const expectMatchPayload = (actionName: CaseAssistActions, actionData: Object, ticket: TicketProperties) => {
+        const [, {body}] = fetchMock.lastCall();
+        const content = JSON.parse(body.toString());
+
+        expectMatchActionPayload(content, actionName, actionData);
+        expectMatchTicketPayload(content, ticket);
+    };
+
+    const expectMatchActionPayload = (
+        content: Record<string, unknown>,
+        actionName: CaseAssistActions,
+        actionData: Object
+    ) => {
+        expectMatchProperty(content, 'ec', 'svc');
+        expectMatchProperty(content, 'svc_action', actionName);
+        expectMatchProperty(content, 'svc_action_data', actionData);
+
+        const expectedEvent =
+            actionName === CaseAssistActions.enterInterface ? CaseAssistEvents.flowStart : CaseAssistEvents.click;
+        expectMatchProperty(content, 'ea', expectedEvent);
+    };
+
+    const expectMatchTicketPayload = (content: Record<string, unknown>, ticket?: TicketProperties) => {
+        expectMatchProperty(content, 'svc_ticket_id', ticket?.id);
+        expectMatchProperty(content, 'svc_ticket_subject', ticket?.subject);
+        expectMatchProperty(content, 'svc_ticket_description', ticket?.description);
+        expectMatchProperty(content, 'svc_ticket_category', ticket?.category);
+        expectMatchProperty(content, 'svc_ticket_product_id', ticket?.productId);
+        expectMatchProperty(content, 'svc_ticket_custom', ticket?.custom);
+    };
+
+    const expectMatchProperty = (content: Record<string, unknown>, propName: string, propValue: unknown) => {
+        if (typeof propValue !== 'undefined') {
+            if (typeof propValue === 'object') {
+                expect(content).toHaveProperty(propName);
+                expect(content[propName]).toMatchObject(propValue);
+            } else {
+                expect(content).toHaveProperty(propName, propValue);
+            }
+        } else {
+            expect(content).not.toHaveProperty(propName);
+        }
+    };
+
+    it('should have #enableAnalytics default to #true', async () => {
+        client = new CaseAssistClient({});
+
+        await client.logEnterInterface({
+            ticket: emptyTicket,
+        });
+
+        expect(fetchMock.called()).toBe(true);
+    });
+
+    it('should not send events when #enableAnalytics option is #false', async () => {
+        client = new CaseAssistClient({
+            enableAnalytics: false,
+        });
+
+        await client.logEnterInterface({
+            ticket: emptyTicket,
+        });
+
+        expect(fetchMock.called()).toBe(false);
+    });
+
+    it('should not send events after #disable function is called', async () => {
+        client.disable();
+
+        await client.logEnterInterface({
+            ticket: emptyTicket,
+        });
+
+        expect(fetchMock.called()).toBe(false);
+    });
+
+    it('should send events after #enable function is called', async () => {
+        client = new CaseAssistClient({
+            enableAnalytics: false,
+        });
+
+        client.enable();
+
+        await client.logEnterInterface({
+            ticket: emptyTicket,
+        });
+
+        expect(fetchMock.called()).toBe(true);
+    });
+
+    it('should send proper payload for #logEnterInterface', async () => {
+        await client.logEnterInterface({
+            ticket: emptyTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.enterInterface, noActionData, noTicket);
+    });
+
+    it('should send proper payload for #logUpdateCaseField', async () => {
+        await client.logUpdateCaseField({
+            fieldName: 'subject',
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.fieldUpdate, {fieldName: 'subject'}, fakeTicket);
+    });
+
+    it('should send proper payload for #logSelectFieldSuggestion', async () => {
+        await client.logSelectFieldSuggestion({
+            suggestion: fakeFieldSuggestion,
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.fieldSuggestionClick, fakeFieldSuggestion, fakeTicket);
+    });
+
+    it('should send proper payload for #logSelectDocumentSuggestion', async () => {
+        await client.logSelectDocumentSuggestion({
+            suggestion: fakeDocumentSuggestion,
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.suggestionClick, fakeDocumentSuggestion, fakeTicket);
+    });
+
+    it('should send proper payload for #logRateDocumentSuggestion', async () => {
+        const rating = 0.8;
+
+        await client.logRateDocumentSuggestion({
+            rating,
+            suggestion: fakeDocumentSuggestion,
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(
+            CaseAssistActions.suggestionRate,
+            {
+                ...fakeDocumentSuggestion,
+                rate: rating,
+            },
+            fakeTicket
+        );
+    });
+
+    it('should send proper payload for #logMoveToNextCaseStep', async () => {
+        await client.logMoveToNextCaseStep({
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.nextCaseStep, noActionData, fakeTicket);
+    });
+
+    it('should send proper payload for #logCaseCancelled', async () => {
+        await client.logCaseCancelled({
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(
+            CaseAssistActions.caseCancelled,
+            {
+                reason: CaseCancelledReasons.quit,
+            },
+            fakeTicket
+        );
+    });
+
+    it('should send proper payload for #logCaseSolved', async () => {
+        await client.logCaseSolved({
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(
+            CaseAssistActions.caseSolved,
+            {
+                reason: CaseCancelledReasons.solved,
+            },
+            fakeTicket
+        );
+    });
+
+    it('should send proper payload for #logCaseCreated', async () => {
+        await client.logCaseCreated({
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.caseCreated, noActionData, fakeTicket);
+    });
+});

package/src/caseAssist/caseAssistClient.ts

@@ -0,0 +1,117 @@
+import CoveoAnalyticsClient, {AnalyticsClient, ClientOptions} from '../client/analytics';
+import {NoopAnalytics} from '../client/noopAnalytics';
+import {SVCPlugin} from '../plugins/svc';
+import {
+    CaseAssistActions,
+    CaseAssistEvents,
+    CaseCancelledMetadata,
+    CaseCancelledReasons,
+    CaseCreatedMetadata,
+    CaseSolvedMetadata,
+    EnterInterfaceMetadata,
+    MoveToNextCaseStepMetadata,
+    RateDocumentSuggestionMetadata,
+    SelectDocumentSuggestionMetadata,
+    SelectFieldSuggestionMetadata,
+    UpdateCaseFieldMetadata,
+} from './caseAssistActions';
+
+export interface CaseAssistClientOptions extends ClientOptions {
+    enableAnalytics?: boolean;
+}
+
+export class CaseAssistClient {
+    public coveoAnalyticsClient: AnalyticsClient;
+    private svc: SVCPlugin;
+
+    constructor(private options: Partial<CaseAssistClientOptions>) {
+        const analyticsEnabled = options.enableAnalytics ?? true;
+
+        this.coveoAnalyticsClient = analyticsEnabled ? new CoveoAnalyticsClient(options) : new NoopAnalytics();
+        this.svc = new SVCPlugin({client: this.coveoAnalyticsClient});
+    }
+
+    public disable() {
+        if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+            this.coveoAnalyticsClient.clear();
+        }
+        this.coveoAnalyticsClient = new NoopAnalytics();
+        this.svc = new SVCPlugin({client: this.coveoAnalyticsClient});
+    }
+
+    public enable() {
+        this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.options);
+        this.svc = new SVCPlugin({client: this.coveoAnalyticsClient});
+    }
+
+    public logEnterInterface(meta: EnterInterfaceMetadata) {
+        this.svc.setAction(CaseAssistActions.enterInterface);
+        this.svc.setTicket(meta.ticket);
+        return this.sendFlowStartEvent();
+    }
+
+    public logUpdateCaseField(meta: UpdateCaseFieldMetadata) {
+        this.svc.setAction(CaseAssistActions.fieldUpdate, {
+            fieldName: meta.fieldName,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logSelectFieldSuggestion(meta: SelectFieldSuggestionMetadata) {
+        this.svc.setAction(CaseAssistActions.fieldSuggestionClick, meta.suggestion);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logSelectDocumentSuggestion(meta: SelectDocumentSuggestionMetadata) {
+        this.svc.setAction(CaseAssistActions.suggestionClick, meta.suggestion);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logRateDocumentSuggestion(meta: RateDocumentSuggestionMetadata) {
+        this.svc.setAction(CaseAssistActions.suggestionRate, {
+            rate: meta.rating,
+            ...meta.suggestion,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logMoveToNextCaseStep(meta: MoveToNextCaseStepMetadata) {
+        this.svc.setAction(CaseAssistActions.nextCaseStep);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logCaseCancelled(meta: CaseCancelledMetadata) {
+        this.svc.setAction(CaseAssistActions.caseCancelled, {
+            reason: CaseCancelledReasons.quit,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logCaseSolved(meta: CaseSolvedMetadata) {
+        this.svc.setAction(CaseAssistActions.caseSolved, {
+            reason: CaseCancelledReasons.solved,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logCaseCreated(meta: CaseCreatedMetadata) {
+        this.svc.setAction(CaseAssistActions.caseCreated);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    private sendFlowStartEvent() {
+        return this.coveoAnalyticsClient.sendEvent('event', 'svc', CaseAssistEvents.flowStart);
+    }
+
+    private sendClickEvent() {
+        return this.coveoAnalyticsClient.sendEvent('event', 'svc', CaseAssistEvents.click);
+    }
+}

package/src/coveoua/headless.ts

@@ -1,4 +1,5 @@
 export {CoveoSearchPageClient, SearchPageClientProvider} from '../searchPage/searchPageClient';
+export {CaseAssistClient} from '../caseAssist/caseAssistClient';
 export {CoveoAnalyticsClient, AnalyticsClientSendEventHook} from '../client/analytics';
 export {PreprocessAnalyticsRequest} from '../client/analyticsRequestClient';
 export * as history from '../history';

package/src/coveoua/library.ts

@@ -8,5 +8,6 @@ export {PreprocessAnalyticsRequest} from '../client/analyticsRequestClient';
 export {IRuntimeEnvironment} from '../client/runtimeEnvironment';
 export {CoveoUA, getCurrentClient, handleOneAnalyticsEvent} from './simpleanalytics';
 export {CoveoSearchPageClient, SearchPageClientProvider} from '../searchPage/searchPageClient';
+export {CaseAssistClient} from '../caseAssist/caseAssistClient';
 
 export {analytics, donottrack, history, SimpleAnalytics, storage};

package/src/donottrack.spec.ts

@@ -94,5 +94,29 @@ describe('doNotTrack', () => {
                 expect(doNotTrack()).toBeTruthy();
             });
         });
+
+        [false, 'no', '0', 'unspecified'].forEach((value) => {
+            it('should fallback on `navigator.doNotTrack`: ' + JSON.stringify(value), () => {
+                initModule(true, {
+                    navigatorDoNotTrack: value,
+                });
+
+                expect(doNotTrack()).toBeFalsy();
+            });
+
+            it('should fallback on `navigator.msDoNotTrack`: ' + JSON.stringify(value), () => {
+                initModule(true, {
+                    navigatorMsDoNotTrack: value,
+                });
+                expect(doNotTrack()).toBeFalsy();
+            });
+
+            it('should fallback on `window.doNotTrack`: ' + JSON.stringify(value), () => {
+                initModule(true, {
+                    windowDoNotTrack: value,
+                });
+                expect(doNotTrack()).toBeFalsy();
+            });
+        });
     });
 });

package/src/donottrack.ts

@@ -6,6 +6,8 @@
 
 import {hasNavigator} from './detector';
 
+const doNotTrackValues = ['1', 1, 'yes', true];
+
 export function doNotTrack(): boolean {
     return (
         hasNavigator() &&
@@ -14,7 +16,7 @@ export function doNotTrack(): boolean {
             (<any>navigator).doNotTrack,
             (<any>navigator).msDoNotTrack,
             (<any>window).doNotTrack,
-        ].some((value) => !!value)
+        ].some((value) => doNotTrackValues.indexOf(value) !== -1)
     );
 }
 

package/dist/definitions/src/plugins/BasePlugin.d.ts

@@ -1,53 +0,0 @@
-import { AnalyticsClient } from '../client/analytics';
-import { uuidv4 } from '../client/crypto';
-declare type PluginWithId = {
-    readonly Id: string;
-};
-export declare type PluginClass = typeof BasePlugin & PluginWithId;
-export declare const BasePluginEventTypes: {
-    pageview: string;
-    event: string;
-};
-export declare type PluginOptions = {
-    client: AnalyticsClient;
-    uuidGenerator?: typeof uuidv4;
-};
-export declare abstract class BasePlugin {
-    protected client: AnalyticsClient;
-    protected uuidGenerator: typeof uuidv4;
-    protected action?: string;
-    protected actionData: {
-        [name: string]: string;
-    };
-    private pageViewId;
-    private nextPageViewId;
-    private hasSentFirstPageView?;
-    private currentLocation;
-    private lastReferrer;
-    constructor({ client, uuidGenerator }: PluginOptions);
-    protected abstract addHooks(): void;
-    protected abstract clearPluginData(): void;
-    setAction(action: string, options?: any): void;
-    clearData(): void;
-    getLocationInformation(eventType: string, payload: any): {
-        pageViewId: string;
-        referrer: string;
-        location: string;
-        hitType: string;
-    };
-    updateLocationInformation(eventType: string, payload: any): void;
-    getDefaultContextInformation(eventType: string): {
-        title: string;
-        encoding: string;
-        language: string;
-        userAgent: string;
-        screenResolution: string;
-        screenColor: string;
-        time: string;
-        eventId: string;
-    };
-    private updateLocationForNextPageView;
-    private getNextValues;
-    private getCurrentLocationFromPayload;
-}
-export {};

package/dist/definitions/src/plugins/svc.d.ts

@@ -1,31 +0,0 @@
-import { BasePlugin, PluginClass, PluginOptions } from './BasePlugin';
-export declare const SVCPluginEventTypes: {
-    pageview: string;
-    event: string;
-};
-export declare type CustomValues = {
-    [key: string]: string | number | boolean;
-};
-export interface TicketProperties {
-    id?: string;
-    subject?: string;
-    description?: string;
-    category?: string;
-    productId?: string;
-    custom?: CustomValues;
-}
-export declare type Ticket = TicketProperties;
-export declare class SVCPlugin extends BasePlugin {
-    static readonly Id = "svc";
-    private ticket;
-    constructor({ client, uuidGenerator }: PluginOptions);
-    protected addHooks(): void;
-    setTicket(ticket: Ticket): void;
-    protected clearPluginData(): void;
-    private addHooksForSVCEvents;
-    private addHooksForPageView;
-    private addHooksForEvent;
-    private addSVCDataToPayload;
-    private getTicketPayload;
-}
-export declare const SVC: PluginClass;