ouisys-engine 2.1.20 → 2.1.25

package/dist/features/strategies/categories/askOperator.js

@@ -0,0 +1,311 @@
+"use strict";
+
+require("core-js/modules/es.symbol");
+
+require("core-js/modules/es.array.filter");
+
+require("core-js/modules/es.object.get-own-property-descriptor");
+
+require("core-js/modules/es.object.get-own-property-descriptors");
+
+require("core-js/modules/es.object.keys");
+
+require("core-js/modules/es.object.to-string");
+
+require("core-js/modules/es.promise");
+
+require("core-js/modules/web.dom-collections.for-each");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectOperatorAction = exports.pin = exports.hePinOneClickAskOperator = exports.askOperator = void 0;
+
+require("regenerator-runtime/runtime");
+
+var _toolkit = require("@reduxjs/toolkit");
+
+var _strategies = require("../../../api/strategies");
+
+var _identifySlice = require("../identifySlice");
+
+var _identifySliceTypes = require("./typings/identifySliceTypes");
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : 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; }
+
+var oneClick = function oneClick(_ref) {
+  var flowObj = _ref.flowObj;
+
+  _identifySlice.tracker.sendOptInFlowEvent('3G click');
+
+  return {
+    type: _identifySliceTypes.StrategyStates.ONE_CLICK,
+    result: {},
+    nextData: {
+      config: flowObj.flowConfig,
+      operator: flowObj.operator
+    }
+  };
+};
+
+var pin = function pin(_ref2) {
+  var flowObj = _ref2.flowObj,
+      msisdn = _ref2.msisdn,
+      isHeaderEnrichmentSuccess = _ref2.isHeaderEnrichmentSuccess;
+
+  if (isHeaderEnrichmentSuccess !== true) {
+    _identifySlice.tracker.sendOptInFlowEvent('Pin');
+  } else {
+    _identifySlice.tracker.sendOptInFlowEvent('Hybrid Pin');
+  }
+
+  return {
+    type: _identifySliceTypes.StrategyStates.PIN,
+    result: {},
+    nextData: {
+      config: flowObj.flowConfig,
+      operator: flowObj.operator,
+      msisdn: msisdn,
+      isHeaderEnrichmentSuccess: isHeaderEnrichmentSuccess
+    }
+  };
+};
+
+exports.pin = pin;
+
+var moRedir = function moRedir(_ref3) {
+  var flowObj = _ref3.flowObj;
+
+  _identifySlice.tracker.sendOptInFlowEvent('Redirect');
+
+  return {
+    type: _identifySliceTypes.StrategyStates.MO_REDIR,
+    result: {},
+    nextData: {
+      config: flowObj.flowConfig,
+      operator: flowObj.operator
+    }
+  };
+};
+
+var click2sms = function click2sms(_ref4) {
+  var flowObj = _ref4.flowObj;
+
+  _identifySlice.tracker.sendOptInFlowEvent('Click to sms');
+
+  return {
+    type: _identifySliceTypes.StrategyStates.CLICK2SMS,
+    result: {},
+    nextData: {
+      config: _objectSpread({
+        operators: [flowObj.operator]
+      }, flowObj.flowConfig),
+      operator: flowObj.operator
+    }
+  };
+};
+
+var mo = function mo(_ref5) {
+  var flowObj = _ref5.flowObj;
+
+  _identifySlice.tracker.sendOptInFlowEvent('Msisdn to sms');
+
+  return {
+    type: _identifySliceTypes.StrategyStates.MO,
+    result: {},
+    nextData: {
+      config: flowObj.flowConfig,
+      operator: flowObj.operator
+    }
+  };
+};
+
+var hePinOneClickAskOperator = /*#__PURE__*/function () {
+  var _ref7 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(_ref6) {
+    var configs, flowObj, extraParams, strategyConfigs, defaultFlow, heResult, msisdn, operator, isHeaderEnrichmentSuccess;
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            configs = _ref6.configs, flowObj = _ref6.flowObj, extraParams = _ref6.extraParams;
+            strategyConfigs = configs.strategyConfigs;
+            defaultFlow = strategyConfigs.default;
+            _context.prev = 3;
+            _context.next = 6;
+            return (0, _strategies.identifyUser)({
+              configs: configs,
+              extraParams: extraParams
+            });
+
+          case 6:
+            heResult = _context.sent;
+            msisdn = heResult.msisdn;
+            operator = heResult.operator;
+            isHeaderEnrichmentSuccess = !!msisdn;
+            return _context.abrupt("return", pin({
+              flowObj: flowObj,
+              msisdn: msisdn,
+              operator: operator,
+              isHeaderEnrichmentSuccess: isHeaderEnrichmentSuccess
+            }));
+
+          case 13:
+            _context.prev = 13;
+            _context.t0 = _context["catch"](3);
+            console.warn(_context.t0);
+            return _context.abrupt("return", pin({
+              flowObj: defaultFlow
+            }));
+
+          case 17:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[3, 13]]);
+  }));
+
+  return function hePinOneClickAskOperator(_x) {
+    return _ref7.apply(this, arguments);
+  };
+}();
+
+exports.hePinOneClickAskOperator = hePinOneClickAskOperator;
+
+var askOperator = /*#__PURE__*/function () {
+  var _ref9 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(_ref8) {
+    var configs, operators;
+    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            configs = _ref8.configs;
+            operators = (0, _strategies.getOperators)({
+              configs: configs
+            });
+            return _context2.abrupt("return", {
+              type: _identifySliceTypes.StrategyStates.IDENTIFY_FLOW_BY_OPERATOR_SELECT,
+              result: {
+                operators: operators
+              }
+            });
+
+          case 3:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function askOperator(_x2) {
+    return _ref9.apply(this, arguments);
+  };
+}();
+
+exports.askOperator = askOperator;
+var selectOperatorAction = (0, _toolkit.createAsyncThunk)('strategy/selectOperatorAction',
+/*#__PURE__*/
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+function () {
+  var _ref10 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(payload, thunkApi) {
+    var configs, strategy, strategyConfigs, operator, defaultFlow, flowObj;
+    return regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            configs = payload.configs || (0, _strategies.getConfig)();
+            strategy = configs.strategy, strategyConfigs = configs.strategyConfigs;
+            operator = payload.operator;
+            defaultFlow = strategyConfigs.default;
+            _context3.prev = 4;
+            flowObj = (0, _strategies.determineFlowByOperator)({
+              configs: configs,
+              operator: operator
+            });
+            _context3.t0 = flowObj.flow;
+            _context3.next = _context3.t0 === 'pin' ? 9 : _context3.t0 === 'mo' ? 14 : _context3.t0 === 'moRedir' ? 15 : _context3.t0 === 'click2sms' ? 16 : _context3.t0 === 'oneClick' ? 17 : 18;
+            break;
+
+          case 9:
+            if (!(strategy === 'he-pin-one-click-ask-operator')) {
+              _context3.next = 13;
+              break;
+            }
+
+            _context3.next = 12;
+            return hePinOneClickAskOperator({
+              configs: configs,
+              flowObj: flowObj
+            });
+
+          case 12:
+            return _context3.abrupt("return", _context3.sent);
+
+          case 13:
+            return _context3.abrupt("return", pin({
+              flowObj: flowObj
+            }));
+
+          case 14:
+            return _context3.abrupt("return", mo({
+              flowObj: flowObj
+            }));
+
+          case 15:
+            return _context3.abrupt("return", moRedir({
+              flowObj: flowObj
+            }));
+
+          case 16:
+            return _context3.abrupt("return", click2sms({
+              flowObj: flowObj
+            }));
+
+          case 17:
+            return _context3.abrupt("return", oneClick({
+              flowObj: flowObj
+            }));
+
+          case 18:
+            console.error('selectOperatorAction', 'Strategy not supported');
+            return _context3.abrupt("return", pin({
+              flowObj: _objectSpread(_objectSpread({}, defaultFlow), {}, {
+                operator: flowObj.operator
+              })
+            }));
+
+          case 20:
+            _context3.next = 26;
+            break;
+
+          case 22:
+            _context3.prev = 22;
+            _context3.t1 = _context3["catch"](4);
+            console.error('identifySuselectOperatorActionbmitMSISDNAction', JSON.stringify(_context3.t1));
+            return _context3.abrupt("return", pin({
+              flowObj: _objectSpread({}, defaultFlow)
+            }));
+
+          case 26:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[4, 22]]);
+  }));
+
+  return function (_x3, _x4) {
+    return _ref10.apply(this, arguments);
+  };
+}());
+exports.selectOperatorAction = selectOperatorAction;