datastake-daf 0.6.782 → 0.6.784

package/src/@daf/pages/View/hooks/useCallToGetData.js

@@ -0,0 +1,73 @@
+import { useRef, useEffect } from "react";
+import { hasKeyInObject } from "../../../../@daf/utils/object.js";
+import { getNkey } from "../../../../@daf/core/components/ViewForm/helper.js";
+
+export const useCallToGetData = ({
+    namespaceConfig,
+    namespace,
+    allData,
+    id,
+    isSupported,
+    namespaceGet,
+    source,
+    version,
+    user,
+    setLoading,
+    APP,
+  }) => {
+    const isFirstRender = useRef(true);
+  
+    const callToGetData = (_doCall = false) => {
+          const dKey = namespaceConfig?.dataKey;
+          const nKey = `${APP}-${getNkey(namespace || "")}`;
+          const doCall = _doCall
+              ? true
+              : hasKeyInObject(allData, dKey) && hasKeyInObject(allData[dKey], nKey)
+              ? allData[dKey][nKey]?.data?.datastakeId !== id
+              : true;
+          if (doCall) {
+              if (isSupported) {
+                  namespaceGet[namespace]();
+              }
+          }
+      };
+  
+    useEffect(() => {
+          if (isFirstRender.current) {
+              isFirstRender.current = false;
+              return;
+          }
+          callToGetData(true);
+      }, [source, version]);
+  
+    useEffect(() => {
+          callToGetData(true);
+      }, [id, namespace, user.language]);
+  
+    const onStorageUpdate = (e) => {
+          const { key, newValue } = e;
+          if (key === `${id}-loading` && newValue) {
+              setLoading(newValue);
+          }
+          if (key === `${id}-updated` && newValue) {
+              setLoading(true);
+              callToGetData();
+          }
+      };
+  
+      useEffect(() => {
+          window.addEventListener("storage", onStorageUpdate);
+          return () => {
+              window.removeEventListener("storage", onStorageUpdate);
+          };
+      }, []);
+  
+    // useEffect(() => {
+    //       setLoading(true);
+    //   }, [namespace]);
+  
+  
+    return {
+      callToGetData,
+    }
+  }

package/src/@daf/pages/View/hooks/usePrepareForm.js

@@ -0,0 +1,86 @@
+import { useState, useEffect } from "react";
+import { hasKeyInObject } from "../../../../@daf/utils/object.js";
+
+export const usePrepareForm = ({
+    namespaceConfig,
+    allData,
+    id,
+    namespace,
+    t,
+    mode,
+    APP,
+    viewConfig,
+  }) => {
+    const [form, setForm] = useState({});
+      const [data, setData] = useState({});
+      const [groups, setGroups] = useState({});
+      const [linkingForms, setLinkingForms] = useState({});
+      const [loading, setLoading] = useState(true);
+      const [notFound, setNotFound] = useState(false);
+  
+    const prepareForm = (currentView) => {
+          const dKey = namespaceConfig?.dataKey;
+          const nKey = `${APP}-${currentView}`;
+  
+          if (hasKeyInObject(allData, dKey) && hasKeyInObject(allData[dKey], nKey)) {
+              const {
+                  form = {},
+                  data = {},
+                  config = {},
+                  linkingForms = {},
+              } = JSON.parse(JSON.stringify(allData[dKey][nKey] || {}));
+  
+              if (data.datastakeId === id || id === "user") {
+                //   if (viewConfig.linkingSubjects.includes(namespace)) {
+                      setForm({
+                          ...form,
+                          linking: {
+                              position: 100,
+                              excludeFromEdit: true,
+                              label: t("Linked Subjects"),
+                              template: "linkingSubjects",
+                          },
+                      });
+                //   } else {
+                //       setForm(form);
+                //   }
+                  setData(data);
+                  setGroups(config.groups || {});
+                  setLinkingForms(linkingForms);
+                  setLoading(false);
+                  setNotFound(false);
+              } else if (!data.id) {
+                  if (mode === "proxy") {
+                      window.location.reload();
+                  } else {
+                      setLoading(false);
+                      setNotFound(true);
+                  }
+              }
+          }
+      };
+  
+    const getCertainData = allData?.[namespaceConfig?.dataKey];
+  
+      useEffect(() => {
+          if(namespace && namespaceConfig) {
+              prepareForm(namespaceConfig?.view);
+          }
+      }, [getCertainData, namespaceConfig]);
+  
+    return {
+      form,
+      setForm,
+      data,
+      setData,
+      groups,
+      setGroups,
+      linkingForms,
+      setLinkingForms,
+      loading,
+      setLoading,
+      notFound,
+      setNotFound,
+      prepareForm,
+    }
+  }

package/src/@daf/pages/View/hooks/useSubmitSubject.js

@@ -0,0 +1,40 @@
+import { useState, useCallback } from "react";
+
+export const submitSubjectData = async (namespace, data, serviceMap) => {
+    const service = serviceMap[namespace];
+    if (!service) {
+      throw new Error(`No service found for namespace: ${namespace}`);
+    }
+  
+    const response = await service.submitStep(
+      data,
+      data.datastakeId || data.id
+    );
+    return response.data;
+};
+
+export const useSubmitSubject = ({namespace, data, serviceMap}) => {
+    const [isDisabled, setIsDisabled] = useState(false);
+    const [loading, setLoading] = useState(false);
+    const [isPublished, setIsPublished] = useState(false);
+  
+    const submitSubject = useCallback(async () => {
+      try {
+        setLoading(true);
+        const response = await submitSubjectData(namespace, data, serviceMap);
+        setIsDisabled(response.published);
+        setIsPublished(response.published);
+      } catch (error) {
+        console.error("Submit error:", error);
+      } finally {
+        setLoading(false);
+      }
+    }, [namespace, data]);
+  
+    return {
+      submitSubject,
+      isDisabled,
+      submitLoading: loading,
+      isPublished,
+    };
+};

package/src/@daf/pages/View/hooks/useViewActions.js

@@ -0,0 +1,83 @@
+import { useState, useEffect } from "react";
+
+export const useViewActions = ({
+    namespace,
+    data,
+    isSupported,
+    canEdit,
+    versionUrl,
+    sourceUrl,
+    getEditLink,
+    submitSubject,
+    isDisabled,
+    setOpenRecordsModal,
+    goBackFromSource,
+    push,
+    getRedirectLink,
+    t,
+    viewConfig,
+    buttonActions,
+  }) => {
+    const [pageActions, setPageActions] = useState([]);
+    const [extraPageActions, setExtraPageActions] = useState([]);
+  
+    useEffect(() => {
+      const actions = [];
+      const extraActions = [];
+  
+      if (!isSupported) {
+        setPageActions([]);
+        setExtraPageActions([]);
+        return;
+      }
+  
+      if (canEdit) {
+        if (viewConfig.namespacesWithoutActionButtons.includes(namespace)) {
+          if (viewConfig.editOnlyButton.includes(namespace)) {
+            if (versionUrl && sourceUrl) {
+              actions.push(buttonActions.createBackButton(t, goBackFromSource));
+            } else {
+              actions.push(buttonActions.createEditButton(t, getEditLink));
+            }
+          }
+        } else {
+          if (versionUrl && sourceUrl) {
+            actions.push(buttonActions.createBackButton(t, goBackFromSource));
+          } else {
+            actions.push(buttonActions.createSubmitButton(t, submitSubject, isDisabled, data));
+            actions.push(buttonActions.createEditButton(t, getEditLink));
+            // actions.push(createRecordsButton(t, setOpenRecordsModal));
+          }
+        }
+      }
+  
+      if (viewConfig.summaryNamespaces.includes(namespace)) {
+        extraActions.push(
+          buttonActions.createSummaryButton(t, namespace, data, push, getRedirectLink)
+        );      
+        extraActions.push(
+          buttonActions.createRecordsButton(t, setOpenRecordsModal)
+        );
+      }
+  
+      setPageActions(actions);
+      setExtraPageActions(extraActions);
+    }, [
+      namespace,
+      data,
+      isSupported,
+      canEdit,
+      versionUrl,
+      sourceUrl,
+      isDisabled,
+      t,
+      getEditLink,
+      submitSubject,
+      goBackFromSource,
+      setOpenRecordsModal,
+      push,
+      getRedirectLink,
+    ]);
+  
+    return { pageActions, extraPageActions };
+  };

package/src/@daf/pages/View/hooks/useViewPermissions.js

@@ -0,0 +1,74 @@
+import { useMemo, useEffect } from "react";
+
+export const useViewPermissions = ({
+    data,
+    id,
+    namespaceOverrides = {
+        supportedNamespaces: {},
+        canEdit: {},
+      },
+    namespace,
+    user,
+    push,
+    getRedirectLink,
+    namespaceConfig,
+    APP,
+    viewConfig,
+}) => {
+    const baseNamespaceKeys = Object.keys(namespaceConfig || {});
+
+    const baseSupportedNamespaces = baseNamespaceKeys?.reduce((acc, key) => {
+      acc[key] = () => true;
+      return acc;
+    }, {});
+
+    const isSupportedNamespaces = useMemo(
+        () => ({
+          ...baseSupportedNamespaces,
+          ...namespaceOverrides?.supportedNamespaces,
+        }),
+        [data, id],
+    );
+
+    const isSupported = typeof isSupportedNamespaces[namespace] === "function"
+      ? isSupportedNamespaces[namespace]() &&
+        viewConfig?.supportedNamespaces[APP] &&
+        viewConfig?.supportedNamespaces[APP]?.includes(namespace)
+      : viewConfig?.supportedNamespaces[APP] && viewConfig?.supportedNamespaces[APP].includes(namespace);
+
+
+      const isUserData = () => {
+		return data && data.authorId && user?.company?.id === data.authorId;
+	};
+
+    const canEdit = useMemo(() => {
+        const baseCanEditAction = baseNamespaceKeys.reduce((acc, key) => {
+        acc[key] = () => isUserData();
+        return acc;
+        }, {});
+
+        const canEditAction = {
+        ...baseCanEditAction,
+        ...namespaceOverrides.canEdit,
+        };
+        
+        return canEditAction[namespace] ? canEditAction[namespace]() : false;
+    }, [namespace, data, user]);
+
+    useEffect(() => {
+            if (data) {
+                if (typeof isSupportedNamespaces[namespace] === "function") {
+                    if (!isSupportedNamespaces[namespace]()) {
+                        push(getRedirectLink(`/app`));
+                    }
+                }
+            }
+        }, [data, namespace]);
+
+    return {
+        isSupportedNamespaces,
+        canEdit,
+        isSupported,
+    }
+
+}

package/src/@daf/pages/View/hooks/useViewUrlParams.js

@@ -0,0 +1,93 @@
+import { useState, useEffect, useCallback, useMemo } from "react";
+
+export const useViewUrlParams = ({
+    params,
+    push,
+    pathname,
+    search,
+    searchParams,
+    setSearchParams,
+}) => {
+    const [namespace, setNamespace] = useState(params?.namespace);
+    const [id, setId] = useState(params?.id);
+    const [group, setGroup] = useState(params?.group);
+    const [subsection, setSubSection] = useState(params?.subsection);
+    const sourceUrl = searchParams.get("source");
+    const versionUrl = searchParams.get("version");
+    const [source, setSource] = useState(sourceUrl || null);
+    const [version, setVersion] = useState(versionUrl || null);
+
+    useEffect(() => {
+        if ((id && params.id !== id) || (namespace && namespace !== params.namespace)) {
+          setGroup(undefined);
+          setSubSection(undefined);
+          // setSubGroup(undefined);
+        } else {
+          setGroup(params.group);
+          setSubSection(params.subsection);
+          // setSubGroup(params.subgroup);
+        }
+        setNamespace(params.namespace);
+        setId(params.id);
+    }, [params]);
+
+    useEffect(() => {
+        if (source && version) {
+          const newParams = new URLSearchParams(searchParams);
+          newParams.set("source", source);
+          newParams.set("version", version);
+          setSearchParams(newParams);
+        }
+    }, [source, version]);
+
+    const goBackFromSource = useCallback(() => {
+        const params = new URLSearchParams(searchParams);
+        params.delete("source");
+        params.delete("version");
+        setSearchParams(params);
+        setVersion(null);
+        setSource(null);
+      }, [searchParams, setSearchParams]);
+  
+      const getEditLink = useCallback((srcId) => {
+        const r = new RegExp(`\/view\/`);
+        const [previous, extra] = pathname.split(r);
+    
+        if (srcId) {
+          push(`${previous}/edit/${extra}?sourceId=${srcId}`);
+          return;
+        }
+    
+        if (search) {
+          push(`${previous}/edit/${extra}${search}`);
+        } else {
+          push(`${previous}/edit/${extra}`);
+        }
+      }, [pathname, search, push]);
+    
+      const match = useMemo(
+        () => ({
+          params,
+          path: pathname,
+        }),
+        [params, pathname],
+    );
+
+    return { 
+        namespace, 
+        id, 
+        group, 
+        subsection, 
+        params, 
+        source,
+        setSource,
+        sourceUrl,
+        version,
+        setVersion,
+        versionUrl,
+        goBackFromSource,
+        getEditLink,
+        match,
+        search,
+      };
+}