datastake-daf 0.6.486 → 0.6.488

package/dist/utils/index.js

@@ -5096,6 +5096,16 @@ const safeJsonParse = (value, fallback = value) => {
     return fallback;
   }
 };
+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;
+};
 
 function _checkValue$1(wantedValue, match, fieldValue) {
   match = match ? match.trim() : null;
@@ -6016,6 +6026,152 @@ var browser$1 = {
 
 var process = browser$1;
 
+/**
+ * @description Manages window.storage
+ * @returns storage objects
+ * @class StorageManager
+ */
+class StorageManager {
+  /**
+   * @description Set or update given value in localStorage
+   * @static
+   * @returns Object
+   * @memberof StorageManager
+   */
+  static set(key, value) {
+    if (key && value) {
+      window.localStorage.setItem(key, value);
+      return {
+        success: true,
+        data: "Storage has been set successfully."
+      };
+    }
+    return {
+      error: true,
+      data: "Storage was not set. Storage key and value is required!"
+    };
+  }
+
+  /**
+   * @description Set or update given value in sessionStorage, used to not remember user after closing opened tab.
+   * @static
+   * @returns Object
+   * @memberof StorageManager
+   */
+  static setToSession(key, value) {
+    if (key && value) {
+      window.sessionStorage.setItem(key, value);
+      return {
+        success: true,
+        data: "Storage has been set successfully."
+      };
+    }
+    return {
+      error: true,
+      data: "Storage was not set. Storage key and value is required!"
+    };
+  }
+
+  /**
+   * @description Fetch data from localStorage
+   * @static
+   * @returns Object
+   * @memberof StorageManager
+   */
+  static get(key, defaultValue = undefined) {
+    if (key) {
+      const val = window.localStorage.getItem(key) || window.sessionStorage.getItem(key);
+      return val || defaultValue;
+    }
+    return {
+      error: true,
+      data: "Storage key is required!"
+    };
+  }
+
+  /**
+   * @description Clear only one value from localStorage
+   * @static
+   * @returns Object
+   * @memberof StorageManager
+   */
+  static clearOne(key) {
+    if (key === 'token') {
+      localStorage.removeItem('trade-type');
+      localStorage.removeItem('trade-value');
+    }
+    if (key) {
+      window.localStorage.removeItem(key) || window.sessionStorage.removeItem(key);
+    }
+    return "Storage key is required!";
+  }
+
+  /**
+   * @description Clear all values from localStorage
+   * @static
+   * @returns Object
+   * @memberof StorageManager
+   */
+  static clearAll() {
+    window.localStorage.clear();
+    window.sessionStorage.clear();
+  }
+  static hasKey(key) {
+    return typeof this.get(key) === 'string';
+  }
+  static saveFilters(module, namespace, filters = {}, merge = false) {
+    let savedFilters = this.get('filters');
+    try {
+      savedFilters = JSON.parse(savedFilters);
+    } catch (e) {
+      savedFilters = {};
+    }
+    if (!savedFilters) {
+      savedFilters = {};
+    }
+    if (!savedFilters[module]) {
+      savedFilters[module] = {};
+    }
+    if (!savedFilters[module][namespace]) {
+      savedFilters[module][namespace] = {};
+    }
+    if (Object.keys(filters).length) {
+      savedFilters[module][namespace] = merge ? Object.assign(savedFilters[module][namespace], filters) : filters;
+    } else {
+      savedFilters[module][namespace] = {};
+    }
+    this.set('filters', JSON.stringify(savedFilters));
+    return savedFilters[module][namespace];
+  }
+  static getFilters(module, namespace) {
+    let savedFilters = this.get('filters');
+    try {
+      savedFilters = JSON.parse(savedFilters);
+    } catch (e) {
+      savedFilters = {};
+    }
+    if (!savedFilters) {
+      savedFilters = {};
+    }
+    if (!savedFilters[module]) {
+      savedFilters[module] = {};
+    }
+    if (!savedFilters[module][namespace]) {
+      savedFilters[module][namespace] = {};
+    }
+    return savedFilters[module][namespace];
+  }
+}
+
+const isProxy = () => {
+  const pathname = window.location.pathname;
+  if (pathname.includes('/proxy/pme') || pathname.includes('/proxy/cadd')) {
+    return window.opener || !!StorageManager.get('proxy_token');
+  }
+  return false;
+};
+const getToken = () => isProxy() ? StorageManager.get('proxy_token') : StorageManager.get('token');
+
 ({
   config: PropTypes__default["default"].object,
   filters: PropTypes__default["default"].object,
@@ -13431,17 +13587,153 @@ const processConfig = async configArray => {
   return processedConfig;
 };
 
+/**
+ * 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'
+ */
+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'
+ */
+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}` : '';
+};
+
+/**
+ * Generic error handler factory for axios requests
+ * Highly configurable to adapt to different project needs
+ */
+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
+ */
+const handleError = err => {
+  const errorMessage = err?.response?.data?.message || err?.message || 'An error occurred';
+  antd.message.error(errorMessage);
+};
+
+/**
+ * Success message handler
+ */
+const handleSuccess = msg => {
+  antd.message.success(msg || 'Operation successful');
+};
+
+/**
+ * Warning message handler
+ */
+const handleWarning = msg => {
+  antd.message.warning(msg || 'Warning');
+};
+
+/**
+ * Info message handler
+ */
+const handleInfo = msg => {
+  antd.message.info(msg);
+};
+
 exports.ErrorFormat = ErrorFormat;
 exports.MessageTypes = MessageTypes;
+exports.StorageManager = StorageManager;
+exports.assignParamsToUrl = assignParamsToUrl;
 exports.btn = button;
+exports.buildQueryString = buildQueryString;
 exports.camelCaseToTitle = camelCaseToTitle;
 exports.capitalize = capitalize;
 exports.capitalizeAll = capitalizeAll;
 exports.captureComponentsAsImages = captureComponentsAsImages;
 exports.captureElementsAsImages = captureElementsAsImages;
 exports.changeInputMeta = changeInputMeta;
+exports.cleanJSON = cleanJSON;
 exports.convertUndefinedToNull = convertUndefinedToNull;
 exports.createDocument = createDocument;
+exports.createErrorHandler = createErrorHandler;
 exports.defaultFilterKeys = defaultFilterKeys;
 exports.defaultMapConfig = defaultMapConfig;
 exports.defaultTheme = mmtTheme;
@@ -13464,7 +13756,12 @@ exports.getOptionConfig = getOptionConfig;
 exports.getOptionLabel = getOptionLabel;
 exports.getRangeOfTicks = getRangeOfTicks;
 exports.getTagColor = getTagColor;
+exports.getToken = getToken;
 exports.groupSubsections = groupSubsections;
+exports.handleError = handleError;
+exports.handleInfo = handleInfo;
+exports.handleSuccess = handleSuccess;
+exports.handleWarning = handleWarning;
 exports.hasNotChanged = hasNotChanged;
 exports.isEmptyOrSpaces = isEmptyOrSpaces;
 exports.isModuleApproved = isModuleApproved;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "datastake-daf",
-	"version": "0.6.486",
+	"version": "0.6.488",
 	"dependencies": {
 		"@ant-design/icons": "^5.2.5",
 		"@antv/g2": "^5.1.1",

package/rollup.config.js

@@ -95,6 +95,26 @@ export default [
 				requireReturnsDefault: "auto",
 			}),
 		],
+	},	
+	{
+		input: "src/services.js",
+		output: [
+			{
+				file: "dist/services/index.js",
+				format: "cjs",
+			},
+		],
+		external,
+		plugins: [
+			nodePolyfills(),
+			resolve({ browser: true }),
+			babel({ exclude: "node_modules/**", babelrc: true }),
+			peerDep(),
+			commonjs({
+				include: /node_modules/,
+				requireReturnsDefault: "auto",
+			}),
+		],
 	},
 	{
 		input: "src/hooks.js",

package/src/@daf/core/components/DynamicForm/helper.js

@@ -89,6 +89,13 @@ export const checkCondition = (condition, repeatValues, formsValue) => {
 };
 export function showHideInput(input, formsValue, repeatIndex, repeatValues, setValues, ref) {
 	if (input?.meta?.hidden === true) {
+		// Set default value for hidden fields
+		if (input?.meta?.defaultValue !== undefined && !propHasValue(formsValue[ref])) {
+			formsValue[ref] = input.meta.defaultValue;
+			if (setValues && typeof setValues === 'function') {
+				setValues({ ...formsValue });
+			}
+		}
 		return false;
 	}
 	if (input.showIf) {

package/src/@daf/core/components/DynamicForm/index.jsx

@@ -168,6 +168,34 @@ export default function DynamicForm({
     }
   }, [data]);
 
+    // Initialize default values for hidden fields
+    useEffect(() => {
+      if (Object.keys(form).length > 0) {
+        const updatedValues = { ...values };
+        let hasChanges = false;
+  
+        // Process all form fields to set default values for hidden fields
+        Object.keys(form).forEach(formKey => {
+          Object.keys(form[formKey]).forEach(fieldKey => {
+            const field = form[formKey][fieldKey];
+            if (field?.meta?.hidden === true && field?.meta?.defaultValue !== undefined) {
+              const fieldId = field.dataId || fieldKey;
+              if (!propHasValue(updatedValues[fieldId])) {
+                updatedValues[fieldId] = field.meta.defaultValue;
+                hasChanges = true;
+              }
+            }
+          });
+        });
+  
+        if (hasChanges) {
+          setValues(updatedValues);
+          // Also set the values in the Ant Design form
+          MainForm.setFieldsValue(updatedValues);
+        }
+      }
+    }, [form]);
+
   const setSelectedForm = (id) => {
     setForms(Forms.map(form => {
       (id === form.id)
@@ -267,6 +295,14 @@ export default function DynamicForm({
       }
       value = fileList;
     }
+    // Handle default values for hidden fields
+    if (input?.meta?.hidden === true && input?.meta?.defaultValue !== undefined && !propHasValue(value)) {
+      value = input.meta.defaultValue;
+      if (typeof path === 'string') {
+        dot.str(path, value, values);
+      }
+    }
+    
     const config = {
       name,
       call: input.call ? input.call : input?.meta?.call,

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);
+    }    
+}