@xuda.io/xuda-worker-bundle 1.3.1178 → 1.3.1180

package/index.js

@@ -7533,1778 +7533,7 @@ func.utils.set_SYS_GLOBAL_OBJ_WIDGET_INFO = async function (SESSION_ID, docP) {
   await func.datasource.update(SESSION_ID, datasource_changes);
 };
 
- func.events = {};
-func.events.validate = async function (
-  SESSION_ID,
-  triggerP,
-  dsSessionP,
-  eventIdP,
-  sourceP,
-  argumentsP,
-  return_validation_onlyP
-) {
-  var _session = SESSION_OBJ[SESSION_ID];
-  var _ds = _session.DS_GLB[dsSessionP];
-  var args = {
-    triggerP,
-    dsSessionP,
-    eventIdP,
-
-    sourceP,
-    argumentsP,
-    return_validation_onlyP,
-  };
-  const search_event_in_parent_ds = async function () {
-    if (_ds && typeof _ds.parentDataSourceNo !== "undefined") {
-      await func.events.validate(
-        SESSION_ID,
-        triggerP,
-        _ds.parentDataSourceNo,
-        eventIdP,
-        sourceP,
-        argumentsP,
-        return_validation_onlyP
-      );
-    }
-  };
-  var ret = false;
-  var jobs = [];
-
-  // var success;
-  if (_ds?.prog_id) {
-    const _view_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
-    // check view exist
-    if (!glb.IS_WORKER) _ds.event_stat_obj = {};
-
-    if (_view_obj.progEvents) {
-      if (_session.api_callback && eventIdP) {
-        _session.api_callback(eventIdP, SESSION_ID, SESSION_OBJ);
-      }
-      // check events has rows
-      for await (let val of _view_obj.progEvents) {
-        //run events rows
-        var eventProp = undefined;
-        if (val.data.type === triggerP) {
-          // compare event trigger
-          if (
-            (triggerP !== "user_defined") |
-            (triggerP === "user_defined" && eventIdP === val.data.event_name)
-          ) {
-            // compare user defined name
-
-            var expCond;
-            if (val.data.condition)
-              expCond = await func.expression.get(
-                SESSION_ID,
-                val.data.condition,
-                dsSessionP,
-                "condition"
-              );
-            if (!val.data.condition || expCond.result) {
-              func.utils.debug.watch(
-                SESSION_ID,
-                _ds.prog_id + "%" + val.id,
-                "view_event",
-                val,
-                triggerP + " " + eventIdP,
-                expCond
-              );
-              ret = true;
-              if (return_validation_onlyP) break;
-              const set_arguments = async function () {
-                var args = argumentsP || {};
-
-                for await (let [key, fieldId] of Object.entries(
-                  val.data.parameters
-                )) {
-                  const field_info = func.common.find_item_by_key(
-                    _view_obj.progFields,
-                    "field_id",
-                    fieldId
-                  );
-
-                  var value = await func.common.get_cast_val(
-                    SESSION_ID,
-                    "events",
-                    fieldId,
-                    field_info.props.fieldType,
-                    args[fieldId]
-                  );
-
-                  const ret = await func.datasource.get_value(
-                    SESSION_ID,
-                    fieldId,
-                    dsSessionP,
-                    _ds.currentRecordId
-                  );
-
-                  const datasource_changes = {
-                    [ret.dsSessionP]: {
-                      [ret.currentRecordId]: { [fieldId]: value },
-                    },
-                  };
-                  await func.datasource.update(SESSION_ID, datasource_changes);
-                }
-
-                add_event();
-              };
-              var add_event = function () {
-                const _event = func.common.find_item_by_key_root(
-                  _view_obj.progEvents,
-                  "id",
-                  val.id
-                );
-                if (_event.triggers) {
-                  // check if event property exist
-
-                  if (!_event.triggers || _.isEmpty(_event.triggers)) return;
-                  // check events has rows
-                  for (const trigger_obj of _event.triggers) {
-                    //run events rows
-                    if (!trigger_obj.data.action) continue;
-                    if (!trigger_obj.data.enabled) continue;
-                    // condition ok
-                    var callingEventId = val.data.event_name;
-                    if (!callingEventId) callingEventId = val.id; // default event id when event name is missing
-                    // eventProp = trigger_obj;
-
-                    // success = true;
-                    const ref_id = trigger_obj.data.name;
-
-                    var container = undefined;
-                    var screen_prop = undefined;
-                    if (!glb.IS_WORKER) {
-                      if (_ds.panel_div_id) {
-                        try {
-                          container = "#" + _ds.panel_div_id;
-                          if ($(container).data().xuData.panel_info) {
-                            screen_prop =
-                              $(container).data().xuData.panel_info.paramsP;
-                          } else {
-                            ///////////////
-                            container =
-                              "#" + _session.DS_GLB[dsSessionP].screenId;
-
-                            if ($(container) && $(container).data()) {
-                              screen_prop = $(container).data().xuData.paramsP;
-                            }
-
-                            if (!$(container) || !$(container).length) {
-                              container =
-                                "#" + _session.DS_GLB[dsSessionP].containerId;
-                            }
-                            //////////////
-                          }
-                        } catch (e) {
-                          console.error(e);
-                        }
-                      } else {
-                        container = "#" + _ds.screenId;
-
-                        if ($(container) && $(container).data()) {
-                          screen_prop = $(container).data().xuData.paramsP;
-                        }
-
-                        if (!$(container) || !$(container).length) {
-                          container = "#" + _ds.containerId;
-                        }
-                      }
-                    } else {
-                      screen_prop = {
-                        callingContainerP: _ds.containerId,
-                      };
-                    }
-
-                    jobs.push(
-                      func.events.add_to_queue(
-                        SESSION_ID,
-                        sourceP + " event",
-                        trigger_obj.id,
-                        null, // was click
-                        trigger_obj.data.action,
-                        ref_id,
-                        container,
-                        null,
-                        _ds.currentRecordId,
-                        null,
-                        trigger_obj.data.name,
-                        null,
-                        null,
-                        dsSessionP,
-                        null,
-                        null,
-                        trigger_obj,
-                        triggerP,
-                        screen_prop,
-                        null, // was target frame id
-                        null,
-                        trigger_obj,
-                        trigger_obj.data.parameter_source_data,
-                        val.id,
-                        null,
-                        args,
-                        null,
-                        null
-                      )
-                    );
-                  }
-                }
-              };
-              if (val.data.parameters) {
-                await set_arguments();
-              } else {
-                add_event();
-              }
-            } else {
-              if (val.data.condition && !expCond.result) {
-                func.utils.debug.watch(
-                  SESSION_ID,
-                  _ds.prog_id + "%" + val.id,
-                  "view_event",
-                  val,
-                  triggerP + " " + eventIdP,
-                  expCond,
-                  true
-                );
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  if (return_validation_onlyP) return ret;
-  if (!ret) await search_event_in_parent_ds();
-
-  return jobs;
-};
-func.events.add_to_queue = async function (
-  SESSION_ID,
-  typeP,
-  eventIdP,
-  triggerP,
-  functionP,
-  refIdP,
-  containerP,
-  elementP,
-  rowP,
-  NA_colP,
-  descP,
-  NA_rootScreenIdP,
-  NA_callingEventIdP,
-  dsSessionP,
-  NA_isInitP,
-  NA_calling_program,
-  event_propertiesP,
-  calling_triggerP,
-  paramsP,
-  NA_target_frame_idP,
-  _NA2,
-  calling_trigger_prop,
-  argumentsP,
-  source_event_idP,
-  calling_job,
-  args,
-  $div,
-  $container
-) {
-  var _session = SESSION_OBJ[SESSION_ID];
-  var obj = {
-    SESSION_ID,
-    typeP,
-    eventIdP,
-    triggerP,
-    functionP,
-    refIdP,
-    containerP,
-    elementP,
-    rowP,
-    descP,
-    dsSessionP,
-    event_propertiesP,
-    calling_triggerP,
-    paramsP,
-    calling_trigger_prop,
-    argumentsP,
-    source_event_idP,
-    calling_job,
-    args,
-    $div,
-    $container,
-
-    job_num: _session.WORKER_OBJ.num,
-  };
-  var _ds = _session.DS_GLB[dsSessionP];
-  if (typeof dsSessionP !== "undefined" && dsSessionP !== null) {
-    obj.prog_id = _ds.prog_id;
-    obj.parentDataSourceNo = _ds.parentDataSourceNo;
-    obj.nodeId = _ds.nodeId;
-  }
-  ///////
-  if (glb.IS_WORKER && func.utils.is_onscreen_event(functionP)) {
-    obj.client = true;
-    if (functionP === "call_library") {
-      obj.client = false;
-    }
-    if (typeof dsSessionP !== "undefined" && dsSessionP !== null) {
-      obj.ds_obj = func.utils.clean_returned_datasource(SESSION_ID, dsSessionP);
-    }
-    if (obj.client) {
-      _session.WORKER_OBJ.num++;
-      // if (!_session.IS_API)
-      func.utils.post_back_to_client(
-        SESSION_ID,
-        "job",
-        _session.worker_id,
-        obj
-      );
-      return;
-    }
-  }
-  ////////
-
-  if (calling_job) {
-    var job_index = func.events.find_job_index(SESSION_ID, calling_job);
-
-    try {
-      if (!_session.WORKER_OBJ.jobs[job_index].splice_count) {
-        _session.WORKER_OBJ.jobs[job_index].splice_count = 0;
-      }
-      _session.WORKER_OBJ.jobs[job_index].splice_count++;
-      _session.WORKER_OBJ.jobs.splice(
-        job_index + _session.WORKER_OBJ.jobs[job_index].splice_count,
-        0,
-        obj
-      );
-      // }
-    } catch (e) {
-      console.error("bug");
-      // _session.WORKER_OBJ.jobs.splice(0, 0, obj);
-    }
-  } else {
-    _session.WORKER_OBJ.jobs.push(obj);
-  }
-
-  _session.WORKER_OBJ.num++;
-  return _session.WORKER_OBJ.num - 1;
-};
-func.events.find_job_index = function (SESSION_ID, jobNoP) {
-  var _session = SESSION_OBJ[SESSION_ID];
-  var ret = null;
-  if (!_session.WORKER_OBJ) return ret;
-  _.forEach(_session.WORKER_OBJ.jobs, function (val, key) {
-    if (val && val.job_num == jobNoP) {
-      ret = key;
-      return false;
-    }
-  });
-  return ret;
-};
-func.events.execute = async function (
-  SESSION_ID,
-  jobNoP,
-  eventIdP,
-  triggerP,
-  functionP,
-  refIdP,
-  containerP,
-  elementP,
-  rowP,
-  NA_colP,
-  descP,
-  rootScreenIdP,
-  dsSessionP,
-  NA_callingEventIdP,
-  callingSourceP,
-  NA_isInitP,
-  event_propertiesP,
-  calling_triggerP,
-  calling_jobP,
-  paramsP,
-  NA_target_frame_idP,
-  calling_trigger_prop,
-  NA_calling_program,
-  argumentsP,
-  NA_viewIdP,
-  NA_nodeIdP,
-  NA_parentDataSourceNoP,
-  $div
-) {
-  var _session = SESSION_OBJ[SESSION_ID];
-  var _ds = _session.DS_GLB[dsSessionP];
-  if (functionP === "update") refIdP = null; // in case of left over when program changing from call function to update
-
-  var job_index = func.events.find_job_index(SESSION_ID, jobNoP);
-  if (_session.WORKER_OBJ.jobs?.[job_index]?.stat === "busy") {
-    if (jobNoP) _session.WORKER_OBJ.stat = job_index;
-    return;
-  }
-  if (jobNoP && !_session.WORKER_OBJ.jobs[job_index]) {
-    _session.WORKER_OBJ.stat = null;
-    return;
-  }
-
-  if (jobNoP) _session.WORKER_OBJ.stat = job_index;
-
-  if (jobNoP && calling_trigger_prop?.props?.async) {
-    func.events.delete_job(SESSION_ID, jobNoP);
-    _session.WORKER_OBJ.stat = null;
-  }
-
-  if (_session.WORKER_OBJ.jobs[job_index]) {
-    _session.WORKER_OBJ.jobs[job_index].stat = "busy";
-  }
-
-  var dsSession = dsSessionP; // new 2020420
-  var field_elm = elementP;
-
-  var calling_field_id = field_elm;
-  if (field_elm && typeof field_elm === "object")
-    calling_field_id = field_elm.attr("xu-ui-id");
-
-  var log_nodeId;
-  var log_prog_id;
-  var log_source;
-
-  if (_session.DS_GLB[dsSession]?.prog_id)
-    log_prog_id = _session.DS_GLB[dsSession].prog_id;
-  log_nodeId = log_prog_id + "_" + eventIdP;
-  var log_prop = callingSourceP;
-  if (callingSourceP === "system event") {
-    log_prop = "global event";
-  }
-  if (calling_field_id) {
-    const _view_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
-    let _field_obj = func.common.find_item_by_key(
-      _view_obj.progFields,
-      "field_id",
-      calling_field_id
-    );
-    log_nodeId = log_prog_id + "_" + eventIdP + "_" + _field_obj?.id;
-
-    log_source = calling_field_id;
-  }
-  if (elementP) {
-    log_prop = triggerP;
-    log_nodeId = log_nodeId + "_ui_prop"; //+"_"+eventIdP;
-  }
-  //check condition
-  var expCond;
-  if (event_propertiesP) {
-    // conditional event
-    if (event_propertiesP?.props?.condition) {
-      expCond = await func.expression.get(
-        SESSION_ID,
-        event_propertiesP.props.condition,
-        dsSession,
-        "condition",
-        null,
-        null,
-        null,
-        calling_field_id ? calling_field_id : calling_triggerP,
-        null,
-        descP
-      ); // execute expression
-      func.utils.debug.log(SESSION_ID, log_nodeId, {
-        module: "event",
-        action: log_prop,
-        source: log_source,
-        prop: descP,
-        details: event_propertiesP.props.condition,
-        result: expCond.result,
-        error: expCond.error,
-        fields: expCond.fields,
-        type: "event",
-        prog_id: log_prog_id,
-        conditional: true,
-      });
-      var cond = expCond.result;
-      if (!cond || expCond.error) {
-        // condition failed // === true 03/04/16
-        func.events.delete_job(SESSION_ID, jobNoP);
-
-        func.utils.debug.watch(
-          SESSION_ID,
-          calling_trigger_prop?.id,
-          functionP,
-          "",
-          "",
-          expCond,
-          true
-        );
-        return;
-      }
-    } // Non conditional event
-    else {
-      func.utils.debug.log(SESSION_ID, log_nodeId, {
-        module: "event",
-        action: log_prop,
-        source: log_source,
-        prop: descP,
-        details: null,
-        result: null,
-        error: null,
-        fields: null,
-        type: "event",
-        prog_id: log_prog_id,
-      });
-    }
-  }
-
-  // var log_error = function (descP, detailsP, warning) {
-  //   func.utils.debug.log(SESSION_ID, log_nodeId, {
-  //     module: "event",
-  //     action: functionP,
-  //     source: log_source,
-  //     prop: descP,
-  //     details: detailsP,
-  //     result: null,
-  //     error: !warning,
-  //     warning: warning,
-  //     fields: null,
-  //     type: "event",
-  //     prog_id: log_prog_id,
-  //   });
-  // };
-
-  const get_params_obj = async function () {
-    const _prog = await func.utils.VIEWS_OBJ.get(
-      SESSION_ID,
-      await get_prog_id()
-    );
-    if (!_prog) {
-      func.events.delete_job(SESSION_ID, jobNoP);
-      return func.utils.debug_report(
-        SESSION_ID,
-        "func.events.execute",
-        "Program not found: " + refIdP.prog,
-        "E"
-      );
-    }
-
-    // get in parameters
-    var params_obj = {};
-    if (_prog?.properties?.progParams) {
-      for await (const [key, val] of Object.entries(
-        _prog.properties.progParams
-      )) {
-        if (!val.data.dir === "in") continue;
-        if (
-          typeof args.parameters_obj_inP?.[val.data.parameter] !== "undefined"
-        ) {
-          if (args.parameters_obj_inP?.[val.data.parameter].fx) {
-            let ret = await func.expression.get(
-              SESSION_ID,
-              args.parameters_obj_inP?.[val.data.parameter].fx,
-              dsSession,
-              "parameters"
-            );
-            params_obj[val.data.parameter] = ret.result;
-          } else {
-            params_obj[val.data.parameter] =
-              args.parameters_obj_inP?.[val.data.parameter].value;
-          }
-          continue;
-        }
-        console.warn(
-          `Warning: Program ${_prog.properties.menuName} expected In parameter: ${val.data.parameter} but received null instead`
-        );
-      }
-    }
-    return params_obj;
-  };
-
-  const get_prog_id = async function () {
-    let _prop = args?.calling_trigger_prop?.data?.name?.properties;
-    let _prog_id = args.prog_id;
-    if (_prop?.["xu-exp:prog"]) {
-      _prog_id = (
-        await func.expression.get(
-          SESSION_ID,
-          _prop["xu-exp:prog"],
-          dsSession,
-          "prog_id expression"
-        )
-      ).result;
-    }
-
-    return _prog_id;
-  };
-  // const get_args_property_value = async function (prop_name) {
-  //   let _prop = args?.calling_trigger_prop?.data?.name;
-  //   let _value = _prop[prop_name];
-  //   if (_prop?.[`xu-exp:${prop_name}`]) {
-  //     _value = (
-  //       await func.expression.get(
-  //         SESSION_ID,
-  //         _prop[`xu-exp:${prop_name}`],
-  //         dsSession,
-  //         `${prop_name} expression`
-  //       )
-  //     ).result;
-  //   }
-
-  //   return _value;
-  // };
-
-
-  var args = {
-    prog_id: refIdP?.prog,
-    screenIdP: refIdP?.prog,
-    callingFieldIdP: field_elm,
-    dataSourceNoP: null,
-    parentDataSourceNoP: dsSession,
-    triggerIdP: eventIdP,
-    containerIdP: null,
-    rowIdP: rowP, //sub_row_idP ? sub_row_idP : rowP,
-    jobNoP: jobNoP,
-
-    callingSourceP: callingSourceP,
-    calling_jobP: calling_jobP,
-    screen_dsP: null,
-    is_panelP: null,
-    argument_listP: null,
-    calling_trigger_prop: calling_trigger_prop,
-    parameters_obj_inP: refIdP?.parameters,
-    call_screen_propertiesP: refIdP?.properties,
-  };
-
-  const fx = {
-    Call_window: async function () {
-      var is_panel;
-      var $calling_container;
-      if (_session.WORKER_OBJ.jobs[job_index]) {
-        if (_session.WORKER_OBJ.jobs[job_index].paramsP) {
-          $calling_container = $(
-            "#" + _session.WORKER_OBJ.jobs[job_index].paramsP.callingContainerP
-          );
-        } else {
-          $calling_container = ""; // calling from datasource 0
-          _session.WORKER_OBJ.jobs[job_index].paramsP = {};
-        }
-      }
-
-      if (!refIdP.prog) {
-        func.events.delete_job(SESSION_ID, jobNoP);
-        return func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          "Program is empty",
-          "E"
-        );
-      }
-
-      const params_obj = await get_params_obj();
-      return await func.UI.screen.init(
-        SESSION_ID,
-        await get_prog_id(),
-        $(containerP)?.data()?.xuData.screenId,
-        _session.DS_GLB[dsSession],
-        $calling_container,
-        eventIdP,
-        rowP,
-        jobNoP,
-        is_panel,
-        params_obj,
-        functionP,
-        args.call_screen_propertiesP
-      );
-    },
-    call_modal: async function () {
-      return await fx.Call_window();
-    },
-    call_popover: async function () {
-      return await fx.Call_window();
-    },
-    call_page: async function () {
-      return await fx.Call_window();
-    },
-    call_library: async function () {
-      let plugin_name = refIdP.plugin_name,
-        method = refIdP.library_method,
-        $containerP = $div,
-        dsP = dsSession,
-        propsP = refIdP.library_props,
-        sourceP = descP;
-
-      var _session = SESSION_OBJ[SESSION_ID];
-
-      const set_SYS_GLOBAL_OBJ_WIDGET_INFO = async function (docP) {
-        var obj = _.clone(docP);
-        obj.date = await func.utils.get_dateTime(
-          SESSION_ID,
-          "SYS_DATE",
-          docP.date
-        );
-        obj.time = await func.utils.get_dateTime(
-          SESSION_ID,
-          "SYS_TIME",
-          docP.date
-        );
-
-        var datasource_changes = {
-          [0]: {
-            ["data_system"]: {
-              ["SYS_GLOBAL_OBJ_WIDGET_INFO"]: obj,
-            },
-          },
-        };
-        await func.datasource.update(SESSION_ID, datasource_changes);
-      };
-      const call_plugin_api = async function (plugin_nameP, dataP) {
-        return await func.utils.call_plugin_api(
-          SESSION_ID,
-          plugin_nameP,
-          dataP
-        );
-      };
-      const report_error = function (descP, warn) {
-        func.utils.debug.log(
-          SESSION_ID,
-          _session.DS_GLB[dsP].prog_id +
-          "_" +
-          _session.DS_GLB[dsP].callingMenuId,
-          {
-            module: "widgets",
-            action: "Init",
-            source: sourceP,
-            prop: descP,
-            details: descP,
-            result: null,
-            error: warn ? false : true,
-            fields: null,
-            type: "widgets",
-            prog_id: _session.DS_GLB[dsP].prog_id,
-          }
-        );
-      };
-      const get_fields_data = async function (fields, props) {
-        const report_error = function (descP, warn) {
-          func.utils.debug.log(
-            SESSION_ID,
-            _session.DS_GLB[dsP].prog_id +
-            "_" +
-            _session.DS_GLB[dsP].callingMenuId,
-            {
-              module: "widgets",
-              action: "Init",
-              source: sourceP,
-              prop: descP,
-              details: descP,
-              result: null,
-              error: warn ? false : true,
-              fields: null,
-              type: "widgets",
-              prog_id: _session.DS_GLB[dsP].prog_id,
-            }
-          );
-        };
-        const get_property_value = async function (fieldIdP, val) {
-          // var value = props[fieldIdP];
-
-          var value =
-            props[fieldIdP] ||
-            (typeof val.defaultValue === "function"
-              ? val?.defaultValue?.()
-              : val?.defaultValue);
-
-          if (props[`xu-exp:${fieldIdP}`]) {
-            value = (
-              await func.expression.get(
-                SESSION_ID,
-                props[`xu-exp:${fieldIdP}`],
-                dsP,
-                "widget property"
-              )
-            ).result;
-          }
-
-          return func.common.get_cast_val(
-            SESSION_ID,
-            "widgets",
-            fieldIdP,
-            val.type, //val.type !== "string" || val.type !== "number" ? "string" : val.type,
-            value,
-            null
-          );
-        };
-        var data_obj = {};
-        var return_code = 1;
-        // $.each(fields, function (key, val) {
-        for await (const [key, val] of Object.entries(fields)) {
-          try {
-            data_obj[key] = await get_property_value(key, val);
-            if (!data_obj[key] && val.mandatory) {
-              return_code = -1;
-              report_error(`${key} is a mandatory field.`);
-              break;
-            }
-            // console.log(val);
-          } catch (error) {
-            debugger;
-          }
-        }
-        return { code: return_code, data: data_obj };
-      };
-
-      try {
-        const _plugin =
-          APP_OBJ[_session.app_id]?.app_plugins_purchased?.[plugin_name];
-
-        const index = await func.utils.get_plugin_resource(
-          SESSION_ID,
-          plugin_name,
-          `${_plugin.manifest["index.mjs"].dist ? "dist/" : ""}index.mjs`
-        );
-
-        const methods = index.methods;
-        if (methods && !methods[method]) {
-          return report_error("method not found");
-        }
-
-        const fields_ret = await get_fields_data(
-          methods[method].fields,
-          propsP
-        );
-
-        if (fields_ret.code < 0) {
-          return report_error(fields_ret.data);
-        }
-        const fields = fields_ret.data;
-
-        const plugin_setup_ret = await func.utils.get_plugin_setup(
-          SESSION_ID,
-          plugin_name
-        );
-        if (plugin_setup_ret.code < 0) {
-          return report_error(plugin_setup_ret);
-        }
-
-        const api_utils = await func.common.get_module(
-          SESSION_ID,
-          "xuda-api-library.mjs",
-          {
-            func,
-            glb,
-            SESSION_OBJ,
-            SESSION_ID,
-            APP_OBJ,
-            dsSession: dsP,
-            job_id: jobNoP,
-          }
-        );
-
-        const params = {
-          SESSION_ID,
-          method,
-          _session,
-          dsP,
-          sourceP,
-          propsP,
-          plugin_name,
-          $containerP,
-          plugin_setup: plugin_setup_ret.data,
-
-          report_error,
-          call_plugin_api,
-          set_SYS_GLOBAL_OBJ_WIDGET_INFO,
-          api_utils,
-        };
-
-        const fx = await func.utils.get_plugin_resource(
-          SESSION_ID,
-          plugin_name,
-          `${_plugin.manifest["runtime.mjs"].dist ? "dist/" : ""}runtime.mjs`
-        );
-
-        if (!fx[method]) {
-          throw `Method: ${method} does not exist`;
-        }
-        await fx[method](fields, params);
-      } catch (err) {
-        report_error(err);
-      }
-
-      func.events.delete_job(SESSION_ID, jobNoP);
-    },
-
-    call_native_javascript: async function () {
-      const module = await func.common.get_module(
-        SESSION_ID,
-        "xuda-event-javascript-module.mjs"
-      );
-      return await module.call_javascript(
-        SESSION_ID,
-        jobNoP,
-        refIdP,
-        dsSession
-      );
-    },
-    call_evaluate_javascript: async function () {
-      const module = await func.common.get_module(
-        SESSION_ID,
-        "xuda-event-javascript-module.mjs"
-      );
-      return await module.call_javascript(
-        SESSION_ID,
-        jobNoP,
-        refIdP,
-        dsSession,
-        true
-      );
-    },
-    execute_native_javascript: async function () {
-      const module = await func.common.get_module(
-        SESSION_ID,
-        "xuda-event-javascript-module.mjs"
-      );
-
-      const result = await module.run_javascript(
-        SESSION_ID,
-        jobNoP,
-        dsSession,
-        `(async function(el) {
-          ${refIdP.value}
-          })(document.querySelector(\`[xu-ui-id=${elementP}]\`))`
-      );
-      return result
-    },
-    execute_evaluate_javascript: async function () {
-      const module = await func.common.get_module(
-        SESSION_ID,
-        "xuda-event-javascript-module.mjs"
-      );
-
-      return await module.run_javascript(
-        SESSION_ID,
-        jobNoP,
-        dsSession,
-        `(async function(el) {
-          ${refIdP.value}
-          })(document.querySelector(\`[xu-ui-id=${elementP}]\`))`,
-        true
-      );
-    },
-    loader_on: async function () {
-      glb.CURRENT_APP_LOADING = null;
-      LOADER_ACTIVE = true;
-      LOADER_TEXT = descP;
-      // }
-      func.events.delete_job(SESSION_ID, jobNoP);
-      // if (callbackP) callbackP();
-    },
-    loader_off: async function () {
-      LOADER_ACTIVE = false;
-
-      func.events.delete_job(SESSION_ID, jobNoP);
-      // if (callbackP) callbackP();
-    },
-    emit_event: async function () {
-      if (refIdP.value) {
-        //  if (descP.value) {
-        $(document).trigger(refIdP.value, [_session.DS_GLB[dsSession]]);
-      } else {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          "Event name missing",
-          "E"
-        );
-      }
-      func.events.delete_job(SESSION_ID, jobNoP);
-      // if (callbackP) callbackP();
-    },
-
-    invoke_action: async function () {
-      func.utils.debug.watch(
-        SESSION_ID,
-        calling_trigger_prop?.id,
-        functionP,
-        null,
-        null,
-        expCond
-      );
-
-      await func.action.execute(
-        SESSION_ID,
-        refIdP.value,
-        _ds,
-        null,
-        null,
-        jobNoP,
-        containerP
-      );
-    },
-    raise_event: async function () {
-      var _ds = _session.DS_GLB[dsSession];
-      const _view_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
-      if (callingSourceP === "grid" || callingSourceP === "form") {
-        let _field_obj = func.common.find_item_by_key(
-          _view_obj.progFields,
-          "field_id",
-          field_elm
-        );
-        var event_name = _field_obj?.triggers?.[eventIdP].name.event;
-
-        if (_field_obj?.triggers?.[eventIdP].name?.properties["xu-exp:event"]) {
-          event_name = (
-            await func.expression.get(
-              SESSION_ID,
-              props[`xu-exp:event`],
-              dsSession,
-              "event_name expression"
-            )
-          ).result;
-        }
-
-        if (field_elm && event_name) {
-          // get container for fields events
-          const dsP = await func.datasource.find_event_dataSource(
-            SESSION_ID,
-            event_name,
-            dsSession
-          );
-
-          return await func.datasource.run_events_functions(
-            SESSION_ID,
-            dsP,
-            event_name,
-            jobNoP,
-            null
-          );
-        }
-        // done_execution(event_name);
-      }
-      if (callingSourceP.includes("event")) {
-        let event_name = refIdP.event;
-
-        if (refIdP?.properties?.["xu-exp:event"]) {
-          event_name = (
-            await func.expression.get(
-              SESSION_ID,
-              refIdP.properties["xu-exp:event"],
-              dsSession,
-              "event_name expression"
-            )
-          ).result;
-        }
-
-        const dsP = await func.datasource.find_event_dataSource(
-          SESSION_ID,
-          event_name,
-          dsSession
-        );
-
-        await func.datasource.run_events_functions(
-          SESSION_ID,
-          dsP,
-          event_name,
-          jobNoP,
-          null
-        );
-        // done_execution(event_name);
-      }
-
-      func.events.delete_job(SESSION_ID, jobNoP);
-      // if (callbackP) callbackP();
-
-      func.utils.debug.watch(
-        SESSION_ID,
-        calling_trigger_prop?.id,
-        functionP,
-        "",
-        "",
-        expCond
-      );
-    },
-    get_data: async function () {
-      const params_obj = await get_params_obj();
-
-      if (!(await get_prog_id())) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          `${elementP} > ${triggerP} > ${functionP} > program ${prog} is missing`,
-          "E"
-        );
-        func.events.delete_job(SESSION_ID, jobNoP);
-        return;
-      }
-
-      var _ds = _session.DS_GLB[dsSession];
-      if (!_ds) {
-        func.events.delete_job(SESSION_ID, jobNoP);
-        return;
-      }
-
-      // args.prog_id = _viewId;
-      if (_ds) {
-        func.utils.debug.watch(
-          SESSION_ID,
-          calling_trigger_prop?.id,
-          functionP,
-          null,
-          calling_trigger_prop,
-          expCond
-        );
-        // }
-        const ret = await func.datasource.create(
-          SESSION_ID,
-          await get_prog_id(),
-          args.dataSourceNoP,
-          args.parentDataSourceNoP,
-          args.containerIdP,
-          args.rowIdP,
-          args.jobNoP,
-          args.calling_trigger_prop,
-          null,
-          null,
-          args.callingSourceP,
-          args.calling_jobP,
-          args.screen_dsP,
-          args.is_panelP,
-          params_obj
-        );
-
-        let _ds_new = _session.DS_GLB[ret.dsSessionP];
-        let parameters = args?.calling_trigger_prop?.data?.name?.parameters;
-        if (parameters && !_.isEmpty(parameters)) {
-          await func.datasource.update_changes_for_out_parameter(
-            SESSION_ID,
-            _ds_new.dsSession,
-            _ds.dsSession
-          );
-        }
-        // if (parameters && !_.isEmpty(parameters) && _ds_new.PARAM_OUT_INFO) {
-        //   let data = {};
-        //   for await (const [key, val] of Object.entries(
-        //     _ds_new.PARAM_OUT_INFO
-        //   )) {
-        //     if (val.prop === "out") {
-        //       try {
-        //         const row_idx = func.common.find_ROWID_idx(
-        //           _ds_new,
-        //           _ds_new.currentRecordId
-        //         );
-        //         data[val.details] =
-        //           _ds_new.data_feed.rows[row_idx][val.fieldId];
-        //       } catch (err) {
-        //         console.error(err);
-        //       }
-        //     }
-        //   }
-        //   if (!_.isEmpty(data)) {
-        //     let datasource_changes = {
-        //       [_ds.dsSession]: { [_ds.currentRecordId]: data },
-        //     };
-        //     await func.datasource.update(SESSION_ID, datasource_changes);
-        //   }
-        // }
-
-        func.events.delete_job(SESSION_ID, jobNoP);
-        return _ds_new
-      }
-    },
-    set_data: async function () {
-      return this.get_data();
-    },
-    batch: async function () {
-      const result = await this.get_data();
-      debugger
-      // await set_outputField(SESSION_ID, elementP, triggerP, functionP, dsSessionP, result);
-      return result
-
-    },
-    update: async function () {
-      const obj_values_to_update =
-        func.datasource.get_viewFields_for_update_function(
-          SESSION_ID,
-          calling_trigger_prop,
-          null,
-          dsSessionP
-        );
-      if (!obj_values_to_update || _.isEmpty(obj_values_to_update)) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "Update values object is empty",
-          "",
-          "W"
-        );
-        if (jobNoP) func.events.delete_job(SESSION_ID, jobNoP);
-        return;
-      }
-      var updates = [];
-
-      for await (const [key, val] of Object.entries(obj_values_to_update)) {
-        var $element;
-
-        if (elementP) {
-          $element = $(`[xu-ui-id="${elementP}"]`).clone(true);
-        }
-
-        let ret_field_id = await func.expression.get(
-          SESSION_ID,
-          val.id.trim(),
-          dsSessionP,
-          "update",
-          null,
-          null,
-          null,
-          null,
-          null,
-          null,
-          $element?.length ? $element?.data()?.xuData?.iterate_info : null
-        );
-        let ret_value = await func.expression.get(
-          SESSION_ID,
-          val.val.trim(),
-          dsSessionP,
-          "update",
-          null,
-          null,
-          null,
-          null,
-          null,
-          null,
-          $element?.length ? $element?.data()?.xuData?.iterate_info : null
-        );
-        let _field_id = ret_field_id.result;
-        let _value = ret_value.result;
-
-        updates.push({ _field_id, _value });
-      }
-
-      let datasource_changes = {};
-      for await (const change of updates) {
-        let ret_get_value = await func.datasource.get_value(
-          SESSION_ID,
-          change._field_id,
-          dsSessionP
-        );
-        if (ret_get_value.found) {
-          let _ds = _session.DS_GLB[ret_get_value.dsSessionP];
-          if (!datasource_changes[_ds.dsSession]) {
-            datasource_changes[_ds.dsSession] = {};
-          }
-          if (
-            !datasource_changes[_ds.dsSession][ret_get_value.currentRecordId]
-          ) {
-            datasource_changes[_ds.dsSession][ret_get_value.currentRecordId] =
-              {};
-          }
-          datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][
-            change._field_id
-          ] = change._value;
-        }
-      }
-
-      await func.datasource.update(SESSION_ID, datasource_changes);
-      if (jobNoP) func.events.delete_job(SESSION_ID, jobNoP);
-      // return changes;
-    },
-    call_alert: async function () {
-      await func.utils.alerts.invoke(
-        SESSION_ID,
-        "call_alert",
-        refIdP,
-        log_source,
-        dsSession
-      );
-      func.events.delete_job(SESSION_ID, jobNoP);
-    },
-    alert: async function () {
-      await func.utils.alerts.invoke(
-        SESSION_ID,
-        "alert",
-        refIdP,
-        log_source,
-        dsSession
-      );
-      func.events.delete_job(SESSION_ID, jobNoP);
-    },
-    delay: async function () {
-      return new Promise((resolve) => {
-        setTimeout(function () {
-          if (jobNoP) func.events.delete_job(SESSION_ID, jobNoP);
-          resolve();
-        }, refIdP.value);
-      });
-    },
-    comment: async function () {
-      if (jobNoP) func.events.delete_job(SESSION_ID, jobNoP);
-    },
-    call_project_api: async function () {
-      const params_obj = await get_params_obj();
-      const _prog_id = await get_prog_id();
-
-      if (!_prog_id) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          `${elementP} > ${triggerP} > ${functionP} > program not defined`,
-          "E"
-        );
-        func.events.delete_job(SESSION_ID, jobNoP);
-        return;
-      }
-
-      // const output_field = await get_args_property_value("outputField");
-
-      // if (!output_field) {
-      //   func.utils.debug_report(
-      //     SESSION_ID,
-      //     "func.events.execute",
-      //     `${elementP} >${triggerP} >${functionP} > Output field not defined`,
-      //     "W"
-      //   );
-      //   // func.events.delete_job(SESSION_ID, jobNoP);
-      //   // return;
-      // }
-
-      const api_ret = await func.api.call_project_api(_prog_id, params_obj);
-
-      await func.datasource.set_outputField(SESSION_ID, dsSessionP, api_ret);
-
-      // if (output_field) {
-      //   let datasource_changes = {};
-
-      //   let ret_get_value = await func.datasource.get_value(
-      //     SESSION_ID,
-      //     output_field,
-      //     dsSessionP
-      //   );
-      //   if (ret_get_value.found) {
-      //     let _ds = _session.DS_GLB[ret_get_value.dsSessionP];
-      //     if (!datasource_changes[_ds.dsSession]) {
-      //       datasource_changes[_ds.dsSession] = {};
-      //     }
-      //     if (
-      //       !datasource_changes[_ds.dsSession][ret_get_value.currentRecordId]
-      //     ) {
-      //       datasource_changes[_ds.dsSession][ret_get_value.currentRecordId] =
-      //         {};
-      //     }
-      //     datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][
-      //       output_field
-      //     ] = api_ret;
-      //     await func.datasource.update(SESSION_ID, datasource_changes);
-      //   }
-      // }
-      func.events.delete_job(SESSION_ID, jobNoP);
-    },
-    call_system_api: async function () {
-      const api_method = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "api_method");
-
-      if (!api_method) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          `${elementP} >${triggerP} >${functionP} > api_method not defined`,
-          "E"
-        );
-        func.events.delete_job(SESSION_ID, jobNoP);
-        return;
-      }
-      let payload = {};
-      const _payload = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "payload");
-      if (_payload) {
-        const get_payload_property_value = async function (prop_name) {
-          let _prop = _payload;
-          let _value = _prop[prop_name];
-          if (_prop?.[`xu-exp:${prop_name}`]) {
-            _value = (
-              await func.expression.get(
-                SESSION_ID,
-                _prop[`xu-exp:${prop_name}`],
-                dsSession,
-                `${prop_name} expression`
-              )
-            ).result;
-          }
-
-          return _value;
-        };
-
-        for await (let [key, val] of Object.entries(_payload)) {
-          // if (key.substring(0, 7) !== "xu-exp:") {
-          const new_key = key.replaceAll("xu-exp:", ""); //key.substring(0, 7) === "xu-exp:" ? key.substring(7): key
-          payload[new_key] = await get_payload_property_value(new_key);
-          // }
-        }
-      }
-
-      // if (!payload) {
-      //   func.utils.debug_report(
-      //     SESSION_ID,
-      //     "func.events.execute",
-      //     `${elementP} >${triggerP} >${functionP} > payload not defined`,
-      //     "E"
-      //   );
-      //   func.events.delete_job(SESSION_ID, jobNoP);
-      //   return;
-      // }
-
-      const output_field = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "outputField");
-
-      // if (!output_field) {
-      //   func.utils.debug_report(
-      //     SESSION_ID,
-      //     "func.events.execute",
-      //     `${elementP} >${triggerP} >${functionP} > Output field not defined`,
-      //     "E"
-      //   );
-      //   func.events.delete_job(SESSION_ID, jobNoP);
-      //   return;
-      // }
-
-      const api_ret = await func.api.call_system_api(api_method, payload);
-      if (output_field) {
-        let datasource_changes = {};
-
-        let ret_get_value = await func.datasource.get_value(
-          SESSION_ID,
-          output_field,
-          dsSessionP
-        );
-        if (ret_get_value.found) {
-          let _ds = _session.DS_GLB[ret_get_value.dsSessionP];
-          if (!datasource_changes[_ds.dsSession]) {
-            datasource_changes[_ds.dsSession] = {};
-          }
-          if (
-            !datasource_changes[_ds.dsSession][ret_get_value.currentRecordId]
-          ) {
-            datasource_changes[_ds.dsSession][ret_get_value.currentRecordId] =
-              {};
-          }
-          datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][
-            output_field
-          ] = api_ret;
-          await func.datasource.update(SESSION_ID, datasource_changes);
-        }
-      }
-      func.events.delete_job(SESSION_ID, jobNoP);
-    },
-    call_external_api: async function () {
-      const method = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "method");
-
-      if (!method) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          `${elementP} >${triggerP} >${functionP} > method not defined`,
-          "E"
-        );
-        func.events.delete_job(SESSION_ID, jobNoP);
-        return;
-      }
-
-      const url = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "url");
-
-      if (!url) {
-        func.utils.debug_report(
-          SESSION_ID,
-          "func.events.execute",
-          `${elementP} >${triggerP} >${functionP} > url not defined`,
-          "E"
-        );
-        func.events.delete_job(SESSION_ID, jobNoP);
-        return;
-      }
-
-      const payload_arr = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "payload");
-
-      const report_conversion_error = function (res, typeP, valP) {
-        var msg = `${elementP} >${triggerP} >${functionP} > error converting from ${valP} to ${typeP}`;
-        if (error) {
-          return func.utils.debug_report(SESSION_ID, msg, "", "W");
-        }
-        func.utils.debug_report(
-          SESSION_ID,
-          msg + " " + _.capitalize(source) + prog_info,
-          "",
-          "E"
-        );
-      };
-      const report_conversion_warn = function (res) {
-        var msg = `${elementP} >${triggerP} >${functionP} > type mismatch auto conversion from value ${valP} to ${typeP}`;
-        func.utils.debug_report(
-          SESSION_ID,
-          msg + " " + _.capitalize(source) + prog_info,
-          "",
-          "W"
-        );
-      };
-      // var ret = valP;
-      if (error) {
-        return report_conversion_error();
-      }
-
-      const module = await func.common.get_module(
-        SESSION_ID,
-        "xuda-get-cast-util-module.mjs"
-      );
-      // return module.cast(
-      //   typeP,
-      //   valP,
-      //   report_conversion_error,
-      //   report_conversion_warn
-      // );
-
-      var payload = _.reduce(
-        payload_arr,
-        (ret, val, key) => {
-          ret[val.key] = module.cast(
-            val.type,
-            val.val,
-            report_conversion_error,
-            report_conversion_warn
-          );
-
-          return ret;
-        },
-        {}
-      );
-      // if (!payload) {
-      //   func.utils.debug_report(
-      //     SESSION_ID,
-      //     "func.events.execute",
-      //     `${elementP} >${triggerP} >${functionP} > payload not defined`,
-      //     "E"
-      //   );
-      //   func.events.delete_job(SESSION_ID, jobNoP);
-      //   return;
-      // }
-
-      const output_field = await func.datasource.get_args_property_value(SESSION_ID, dsSession, args, "outputField");
-
-      // if (!output_field) {
-      //   func.utils.debug_report(
-      //     SESSION_ID,
-      //     "func.events.execute",
-      //     `${elementP} >${triggerP} >${functionP} > Output field not defined`,
-      //     "E"
-      //   );
-      //   func.events.delete_job(SESSION_ID, jobNoP);
-      //   return;
-      // }
-
-      const api_ret = await func.api.call_external_api(method, url, payload);
-      if (output_field) {
-        let datasource_changes = {};
-
-        let ret_get_value = await func.datasource.get_value(
-          SESSION_ID,
-          output_field,
-          dsSessionP
-        );
-        if (ret_get_value.found) {
-          let _ds = _session.DS_GLB[ret_get_value.dsSessionP];
-          if (!datasource_changes[_ds.dsSession]) {
-            datasource_changes[_ds.dsSession] = {};
-          }
-          if (
-            !datasource_changes[_ds.dsSession][ret_get_value.currentRecordId]
-          ) {
-            datasource_changes[_ds.dsSession][ret_get_value.currentRecordId] =
-              {};
-          }
-          datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][
-            output_field
-          ] = api_ret;
-          await func.datasource.update(SESSION_ID, datasource_changes);
-        }
-      }
-      func.events.delete_job(SESSION_ID, jobNoP);
-    },
-  };
-  // if (functionP.includes("alert")) {
-  //   return await fx.alert();
-  // } else {
-  // try {
-  // console.log("functionP", functionP);
-  return await fx[functionP]();
-  // } catch (err) {
-  //   console.error(err);
-  //   debugger;
-  // }
-  // }
-};
-
-func.events.delete_job = function (SESSION_ID, jobNoP) {
-  var _session = SESSION_OBJ[SESSION_ID];
-  var job_index = func.events.find_job_index(SESSION_ID, jobNoP);
-
-  // console.log(jobNoP, job_index);
-  if (!_session.WORKER_OBJ.jobs[job_index]) {
-    _session.WORKER_OBJ.stat = null;
-    return;
-  }
-
-  var dsSession = _session.WORKER_OBJ.jobs[job_index].dsSessionP;
-  let ds_obj = _session?.DS_GLB[dsSession];
-  if (ds_obj) {
-    delete SCREEN_BLOCKER_OBJ[
-      ds_obj.screenId +
-      (ds_obj.callingScreenId ? "_" + ds_obj.callingScreenId : "")
-    ];
-  }
-  if (
-    dsSession &&
-    ds_obj?.loops_limit &&
-    ds_obj?.loops_count < ds_obj?.loops_limit - 1
-  ) {
-    return;
-  }
-  _session.WORKER_OBJ.stat = null;
-
-  _session.WORKER_OBJ.jobs.splice(job_index, 1);
-};
-func.events.delete_job_0 = function (SESSION_ID) {
-  var job_index = 0;
-  var _session = SESSION_OBJ[SESSION_ID];
-  if (!_session.WORKER_OBJ.jobs[job_index]) {
-    _session.WORKER_OBJ.stat = null;
-    return;
-  }
-
-  var dsSession = _session.WORKER_OBJ.jobs[job_index].dsSession;
-  let ds_obj = _session?.DS_GLB[dsSession];
-  if (ds_obj) {
-    delete SCREEN_BLOCKER_OBJ[
-      ds_obj.screenId +
-      (ds_obj.callingScreenId ? "_" + ds_obj.callingScreenId : "")
-    ];
-  }
-  if (
-    dsSession &&
-    ds_obj &&
-    ds_obj.loops_limit &&
-    ds_obj.loops_count < ds_obj.loops_limit - 1
-  ) {
-    return;
-  }
-  _session.WORKER_OBJ.stat = null;
-
-  _session.WORKER_OBJ.jobs.splice(job_index, 1);
-};
-func.events.check_jobs_idle = async function (SESSION_ID, jobsP) {
-  return new Promise((resolve, reject) => {
-    var _session = SESSION_OBJ[SESSION_ID];
-    if (!jobsP || (jobsP && jobsP.length === 0)) {
-      resolve();
-      return;
-    }
-    var listener = setInterval(function () {
-      var found;
-      for (const [key, val] of Object.entries(jobsP)) {
-        _.forEach(_session.WORKER_OBJ.jobs, function (val2, key2) {
-          if (key2 === val) {
-            found = true;
-            return false;
-          }
-        });
-      }
-      if (!found) {
-        do_callback();
-        return;
-      }
-    }, 100);
-    var do_callback = function () {
-      window.clearInterval(listener);
-      resolve();
-    };
-  });
-};
-
-var loop_detected_obj = {};
-setInterval(function () {
-  loop_detected_obj = {};
-}, 1000);
-
-func.events.set_browser_changes = function (dsP, fieldsChangedP) {
-  if (fieldsChangedP.includes("SYS_GLOBAL_STR_BROWSER_TITLE"))
-    document.title = dsP.dataset_new["SYS_GLOBAL_STR_BROWSER_TITLE"];
-};
-
-func.events.execute_PENDING_OPEN_URL_EVENTS = async function () {
-  for (let [key, url] of Object.entries(PENDING_OPEN_URL_EVENTS)) {
-    if (url) {
-      glb.WINDOW_LOCATION_SEARCH = url;
-      glb.ROOT_ELEMENT_ATTRIBUTES = func.UI.utils.get_root_element_attributes();
-
-      const params_obj = func.common.getObjectFromUrl(
-        url,
-        glb.ROOT_ELEMENT_ATTRIBUTES
-      );
-      if (!params_obj.prog) {
-        return console.warn("prog empty");
-      }
-
-      await func.utils.TREE_OBJ.get(SESSION_ID, params_obj.prog);
-      let screen_ret = await func.utils.get_screen_obj(
-        SESSION_ID,
-        params_obj.prog
-      );
-
-      if (screen_ret) {
-        await func.UI.screen.init(
-          SESSION_ID,
-          params_obj.prog,
-          null,
-          null,
-          $("#embed_" + SESSION_ID),
-          null,
-          null,
-          null,
-          null,
-          null,
-          "pendingUrlEvent_embed"
-        );
-      } else {
-        console.error("Program not exist", params_obj.prog_id);
-        func.UI.utils.progressScreen.show(
-          SESSION_ID,
-          "Program not exist",
-          null,
-          true
-        );
-      }
-    } else {
-      console.warn("url empty");
-    }
-  }
-};
-func.events.invoke = async function (event_id) {
-  var _session = SESSION_OBJ[SESSION_ID];
-  if (!event_id) {
-    console.warn("event_id Cannot be empty");
-    return false;
-  }
-  var ds;
-  for await (const [ds_key, val] of Object.entries(_session.DS_GLB)) {
-    const _view_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, val.prog_id);
-    if (_.isEmpty(_view_obj.progEvents)) continue;
-    if (ds) break;
-    for await (const [key, val] of Object.entries(_view_obj.progEvents)) {
-      if (
-        val?.data?.type === "user_defined" &&
-        val.data.event_name === event_id
-      ) {
-        ds = ds_key;
-        break;
-      }
-    }
-  }
-
-  if (!ds) {
-    console.warn("event_id not found");
-    return false;
-  }
-
-  func.events.validate(SESSION_ID, "user_defined", ds, event_id);
-};
- func.expression = {};
+  func.expression = {};
 
 func.expression.get = async function (
   SESSION_ID,