ui-soxo-bootstrap-core 2.4.24

package/core/lib/utils/form/form.utils.js

@@ -0,0 +1,256 @@
+/**
+ * (New) Hook groups all functionalities that needs to be implemented for form
+ * 
+ * 
+ * All the forms in the projects extending/using formUtils has superpowers to control its
+ * behavior with class for controlling , visibility , mandate, validation , 
+ * and change 
+ * 
+ * @description useFormUtils hook for controlling any form and extending it
+ * @author Ashique Mohammed
+ * 
+ */
+
+import { useState, useEffect } from 'react';
+
+// 
+import { prepareAndExecuteScript } from '../script.utils';
+
+let n = 1;
+
+/**
+ * 
+ * @param {*} form 
+ * @param {*} formSettings 
+ * @returns 
+ */
+const useFormUtils = (form, formSettings,preference) => {
+
+    let [config, setConfig] = useState({ fields: {}, add_on_fields: [] });
+
+    const [formData, setFormData] = useState({});
+
+    const [onChangeListeners, setOnChangeListeners] = useState({});
+
+    console.log('pre',preference);
+
+    useEffect(() => {
+        setFormData({ ...form.getFieldsValue() });
+    }, [form]);
+
+    useEffect(() => {
+
+        // With the settings received as input we have to initialize the configuration 
+        // to prepare for use in the form
+        initializeConfiguration();
+
+        return () => {
+
+        }
+    }, [])
+
+    /**
+     * Takes the preference from local storage and creates the object
+     */
+    function initializeConfiguration() {
+
+        let preferences = { fields: [] };
+
+        // if (localStorage.preferences && JSON.parse(localStorage.preferences)) {
+
+        //     preferences = JSON.parse(localStorage.preferences);
+        // }
+
+        // let activePreference = preferences;
+
+        // We iterate the default form settings to specifiy the field configuration 
+        // for each field.
+
+        config = prepareFields({ formSettings, preference, config, index: 'fields' });
+
+        // formSettings.fields.forEach((field) => {
+
+        //     // We default the field setting from the default setting
+        //     config.fields[field.field] = field;
+
+        //     // We check if there is any change in the field 
+        //     activePreference.fields.forEach((item) => {
+
+        //         if (field.field === item.field) {
+
+        //             config.fields[field.field] = item;
+        //         }
+
+        //     });
+        // })
+
+        // If there are add on fields
+        // prepareFields(formSettings, activePreference, config);
+
+        if (preference.add_on_fields) {
+
+            config['add_on_fields'] = {};
+
+            try {
+
+                preference['add_on_fields'].forEach((item) => {
+
+                    config['add_on_fields'][item.field] = item;
+
+                });
+
+            } catch (error) {
+
+            }
+        }
+
+        setConfig({ ...config });
+    }
+
+    /**
+     * For the index specified , we have to consider the local storage settings 
+     * over the default settings to build the config object that is used in the form
+     * 
+     * @param {*} formSettings 
+     * @param {*} activePreference 
+     * @param {*} config 
+     */
+    function prepareFields({ formSettings, preference, config, index }) {
+
+        formSettings[index].forEach((field) => {
+
+            // We default the field setting from the default setting
+            config[index][field.field] = field;
+
+            // We check if there is any change in the field 
+            // config = considerPreferenceFields({ field, activePreference, config, index })
+            preference[index].forEach((item) => {
+
+                if (field.field === item.field) {
+
+                    config[index][field.field] = item;
+                }
+
+            });
+        })
+
+        return config;
+    }
+
+    /**
+     * 
+     * @param {*} formSettings 
+     * @param {*} activePreference 
+     * @param {*} config 
+     * @param {*} index 
+     */
+    function considerPreferenceFields({ field, activePreference, config, index }) {
+
+        activePreference[index].forEach((item) => {
+
+            if (field.field === item.field) {
+
+                config[index][field.field] = item;
+            }
+
+        });
+
+        return config;
+    }
+
+    /**
+     * On change listener
+     * 
+     * @param {*} key 
+     * @param {*} column 
+     */
+    const onChange = async ({ field, fieldConfiguration, values: initialValues }) => {
+
+        // On change script
+        let { onChangeScript: script } = fieldConfiguration;
+        // form.registerField(column, {
+        //     setValue: form.setFieldsValue,
+        //     getValue: form.getFieldValue,
+        // });
+        // setOnChangeListeners({
+        //     ...onChangeListeners,
+        //     [column]: callback,
+        // });
+
+        // If there is a script assigned the field , 
+        // we have to execute the script
+        if (script) {
+
+            // Before Submit of form , execute the script
+            let values = await prepareAndExecuteScript({
+                field,
+                script,
+                values: initialValues,
+
+                // We build a new object 
+                // that needs to be used within the code editor
+                // we can 
+                formUtils: {
+                    setVisible,
+                    setRequired
+
+                }
+            });
+
+            console.log(values);
+
+        }
+    };
+
+    /**
+     * Function controls the visibilty 
+     * of a column 
+     * 
+     * @param {*} column 
+     * @param {*} visibility 
+     */
+    const setVisible = (column, visibility) => {
+
+        console.log(column, visibility);
+
+        // Toggle the visiblity of the column
+        config.fields[column].visible = visibility;
+
+        form.setFields([{ name: column, visible: visibility }]);
+
+        setConfig({
+            ...config,
+            updated: ++n
+        })
+    };
+
+    /**
+   * Function controls the visibilty 
+   * of a column 
+   * 
+   * @param {*} column 
+   * @param {*} visibility 
+   */
+    const setRequired = (column, required) => {
+
+        // Toggle the visiblity of the column
+        config.fields[column].required = required;
+
+        // form.setFields([{ name: column, visible: visibility }]);
+
+        setConfig({
+            ...config,
+            updated: ++n
+        })
+    };
+
+    return {
+        config,
+        formData,
+        onChange,
+        setVisible,
+        setRequired
+    };
+};
+
+export default useFormUtils;

package/core/lib/utils/generic/generic.utils.js

@@ -0,0 +1,69 @@
+
+
+
+
+
+
+
+
+/**
+ * 
+ * @param {*} records 
+ * @param {*} columns 
+ * @returns 
+ */
+export function getExportData(records, exportDataColumns) {
+
+    let filteredColumns = exportDataColumns.filter((col) => !col.disableExport)
+
+    // Preparing headers for data exporting
+    let exportDataHeaders = filteredColumns.map((data) => {
+
+        return {
+            ...data,
+            key: data.key,
+            label: data.title
+        }
+
+    })
+
+    // Iterate each record and map with the columns
+    const response = records.map((row, columnIndex) => {
+
+        let entry = {
+            'Sl No': columnIndex + 1
+        };
+
+        filteredColumns.forEach((column, indexValue) => {
+
+            // Data Index / Field
+            if (column.exportDefinition) {
+
+                entry[column.key] = column.exportDefinition(row, indexValue, columnIndex);
+
+            } else if (column.render) {
+
+                entry[column.key] = column.render(row, indexValue, columnIndex);
+
+            } else if (column.dataIndex) {
+
+                entry[column.key] = row[column.dataIndex];
+
+            } else if (column.field) {
+
+                entry[column.key] = row[column.field];
+
+            } else {
+
+                entry[column.key] = row[column.field];
+
+            }
+        })
+
+        return entry;
+
+    })
+
+    return { exportDataColumns: response, exportDataHeaders }
+
+}

package/core/lib/utils/http/auth.helper.js

@@ -0,0 +1,95 @@
+import { Location } from '../location/location.utils';
+
+let refreshTokenPromise = null; // Holds the ongoing token refresh promise
+let pendingRequests = []; // Array to store requests waiting for the new token
+const MAX_PENDING_REQUESTS = 20; // Maximum number of requests allowed in the queue
+
+// Get the current access token from localStorage
+export const getAccessToken = () => localStorage.getItem('access_token');
+
+// Get the current refresh token from localStorage
+export const getRefreshToken = () => localStorage.getItem('refresh_token');
+
+// Set a new access token in localStorage
+export const setAccessToken = (token) => token && localStorage.setItem('access_token', token);
+
+// Set a new refresh token in localStorage
+export const setRefreshToken = (token) => token && localStorage.setItem('refresh_token', token);
+
+// Clear both access and refresh tokens from localStorage
+export const clearAuthTokens = () => {
+  localStorage.removeItem('access_token');
+  localStorage.removeItem('refresh_token');
+};
+
+// Queue a request to be retried after token refresh
+export const queueRequest = (cb) =>
+  new Promise((resolve, reject) => {
+    // Reject if too many requests are already queued
+    if (pendingRequests.length >= MAX_PENDING_REQUESTS) {
+      reject(new Error('Too many requests waiting for token refresh'));
+      return;
+    }
+
+    // Add the request to the pending requests array
+    pendingRequests.push({ cb, resolve, reject });
+  });
+
+// Retry all queued requests with the new access token
+const retryQueuedRequests = (newToken) => {
+  pendingRequests.forEach(({ cb, resolve, reject }) => {
+    cb(newToken).then(resolve).catch(reject); // Retry each request
+  });
+
+  // Clear the queue after retrying all requests
+  pendingRequests = [];
+};
+
+export const refreshAccessToken = () => {
+  // If a refresh is already in progress, return the same promise
+  if (refreshTokenPromise) {
+    return refreshTokenPromise;
+  }
+
+  const refreshToken = getRefreshToken();
+
+  refreshTokenPromise = new Promise(async (resolve, reject) => {
+    try {
+      const response = await fetch(`${process.env.REACT_APP_endpoint}auth/refresh`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          db_ptr: localStorage.getItem('db_ptr'),
+        },
+        body: JSON.stringify({ refreshToken }),
+      });
+
+      const data = await response.json();
+
+      const { access_token, refresh_token, success } = data || {};
+
+      if (success) {
+        // Save the new access token
+        setAccessToken(access_token);
+        // Save the new refresh token
+        setRefreshToken(refresh_token);
+        // Retry all queued requests with the new token
+        retryQueuedRequests(access_token);
+        // Resolve the promise with the new token
+        resolve(access_token);
+      } else {
+        localStorage.clear();
+        Location.navigate({ url: '/login' });
+        throw new Error('Token refresh failed');
+      }
+    } catch (error) {
+      pendingRequests.forEach(({ reject }) => reject(error));
+      pendingRequests = [];
+      reject(error);
+    } finally {
+      refreshTokenPromise = null;
+    }
+  });
+
+  return refreshTokenPromise;
+};

package/core/lib/utils/http/http.utils.js

@@ -0,0 +1,157 @@
+/**
+ *
+ * Final Entry for all the API calls
+ *
+ * All the common configurations should bypass httpUtils
+ * Keep adding additional methods on requirement
+ *
+ */
+
+import { message } from 'antd';
+
+import FirebaseUtils from '../firebase.utils';
+
+import { Location } from '../location/location.utils';
+import { getRefreshToken, queueRequest, refreshAccessToken } from './auth.helper';
+
+let headers = {
+  // 'Accept': 'application/json',
+  'Content-Type': 'application/json',
+  // 'Cache-Control': 'no-cache',
+  // 'X-Apartment-Id': 1,
+};
+
+/**
+ * Method for Get Call
+ *
+ * @param {*} param
+ * @public
+ */
+export async function GetData({ url, formBody, settings, ...props }) {
+  return ApiCall({ url, formBody, method: 'GET', settings, ...props });
+}
+
+/**
+ * Method posts data to mentioned url
+ *
+ * @param {*} param
+ * @public
+ */
+export async function PostData({ url, formBody, ...props }) {
+  return ApiCall({ url, formBody, method: 'POST', returnResponse: true, ...props });
+}
+
+/**
+ * Method for update the data
+ * @public
+ */
+export async function PutData({ url, formBody, ...props }) {
+  return ApiCall({ url, formBody, method: 'PUT', returnResponse: true, ...props });
+}
+
+/**
+ * Method for update the data
+ * @public
+ */
+export async function PatchData({ url, formBody, ...props }) {
+  return ApiCall({ url, formBody, method: 'PATCH', returnResponse: true, ...props });
+}
+
+/**
+ * Method for update the data
+ * @public
+ */
+export async function DeleteData({ url, ...props }) {
+  return ApiCall({ url, method: 'DELETE', returnResponse: true, ...props });
+}
+
+/**
+ * Final Exit for API call
+ *
+ * @param {*} param
+ */
+
+export async function ApiCall({ url, formBody, method, settings, ...props }) {
+  const token = props.token || (await settings.getToken());
+  const path = window.location.pathname;
+  const baseUrl = props.baseUrl || process.env.REACT_APP_endpoint;
+
+  const payload = {
+    method,
+    headers: {
+      ...settings.headers,
+      ...headers,
+      ...(props.headers || {}),
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    body: formBody ? JSON.stringify(formBody) : null,
+  };
+
+  // 🟡 Handles both normal and retried responses
+  const handleResponse = async (res) => {
+    if (props.responseType === 'blob') {
+      const blob = await res.blob();
+      return {
+        contentType: res.headers.get('Content-Type'),
+        raw: blob,
+      };
+    }
+
+    const json = await res.json();
+
+    if ([400, 404].includes(res.status) || [400, 500, 501].includes(json?.statusCode)) {
+      if (!props.hideError) {
+        message.error(json.message || 'Request failed');
+      }
+      throw json;
+    }
+
+    return json;
+  };
+
+  // 🟢 Main function with retry logic
+  const makeRequest = async () => {
+    const res = await fetch(baseUrl + url, payload);
+    const refreshToken = getRefreshToken();
+
+    if (res.status === 403) {
+      message.warn('Your license has expired. Please contact support.');
+    }
+
+    if (res.status === 401 && path !== '/login' && refreshToken) {
+      const retryPromise = queueRequest(async (newToken) => {
+        payload.headers = {
+          ...payload.headers,
+          Authorization: `Bearer ${newToken}`,
+        };
+
+        const retryRes = await fetch(baseUrl + url, payload);
+
+        if (retryRes.status === 401) {
+          Location.navigate({ url: '/login' });
+          throw new Error('Unauthorized after token refresh');
+        }
+
+        // ✅ return parsed JSON
+        return handleResponse(retryRes);
+      });
+
+      // 🔁 triggers queued requests
+      refreshAccessToken();
+      // ✅ resolve to retried final data
+      return retryPromise;
+    }
+
+    // ✅ normal (non-401) case
+    return handleResponse(res);
+  };
+
+  try {
+    const result = await makeRequest();
+    // ✅ always return final result
+    return result;
+  } catch (err) {
+    console.error('Login error -->', err?.message);
+  }
+}

package/core/lib/utils/http/readme.md

@@ -0,0 +1,14 @@
+## Usage
+
+HTTP Utils is a JavaScript library for making HTTP requests. It provides a set of functions for making GET, POST, PUT, and DELETE requests, as well as for handling errors and parsing response data.
+
+To use HTTP Utils in your JavaScript code, you need to require it:
+
+### HTTP Requests
+
+The following functions are available for making HTTP requests:
+
+● get(url, params): Sends a GET request to the specified url with the given params. Returns a Promise that resolves with the response data.<br>
+● post(url, data): Sends a POST request to the specified url with the given data. Returns a Promise that resolves with the response data.<br>
+● put(url, data): Sends a PUT request to the specified url with the given data. Returns a Promise that resolves with the response data.<br>
+● del(url): Sends a DELETE request to the specified url. Returns a Promise that resolves with the response data.

package/core/lib/utils/index.js

@@ -0,0 +1,46 @@
+
+
+import { Location } from './location/location.utils'
+
+import Notification from './notification.utils';
+
+import DateUtils from './date/date.utils'
+
+import ApiUtils from './api/api.utils';
+
+import FormUtils from './form/form.utils';
+
+import { UploadUtils } from './upload.utils';
+
+import { GetData, PostData, PutData, DeleteData } from './http/http.utils';
+
+import { getExportData } from './generic/generic.utils';
+
+import { ConvertBytesToArray } from './common/common.utils';
+
+import SettingsUtil from './setting.utils';
+
+
+export {
+    // FirebaseUtils,
+
+    Notification,
+
+    Location,
+    DateUtils,
+    ApiUtils,
+    UploadUtils,
+    GetData,
+    PostData,
+    PutData,
+    DeleteData,
+
+    getExportData,
+
+
+    // Common Functions
+    ConvertBytesToArray,
+
+    SettingsUtil,
+    FormUtils
+}