@cxco/dcx-connector/lib/buildRequest.js

A simple module to retrieve information from DigitalCX

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = buildRequest;

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/**
 *
 * @param {Object} eventPayload
 * @param {string} eventPayload.type - request type
 * @param {Object} eventPayload.data - request specific data
 * @param {Object} eventPayload.metadata - request specific metadata
 * @param {Object} eventPayload.config - request configuration
 * @returns Object
 */
function buildRequest(eventPayload) {
  var baseUrl = eventPayload.config.baseUrl;

  switch (eventPayload.type) {
    case 'ask':
      return getAskRequest(baseUrl, eventPayload);

    case 'dialogstep':
      return getDialogStepRequest(baseUrl, eventPayload);

    case 'event':
      return getEventRequest(baseUrl, eventPayload);

    case 'linkclick':
      return getLinkclickRequest(baseUrl, eventPayload);

    case 'feedback':
      return getFeedbackRequest(baseUrl, eventPayload);

    case 'faq':
      return getFaqRequest(baseUrl, eventPayload);

    case 'faqsincategory':
      return getFaqsByCatIdRequest(baseUrl, eventPayload);

    case 'defaultfaqs':
      return getDefaultFaqsByClassificationIdRequest(baseUrl, eventPayload);

    case 'categorytree':
      return getCategoriesTreeStructure(baseUrl, eventPayload);

    case 'category':
      return getCategoryRequest(baseUrl, eventPayload);

    case 'searchfaqs':
      return getFaqsBySearchRequest(baseUrl, eventPayload);

    case 'autocomplete':
      return getWordsFromDictionary(baseUrl, eventPayload);
  }

  console.error('not supported payload', eventPayload);
  return null;
}

function getAskRequest(baseUrl, eventPayload) {
  var query = _objectSpread({}, getRequiredQueryParams(eventPayload), {
    q: eventPayload.data.userInput
  });

  if (eventPayload.data.dialogPath) {
    query['session.dialogPath'] = eventPayload.data.dialogPath;
  }

  attachOptionalQueryParams(query, eventPayload);
  var headers = attachOptionalHeaders(eventPayload);
  return createGetRequest("".concat(baseUrl, "/ask"), query, headers, eventPayload.config.timeout);
}

function getDialogStepRequest(baseUrl, eventPayload) {
  var query = _objectSpread({}, getRequiredQueryParams(eventPayload), {
    path: eventPayload.data.dialogPath
  });

  attachOptionalQueryParams(query, eventPayload);
  var headers = attachOptionalHeaders(eventPayload);
  return createGetRequest("".concat(baseUrl, "/dialogstep"), query, headers, eventPayload.config.timeout);
}

function getEventRequest(baseUrl, eventPayload) {
  var query = getRequiredQueryParams(eventPayload);
  attachOptionalQueryParams(query, eventPayload);
  var headers = attachOptionalHeaders(eventPayload);
  return createGetRequest("".concat(baseUrl, "/event/").concat(eventPayload.data.eventName), query, headers, eventPayload.config.timeout);
}

function getLinkclickRequest(baseUrl, eventPayload) {
  var _eventPayload$data = eventPayload.data,
      linkId = _eventPayload$data.linkId,
      linkUrl = _eventPayload$data.linkUrl,
      interactionId = _eventPayload$data.interactionId;
  var headers = attachOptionalHeaders(eventPayload);
  return createPostRequest("".concat(baseUrl, "/linkclick"), getRequiredQueryParams(eventPayload), headers, {
    originInteractionId: interactionId,
    url: linkUrl,
    urlId: linkId
  }, eventPayload.config.timeout);
}

function getFeedbackRequest(baseUrl, eventPayload) {
  var _eventPayload$data2 = eventPayload.data,
      score = _eventPayload$data2.score,
      label = _eventPayload$data2.label,
      comment = _eventPayload$data2.comment,
      interactionId = _eventPayload$data2.interactionId;
  var headers = attachOptionalHeaders(eventPayload);
  return createPostRequest("".concat(baseUrl, "/feedback"), getRequiredQueryParams(eventPayload), headers, {
    originInteractionId: interactionId,
    score: score,
    label: label,
    comment: comment
  }, eventPayload.config.timeout);
}
/**
 * Builds Request to get an FAQ output
 * @param {string} baseUrl
 * @param {Object} eventPayload
 */


function getFaqRequest(baseUrl, eventPayload) {
  var query = getRequiredQueryParams(eventPayload);
  attachOptionalQueryParams(query, eventPayload);
  var headers = attachOptionalHeaders(eventPayload);
  return createGetRequest("".concat(baseUrl, "/faqs/").concat(eventPayload.data.faqId, "/output"), query, headers, eventPayload.config.timeout);
}
/**
 * Builds Request to get FAQs from a given CategoryId
 * @param {string} baseUrl
 * @param {object} eventPayload
 */


function getFaqsByCatIdRequest(baseUrl, eventPayload) {
  var query = getRequiredQueryParams(eventPayload);
  attachOptionalQueryParams(query, eventPayload);
  var headers = attachOptionalHeaders(eventPayload);
  /* remove classification id from query to avoid confusion
      * between page related faqs and contextual faqs */

  if (query.classificationId) {
    delete query.classificationId;
  }

  return createGetRequest("".concat(baseUrl, "/classifications/").concat(eventPayload.data.classificationId, "/categories/").concat(eventPayload.data.categoryId, "/faqs"), query, headers, eventPayload.config.timeout);
}
/**
 * Builds Request to get default FAQs from a given ClassificationId
 * @param {string} baseUrl
 * @param {object} eventPayload
 */


function getDefaultFaqsByClassificationIdRequest(baseUrl, eventPayload) {
  var query = _objectSpread({}, getRequiredQueryParams(eventPayload), {
    classificationId: eventPayload.data.classificationId
  });

  attachOptionalQueryParams(query, eventPayload);
  var headers = attachOptionalHeaders(eventPayload);
  return createGetRequest("".concat(baseUrl, "/faqs/default"), query, headers, eventPayload.config.timeout);
}
/**
 * Builds Request to get tree structure of the categories.
 * e.g. Get categories for a Classification containing the Page Related FAQs.
 * @param {string} baseUrl
 * @param {Object} eventPayload
 */


function getCategoriesTreeStructure(baseUrl, eventPayload) {
  var query = getRequiredQueryParams(eventPayload);
  attachOptionalQueryParams(query, eventPayload);
  var headers = attachOptionalHeaders(eventPayload);
  /* remove classification id from query to avoid confusion
  * between page related faqs and contextual faqs */

  if (query.classificationId) {
    delete query.classificationId;
  }

  return createGetRequest("".concat(baseUrl, "/classifications/").concat(eventPayload.data.classificationId, "/categories"), query, headers, eventPayload.config.timeout);
}
/**
 * Builds Request to get the category.
 * e.g. Get categories for a Classification containing the Page Related FAQs.
 * @param {string} baseUrl
 * @param {Object} eventPayload
 */


function getCategoryRequest(baseUrl, eventPayload) {
  var query = getRequiredQueryParams(eventPayload);
  var headers = attachOptionalHeaders(eventPayload);
  return createGetRequest("".concat(baseUrl, "/classifications/").concat(eventPayload.data.classificationId, "/categories/").concat(eventPayload.data.categoryId), query, headers, eventPayload.config.timeout);
}
/**
 * Builds Request to get FAQs from a given search text and classificationId
 * @param {string} baseUrl
 * @param {object} eventPayload
 */


function getFaqsBySearchRequest(baseUrl, eventPayload) {
  var query = _objectSpread({
    searchText: eventPayload.data.userInput,
    classificationId: eventPayload.data.classificationId
  }, getRequiredQueryParams(eventPayload));

  attachOptionalQueryParams(query, eventPayload);
  var headers = attachOptionalHeaders(eventPayload);
  return createGetRequest("".concat(baseUrl, "/faqs"), query, headers, eventPayload.config.timeout);
}

function getWordsFromDictionary(baseUrl, eventPayload) {
  var query = {
    text: eventPayload.data.userInput,
    apiKey: eventPayload.config.apiKey
  };
  attachOptionalQueryParams(query, eventPayload);
  var headers = attachOptionalHeaders(eventPayload);
  return createGetRequest("".concat(baseUrl, "/autocomplete/suggestions"), query, headers, eventPayload.config.timeout);
}

function getRequiredQueryParams(eventPayload) {
  var requiredParams = {
    apiKey: eventPayload.config.apiKey,
    culture: eventPayload.config.culture
  };

  if (eventPayload.metadata.sessionId) {
    requiredParams['session.id'] = eventPayload.metadata.sessionId;
  } // if projectkey and customerkey are in the eventPayload, then you're using the new baseurl


  if (eventPayload.config.customerKey && eventPayload.config.projectKey) {
    requiredParams.customerKey = eventPayload.config.customerKey;
    requiredParams.projectKey = eventPayload.config.projectKey;
  }

  return requiredParams;
}
/**
 * Adds optional parameters to the query object.
 * @param {Object} query
 * @param {Object} eventPayload
 */


function attachOptionalQueryParams(query, eventPayload) {
  if (eventPayload.metadata) {
    if (eventPayload.metadata.classificationId) {
      query.classificationId = eventPayload.metadata.classificationId;
    }

    if (eventPayload.metadata.minFaqs) {
      query.minFaqs = eventPayload.metadata.minFaqs;
    }

    if (eventPayload.metadata.maxFaqs) {
      query.maxFaqs = eventPayload.metadata.maxFaqs;
    }

    if (eventPayload.metadata.tDialogState) {
      query.tDialogState = eventPayload.metadata.tDialogState;
    }

    if (eventPayload.metadata.region) {
      query.region = eventPayload.metadata.region;
    }

    if (eventPayload.metadata.max) {
      query.max = eventPayload.metadata.max;
    }

    if (eventPayload.metadata.offset) {
      query.offset = eventPayload.metadata.offset;
    }

    if (Object.prototype.hasOwnProperty.call(eventPayload.metadata, 'includeFaqs')) {
      query.includefaqs = eventPayload.metadata.includeFaqs;
    }

    if (eventPayload.metadata.context && Array.isArray(eventPayload.metadata.context)) {
      eventPayload.metadata.context.forEach(function (dimension) {
        // TODO this could support adding more dimensions at once
        var newDim = Object.entries(dimension)[0];
        query["dim.".concat(newDim[0])] = newDim[1];
      });
    } // Session properties


    if (Object.prototype.hasOwnProperty.call(eventPayload.metadata, 'session') && typeof eventPayload.metadata.session !== 'undefined') {
      Object.entries(eventPayload.metadata.session).forEach(function (_ref) {
        var _ref2 = _slicedToArray(_ref, 2),
            key = _ref2[0],
            value = _ref2[1];

        query["session.".concat(key)] = value;
      });
    } // User properties


    if (Object.prototype.hasOwnProperty.call(eventPayload.metadata, 'user') && typeof eventPayload.metadata.user !== 'undefined') {
      Object.entries(eventPayload.metadata.user).forEach(function (_ref3) {
        var _ref4 = _slicedToArray(_ref3, 2),
            key = _ref4[0],
            value = _ref4[1];

        query["user.".concat(key)] = value;
      });
    } // TODO: sessionMode should be metadata.session.mode and the same for session.id


    if (Object.prototype.hasOwnProperty.call(eventPayload.metadata, 'sessionMode') && typeof eventPayload.metadata.sessionMode !== 'undefined') {
      query['session.mode'] = eventPayload.metadata.sessionMode;
    }
  }
}

function attachOptionalHeaders(payload) {
  var headers;

  if (payload.metadata.headers) {
    if (payload.metadata.headers.userAgent) {
      headers = headers || {};
      headers['User-Agent'] = payload.metadata.headers.userAgent;
    }

    if (payload.metadata.headers.referer) {
      headers = headers || {};
      headers.Referer = payload.metadata.headers.referer;
    }
  }

  return headers;
}
/**
 * Creates a GET payload
 * @param {string} url
 * @param {Object} query - query parameters
 * @param {Object} headers - headers
 * @param {number} timeout - in milliseconds
 */


function createGetRequest(url, query, headers, timeout) {
  var options = {
    method: 'get',
    url: url,
    query: query
  };

  if (typeof headers !== 'undefined') {
    options.headers = headers;
  }

  return createRequest(options, timeout);
}
/**
 * Creates a POST payload
 * @param {string} url
 * @param {Object} query - query parameters
 * @param {Object} headers - headers
 * @param {Object} data - data to be posted
 * @param {number} timeout - in milliseconds
 */


function createPostRequest(url, query, headers, data, timeout) {
  var options = {
    method: 'post',
    url: url,
    query: query,
    data: data
  };

  if (typeof headers !== 'undefined') {
    options.headers = headers;
  }

  return createRequest(options, timeout);
}
/**
 * Creates a payload containing request `config` and a `timeout`
 * @param {Object} config
 * @param {number} timeout - in milliseconds
 */


function createRequest(config, timeout) {
  return _objectSpread({}, config, {}, timeout && {
    timeout: timeout
  });
}