datastake-daf 0.6.778 → 0.6.780

package/src/@daf/pages/Summary/Activities/PlantingCycle/components/AssociatedInformation/index.jsx

@@ -50,6 +50,7 @@ const AssociatedInformation = ({
 }) => {
     const [activeTab, setActiveTab] = useState(ACTIVITIES_TAB);
     const [search, setSearch] = useState('');
+
     
     const searchFields = useMemo(() => searchFieldsMap(activeTab), [activeTab, searchFieldsMap]);
     

package/src/@daf/pages/Summary/Activities/PlantingCycle/components/PlantingLocations/index.jsx

@@ -1,6 +1,9 @@
 import React, { useMemo } from 'react';
 import { Widget, MineSiteMap } from '../../../../../../../../src/index.js';
 import { useWidgetFetch } from '../../../../../../hooks/useWidgetFetch.js';
+import { convertDMS } from '../../../../../../../../src/helpers/Map';
+import CustomIcon from '../../../../../../../../src/@daf/core/components/Icon/CustomIcon.jsx';
+import { renderDateFormatted } from '../../../../../../../../src/helpers/Forms';
 
 const PlantingLocations = ({
     id,
@@ -76,6 +79,8 @@ const PlantingLocations = ({
          
             const color = "#15FFFFB2"
 
+            const locationName = matchingLocation?.name || locationCheckArrival.name || 'Planting Location';
+
             return {
                 _id: locationCheckArrival._id || event._id || {},
                 area: area,
@@ -83,13 +88,16 @@ const PlantingLocations = ({
                 datastakeId: `LOC-${String(index + 1).padStart(9, '0')}`,
                 gps: gps,
                 id: matchingLocation?.id || locationCheckArrival._id || `event-${index}`,
-                name: locationCheckArrival.name || matchingLocation?.name || `Event ${index + 1}`,
+                name: event.name || t("Activity Start"),
+                date: event.date,
                 sources: 1,
-                subTitle: locationCheckArrival.name || matchingLocation?.name || 'Planting Location',
+                subTitle: event.date ? renderDateFormatted(event.date, "DD MMM YY") : locationName,
+                plotName: locationName,
+                territoryTitle: locationName,
                 type: 'Planting Location'
             };
         });
-    }, [plantingLocationsData]);
+    }, [plantingLocationsData, t]);
 
     return (
         <section>
@@ -107,7 +115,55 @@ const PlantingLocations = ({
                     onClickLink={() => { }}
                     onFilterChange={() => { }}
                     primaryLink
-                    renderTooltip={() => { }}
+                    renderTooltipForLocation={(data) => {
+                        const coordinates = data.gps?.latitude && data.gps?.longitude
+                            ? convertDMS(data.gps.latitude, data.gps.longitude)
+                            : null;
+
+                        if (!coordinates) {
+                            return [];
+                        }
+
+                        const iconColor = "#016C6E"; // Activity Start color
+
+                        return [
+                            {
+                                label: t("Coordinates"),
+                                value: (
+                                    <div style={{ display: 'flex', alignItems: 'center', gap: '6px', flexWrap: 'nowrap' }}>
+                                        {/* Latitude icon (vertical) */}
+                                        <div style={{ display: 'flex', alignItems: 'center' }}>
+                                            <CustomIcon 
+                                                name="SpacingHeight" 
+                                                width={14} 
+                                                height={14} 
+                                                color={iconColor}
+                                            />
+                                            <span style={{ fontWeight: 600, marginLeft: '4px' }}>{coordinates[0]}</span>
+                                        </div>
+                                        {/* Longitude icon (horizontal) */}
+                                        <div style={{ display: 'flex', alignItems: 'center' }}>
+                                            <CustomIcon 
+                                                name="SpacingWidth" 
+                                                width={14} 
+                                                height={14} 
+                                                color={iconColor}
+                                            />
+                                            <span style={{ fontWeight: 600, marginLeft: '4px' }}>{coordinates[1]}</span>
+                                        </div>
+                                    </div>
+                                ),
+                            },
+                        ];
+                    }}
+                    renderTooltipForTerritory={(data) => {
+                        return [
+                            {
+                                label: t("Plot Name"),
+                                value: data.plotName || data.name || "--",
+                            },
+                        ];
+                    }}
                     renderTooltipTags={() => { }}
                     type="location-territory"
                 />

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,75 @@
+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] &&
+        namespaceConfig.supportedNamespaces[APP].includes(namespace)
+      : namespaceConfig.supportedNamespaces[APP] && namespaceConfig.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,
+      };
+}