typeahead-client-logger 0.0.1-security → 2.532.1

package/dist/TypeaheadEvent.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeaheadEvent = exports.EventName = void 0;
+var Utils_1 = require("./utils/Utils");
+var EventName;
+(function (EventName) {
+  EventName["FOCUS"] = "typeaheadFocused";
+  EventName["BLUR"] = "typeaheadBlurred";
+  EventName["SELECT"] = "typeaheadSuggestionSelected";
+  EventName["CURRENT_LOCATION"] = "currentLocation";
+})((EventName = exports.EventName || (exports.EventName = {})));
+var EventType;
+(function (EventType) {
+  EventType["TYPEAHEAD_INTERACTION"] = "typeaheadInteraction";
+})(EventType || (EventType = {}));
+var SearchField;
+(function (SearchField) {
+  SearchField["O"] = "Origin";
+  SearchField["D"] = "Destination";
+  SearchField["U"] = "UNKNOWN";
+})(SearchField || (SearchField = {}));
+var SourceSystem;
+(function (SourceSystem) {
+  SourceSystem["GAIA"] = "GAIA";
+  SourceSystem["LCM"] = "LCM";
+  SourceSystem["GOOGLE"] = "GOOGLE";
+  SourceSystem["UNKNOWN"] = "UNKNOWN";
+})(SourceSystem || (SourceSystem = {}));
+var SuggestionType;
+(function (SuggestionType) {
+  SuggestionType["ALTERNATE"] = "Alternate";
+  SuggestionType["CURRENT_LOCATION"] = "CurrentLocation";
+  SuggestionType["POPULAR"] = "Popular";
+  SuggestionType["GOOGLE"] = "Google";
+  SuggestionType["NORMAL"] = "Normal";
+  SuggestionType["RECENT_HISTORY"] = "RecentHistory";
+})(SuggestionType || (SuggestionType = {}));
+// tslint:disable-next-line:max-line-length
+
+var TypeaheadEvent = /** @class */ (function () {
+  function TypeaheadEvent(eventName, session) {
+    var _a, _b;
+    var isCurrLoc = EventName.CURRENT_LOCATION === eventName;
+    if (isCurrLoc) {
+      eventName = EventName.SELECT;
+    }
+    this.typeaheadEvent = {
+      event: {
+        name: eventName,
+        type: EventType.TYPEAHEAD_INTERACTION,
+      },
+      numberOfBackspaces: session.noOfBackspaces,
+      page: {
+        actionLocation: session.fieldName,
+        lineOfBusiness:
+          session.metadata.lob +
+          this.getSublob(session.metadata.lob, session.metadata.subLob),
+        pageName: this.getPageName(session.metadata.client || "", session.href),
+      },
+      searchField: this.getSearchField(session.fieldName),
+      searchFieldContent:
+        EventName.FOCUS === eventName
+          ? ((_a = session.input) === null || _a === void 0
+              ? void 0
+              : _a.value) || ""
+          : session.query === session.prefill
+          ? ""
+          : session.query || "",
+      timestamps: {
+        receivedAt: Date.now(),
+      },
+    };
+    if (EventName.FOCUS === eventName) {
+      // we are setting the initial time stamp when user first interacts with typeahead input box
+      session.isResolve = false;
+      session.focusTime = new Date().toString();
+    }
+    if ([EventName.SELECT, EventName.BLUR].indexOf(eventName) > -1) {
+      if (session.response) {
+        this.setSuggestionShownFields(session.response);
+      }
+      if (session.selected) {
+        if (EventName.BLUR === eventName) {
+          this.typeaheadEvent.typeaheadSelection = true;
+          this.typeaheadEvent.charactersTyped =
+            this.typeaheadEvent.searchFieldContent.length;
+          this.calculateTimeSpendOnTypeaheadInput(session);
+        }
+        this.setSuggestionSelectedFields(session.selected);
+      }
+      if (session.selected === undefined && EventName.BLUR === eventName) {
+        this.calculateTimeSpendOnTypeaheadInput(session);
+        this.typeaheadEvent.typeaheadSelection = false;
+        this.typeaheadEvent.charactersTyped =
+          this.typeaheadEvent.searchFieldContent.length;
+        var input =
+          (_b = document.getElementsByName("regionId")) === null ||
+          _b === void 0
+            ? void 0
+            : _b.item(0);
+        var regionId =
+          (input === null || input === void 0 ? void 0 : input.value) ||
+          "UNKNOWN";
+        this.typeaheadEvent.searchDestination = {
+          id: session.isResolve ? "UNKNOWN" : regionId,
+          sourceSystem: "UNKNOWN",
+          fullName: session.isResolve ? session.query : session.prefill || "",
+        };
+      }
+      if (isCurrLoc) {
+        this.setCurrentLocationSelectedFields();
+      }
+    }
+  }
+  TypeaheadEvent.prototype.getTypeaheadEventMessage = function () {
+    return {
+      messageContent: this.typeaheadEvent,
+      schemaName: "typeahead",
+    };
+  };
+  TypeaheadEvent.prototype.getFlattenedJsonMessage = function () {
+    var _a, _b, _c;
+    return {
+      "ta.page.actionLocation": this.typeaheadEvent.page.actionLocation,
+      "ta.page.lob": this.typeaheadEvent.page.lineOfBusiness,
+      "ta.page.name": this.typeaheadEvent.page.pageName,
+      "ta.searchField": this.typeaheadEvent.searchField,
+      "ta.searchFieldContent": this.typeaheadEvent.searchFieldContent,
+      "ta.timestamps.receivedAt": this.typeaheadEvent.timestamps.receivedAt,
+      "ta.noOfSuggestions": this.typeaheadEvent.noOfSuggestions,
+      "ta.requestId": this.typeaheadEvent.serviceRequestLogId,
+      "ta.suggestionType": this.typeaheadEvent.suggestionType,
+      "ta.searchDestination":
+        ((_a = this.typeaheadEvent.searchDestination) === null || _a === void 0
+          ? void 0
+          : _a.sourceSystem) +
+        ":" +
+        ((_b = this.typeaheadEvent.searchDestination) === null || _b === void 0
+          ? void 0
+          : _b.id),
+      "ta.selectionDepth": this.typeaheadEvent.selectionDepth,
+      "ta.suggestionList":
+        (_c = this.typeaheadEvent.suggestionList) === null || _c === void 0
+          ? void 0
+          : _c
+              .map(function (s) {
+                return s.sourceSystem + ":" + s.id;
+              })
+              .join(","),
+    };
+  };
+  TypeaheadEvent.prototype.setSuggestionShownFields = function (response) {
+    this.typeaheadEvent.noOfSuggestions = response.sr.length;
+    this.typeaheadEvent.serviceRequestLogId = response.rid;
+    if (response.sr && response.sr.length) {
+      this.typeaheadEvent.suggestionType = this.getSuggestionType(
+        response.sr[0].category
+      );
+      this.typeaheadEvent.suggestionList = this.getSuggestionList(response.sr);
+    }
+  };
+  TypeaheadEvent.prototype.setSuggestionSelectedFields = function (selected) {
+    this.typeaheadEvent.suggestionType = this.getSuggestionType(
+      selected.category
+    );
+    this.typeaheadEvent.searchDestination = this.getGeoEntity(selected);
+    this.typeaheadEvent.selectionDepth = parseInt(selected.index, 10);
+    if (selected && selected.displayType !== "CATEGORIZED")
+      this.typeaheadEvent.selectionDepth += 1;
+  };
+  TypeaheadEvent.prototype.setCurrentLocationSelectedFields = function () {
+    this.typeaheadEvent.suggestionType = SuggestionType.CURRENT_LOCATION;
+    this.typeaheadEvent.typeaheadSelection = true;
+    this.typeaheadEvent.searchDestination = {
+      fullName: "CurrentLocation",
+      id: "",
+      type: SuggestionType.CURRENT_LOCATION,
+    };
+    this.typeaheadEvent.selectionDepth = 1;
+  };
+  TypeaheadEvent.prototype.getSearchField = function (domElementId) {
+    if (!domElementId) {
+      return SearchField.U;
+    }
+    return Utils_1.Utils.isOrigin(domElementId)
+      ? SearchField.O
+      : Utils_1.Utils.isDestination(domElementId)
+      ? SearchField.D
+      : SearchField.U;
+  };
+  TypeaheadEvent.prototype.getGeoEntity = function (selected) {
+    return {
+      fullName: selected.regionNames.lastSearchName,
+      id: this.getSourceId(selected),
+      shortName: selected.regionNames.shortName,
+      sourceSystem: this.getSourceSystem(selected),
+      type: selected.type,
+    };
+  };
+  TypeaheadEvent.prototype.getSourceId = function (s) {
+    var _a;
+    return (
+      s.sourceId ||
+      ((_a = s.essId) === null || _a === void 0 ? void 0 : _a.sourceId) ||
+      s.hotelId ||
+      s.gaiaId ||
+      Utils_1.Utils.UNKNOWN
+    );
+  };
+  TypeaheadEvent.prototype.getSourceSystem = function (s) {
+    var _a;
+    var sourceName =
+      s.sourceName ||
+      ((_a = s.essId) === null || _a === void 0 ? void 0 : _a.sourceName) ||
+      (s.hotelId ? "LCM" : s.gaiaId ? "GAI" : "");
+    switch (sourceName) {
+      case "GAI":
+        return SourceSystem.GAIA;
+      case "LCM":
+        return SourceSystem.LCM;
+      case "GPA":
+        return SourceSystem.GOOGLE;
+      default:
+        return sourceName || SourceSystem.UNKNOWN;
+    }
+  };
+  TypeaheadEvent.prototype.getSuggestionType = function (category) {
+    switch (category) {
+      case "GOOGLEMAPS":
+        return SuggestionType.GOOGLE;
+      case "USERHISTORY":
+        return SuggestionType.RECENT_HISTORY;
+      case "ALTERNATE":
+        return SuggestionType.ALTERNATE;
+      case "POPULAR":
+        return SuggestionType.POPULAR;
+      case "CURRENTLOCATION":
+        return SuggestionType.CURRENT_LOCATION;
+      default:
+        return SuggestionType.NORMAL;
+    }
+  };
+  TypeaheadEvent.prototype.getSuggestionList = function (suggestions) {
+    var _this = this;
+    return suggestions.map(function (s) {
+      var suggId = {
+        id: _this.getSourceId(s),
+        sourceSystem: _this.getSourceSystem(s),
+        type: s.type,
+      };
+      if (
+        s.hierarchyInfo &&
+        s.hierarchyInfo.relation &&
+        s.hierarchyInfo.relation.length
+      ) {
+        suggId.reason = s.hierarchyInfo.relation[0];
+      }
+      return suggId;
+    });
+  };
+  TypeaheadEvent.prototype.getSublob = function (lob, sublob) {
+    sublob = Utils_1.Utils.getSubLob(lob, sublob);
+    return sublob ? "." + sublob : "";
+  };
+  TypeaheadEvent.prototype.getPageName = function (client, href) {
+    /* Cases:
+            Case 1: If Client = Homepage,
+                    then check for Href because currently we are getting Client=Homepage for landing page as well
+            Case 2: If Client is not Homepage
+                    then we first deduce the page name with client if found UNKNOWN then we use Href
+            Case 3: If Client is not present,
+                    then check the Href if it belongs to HomePage then resolve otherwise check for other possibility
+            Case 4: If client is not Homepage but the href is of Homepage(Special Case)
+         */
+    href = href.toLowerCase();
+    client = client.toLowerCase();
+    if (client && !(client.indexOf("homepage") !== -1)) {
+      var pageName = this.checkIfHomepage(href)
+        ? "Homepage"
+        : this.findPageName(client);
+      return pageName.indexOf("UNKNOWN") !== -1
+        ? this.findPageName(href)
+        : pageName;
+    } else {
+      return this.checkIfHomepage(href) ? "Homepage" : this.findPageName(href);
+    }
+  };
+  TypeaheadEvent.prototype.checkIfHomepage = function (href) {
+    // RegExp for homePage
+    // Match with https://www.expedia.co.in/ , https://www.travelocity.com/ and similar hrefs
+    var regex = new RegExp(
+      "^(https:\\/\\/)[a-zA-Z]{2,}\\.[a-zA-Z0-9]{1,61}\\.[a-zA-Z.]{2,}((\\/\\?)|\\/$)"
+    );
+    return regex.test(href);
+  };
+  TypeaheadEvent.prototype.findPageName = function (pageName) {
+    if (
+      pageName.indexOf("package") !== -1 ||
+      pageName.indexOf("packagetype") !== -1
+    ) {
+      return this.returnPageName("Packages", pageName);
+    }
+    if (pageName.indexOf("flight") !== -1) {
+      return this.returnPageName("Flights", pageName);
+    }
+    if (pageName.indexOf("hotel") !== -1) {
+      return this.returnPageName("Hotels", pageName);
+    }
+    if (pageName.indexOf("car") !== -1) {
+      return this.returnPageName("Cars", pageName);
+    }
+    if (
+      pageName.indexOf("lx") !== -1 ||
+      pageName.indexOf("activities") !== -1 ||
+      pageName.indexOf("things-to-do") !== -1
+    ) {
+      return this.returnPageName("Activities", pageName);
+    }
+    if (pageName.indexOf("rail") !== -1) {
+      return this.returnPageName("Rails", pageName);
+    }
+    return "UNKNOWN";
+  };
+  TypeaheadEvent.prototype.returnPageName = function (name, pathName) {
+    if (pathName.indexOf("search") !== -1) {
+      return name + ".Search";
+    }
+    return name + "LandingPage";
+  };
+  /*
+    This method is used to calculate the time spent by user on typeahead input box
+    It first calculate the timestamp and store it in case of blur event only.
+     */
+  TypeaheadEvent.prototype.calculateTimeSpendOnTypeaheadInput = function (
+    session
+  ) {
+    // @ts-ignore
+    var focus = session.focusTime;
+    this.typeaheadEvent.timestamps.timeFromFocusToBlur =
+      new Date().getTime() - new Date(focus).getTime();
+  };
+  return TypeaheadEvent;
+})();
+exports.TypeaheadEvent = TypeaheadEvent;
+//# sourceMappingURL=TypeaheadEvent.js.map