impaktapps-ui-builder 0.0.409-h → 0.0.409-k

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

@@ -1,148 +1,102 @@
-import _ from "lodash";
+import _, { cloneDeep } from "lodash";
 import { handlersProps } from "./interface";
 
-export const executeEvents = (params: handlersProps) => {
+
+export const executeEvents = async (
+  params: handlersProps
+) => {
   let nextEvent = [];
   let finalResponse = null;
-
-  if (params.config.isSync !== "Yes") {
-    return shouldEventExecute(params)
-      .then((shouldExecute) => {
-        if (!shouldExecute) {
-          return { response: undefined, events: undefined };
-        }
-        return executeEventsHandler(params);
-      })
-      .then((response) => {
-        finalResponse = response;
-        const SuccessEvent = params.config?.events.filter(e => e.eventType === "Success");
-        nextEvent = SuccessEvent;
-      })
-      .catch((err) => {
-        const FailEvent = params.config?.events?.filter(e => e.eventType === "Fail");
-        const setEvent = FailEvent?.length > 0 ? FailEvent : [];
-        nextEvent = setEvent;
-      })
-      .then(() => {
-        if (nextEvent?.length > 0) {
-          return nextEvent.reduce((chain, actionConfig) => {
-            return chain.then(() => executeEvents({ ...params, config: actionConfig, parentEventOutput: finalResponse }));
-          }, Promise.resolve());
-        }
-      })
-      .then(() => finalResponse)
-  }
-  const shouldExecute = shouldEventExecute(params);
-  if (!shouldExecute) {
-    return { response: undefined, events: undefined };
-  }
   try {
-    const eventsResponse = executeEventsHandler(params);
-    finalResponse = eventsResponse;
+    const shouldExecute = await shouldEventExecute(params)
+    if (!shouldExecute) {
+      return { response: undefined, events: undefined };
+    }
+    const response = await executeEventsHandler(params)
+    finalResponse = response;
     const SuccessEvent = params.config?.events.filter(e => e.eventType === "Success");
     nextEvent = SuccessEvent;
-  } catch {
-    const FailEvent = params.config?.events?.filter(e => e.eventType === "Fail");
-    const setEvent = FailEvent?.length > 0 ? FailEvent : [];
+  } catch (err) {
+    const FailEvent = params.config?.events?.filter(e => e.eventType === "Fail")
+    const setEvent = FailEvent?.length > 0 ? FailEvent : []
     nextEvent = setEvent;
   }
   if (nextEvent?.length > 0) {
     for (const actionConfig of nextEvent) {
-      executeEvents({ ...params, config: actionConfig, parentEventOutput: finalResponse })
+      await executeEvents({ ...params, config: actionConfig, parentEventOutput: finalResponse })
     }
   }
   return finalResponse;
 }
-function executeEventsHandler(params: handlersProps) {
+
+async function executeEventsHandler(params: handlersProps) {
   if (params.config.Handler === "api") {
-    return executeApiRequest(params);
-  } else if (params.config.Handler === "inBuiltFunction") {
-    return executeInBuiltFunctionHandler(params);
-  } else if (params.config.Handler === "custom") {
-    return executeCustomHandler(params);
-  } else if (params.config.Handler === "refresh") {
-    return executeRefreshHandler(params);
-  } else if (params.config.Handler === "mergeFormdata") {
-    return mergeFormdata(
-      params.parentEventOutput,
-      params.componentName,
-      params.config,
-      params.store,
-      params.service
-    );
-  } else if (params.config.Handler === "onBackHandler") {
-    return params.store.functionParameters?.handleBack();
-  } else if (params.config.Handler === "onNextHandler") {
-    return params.store.functionParameters?.handleNext();
-  } else if (params.config.Handler === "onResetHandler") {
-    return params.store.functionParameters?.handleReset();
+    return await executeApiEventHandler(params)
+  }
+  else if (params.config.Handler === "inBuiltFunction") {
+    return await executeInBuiltFunctionHandler(params)
+  }
+  else if (params.config.Handler === "custom") {
+    return await executeCustomHandler(params)
+  }
+  else if (params.config.Handler === "refresh") {
+    return await executeRefreshHandler(params)
+  }
+  else if (params.config.Handler === "mergeFormdata") {
+    const result = await mergeFormdata(
+      params.parentEventOutput, params.componentName, params.config, params.store, params.service)
+    return result;
+  }
+  else if (params.config.Handler === "onBackHandler") {
+    return params.store.functionParameters?.handleBack()
+  }
+  else if (params.config.Handler === "onNextHandler") {
+    return params.store.functionParameters?.handleNext()
+  }
+  else if (params.config.Handler === "onResetHandler") {
+    return params.store.functionParameters?.handleReset()
   }
 }
-
-export function getRefreshElements(eventConfig: any, eventGropus: any) {
-  let result: string[] = [];
-  if (eventConfig?.refreshElements?.length > 0) {
-    result = eventConfig.refreshElements.map((e) => {
-      return e.value
-    })
-
-  } else {
-    if (eventGropus?.onLoad) {
-      result = Object.keys(eventGropus?.onLoad)
-      result.push(result[0]);
+export async function executeRefreshHandler(params: handlersProps) {
+  const compToRefresh: string[] = getRefreshElements(params.config, params.eventGroups)
+  for (const componentName of compToRefresh) {
+    for (const compEventConfig of params.eventGroups.onLoad[componentName]) {
+      await executeEvents({ ...params, config: compEventConfig, componentName });
     }
   }
-  return result;
 }
-export function executeRefreshHandler(params: handlersProps) {
-  const compToRefresh: string[] = getRefreshElements(params.config, params.eventGroups);
-
-  return Promise.all(compToRefresh.map(componentName => {
-    return Promise.all(params.eventGroups.onLoad[componentName].map(compEventConfig => {
-      return executeEvents({ ...params, config: compEventConfig, componentName });
-    }));
-  }))
-};
-export function executeApiRequest(params: any) {
+async function executeApiEventHandler(params: handlersProps) {
   const initialBody = { ...params.userValue?.payload };
   const initialHeaders = {
     "X-Requested-With": "XMLHttpRequest",
     "Access-Control-Allow-Origin": "*"
   };
+  const { body, headers } = await buildApiPayload(params.config, initialBody, initialHeaders, params.store, params.dynamicData, params.userValue, params.service)
 
-  const payloadApi = buildApiPayload(params.config, initialBody, initialHeaders, params.store, params.dynamicData, params.userValue, params.service)
-  return params.service[params.config.method](
+  const response = await params.service[params.config.method](
     params.config.path,
-    payloadApi.body,
-    { headers: payloadApi.headers }
-  ).then((response) => {
-    return response;
-  });
-};
+    body,
+    headers && { headers: headers }
+  );
+  return response;
+}
 
-function executeInBuiltFunctionHandler(params: handlersProps) {
+async function executeInBuiltFunctionHandler(params: handlersProps) {
   let parameter = {};
   if (params.config.funcParametersCode) {
     const makeFunc = eval(params.config.funcParametersCode)
     parameter = makeFunc(params.store, params.dynamicData, params.userValue, params.parentEventOutput, params.service);
-    params.serviceHolder[params.config.inBuiltFunctionType](parameter, params.service)
-  } else {
-    params.serviceHolder[params.config.inBuiltFunctionType](params.store, params.dynamicData, params.userValue, params.parentEventOutput, params.service)
   }
+  params.serviceHolder[params.config.inBuiltFunctionType](parameter)
 }
 
-function executeCustomHandler(params: handlersProps) {
+async function executeCustomHandler(params: handlersProps) {
   const makeFunc = eval(params.config.eventCode)
-  if (params.config.isSync !== "Yes") {
-    makeFunc(params.store, params.dynamicData, params.userValue, params.parentEventOutput, params.service, params.componentName).then((res) => res)
-  } else {
-    const response = makeFunc(params.store, params.dynamicData, params.userValue, params.parentEventOutput, params.service, params.componentName)
-    return response;
-  }
-
+  const response = await makeFunc(params.store, params.dynamicData, params.userValue, params.parentEventOutput, params.service, params.componentName);
+  return response;
 }
 
-function mergeFormdata(handlerResponse: any, componentName: string, eventConfig: any, store: any, service: any) {
+async function mergeFormdata(handlerResponse: any, componentName: string, eventConfig: any, store: any, service: any) {
   if (eventConfig.type === "Select" && !(_.isEmpty(handlerResponse?.data) && handlerResponse?.data)) {
     store.setSchema((pre) => {
       return {
@@ -177,13 +131,14 @@ function mergeFormdata(handlerResponse: any, componentName: string, eventConfig:
   }
   else {
     if (handlerResponse) {
-      store.setFormdata((pre) => { return { ...pre, [componentName]: eventConfig.lazyLoading ? handlerResponse?.data?.data : handlerResponse.data } });
+      store.setFormdata((pre) => { return { ...pre, [componentName]: eventConfig.lazyLoading ? handlerResponse.data.data : handlerResponse.data } });
+      const demoData = await asyncOperation();
     }
   }
 }
 
 const buildBodyFormat = (body: any[], formData: any, userValue: any) => {
-  let finalBody = { ...userValue?.payload };
+  const finalBody = { ...userValue?.payload };
   body.map((elem) => {
     if (typeof elem?.value !== "string") {
       finalBody[elem.key] = elem.value;
@@ -195,12 +150,7 @@ const buildBodyFormat = (body: any[], formData: any, userValue: any) => {
       else if (elem?.value?.startsWith("$")) {
         const finalpath = elem.value.substring(1);
         finalBody[elem.key] = _.get(formData, finalpath);;
-      } else if (elem?.value === "*" && elem?.key === "*") {
-        finalBody = { ...finalBody, ...formData };
-      } else if (elem?.value === "*") {
-        finalBody[elem.key] = formData;
-      }
-      else {
+      } else {
         finalBody[elem.key] = elem.value;
       }
     }
@@ -219,40 +169,58 @@ const buildHeadersFormat = (headers: any[]) => {
   return headerObj;
 }
 
-export function shouldEventExecute(params: handlersProps) {
+async function shouldEventExecute(params: handlersProps) {
   const startEvent = params.config?.events?.filter(e => e.eventType === "onStart");
-
   if (startEvent?.length > 0) {
-    return executeEventsHandler({ ...params, config: startEvent[0] }).then((response) => {
-      return response;
-    });
+    const response = await executeEventsHandler({ ...params, config: startEvent[0] });
+    return response;
   } else {
-    if (params.config.isSync !== "Yes") {
-      return Promise.resolve(true)
-    } else {
-      return true
-    }
+    return true
   }
 }
 
-
-export function buildApiPayload(compConfig: any, body: any, headers: any, store: any, dynamicData: any, userValue: any, service) {
+export async function buildApiPayload(compConfig: any, body: any, headers: any, store: any, dynamicData: any, userValue: any, service) {
   if (compConfig?.headers) {
-    headers = buildHeadersFormat(compConfig.headers);
-  }
+    headers = buildHeadersFormat(compConfig.headers)
 
+  }
   if (compConfig.body) {
     body = { ...buildBodyFormat(compConfig.body, store.newData || store?.ctx?.core?.data || store.formData, userValue) };
   }
-
-  const promiseChain = { body, headers };
-
-
   if (compConfig.apiBody) {
     const makeFunc = eval(compConfig.apiBody);
-    return { body: makeFunc(store, dynamicData, userValue, promiseChain.body), headers: promiseChain.headers };
-    // return result;
+    const data = await makeFunc(store, dynamicData, userValue, body);
+    body = data
+  }
+  return { body, headers };
+}
+
+export function getRefreshElements(eventConfig: any, eventGropus: any) {
+  let result: string[] = [];
+  if (eventConfig?.refreshElements?.length > 0) {
+    result = eventConfig.refreshElements.map((e) => {
+      return e.value
+    })
 
+  } else {
+    if (eventGropus?.onLoad) {
+      result = Object.keys(eventGropus?.onLoad)
+      result.push(result[0]);
+    }
   }
-  return promiseChain;
+  console.log(result);
+  return result;
+}
+
+
+export function asyncOperation() {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      const success = true;
+      if (success) {
+        resolve("Operation completed successfully!");
+        reject(new Error("Operation failed!"));
+      }
+    }, 50);
+  });
 }

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

@@ -1,6 +1,6 @@
 import _, { isEmpty } from "lodash";
 import { doDownload, downloadFile } from "./downloadFile";
-import { executeEvents, executeRefreshHandler } from "./events";
+import { asyncOperation, executeEvents, executeRefreshHandler } from "./events";
 import { handlersProps } from "./interface";
 let compType: string;
 let eventGroups: any = {};
@@ -13,14 +13,6 @@ const notifyUiSchema = {
   layout: 6,
 };
 
-interface funcParamsProps {
-  store: any,
-  dynamicData: any,
-  service: any,
-  userValue: any,
-  functionsProvider?: Record<string, any>
-}
-
 export const extractEvents = (eventConfig: any) => {
   function extractsConfigEvents(eventConfigObj: any) {
     if (eventConfigObj.events) {
@@ -54,53 +46,41 @@ export const extractEvents = (eventConfig: any) => {
   }
   return eventGroups;
 };
+
+interface funcParamsProps {
+  store: any,
+  dynamicData: any,
+  config: any,
+  uiSchema: any,
+  schema: any,
+  service: any,
+  userValue: any,
+}
 export default (funcParams: funcParamsProps) => {
+  eventGroups = {}
+  eventGroups = extractEvents(funcParams.config)
   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,
+    serviceHolder: { downloadFile, download: doDownload }, eventGroups
   };
   return {
     setPage: async function () {
-      funcParams.store.setFormdata({})
-      const data = JSON.stringify({
-        pageName: funcParams.store.pageName
-      });
-      let pageData;
-      const pageBasicDetailString = localStorage.getItem("pagemasterMetaData")
-      if (pageBasicDetailString) {
-        pageData = JSON.parse(pageBasicDetailString)
-      } else {
-        const pageId = await funcParams.service
-          .post("/page/getByName", data, {
-            headers: {
-              "Content-Type": "application/json",
-            },
-          });
-        const response = await funcParams.service.get(
-          `/page/getById?id=${pageId?.data?.id}`,
-          {
-            headers: {
-              "Content-Type": "application/json",
-            },
+      funcParams.store.setFormdata({});
+      funcParams.store.setSchema(
+        (pre: any) => {
+          return {
+            ...funcParams.schema, properties:
+              { ...funcParams.schema.properties, ...pre.properties, }
           }
-        );
-        pageData = response.data;
-        localStorage.setItem("pagemasterMetaData", JSON.stringify({
-          schema: pageData?.schema,
-          uiSchema: pageData?.uiSchema, config: pageData?.config
-        }))
-      }
-      const config = pageData?.config;
-      const uiSchema = pageData?.uiSchema;
-      const schema = pageData?.schema ?? { type: "object", properties: {} };
-      eventGroups = {}
-      eventGroups = extractEvents(config);
+        }
+      )
+      funcParams.uiSchema.elements.push(notifyUiSchema);
+      funcParams.store.setUiSchema(funcParams.uiSchema);
+      await asyncOperation()
       executeEventsParameters = {
         config: {}, componentName: "",
         store: funcParams.store, dynamicData: funcParams.dynamicData, userValue: funcParams.userValue, service: funcParams.service,
-        functionsProvider: funcParams.functionsProvider,
         serviceHolder: this, eventGroups
       }
       await executeRefreshHandler({
@@ -108,47 +88,15 @@ export default (funcParams: funcParamsProps) => {
         store: funcParams.store, dynamicData: funcParams.dynamicData, userValue: funcParams.userValue, service: funcParams.service,
         serviceHolder: this, eventGroups
       })
-      funcParams.store.setSchema(
-        (pre: any) => {
-          return {
-            ...schema, properties:
-              { ...schema.properties, ...pre.properties, }
-          }
-        }
-      )
-      uiSchema.elements.push(notifyUiSchema);
-      funcParams.store.setUiSchema(uiSchema);
-
-    },
-    onCellRenderer: (cellParams) => {
-      let finalResponse = {};
-      cellParams.spanRef.current.style.color = "yellow";
-      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
-        })
-      }
-      console.log("finalResponse >> >> >> ", finalResponse)
-      return finalResponse
-    },
-    onClick: function () {
-      this.callHandler("onClick")
     },
-    onMount: function () {
-      this.callHandler("onMount")
+    onClick: async function () {
+      await this.callHandler("onClick")
     },
-    onFileDownload: function () {
-      this.callHandler("onDownload")
+    onFileDownload: async function () {
+      await this.callHandler("onDownload")
     },
-    onFileUpload: function () {
-      this.callHandler("onUpload")
-    },
-    backHandler: function () {
-      funcParams.store.navigate(-1)
+    onFileUpload: async function () {
+      await this.callHandler("onUpload")
     },
     onPaginationChange: async function (paginationValues) {
       const apiBody = [
@@ -167,8 +115,7 @@ export default (funcParams: funcParamsProps) => {
           { key: "searchValue", value: param.serachValue },
           { key: "currentValue", value: param.currentValue }
         ]
-        const response = await this.updateConfigApiBody(param, apiBody);
-        return response?.data;
+        return await this.updateConfigApiBody(param, apiBody)
       }
     },
     onChange: async function () {
@@ -237,7 +184,7 @@ export default (funcParams: funcParamsProps) => {
       if (eventGroups?.[eventType]?.[path] !== undefined) {
         for (const eventConfig of eventGroups?.[eventType]?.[path]) {
           executeEventsParameters.store.functionParameters = functionParameters
-           executeEvents({
+          await executeEvents({
             ...executeEventsParameters,
             config: eventConfig,
             componentName: path
@@ -245,10 +192,8 @@ export default (funcParams: funcParamsProps) => {
         }
       }
     },
-
     downloadFile: downloadFile,
     download: doDownload,
-    ...funcParams.functionsProvider
   };
 };
 
@@ -256,3 +201,9 @@ export default (funcParams: funcParamsProps) => {
 
 
 
+
+
+
+
+
+