robobyte-front-builder 1.0.0

package/src/services/StreamService.js

@@ -0,0 +1,82 @@
+import Axios from 'axios'
+import {ApiURL} from './Endpoints'
+import authConfig from 'src/configs/auth'
+import PutRefreshToken from './auth/PutRefreshToken'
+import toast from 'react-hot-toast'
+import {DataTypes} from "services/ContentTypes";
+
+export default async function StreamService(endpoint, showToast, data, params, api, progressCallback) {
+  await PutRefreshToken()
+  const accessToken = localStorage.getItem(authConfig.storageTokenKeyName)
+
+  const url = api ?? ApiURL + endpoint.URL
+
+  let currentParams = {
+    ...params,
+    ...(endpoint.DataType == DataTypes.Params ? {...data} : {})
+  }
+  let currnetData = endpoint.DataType == DataTypes.Form || endpoint.DataType == DataTypes.Body ? data : {}
+
+  try {
+    const response = await Axios.post(url, currnetData, {
+      responseType: 'blob',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': endpoint.ContentType
+      },
+      params: currentParams,
+      onDownloadProgress: progressEvent => {
+        if (progressCallback) {
+          const percentCompleted = Math.round((progressEvent.loaded * 100) / (progressEvent.total || 1))
+          progressCallback(percentCompleted)
+        }
+      }
+    })
+
+    const contentDisposition = response.headers['content-disposition']
+    let fileName = 'download.csv'
+    if (contentDisposition && contentDisposition.includes('filename=')) {
+      fileName = decodeURIComponent(
+        contentDisposition.split('filename=')[1].replace(/"/g, '')
+      )
+    }
+
+    const blob = new Blob([response.data], {
+      type: response.headers['content-type']
+    })
+
+    // 🔍 Estimate total rows & size
+    const textContent = await blob.text()
+    const lines = textContent.split('\n').filter(line => line.trim() !== '')
+
+    const totalRows = lines.length - 1 // remove header
+    const sampleRows = lines.slice(1, 501) // first 500 rows (batch)
+    const avgRowSize = sampleRows.reduce((acc, row) => acc + row.length, 0) / sampleRows.length
+
+    const estimatedSize = Math.round(avgRowSize * totalRows)
+
+    // console.log('📊 Total Rows:', totalRows)
+    // console.log('📏 Estimated File Size:', estimatedSize, 'bytes')
+    // console.log('📦 Actual Blob Size:', blob.size, 'bytes')
+
+    const downloadLink = document.createElement('a')
+    const urlBlob = URL.createObjectURL(blob)
+    downloadLink.href = urlBlob
+    downloadLink.download = fileName
+    document.body.appendChild(downloadLink)
+    downloadLink.click()
+    document.body.removeChild(downloadLink)
+    URL.revokeObjectURL(urlBlob)
+
+    if (showToast) toast.success('تم تحميل الملف بنجاح')
+    return { success: true, totalRows, estimatedSize, actualSize: blob.size }
+
+  } catch (err) {
+    if (err.response && err.response.status === 401)
+      toast.error('غير مخول للوصول')
+    else
+      toast.error('فشل تحميل الملف')
+
+    return { success: false }
+  }
+}

package/src/services/UpdateService.js

@@ -0,0 +1,82 @@
+import Axios from 'axios'
+import { DataTypes } from './ContentTypes'
+import { ApiURL } from './Endpoints'
+import authConfig from 'src/configs/auth'
+import toast from 'react-hot-toast'
+import PutRefreshToken from './auth/PutRefreshToken'
+
+export default async function UpdateService(endpoint, showToast, data, params) {
+  await PutRefreshToken()
+  const accessToken = localStorage.getItem(authConfig.storageTokenKeyName)
+  let response = { status: 'Error', message: '' }
+  let result = null
+  let currentParams = {
+    ...params,
+    ...(endpoint.DataType == DataTypes.Params ? { ...data } : {})
+  }
+  let currnetData =
+    endpoint.DataType == DataTypes.Form
+      ? data
+      : {
+        ...(endpoint.DataType == DataTypes.Body ? { ...data } : {})
+      }
+  if (!data) return
+  const url = ApiURL + endpoint.URL
+
+  const axiosConfig = {
+    method: 'put',
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      'Content-Type': endpoint.ContentType
+    },
+    params: {
+      ...currentParams
+    }
+  }
+
+  try {
+    await Axios.put(url, currnetData, axiosConfig)
+      .then(r => {
+        result = r.data
+        response = {
+          status: 'Success',
+          message: r.data.message ? r.data.message : 'تم الحفظ بنجاح'
+        }
+      })
+      .catch(r => {
+
+        if (r.response && r.response.status == 400) {
+          response = {
+            status: 'Error',
+            message: typeof r.response.data == 'string' ? r.response.data : r.response.data.title
+            // message: "حدث خطأ اثناء الحفظ",
+          }
+        } else if (r.response && (r.response.status == 401 || r.response.status == 403)) {
+          response = {
+            status: 'Error',
+            message: 'غير مخول'
+          }
+        } else {
+
+          response = {
+            status: 'Error',
+            message: 'حدث خطأ في الاتصال مع الخادم'
+          }
+        }
+      })
+  } catch (error) {
+    response = {
+      status: 'Error',
+      message: 'حدث خطأ في الخادم'
+    }
+  } finally {
+    if (showToast) {
+      if (response.status == 'Success') {
+        toast.success(response.message)
+      } else {
+        toast.error(response.message)
+      }
+    }
+  }
+  return result
+}

package/src/services/auth/AuthService.js

@@ -0,0 +1,47 @@
+import Axios from "axios";
+import { ApiUrl } from "services/Endpoints";
+const apiURL = ApiUrl;
+
+export default async function AuthService(User) {
+  let result = { status: "Error", message: "" };
+
+  if (!User) return;
+  const url = apiURL + `/api/Auth/Login`;
+
+  const axiosConfig = {
+    method: "post",
+    headers: {
+      "Content-Type": "application/json-patch+json",
+    },
+  };
+
+  try {
+    const resporone = await Axios.post(url, User, axiosConfig)
+      .then((r) => {
+        result = r.data;
+      })
+      .catch((r) => {
+
+        if (r.response && r.response.status == 400) {
+          result = {
+            status: "Error",
+            message: r.response.data,
+          };
+        } else if (r.response && r.response.status == 401) {
+          result = {
+            status: "Error",
+            message: "غير مخول بالدخول",
+          };
+        } else {
+          result = {
+            status: "Error",
+            message: "حدث خطأ في الاتصال مع الخادم",
+          };
+        }
+      });
+  } catch (error) {
+
+  }
+
+  return result;
+}

package/src/services/auth/GetUsersService.js

@@ -0,0 +1,38 @@
+import Axios from 'axios';
+import ApiURL from '../ApiURL' 
+
+export default async function GetUsersService(User,filter){
+    
+    let result =null;
+    const apiURL = ApiURL() + '/api/Users/GetByUserRole';
+    
+    if (!User )
+        return;
+    let currentFilter
+    if(filter){
+        currentFilter={...filter}
+    }else{
+        currentFilter={
+            page:1,
+            pageSize:100
+        }
+    }
+    const axiosConfig={
+        method: 'get',
+        headers: {
+          'Authorization': `Bearer ${User.accessToken}`,
+          'Content-Type': 'application/json-patch+json',
+      },params:{
+          ...currentFilter
+      }
+        };
+
+            const response = await Axios.get(apiURL,axiosConfig);
+            if (response.status===200)
+            {
+                result = response.data;
+                
+            }
+            
+return result
+}

package/src/services/auth/PostRegisterUser.js

@@ -0,0 +1,29 @@
+import Axios from 'axios';
+import ApiURL from '../ApiURL' 
+
+export default async function PostRegisterUser(User,data){
+    
+    
+    let result =null;
+    const apiURL = ApiURL() + '/api/Auth/Register';
+    
+    
+    if (!User || !data)
+        return;
+    const axiosConfig={
+        method: 'post',
+        headers: {
+          'Authorization': `Bearer ${User.accessToken}`,
+          'Content-Type': 'application/json-patch+json',
+      },
+     
+        };
+
+            const resporone = await Axios.post(apiURL,data,axiosConfig);
+            if (resporone.status===200)
+            {
+                result = resporone.data;
+              
+            }
+return result
+}

package/src/services/auth/PostResetPasswordService.js

@@ -0,0 +1,28 @@
+import Axios from 'axios';
+import ApiURL from '../ApiURL'
+
+export default async function PostResetPasswordService(User,data){
+
+    let result =null;
+    const apiURL = ApiURL() + '/api/Auth/ResetPassword';
+
+
+    if (!User || !data)
+        return;
+    const axiosConfig={
+        method: 'post',
+        headers: {
+          'Authorization': `Bearer ${User.accessToken}`,
+          'Content-Type': 'application/json-patch+json',
+      }
+        };
+
+            const resporone = await Axios.post(apiURL,data,axiosConfig);
+
+            if (resporone.status===200)
+            {
+                result = resporone.data;
+
+            }
+return result
+}

package/src/services/auth/PutAccountService.js

@@ -0,0 +1,29 @@
+import Axios from "axios";
+import ApiURL from "../ApiURL";
+
+export default async function PutAccountService(User, data) {
+  let result = null;
+  if (!User || !data) return;
+  const apiURL = ApiURL() + `/api/Users/${data.id}`;
+
+  const axiosConfig = {
+    method: "put",
+    headers: {
+      Authorization: `Bearer ${User.accessToken}`,
+      "Content-Type": "application/json-patch+json",
+    },
+  };
+
+  try {
+    const resporone = await Axios.put(apiURL, data, axiosConfig);
+
+    if (resporone.status === 200) {
+      result = resporone.data;
+    }
+    throw resporone;
+  } catch (error) {
+
+  }
+
+  return result;
+}

package/src/services/auth/PutRefreshToken.js

@@ -0,0 +1,69 @@
+import Axios from 'axios';
+import {ApiURL, BaseURL} from '../Endpoints'
+import {jwtDecode} from "jwt-decode";
+import {ElevatorPassengerOffOutline} from 'mdi-material-ui';
+import {useContext} from 'react';
+import authConfig from 'src/configs/auth'
+import {Router} from 'next/router';
+import {useRouter} from 'next/router';
+
+
+const apiURL = BaseURL
+
+const handleLogout = () => {
+  localStorage.removeItem('userData')
+  localStorage.removeItem('refreshToken')
+  localStorage.removeItem('userId')
+  localStorage.removeItem('accessToken')
+
+  window.location.href = '/login'
+
+}
+
+export default async function PutRefreshToken() {
+  let token = localStorage.getItem(authConfig.storageTokenKeyName)
+  if (token == null || token == '') {
+    handleLogout()
+  }
+  let refreshToken = localStorage.getItem(authConfig.refreshToken)
+  let response = null;
+
+  function isTokenExpired(token) {
+    try {
+      const decodedToken = jwtDecode(token);
+      const expirationDate = new Date(decodedToken.exp * 1000);
+      return expirationDate < new Date();
+    } catch {
+      handleLogout()
+    }
+
+  }
+
+  const istokenExpired = isTokenExpired(token)
+  if (istokenExpired) {
+    const url = apiURL + `api/Auth/Refresh-Token?refreshToken=${refreshToken}`;
+    const axiosConfig = {
+      method: 'put',
+      headers: {
+
+        'Content-Type': 'application/json-patch+json',
+      },
+    };
+
+    try {
+      response = await Axios.put(url, axiosConfig);
+      if (response.status == 200) {
+        localStorage.setItem(authConfig.storageTokenKeyName, response.data.accessToken)
+      } else {
+        handleLogout();
+      }
+
+    } catch (error) {
+      handleLogout();
+    }
+
+  }
+
+
+  return
+}

package/src/services/builderHelper/actionExecutor.js

@@ -0,0 +1,73 @@
+import { executeJSCode } from './jsExecutor'
+
+/**
+ * Execute an action and set the result to the data object
+ * @param {object} action - The action to execute
+ * @param {object} context - The execution context (form, data)
+ * @param {function} setData - Function to update the data object
+ */
+export async function executeAction(action, context, setData) {
+  if (!action || !action.code) {
+    console.error('Invalid action:', action)
+    return
+  }
+
+  try {
+    // Execute the action code using centralized executor
+    const result = await executeJSCode(action.code, context)
+
+    // Parse target path and set the result
+    if (action.targetPath) {
+      setDataAtPath(setData, action.targetPath, result)
+    }
+  } catch (e) {
+    console.error(`Action execution error [${action.name}]:`, e)
+  }
+}
+
+/**
+ * Set value at a nested path in the data object
+ * @param {function} setData - Function to update the data object
+ * @param {string} path - Dot-notation path (e.g., 'data.d1' or 'd1')
+ * @param {any} value - Value to set
+ */
+function setDataAtPath(setData, path, value) {
+  // Remove 'data.' prefix if present
+  const cleanPath = path.startsWith('data.') ? path.substring(5) : path
+
+  setData(prev => {
+    const newData = { ...prev }
+    const keys = cleanPath.split('.')
+    let current = newData
+
+    // Navigate to the parent of the target key
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!current[keys[i]]) {
+        current[keys[i]] = {}
+      }
+      current = current[keys[i]]
+    }
+
+    // Set the final value
+    current[keys[keys.length - 1]] = value
+
+    return newData
+  })
+}
+
+/**
+ * Execute all actions of a specific event type
+ * @param {array} actions - All actions from schema
+ * @param {string} eventType - Event type to filter (e.g., 'onLoad')
+ * @param {object} context - Execution context (form, data)
+ * @param {function} setData - Function to update the data object
+ */
+export async function executeActionsByEvent(actions, eventType, context, setData) {
+  if (!actions || !Array.isArray(actions)) return
+
+  const matchingActions = actions.filter(action => action.event === eventType)
+
+  for (const action of matchingActions) {
+    await executeAction(action, context, setData)
+  }
+}

package/src/services/builderHelper/builderHelper.js

@@ -0,0 +1,99 @@
+export function createComponent(type) {
+  return {
+    id: `cmp_${crypto.randomUUID()}`,
+    type,
+    props: {},
+    style: {},
+    children: []
+  }
+}
+
+export function addToRoot(schema, component) {
+  return {
+    ...schema,
+    root: {
+      ...schema.root,
+      children: [...schema.root.children, component]
+    }
+  }
+}
+
+export function insertIntoTree(current, targetId, newNode) {
+  if (current.id === targetId) {
+    return {
+      ...current,
+      children: [...(current.children || []), newNode]
+    }
+  }
+
+  if (!current.children) return current
+
+  return {
+    ...current,
+    children: current.children.map(child =>
+      insertIntoTree(child, targetId, newNode)
+    )
+  }
+}
+
+function cloneNode(node) {
+  const cloned = {
+    ...node,
+    id: `cmp_${crypto.randomUUID()}`,
+    children: node.children?.map(cloneNode)
+  }
+
+  // Generate new unique key for the cloned node
+  if (cloned.props?.main?.key) {
+    const randomKey = `${node.type}_${Math.random().toString(36).substring(2, 9)}`
+    cloned.props = {
+      ...cloned.props,
+      main: {
+        ...cloned.props.main,
+        key: {
+          valueType: 'value',
+          value: randomKey
+        }
+      }
+    }
+  }
+
+  return cloned
+}
+
+export function duplicateInTree(node, targetId) {
+  if (!node.children) return node
+
+  const newChildren = []
+
+  node.children.forEach(child => {
+    newChildren.push(child)
+
+    if (child.id === targetId) {
+      newChildren.push(cloneNode(child))
+    }
+  })
+
+  return {
+    ...node,
+    children: newChildren.map(child =>
+      duplicateInTree(child, targetId)
+    )
+  }
+}
+
+function resolveValue(node, name, formData) {
+  const expr = node.expressions?.main?.[name]
+  if (expr?.type === 'js') {
+    try {
+      return new Function(
+        'form',
+        expr.code
+      )(formData)
+    } catch {
+      return undefined
+    }
+  }
+  return node.props?.main?.[name]
+}
+

package/src/services/builderHelper/index.js

@@ -0,0 +1,2 @@
+export * from './tree'
+export * from './nodeFactory'

package/src/services/builderHelper/jsExecutor.js

@@ -0,0 +1,115 @@
+import { Services } from '../Endpoints'
+import fetchReportDataByPageId from '../reportData/fetchReportData'
+
+/**
+ * Centralized JSEditor code executor
+ * Executes user-defined Calculation functions with injected services
+ *
+ * @param {string} code - The user's JavaScript code containing a Calculation function
+ * @param {object} context - Execution context with form and data
+ * @param {object} context.form - Form data
+ * @param {object} context.data - Global data object
+ * @returns {Promise<any>} - Result from the Calculation function
+ */
+export async function executeJSCode(code, context = {}) {
+  if (!code) {
+    throw new Error('No code provided to execute')
+  }
+
+  const { form = {}, data = {} } = context
+
+  try {
+    // Create async function from code with services available
+    const fn = new Function(
+      'form',
+      'data',
+      'GetService',
+      'PostService',
+      'UpdateService',
+      'DeleteService',
+      'PatchService',
+      'fetchReportData',
+      `
+return (async function() {
+${code}
+if (typeof Calculation !== 'function') {
+  throw new Error('Calculation function not found')
+}
+return await Calculation(form, data)
+})()
+`
+    )
+
+    // Execute the function with services
+    const result = await fn(
+      form,
+      data,
+      Services.GetService,
+      Services.PostService,
+      Services.UpdateService,
+      Services.DeleteService,
+      Services.PatchService,
+      fetchReportDataByPageId
+    )
+
+    return result
+  } catch (error) {
+    console.error('JSCode execution error:', error)
+    throw error
+  }
+}
+
+/**
+ * Synchronous version for prop resolution
+ * Returns the Calculation function itself without executing it
+ *
+ * @param {string} code - The user's JavaScript code containing a Calculation function
+ * @param {object} context - Execution context with form and data
+ * @returns {Function} - The Calculation function ready to be called
+ */
+export function getJSCalculationFunction(code, context = {}) {
+  if (!code) {
+    throw new Error('No code provided')
+  }
+
+  try {
+    const hasAsyncCalculation = /async\s+function\s+Calculation/.test(code)
+    const hasAwaitKeyword = /\bawait\b/.test(code)
+    const normalizedCode =
+      hasAsyncCalculation && !hasAwaitKeyword
+        ? code.replace(/async\s+function\s+Calculation/, 'function Calculation')
+        : code
+
+    const fn = new Function(
+      ...Object.keys(context),
+      'GetService',
+      'PostService',
+      'UpdateService',
+      'DeleteService',
+      'PatchService',
+      'fetchReportData',
+      `
+${normalizedCode}
+if (typeof Calculation !== 'function') {
+  throw new Error('Calculation function not found')
+}
+return Calculation
+`
+    )
+
+    const calc = fn(
+      ...Object.values(context),
+      Services.GetService,
+      Services.PostService,
+      Services.UpdateService,
+      Services.DeleteService,
+      Services.PatchService,
+      fetchReportDataByPageId
+    )
+
+    return calc
+  } catch (error) {
+    console.error('JSCode parsing error:', error)
+    throw error
+  }
+}