datastake-daf 0.6.487 → 0.6.489

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

@@ -0,0 +1,229 @@
+import axios from 'axios';
+import { cleanJSON } from '../../helpers/StringHelper.js';
+import { assignParamsToUrl } from '../../helpers/urlHelpers.js';
+import { getToken } from '../../helpers/Token.js';
+
+/**
+ * Base HTTP Service Class
+ * Provides axios wrapper with token management, cancel tokens, and interceptors
+ */
+export class BaseHTTPService {
+    constructor(config = {}) {
+        const {getHeaders, getBaseURL, onError, timeout = 300000, customAxiosConfig = {}} = config;
+
+        this.getToken = getToken || (() => null);
+        this.getHeaders = getHeaders || (() => ({}));
+        this.getBaseURL = getBaseURL || (() => null);
+        this.onError = onError || (() => null);
+        this.cleanJSON = cleanJSON;
+        this.timeout = timeout;
+        this.customAxiosConfig = customAxiosConfig;
+
+        // Init
+        this.cancelToken = {}
+        this.token = this.getToken();
+
+        this.setupAxios();
+    }
+
+    setupAxios() {
+        const headers = {
+            Authorization: `Bearer ${this.token}`,
+            ...this.getHeaders(),
+        };
+
+        this.api = axios.create({
+            baseURL: this.getBaseURL(),
+            headers,
+            timeout: this.timeout,
+            ...this.customAxiosConfig,
+        });
+
+        this.setupInterceptors();
+    }
+
+    setupInterceptors() {
+        this.api.interceptors.response.use((response) => response,
+            (error) => Promise.reject(error)
+        );
+
+        // Request interceptor - clean JSON data
+        this.api.interceptors.request.use(
+            (config) => {
+                if (['post', 'put', 'patch'].includes(config.method)) {
+                    config.data = this.cleanJSON(config.data);
+                }
+                
+                return config;
+            },
+            (error) => Promise.reject(error)
+        );
+    }
+    
+    reloadAxios() {
+        const token = this.getToken();
+        this.token = token;
+
+        const options = {
+            baseURL: this.getBaseURL(),
+            timeout: this.timeout,
+            ...this.customAxiosConfig,
+        };
+
+        if (token) {
+            options.headers = {
+              Authorization: `Bearer ${token}`,
+              ...this.getHeaders(),
+            };
+        }
+
+        this.api = axios.create(options);
+        this.setupInterceptors();
+    }
+
+    async formatResponse(call) {
+        try {
+          const res = await call;
+          const { data, status, statusText } = res || {};
+          this.cancelToken = {};
+          return { data, status, statusText };
+        } catch (error) {
+          return Promise.reject(error);
+        }
+    }
+
+    apiPost(options) {
+        // Check if there are any previous pending requests
+        if (typeof this.cancelToken[options.url] != typeof undefined) {
+          try {
+            this.cancelToken[options.url].cancel("Operation canceled due to new request.");
+          } catch (e) {
+            console.log(e);
+            return {};
+          }
+        }
+        
+        this.cancelToken[options.url] = axios.CancelToken.source();
+        const token = this.getToken();
+        
+        if (token !== this.token || !token) {
+          this.reloadAxios();
+        }
+    
+        return this.formatResponse(
+          this.api.post(options.url, options.data, {
+            baseURL: options.baseURL || this.getBaseURL(options),
+            cancelToken: this.cancelToken[options.url].token,
+            headers: {
+              Authorization: `Bearer ${this.getToken()}`,
+              ...this.getHeaders(),
+              ...(options?.headers || {}),
+            }
+          })
+            .catch((err) => this.onError(err))
+        );
+    }
+
+    apiGet(options) {
+        const token = this.getToken();
+        
+        if (token !== this.token || !token) {
+          this.reloadAxios();
+        }
+        
+        const { url, ...config } = options;
+    
+        return this.formatResponse(
+          this.api.get(url, {
+            ...config,
+            baseURL: options.baseURL || this.getBaseURL(options),
+            headers: {
+              Authorization: `Bearer ${this.getToken()}`,
+              ...this.getHeaders(),
+              ...(config?.headers || {}),
+            }
+          })
+            .catch((err) => this.onError(err))
+        );
+    }
+
+    apiDelete(options) {
+        const token = this.getToken();
+        
+        if (token !== this.token || !token) {
+          this.reloadAxios();
+        }
+        
+        const { url, ...config } = options;
+    
+        return this.formatResponse(
+          this.api.delete(url, {
+            ...config,
+            baseURL: options.baseURL || this.getBaseURL(options),
+            headers: {
+              Authorization: `Bearer ${this.getToken()}`,
+              ...this.getHeaders(),
+              ...(config?.headers || {}),
+            }
+          })
+            .catch((err) => this.onError(err))
+        );
+    }
+
+    apiPut(options) {
+        if (typeof this.cancelToken[options.url] != typeof undefined) {
+          try {
+            this.cancelToken[options.url].cancel("Operation canceled due to new request.");
+          } catch (e) {
+            console.log(e);
+            return {};
+          }
+        }
+        
+        this.cancelToken[options.url] = axios.CancelToken.source();
+        const token = this.getToken();
+        
+        if (token !== this.token || !token) {
+          this.reloadAxios();
+        }
+    
+        return this.formatResponse(
+          this.api.put(options.url, options.data, {
+            cancelToken: this.cancelToken[options.url].token,
+            baseURL: options.baseURL || this.getBaseURL(options),
+            headers: {
+              Authorization: `Bearer ${this.getToken()}`,
+              ...this.getHeaders(),
+              ...(options?.headers || {}),
+            }
+          })
+            .catch((err) => this.onError(err, options.onUnauthorized))
+        );
+    }
+
+    apiPatch(options) {
+        const token = this.getToken();
+        
+        if (token !== this.token || !token) {
+          this.reloadAxios();
+        }
+    
+        return this.formatResponse(
+          this.api.patch(options.url, options.data, {
+            baseURL: options.baseURL || this.getBaseURL(options),
+            headers: {
+              Authorization: `Bearer ${this.getToken()}`,
+              ...this.getHeaders(),
+              ...(options?.headers || {}),
+            }
+          })
+            .catch((err) => this.onError(err))
+        );
+    }
+    
+
+    // Utility method
+    assignParamsToUrl(path, params) {
+        return assignParamsToUrl(path, params);
+    }
+}

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

@@ -0,0 +1,43 @@
+export class ErrorHandler {
+    constructor(config = {}) {
+        this.store = config.store;
+        this.addToastAction = config.addToastAction;
+        this.formatData = config.formatData || this.defaultFormatData;
+    }
+
+    handle({stats, statusText, data}) {
+        if(this.store && this.addToastAction) {
+            this.store.dispatch(this.addToastAction({
+                title: statusText,
+                type: 'danger',
+                body: this.formatData(data),
+            }));
+        } else {
+            console.error('Error: ', {stats, statusText, data});
+        }
+    }
+
+    defaultFormatData(errors) {
+        if (!Array.isArray(errors)) {
+          return String(errors);
+        }
+    
+        const e = [];
+        errors.forEach(error => {
+          if (error && typeof error === 'object' && error.constraints) {
+            Object.keys(error.constraints)
+              .forEach(key => e.push(error.constraints[key]));
+          } else if (typeof error === 'string') {
+            e.push(error);
+          } else {
+            e.push(JSON.stringify(error));
+          }
+        });
+
+        return e.join('\n');
+    }
+
+    static createInstance(config) {
+        return new ErrorHandler(config);
+    }    
+}

package/src/helpers/StringHelper.js

@@ -202,4 +202,15 @@ export  const safeJsonParse = (value, fallback = value) => {
     console.warn('Failed to parse JSON:', value);
     return fallback;
   }
-};
+};
+
+export const cleanJSON = (json) => {
+  for (let key in json) {
+    if (json[key] === undefined) {
+      json[key] = null;
+    } /*else if (typeof json[key] === 'object')
+      json[key] = cleanJSON(json[key]);
+      */
+  }
+  return json;
+}

package/src/helpers/errorHandling.js

@@ -0,0 +1,97 @@
+import { message } from 'antd';
+
+/**
+ * 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 { 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 || [] 
+          });
+        }
+      }
+      
+      return Promise.reject(error);
+    };
+};
+
+/**
+ * Simple error handler using antd message component
+ * 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);
+  };

package/src/helpers/urlHelpers.js

@@ -0,0 +1,36 @@
+/**
+ * Utility functions for URL manipulation
+ */
+
+/**
+ * Assigns parameters to URL path
+ * Example: assignParamsToUrl('/users/{id}/posts/{postId}', { id: 1, postId: 2 })
+ * Returns: '/users/1/posts/2'
+ */
+export const assignParamsToUrl = (path, params) => {
+    let paramsPath = path;
+    const matches = path.match(/\{\w+\}/gm);
+    
+    if (matches) {
+      for (let param of matches) {
+        const key = param.match(/\w+/)[0];
+        paramsPath = paramsPath.replace(/\{\w+\}/, params[key]);
+      }
+    }
+    
+    return paramsPath;
+};
+
+/**
+ * Build query string from object
+ * Example: buildQueryString({ page: 1, limit: 10 })
+ * Returns: '?page=1&limit=10'
+ */
+export const buildQueryString = (params) => {
+    const query = Object.keys(params)
+      .filter(key => params[key] !== null && params[key] !== undefined)
+      .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
+      .join('&');
+    
+    return query ? `?${query}` : '';
+};

package/src/index.js

@@ -71,6 +71,7 @@ export { default as KeyIndicatorsDetails } from "./@daf/core/components/Dashboar
 export { default as DetailsSection } from "./@daf/core/components/Dashboard/Widget/DetailsSection/index.jsx";
 export { default as SDGWidget } from "./@daf/core/components/Dashboard/Widget/SDGWidget/index.jsx";
 export { default as ComponentWithFocus } from "./@daf/core/components/Dashboard/ComponentWithFocus/index.jsx";
+export { default as ComponentWithHoverFocus } from "./@daf/core/components/Dashboard/ComponentWithFocus/HoverFocus/index.jsx";
 export { default as ProjectWidget } from "./@daf/core/components/Dashboard/Widget/ProjectWidget/index.jsx";
 export { default as WidgetCard } from "./@daf/core/components/Dashboard/Widget/WidgetCard/index.js";
 export { default as CarouselWidget } from "./@daf/core/components/Dashboard/Widget/CarouselWidget/index.jsx";

package/src/services.js

@@ -0,0 +1,2 @@
+export { BaseHTTPService } from './@daf/services/BaseHTTPService.js';
+export { ErrorHandler } from './@daf/services/ErrorHandler.js';

package/src/utils.js

@@ -9,7 +9,7 @@ export { renderTooltip, renderTooltipJsx } from './@daf/utils/tooltip'
 export { getRangeOfTicks } from './helpers/chart'
 
 export { propHasValue } from './helpers/deepFind'
-export { isEmptyOrSpaces, capitalizeAll, capitalize, camelCaseToTitle, snakeCaseToTitleCase, titleToCamelCase, findOptions, getOptionAsObject, nowToIso, renderTemplateString, renderTemplateStringInObject, truncateString, splitStringInMultipleLines, safeJsonParse } from './helpers/StringHelper'
+export { isEmptyOrSpaces, capitalizeAll, capitalize, camelCaseToTitle, snakeCaseToTitleCase, titleToCamelCase, findOptions, getOptionAsObject, nowToIso, renderTemplateString, renderTemplateStringInObject, truncateString, splitStringInMultipleLines, safeJsonParse, cleanJSON } from './helpers/StringHelper'
 export { getNkey, groupSubsections, getImageUploadViewValue } from './@daf/core/components/ViewForm/helper'
 export { renderRows } from './@daf/core/components/Table/helper'
 export { filterOptions, filterString, hasNotChanged, filterSelectOptions, mapSubGroupsInSubmit, mapSubGroupsInGet, filterCreateData, changeInputMeta, renderDateFormatted } from './helpers/Forms'
@@ -39,4 +39,11 @@ export { captureElementsAsImages, captureComponentsAsImages } from './helpers/co
 
 export { createDocument } from './@daf/core/components/Document/WordDocument/createDocument.js'
 
-export { processConfig, fetchImageAsBuffer } from './helpers/docHelper.js'
+export { processConfig, fetchImageAsBuffer } from './helpers/docHelper.js'
+
+export { getToken } from './helpers/Token.js';
+export { StorageManager } from './helpers/StorageManager.js';
+
+export { assignParamsToUrl, buildQueryString } from './helpers/urlHelpers.js';
+
+export { createErrorHandler, handleError, handleSuccess, handleWarning, handleInfo } from './helpers/errorHandling.js';