datastake-daf 0.6.816 → 0.6.817

package/src/@daf/pages/Summary/Activities/MonitoringCampaign/components/chartHelpers.js

@@ -59,80 +59,6 @@ export const calculateNiceAxisConfig = (data, valueField = 'value', multiplier =
     };
 };
 
-/**
- * Calculate y-axis configuration with natural numbers (integers) only
- * Always starts from 0 and extends slightly above max for better visualization
- * @param {number} maxValue - Maximum value from the data
- * @param {Object} options - Optional configuration
- * @param {number} options.minTicks - Minimum number of ticks to show (default: 4)
- * @param {number} options.maxTicks - Maximum number of ticks to show (default: 6)
- * @returns {Object} Axis configuration with min, max, and tickMethod
- */
-export const calculateNaturalAxisConfig = (maxValue, options = {}) => {
-    const { minTicks = 4, maxTicks = 6 } = options;
-    
-    if (maxValue <= 0) {
-        return {
-            min: 0,
-            max: 4,
-            tickMethod: () => [0, 1, 2, 3, 4]
-        };
-    }
-
-    // For very small values (max <= 1), always show 0, 1, 2, 3, 4
-    if (maxValue <= 1) {
-        return {
-            min: 0,
-            max: 4,
-            tickMethod: () => [0, 1, 2, 3, 4]
-        };
-    }
-
-    // Calculate appropriate step size based on max value
-    let step = 1;
-    let displayMax = maxValue;
-
-    if (maxValue <= 5) {
-        // For small values, use step of 1 and extend a bit above
-        step = 1;
-        displayMax = Math.max(5, Math.ceil(maxValue * 1.5));
-    } else if (maxValue <= 10) {
-        // For medium-small values, use step of 2
-        step = 2;
-        displayMax = Math.ceil((maxValue * 1.2) / step) * step;
-    } else if (maxValue <= 20) {
-        // For medium values, use step of 5
-        step = 5;
-        displayMax = Math.ceil((maxValue * 1.2) / step) * step;
-    } else if (maxValue <= 50) {
-        // For larger values, use step of 10
-        step = 10;
-        displayMax = Math.ceil((maxValue * 1.2) / step) * step;
-    } else {
-        // For very large values, calculate step to get 4-6 ticks
-        const targetTicks = Math.min(maxTicks, Math.max(minTicks, Math.ceil(maxValue / 20)));
-        step = Math.ceil(maxValue / targetTicks / 10) * 10; // Round to nearest 10
-        displayMax = Math.ceil((maxValue * 1.2) / step) * step;
-    }
-
-    // Generate ticks from 0 to displayMax
-    const ticks = [];
-    for (let i = 0; i <= displayMax; i += step) {
-        ticks.push(i);
-    }
-
-    // Ensure max value is included if it's close
-    if (ticks[ticks.length - 1] < maxValue && maxValue - ticks[ticks.length - 1] <= step / 2) {
-        ticks.push(maxValue);
-    }
-
-    return {
-        min: 0,
-        max: displayMax,
-        tickMethod: () => ticks
-    };
-};
-
 /**
  * Merge default categories with backend data
  * Ensures all categories are displayed even if they have no data

package/src/@daf/pages/TablePage/config.js

@@ -16,7 +16,7 @@ export const getSelectFiltersConfig = ({ subject }) => {
 
 export const getFiltersConfig = ({ t, subject }) => {
   const registry = FILTER_REGISTRY[subject] || FILTER_REGISTRY[DEFAULT_SUBJECT];
-  return registry?.config({ t });
+  return registry?.config({ t , screen: subject});
 };
   
 export const getFilterOptions = ({ t, subject, options }) => {

package/src/@daf/pages/TablePage/helper.js

@@ -22,6 +22,14 @@ import {
 } from '../Stakeholders/Workers/config.js';
 import { getColumns as getColumnsWorkers } from "../Stakeholders/Workers/columns.js";
 
+import { 
+    getFiltersConfig as getFiltersConfigArmedGroups, 
+    getFilterOptions as getFilterOptionsArmedGroups,
+    formConfig as formConfigArmedGroups,
+    viewConfig as viewConfigArmedGroups
+} from '../Stakeholders/ArmedGroups/config.js';
+import { getColumns as getColumnsArmedGroups } from "../Stakeholders/ArmedGroups/columns.js";
+
 import { 
     getFiltersConfig as getFiltersConfigEvents, 
     getFilterOptions as getFilterOptionsEvents,
@@ -45,6 +53,14 @@ import {
     viewConfig as viewConfigIncidents
 } from '../Events/Incidents/config.js';
 import { getColumns as getColumnsIncidents } from "../Events/Incidents/columns.js";
+
+import { 
+    getFiltersConfig as getFiltersConfigTestimonials, 
+    getFilterOptions as getFilterOptionsTestimonials,
+    formConfig as formConfigTestimonials,
+    viewConfig as viewConfigTestimonials
+} from '../Events/Testimonials/config.js';
+import { getColumns as getColumnsTestimonials } from "../Events/Testimonials/columns.js";
   
 import { 
     getFiltersConfig as getFiltersConfigLocations, 
@@ -63,6 +79,14 @@ import {
     sclViewConfig as sclViewConfigProductionSites
 } from '../Locations/MineSite/config.js';
 import { getColumns as getColumnsProductionSites } from "../Locations/MineSite/columns.js";
+
+import { 
+    getFiltersConfig as getFiltersConfigConflictAreas, 
+    getFilterOptions as getFilterOptionsConflictAreas,
+    formConfig as formConfigConflictAreas,
+    viewConfig as viewConfigConflictAreas
+} from '../Locations/ConflictAreas/config.js';
+import { getColumns as getColumnsConflictAreas } from "../Locations/ConflictAreas/columns.js";
   
 import { 
     getFiltersConfig as getFilterConfigDocuments, 
@@ -95,6 +119,13 @@ export const FILTER_REGISTRY = {
       viewConfig: viewConfigOperators,
       columns: getColumnsOperators,
     },
+    "armed-groups": {
+      config: getFiltersConfigArmedGroups,
+      options: getFilterOptionsArmedGroups,
+      formConfig: formConfigArmedGroups,
+      viewConfig: viewConfigArmedGroups,
+      columns: getColumnsArmedGroups,
+    },
     events: {
       config: getFiltersConfigEvents,
       options: getFilterOptionsEvents,
@@ -123,6 +154,13 @@ export const FILTER_REGISTRY = {
       viewConfig: viewConfigIncidents,
       columns: getColumnsIncidents,
     },
+    testimonials: {
+      config: getFiltersConfigTestimonials,
+      options: getFilterOptionsTestimonials,
+      formConfig: formConfigTestimonials,
+      viewConfig: viewConfigTestimonials,
+      columns: getColumnsTestimonials,
+    },
     locations: {
       config: getFiltersConfigLocations,
       options: getFilterOptionsLocations,
@@ -137,6 +175,13 @@ export const FILTER_REGISTRY = {
       viewConfig: viewConfigProductionSites,
       columns: getColumnsProductionSites,
     },    
+    "conflict-areas": {
+      config: getFiltersConfigConflictAreas,
+      options: getFilterOptionsConflictAreas,
+      formConfig: formConfigConflictAreas,
+      viewConfig: viewConfigConflictAreas,
+      columns: getColumnsConflictAreas,
+    },
     scl: {
       config: getFiltersConfigProductionSites,
       options: getFilterOptionsProductionSites,

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

@@ -0,0 +1,115 @@
+import { BaseService } from "./BaseService.js";
+import { createLazyService } from "./helpers/LazyService.js";
+import { filterCreateData } from "../../helpers/Forms.js";
+
+class EventsService extends BaseService {
+    getForm({ scope }, language = "en") {
+		return this.apiGet({
+			isApp: true,
+			url: `/forms/event`,
+			params: { scope, language },
+		});
+	}
+
+	getWithModule({ query, signal, module }) {
+		return this.apiGet({
+			isApp: true,
+			url: `/${module}/event`,
+			params: query,
+			signal,
+		});
+	}
+
+	getOne({ id, module, signal }) {
+		return this.apiGet({
+			url: `/${module}/event/${id}`,
+			isApp: true,
+			signal,
+		});
+	}
+
+	get(query, signal) {
+		return this.apiGet({
+			isApp: true,
+			url: "/event",
+			params: query,
+			signal,
+		});
+	}
+
+	getData(id, sourceId, source, version) {
+		return this.apiGet({
+			isApp: true,
+			url: `/event/${id}`,
+			params: { authorId: sourceId, source, version },
+		});
+	}
+
+	getLinking(query) {
+		return this.apiGet({
+			isApp: true,
+			url: "/event/linking",
+			params: query,
+		});
+	}
+
+	submit(payload) {
+		if (payload.id) {
+			return this.apiPut({
+				isApp: true,
+				url: `/event/${payload.id}`,
+				data: filterCreateData(payload),
+			});
+		}
+
+		if (payload?.form) {
+			delete payload.form;
+			return this.apiPut({
+				isApp: true,
+				url: "/event",
+				data: filterCreateData(payload),
+			});
+		}
+		return this.apiPost({
+			isApp: true,
+			url: "/event",
+			data: filterCreateData(payload),
+		});
+	}
+
+	submitStep(data, id) {
+		return this.apiPut({
+			isApp: true,
+			url: `/event/submit/${id}`,
+			data: filterCreateData(data),
+		});
+	}
+	remove(id, data) {
+		return this.apiDelete({
+			isApp: true,
+			url: `/event/${id}/remove`,
+			data: data,
+		});
+	}
+
+	submitForm(id) {
+		const app = window.globalServicesConfig.application;
+
+		return this.apiPost({
+			isApp: true,
+			url: `/${app}/versioning/submit/Event/${id}`,
+		});
+	}
+
+	getOptions() {
+		return this.apiGet({
+			isApp: true,
+			url: `/forms/options`,
+			params: {
+				id: "categoryOptions,eventsType,testimonialsType,eventCategory,countries,eventCategoryOptions",
+			},
+		});
+	}
+}
+
+export default createLazyService(EventsService);

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

@@ -27,6 +27,7 @@ export const getNamespace = (namespace) => {
 
 class LinkedSubjectsService extends BaseService {
     getForm({ namespace }, language = "en", scope) {
+		console.log({namespace, language, scope})
 		return this.apiGet({
 			url: `forms/${namespace === "documents" ? namespace : getNamespace(namespace)}`,
 			isApp: true,

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

@@ -0,0 +1,80 @@
+import { BaseService } from "./BaseService.js";
+import { createLazyService } from "./helpers/LazyService.js";
+import { filterCreateData } from "../../helpers/Forms.js";
+
+class WorkersService extends BaseService {
+    get(params) {
+		return this.apiGet({
+			isApp: true,
+			url: "/stakeholder",
+			params,
+		});
+	}
+
+	getForm(scope = "modalNashirikiWorker", language = "en") {
+		return this.apiGet({
+			isApp: true,
+			url: `/forms/stakeholder`,
+			params: { scope, language },
+		});
+	}
+	getData(id, sourceId, version, source) {
+		return this.apiGet({
+			isApp: true,
+			url: `/stakeholder/${id}`,
+			params: { authorId: sourceId, version, source },
+		});
+	}
+
+	submit(payload) {
+		if (payload.id) {
+			// const { id, ...data } = payload;
+			return this.apiPut({
+				isApp: true,
+				url: `/stakeholder/${payload.id}`,
+				data: filterCreateData(payload),
+			});
+		}
+		if (payload?.form) {
+			delete payload.form;
+			return this.apiPost({
+				isApp: true,
+				url: "/stakeholder",
+				data: filterCreateData(payload),
+			});
+		}
+		return this.apiPost({
+			isApp: true,
+			url: "/stakeholder",
+			data: filterCreateData(payload),
+		});
+	}
+
+	submitStep(data, id) {
+		return this.apiPut({
+			isApp: true,
+			url: `/stakeholder/submit/${id}`,
+			data: filterCreateData(data),
+		});
+	}
+
+	remove(id, data) {
+		return this.apiDelete({
+			isApp: true,
+			url: `/stakeholder/${id}/remove`,
+			data: data,
+		});
+	}
+
+	getOptions() {
+		return this.apiGet({
+			isApp: true,
+			url: `/forms/options`,
+			params: {
+				id: "activityAtSiteOptions,category,countries,optionPositionSupplyChain,subCategory",
+			},
+		});
+	}
+}
+
+export default createLazyService(WorkersService);

package/src/helpers/errorHandling.js

@@ -1,67 +1,135 @@
 import { message } from 'antd';
 
+/**
+ * Check if a successful response contains embedded error data
+ */
+export const isErrorResponse = (data) => {
+  if (!data) return false;
+  
+  return (
+    // Check for Exception names
+    (data.name && data.name.includes('Exception')) ||
+    // Check for nested response with error status
+    (data.response?.statusCode && data.response.statusCode >= 400) ||
+    // Check for top-level error status
+    (data.statusCode && data.statusCode >= 400) ||
+    // Check for explicit error flag
+    data.error === true ||
+    // Check for nested error property
+    (data.response?.error && data.response.error !== null)
+  );
+};
+
+/**
+ * Extract error message from various error response formats
+ */
+export const getErrorMessage = (data) => {
+  return (
+    data?.message ||
+    data?.response?.message ||
+    data?.response?.error ||
+    'An error occurred'
+  );
+};
+
 /**
  * Generic error handler factory for axios requests
  * Highly configurable to adapt to different project needs
  */
 export const createErrorHandler = (config = {}) => {
-    const {
-      onUnauthorized,
-      handleError,
-      getStorageManager,
-      checkTokenValidity = true,
-      unauthorizedRedirect = '/',
-      tokenStorageKey = 'token',
-      handleNetworkError = true,
-    } = config;
-  
-    return (error, customOnUnauthorized) => {
-      // Handle cases where error.response doesn't exist (network errors)
-      if (!error.response) {
-        if (handleNetworkError && handleError) {
-          handleError({
-            status: 0,
-            statusText: "Network Error",
-            data: ["Please check your internet connection."],
-          });
-        }
-        return Promise.reject(error);
+  const {
+    onUnauthorized,
+    handleError,
+    getStorageManager,
+    checkTokenValidity = true,
+    unauthorizedRedirect = '/',
+    tokenStorageKey = 'token',
+    handleNetworkError = true,
+  } = config;
+
+  return (error, customOnUnauthorized) => {
+    // Handle cases where error.response doesn't exist (network errors)
+    if (!error.response) {
+      if (handleNetworkError && handleError) {
+        handleError({
+          status: 0,
+          statusText: "Network Error",
+          data: ["Please check your internet connection."],
+        });
       }
-  
-      const { status, statusText, data: { errors, message } = {} } = error.response || { data: {} };
-      
-      // Handle 401 Unauthorized
-      if (status === 401) {
-        if (checkTokenValidity && getStorageManager) {
-          const token = getStorageManager().get(tokenStorageKey);
-          if (token) {
-            if (typeof customOnUnauthorized === 'function') {
-              customOnUnauthorized();
-            } else if (typeof onUnauthorized === 'function') {
-              onUnauthorized();
-            } else {
-              getStorageManager().clearOne(tokenStorageKey);
-              if (typeof window !== 'undefined') {
-                window.location.href = unauthorizedRedirect;
-              }
+      return Promise.reject(error);
+    }
+
+    const { status, statusText, data: { errors, message } = {} } = error.response || { data: {} };
+    
+    // Handle 401 Unauthorized
+    if (status === 401) {
+      if (checkTokenValidity && getStorageManager) {
+        const token = getStorageManager().get(tokenStorageKey);
+        if (token) {
+          if (typeof customOnUnauthorized === 'function') {
+            customOnUnauthorized();
+          } else if (typeof onUnauthorized === 'function') {
+            onUnauthorized();
+          } else {
+            getStorageManager().clearOne(tokenStorageKey);
+            if (typeof window !== 'undefined') {
+              window.location.href = unauthorizedRedirect;
             }
           }
         }
       }
-      
-      // Handle 4xx and 5xx errors
-      if (status >= 400 && status <= 500) {
-        if (handleError) {
-          handleError({ 
-            status, 
-            statusText: message || statusText, 
-            data: errors || [] 
-          });
+    }
+    
+    // Handle 4xx and 5xx errors
+    if (status >= 400 && status <= 500) {
+      if (handleError) {
+        handleError({ 
+          status, 
+          statusText: message || statusText, 
+          data: errors || [] 
+        });
+      }
+    }
+    
+    return Promise.reject(error);
+  };
+};
+
+/**
+ * Create axios response interceptor to catch embedded errors in successful responses
+ */
+export const createResponseInterceptor = (config = {}) => {
+  const { showNotification = true } = config;
+  
+  return {
+    onSuccess: (response) => {
+      // Check if the response data contains an error
+      if (isErrorResponse(response.data)) {
+        const errorMessage = getErrorMessage(response.data);
+        
+        if (showNotification) {
+          message.error(errorMessage);
         }
+        
+        // Convert to a rejected promise so catch blocks handle it
+        const error = new Error(errorMessage);
+        error.response = {
+          data: response.data,
+          status: response.data.statusCode || response.data.response?.statusCode || 200,
+          statusText: errorMessage,
+        };
+        error.isEmbeddedError = true; // Flag to identify these special errors
+        
+        return Promise.reject(error);
       }
       
+      return response;
+    },
+    onError: (error) => {
       return Promise.reject(error);
-    };
+    }
+  };
 };
 
 /**
@@ -69,29 +137,29 @@ export const createErrorHandler = (config = {}) => {
  * Useful for quick error notifications
  */
 export const handleError = (err) => {
-    const errorMessage = err?.response?.data?.message || 
-                         err?.message || 
-                         'An error occurred';
-    message.error(errorMessage);
-  };
-  
-  /**
-   * Success message handler
-   */
-  export const handleSuccess = (msg) => {
-    message.success(msg || 'Operation successful');
-  };
-  
-  /**
-   * Warning message handler
-   */
-  export const handleWarning = (msg) => {
-    message.warning(msg || 'Warning');
-  };
-  
-  /**
-   * Info message handler
-   */
-  export const handleInfo = (msg) => {
-    message.info(msg);
-  };
+  const errorMessage = err?.response?.data?.message || 
+                       err?.message || 
+                       'An error occurred';
+  message.error(errorMessage);
+};
+
+/**
+ * Success message handler
+ */
+export const handleSuccess = (msg) => {
+  message.success(msg || 'Operation successful');
+};
+
+/**
+ * Warning message handler
+ */
+export const handleWarning = (msg) => {
+  message.warning(msg || 'Warning');
+};
+
+/**
+ * Info message handler
+ */
+export const handleInfo = (msg) => {
+  message.info(msg);
+};

package/src/services.js

@@ -18,4 +18,6 @@ export { default as SourceService } from './@daf/services/SourceService.js';
 export { default as DashboardService } from './@daf/services/DashboardService.js';
 export { default as LinkedSubjectsService } from './@daf/services/LinkedSubjects.js';
 export { default as OperatorService } from './@daf/services/OperatorService.js';
-export { default as PartnerService } from './@daf/services/PartnerService.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';

package/src/utils.js

@@ -46,7 +46,7 @@ export { StorageManager } from './helpers/StorageManager.js';
 
 export { assignParamsToUrl, buildQueryString } from './helpers/urlHelpers.js';
 
-export { createErrorHandler, handleError, handleSuccess, handleWarning, handleInfo } from './helpers/errorHandling.js';
+export { createErrorHandler, handleError, handleSuccess, handleWarning, handleInfo, isErrorResponse, getErrorMessage } from './helpers/errorHandling.js';
 
 export { createTheme, createAdminTheme } from './helpers/theme.js';