datastake-daf 0.6.830 → 0.6.831

package/src/@daf/hooks/useWidgetFetch.js

@@ -1,5 +1,7 @@
 import { useState, useEffect } from "react";
 import DashboardService from "../services/DashboardService.js";
+import { isErrorResponse, getErrorMessage } from "../../helpers/errorHandling.js";
+import { message } from "antd";
 
 // config: {
 //     stop: boolean,
@@ -25,6 +27,11 @@ export const useWidgetFetch = ({config, getData = DashboardService.getWidget, on
 		try {
 			const { data } = await getData(rest);
 			setData(data || defaultData);
+			if (isErrorResponse(data)) {
+				const errorMessage = getErrorMessage(data);
+				message.error(errorMessage);
+				return;
+			}
             onFetch()
 		} catch (err) {
 			console.log(err);

package/src/@daf/layouts/AppLayout/components/MobileDrawer/index.js

@@ -109,7 +109,7 @@ export default function MobileDrawer({
         { 
           type: 'link', 
           name: t('Settings'), 
-          path: `/app/${mod}/view/settings`, 
+          path: `/app/view/settings`, 
           isDashboard: true, 
           visible: canViewSettings 
         },

package/src/@daf/pages/Summary/hook.js

@@ -1,6 +1,8 @@
 import { useState, useMemo, useCallback, useEffect } from "react"
 import { debounce } from "lodash";
 import { StorageManager } from "../../../helpers/StorageManager.js";
+import { isErrorResponse, getErrorMessage } from "../../../helpers/errorHandling.js";
+import { message } from "antd";
 
 export const useSummary = ({
     getOne, 
@@ -131,32 +133,63 @@ export const useSummary = ({
 	  }, [debouncedSearch]);
 
       useEffect(() => {
-		if (_partners !== undefined) {
-			if ((params?.id !== null || (isPdf && id !== null)) && !hasSelect) {
-				getOne({ datastakeId: params?.id || id, sources: _partners });
-			}
-		}
+		// if (_partners !== undefined) {
+		// 	if ((params?.id !== null || (isPdf && id !== null)) && !hasSelect) {
+		// 		getOne({ datastakeId: params?.id || id, sources: _partners });
+		// 	}
+		// }
 		if (hasSelect && !params?.id) {
 			getMultiple(filters);
 		}
-	}, [params?.id, hasSelect, getOne, getMultiple, _partners, isPdf, id, filters]);
+	}, [hasSelect, params?.id, filters]);
 
-    	useEffect(() => {
-		if ((selectedItem || params?.id) && _partners !== undefined) {
-			const fetchSingleItem = async () => {
-				setLoading(true);
-				try {
-					const { data } = await service.getOne(selectedItem || params?.id, { sources: _partners });
-					setSingleItemData(data);
-				} catch (error) {
+	const activeId = useMemo(() => {
+		return selectedItem || params?.id;
+	}, [selectedItem, params?.id]);
+
+	const memoizedPartners = useMemo(() => {
+		return _partners;
+	}, [_partners]);
+
+	const memoizedService = useMemo(() => {
+		return service;
+	}, [service]);
+
+	useEffect(() => {
+		if (!activeId || memoizedPartners === undefined) return;
+		
+		let cancelled = false;
+		
+		const fetchSingleItem = async () => {
+			setLoading(true);
+			try {
+				const { data } = await memoizedService.getOne(activeId, { sources: memoizedPartners });
+				
+				if (cancelled) return;
+				
+				setSingleItemData(data);
+				if (isErrorResponse(data)) {
+					const errorMessage = getErrorMessage(data);
+					message.error(errorMessage);
+					return;
+				}
+			} catch (error) {
+				if (!cancelled) {
 					console.log(error);
-				} finally {
+				}
+			} finally {
+				if (!cancelled) {
 					setLoading(false);
 				}
-			};
-			fetchSingleItem();
-		}
-	}, [selectedItem, service, _partners, params?.id]);
+			}
+		};
+		
+		fetchSingleItem();
+		
+		return () => {
+			cancelled = true;
+		};
+	}, [activeId, memoizedPartners, memoizedService]);
 
     useEffect(() => {
 		_setPartners(selectedPartners?.partners);

package/src/@daf/services/MineSiteService.js

@@ -0,0 +1,104 @@
+import { BaseService } from "./BaseService.js";
+import { createLazyService } from "./helpers/LazyService.js";
+import { filterCreateData } from "../../helpers/Forms.js";
+
+class MineSiteService extends BaseService {
+	get(params) {
+		const { datastakeId, ...rest } = params;
+		if(datastakeId) {
+			return this.apiGet({
+				url: `/location/${datastakeId}`,
+				params: {...rest},
+				isApp: true,
+			});
+		}
+		return this.apiGet({
+			url: "/location",
+			params: {...rest},
+			isApp: true,
+		});
+	}
+
+	getOne(id, params) {
+		return this.apiGet({
+			url: `/location/${id}`,
+			params,
+			isApp: true,
+		});
+	}
+
+	getForm(scope = "create", language = "en") {
+		return this.apiGet({
+			url: `/forms/location`,
+			params: { scope, language },
+			isApp: true,
+		});
+	}
+
+	getAll(params, signal) {
+		return this.apiGet({
+			url: "/location",
+			params,
+			signal,
+			isApp: true,
+		});
+	}
+
+	getData(id, sourceId, source, version) {
+		return this.apiGet({
+			url: `/location/${id}`,
+			isApp: true,
+			params: { authorId: sourceId,  source, version },
+		});
+	}
+
+	submit(payload) {
+		if (payload.id) {
+			// eslint-disable-next-line no-unused-vars
+			const { namespace, ...data } = payload;
+			return this.apiPut({
+				url: `/location/${payload.id}`,
+				data: filterCreateData(data),
+				isApp: true,
+			});
+		}
+		if (payload?.form) {
+			delete payload.form;
+			return this.apiPost({
+				url: "/location",
+				data: filterCreateData(payload),
+				isApp: true,
+			});
+		}
+		return this.apiPost({
+			url: "/location",
+			data: filterCreateData(payload),
+			isApp: true,
+		});
+	}
+
+	submitStep(data, id) {
+		return this.apiPut({
+			isApp: true,
+			url: `/location/submit/${id}`,
+			data: filterCreateData(data),
+		});
+	}
+
+	remove(id, data) {
+		return this.apiDelete({
+			url: `/location/${id}/remove`,
+			data: data,
+			isApp: true,
+		});
+	}
+
+	getOptions(id = "countries,minerals") {
+		return this.apiGet({
+			isApp: true,
+			url: `/forms/options`,
+			params: { id },
+		});
+	}
+}
+export default createLazyService(MineSiteService);

package/src/helpers/user.js

@@ -146,7 +146,7 @@ export const userHasInterface = (user, app, intf) => {
 };
 
 export const userIsAdmin = (user) => {
-  return user?.role?.id === 'APP_ADMIN';
+  return user?.role?.id === 'APP_ADMIN' || user?.role?.id === 'SUPER_ADMIN';
 }
 
 export const createModule = (selectedModule, role = "user") => {
@@ -193,3 +193,18 @@ export function getRedirectPath(user, fallback = '', app, isDatastake) {
 
   return isDatastake ? `/${app}/app` : '/app';
 }
+
+
+export function mapUser(user) {
+  return {
+    ...user,
+    company: user.company,
+    verified: user.emailVerified,
+    companyId: user?.company?.id,
+    modules: Array.isArray(user.company?.modules) ?
+      user.company?.modules.reduce((all, item) => {
+        all[item.id] = item;
+        return all;
+      }, {}) : user.company?.modules || {},
+  };
+}

package/src/services.js

@@ -20,4 +20,5 @@ export { default as LinkedSubjectsService } from './@daf/services/LinkedSubjects
 export { default as OperatorService } from './@daf/services/OperatorService.js';
 export { default as PartnerService } from './@daf/services/PartnerService.js';
 export { default as EventsService } from './@daf/services/EventsService.js';
-export { default as WorkersService } from './@daf/services/WorkersService.js';
+export { default as WorkersService } from './@daf/services/WorkersService.js';
+export { default as MineSiteService } from './@daf/services/MineSiteService.js';

package/src/utils.js

@@ -21,7 +21,7 @@ export { getOptionConfig, getOptionLabel } from './@daf/core/components/DynamicV
 
 export { defaultMapConfig } from './@daf/hooks/useMapHelper.js';
 
-export { getInterface, modules, isSuperAdmin, isModuleApproved, userHasInterface, userIsAdmin, createModule, mapModulesFromApps, getRedirectPath } from './helpers/user.js'
+export { getInterface, modules, isSuperAdmin, isModuleApproved, userHasInterface, userIsAdmin, createModule, mapModulesFromApps, getRedirectPath, mapUser } from './helpers/user.js'
 
 export { default as locales } from './constants/locales/index.js';