impaktapps-ui-builder 0.0.382457 → 0.0.382460

package/src/impaktapps-ui-builder/builder/services/utils.ts

@@ -1,10 +1,10 @@
 import buildConfig from "../build/buildConfig";
 import _ from "lodash";
 
-const clearFromLocalStorage = () => {
-    localStorage.removeItem("pageFormdata")
+const clearFromSessionStorage = () => {
+    sessionStorage.removeItem("pageFormdata")
 }
-export default clearFromLocalStorage;
+export default clearFromSessionStorage;
 export const getNavigationHistory = (config: any, path: string | undefined) => {
     if (path) {
         let urlRoutes: string = config.name;
@@ -31,20 +31,20 @@ export const getNavigationHistory = (config: any, path: string | undefined) => {
     return undefined;
 }
 
-export const saveFormdataInLocalStorage = (formData: any, path?: string) => {
+export const saveFormdataInSessionStorage = (formData: any, path?: string) => {
     let updatedFormdata: any;
     if (path) {
-        const pageFormdata = getFormdataFromLocalStorage()
+        const pageFormdata = getFormdataFromSessionStorage()
         updatedFormdata = _.set(pageFormdata, path, buildConfig(formData));
     } else {
         updatedFormdata = buildConfig(formData)
     }
-    localStorage.setItem("pageFormdata", JSON.stringify(updatedFormdata))
+    sessionStorage.setItem("pageFormdata", JSON.stringify(updatedFormdata))
     return updatedFormdata;
 }
 
-export const getFormdataFromLocalStorage = (path?: string) => {
-    const pageFormdata = localStorage.getItem("pageFormdata") ? JSON.parse(localStorage.getItem("pageFormdata")) : undefined;
+export const getFormdataFromSessionStorage = (path?: string) => {
+    const pageFormdata = sessionStorage.getItem("pageFormdata") ? JSON.parse(sessionStorage.getItem("pageFormdata")) : undefined;
     let returnValue: any;
     if (path) {
         returnValue = _.get(pageFormdata, path)
@@ -60,12 +60,12 @@ export const getFormdataFromLocalStorage = (path?: string) => {
 export async function saveHandler(store, service, submitHandler, pageName?: string) {
     const id = store.searchParams?.get("id");
     const path = store.searchParams?.get("path");
-    saveFormdataInLocalStorage(store.ctx.core.data, path);
-    const config = JSON.parse(localStorage.getItem("pageFormdata"));
+    saveFormdataInSessionStorage(store.ctx.core.data, path);
+    const config = JSON.parse(sessionStorage.getItem("pageFormdata"));
     if (_.isEmpty(store.ctx.core.errors)) {
         try {
             const saveReturn = await submitHandler(store, service, config);
-            navigateHandler(store, true, pageName ? `/${pageName}?id=${id}` : "/PageMasterRecords")
+            navigateHandler(store, true, pageName ? `/${pageName}?id=${saveReturn.id}` : "/PageMasterRecords")
         } catch (err) {
             navigateHandler(store, false)
         }
@@ -74,7 +74,7 @@ export async function saveHandler(store, service, submitHandler, pageName?: stri
 
 export const navigateHandler = (store, isSubmitted, pageName?: string | boolean) => {
     if (isSubmitted) {
-        localStorage.removeItem("pageFormdata");
+        sessionStorage.removeItem("pageFormdata");
         store.navigate(pageName || -1)
         store.setNotify({
             SuccessMessage: "Submit Successfully",
@@ -91,9 +91,8 @@ export const navigateHandler = (store, isSubmitted, pageName?: string | boolean)
 
 export function okHandler(store) {
     const path = store.searchParams?.get("path");
-    console.log(store.ctx.core.errors)
     if (_.isEmpty(store.ctx.core.errors)) {
-        saveFormdataInLocalStorage(store.ctx.core.data, path)
+        saveFormdataInSessionStorage(store.ctx.core.data, path)
         store.navigate(-1)
         store.setNotify({
             SuccessMessage: "Save Successfully",

package/src/impaktapps-ui-builder/lib/index.ts

@@ -7,4 +7,4 @@ export { schema} from "../builder/build/buildUiSchema"
 export {default as buildConfig} from "../builder/build/buildConfig"
 export  {default as buildUiSchema} from "../builder/build/buildUiSchema"
 export  {buildSchema} from "../builder/build/buildUiSchema"
-export {default as clearFromLocalStorage} from "../builder/services/utils"
+export {default as clearFromSessionStorage} from "../builder/services/utils"

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

@@ -29,4 +29,4 @@ export const doDownload = (response: any, service) => {
     document.body.appendChild(link);
     link.click();
     link.parentNode.removeChild(link);
-};
+};

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

@@ -1,103 +1,152 @@
 import _, { cloneDeep } from "lodash";
 import { handlersProps } from "./interface";
-
-
-export const executeEvents = async (
-  params: handlersProps
-) => {
+export const executeEvents = (params: handlersProps) => {
   let nextEvent = [];
   let finalResponse = null;
+
+  if (params.config.isSync !== "Yes") {
+    return shouldEventExecute(params)
+      .then((shouldExecute) => {
+        if (!shouldExecute) {
+          throw new Error('onStart Event not allow to run Parent Events');
+        }
+        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 shouldExecute = await shouldEventExecute(params)
-    if (!shouldExecute) {
-      return { response: undefined, events: undefined };
-    }
-    const response = await executeEventsHandler(params)
-    finalResponse = response;
+    const eventsResponse = executeEventsHandler(params);
+    finalResponse = eventsResponse;
     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 : []
+  } catch {
+    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) {
-      await executeEvents({ ...params, config: actionConfig, parentEventOutput: finalResponse })
+      executeEvents({ ...params, config: actionConfig, parentEventOutput: finalResponse })
     }
   }
   return finalResponse;
 }
 
-async function executeEventsHandler(params: handlersProps) {
+function executeEventsHandler(params: handlersProps) {
   if (params.config.Handler === "api") {
-    return await executeApiEventHandler(params)
-  }
-  else if (params.config.Handler === "inBuiltFunction") {
-    return await executeInBuiltFunctionHandler(params)
+    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,
+      params.formDataHolder
+    );
+  } 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();
   }
-  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)
+    }
   }
+  return result;
 }
 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 });
+  const compToRefresh: string[] = getRefreshElements(params.config, params.eventGroups);
+  return Promise.allSettled(compToRefresh.map(componentName => {
+    const eventConfigs = params.eventGroups.onLoad[componentName];
+    if (!eventConfigs) {
+      return Promise.resolve();
     }
-  }
+    return Promise.allSettled(eventConfigs.map(compEventConfig => {
+      return executeEvents({ ...params, config: compEventConfig, componentName });
+    }));
+  }));
 }
-async function executeApiEventHandler(params: handlersProps) {
+export function executeApiRequest(params: any) {
   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 response = await params.service[params.config.method](
+  const payloadApi = buildApiPayload(params.config, initialBody, initialHeaders, params.store, params.dynamicData, params.userValue, params.service)
+  return params.service[params.config.method](
     params.config.path,
-    body,
-    headers && { headers: headers }
-  );
-  return response;
-}
+    payloadApi.body,
+    { headers: payloadApi.headers }
+  ).then((response) => {
+    return response;
+  });
+};
 
-async function executeInBuiltFunctionHandler(params: handlersProps) {
+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)
 }
 
-async function executeCustomHandler(params: handlersProps) {
+function executeCustomHandler(params: handlersProps) {
   const makeFunc = eval(params.config.eventCode)
-  const response = await makeFunc(params.store, params.dynamicData, params.userValue, params.parentEventOutput, params.service, params.componentName);
-  return response;
+  if (params.config.isSync !== "Yes") {
+    return 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;
+  }
+
 }
 
-async function mergeFormdata(handlerResponse: any, componentName: string, eventConfig: any, store: any, service: any) {
-  if (eventConfig.type === "Select" && !(_.isEmpty(handlerResponse?.data) && handlerResponse?.data)) {
+function mergeFormdata(handlerResponse: any, componentName: string, eventConfig: any, store: any, service: any, formDataHolder: any) {
+  if (eventConfig.type === "Select"  && handlerResponse?.data && !_.isEmpty(handlerResponse?.data)) {
     store.setSchema((pre) => {
       return {
         ...pre, properties: {
@@ -109,7 +158,7 @@ async function mergeFormdata(handlerResponse: any, componentName: string, eventC
       }
     })
   }
-  else if (eventConfig.type === "MultipleSelect" && !(_.isEmpty(handlerResponse?.data) && handlerResponse?.data)) {
+  else if (eventConfig.type === "MultipleSelect" && handlerResponse?.data && !_.isEmpty(handlerResponse?.data)) {
     store.setSchema((pre) => {
       return {
         ...pre, properties: {
@@ -126,19 +175,23 @@ async function mergeFormdata(handlerResponse: any, componentName: string, eventC
   }
   else if (eventConfig.type === "page") {
     if (!(_.isEmpty(handlerResponse?.data) && handlerResponse?.data)) {
+      store.newData = {
+        ...store.newData,
+        ...handlerResponse?.data
+      }
       store.setFormdata((pre: any) => { return { ...pre, ...handlerResponse?.data } })
     }
   }
   else {
     if (handlerResponse) {
-      store.setFormdata((pre) => { return { ...pre, [componentName]: eventConfig.lazyLoading ? handlerResponse.data.data : handlerResponse.data } });
-      const demoData = await asyncOperation();
+      formDataHolder[componentName] = handlerResponse.data
+      store.setFormdata((pre) => { return { ...pre, ...formDataHolder } });
     }
   }
 }
 
-const buildBodyFormat = (body: any[], formData: any, userValue: any) => {
-  const finalBody = { ...userValue?.payload };
+const buildBodyFormat = (body: any[], formData: any, userValue: any, store: any) => {
+  let finalBody = { ...userValue?.payload };
   body.map((elem) => {
     if (typeof elem?.value !== "string") {
       finalBody[elem.key] = elem.value;
@@ -146,11 +199,25 @@ const buildBodyFormat = (body: any[], formData: any, userValue: any) => {
       if (elem?.value?.startsWith("$userValue")) {
         const finalpath = elem.value.substring(11);
         finalBody[elem.key] = _.get(userValue, finalpath);;
+      } else if (elem?.value?.startsWith("$urlParams")) {
+        const finalpath = elem.value.substring(11);
+        const value = store?.searchParams?.get(finalpath);
+        finalBody[elem.key] = value;
+      }
+      else if (elem?.value?.startsWith("$local")) {
+        const finalpath = elem.value.substring(7);
+        const value = JSON.parse(sessionStorage.getItem(finalpath) || '""')
+        finalBody[elem.key] = value;
       }
       else if (elem?.value?.startsWith("$")) {
         const finalpath = elem.value.substring(1);
         finalBody[elem.key] = _.get(formData, finalpath);;
-      } else {
+      } else if (elem?.value === "*" && elem?.key === "*") {
+        finalBody = { ...finalBody, ...formData };
+      } else if (elem?.value === "*") {
+        finalBody[elem.key] = formData;
+      }
+      else {
         finalBody[elem.key] = elem.value;
       }
     }
@@ -169,51 +236,42 @@ const buildHeadersFormat = (headers: any[]) => {
   return headerObj;
 }
 
-async function shouldEventExecute(params: handlersProps) {
+export function shouldEventExecute(params: handlersProps) {
   const startEvent = params.config?.events?.filter(e => e.eventType === "onStart");
+
   if (startEvent?.length > 0) {
-    const response = await executeEventsHandler({ ...params, config: startEvent[0] });
-    return response;
+    if (startEvent[0]?.isSync !== "Yes") {
+      return executeEventsHandler({ ...params, config: startEvent[0] }).then((response) => {
+        return response;
+      });
+    } else {
+      return executeEventsHandler({ ...params, config: startEvent[0] })
+    }
   } else {
-    return true
+    if (params.config.isSync !== "Yes") {
+      return Promise.resolve(true)
+    } else {
+      return true
+    }
   }
 }
 
-export async function buildApiPayload(compConfig: any, body: any, headers: any, store: any, dynamicData: any, userValue: any, service) {
-  if (compConfig?.headers) {
-    headers = buildHeadersFormat(compConfig.headers)
 
+export function buildApiPayload(compConfig: any, body: any, headers: any, store: any, dynamicData: any, userValue: any, service) {
+  if (compConfig?.headers) {
+    headers = buildHeadersFormat(compConfig.headers);
   }
   if (compConfig.body) {
-    body = { ...buildBodyFormat(compConfig.body, store.newData || store?.ctx?.core?.data || store.formData, userValue) };
+    body = { ...buildBodyFormat(compConfig.body, store.newData || store?.ctx?.core?.data || store.formData, userValue, store) };
   }
+  const promiseChain = { body, headers };
   if (compConfig.apiBody) {
     const makeFunc = eval(compConfig.apiBody);
-    const data = await makeFunc(store, dynamicData, userValue, body);
-    body = data
+    return { body: makeFunc(store, dynamicData, userValue, promiseChain.body), headers: promiseChain.headers };
   }
-  return { body, headers };
+  return promiseChain;
 }
-
-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]);
-    }
-  }
-  console.log(result);
-  return result;
-}
-
-
-function asyncOperation() {
+export function asyncOperation() {
   return new Promise((resolve, reject) => {
     setTimeout(() => {
       const success = true;

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

@@ -7,5 +7,7 @@ export interface handlersProps {
     service: any, 
     serviceHolder: any, 
     eventGroups?: any, 
-    parentEventOutput?: any
+    parentEventOutput?: any,
+    functionsProvider?:Record<string,any>
+    formDataHolder?:Record<string,any>
 }