@wavemaker/react-runtime 11.14.1-rc.236

package/variables/service-variable.js

@@ -0,0 +1,307 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._setInput = exports.ServiceVariable = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _baseVariable = require("./base-variable");
+var _lodashEs = require("lodash-es");
+var _common = require("@wavemaker/react-runtime/core/util/common");
+var _variables = require("@wavemaker/variables");
+var _useHttp = require("@wavemaker/react-runtime/hooks/useHttp");
+var _formatUtil = require("../utils/format-util");
+var _eventNotifier = _interopRequireDefault(require("@wavemaker/react-runtime/core/event-notifier"));
+function _createSuper(t) { var r = _isNativeReflectConstruct(); return function () { var e, o = (0, _getPrototypeOf2["default"])(t); if (r) { var s = (0, _getPrototypeOf2["default"])(this).constructor; e = Reflect.construct(o, arguments, s); } else e = o.apply(this, arguments); return (0, _possibleConstructorReturn2["default"])(this, e); }; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var _ServiceVariableEvents = /*#__PURE__*/function (_ServiceVariableEvents) {
+  _ServiceVariableEvents["BEFORE_INVOKE"] = "beforeInvoke";
+  return _ServiceVariableEvents;
+}(_ServiceVariableEvents || {});
+var ServiceVariable = exports.ServiceVariable = /*#__PURE__*/function (_ServiceVariable3) {
+  (0, _inherits2["default"])(ServiceVariable, _ServiceVariable3);
+  var _super = _createSuper(ServiceVariable);
+  function ServiceVariable(config) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, ServiceVariable);
+    // Initialize with minimal configuration first
+    var variableConfig = {
+      name: config.name,
+      dataSet: config.paramProvider(),
+      // Default empty value
+      dataBinding: {},
+      firstRecord: {},
+      lastRecord: {},
+      isList: config.isList,
+      service: config.service,
+      serviceType: config.serviceType,
+      maxResults: config.maxResults,
+      _context: config._context,
+      operation: config.operation,
+      operationId: config.operationId,
+      operationType: config.operationType,
+      controller: config.controller,
+      serviceInfo: config.getServiceInfo(),
+      httpClientService: _useHttp.httpService,
+      inFlightBehavior: config.inFlightBehavior,
+      spinnerMessage: config.spinnerMessage,
+      spinnerContext: config.spinnerContext,
+      onSuccess: function onSuccess(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        _this.notify(_baseVariable.VariableEvents.SUCCESS, [args.variable, args.data, args.options]);
+        _this.updateFirstAndLastRecord(args.data);
+        return config.onSuccess && config.onSuccess(args.variable, args.data, args.options);
+      },
+      onError: function onError(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        _this.notify(_baseVariable.VariableEvents.ERROR, [args.variable, args.data, args.options]);
+        _eventNotifier["default"].ROOT.notify("SERVICE_ERROR", [args.variable, args.data, args.options]);
+        return config.onError && config.onError(args.variable, args.data, args.options);
+      },
+      onCanUpdate: function onCanUpdate(context, args) {
+        return config.onCanUpdate && config.onCanUpdate(args.variable, args.data, args.options);
+      },
+      onBeforeUpdate: function onBeforeUpdate(context, args) {
+        _this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [args.variable, args.inputData, args.options]);
+        return config.onBeforeUpdate && config.onBeforeUpdate(args.variable, args.inputData, args.options);
+      },
+      onResult: function onResult(context, args) {
+        return config.onResult && config.onResult(args.variable, args.data, args.options);
+      },
+      onBeforeDatasetReady: function onBeforeDatasetReady(context, args) {
+        return config.onBeforeDatasetReady && config.onBeforeDatasetReady(args.variable, args.data, args.options);
+      }
+    };
+    _this = _super.call(this, variableConfig);
+
+    // Set up event handlers
+    _this.config = config;
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "cancelTokenSource", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "initialized", false);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "params", undefined);
+    _this.setupEventHandlers(config);
+    return _this;
+  }
+  // Method to update firstRecord and lastRecord from the current dataset
+  (0, _createClass2["default"])(ServiceVariable, [{
+    key: "updateFirstAndLastRecord",
+    value: function updateFirstAndLastRecord(data) {
+      try {
+        var dataSet = this.dataSet;
+        var isList = this.isList;
+        if (isList && Array.isArray(dataSet)) {
+          // For list variables, set firstRecord and lastRecord to the actual first and last items
+          this.firstRecord = dataSet.length > 0 ? dataSet[0] : {};
+          this.lastRecord = dataSet.length > 0 ? dataSet[dataSet.length - 1] : {};
+        } else {
+          // For non-list variables, firstRecord and lastRecord are the same as the dataset
+          this.firstRecord = dataSet || {};
+          this.lastRecord = dataSet || {};
+        }
+      } catch (error) {
+        console.error("Error updating firstRecord and lastRecord:", error);
+      }
+    }
+  }, {
+    key: "initialize",
+    value: function () {
+      var _initialize = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this.completeInitialization();
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function initialize() {
+        return _initialize.apply(this, arguments);
+      }
+      return initialize;
+    }()
+  }, {
+    key: "setupEventHandlers",
+    value: function setupEventHandlers(config) {
+      // Implementation for setting up event handlers
+    }
+  }, {
+    key: "completeInitialization",
+    value: function () {
+      var _completeInitialization = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              // Complete the initialization with actual data
+              this.dataSet = this.config.paramProvider();
+              this.serviceInfo = this.config.getServiceInfo();
+              this.init();
+            case 3:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function completeInitialization() {
+        return _completeInitialization.apply(this, arguments);
+      }
+      return completeInitialization;
+    }()
+  }, {
+    key: "invokeOnParamChange",
+    value: function () {
+      var _invokeOnParamChange = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var _this2 = this;
+        var last, latest;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              last = this.params;
+              latest = (0, _lodashEs.merge)({}, this.config.paramProvider(), this.dataBinding);
+              if (!(!(0, _lodashEs.isEqual)(last, latest) && latest !== undefined && !(0, _lodashEs.isEmpty)(latest))) {
+                _context3.next = 11;
+                break;
+              }
+              _context3.prev = 3;
+              _context3.next = 6;
+              return new Promise(function (resolve, reject) {
+                _this2.invoke(latest, function (data) {
+                  return resolve(data);
+                }, function (error) {
+                  return reject(error);
+                });
+              });
+            case 6:
+              _context3.next = 11;
+              break;
+            case 8:
+              _context3.prev = 8;
+              _context3.t0 = _context3["catch"](3);
+              console.error("Error in invokeOnParamChange:", _context3.t0);
+            case 11:
+              return _context3.abrupt("return", this);
+            case 12:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[3, 8]]);
+      }));
+      function invokeOnParamChange() {
+        return _invokeOnParamChange.apply(this, arguments);
+      }
+      return invokeOnParamChange;
+    }()
+  }, {
+    key: "doNext",
+    value: function () {
+      var _doNext = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        var _this3 = this;
+        var page;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              page = 0;
+              if ((0, _lodashEs.isString)(this.pagination.page)) {
+                page = parseInt(this.pagination.page) + 1 + "";
+              } else {
+                page = this.pagination.page + 1;
+              }
+              return _context4.abrupt("return", new Promise(function (resolve, reject) {
+                _this3.invoke({
+                  page: page
+                }, function (dataset) {
+                  return resolve(dataset);
+                }, reject);
+              }));
+            case 3:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function doNext() {
+        return _doNext.apply(this, arguments);
+      }
+      return doNext;
+    }()
+  }, {
+    key: "onDataUpdated",
+    value: function onDataUpdated() {
+      console.log("called in onDataUpdated");
+    }
+  }, {
+    key: "invoke",
+    value: function invoke(options, onSuccess, onError) {
+      this.params = (0, _lodashEs.merge)({}, this.params, this.config.paramProvider());
+      this.params = (0, _common.deepCopy)({}, this.params, this.dataBinding);
+      if (options) {
+        this.params = (0, _common.deepCopy)({}, this.params, options.inputFields ? options.inputFields : options);
+      }
+      options = options || {};
+      options.inputFields = this.params;
+
+      // Get the latest service definition
+      this.serviceInfo = this.config.getServiceInfo();
+      if (!this.serviceInfo) {
+        console.error("Service Info is missing for (".concat(this.name, ") variable."));
+      }
+      return (0, _get2["default"])((0, _getPrototypeOf2["default"])(ServiceVariable.prototype), "invoke", this).call(this, options, onSuccess, onError);
+    }
+  }, {
+    key: "setInput",
+    value: function setInput(key, val, options) {
+      this.params = (0, _lodashEs.merge)({}, _setInput(this.params, key, val, options));
+      return this.params;
+    }
+  }]);
+  return ServiceVariable;
+}(_variables.ServiceVariable);
+var _setInput = exports._setInput = function _setInput(targetObj, key, val, options) {
+  targetObj = targetObj || {};
+  var keys,
+    lastKey,
+    paramObj = {};
+
+  // content type check
+  if ((0, _lodashEs.isObject)(options)) {
+    // @ts-ignore
+    switch (options.type) {
+      case "file":
+        //val = getBlob(val, options.contentType);
+        break;
+      case "number":
+        val = (0, _lodashEs.isNumber)(val) ? val : parseInt(val, 10);
+        break;
+    }
+  }
+  if ((0, _lodashEs.isObject)(key)) {
+    // check if the passed parameter is an object itself
+    paramObj = key;
+  } else if (key.indexOf(".") > -1) {
+    // check for '.' in key e.g. 'employee.department'
+    keys = key.split(".");
+    lastKey = keys.pop();
+    // Finding the object based on the key
+    targetObj = (0, _formatUtil.findValueOf)(targetObj, keys.join("."), true);
+    key = lastKey;
+    paramObj[key] = val;
+  } else {
+    paramObj[key] = val;
+  }
+  (0, _lodashEs.forEach)(paramObj, function (paramVal, paramKey) {
+    targetObj[paramKey] = paramVal;
+  });
+  return targetObj;
+};