@zohodesk/platform-middleware/lib/utils.js

Generalized Contract for the events from Marketplace App, In-App widgets, CRM-Plus and EFC

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.handleEvent = handleEvent;
exports.isEventNeededToBroadCast = isEventNeededToBroadCast;
exports.validateConfig = validateConfig;
exports.zAppHookEvent = exports.zAppBroadcastEvent = void 0;

var _selectn = _interopRequireDefault(require("selectn"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }

function clearNonRuntimeWidgetInstances() {
  var allwidgetsInstance = ZApp.GetAllWidgetInstance();
  allwidgetsInstance = Object.keys(allwidgetsInstance);
  var widgetInstance = null;

  for (var i = 0; i < allwidgetsInstance.length; i++) {
    widgetInstance = ZApp.GetWidgetInstance(allwidgetsInstance[i]);

    if (widgetInstance.getIFrame() === null) {
      ZApp.DeleteWidgetInstance(allwidgetsInstance[i]);
    }
  }
}

function patchString(string, data) {
  if (!string || typeof string !== 'string') {
    throw new Error('Invalid String');
  }

  if (!data || _typeof(data) !== 'object') {
    throw new Error('Invalid Params object');
  }

  var patchedString = string.replace(/\{\{\w+\}\}?/g, function (match) {
    var key = match.replace(/[{{}}]/g, '');
    return data[key] || match;
  });
  return patchedString;
}

function isObject(obj) {
  return obj.constructor === {}.constructor;
} // function getComputedParams(paramsObj) {
//   return Object.keys(paramsObj.computeParams).reduce((result, param) => {
//     result[param] = selectn(patchString(paramsObj.computeParams[param], paramsObj.data), paramsObj.data);
//     return result;
//   }, {});
// }
// function paraseData(dataObj) {
//   return Object.keys(dataObj.params).reduce((result, param) => {
//     if (typeof dataObj.params[param] === "object") {
//       paraseData({
//         params: params[param],
//         data: dataObj.data
//       })
//     } else {
//       result[param] = selectn(patchString(dataObj.params[param], dataObj.data), dataObj.data);
//     }
//     return result;
//   }, {});
// }
// export function constructDataForEvent(dataObj) {
//   let computedParams = getComputedParams({ computeParams: dataObj.computeParams, data: dataObj.data });
//   computedParams = Object.assign({}, computedParams, dataObj.data);
//   return paraseData({ params: dataObj.params, data: computedParams });
// }
// export let zAppBroadcastEvent = (eventObj) => {
//   if (typeof ZApp !== 'undefined') {
//     clearNonRuntimeWidgetInstances();
//     ZApp.BroadcastEvent(eventObj.name, eventObj.data);
//   }
//   PlatformInstance.BroadcastEvent({ name: eventObj.name, data: eventObj.data })
// }


function isValidEventObj(eventObj) {
  return eventObj.eventName && eventObj.responseHandler && typeof eventObj.responseHandler == 'function' ? true : false;
}

function hasWidgetsForEvent(eventName) {
  return ZApp.GetWidgetsByEvent(eventName).length > 0 ? true : false;
}

function isEventNeededToBroadCast(eventObj) {
  return isValidEventObj(eventObj);
}

var zAppBroadcastEvent = function zAppBroadcastEvent(eventObj) {
  var getState = eventObj.getState,
      dispatch = eventObj.dispatch,
      action = eventObj.action,
      event = eventObj.event,
      getPrevState = eventObj.getPrevState;
  var responseHandler = event.responseHandler,
      eventName = event.eventName;

  if (typeof eventName == 'function') {
    eventName = eventName({
      action: action,
      getState: getState,
      getPrevState: getPrevState
    });
  }

  if (Array.isArray(eventName)) {
    eventName.map(function (name) {
      responseHandler(action, getState, dispatch, name, getPrevState).then(function (response) {
        if (typeof ZApp !== 'undefined') {
          clearNonRuntimeWidgetInstances();
          isObject(response) ? ZApp.BroadcastEvent(name, response) : null;
        }

        isObject(response) && typeof PlatformInstance != 'undefined' ? PlatformInstance.BroadcastEvent({
          name: name,
          data: response
        }) : null;
      });
    });
  } else {
    responseHandler(action, getState, dispatch, eventName, getPrevState).then(function (response) {
      if (typeof ZApp !== 'undefined') {
        clearNonRuntimeWidgetInstances();
        isObject(response) ? ZApp.BroadcastEvent(eventName, response) : null;
      }

      isObject(response) && typeof PlatformInstance != 'undefined' ? PlatformInstance.BroadcastEvent({
        name: eventName,
        data: response
      }) : null;
    });
  }
};

exports.zAppBroadcastEvent = zAppBroadcastEvent;

var zAppHookEvent = function zAppHookEvent(eventObj) {
  return new Promise(function (resolve, reject) {
    var getState = eventObj.getState,
        dispatch = eventObj.dispatch,
        action = eventObj.action,
        hook = eventObj.hook;
    var responseHandler = hook.responseHandler,
        eventName = hook.eventName;

    if (typeof eventName === 'function') {
      eventName = eventName({
        action: action,
        getState: getState
      });
    }

    responseHandler(action, getState, dispatch, eventName).then(function (hookData) {
      if (typeof ZApp !== 'undefined') {
        clearNonRuntimeWidgetInstances();
        var isTimeOutCalled = false,
            failedWidgets = [],
            eventListeners = ZApp.GetWidgetsByEvent(eventName);

        if (eventListeners.length > 0) {
          //TODO: Get the Hook Timing from the application
          var eventTimeout = setTimeout(function () {
            isTimeOutCalled = true;
            resolve(eventObj.action);
          }, 30000); //Third argument true is set because of Hook Event

          Promise.all(ZApp.BroadcastEvent(eventName, hookData, true)).then(function (response) {
            var content = null;

            if (!isTimeOutCalled) {
              clearTimeout(eventTimeout);
              response.map(function (widgetsResponse) {
                var widgetInstance = ZApp.GetWidgetInstance(widgetsResponse.widgetID);
                var widgetName = widgetInstance.getProp('title') || widgetInstance.getProp('name');
                var responseObj = widgetsResponse.response && widgetsResponse.response[0] || {};

                if (!responseObj.isSuccess) {
                  var widgetResult = responseObj.response || {};
                  var rejectTitle = widgetResult.title || '';
                  var shouldNotify = widgetResult.hasOwnProperty('shouldNotify') ? widgetResult.shouldNotify : true;

                  if (shouldNotify) {
                    var rejectMessage = widgetResult.msg || widgetResult.message || '';

                    if (rejectMessage && typeof rejectMessage === 'string') {
                      content = rejectMessage.trim();
                    } else {
                      content = "This widget has stopped the ".concat(eventName, " operation");
                    }
                  }

                  failedWidgets.push({
                    title: rejectTitle || widgetName,
                    content: content
                  });
                } else {
                  widgetsResponse.response[0].response == false ? failedWidgets.push({
                    title: widgetName,
                    content: "This widget has stopped the ".concat(eventName, " operation")
                  }) : null;
                }
              });

              if (failedWidgets.length) {
                failedWidgets.forEach(function (widget) {
                  if (widget.content) {
                    eventObj.notifyHandler({
                      title: widget.title,
                      content: widget.content
                    });
                  }

                  var hookRejectCallback = action.hookRejectCallback;

                  if (hookRejectCallback && typeof hookRejectCallback === 'function') {
                    hookRejectCallback();
                  }
                });
              } else {
                resolve(eventObj.action);
              }
            }
          })["catch"](function (err) {
            if (!isTimeOutCalled) {
              clearTimeout(eventTimeout);
              eventObj.notifyHandler({
                title: 'Hook Event Failed',
                content: "Some widget has stopped the ".concat(eventName, " hook event")
              });
              var hookRejectCallback = action.hookRejectCallback;

              if (hookRejectCallback && typeof hookRejectCallback === 'function') {
                hookRejectCallback();
              }
            }
          });
        } else {
          resolve(eventObj.action);
        }
      }
    })["catch"](function (err) {
      var hookRejectCallback = action.hookRejectCallback;

      if (hookRejectCallback && typeof hookRejectCallback === 'function') {
        hookRejectCallback(err);
      }

      reject(err);
    });
  });
};

exports.zAppHookEvent = zAppHookEvent;

function constructEventAndResponseObject(eventObj) {
  var info = {};

  if (eventObj.event.EVENT_FROM == 'PRODUCT') {
    info = {
      type: eventObj.event.type,
      value: eventObj.event.payload,
      property: eventObj.event.property
    };
  } else {
    info = {
      type: eventObj.event.data.type,
      value: eventObj.event.data.value,
      property: eventObj.event.data.property || null,
      iframe: eventObj.event.iframe
    };
  }

  function sendResponse(eventPromise, eventResponseObj) {
    var data = eventResponseObj.data;

    if (eventResponseObj.hasOwnProperty('status')) {
      eventResponseObj.status ? eventPromise.resolve(data) : eventPromise.reject({
        errMsg: data
      });
    }
  }

  return {
    info: info,
    sendResponse: sendResponse.bind(null, eventObj.event.promise)
  };
}

function constructWidgetObject(widgetId, extension_id) {
  var widgetInstance = ZApp.GetWidgetInstance(widgetId);
  return {
    id: widgetInstance.getProp('widgetId'),
    clientId: widgetId,
    title: widgetInstance.getProp('title') || widgetInstance.getProp('name'),
    extensionId: extension_id,
    location: widgetInstance.getLocation()
  };
}

function handleEvent(eventObj) {
  var _eventObj$event = eventObj.event,
      widgetID = _eventObj$event.widgetID,
      extension_id = _eventObj$event.extension_id;
  var constructedEventObject = {
    store: {
      getState: eventObj.getState,
      dispatch: eventObj.dispatch
    },
    patchString: patchString
  };

  if (widgetID && extension_id) {
    constructedEventObject.widget = constructWidgetObject(widgetID, extension_id);
  }

  constructedEventObject.event = constructEventAndResponseObject(eventObj);
  return constructedEventObject;
}

function validateConfig(config) {
  var errorMsg = null;

  if (config.featureFlags.isMarketplaceNeeded) {
    if (!config.hasOwnProperty('marketplace')) {
      errorMsg = 'marketplace object is missing';
    } else {
      if (!(config.marketplace.hasOwnProperty('renderHandler') && typeof config.marketplace.renderHandler === 'function')) {
        errorMsg = 'marketplace object should have renderHandler key with function as value';
      }

      if (!(config.marketplace.hasOwnProperty('postAssestsFetch') && typeof config.marketplace.postAssestsFetch === 'function')) {
        errorMsg = 'marketplace object should have postAssestsFetch key with function as value';
      }

      if (!(config.marketplace.hasOwnProperty('isDevMode') && typeof config.marketplace.isDevMode === 'function')) {
        errorMsg = 'marketplace object should have isDevMode key with function as value';
      }

      if (!(config.marketplace.hasOwnProperty('requestHandler') && typeof config.marketplace.requestHandler === 'function')) {
        errorMsg = 'marketplace object should have requestHandler key with function as value';
      }

      if (!(config.marketplace.hasOwnProperty('notifyHandler') && typeof config.marketplace.notifyHandler === 'function')) {
        errorMsg = 'marketplace object should have notifyHandler key with function as value';
      }
    }
  }

  if (!(config.hasOwnProperty('globalNameSpace') && typeof config.globalNameSpace === 'string')) {
    errorMsg = 'globalNameSpace key with string as value is missing';
  }

  if (!(config.hasOwnProperty('postProductSDKAssetsFetch') && typeof config.postProductSDKAssetsFetch === 'function')) {
    errorMsg = 'postProductSDKAssetsFetch key with function as value is missing';
  }

  if (!(config.hasOwnProperty('isPromiseBasedAction') && typeof config.isPromiseBasedAction === 'boolean')) {
    errorMsg = 'isPromiseBasedAction key with true/false as value is missing';
  }

  if (!(config.hasOwnProperty('locale') && typeof config.locale === 'string')) {
    errorMsg = 'locale key with string as value is missing';
  }

  if (!config.hasOwnProperty('eventListeners')) {
    errorMsg = 'eventListeners object is missing';
  } else {
    Object.keys(config.eventListeners).forEach(function (key) {
      if (!(typeof config.eventListeners[key] === 'function')) {
        errorMsg = 'every keys in eventListeners object should have function as value';
        return;
      }
    });
  }

  return {
    isConfigValid: errorMsg ? false : true,
    errorMsg: errorMsg
  };
}