@fctc/edu-logic-lib 1.1.4 → 1.1.5

package/dist/index.js

@@ -1,15 +1,18 @@
 'use strict';
 
+var axios = require('axios');
 var reactRedux = require('react-redux');
 var toolkit = require('@reduxjs/toolkit');
-var axios = require('axios');
 var reactQuery = require('@tanstack/react-query');
-var react = require('react');
+var React = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var axios__default = /*#__PURE__*/_interopDefault(axios);
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+// src/config/axios-client.ts
 
 // src/constants/api/key-constant.ts
 var KeyConstants = /* @__PURE__ */ ((KeyConstants2) => {
@@ -67,6 +70,259 @@ var UriConstants = /* @__PURE__ */ ((UriConstants2) => {
   return UriConstants2;
 })(UriConstants || {});
 
+// src/config/axios-client.ts
+var MAINT_KEY = "MAINTENANCE_ACTIVE";
+var MAINT_AT = "MAINTENANCE_AT";
+var MAINT_LAST_PATH = "MAINTENANCE_LAST_PATH";
+var hasRedirectedToMaintenance = false;
+function setMaintenanceFlags() {
+  if (typeof window === "undefined") return;
+  const { pathname, search } = window.location;
+  const lastPath = pathname + (search || "");
+  if (pathname !== "/maintenance" && !window.localStorage.getItem(MAINT_LAST_PATH)) {
+    window.localStorage.setItem(MAINT_LAST_PATH, lastPath);
+  }
+  window.localStorage.setItem(MAINT_KEY, "true");
+  window.localStorage.setItem(MAINT_AT, String(Date.now()));
+}
+async function clearMaintenanceAndExit(getToken, opts) {
+  if (typeof window === "undefined") return;
+  const forceLogin = opts?.forceLogin === true;
+  const clearTokenOnForce = opts?.clearTokenOnForce !== false;
+  window.localStorage.removeItem(MAINT_KEY);
+  window.localStorage.removeItem(MAINT_AT);
+  const lastPath = window.localStorage.getItem(MAINT_LAST_PATH);
+  window.localStorage.removeItem(MAINT_LAST_PATH);
+  try {
+    if (forceLogin) {
+      if (clearTokenOnForce) {
+        try {
+          await opts?.clearToken?.();
+        } catch {
+        }
+      }
+      window.location.replace("/login");
+      return;
+    }
+    const token = await getToken();
+    if (token) {
+      const target = lastPath && lastPath !== "/maintenance" ? lastPath : "/";
+      window.location.replace(target);
+    } else {
+      window.location.replace("/login");
+    }
+  } catch {
+    window.location.replace("/login");
+  }
+}
+var axiosClient = {
+  init(config) {
+    const localStorage2 = config.localStorageUtils;
+    const sessionStorage = config.sessionStorageUtils;
+    const db = config.db;
+    let isRefreshing = false;
+    let failedQueue = [];
+    const processQueue = (error, token = null) => {
+      failedQueue?.forEach((prom) => {
+        if (error) {
+          prom.reject(error);
+        } else {
+          prom.resolve(token);
+        }
+      });
+      failedQueue = [];
+    };
+    const instance = axios__default.default.create({
+      adapter: axios__default.default.defaults.adapter,
+      baseURL: config.baseUrl,
+      timeout: 5e4,
+      paramsSerializer: (params) => new URLSearchParams(params).toString()
+    });
+    if (typeof window !== "undefined") {
+      const isMaint = window.localStorage.getItem(MAINT_KEY) === "true";
+      const onMaintenancePage = window.location.pathname === "/maintenance";
+      if (isMaint && !onMaintenancePage) {
+        hasRedirectedToMaintenance = true;
+        window.location.replace("/maintenance");
+      }
+      if (isMaint && onMaintenancePage) {
+        const healthUrl = config.healthUrl || `${(config.baseUrl || "").replace(/\/+$/, "")}/health`;
+        (async () => {
+          try {
+            await axios__default.default.get(healthUrl, { timeout: 8e3 });
+            await clearMaintenanceAndExit(() => localStorage2.getAccessToken(), {
+              forceLogin: true,
+              clearTokenOnForce: true,
+              clearToken: () => localStorage2.clearToken()
+            });
+          } catch {
+          }
+        })();
+      }
+    }
+    instance.interceptors.request.use(
+      async (configReq) => {
+        const token = await localStorage2.getAccessToken();
+        if (token) {
+          configReq.headers["Authorization"] = "Bearer " + token;
+        }
+        return configReq;
+      },
+      (error) => Promise.reject(error)
+    );
+    instance.interceptors.response.use(
+      (response) => {
+        if (typeof window !== "undefined") {
+          const isMaint = window.localStorage.getItem(MAINT_KEY) === "true";
+          const onMaintenancePage = window.location.pathname === "/maintenance";
+          if (isMaint && onMaintenancePage) {
+            (async () => {
+              await clearMaintenanceAndExit(
+                () => localStorage2.getAccessToken(),
+                {
+                  forceLogin: true,
+                  clearTokenOnForce: true,
+                  clearToken: () => localStorage2.clearToken()
+                }
+              );
+            })();
+          } else if (isMaint) {
+            window.localStorage.removeItem(MAINT_KEY);
+            window.localStorage.removeItem(MAINT_AT);
+            window.localStorage.removeItem(MAINT_LAST_PATH);
+          }
+        }
+        return handleResponse(response);
+      },
+      async (error) => {
+        const status = error?.response?.status;
+        if (status === 503) {
+          if (typeof window !== "undefined") {
+            setMaintenanceFlags();
+            if (!hasRedirectedToMaintenance && window.location.pathname !== "/maintenance") {
+              hasRedirectedToMaintenance = true;
+              window.location.replace("/maintenance");
+            }
+          }
+          return Promise.reject({
+            code: 503,
+            message: "SERVICE_UNAVAILABLE",
+            original: error?.response?.data
+          });
+        }
+        const handleError = async (err) => {
+          if (!err.response) {
+            return err;
+          }
+          const { data } = err.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((token) => {
+              originalRequest.headers["Authorization"] = "Bearer " + token;
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage.getBrowserSession();
+          const refreshToken = await localStorage2.getRefreshToken();
+          const accessTokenExp = await localStorage2.getAccessToken();
+          isRefreshing = true;
+          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
+            await clearAuthToken();
+          } else {
+            const payload = Object.fromEntries(
+              Object.entries({
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+                client_id: config.config.clientId,
+                client_secret: config.config.clientSecret
+              }).filter(([_, value]) => !!value)
+            );
+            return new Promise(function(resolve) {
+              axios__default.default.post(
+                `${config.baseUrl}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
+                }
+              ).then(async (res) => {
+                const data = res.data;
+                await localStorage2.setToken(data.access_token);
+                await localStorage2.setRefreshToken(data.refresh_token);
+                axios__default.default.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_BAD_REQUEST")) {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  const { error_code } = err.response?.data || {};
+                  if (error_code === "AUTHEN_FAIL") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
+          }
+        }
+        return Promise.reject(await handleError(error));
+      }
+    );
+    const handleResponse = (res) => {
+      if (res && res.data) {
+        return res.data;
+      }
+      return res;
+    };
+    const clearAuthToken = async () => {
+      await localStorage2.clearToken();
+      if (typeof window !== "undefined") {
+        window.location.href = `/login`;
+      }
+    };
+    function formatUrl(url, db2) {
+      return url + (db2 ? "?db=" + db2 : "");
+    }
+    const responseBody = (response) => response;
+    const requests = {
+      get: (url, headers) => instance.get(formatUrl(url, db), headers).then(responseBody),
+      post: (url, body, headers) => instance.post(formatUrl(url, db), body, { headers }).then(responseBody),
+      post_excel: (url, body, headers) => instance.post(formatUrl(url, db), body, {
+        responseType: "arraybuffer",
+        headers: {
+          "Content-Type": typeof window !== "undefined" ? "application/json" : "application/javascript",
+          Accept: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        }
+      }).then(responseBody),
+      put: (url, body, headers) => instance.put(formatUrl(url, db), body, headers).then(responseBody),
+      patch: (url, body) => instance.patch(formatUrl(url, db), body).then(responseBody),
+      delete: (url, body) => instance.delete(formatUrl(url, db), body).then(responseBody)
+    };
+    return requests;
+  }
+};
+
 // src/constants/field/field-type-constant.ts
 var FieldTypeConstants = /* @__PURE__ */ ((FieldTypeConstants2) => {
   FieldTypeConstants2["CHAR"] = "char";
@@ -663,257 +919,6 @@ var envStore = toolkit.configureStore({
 // src/store/index.ts
 var useAppDispatch = reactRedux.useDispatch;
 var useAppSelector = reactRedux.useSelector;
-var MAINT_KEY = "MAINTENANCE_ACTIVE";
-var MAINT_AT = "MAINTENANCE_AT";
-var MAINT_LAST_PATH = "MAINTENANCE_LAST_PATH";
-var hasRedirectedToMaintenance = false;
-function setMaintenanceFlags() {
-  if (typeof window === "undefined") return;
-  const { pathname, search } = window.location;
-  const lastPath = pathname + (search || "");
-  if (pathname !== "/maintenance" && !window.localStorage.getItem(MAINT_LAST_PATH)) {
-    window.localStorage.setItem(MAINT_LAST_PATH, lastPath);
-  }
-  window.localStorage.setItem(MAINT_KEY, "true");
-  window.localStorage.setItem(MAINT_AT, String(Date.now()));
-}
-async function clearMaintenanceAndExit(getToken, opts) {
-  if (typeof window === "undefined") return;
-  const forceLogin = opts?.forceLogin === true;
-  const clearTokenOnForce = opts?.clearTokenOnForce !== false;
-  window.localStorage.removeItem(MAINT_KEY);
-  window.localStorage.removeItem(MAINT_AT);
-  const lastPath = window.localStorage.getItem(MAINT_LAST_PATH);
-  window.localStorage.removeItem(MAINT_LAST_PATH);
-  try {
-    if (forceLogin) {
-      if (clearTokenOnForce) {
-        try {
-          await opts?.clearToken?.();
-        } catch {
-        }
-      }
-      window.location.replace("/login");
-      return;
-    }
-    const token = await getToken();
-    if (token) {
-      const target = lastPath && lastPath !== "/maintenance" ? lastPath : "/";
-      window.location.replace(target);
-    } else {
-      window.location.replace("/login");
-    }
-  } catch {
-    window.location.replace("/login");
-  }
-}
-var axiosClient = {
-  init(config) {
-    const localStorage2 = config.localStorageUtils;
-    const sessionStorage = config.sessionStorageUtils;
-    const db = config.db;
-    let isRefreshing = false;
-    let failedQueue = [];
-    const processQueue = (error, token = null) => {
-      failedQueue?.forEach((prom) => {
-        if (error) {
-          prom.reject(error);
-        } else {
-          prom.resolve(token);
-        }
-      });
-      failedQueue = [];
-    };
-    const instance = axios__default.default.create({
-      adapter: axios__default.default.defaults.adapter,
-      baseURL: config.baseUrl,
-      timeout: 5e4,
-      paramsSerializer: (params) => new URLSearchParams(params).toString()
-    });
-    if (typeof window !== "undefined") {
-      const isMaint = window.localStorage.getItem(MAINT_KEY) === "true";
-      const onMaintenancePage = window.location.pathname === "/maintenance";
-      if (isMaint && !onMaintenancePage) {
-        hasRedirectedToMaintenance = true;
-        window.location.replace("/maintenance");
-      }
-      if (isMaint && onMaintenancePage) {
-        const healthUrl = config.healthUrl || `${(config.baseUrl || "").replace(/\/+$/, "")}/health`;
-        (async () => {
-          try {
-            await axios__default.default.get(healthUrl, { timeout: 8e3 });
-            await clearMaintenanceAndExit(() => localStorage2.getAccessToken(), {
-              forceLogin: true,
-              clearTokenOnForce: true,
-              clearToken: () => localStorage2.clearToken()
-            });
-          } catch {
-          }
-        })();
-      }
-    }
-    instance.interceptors.request.use(
-      async (configReq) => {
-        const token = await localStorage2.getAccessToken();
-        if (token) {
-          configReq.headers["Authorization"] = "Bearer " + token;
-        }
-        return configReq;
-      },
-      (error) => Promise.reject(error)
-    );
-    instance.interceptors.response.use(
-      (response) => {
-        if (typeof window !== "undefined") {
-          const isMaint = window.localStorage.getItem(MAINT_KEY) === "true";
-          const onMaintenancePage = window.location.pathname === "/maintenance";
-          if (isMaint && onMaintenancePage) {
-            (async () => {
-              await clearMaintenanceAndExit(
-                () => localStorage2.getAccessToken(),
-                {
-                  forceLogin: true,
-                  clearTokenOnForce: true,
-                  clearToken: () => localStorage2.clearToken()
-                }
-              );
-            })();
-          } else if (isMaint) {
-            window.localStorage.removeItem(MAINT_KEY);
-            window.localStorage.removeItem(MAINT_AT);
-            window.localStorage.removeItem(MAINT_LAST_PATH);
-          }
-        }
-        return handleResponse(response);
-      },
-      async (error) => {
-        const status = error?.response?.status;
-        if (status === 503) {
-          if (typeof window !== "undefined") {
-            setMaintenanceFlags();
-            if (!hasRedirectedToMaintenance && window.location.pathname !== "/maintenance") {
-              hasRedirectedToMaintenance = true;
-              window.location.replace("/maintenance");
-            }
-          }
-          return Promise.reject({
-            code: 503,
-            message: "SERVICE_UNAVAILABLE",
-            original: error?.response?.data
-          });
-        }
-        const handleError = async (err) => {
-          if (!err.response) {
-            return err;
-          }
-          const { data } = err.response;
-          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
-            await clearAuthToken();
-          }
-          return data;
-        };
-        const originalRequest = error.config;
-        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401].includes(
-          error.response.data.code
-        )) {
-          if (isRefreshing) {
-            return new Promise(function(resolve, reject) {
-              failedQueue.push({ resolve, reject });
-            }).then((token) => {
-              originalRequest.headers["Authorization"] = "Bearer " + token;
-              return instance.request(originalRequest);
-            }).catch(async (err) => {
-              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
-                await clearAuthToken();
-              }
-            });
-          }
-          const browserSession = await sessionStorage.getBrowserSession();
-          const refreshToken = await localStorage2.getRefreshToken();
-          const accessTokenExp = await localStorage2.getAccessToken();
-          isRefreshing = true;
-          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
-            await clearAuthToken();
-          } else {
-            const payload = Object.fromEntries(
-              Object.entries({
-                refresh_token: refreshToken,
-                grant_type: "refresh_token",
-                client_id: config.config.clientId,
-                client_secret: config.config.clientSecret
-              }).filter(([_, value]) => !!value)
-            );
-            return new Promise(function(resolve) {
-              axios__default.default.post(
-                `${config.baseUrl}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
-                payload,
-                {
-                  headers: {
-                    "Content-Type": "multipart/form-data",
-                    Authorization: `Bearer ${accessTokenExp}`
-                  }
-                }
-              ).then(async (res) => {
-                const data = res.data;
-                await localStorage2.setToken(data.access_token);
-                await localStorage2.setRefreshToken(data.refresh_token);
-                axios__default.default.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
-                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
-                processQueue(null, data.access_token);
-                resolve(instance.request(originalRequest));
-              }).catch(async (err) => {
-                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_BAD_REQUEST")) {
-                  await clearAuthToken();
-                }
-                if (err && err.response) {
-                  const { error_code } = err.response?.data || {};
-                  if (error_code === "AUTHEN_FAIL") {
-                    await clearAuthToken();
-                  }
-                }
-                processQueue(err, null);
-              }).finally(() => {
-                isRefreshing = false;
-              });
-            });
-          }
-        }
-        return Promise.reject(await handleError(error));
-      }
-    );
-    const handleResponse = (res) => {
-      if (res && res.data) {
-        return res.data;
-      }
-      return res;
-    };
-    const clearAuthToken = async () => {
-      await localStorage2.clearToken();
-      if (typeof window !== "undefined") {
-        window.location.href = `/login`;
-      }
-    };
-    function formatUrl(url, db2) {
-      return url + (db2 ? "?db=" + db2 : "");
-    }
-    const responseBody = (response) => response;
-    const requests = {
-      get: (url, headers) => instance.get(formatUrl(url, db), headers).then(responseBody),
-      post: (url, body, headers) => instance.post(formatUrl(url, db), body, { headers }).then(responseBody),
-      post_excel: (url, body, headers) => instance.post(formatUrl(url, db), body, {
-        responseType: "arraybuffer",
-        headers: {
-          "Content-Type": typeof window !== "undefined" ? "application/json" : "application/javascript",
-          Accept: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-        }
-      }).then(responseBody),
-      put: (url, body, headers) => instance.put(formatUrl(url, db), body, headers).then(responseBody),
-      patch: (url, body) => instance.patch(formatUrl(url, db), body).then(responseBody),
-      delete: (url, body) => instance.delete(formatUrl(url, db), body).then(responseBody)
-    };
-    return requests;
-  }
-};
 
 // src/environment/EnvStore.ts
 var EnvStore = class {
@@ -4394,12 +4399,370 @@ var ViewService = {
 };
 var view_service_default = ViewService;
 
-// src/models/base-model/index.ts
-var BaseModel = class {
-  name;
-  view;
-  actContext;
-  fields;
+// src/hooks/auth/use-forgot-password.ts
+var useForgotPassword = () => {
+  return reactQuery.useMutation({
+    mutationFn: (email) => {
+      return auth_service_default.forgotPassword(email);
+    }
+  });
+};
+var use_forgot_password_default = useForgotPassword;
+var useGetProvider = () => {
+  return reactQuery.useMutation({
+    mutationFn: (data) => {
+      return auth_service_default.getProviders(data?.db);
+    }
+  });
+};
+var use_get_provider_default = useGetProvider;
+var useIsValidToken = () => {
+  return reactQuery.useMutation({
+    mutationFn: (token) => {
+      return auth_service_default.isValidToken(token);
+    }
+  });
+};
+var use_isvalid_token_default = useIsValidToken;
+var useLoginCredential = () => {
+  return reactQuery.useMutation({
+    mutationFn: (data) => {
+      return auth_service_default.login(data);
+    }
+  });
+};
+var use_login_credential_default = useLoginCredential;
+var useLoginSocial = () => {
+  return reactQuery.useMutation({
+    mutationFn: (data) => {
+      return auth_service_default.loginSocial(data);
+    }
+  });
+};
+var use_login_socical_default = useLoginSocial;
+var useResetPassword = () => {
+  return reactQuery.useMutation({
+    mutationFn: (request) => {
+      return auth_service_default.resetPassword(request.data, request.token);
+    }
+  });
+};
+var use_reset_password_default = useResetPassword;
+var useUpdatePassword = () => {
+  return reactQuery.useMutation({
+    mutationFn: (request) => {
+      return auth_service_default.updatePassword(request.data, request.token);
+    }
+  });
+};
+var use_update_password_default = useUpdatePassword;
+var useField = (props) => {
+  const [invisible, setInvisible] = React__default.default.useState(true);
+  const [required, setRequired] = React__default.default.useState(false);
+  const [readonly, setReadOnly] = React__default.default.useState(false);
+  const {
+    invisible: inv,
+    required: req,
+    readonly: rea,
+    onchangeData,
+    rootField,
+    index,
+    name
+  } = props;
+  const nameField = rootField ? `${rootField?.name}.${index}.${name}` : null;
+  React.useEffect(() => {
+    if (onchangeData && Object.keys(onchangeData).length > 0) {
+      setRequired(
+        typeof req === "object" ? matchDomains(onchangeData, req) : checkDomain(onchangeData, req)
+      );
+      setInvisible(matchDomains(onchangeData, inv));
+      setReadOnly(
+        typeof req === "object" ? matchDomains(onchangeData, rea) : checkDomain(onchangeData, rea)
+      );
+    }
+  }, [onchangeData]);
+  return {
+    invisible,
+    required,
+    readonly,
+    nameField
+  };
+};
+var use_field_default = useField;
+var useGetCompanyInfo = () => {
+  return reactQuery.useMutation({
+    mutationFn: (id) => company_service_default.getInfoCompany(id)
+  });
+};
+var use_get_company_info_default = useGetCompanyInfo;
+var useGetCurrentCompany = () => {
+  return reactQuery.useMutation({
+    mutationFn: () => company_service_default.getCurrentCompany()
+  });
+};
+var use_get_current_company_default = useGetCurrentCompany;
+var useChangeStatus = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ data }) => {
+      return form_service_default.changeStatus({
+        data
+      });
+    }
+  });
+};
+var use_change_status_default = useChangeStatus;
+var useDeleteComment = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ data }) => form_service_default.deleteComment({
+      data
+    })
+  });
+};
+var use_delete_comment_default = useDeleteComment;
+var useGetComment = ({ data, queryKey }) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => form_service_default.getComment({ data }).then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    enabled: !!data.thread_id && !isNaN(data.thread_id),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_comment_default = useGetComment;
+var useGetFormView = ({
+  data,
+  queryKey,
+  enabled
+}) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => form_service_default.getFormView({ data }).then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    enabled,
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_form_view_default = useGetFormView;
+var useGetImage = ({
+  data,
+  queryKey,
+  src
+}) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => form_service_default.getImage({ data }).then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    enabled: !src && !isBase64File(src),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_image_default = useGetImage;
+var useSendComment = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ data }) => form_service_default.sentComment({
+      data
+    })
+  });
+};
+var use_send_comment_default = useSendComment;
+var useUploadImage = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ data }) => form_service_default.uploadImage({
+      data
+    })
+  });
+};
+var use_upload_image_default = useUploadImage;
+var useExportExcel = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      model,
+      domain,
+      ids,
+      fields,
+      type,
+      importCompat,
+      context,
+      groupby
+    }) => excel_service_default.exportExcel({
+      model,
+      domain,
+      ids,
+      fields,
+      type,
+      importCompat,
+      context,
+      groupby
+    })
+  });
+};
+var use_export_excel_default = useExportExcel;
+var useGetFieldExport = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      ids,
+      model,
+      isShow,
+      parentField,
+      fieldType,
+      parentName,
+      prefix,
+      name,
+      context,
+      importCompat
+    }) => excel_service_default.getFieldExport({
+      ids,
+      model,
+      isShow,
+      parentField,
+      fieldType,
+      parentName,
+      prefix,
+      name,
+      context,
+      importCompat
+    })
+  });
+};
+var use_get_field_export_default = useGetFieldExport;
+var useGetFileExcel = ({
+  model,
+  context
+}) => {
+  return reactQuery.useQuery({
+    queryKey: [],
+    queryFn: () => excel_service_default.getFileExcel({
+      model,
+      context
+    }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_file_excel_default = useGetFileExcel;
+var useParsePreview = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      id,
+      selectedSheet,
+      isHeader,
+      context
+    }) => excel_service_default.parsePreview({
+      id,
+      selectedSheet,
+      isHeader,
+      context
+    })
+  });
+};
+var use_parse_preview_default = useParsePreview;
+var useUploadFile = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ formData }) => excel_service_default.uploadFile({
+      formData
+    })
+  });
+};
+var use_upload_file_default = useUploadFile;
+var useUploadIdFile = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ formData }) => excel_service_default.uploadIdFile({
+      formData
+    })
+  });
+};
+var use_upload_id_file_default = useUploadIdFile;
+var useExecuteImport = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      fields,
+      columns,
+      idFile,
+      options,
+      dryrun,
+      context
+    }) => excel_service_default.executeImport({
+      fields,
+      columns,
+      idFile,
+      options,
+      dryrun,
+      context
+    })
+  });
+};
+var uss_execute_import_default = useExecuteImport;
+var useDelete = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ ids, model }) => model_service_default.delete({ ids, model })
+  });
+};
+var use_delete_default = useDelete;
+var useGetAll = ({ data, queryKey, viewResponse }) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => model_service_default.getAll({ data }).then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    enabled: !!data.specification && !!data.model && !!data.domain && !!viewResponse,
+    refetchOnWindowFocus: false
+    // placeholderData: keepPreviousData,
+  });
+};
+var use_get_all_default = useGetAll;
+var useGetDetail = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      model,
+      ids,
+      specification,
+      context
+    }) => model_service_default.getDetail({
+      model,
+      ids,
+      specification,
+      context
+    })
+  });
+};
+var use_get_detail_default = useGetDetail;
+var useGetFieldOnChange = ({ model }) => {
+  return reactQuery.useQuery({
+    queryKey: [`field-onchange-${model}`, model],
+    queryFn: () => model_service_default.getListFieldsOnchange({
+      model
+    }).then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    refetchOnWindowFocus: false,
+    staleTime: Infinity
+  });
+};
+var use_get_field_onchange_default = useGetFieldOnChange;
+
+// src/models/base-model/index.ts
+var BaseModel = class {
+  name;
+  view;
+  actContext;
+  fields;
   constructor(init) {
     this.name = init.name;
     this.view = init.view;
@@ -4510,7 +4873,88 @@ var BaseModel = class {
   }
 };
 var base_model_default = BaseModel;
-function useButton() {
+
+// src/hooks/model/use-model.ts
+var useModel = () => {
+  const initModel = (modelData) => {
+    switch (modelData?.name) {
+      default:
+        return new base_model_default(modelData);
+    }
+  };
+  return {
+    initModel
+  };
+};
+var use_model_default = useModel;
+
+// src/hooks/model/use-odoo-data-transform.ts
+var useOdooDataTransform = () => {
+  return {
+    toDataJS: model_service_default.toDataJS,
+    parseORM: model_service_default.parseORMOdoo
+  };
+};
+var use_odoo_data_transform_default = useOdooDataTransform;
+var useOnChangeForm = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      ids,
+      model,
+      specification,
+      context,
+      object,
+      fieldChange
+    }) => model_service_default.onChange({
+      ids,
+      model,
+      specification,
+      context,
+      object,
+      fieldChange
+    })
+  });
+};
+var use_onchange_form_default = useOnChangeForm;
+var useSave = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      ids,
+      model,
+      data,
+      specification,
+      context
+    }) => model_service_default.save({ ids, model, data, specification, context })
+  });
+};
+var use_save_default = useSave;
+var useGetProfile = () => {
+  return reactQuery.useMutation({
+    mutationFn: () => user_service_default.getProfile()
+  });
+};
+var use_get_profile_default = useGetProfile;
+var useGetUser = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ id, context }) => user_service_default.getUser({
+      id,
+      context
+    })
+  });
+};
+var use_get_user_default = useGetUser;
+var useSwitchLocale = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ data }) => {
+      return user_service_default.switchUserLocale({
+        id: data.id,
+        values: data.values
+      });
+    }
+  });
+};
+var use_switch_locale_default = useSwitchLocale;
+var useButton = () => {
   return reactQuery.useMutation({
     mutationFn: ({
       model,
@@ -4522,11 +4966,161 @@ function useButton() {
       ids,
       context,
       method
+    }),
+    onSuccess: (response) => {
+      return response;
+    }
+  });
+};
+var use_button_default = useButton;
+var useDuplicateRecord = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      id,
+      model,
+      context
+    }) => action_service_default.duplicateRecord({
+      id,
+      model,
+      context
     })
   });
-}
+};
+var use_duplicate_record_default = useDuplicateRecord;
+var useGetListData = (listDataProps, queryKey, enabled) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => model_service_default.getAll({ data: listDataProps }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    enabled,
+    refetchOnWindowFocus: false,
+    staleTime: 0
+  });
+};
+var use_get_list_data_default = useGetListData;
+var useGetMenu = ({ context, enabled, queryKey }) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: async () => {
+      const res = await view_service_default.getMenu(context);
+      if (res?.records && Array.isArray(res.records) && res.records.length > 0) {
+        return res.records;
+      }
+      return [];
+    },
+    refetchOnWindowFocus: false,
+    staleTime: Infinity,
+    enabled
+  });
+};
+var use_get_menu_default = useGetMenu;
+var useGetSelection = ({
+  data,
+  queryKey,
+  enabled
+}) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => view_service_default.getSelectionItem({ data }),
+    enabled,
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_selection_default = useGetSelection;
+var useGetView = (viewParams, actData) => {
+  return reactQuery.useQuery({
+    queryKey: ["get_view_by_action" /* GET_VIEW_BY_ACTION */, viewParams],
+    queryFn: () => view_service_default.getView(viewParams),
+    enabled: !!actData,
+    refetchOnWindowFocus: false,
+    staleTime: Infinity
+  });
+};
+var use_get_view_default = useGetView;
+var useLoadAction = ({
+  idAction,
+  context
+}) => {
+  return reactQuery.useQuery({
+    queryKey: ["load_action", idAction],
+    queryFn: () => action_service_default.loadAction({
+      idAction,
+      context
+    }),
+    enabled: false,
+    staleTime: Infinity,
+    gcTime: Infinity
+  });
+};
+var use_load_action_default = useLoadAction;
+var usePrint = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ id, report, db }) => action_service_default.print({
+      id,
+      report,
+      db
+    })
+  });
+};
+var use_print_default = usePrint;
+var useRemoveRow = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      model,
+      ids,
+      context
+    }) => action_service_default.removeRows({
+      model,
+      ids,
+      context
+    })
+  });
+};
+var use_remove_row_default = useRemoveRow;
+var useRunAction = ({ idAction, context }) => {
+  return reactQuery.useQuery({
+    queryKey: ["run_action", idAction],
+    queryFn: () => action_service_default.runAction({
+      idAction,
+      context
+    }),
+    enabled: false,
+    staleTime: Infinity,
+    gcTime: Infinity
+  });
+};
+var use_run_action_default = useRunAction;
+
+// src/models/company-model/index.ts
+var CompanyModel = class extends base_model_default {
+  constructor(init) {
+    super(init);
+  }
+  async getCurrentCompany() {
+    return await company_service_default.getCurrentCompany();
+  }
+  async getUserCompany(id) {
+    return await company_service_default.getInfoCompany(id);
+  }
+};
+var company_model_default = CompanyModel;
+
+// src/models/user-model/index.ts
+var UserModel = class extends base_model_default {
+  constructor(init) {
+    super(init);
+  }
+  async getProfile() {
+    return await user_service_default.getProfile();
+  }
+};
+var user_model_default = UserModel;
 var ReactQueryProvider = ({ children }) => {
-  const [queryClient] = react.useState(
+  const [queryClient] = React.useState(
     () => new reactQuery.QueryClient({
       defaultOptions: {
         queries: {
@@ -4548,8 +5142,8 @@ var MainProvider = ({ children }) => {
 };
 var VersionGate = ({ children }) => {
   const queryClient = reactQuery.useQueryClient();
-  const [ready, setReady] = react.useState(false);
-  react.useEffect(() => {
+  const [ready, setReady] = React.useState(false);
+  React.useEffect(() => {
     const clearVersion = () => {
       queryClient.clear();
       localStorage.removeItem("__api_version__");
@@ -4579,31 +5173,6 @@ var VersionGate = ({ children }) => {
   return ready ? /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children }) : null;
 };
 
-// src/models/company-model/index.ts
-var CompanyModel = class extends base_model_default {
-  constructor(init) {
-    super(init);
-  }
-  async getCurrentCompany() {
-    return await company_service_default.getCurrentCompany();
-  }
-  async getUserCompany(id) {
-    return await company_service_default.getInfoCompany(id);
-  }
-};
-var company_model_default = CompanyModel;
-
-// src/models/user-model/index.ts
-var UserModel = class extends base_model_default {
-  constructor(init) {
-    super(init);
-  }
-  async getProfile() {
-    return await user_service_default.getProfile();
-  }
-};
-var user_model_default = UserModel;
-
 exports.ActionService = action_service_default;
 exports.AuthService = auth_service_default;
 exports.BaseModel = base_model_default;
@@ -4710,5 +5279,49 @@ exports.toQueryString = toQueryString;
 exports.updateSearchMap = updateSearchMap;
 exports.useAppDispatch = useAppDispatch;
 exports.useAppSelector = useAppSelector;
-exports.useButton = useButton;
+exports.useButton = use_button_default;
+exports.useChangeStatus = use_change_status_default;
+exports.useDelete = use_delete_default;
+exports.useDeleteComment = use_delete_comment_default;
+exports.useDuplicateRecord = use_duplicate_record_default;
+exports.useExecuteImport = uss_execute_import_default;
+exports.useExportExcel = use_export_excel_default;
+exports.useField = use_field_default;
+exports.useForgotPassword = use_forgot_password_default;
+exports.useGetAll = use_get_all_default;
+exports.useGetComment = use_get_comment_default;
+exports.useGetCompanyInfo = use_get_company_info_default;
+exports.useGetCurrentCompany = use_get_current_company_default;
+exports.useGetDetail = use_get_detail_default;
+exports.useGetFieldExport = use_get_field_export_default;
+exports.useGetFieldOnChange = use_get_field_onchange_default;
+exports.useGetFileExcel = use_get_file_excel_default;
+exports.useGetFormView = use_get_form_view_default;
+exports.useGetImage = use_get_image_default;
+exports.useGetListData = use_get_list_data_default;
+exports.useGetMenu = use_get_menu_default;
+exports.useGetProfile = use_get_profile_default;
+exports.useGetProvider = use_get_provider_default;
+exports.useGetSelection = use_get_selection_default;
+exports.useGetUser = use_get_user_default;
+exports.useGetView = use_get_view_default;
+exports.useIsValidToken = use_isvalid_token_default;
+exports.useLoadAction = use_load_action_default;
+exports.useLoginCredential = use_login_credential_default;
+exports.useLoginSocial = use_login_socical_default;
+exports.useModel = use_model_default;
+exports.useOdooDataTransform = use_odoo_data_transform_default;
+exports.useOnChangeForm = use_onchange_form_default;
+exports.useParsePreview = use_parse_preview_default;
+exports.usePrint = use_print_default;
+exports.useRemoveRow = use_remove_row_default;
+exports.useResetPassword = use_reset_password_default;
+exports.useRunAction = use_run_action_default;
+exports.useSave = use_save_default;
+exports.useSendComment = use_send_comment_default;
+exports.useSwitchLocale = use_switch_locale_default;
 exports.useTabModel = useTabModel;
+exports.useUpdatePassword = use_update_password_default;
+exports.useUploadFile = use_upload_file_default;
+exports.useUploadIdFile = use_upload_id_file_default;
+exports.useUploadImage = use_upload_image_default;