impaktapps-ui-builder 1.0.80-schema.0 → 1.0.80-schema.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "impaktapps-ui-builder",
-    "version": "1.0.80-schema.0",
+    "version": "1.0.80-schema.2",
     "scripts": {
         "dev": "vite",
         "build": "tsc && vite build",

package/src/impaktapps-ui-builder/runtime/services/service.ts

@@ -92,25 +92,21 @@ export default (funcParams: funcParamsProps) => {
         functionsProvider: funcParams.functionsProvider,
         serviceHolder: this, eventGroups, formDataHolder
       }
+
+      funcParams.store.setSchema(
+        (pre: any) => {
+          return {
+            ...schema, ...pre, properties:
+              { ...schema.properties, ...pre.properties, }
+          }
+        }
+      )
       await executeRefreshHandler({
         config: {}, componentName: "",
         store: funcParams.store, dynamicData: funcParams.dynamicData, userValue: funcParams.userValue, service: funcParams.service,
         serviceHolder: this, eventGroups, formDataHolder: {}
       })
-     funcParams.store.setSchema((pre: any) => {
-        const updatedSchema = {
-          ...schema,
-          ...pre,
-          properties: {
-            ...schema.properties,
-            ...pre.properties,
-          },
-        };
-
-        funcParams.store.tempSchema = updatedSchema;
-
-        return updatedSchema;
-      });
+  
       uiSchema.elements.push(notifyUiSchema);
       funcParams.store.setUiSchema(uiSchema);
     },

package/src/impaktapps-ui-builder/runtime/services/serviceTest.tsx

@@ -0,0 +1,265 @@
+import _, { isEmpty } from "lodash";
+import { doDownload, downloadFile } from "./downloadFile";
+import { executeEvents, executeRefreshHandler } from "./events";
+import { handlersProps } from "./interface";
+let compType: string;
+let eventGroups: any = {};
+const notifyUiSchema = {
+  type: "Control",
+  scope: "#/properties/notify",
+  options: {
+    widget: "Notify",
+  },
+  layout: 6,
+};
+
+interface funcParamsProps {
+  store: any,
+  dynamicData: any,
+  service: any,
+  userValue: any,
+  pageDataProvider: any,
+  functionsProvider?: Record<string, any>,
+  initFormData?: any
+}
+let pageData: any = false;
+export const extractEvents = (eventConfig: any) => {
+  function extractsConfigEvents(eventConfigObj: any) {
+    if (eventConfigObj.events) {
+      eventConfigObj.events.forEach((event: any) => {
+        if (eventConfigObj.type) {
+          compType = eventConfigObj.type;
+        }
+        if (!eventGroups[event.eventType]) {
+          eventGroups[event.eventType] = {};
+        }
+        if (!eventGroups[event.eventType][eventConfigObj.name]) {
+          eventGroups[event.eventType][eventConfigObj.name] = [];
+        }
+        const SuccessEvent = event?.events?.find((elem) => {
+          return elem.eventType === "Success"
+        })
+        if (!(!!SuccessEvent) && event.eventType === "onLoad") {
+          if (!(!!event.events)) {
+            event.events = [];
+          }
+          event.events.push({ Handler: "mergeFormdata", eventType: "Success", type: compType, lazyLoading: eventConfig.lazyLoading === "YES" ? true : false })
+        }
+        if (!(!!SuccessEvent) && (event.eventType === "onBack" || event.eventType === "onNext" || event.eventType === "onReset")) {
+          if (!(!!event.events)) {
+            event.events = [];
+          }
+          event.events.push({ Handler: `${event.eventType}Handler`, eventType: "Success", type: compType, lazyLoading: eventConfig.lazyLoading === "YES" ? true : false })
+        }
+        eventGroups[event.eventType][eventConfigObj.name].push({ ...event, type: compType })
+      });
+    }
+  }
+  extractsConfigEvents(eventConfig)
+  if (eventConfig?.elements) {
+    eventConfig.elements.forEach(extractEvents);
+  }
+  return eventGroups;
+};
+export default (funcParams: funcParamsProps) => {
+  const formDataHolder = {}
+  let executeEventsParameters: handlersProps = {
+    config: {}, componentName: "",
+    store: funcParams.store, dynamicData: funcParams.dynamicData, userValue: funcParams.userValue, service: funcParams.service,
+    serviceHolder: { downloadFile, download: doDownload, ...funcParams.functionsProvider }, eventGroups,
+    functionsProvider: funcParams.functionsProvider, formDataHolder
+  };
+  return {
+    setPage: async function () {
+      funcParams.store.setAdditionalErrors([]);
+      funcParams.store.setFormdata(funcParams?.initFormData() || {});
+      funcParams.store.setSchema({ type: "object", properties: {} });
+      funcParams.store.newData = {};
+      eventGroups = {};
+      pageData = await funcParams.pageDataProvider();
+      const config = pageData?.config;
+      const uiSchema = pageData?.uiSchema;
+      const event = new CustomEvent('pageNameChanged', {
+        detail: { pageName: config.label, hasBackIcon: config.hasBackIcon === "NO" ? false : true }
+      });
+      window.dispatchEvent(event)
+      const theme = funcParams?.store?.theme?.myTheme;
+      const schema = pageData?.schema ?? { type: "object", properties: {} };
+      eventGroups = extractEvents(config);
+      executeEventsParameters = {
+        config: {}, componentName: "",
+        store: funcParams.store, dynamicData: funcParams.dynamicData, userValue: funcParams.userValue, service: funcParams.service,
+        functionsProvider: funcParams.functionsProvider,
+        serviceHolder: this, eventGroups, formDataHolder
+      }
+      await executeRefreshHandler({
+        config: {}, componentName: "",
+        store: funcParams.store, dynamicData: funcParams.dynamicData, userValue: funcParams.userValue, service: funcParams.service,
+        serviceHolder: this, eventGroups, formDataHolder: {}
+      })
+     funcParams.store.setSchema((pre: any) => {
+        const updatedSchema = {
+          required: [...(schema.required||[]), ...(pre.required||[])],
+          properties: {
+            ...schema.properties,
+            ...pre.properties,
+          },
+        };
+
+        funcParams.store.tempSchema = updatedSchema;
+
+        return updatedSchema;
+      });
+      uiSchema.elements.push(notifyUiSchema);
+      funcParams.store.setUiSchema(uiSchema);
+    },
+    onCellRenderer: (cellParams) => {
+      if (eventGroups.onCellRenderer) {
+        let finalResponse = {};
+        const path = funcParams.dynamicData?.tableButtonPath || funcParams?.dynamicData?.path?.split(".")[0];
+
+        for (const eventConfig of eventGroups?.onCellRenderer?.[path]) {
+          executeEventsParameters.store.functionParameters = cellParams
+          finalResponse = executeEvents({
+            ...executeEventsParameters,
+            config: eventConfig,
+            componentName: path
+          })
+        }
+        return finalResponse
+      }
+      return {}
+    },
+    onClick: function () {
+      this.callHandler("onClick")
+    },
+    onKeyDown: function () {
+      this.callHandler("onKeyDown")
+    },
+    onFileDelete: async function () {
+      this.callHandler("onFileDelete")
+    },
+    onMount: function () {
+      this.callHandler("onMount")
+    },
+    onFileDownload: function () {
+      this.callHandler("onDownload")
+    },
+    onFileUpload: function () {
+      this.callHandler("onUpload")
+    },
+    backHandler: function () {
+      funcParams.store.navigate(-1)
+    },
+    onRowMovement: async function (paginationValues) {
+      const apiBody = [
+        { key: "direction", value: paginationValues.rowMovement.direction },
+        { key: "movedRowId", value: paginationValues.rowMovement.movedRowId },
+        { key: "targetRowId", value: paginationValues.rowMovement.targetRowId || [] }
+      ]
+      await this.callExecuteEvents({ path: paginationValues?.path }, apiBody, "onRowMovement");
+      const response = await this.callExecuteEvents({ path: paginationValues?.path }, apiBody, "onLoad");
+      return response?.data;
+    },
+    onPaginationChange: async function (paginationValues) {
+      const apiBody = [
+        { key: "size", value: paginationValues.pagination.pageSize },
+        { key: "pageIndex", value: paginationValues.pagination.pageIndex },
+        { key: "sorting", value: paginationValues.sorting || [] },
+        { key: "filters", value: paginationValues.tableColumnConfig || [] },
+        { key: "globalFilter", value: paginationValues.globalFilter ?? '' },
+        { key: "expandedRowIds", value: paginationValues.expandedRowIds ?? []}
+      ]
+      const response = await this.callExecuteEvents(paginationValues, apiBody, "onLoad");
+      return response?.data;
+    },
+    getSelectOptions: async function (param) {
+      if (param.serachValue !== "" && param.serachValue !== undefined) {
+        const apiBody = [
+          { key: "searchValue", value: param.serachValue },
+          { key: "currentValue", value: param.currentValue }
+        ]
+        const response = await this.callExecuteEvents(param, apiBody, "onLoad");
+        return response?.data;
+      }
+    },
+    onChange: async function () {
+      if (eventGroups.onChange) {
+        const ChangeEventsKeysArray = Object.keys(eventGroups.onChange);
+        Promise.all(ChangeEventsKeysArray.map(async (componentName: string) => {
+          if (
+            funcParams.store?.formData[componentName] !== funcParams.store.newData[componentName] &&
+            funcParams.store?.newData[componentName] !== undefined
+          ) {
+            for (const eventConfig of eventGroups.onChange[componentName]) {
+              await executeEvents({
+                ...executeEventsParameters,
+                config: eventConfig,
+                componentName
+              })
+            }
+          }
+        }))
+      }
+    },
+    callExecuteEvents: async function (paramValue, apiBody, eventType: string) {
+      let LastCallResponse = undefined;
+      const cloneEventGroup = _.cloneDeep(eventGroups)
+      for (const eventConfig of cloneEventGroup?.[eventType]?.[paramValue.path]) {
+        if (eventConfig.body) {
+          eventConfig.body = [
+            ...eventConfig.body,
+            ...apiBody
+          ]
+        } else { eventConfig.body = apiBody; };
+        const responseEvent = eventConfig?.events?.filter((elem) => {
+          return elem.Handler !== "mergeFormdata"
+        })
+        eventConfig.events = responseEvent ?? []
+        LastCallResponse = await executeEvents({
+          ...executeEventsParameters,
+          config: eventConfig,
+          componentName: paramValue.path
+        })
+      }
+      return LastCallResponse
+    },
+    onBack: async function (functionParameters) {
+      const path = funcParams.dynamicData?.tableButtonPath || funcParams.dynamicData.path.split(".")[0];
+      await this.callHandler("onBack", functionParameters)
+      if (eventGroups?.["onBack"]?.[path] === undefined) {
+        functionParameters?.handleBack()
+      }
+    },
+    onNext: async function (functionParameters) {
+      const path = funcParams.dynamicData?.tableButtonPath || funcParams.dynamicData.path.split(".")[0];
+      await this.callHandler("onNext", functionParameters)
+      if (eventGroups?.["onNext"]?.[path] === undefined) {
+        functionParameters?.handleNext()
+      }
+    },
+    onReset: async function (functionParameters) {
+      const path = funcParams.dynamicData?.tableButtonPath || funcParams.dynamicData.path.split(".")[0];
+      await this.callHandler("onReset", functionParameters)
+      if (eventGroups?.["onReset"]?.[path] === undefined) {
+        functionParameters?.handleReset()
+      }
+    },
+    callHandler: async function (eventType: string, functionParameters?: any) {
+      const path = funcParams.dynamicData?.tableButtonPath || funcParams.dynamicData.path.split(".")[funcParams.dynamicData.path.split(".").length - 1];
+      if (eventGroups?.[eventType]?.[path] !== undefined) {
+        Promise.all(eventGroups?.[eventType]?.[path].map((eventConfig) => {
+          executeEventsParameters.store.functionParameters = functionParameters
+          executeEvents({
+            ...executeEventsParameters,
+            config: eventConfig,
+            componentName: path
+          })
+        }))
+      }
+    },
+    downloadFile: downloadFile,
+    download: doDownload,
+    ...funcParams.functionsProvider
+  };
+};