impaktapps-ui-builder 0.0.284 → 0.0.286

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

@@ -1,171 +1,100 @@
 import _, { cloneDeep } from "lodash";
+import { handlersProps } from "./interface";
 
 
 export const executeEvents = async (
-  config: any, componentName: string,
-  store: any, dynamicData: any, userValue: any,
-  service: any, serviceHolder: any, eventGroups?: any, parentEventOutput?: any
+ params:handlersProps
 ) => {
   let nextEvent = [];
   let LoadResponse = null;
-  if (config.eventType === "onLoad") {
-    const { response, events } = await executetOnLoadEvent(config, componentName,
-      store, dynamicData, userValue,
-      service, serviceHolder, eventGroups, parentEventOutput)
-    if (config.returnResponse) {
-      return response;
-    }
-    LoadResponse = response;
-    nextEvent = events;
-  }
-  else {
-    if (!shouldEventExecute(config, componentName,
-      store, dynamicData, userValue,
-      service, serviceHolder, eventGroups)) {
+  try{
+    if (!shouldEventExecute(params)) {
       return { response: undefined, events: undefined };
     }
-    const { response, events } = await executeEventsHandler(config, componentName,
-      store, dynamicData, userValue,
-      service, serviceHolder, eventGroups, parentEventOutput)
+    const response  = await executeEventsHandler(params)
     LoadResponse = response;
-    nextEvent = events;
+    const SuccessEvent = params.config?.events.filter(e => e.eventType === "Success");
+    if(params.config.returnNeeded){
+      return LoadResponse
+    }
+    nextEvent = SuccessEvent;
+  } 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) {
-      await executeEvents(actionConfig, componentName, store, dynamicData, userValue, service, serviceHolder, eventGroups, LoadResponse)
-    }
-  }
-}
-const executetOnLoadEvent = async (
-  config: any, componentName: string,
-  store: any, dynamicData: any, userValue: any,
-  service: any, serviceHolder: any, eventGroups?: any, parentEventOutput?: any
-) => {
-
-  try {
-    if (!shouldEventExecute(config, componentName,
-      store, dynamicData, userValue,
-      service, serviceHolder, eventGroups)) {
-      return { response: undefined, events: undefined };
+        await executeEvents({...params,config:actionConfig,parentEventOutput:LoadResponse})
     }
-    const { response } = await executeEventsHandler(config, componentName,
-      store, dynamicData, userValue,
-      service, serviceHolder, eventGroups, parentEventOutput)
-      if(config.returnResponse){
-        return {response}
-      }
-    const SuccessEvent = config?.events.filter(e => e.eventType === "Success")
-    const setEvent = SuccessEvent.length > 0 ? SuccessEvent : [{ Handler: "mergeFormdata", eventType: "Success", type: config.type }]
-    return { response, events: setEvent };
-  } catch (err) {
-    const FailEvent = config?.events.filter(e => e.eventType === "Fail")
-    const setEvent = FailEvent.length > 0 ? FailEvent : []
-    return { response: undefined, events: setEvent };
   }
-
+  return LoadResponse;
 }
 
-async function executeEventsHandler(
-  config: any, componentName: string,
-  store: any, dynamicData: any, userValue: any,
-  service: any, serviceHolder: any, eventGroups?: any, parentEventOutput?: any
-) {
-  if (config.Handler === "api") {
-    return await executeApiEventHandler(
-      config, componentName,
-      store, dynamicData, userValue,
-      service, serviceHolder, parentEventOutput
-    )
+async function executeEventsHandler(params:handlersProps) {
+  if (params.config.Handler === "api") {
+    return await executeApiEventHandler(params)
   }
-  else if (config.Handler === "inBuiltFunction") {
-    return await executeInBuiltFunctionHandler(
-      config, componentName,
-      store, dynamicData, userValue,
-      service, serviceHolder, parentEventOutput
-    )
+  else if (params.config.Handler === "inBuiltFunction") {
+    return await executeInBuiltFunctionHandler(params)
   }
-  else if (config.Handler === "custom") {
-    return await executeCustomHandler(
-      config, componentName,
-      store, dynamicData, userValue,
-      service, serviceHolder, parentEventOutput
-    )
+  else if (params.config.Handler === "custom") {
+    return await executeCustomHandler(params)
   }
-  else if (config.Handler === "refresh") {
-    return await executeRefreshHandler(
-      config, componentName,
-      store, dynamicData, userValue,
-      service, serviceHolder, parentEventOutput, eventGroups
-    )
+  else if (params.config.Handler === "refresh") {
+    return await executeRefreshHandler(params)
   }
-  else if (config.Handler === "mergeFormdata") {
-    return await mergeFormdata(parentEventOutput, componentName, config, store)
+  else if (params.config.Handler === "mergeFormdata") {
+    return await mergeFormdata(
+    params.parentEventOutput, params.componentName, params.config, params.store)
   }
 }
-async function executeRefreshHandler(
-  refreshConfig: any, componentName: string,
-  store: any, dynamicData: any, userValue: any,
-  service: any, serviceHolder: any, parentEventOutput?: any, eventGroups?: any
-) {
-  const compToRefresh: string[] = getRefreshElements(refreshConfig, eventGroups)
+async function executeRefreshHandler(params:handlersProps) {
+  const compToRefresh: string[] = getRefreshElements(params.config, params.eventGroups)
   for (const componentName of compToRefresh) {
-    for (const compEventConfig of eventGroups.onLoad[componentName]) {
-      await executeEvents(compEventConfig, componentName, store, dynamicData, userValue, service, serviceHolder);
+    for (const compEventConfig of params.eventGroups.onLoad[componentName]) {
+      await executeEvents({...params,config:compEventConfig});
     }
   }
-  return { response: undefined, events: undefined }
 }
-async function executeApiEventHandler(apiHandlerConfig: any, componentName: string,
-  store: any, dynamicData: any, userValue: any,
-  service: any, serviceHolder: any, parentEventOutput?: any) {
-  const initialBody = { ...userValue?.payload };
+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(apiHandlerConfig, initialBody, initialHeaders, store, dynamicData, userValue, service)
-  let response: any;
-  response = await service[apiHandlerConfig.method](
-    apiHandlerConfig.path,
+  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](
+    params.config.path,
     body,
     headers && { headers: headers }
   );
-  if(apiHandlerConfig.returnResponse){
-    return {response}
-  }
-  return { response, events: apiHandlerConfig?.events };;
+  return response;
 }
 
-async function executeInBuiltFunctionHandler(refreshHandlerConfig: any, componentName: string,
-  store: any, dynamicData: any, userValue: any,
-  service: any, serviceHolder: any, parentEventOutput?: any) {
+async function executeInBuiltFunctionHandler(params:handlersProps) {
   let parameter = {};
-  if (refreshHandlerConfig.funcParametersCode) {
-    const makeFunc = eval(refreshHandlerConfig.funcParametersCode)
-    parameter = makeFunc(store, dynamicData, userValue, parentEventOutput, service);
+  if (params.config.funcParametersCode) {
+    const makeFunc = eval(params.config.funcParametersCode)
+    parameter = makeFunc(params.store, params.dynamicData, params.userValue, params.parentEventOutput, params.service);
   }
-  serviceHolder[refreshHandlerConfig.inBuiltFunctionType](parameter)
-  return { response: undefined, events: refreshHandlerConfig?.events };;
+  params.serviceHolder[params.config.inBuiltFunctionType](parameter)
 }
 
-async function executeCustomHandler(customHandlerConfig: any, componentName: string,
-  store: any, dynamicData: any, userValue: any,
-  service: any, serviceHolder: any, parentEventOutput?: any) {
-  console.log(service)
-  const makeFunc = eval(customHandlerConfig.eventCode)
-  const response = await makeFunc(store, dynamicData, userValue, parentEventOutput, service, componentName);
-  return { response: response, events: customHandlerConfig?.events };
+async 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;
 }
 
 async function mergeFormdata(handlerResponse: any, componentName: string, eventConfig: any, store: any) {
-
   if (eventConfig.type === "Select" && !(_.isEmpty(handlerResponse) && handlerResponse)) {
     store.setSchema((pre) => {
       return {
         ...pre, properties: {
           ...pre.properties, [componentName]: {
-            // ...pre?.properties?. [componentName],
-            oneOf: handlerResponse.data
+            enum: handlerResponse.data
           }
         }
       }
@@ -175,16 +104,12 @@ async function mergeFormdata(handlerResponse: any, componentName: string, eventC
     store.setFormdata((pre: any) => { return { ...pre, ...handlerResponse?.data } })
   }
   else {
-    handlerResponse &&
-      store.setFormdata((pre) => { return { ...pre, [componentName]: handlerResponse.data } });
+    if (handlerResponse) {
+      store.setFormdata((pre) => { return { ...pre, [componentName]: handlerResponse } });
+    }
   }
-
-  return { response: undefined, events: undefined }
 }
 
-
-
-
 const buildBodyFormat = (body: any[], formData: any, userValue: any) => {
   const finalBody = { ...userValue?.payload };
   body.map((elem) => {
@@ -217,17 +142,14 @@ const buildHeadersFormat = (headers: any[]) => {
   return headerObj;
 }
 
-async function shouldEventExecute(config, componentName,
-  store, dynamicData, userValue,
-  service, serviceHolder, eventGroups) {
-  const startEvent = config?.events?.filter(e => e.eventType === "onStart");
+async function shouldEventExecute(params:handlersProps) {
+  const startEvent = params.config?.events?.filter(e => e.eventType === "onStart");
   if (startEvent?.length > 0) {
-    const { response } = await executeEventsHandler(startEvent[0], componentName,
-      store, dynamicData, userValue,
-      service, serviceHolder, eventGroups);
+    const { response } = await executeEventsHandler(params);
     return response
   }
 }
+
 export async function buildApiPayload(compConfig: any, body: any, headers: any, store: any, dynamicData: any, userValue: any, service) {
   if (compConfig?.headers) {
     headers = buildHeadersFormat(compConfig.headers)
@@ -244,7 +166,6 @@ export async function buildApiPayload(compConfig: any, body: any, headers: any,
   return { body, headers };
 }
 
-
 export function getRefreshElements(eventConfig: any, eventGropus: any) {
   let result: string[] = [];
   if (eventConfig?.refreshElements?.length > 0) {

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

@@ -0,0 +1,11 @@
+export interface handlersProps {
+    config: any, 
+    componentName: string,
+    store: any,
+     dynamicData: any,
+      userValue: any,
+    service: any, 
+    serviceHolder: any, 
+    eventGroups?: any, 
+    parentEventOutput?: any
+}

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

@@ -1,6 +1,7 @@
 import _ from "lodash";
 import { downloadFile } from "./downloadFile";
 import { executeEvents } from "./events";
+import { handlersProps } from "./interface";
 let compType: string;
 let eventGroups: any = {};
 const notifyUiSchema = {
@@ -25,10 +26,17 @@ export const extractEvents = (eventConfig: any) => {
         if (!eventGroups[event.eventType][eventConfigObj.name]) {
           eventGroups[event.eventType][eventConfigObj.name] = [];
         }
-        eventGroups[event.eventType][eventConfigObj.name].push({ ...event, type: compType });
+        const SuccessEvent = event?.events?.find((elem) => {
+          return elem.eventType === "Success"
+        })
+        if (!(!!SuccessEvent) && event.eventType === "onLoad"  ) {
+          event.events.push({ Handler: "mergeFormdata", eventType: "Success", type: compType })
+         } 
+          eventGroups[event.eventType][eventConfigObj.name].push({ ...event, type: compType })      
       });
     }
   }
+
   extractsConfigEvents(eventConfig)
   if (eventConfig?.elements) {
     eventConfig.elements.forEach(extractEvents);
@@ -46,17 +54,29 @@ interface funcParamsProps {
   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: this, eventGroups
+  };
   return {
     setPage: async function () {
       funcParams.store.setFormdata({});
-      eventGroups = {}
-      eventGroups = extractEvents(funcParams.config)
-      await executeEvents(
-        { Handler: "refresh", eventType: "onPageRefresh" }, "all",
-        funcParams.store, funcParams.dynamicData, funcParams.userValue, funcParams.service,
-        this, eventGroups)
+      executeEventsParameters = {
+        config: {}, componentName: "",
+        store: funcParams.store, dynamicData: funcParams.dynamicData, userValue: funcParams.userValue, service: funcParams.service,
+        serviceHolder: this, eventGroups
+      }
+      await executeEvents({
+        ...executeEventsParameters,
+        config: { Handler: "refresh", eventType: "onPageRefresh" },
+        componentName: "all"
+      })
+      
       funcParams.store.setSchema(
-        (pre:any) => {
+        (pre: any) => {
           return {
             ...funcParams.schema, properties:
               { ...funcParams.schema.properties, ...pre.properties, }
@@ -68,36 +88,38 @@ export default (funcParams: funcParamsProps) => {
     onClick: async function () {
       const path = funcParams.dynamicData?.tableButtonPath || funcParams.dynamicData.path.split(".")[0];
       for (const eventConfig of eventGroups?.onClick[path]) {
-
-        await executeEvents(
-          eventConfig, path,
-          funcParams.store, funcParams.dynamicData, funcParams.userValue, funcParams.service,
-          this, eventGroups)
+        await executeEvents({
+          ...executeEventsParameters,
+          config: eventConfig,
+          componentName: path
+        })
       }
     },
     onPaginationChange: async (paginationValues) => {
       for (const eventConfig of eventGroups?.onLoad[paginationValues.path]) {
-;
         const bodyValues = [
-         {key: "size",value: paginationValues.pagination.pageSize},
-         {key: "start",value: paginationValues.pagination.pageIndex * paginationValues.pagination.pageSize},
-          {key:"filters",value: paginationValues.columnFilters || []},
-          {key:"globalFilter",value: paginationValues.globalFilter ?? ''}
+          { key: "size", value: paginationValues.pagination.pageSize },
+          { key: "start", value: paginationValues.pagination.pageIndex * paginationValues.pagination.pageSize },
+          { key: "sorting", value: paginationValues.sorting || [] },
+          { key: "filters", value: paginationValues.columnFilters || [] },
+          { key: "globalFilter", value: paginationValues.globalFilter ?? '' }
         ]
         if (eventConfig.body) {
-          eventConfig.returnResponse = true
           eventConfig.body = [
             ...eventConfig.body,
             ...bodyValues
           ]
-        } else { 
-          eventConfig.returnResponse = true
-          eventConfig.body = bodyValues; 
-        };
-        await executeEvents(
-          eventConfig, paginationValues.path,
-          funcParams.store, funcParams.dynamicData, funcParams.userValue, funcParams.service,
-          this, eventGroups)
+        } else { eventConfig.body = bodyValues; };
+        const responseEvent = eventConfig?.events?.filter((elem) => {
+          return elem.Handler !== "mergeFormdata"
+        })
+        eventConfig.events = responseEvent??[]
+        const data = await executeEvents({
+          ...executeEventsParameters,
+          config: eventConfig,
+          componentName: paginationValues.path
+        })
+        return data;
       }
     },
     onChange: async function () {
@@ -109,10 +131,11 @@ export default (funcParams: funcParamsProps) => {
             funcParams.store?.newData[componentName] !== undefined
           ) {
             for (const eventConfig of eventGroups.onChange[componentName]) {
-              await executeEvents(
-                eventConfig, componentName,
-                funcParams.store, funcParams.dynamicData, funcParams.userValue, funcParams.service,
-                this, eventGroups)
+              await executeEvents({
+                ...executeEventsParameters,
+                config: eventConfig,
+                componentName
+              })
             }
           }
         }))