datastake-daf 0.6.782 → 0.6.783

package/src/@daf/pages/Template/components/LinkingTemplate/columns.js

@@ -0,0 +1,95 @@
+import { renderType } from './config.js';
+import { renderDateFormatted } from '../../../../../helpers/Forms.js';
+import CustomIcon from '../../../../core/components/Icon/CustomIcon.jsx';
+
+export const getColumns = ({ t, redirect = () => "", mod, mode = "app", options }) => [
+	{
+		title: "ID",
+		dataIndex: "datastakeId",
+		key: "datastakeId",
+	},
+	{
+		title: t("Type"),
+		dataIndex: "type",
+		key: "type",
+		render: (type, all) => renderType({ item: all, t, type }),
+	},
+	{
+		title: t("Name"),
+		dataIndex: "name",
+		key: "name",
+		render: (name, all) => {
+			if (all.empty) {
+				return <div className="daf-default-cell" />;
+			}
+
+			if (all?.form === "products") {
+				const { minerals } = options;
+				const mineral = minerals.find(
+					(mineral) => mineral.value === all?.typeOfProduct,
+				)?.label;
+				return mineral || "--";
+			}
+
+			return name || "--";
+		},
+	},
+	{
+		title: t("Last Update"),
+		dataIndex: "updatedAt",
+		key: "updateAt",
+		render: (updatedAt, all) => {
+			if (all.empty) {
+				return <div className="daf-default-cell" />;
+			}
+
+			return (
+				<div className="daf-default-cell">
+					{renderDateFormatted(updatedAt, "DD MMM YYYY")}
+				</div>
+			);
+		},
+	},
+	{
+		title: "",
+		dataIndex: "actions",
+		width: 50,
+		key: "actions",
+		render: (_, all) => {
+			if (all.empty) {
+				return <div className="daf-default-cell" />;
+			}
+
+			return mode === "proxy" ? (
+				<a
+					onClick={() =>
+						redirect({
+							id: all.datastakeId,
+							type: all.type,
+							mod,
+							mode,
+							item: all,
+						})
+					}
+					href="#"
+				>
+					<CustomIcon name="LinkNewTab" width={14} height={14} color="#6C737F" />
+				</a>
+			) : (
+				<a
+					href={redirect({
+						id: all.datastakeId,
+						type: all.type,
+						mod,
+						mode,
+						item: all,
+					})}
+					target="_blank"
+					rel="noreferrer"
+				>
+					<CustomIcon name="LinkNewTab" width={14} height={14} color="#6C737F" />
+				</a>
+			);
+		},
+	},
+];

package/src/@daf/pages/Template/components/LinkingTemplate/config.js

@@ -0,0 +1,75 @@
+import React from "react";
+import { capitalizeAll } from '../../../../../helpers/StringHelper.js';
+
+
+export const decapitalize = string => 
+	string && string.charAt(0).toLowerCase() + string.slice(1);
+
+const formatRedirectString = (stringItem) => {
+	let string;
+	if (stringItem.includes("nashiriki")) {
+		string = decapitalize(stringItem?.replaceAll("nashiriki", ""));
+	} else {
+		string = stringItem;
+	}
+	return string;
+};
+
+export const getLanguage = (lng = "") => {
+	if (lng.includes("en")) {
+		return "en";
+	}
+
+	if (lng.includes("fr")) {
+		return "fr";
+	}
+};
+
+export const redirect = ({ id, item }) => {
+	const viewMode = "view";
+	let type = "testimonials";
+
+	if (item.category === "mineSite") {
+		type = "scl";
+	}
+
+	if (item.stakeholderType === "operator") {
+		type = "operators";
+	}
+
+	if (item.stakeholderType === "worker") {
+		type = "workers";
+	}
+
+    if (item.form) {
+		type = `${formatRedirectString(item.form)}s`;
+	}
+
+	let url = `/${viewMode}/${type}/${id}`;
+
+	return `/app${url}`;
+};
+
+export const renderType = ({ item = {}, t = (s) => s }) => {
+	if (item.empty) {
+		return <div className="daf-default-cell" />;
+	}
+
+	if (item.category === "mineSite") {
+		return t("Mine Site");
+	}
+
+	if (item.stakeholderType === "operator") {
+		return t("Operator");
+	}
+
+	if (item.stakeholderType === "worker") {
+		return t("Worker");
+	}
+
+	if (item.form) {
+		return t(capitalizeAll(item.form));
+	}
+
+	return "--";
+};

package/src/@daf/pages/Template/components/LinkingTemplate/index.jsx

@@ -0,0 +1,119 @@
+import React, { useEffect, useMemo } from 'react';
+import { useFilters } from '../../../../hooks/useFilters.js';
+import { getColumns } from './columns.js';
+import { redirect } from './config.js';
+import LinkedSubjectsService from '../../../../services/LinkedSubjects.js';
+import { formatClassname } from '../../../../../helpers/ClassesHelper.js';
+import Table from '../../../../core/components/Table/index.jsx';
+import Pagination from '../../../../core/components/Table/Pagination/index.jsx';
+
+const emptyObject = {};
+
+const LinkingTemplate = ({
+    conf,
+    namespace
+}) => {
+    const view = useMemo(() => conf?.location?.pathname?.split(`/app/${conf.mod}/`)[1], [conf]);
+
+    const {
+		pagination,
+		onTableChange,
+		totalPages,
+		canGoNext,
+		canGoPrev,
+		setPagination,
+		goPrev,
+		goNext,
+	} = useFilters({
+		module: conf.mod,
+		view,
+		selectFiltersConfig: emptyObject,
+		filtersConfig: emptyObject,
+	});
+
+    const columns = useMemo(() => getColumns({
+		t: conf.t,
+		redirect,
+		mod: conf.mod,
+		language: conf.user?.language,
+		mode: conf.mode,
+		options: conf.options,
+	}), [conf]);
+
+    const id = conf.allData.id;
+
+    const dataSource = conf?.linkingTemplateContextData?.[id];
+
+    const changeData = async () => {
+		try {
+			const _data = await LinkedSubjectsService.getLinkedSubjects({ namespace, id, mod: conf.mod });
+			const data = (_data?.data || []).map((d, i) => ({ ...d, key: `${d.id}-${i}` }));
+			conf?.addData(id, data);
+			setPagination((prev) => ({
+				...prev,
+				current: 1,
+				total: data.length ? data.length : 1,
+			}));
+		} catch (err) {
+			console.log(err);
+		}
+	};
+
+    const _dataSource = useMemo(() => {
+		const startIndex = pagination.pageSize * (pagination.current - 1);
+		const endIndex = Math.min(startIndex + pagination.pageSize, dataSource?.length || 0);
+		return [...(dataSource || [])].slice(startIndex, endIndex);
+	}, [pagination, dataSource]);
+
+    useEffect(() => {
+		if (!dataSource) {
+			changeData();
+		} else {
+			setPagination((prev) => ({
+				...prev,
+				current: 1,
+				total: dataSource.length ? dataSource.length : 1,
+			}));
+		}
+	}, []);
+
+
+    return ( <div className={formatClassname(["content", "documents-layout"])} style={{}}>
+            <div className="view-header" style={{ flexDirection: "column", paddingTop: 0 }}>
+                <div className="daf-table-wrapper pagination-no-padding">
+                    <Table
+                        className="mt-0 p-0"
+                        columns={columns}
+                        hideOnLoading={false}
+                        data={_dataSource}
+                        doEmptyRows
+                        loading={!dataSource}
+                        rowKey="key"
+                        pagination={pagination}
+                        size="small"
+                    />
+
+                    <Pagination
+                        t={conf?.t}
+                        isMobile={conf?.isMobile}
+                        page={pagination.current}
+                        totalPages={totalPages}
+                        goPrev={goPrev}
+                        goNext={goNext}
+                        canGoNext={canGoNext}
+                        canGoPrev={canGoPrev}
+                        totalItems={pagination.total}
+                        doTotalItems
+                        onChangePagination={(val) => {
+                            onTableChange({ ...pagination, current: 1, pageSize: val });
+                        }}
+                        perPage={pagination.pageSize}
+                        arrowIcons
+                    />
+                </div>
+            </div>
+        </div>
+    )
+};
+
+export default LinkingTemplate;

package/src/@daf/pages/Template/index.jsx

@@ -0,0 +1,19 @@
+/* eslint-disable react/prop-types */
+import React from 'react';
+import LinkingTemplate from './components/LinkingTemplate/index.jsx';
+
+export function Template({
+  conf,
+  namespace,
+}) {
+  switch (namespace) {
+    case 'locations':
+    case 'documents':
+    case 'stakeholders':
+    case 'events':
+      return <LinkingTemplate conf={conf} namespace={namespace} />
+    default:
+      return null;
+
+  }
+}

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,
+    }
+
+}