@fctc/interface-logic 1.10.6 → 1.10.8

package/dist/provider.mjs

@@ -653,8 +653,47 @@ import { useQueryClient } from "@tanstack/react-query";
 
 // src/services/view-service/backup.ts
 import { useCallback } from "react";
+
+// src/constants/api/uri-constant.ts
+var UriConstants = /* @__PURE__ */ ((UriConstants2) => {
+  UriConstants2["AUTH_TOKEN_PATH"] = "/authentication/oauth2/token";
+  UriConstants2["GENTOKEN_SOCIAL"] = "/token/generate";
+  UriConstants2["CALL_PATH"] = "/call";
+  UriConstants2["COMPANY_PATH"] = "/company";
+  UriConstants2["PROFILE_PATH"] = "/userinfo";
+  UriConstants2["RESET_PASSWORD_PATH"] = "/reset_password";
+  UriConstants2["CHANGE_PASSWORD_PATH"] = "/change_password";
+  UriConstants2["UPDATE_PASSWORD_PATH"] = "/change_password_parent";
+  UriConstants2["LOAD_ACTION"] = `/load_action`;
+  UriConstants2["REPORT_PATH"] = `/report`;
+  UriConstants2["RUN_ACTION_PATH"] = `/run_action`;
+  UriConstants2["UPLOAD_FILE_PATH"] = `/upload/file`;
+  UriConstants2["GET_MESSAGE"] = `/chatter/thread/messages`;
+  UriConstants2["SENT_MESSAGE"] = `/chatter/message/post`;
+  UriConstants2["UPLOAD_IMAGE"] = `/mail/attachment/upload`;
+  UriConstants2["DELETE_MESSAGE"] = `/chatter/message/update_content`;
+  UriConstants2["IMAGE_PATH"] = `/web/image`;
+  UriConstants2["LOAD_MESSAGE"] = `/load_message_failures`;
+  UriConstants2["TOKEN"] = `/check_token`;
+  UriConstants2["CREATE_UPDATE_PATH"] = `/create_update`;
+  UriConstants2["TWOFA_METHOD_PATH"] = `/id/api/v2/call`;
+  UriConstants2["SIGNIN_SSO"] = `/signin-sso/oauth`;
+  UriConstants2["GRANT_ACCESS"] = "/grant-access";
+  UriConstants2["TOKEN_BY_CODE"] = "/token";
+  UriConstants2["LOGOUT"] = "/logout";
+  return UriConstants2;
+})(UriConstants || {});
+
+// src/constants/widget/widget-avatar-constant.ts
+var WIDGETAVATAR = /* @__PURE__ */ ((WIDGETAVATAR2) => {
+  WIDGETAVATAR2["many2one_avatar_user"] = "many2one_avatar_user";
+  WIDGETAVATAR2["many2many_avatar_user"] = "many2many_avatar_user";
+  return WIDGETAVATAR2;
+})(WIDGETAVATAR || {});
+
+// src/services/view-service/backup.ts
 function useViewService() {
-  const { env } = useEnv();
+  const { env: env2 } = useEnv();
   const getView = useCallback(
     async ({ model, views, context = {}, options = {}, aid }) => {
       const defaultOptions = {
@@ -671,13 +710,13 @@ function useViewService() {
         },
         with_context: context
       };
-      return env?.requests?.post("/call" /* CALL_PATH */, jsonDataView, {
+      return env2?.requests?.post("/call" /* CALL_PATH */, jsonDataView, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env]
+    [env2]
   );
   const getMenu = useCallback(
     async (context) => {
@@ -784,13 +823,13 @@ function useViewService() {
           ]
         }
       };
-      return env?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+      return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env]
+    [env2]
   );
   const getActionDetail = useCallback(
     async (aid, context) => {
@@ -814,13 +853,13 @@ function useViewService() {
           }
         }
       };
-      return env?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+      return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env]
+    [env2]
   );
   const getResequence = useCallback(
     async ({ model, ids, context, offset }) => {
@@ -831,13 +870,13 @@ function useViewService() {
         field: "sequence",
         ...offset > 0 ? { offset } : {}
       };
-      return env?.requests.post("/web/dataset/resequence", jsonData, {
+      return env2?.requests.post("/web/dataset/resequence", jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env]
+    [env2]
   );
   const getSelectionItem = useCallback(
     async ({ data }) => {
@@ -858,17 +897,17 @@ function useViewService() {
           }
         }
       };
-      return env?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env]
+    [env2]
   );
   const loadMessages = useCallback(
     async () => {
-      return env.requests.post(
+      return env2.requests.post(
         "/load_message_failures" /* LOAD_MESSAGE */,
         {},
         {
@@ -878,18 +917,18 @@ function useViewService() {
         }
       );
     },
-    [env]
+    [env2]
   );
   const getVersion = useCallback(
     async () => {
-      console.log("env?.requests", env, env?.requests);
-      return env?.requests?.get("", {
+      console.log("env?.requests", env2, env2?.requests);
+      return env2?.requests?.get("", {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env]
+    [env2]
   );
   return {
     getView,
@@ -3019,6 +3058,26 @@ function matchDomain(record, domain) {
 
 // src/utils/function.ts
 import { useEffect, useState } from "react";
+var toQueryString = (params) => {
+  return Object.keys(params).map(
+    (key) => encodeURIComponent(key) + "=" + encodeURIComponent(params[key].toString())
+  ).join("&");
+};
+var isBase64File = (str) => {
+  try {
+    const dataUriPattern = /^data:([a-zA-Z]+\/[a-zA-Z0-9-.+]+)?;base64,/;
+    if (dataUriPattern.test(str)) {
+      return true;
+    }
+    const base64Pattern = (
+      // eslint-disable-next-line no-useless-escape
+      /^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{3}=|[A-Za-z0-9+\/]{2}==)?$/
+    );
+    return base64Pattern.test(str);
+  } catch (e) {
+    return false;
+  }
+};
 var updateTokenParamInOriginalRequest = (originalRequest, newAccessToken) => {
   if (!originalRequest.data) return originalRequest.data;
   if (typeof originalRequest.data === "string") {
@@ -3249,116 +3308,1822 @@ var axiosClient = {
   }
 };
 
-// src/hooks/auth/use-forgotpassword-sso.ts
-import { useMutation as useMutation2 } from "@tanstack/react-query";
-
-// src/hooks/auth/use-get-provider.ts
-import { useMutation as useMutation3 } from "@tanstack/react-query";
-
-// src/hooks/auth/use-isvalid-token.ts
-import { useMutation as useMutation4 } from "@tanstack/react-query";
-
-// src/hooks/auth/use-login-credential.tsx
-import { useMutation as useMutation5 } from "@tanstack/react-query";
+// src/environment/EnvStore.ts
+var EventEmitter = class {
+  listeners = {};
+  on(event, callback) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event].push(callback);
+  }
+  emit(event, data) {
+    if (this.listeners[event]) {
+      this.listeners[event].forEach((callback) => callback(data));
+    }
+  }
+};
+var EnvStore = class {
+  state;
+  emitter;
+  localStorageUtil;
+  sessionStorageUtil;
+  constructor(localStorageUtil = localStorageUtils(), sessionStorageUtil = sessionStorageUtils()) {
+    this.state = {
+      baseUrl: "",
+      requests: null,
+      companies: [],
+      user: {},
+      config: null,
+      envFile: null,
+      defaultCompany: {
+        id: null,
+        logo: "",
+        secondary_color: "",
+        primary_color: ""
+      },
+      context: {
+        uid: null,
+        allowed_company_ids: [],
+        lang: "vi_VN",
+        tz: "Asia/Saigon"
+      },
+      localStorageUtils: localStorageUtil,
+      sessionStorageUtils: sessionStorageUtil
+    };
+    this.emitter = new EventEmitter();
+    this.localStorageUtil = localStorageUtil;
+    this.sessionStorageUtil = sessionStorageUtil;
+  }
+  getEnv() {
+    return { ...this.state };
+  }
+  onUpdate(callback) {
+    this.emitter.on("update", callback);
+  }
+  setupEnv(envConfig) {
+    this.state = {
+      ...this.state,
+      ...envConfig,
+      localStorageUtils: this.localStorageUtil,
+      sessionStorageUtils: this.sessionStorageUtil
+    };
+    this.state.requests = axiosClient.init(this.state);
+    this.emitter.emit("update", this.getEnv());
+    return this.getEnv();
+  }
+  setUid(uid) {
+    this.state = {
+      ...this.state,
+      context: { ...this.state.context, uid }
+    };
+    this.emitter.emit("update", this.getEnv());
+  }
+  setLang(lang) {
+    this.state = {
+      ...this.state,
+      context: { ...this.state.context, lang }
+    };
+    this.emitter.emit("update", this.getEnv());
+  }
+  setAllowCompanies(allowed_company_ids) {
+    this.state = {
+      ...this.state,
+      context: { ...this.state.context, allowed_company_ids }
+    };
+    this.emitter.emit("update", this.getEnv());
+  }
+  setCompanies(companies) {
+    this.state = { ...this.state, companies };
+    this.emitter.emit("update", this.getEnv());
+  }
+  setDefaultCompany(defaultCompany) {
+    this.state = { ...this.state, defaultCompany };
+    this.emitter.emit("update", this.getEnv());
+  }
+  setUserInfo(user) {
+    this.state = { ...this.state, user };
+    this.emitter.emit("update", this.getEnv());
+  }
+  setConfig(config) {
+    this.state = { ...this.state, config };
+    this.emitter.emit("update", this.getEnv());
+  }
+  setEnvFile(envFile) {
+    this.state = { ...this.state, envFile };
+    this.emitter.emit("update", this.getEnv());
+  }
+};
+var env = null;
+function initEnv({
+  localStorageUtils: localStorageUtil = localStorageUtils(),
+  sessionStorageUtils: sessionStorageUtil = sessionStorageUtils()
+}) {
+  if (!env) {
+    env = new EnvStore(localStorageUtil, sessionStorageUtil);
+  }
+  return env;
+}
+function getEnv() {
+  if (!env) {
+    env = initEnv({});
+  }
+  return env?.getEnv();
+}
 
-// src/services/auth-service/backup.ts
-import { useCallback as useCallback2 } from "react";
-function useAuthService() {
-  const { env } = useEnv();
-  const login = useCallback2(
-    async (body) => {
-      const payload = Object.fromEntries(
-        Object.entries({
-          username: body.email,
-          password: body.password,
-          grant_type: env?.config?.grantType || "",
-          client_id: env?.config?.clientId || "",
-          client_secret: env?.config?.clientSecret || ""
-        }).filter(([_, value]) => !!value)
-      );
-      const encodedData = new URLSearchParams(payload).toString();
-      return env?.requests?.post(body.path, encodedData, {
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        }
-      });
-    },
-    [env]
-  );
-  const forgotPassword = useCallback2(
-    async (email) => {
-      const bodyData = {
-        login: email,
-        url: `${window.location.origin}/reset-password`
+// src/services/action-service/index.ts
+var ActionService = {
+  // Load Action
+  async loadAction({
+    idAction,
+    context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      action_id: idAction,
+      with_context: {
+        ...context
+      }
+    };
+    return env2.requests.post(`${"/load_action" /* LOAD_ACTION */}`, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  // Call Button
+  async callButton({
+    model,
+    ids = [],
+    context,
+    method
+  }) {
+    try {
+      const env2 = getEnv();
+      const jsonData = {
+        model,
+        method,
+        ids,
+        with_context: context
       };
-      return env?.requests?.post("/reset_password" /* RESET_PASSWORD_PATH */, bodyData, {
+      return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
-    },
-    [env]
-  );
-  const forgotPasswordSSO = useCallback2(
-    async ({
-      email,
-      with_context,
-      method
-    }) => {
-      const body = {
-        method,
-        kwargs: {
-          vals: {
-            email
-          }
+    } catch (error) {
+      console.error("Error when calling button action:", error);
+      throw error;
+    }
+  },
+  // remove Row
+  async removeRows({
+    model,
+    ids,
+    context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "unlink",
+      ids,
+      with_context: context
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  // Duplicate Model
+  async duplicateRecord({
+    model,
+    id,
+    context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "copy",
+      ids: id,
+      with_context: context
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  // Get Print Report
+  async getPrintReportName({ id }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model: "ir.actions.report",
+      method: "web_read",
+      id,
+      kwargs: {
+        specification: {
+          report_name: {}
+        }
+      }
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  //Save Print Invoice
+  async print({ id, report, db }) {
+    const env2 = getEnv();
+    const jsonData = {
+      report,
+      id,
+      type: "pdf",
+      file_response: true,
+      db
+    };
+    const queryString = toQueryString(jsonData);
+    const urlWithParams = `${"/report" /* REPORT_PATH */}?${queryString}`;
+    return env2.requests.get(urlWithParams, {
+      headers: {
+        "Content-Type": "application/json"
+      },
+      responseType: "arraybuffer"
+    });
+  },
+  //Run Action
+  async runAction({
+    idAction,
+    context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      action_id: idAction,
+      with_context: {
+        ...context
+      }
+      // context: {
+      //   lang: 'en_US',
+      //   tz: 'Asia/Saigon',
+      //   uid: 2,
+      //   allowed_company_ids: [1],
+      //   active_id: Array.isArray(idDetail) ? idDetail[0] : idDetail,
+      //   active_ids: Array.isArray(idDetail) ? [...idDetail] : idDetail,
+      //   active_model: model,
+      // },
+    };
+    return env2.requests.post(`${"/run_action" /* RUN_ACTION_PATH */}`, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+};
+var action_service_default = ActionService;
+
+// src/services/auth-service/index.ts
+var AuthService = {
+  async login(body) {
+    const env2 = getEnv();
+    const payload = Object.fromEntries(
+      Object.entries({
+        username: body.email,
+        password: body.password,
+        grant_type: env2?.config?.grantType || "",
+        client_id: env2?.config?.clientId || "",
+        client_secret: env2?.config?.clientSecret || ""
+      }).filter(([_, value]) => !!value)
+    );
+    const encodedData = new URLSearchParams(payload).toString();
+    return env2?.requests?.post(body.path, encodedData, {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+  },
+  async forgotPassword(email) {
+    const env2 = getEnv();
+    const bodyData = {
+      login: email,
+      url: `${window.location.origin}/reset-password`
+    };
+    return env2?.requests?.post("/reset_password" /* RESET_PASSWORD_PATH */, bodyData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async forgotPasswordSSO({
+    email,
+    with_context,
+    method
+  }) {
+    const env2 = getEnv();
+    const body = {
+      method,
+      kwargs: {
+        vals: {
+          email
+        }
+      },
+      with_context
+    };
+    return env2?.requests?.post("/call" /* CALL_PATH */, body, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async resetPassword(data, token) {
+    const env2 = getEnv();
+    const bodyData = {
+      token,
+      password: data.password,
+      new_password: data.confirmPassword
+    };
+    return env2?.requests?.post("/change_password" /* CHANGE_PASSWORD_PATH */, bodyData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async resetPasswordSSO({
+    method,
+    password,
+    with_context
+  }) {
+    const env2 = getEnv();
+    const bodyData = {
+      method,
+      kwargs: {
+        vals: {
+          password
+        }
+      },
+      with_context
+    };
+    return env2?.requests?.post("/call" /* CALL_PATH */, bodyData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async updatePassword(data, token) {
+    const env2 = getEnv();
+    const bodyData = {
+      token,
+      old_password: data.oldPassword,
+      new_password: data.newPassword
+    };
+    return env2?.requests?.post("/change_password_parent" /* UPDATE_PASSWORD_PATH */, bodyData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async isValidToken(token) {
+    const env2 = getEnv();
+    const bodyData = {
+      token
+    };
+    return env2?.requests?.post("/check_token" /* TOKEN */, bodyData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async isValidActionToken(actionToken, path) {
+    const env2 = getEnv();
+    return env2?.requests?.post(
+      path,
+      {},
+      {
+        headers: {
+          "Content-Type": "application/json"
         },
-        with_context
-      };
-      return env?.requests?.post("/call" /* CALL_PATH */, body, {
+        useActionToken: true,
+        actionToken
+      }
+    );
+  },
+  async loginSocial({
+    db,
+    state,
+    access_token
+  }) {
+    const env2 = getEnv();
+    return env2?.requests?.post(
+      "/token/generate" /* GENTOKEN_SOCIAL */,
+      { state, access_token },
+      {
         headers: {
           "Content-Type": "application/json"
         }
-      });
-    },
-    [env]
-  );
-  const resetPassword = useCallback2(
-    async (data, token) => {
-      const bodyData = {
-        token,
-        password: data.password,
-        new_password: data.confirmPassword
+      }
+    );
+  },
+  async getProviders(db) {
+    const env2 = getEnv();
+    return env2?.requests?.get("/oauth/providers", { params: { db } });
+  },
+  async getAccessByCode(code) {
+    const env2 = getEnv();
+    const data = new URLSearchParams();
+    data.append("code", code);
+    data.append("grant_type", "authorization_code");
+    data.append("client_id", env2?.config?.clientId || "");
+    data.append("redirect_uri", env2?.config?.redirectUri || "");
+    return env2?.requests?.post(
+      `${env2?.baseUrl?.replace("/mms/", "/id/")}/${"/token" /* TOKEN_BY_CODE */}`,
+      data,
+      {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      }
+    );
+  },
+  async logout(data) {
+    const env2 = getEnv();
+    console.log(data);
+    return env2?.requests?.post(
+      "/logout" /* LOGOUT */,
+      {},
+      {
+        headers: {
+          "Content-Type": "application/json"
+        },
+        withCredentials: true,
+        useRefreshToken: true
+      }
+    );
+  }
+};
+var auth_service_default = AuthService;
+
+// src/services/company-service/index.ts
+var CompanyService = {
+  async getCurrentCompany() {
+    const env2 = getEnv();
+    return await env2.requests.get("/company" /* COMPANY_PATH */, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getInfoCompany(id) {
+    const env2 = getEnv();
+    const jsonData = {
+      ids: [id],
+      model: "res.company" /* COMPANY */,
+      method: "web_read" /* WEB_READ */,
+      kwargs: {
+        specification: {
+          primary_color: {},
+          secondary_color: {},
+          logo: {},
+          display_name: {},
+          secondary_logo: {}
+        }
+      }
+    };
+    return await env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+};
+var company_service_default = CompanyService;
+
+// src/services/excel-service/index.ts
+var ExcelService = {
+  async uploadFile({ formData }) {
+    const env2 = getEnv();
+    return env2.requests.post(`${"/upload/file" /* UPLOAD_FILE_PATH */}`, formData, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+  },
+  async uploadIdFile({ formData }) {
+    const env2 = getEnv();
+    return env2.requests.post(`${"/upload/file" /* UPLOAD_FILE_PATH */}`, formData, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+  },
+  async parsePreview({
+    id,
+    selectedSheet,
+    isHeader,
+    context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model: "base_import.import" /* BASE_IMPORT */,
+      method: "parse_preview",
+      ids: [id],
+      kwargs: {
+        options: {
+          import_skip_records: [],
+          import_set_empty_fields: [],
+          fallback_values: {},
+          name_create_enabled_fields: {},
+          encoding: "",
+          separator: "",
+          quoting: '"',
+          date_format: "",
+          datetime_format: "",
+          float_thousand_separator: ",",
+          float_decimal_separator: ".",
+          advanced: true,
+          has_headers: isHeader,
+          keep_matches: false,
+          limit: 2e3,
+          sheets: [],
+          sheet: selectedSheet,
+          skip: 0,
+          tracking_disable: true
+        }
+      },
+      with_context: context
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+  },
+  async executeImport({
+    columns,
+    fields,
+    idFile,
+    options,
+    dryrun,
+    context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model: "base_import.import" /* BASE_IMPORT */,
+      method: "execute_import",
+      ids: [idFile],
+      kwargs: {
+        fields,
+        columns,
+        options,
+        dryrun
+      },
+      with_context: context
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+  },
+  async getFileExcel({ model }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "get_import_templates" /* GET_IMPORT */,
+      args: []
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonData);
+  },
+  async getFieldExport({
+    ids,
+    model,
+    isShow,
+    parentField,
+    fieldType,
+    parentName,
+    prefix,
+    name,
+    context,
+    importCompat
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      import_compat: importCompat,
+      domain: [["id", "in", ids]],
+      with_context: context
+    };
+    if (isShow) {
+      jsonData.parent_field = parentField;
+      jsonData.parent_field_type = fieldType;
+      jsonData.parent_name = parentName;
+      jsonData.name = name;
+      jsonData.prefix = prefix;
+      jsonData.exclude = [null];
+    }
+    return env2.requests.post("/export/get_fields", jsonData);
+  },
+  async exportExcel({
+    model,
+    domain,
+    ids,
+    fields,
+    type,
+    importCompat,
+    context,
+    groupby
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      domain,
+      ids,
+      import_compat: importCompat,
+      fields,
+      with_context: context,
+      groupby: groupby ?? []
+    };
+    return env2.requests.post_excel(`/export/${type}`, jsonData);
+  }
+};
+var excel_service_default = ExcelService;
+
+// src/services/form-service/index.ts
+var FormService = {
+  async getComment({ data }) {
+    try {
+      const env2 = getEnv();
+      const jsonData = {
+        thread_id: data.thread_id,
+        thread_model: data.thread_model,
+        limit: 100,
+        with_context: {
+          lang: data.lang
+        }
       };
-      return env?.requests?.post("/change_password" /* CHANGE_PASSWORD_PATH */, bodyData, {
+      return env2.requests.post("/chatter/thread/messages" /* GET_MESSAGE */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
-    },
-    [env]
-  );
-  const resetPasswordSSO = useCallback2(
-    async ({
-      method,
-      password,
-      with_context
-    }) => {
-      const bodyData = {
-        method,
-        kwargs: {
-          vals: {
-            password
-          }
+    } catch (error) {
+      console.error("Error when sending message:", error);
+      throw error;
+    }
+  },
+  async sentComment({ data }) {
+    try {
+      const env2 = getEnv();
+      const jsonData = {
+        context: {
+          tz: "Asia/Saigon",
+          uid: 2,
+          allowed_company_ids: [1],
+          mail_post_autofollow: false,
+          temporary_id: 142183.01
         },
-        with_context
+        post_data: {
+          body: data.message,
+          message_type: "comment",
+          attachment_ids: data.attachment_ids,
+          attachment_tokens: [],
+          subtype_xmlid: data.subtype
+        },
+        thread_id: Number(data.thread_id),
+        thread_model: data.thread_model
       };
-      return env?.requests?.post("/call" /* CALL_PATH */, bodyData, {
+      return env2.requests.post("/chatter/message/post" /* SENT_MESSAGE */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (error) {
+      console.error("Error when sent message:", error);
+      throw error;
+    }
+  },
+  async deleteComment({ data }) {
+    try {
+      const env2 = getEnv();
+      const jsonData = {
+        attachment_ids: [],
+        attachment_tokens: [],
+        body: "",
+        message_id: data.message_id
+      };
+      return env2.requests.post("/chatter/message/update_content" /* DELETE_MESSAGE */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (error) {
+      console.error("Error when sent message:", error);
+      throw error;
+    }
+  },
+  async getImage({ data }) {
+    try {
+      const env2 = getEnv();
+      return env2.requests.get(
+        `${"/web/image" /* IMAGE_PATH */}?filename=${data.filename}&unique=${data.checksum}&width=1920&height=300`,
+        {
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+    } catch (error) {
+      console.error("Error when sent message:", error);
+      throw error;
+    }
+  },
+  async uploadImage({ data }) {
+    try {
+      const env2 = getEnv();
+      return env2.requests.post("/mail/attachment/upload" /* UPLOAD_IMAGE */, data, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+    } catch (error) {
+      console.error("Error when sent message:", error);
+      throw error;
+    }
+  },
+  async getFormView({ data }) {
+    try {
+      const env2 = getEnv();
+      const jsonData = {
+        model: data.model,
+        method: "get_formview_action",
+        ids: data.id ? [data.id] : [],
+        with_context: data.context
+      };
+      return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (error) {
+      console.error("Error when fetching form view:", error);
+      throw error;
+    }
+  },
+  async changeStatus({ data }) {
+    const env2 = getEnv();
+    const vals = {
+      [data.name]: data.stage_id
+    };
+    const jsonData = {
+      model: data.model,
+      method: "web_save",
+      with_context: {
+        lang: data.lang,
+        allowed_company_ids: [1],
+        uid: 2,
+        search_default_my_ticket: true,
+        search_default_is_open: true
+      },
+      ids: [data.id],
+      kwargs: {
+        vals,
+        specification: {}
+      }
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+};
+var form_service_default = FormService;
+
+// src/services/kanban-service/index.ts
+var KanbanServices = {
+  async getGroups({
+    model,
+    width_context
+  }) {
+    const env2 = getEnv();
+    const jsonDataView = {
+      model,
+      method: "web_read_group",
+      kwargs: {
+        domain: [["stage_id.fold", "=", false]],
+        fields: ["color:sum"],
+        groupby: ["stage_id"]
+      },
+      width_context
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonDataView, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getProgressBar({
+    field,
+    color,
+    model,
+    width_context
+  }) {
+    const env2 = getEnv();
+    const jsonDataView = {
+      model,
+      method: "read_progress_bar",
+      kwargs: {
+        domain: [],
+        group_by: "stage_id",
+        progress_bar: {
+          colors: color,
+          field
+        }
+      },
+      width_context
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonDataView, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+};
+var kanban_service_default = KanbanServices;
+
+// src/services/model-service/index.ts
+var OBJECT_POSITION = 2;
+var ModelService = {
+  async getListMyBankAccount({
+    domain,
+    spectification,
+    model
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "web_search_read",
+      kwargs: {
+        specification: spectification,
+        domain,
+        limit: 100,
+        offset: 0
+      }
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getCurrency() {
+    const env2 = getEnv();
+    const jsonData = {
+      model: "res.currency",
+      method: "web_search_read",
+      kwargs: {
+        specification: {
+          icon_url: {},
+          name: {}
+        },
+        domain: [["active", "=", true]],
+        limit: 100,
+        offset: 0
+      }
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getConversionRate() {
+    const env2 = getEnv();
+    const jsonData = {
+      model: "res.currency",
+      method: "web_search_read",
+      kwargs: {
+        specification: {
+          name: {},
+          icon_url: {},
+          rate_ids: {
+            fields: {
+              company_rate: {},
+              sell: {}
+            }
+          }
+        },
+        domain: [["active", "=", true]],
+        limit: 100,
+        offset: 0
+      }
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getAll({ data }) {
+    const env2 = getEnv();
+    const jsonReadGroup = data.type == "calendar" ? { fields: data?.fields } : data.fields && data.fields.length > 0 && data.groupby && data.groupby.length > 0 && data.groupby[0] ? {
+      fields: data.fields,
+      groupby: data.groupby
+    } : {
+      count_limit: 10001,
+      order: data.sort,
+      specification: data.specification
+    };
+    const jsonData = {
+      model: String(data.model),
+      method: data.type == "calendar" ? "search_read" : jsonReadGroup.fields && jsonReadGroup.groupby ? "web_read_group" : "web_search_read",
+      ids: data.ids,
+      with_context: data.context,
+      kwargs: {
+        domain: data.domain,
+        limit: data.limit,
+        offset: data.offset,
+        ...jsonReadGroup
+      }
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getListCalendar({ data }) {
+    const env2 = getEnv();
+    const jsonReadGroup = data.type == "calendar" ? data?.fields : data.fields && data.fields.length > 0 && data.groupby && data.groupby.length > 0 && data.groupby[0] ? {
+      fields: data.fields,
+      groupby: data.groupby
+    } : {
+      count_limit: 10001,
+      order: data.sort,
+      specification: data.specification
+    };
+    const jsonData = {
+      model: String(data.model),
+      method: data.type == "calendar" ? "search_read" : jsonReadGroup.fields && jsonReadGroup.groupby ? "web_read_group" : "web_search_read",
+      ids: data.ids,
+      with_context: data.context,
+      kwargs: {
+        domain: data.domain,
+        limit: data.limit,
+        offset: data.offset,
+        fields: data.fields,
+        ...jsonReadGroup
+      }
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getList({
+    model,
+    ids = [],
+    specification = {},
+    domain = [],
+    offset,
+    order,
+    context = {},
+    limit = 10
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "web_search_read" /* WEB_SEARCH_READ */,
+      ids,
+      with_context: context,
+      kwargs: {
+        specification,
+        domain,
+        limit,
+        offset,
+        order
+      }
+    };
+    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getDetail({
+    ids = [],
+    model,
+    specification,
+    context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "web_read" /* WEB_READ */,
+      ids,
+      with_context: context,
+      kwargs: {
+        specification
+      }
+    };
+    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async save({
+    model,
+    ids = [],
+    data = {},
+    specification = {},
+    context = {},
+    path
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "web_save" /* WEB_SAVE */,
+      with_context: context,
+      ids,
+      kwargs: {
+        vals: data,
+        specification
+      }
+    };
+    return env2?.requests?.post(path ?? "/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async delete({ ids = [], model }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "unlink" /* UNLINK */,
+      ids
+    };
+    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async onChange({
+    ids = [],
+    model,
+    object,
+    specification,
+    context,
+    fieldChange
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "onchange" /* ONCHANGE */,
+      ids,
+      with_context: context,
+      args: [
+        object ? object : {},
+        fieldChange ? fieldChange : [],
+        specification
+      ]
+    };
+    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getListFieldsOnchange({ model }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "get_fields_onchange" /* GET_ONCHANGE_FIELDS */
+    };
+    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  parseORMOdoo(data) {
+    for (const key in data) {
+      if (key === "display_name") {
+        delete data[key];
+      }
+      if (!data[key] && data[key] !== 0) {
+        data[key] = false;
+      } else if (data[key] === "Draft") {
+        data[key] = "/";
+      }
+    }
+    return { ...data };
+  },
+  toDataJS(data, viewData, model) {
+    for (const key in data) {
+      if (data[key] === false) {
+        if (viewData && model) {
+          if (viewData?.models?.[model]?.[key]?.type !== "boolean" /* BOOLEAN */) {
+            data[key] = null;
+          }
+        } else {
+          data[key] = null;
+        }
+      } else if (data[key] === "/") {
+        data[key] = "Draft";
+      } else if (data[key] !== false) {
+        if (model !== void 0) {
+          if (viewData?.models?.[model]?.[key]?.type === "one2many" /* ONE2MANY */ || viewData?.models?.[model]?.[key]?.type === "many2many" /* MANY2MANY */) {
+            data[key] = (data[key] ??= [])?.map((item) => {
+              const relation = viewData?.models?.[model]?.[key]?.relation;
+              if (relation !== void 0) {
+                if (viewData?.models?.[relation]) {
+                  if (item?.length >= 3) {
+                    return ModelService.toDataJS(
+                      item[OBJECT_POSITION],
+                      viewData,
+                      relation
+                    );
+                  } else {
+                    return ModelService.toDataJS(item, viewData, relation);
+                  }
+                } else {
+                  if (item?.length >= 3) {
+                    return item[OBJECT_POSITION];
+                  } else {
+                    return item;
+                  }
+                }
+              }
+            });
+          }
+        }
+      }
+    }
+    return { ...data };
+  }
+};
+var model_service_default = ModelService;
+
+// src/services/user-service/index.ts
+var UserService = {
+  async getProfile(path) {
+    const env2 = getEnv();
+    return env2?.requests?.get(path ?? "/userinfo" /* PROFILE_PATH */, {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+  },
+  async getUser({ context, id }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model: "res.users",
+      method: "web_read",
+      ids: [id],
+      with_context: context,
+      kwargs: {
+        specification: {
+          display_name: {},
+          image_1920: {},
+          name: {},
+          login: {},
+          email: {},
+          password: {},
+          visible_group_id: {
+            fields: {
+              id: {},
+              display_name: {}
+            }
+          },
+          company_id: {
+            fields: {
+              id: {},
+              display_name: {}
+            }
+          }
+        }
+      }
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  switchUserLocale: async ({ id, values }) => {
+    const env2 = getEnv();
+    const jsonData = {
+      model: "res.users",
+      domain: [["id", "=", id]],
+      values
+    };
+    return env2?.requests.post(UriConstants?.CREATE_UPDATE_PATH, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+};
+var user_service_default = UserService;
+
+// src/services/view-service/index.ts
+var ViewService = {
+  async getView({
+    model,
+    views,
+    context = {},
+    options = {},
+    aid
+  }) {
+    const env2 = getEnv();
+    const defaultOptions = {
+      load_filters: true,
+      toolbar: true,
+      action_id: aid
+    };
+    const jsonDataView = {
+      model,
+      method: "get_fields_view_v2" /* GET_FIELD_VIEW */,
+      kwargs: {
+        views,
+        options: { ...options, ...defaultOptions }
+      },
+      with_context: context
+    };
+    return env2?.requests?.post("/call" /* CALL_PATH */, jsonDataView, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getMenu(context) {
+    const env2 = getEnv();
+    const jsonData = {
+      model: "ir.ui.menu" /* MENU */,
+      method: "web_search_read" /* WEB_SEARCH_READ */,
+      ids: [],
+      with_context: context,
+      kwargs: {
+        specification: {
+          active: {},
+          name: {},
+          is_display: {},
+          sequence: {},
+          complete_name: {},
+          action: {
+            fields: {
+              display_name: {},
+              type: {},
+              binding_view_types: {}
+              // res_model: {},
+            }
+          },
+          url_icon: {},
+          web_icon: {},
+          web_icon_data: {},
+          groups_id: {
+            fields: {
+              full_name: {}
+            },
+            limit: 40,
+            order: ""
+          },
+          display_name: {},
+          child_id: {
+            fields: {
+              active: {},
+              name: {},
+              is_display: {},
+              sequence: {},
+              complete_name: {},
+              action: {
+                fields: {
+                  display_name: {},
+                  type: {},
+                  binding_view_types: {}
+                  // res_model: {},
+                }
+              },
+              url_icon: {},
+              web_icon: {},
+              web_icon_data: {},
+              groups_id: {
+                fields: {
+                  full_name: {}
+                },
+                limit: 40,
+                order: ""
+              },
+              display_name: {},
+              child_id: {
+                fields: {
+                  active: {},
+                  name: {},
+                  is_display: {},
+                  sequence: {},
+                  complete_name: {},
+                  action: {
+                    fields: {
+                      display_name: {},
+                      type: {},
+                      binding_view_types: {}
+                      // res_model: {},
+                    }
+                  },
+                  url_icon: {},
+                  web_icon: {},
+                  web_icon_data: {},
+                  groups_id: {
+                    fields: {
+                      full_name: {}
+                    },
+                    limit: 40,
+                    order: ""
+                  },
+                  display_name: {},
+                  child_id: {
+                    fields: {
+                      active: {},
+                      name: {},
+                      is_display: {},
+                      sequence: {},
+                      complete_name: {},
+                      action: {
+                        fields: {
+                          display_name: {},
+                          type: {},
+                          binding_view_types: {}
+                          // res_model: {},
+                        }
+                      },
+                      url_icon: {},
+                      web_icon: {},
+                      web_icon_data: {},
+                      groups_id: {
+                        fields: {
+                          full_name: {}
+                        },
+                        limit: 40,
+                        order: ""
+                      },
+                      display_name: {},
+                      child_id: {
+                        fields: {},
+                        limit: 40,
+                        order: ""
+                      }
+                    },
+                    limit: 40,
+                    order: ""
+                  }
+                },
+                limit: 40,
+                order: ""
+              }
+            },
+            limit: 40,
+            order: ""
+          }
+        },
+        domain: [
+          "&",
+          ["is_display", "=", true],
+          "&",
+          ["active", "=", true],
+          ["parent_id", "=", false]
+        ]
+      }
+    };
+    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getActionDetail(aid, context) {
+    const env2 = getEnv();
+    const jsonData = {
+      model: "ir.actions.act_window" /* WINDOW_ACTION */,
+      method: "web_read" /* WEB_READ */,
+      ids: [aid],
+      with_context: context,
+      kwargs: {
+        specification: {
+          id: {},
+          name: {},
+          res_model: {},
+          views: {},
+          view_mode: {},
+          mobile_view_mode: {},
+          domain: {},
+          context: {},
+          groups_id: {},
+          search_view_id: {}
+        }
+      }
+    };
+    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getResequence({
+    model,
+    ids,
+    context,
+    offset
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      with_context: context,
+      ids,
+      field: "sequence",
+      ...offset > 0 ? { offset } : {}
+    };
+    return env2?.requests.post("/web/dataset/resequence", jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async getSelectionItem({ data }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model: data.model,
+      ids: [],
+      method: "get_data_select",
+      with_context: data.context,
+      kwargs: {
+        count_limit: 10001,
+        domain: data.domain ? data.domain : [],
+        offset: 0,
+        order: "",
+        specification: data?.specification ?? {
+          id: {},
+          name: {},
+          display_name: {}
+        }
+      }
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async loadMessages() {
+    const env2 = getEnv();
+    return env2.requests.post(
+      "/load_message_failures" /* LOAD_MESSAGE */,
+      {},
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+  },
+  async getVersion() {
+    const env2 = getEnv();
+    console.log("env?.requests", env2, env2?.requests);
+    return env2?.requests?.get("", {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async get2FAMethods({
+    method,
+    with_context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      method,
+      with_context
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async verify2FA({
+    method,
+    with_context,
+    code,
+    device,
+    location
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      method,
+      kwargs: {
+        vals: {
+          code,
+          device,
+          location
+        }
+      },
+      with_context
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      },
+      withCredentials: true
+    });
+  },
+  async signInSSO({
+    redirect_uri,
+    state,
+    client_id,
+    response_type,
+    path
+  }) {
+    const env2 = getEnv();
+    const params = new URLSearchParams({
+      response_type,
+      client_id,
+      redirect_uri,
+      state
+    });
+    const url = `${path}?${params.toString()}`;
+    return env2?.requests.get(url, {
+      headers: {
+        "Content-Type": "application/json"
+      },
+      withCredentials: true
+    });
+  },
+  async grantAccess({
+    redirect_uri,
+    state,
+    client_id,
+    scopes
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      redirect_uri,
+      state,
+      client_id,
+      scopes
+    };
+    return env2?.requests.post("/grant-access" /* GRANT_ACCESS */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      },
+      withCredentials: true
+    });
+  },
+  async getFieldsViewSecurity({
+    method,
+    token,
+    views
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      method,
+      kwargs: {
+        views
+      },
+      with_context: {
+        token
+      }
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async settingsWebRead2fa({
+    method,
+    model,
+    kwargs,
+    token
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      method,
+      model,
+      kwargs,
+      with_context: {
+        token
+      }
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async requestSetupTotp({ method, token }) {
+    const env2 = getEnv();
+    const jsonData = {
+      method,
+      with_context: {
+        token
+      }
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async verifyTotp({
+    method,
+    action_token,
+    code
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      method,
+      kwargs: {
+        vals: {
+          code
+        }
+      },
+      with_context: {
+        action_token
+      }
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async removeTotpSetUp({ method, token }) {
+    const env2 = getEnv();
+    const jsonData = {
+      method,
+      with_context: {
+        token
+      }
+    };
+    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+};
+var view_service_default = ViewService;
+
+// src/hooks/auth/use-forgot-password.ts
+var useForgotPassword = () => {
+  return useMutation({
+    mutationFn: (email) => {
+      return auth_service_default.forgotPassword(email);
+    }
+  });
+};
+var use_forgot_password_default = useForgotPassword;
+
+// src/hooks/auth/use-forgotpassword-sso.ts
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+var useForgotPasswordSSO = () => {
+  return useMutation2({
+    mutationFn: ({
+      email,
+      with_context,
+      method
+    }) => {
+      return auth_service_default.forgotPasswordSSO({ email, with_context, method });
+    }
+  });
+};
+var use_forgotpassword_sso_default = useForgotPasswordSSO;
+
+// src/hooks/auth/use-get-provider.ts
+import { useMutation as useMutation3 } from "@tanstack/react-query";
+var useGetProvider = () => {
+  return useMutation3({
+    mutationFn: (data) => {
+      return auth_service_default.getProviders(data?.db);
+    }
+  });
+};
+var use_get_provider_default = useGetProvider;
+
+// src/hooks/auth/use-isvalid-token.ts
+import { useMutation as useMutation4 } from "@tanstack/react-query";
+var useIsValidToken = () => {
+  return useMutation4({
+    mutationFn: (token) => {
+      return auth_service_default.isValidToken(token);
+    }
+  });
+};
+var use_isvalid_token_default = useIsValidToken;
+
+// src/hooks/auth/use-login-credential.tsx
+import { useMutation as useMutation5 } from "@tanstack/react-query";
+
+// src/services/auth-service/backup.ts
+import { useCallback as useCallback2 } from "react";
+function useAuthService() {
+  const { env: env2 } = useEnv();
+  const login = useCallback2(
+    async (body) => {
+      const payload = Object.fromEntries(
+        Object.entries({
+          username: body.email,
+          password: body.password,
+          grant_type: env2?.config?.grantType || "",
+          client_id: env2?.config?.clientId || "",
+          client_secret: env2?.config?.clientSecret || ""
+        }).filter(([_, value]) => !!value)
+      );
+      const encodedData = new URLSearchParams(payload).toString();
+      return env2?.requests?.post(body.path, encodedData, {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      });
+    },
+    [env2]
+  );
+  const forgotPassword = useCallback2(
+    async (email) => {
+      const bodyData = {
+        login: email,
+        url: `${window.location.origin}/reset-password`
+      };
+      return env2?.requests?.post("/reset_password" /* RESET_PASSWORD_PATH */, bodyData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env2]
+  );
+  const forgotPasswordSSO = useCallback2(
+    async ({
+      email,
+      with_context,
+      method
+    }) => {
+      const body = {
+        method,
+        kwargs: {
+          vals: {
+            email
+          }
+        },
+        with_context
+      };
+      return env2?.requests?.post("/call" /* CALL_PATH */, body, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env2]
+  );
+  const resetPassword = useCallback2(
+    async (data, token) => {
+      const bodyData = {
+        token,
+        password: data.password,
+        new_password: data.confirmPassword
+      };
+      return env2?.requests?.post("/change_password" /* CHANGE_PASSWORD_PATH */, bodyData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env2]
+  );
+  const resetPasswordSSO = useCallback2(
+    async ({
+      method,
+      password,
+      with_context
+    }) => {
+      const bodyData = {
+        method,
+        kwargs: {
+          vals: {
+            password
+          }
+        },
+        with_context
+      };
+      return env2?.requests?.post("/call" /* CALL_PATH */, bodyData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env]
+    [env2]
   );
   const updatePassword = useCallback2(
     async (data, token) => {
@@ -3367,30 +5132,30 @@ function useAuthService() {
         old_password: data.oldPassword,
         new_password: data.newPassword
       };
-      return env?.requests?.post("/change_password_parent" /* UPDATE_PASSWORD_PATH */, bodyData, {
+      return env2?.requests?.post("/change_password_parent" /* UPDATE_PASSWORD_PATH */, bodyData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env]
+    [env2]
   );
   const isValidToken = useCallback2(
     async (token) => {
       const bodyData = {
         token
       };
-      return env?.requests?.post("/check_token" /* TOKEN */, bodyData, {
+      return env2?.requests?.post("/check_token" /* TOKEN */, bodyData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env]
+    [env2]
   );
   const isValidActionToken = useCallback2(
     async (actionToken, path) => {
-      return env?.requests?.post(
+      return env2?.requests?.post(
         path,
         {},
         {
@@ -3402,7 +5167,7 @@ function useAuthService() {
         }
       );
     },
-    [env]
+    [env2]
   );
   const loginSocial = useCallback2(
     async ({
@@ -3410,7 +5175,7 @@ function useAuthService() {
       state,
       access_token
     }) => {
-      return env?.requests?.post(
+      return env2?.requests?.post(
         "/token/generate" /* GENTOKEN_SOCIAL */,
         { state, access_token },
         {
@@ -3420,23 +5185,23 @@ function useAuthService() {
         }
       );
     },
-    [env]
+    [env2]
   );
   const getProviders = useCallback2(
     async (db) => {
-      return env?.requests?.get("/oauth/providers", { params: { db } });
+      return env2?.requests?.get("/oauth/providers", { params: { db } });
     },
-    [env]
+    [env2]
   );
   const getAccessByCode = useCallback2(
     async (code) => {
       const data = new URLSearchParams();
       data.append("code", code);
       data.append("grant_type", "authorization_code");
-      data.append("client_id", env?.config?.clientId || "");
-      data.append("redirect_uri", env?.config?.redirectUri || "");
-      return env?.requests?.post(
-        `${env?.baseUrl?.replace("/mms/", "/id/")}/${"/token" /* TOKEN_BY_CODE */}`,
+      data.append("client_id", env2?.config?.clientId || "");
+      data.append("redirect_uri", env2?.config?.redirectUri || "");
+      return env2?.requests?.post(
+        `${env2?.baseUrl?.replace("/mms/", "/id/")}/${"/token" /* TOKEN_BY_CODE */}`,
         data,
         {
           headers: {
@@ -3445,12 +5210,12 @@ function useAuthService() {
         }
       );
     },
-    [env]
+    [env2]
   );
   const logout = useCallback2(
     async (data) => {
       console.log(data);
-      return env?.requests?.post(
+      return env2?.requests?.post(
         "/logout" /* LOGOUT */,
         {},
         {
@@ -3462,7 +5227,7 @@ function useAuthService() {
         }
       );
     },
-    [env]
+    [env2]
   );
   return {
     login,
@@ -3510,7 +5275,7 @@ function EnvProvider({
   localStorageUtils: localStorageUtil = localStorageUtils(),
   sessionStorageUtils: sessionStorageUtil = sessionStorageUtils()
 }) {
-  const [env, setEnvState] = useState2({
+  const [env2, setEnvState] = useState2({
     ...initialEnvState,
     localStorageUtils: localStorageUtil,
     sessionStorageUtils: sessionStorageUtil
@@ -3518,7 +5283,7 @@ function EnvProvider({
   const setupEnv = useCallback3(
     (envConfig) => {
       const updatedEnv = {
-        ...env,
+        ...env2,
         ...envConfig,
         localStorageUtils: localStorageUtil,
         sessionStorageUtils: sessionStorageUtil
@@ -3527,7 +5292,7 @@ function EnvProvider({
       setEnvState({ ...updatedEnv, requests });
       return updatedEnv;
     },
-    [env, localStorageUtil, sessionStorageUtil]
+    [env2, localStorageUtil, sessionStorageUtil]
   );
   const setUid2 = useCallback3((uid) => {
     setEnvState((prev) => ({
@@ -3584,7 +5349,7 @@ function EnvProvider({
     EnvContext.Provider,
     {
       value: {
-        env,
+        env: env2,
         setupEnv,
         setUid: setUid2,
         setLang: setLang2,
@@ -3609,8 +5374,8 @@ function useEnv() {
 
 // src/hooks/auth/use-login-credential.tsx
 var useLoginCredential = () => {
-  const { env } = useEnv();
-  console.log("useLoginCredential called", env, new Error().stack);
+  const { env: env2 } = useEnv();
+  console.log("useLoginCredential called", env2, new Error().stack);
   const { login } = useAuthService();
   return useMutation5({
     mutationFn: (data) => {
@@ -3622,189 +5387,1173 @@ var use_login_credential_default = useLoginCredential;
 
 // src/hooks/auth/use-login-socical.ts
 import { useMutation as useMutation6 } from "@tanstack/react-query";
+var useLoginSocial = () => {
+  return useMutation6({
+    mutationFn: (data) => {
+      return auth_service_default.loginSocial(data);
+    }
+  });
+};
+var use_login_socical_default = useLoginSocial;
 
 // src/hooks/auth/use-reset-password.ts
 import { useMutation as useMutation7 } from "@tanstack/react-query";
+var useResetPassword = () => {
+  return useMutation7({
+    mutationFn: (request) => {
+      return auth_service_default.resetPassword(request.data, request.token);
+    }
+  });
+};
+var use_reset_password_default = useResetPassword;
 
 // src/hooks/auth/use-reset-password-sso.ts
 import { useMutation as useMutation8 } from "@tanstack/react-query";
+var useResetPasswordSSO = () => {
+  return useMutation8({
+    mutationFn: ({
+      method,
+      password,
+      with_context
+    }) => {
+      return auth_service_default.resetPasswordSSO({
+        method,
+        password,
+        with_context
+      });
+    }
+  });
+};
+var use_reset_password_sso_default = useResetPasswordSSO;
 
 // src/hooks/auth/use-update-password.ts
 import { useMutation as useMutation9 } from "@tanstack/react-query";
+var useUpdatePassword = () => {
+  return useMutation9({
+    mutationFn: (request) => {
+      return auth_service_default.updatePassword(request.data, request.token);
+    }
+  });
+};
+var use_update_password_default = useUpdatePassword;
 
 // src/hooks/auth/use-logout.ts
 import { useMutation as useMutation10 } from "@tanstack/react-query";
+var useLogout = () => {
+  return useMutation10({
+    mutationFn: (data) => {
+      return auth_service_default.logout(data);
+    }
+  });
+};
+var use_logout_default = useLogout;
 
 // src/hooks/auth/use-get-access-by-code.ts
 import { useMutation as useMutation11 } from "@tanstack/react-query";
+var useGetAccessByCode = () => {
+  return useMutation11({
+    mutationFn: ({ code }) => {
+      return auth_service_default.getAccessByCode(code);
+    }
+  });
+};
+var use_get_access_by_code_default = useGetAccessByCode;
 
 // src/hooks/auth/use-validate-action-token.ts
 import { useMutation as useMutation12 } from "@tanstack/react-query";
+var useValidateActionToken = () => {
+  return useMutation12({
+    mutationFn: ({
+      actionToken,
+      path
+    }) => {
+      return auth_service_default.isValidActionToken(actionToken, path);
+    }
+  });
+};
+var use_validate_action_token_default = useValidateActionToken;
 
 // src/hooks/company/use-get-company-info.ts
 import { useMutation as useMutation13 } from "@tanstack/react-query";
+var useGetCompanyInfo = () => {
+  return useMutation13({
+    mutationFn: (id) => company_service_default.getInfoCompany(id)
+  });
+};
+var use_get_company_info_default = useGetCompanyInfo;
 
 // src/hooks/company/use-get-current-company.ts
 import { useMutation as useMutation14 } from "@tanstack/react-query";
+var useGetCurrentCompany = () => {
+  return useMutation14({
+    mutationFn: () => company_service_default.getCurrentCompany()
+  });
+};
+var use_get_current_company_default = useGetCurrentCompany;
 
 // src/hooks/company/use-get-list-company.ts
 import { useQuery } from "@tanstack/react-query";
+var useGetListCompany = (companyIDs = []) => {
+  const companySpec = {
+    id: {},
+    name: {}
+  };
+  const getListParams = {
+    model: "res.company" /* COMPANY */,
+    ids: companyIDs,
+    specification: companySpec
+  };
+  return useQuery({
+    queryKey: ["list_company" /* LIST_COMPANY */, companyIDs],
+    queryFn: () => model_service_default.getList(getListParams),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_list_company_default = useGetListCompany;
 
 // src/hooks/excel/use-export-excel.ts
 import { useMutation as useMutation15 } from "@tanstack/react-query";
+var useExportExcel = () => {
+  return useMutation15({
+    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;
 
 // src/hooks/excel/use-get-field-export.ts
 import { useMutation as useMutation16 } from "@tanstack/react-query";
+var useGetFieldExport = () => {
+  return useMutation16({
+    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;
 
 // src/hooks/excel/use-get-file-excel.ts
 import { useQuery as useQuery2 } from "@tanstack/react-query";
+var useGetFileExcel = ({ model }) => {
+  return useQuery2({
+    queryKey: [],
+    queryFn: () => excel_service_default.getFileExcel({
+      model
+    }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_file_excel_default = useGetFileExcel;
 
 // src/hooks/excel/use-parse-preview.ts
 import { useMutation as useMutation17 } from "@tanstack/react-query";
+var useParsePreview = () => {
+  return useMutation17({
+    mutationFn: ({
+      id,
+      selectedSheet,
+      isHeader,
+      context
+    }) => excel_service_default.parsePreview({
+      id,
+      selectedSheet,
+      isHeader,
+      context
+    })
+  });
+};
+var use_parse_preview_default = useParsePreview;
 
 // src/hooks/excel/use-upload-file.ts
 import { useMutation as useMutation18 } from "@tanstack/react-query";
+var useUploadFile = () => {
+  return useMutation18({
+    mutationFn: ({ formData }) => excel_service_default.uploadFile({
+      formData
+    })
+  });
+};
+var use_upload_file_default = useUploadFile;
 
 // src/hooks/excel/use-upload-id-file.ts
 import { useMutation as useMutation19 } from "@tanstack/react-query";
+var useUploadIdFile = () => {
+  return useMutation19({
+    mutationFn: ({ formData }) => excel_service_default.uploadIdFile({
+      formData
+    })
+  });
+};
+var use_upload_id_file_default = useUploadIdFile;
 
 // src/hooks/excel/uss-execute-import.ts
 import { useMutation as useMutation20 } from "@tanstack/react-query";
+var useExecuteImport = () => {
+  return useMutation20({
+    mutationFn: ({
+      fields,
+      columns,
+      idFile,
+      options,
+      dryrun,
+      context
+    }) => excel_service_default.executeImport({
+      fields,
+      columns,
+      idFile,
+      options,
+      dryrun,
+      context
+    })
+  });
+};
+var uss_execute_import_default = useExecuteImport;
 
 // src/hooks/form/use-change-status.ts
 import { useMutation as useMutation21 } from "@tanstack/react-query";
+var useChangeStatus = () => {
+  return useMutation21({
+    mutationFn: ({ data }) => {
+      return form_service_default.changeStatus({
+        data
+      });
+    }
+  });
+};
+var use_change_status_default = useChangeStatus;
 
 // src/hooks/form/use-delete-comment.ts
 import { useMutation as useMutation22 } from "@tanstack/react-query";
+var useDeleteComment = () => {
+  return useMutation22({
+    mutationFn: ({ data }) => form_service_default.deleteComment({
+      data
+    })
+  });
+};
+var use_delete_comment_default = useDeleteComment;
 
 // src/hooks/form/use-get-comment.ts
 import { useQuery as useQuery3 } from "@tanstack/react-query";
+var useGetComment = ({ data, queryKey }) => {
+  return useQuery3({
+    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;
 
 // src/hooks/form/use-get-form-view.ts
 import { useQuery as useQuery4 } from "@tanstack/react-query";
+var useGetFormView = ({
+  data,
+  queryKey,
+  enabled
+}) => {
+  return useQuery4({
+    queryKey,
+    queryFn: () => form_service_default.getFormView({ data }).then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    enabled,
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_form_view_default = useGetFormView;
 
 // src/hooks/form/use-get-image.ts
 import { useQuery as useQuery5 } from "@tanstack/react-query";
+var useGetImage = ({
+  data,
+  queryKey,
+  src
+}) => {
+  return useQuery5({
+    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;
 
 // src/hooks/form/use-send-comment.ts
 import { useMutation as useMutation23 } from "@tanstack/react-query";
+var useSendComment = () => {
+  return useMutation23({
+    mutationFn: ({ data }) => form_service_default.sentComment({
+      data
+    })
+  });
+};
+var use_send_comment_default = useSendComment;
 
 // src/hooks/form/use-upload-image.ts
 import { useMutation as useMutation24 } from "@tanstack/react-query";
+var useUploadImage = () => {
+  return useMutation24({
+    mutationFn: ({ data }) => form_service_default.uploadImage({
+      data
+    })
+  });
+};
+var use_upload_image_default = useUploadImage;
 
 // src/hooks/model/use-delete.ts
 import { useMutation as useMutation25 } from "@tanstack/react-query";
+var useDelete = () => {
+  return useMutation25({
+    mutationFn: ({ ids, model }) => model_service_default.delete({ ids, model })
+  });
+};
+var use_delete_default = useDelete;
 
 // src/hooks/model/use-get-all.ts
 import { useQuery as useQuery6 } from "@tanstack/react-query";
+var useGetAll = ({ data, queryKey, viewResponse }) => {
+  return useQuery6({
+    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;
 
 // src/hooks/model/use-get-conversion-rate.ts
 import { useQuery as useQuery7 } from "@tanstack/react-query";
+var useGetConversionRate = () => {
+  return useQuery7({
+    queryKey: ["currency-rate"],
+    queryFn: () => model_service_default.getConversionRate().then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    enabled: true
+  });
+};
+var use_get_conversion_rate_default = useGetConversionRate;
 
 // src/hooks/model/use-get-currency.ts
 import { useQuery as useQuery8 } from "@tanstack/react-query";
+var useGetCurrency = () => {
+  return useQuery8({
+    queryKey: ["currency"],
+    queryFn: () => model_service_default.getCurrency().then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    enabled: true
+  });
+};
+var use_get_currency_default = useGetCurrency;
 
 // src/hooks/model/use-get-detail.ts
 import { useMutation as useMutation26 } from "@tanstack/react-query";
+var useGetDetail = () => {
+  return useMutation26({
+    mutationFn: ({
+      model,
+      ids,
+      specification,
+      context
+    }) => model_service_default.getDetail({
+      model,
+      ids,
+      specification,
+      context
+    })
+  });
+};
+var use_get_detail_default = useGetDetail;
 
 // src/hooks/model/use-get-field-onchange.ts
 import { useQuery as useQuery9 } from "@tanstack/react-query";
+var useGetFieldOnChange = ({ model }) => {
+  return useQuery9({
+    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/hooks/model/use-get-list-my-bank-account.ts
 import { useQuery as useQuery10 } from "@tanstack/react-query";
+var useGetListMyBankAccount = ({
+  domain,
+  spectification,
+  model
+}) => {
+  return useQuery10({
+    queryKey: ["bank-account", model, domain],
+    queryFn: () => model_service_default.getListMyBankAccount({
+      domain,
+      spectification,
+      model
+    }).then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    enabled: true
+  });
+};
+var use_get_list_my_bank_account_default = useGetListMyBankAccount;
+
+// src/models/base-model/index.ts
+var BaseModel = class {
+  name;
+  view;
+  actContext;
+  fields;
+  constructor(init) {
+    this.name = init.name;
+    this.view = init.view;
+    this.actContext = init.actContext;
+    this.fields = init.fields;
+  }
+  getSpecificationByFields({
+    fields = [],
+    specification = {},
+    modelsData,
+    model,
+    modelRoot
+  }) {
+    if (Array.isArray(fields)) {
+      let spec = { ...specification };
+      fields.forEach((field) => {
+        if (!field?.type_co || field?.name && field?.type_co === "field" /* FIELD */) {
+          if (modelsData?.[model]?.[field?.name]) {
+            if (modelsData?.[model]?.[field?.name]?.type === "one2many" /* ONE2MANY */ || modelsData?.[model]?.[field?.name]?.type === "many2many" /* MANY2MANY */) {
+              const relation = modelsData?.[model]?.[field?.name]?.relation;
+              const modelRelation = modelsData?.[relation];
+              if (modelRelation) {
+                spec[field?.name] = {
+                  fields: {}
+                };
+                if (modelRoot && modelRoot === relation) {
+                  spec[field?.name].fields = { id: {} };
+                } else {
+                  spec[field?.name].fields = this.getSpecificationByFields({
+                    fields: Object.values(modelRelation),
+                    specification: {},
+                    modelsData,
+                    model: relation,
+                    modelRoot: model
+                  });
+                }
+              } else {
+                spec[field?.name] = {
+                  fields: {
+                    id: {},
+                    display_name: {}
+                  }
+                };
+              }
+            } else if (modelsData?.[model]?.[field?.name]?.type === "many2one" /* MANY2ONE */) {
+              spec[field?.name] = {
+                fields: {
+                  id: {},
+                  display_name: {},
+                  ...WIDGETAVATAR[field?.widget] ? { image_256: {} } : {},
+                  ...field?.name === "currency_id" && fields?.find((item) => item?.widget === "monetary") ? { symbol: {} } : {},
+                  ...field?.widget === "many2many_binary" ? { mimetype: {} } : {}
+                }
+              };
+            } else {
+              spec[field?.name] = {};
+            }
+          }
+        } else if (field?.type_co === "group" /* GROUP */ || field?.type_co === "div" /* DIV */ || field?.type_co === "span" /* SPAN */) {
+          const specGroup = this.getSpecificationByFields({
+            fields: field?.fields,
+            specification: spec,
+            modelsData,
+            model
+          });
+          spec = { ...spec, ...specGroup };
+        } else if (field?.type_co === "tree" /* TREE */ || field?.type_co === "list" /* LIST */) {
+          const relation = modelsData?.[model]?.[field?.name]?.relation;
+          const specTreee = this.getSpecificationByFields({
+            fields: field?.fields,
+            specification: {},
+            modelsData,
+            model: relation,
+            modelRoot: model
+          });
+          spec = { ...spec, [field?.name]: { fields: specTreee } };
+        }
+      });
+      return spec;
+    } else {
+      console.warn("fields is not array");
+    }
+  }
+  getTreeProps() {
+    const props = this.view?.views?.list || {};
+    return props;
+  }
+  getTreeFields() {
+    const fields = this.view?.views?.list?.fields || [];
+    return fields;
+  }
+  getSpecification() {
+    const specInit = {};
+    const modelData = this.view?.models || {};
+    const specification = this.getSpecificationByFields({
+      fields: this.fields,
+      specification: specInit,
+      modelsData: modelData,
+      model: this.name,
+      modelRoot: ""
+    });
+    return specification;
+  }
+};
+var base_model_default = BaseModel;
+
+// 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;
 
 // src/hooks/model/use-onchange-form.ts
 import { useMutation as useMutation27 } from "@tanstack/react-query";
+var useOnChangeForm = () => {
+  return useMutation27({
+    mutationFn: ({
+      ids,
+      model,
+      specification,
+      context,
+      object,
+      fieldChange
+    }) => model_service_default.onChange({
+      ids,
+      model,
+      specification,
+      context,
+      object,
+      fieldChange
+    })
+  });
+};
+var use_onchange_form_default = useOnChangeForm;
 
 // src/hooks/model/use-save.ts
 import { useMutation as useMutation28 } from "@tanstack/react-query";
+var useSave = () => {
+  return useMutation28({
+    mutationFn: ({
+      ids,
+      model,
+      data,
+      specification,
+      context,
+      path
+    }) => model_service_default.save({ ids, model, data, specification, context, path })
+  });
+};
+var use_save_default = useSave;
 
 // src/hooks/user/use-get-profile.ts
 import { useMutation as useMutation29 } from "@tanstack/react-query";
+var useGetProfile = (path) => {
+  return useMutation29({
+    mutationFn: () => user_service_default.getProfile(path)
+  });
+};
+var use_get_profile_default = useGetProfile;
 
 // src/hooks/user/use-get-user.ts
 import { useMutation as useMutation30 } from "@tanstack/react-query";
+var useGetUser = () => {
+  return useMutation30({
+    mutationFn: ({ id, context }) => user_service_default.getUser({
+      id,
+      context
+    })
+  });
+};
+var use_get_user_default = useGetUser;
 
 // src/hooks/user/use-switch-locale.ts
 import { useMutation as useMutation31 } from "@tanstack/react-query";
+var useSwitchLocale = () => {
+  return useMutation31({
+    mutationFn: ({ data }) => {
+      return user_service_default.switchUserLocale({
+        id: data.id,
+        values: data.values
+      });
+    }
+  });
+};
+var use_switch_locale_default = useSwitchLocale;
 
 // src/hooks/view/use-button.ts
 import { useMutation as useMutation32 } from "@tanstack/react-query";
+var useButton = () => {
+  return useMutation32({
+    mutationFn: ({
+      model,
+      ids,
+      context,
+      method
+    }) => action_service_default.callButton({
+      model,
+      ids,
+      context,
+      method
+    }),
+    onSuccess: (response) => {
+      return response;
+    }
+  });
+};
+var use_button_default = useButton;
 
 // src/hooks/view/use-duplicate-record.ts
 import { useMutation as useMutation33 } from "@tanstack/react-query";
+var useDuplicateRecord = () => {
+  return useMutation33({
+    mutationFn: ({
+      id,
+      model,
+      context
+    }) => action_service_default.duplicateRecord({
+      id,
+      model,
+      context
+    })
+  });
+};
+var use_duplicate_record_default = useDuplicateRecord;
 
 // src/hooks/view/use-get-action-detail.ts
 import { useQuery as useQuery11 } from "@tanstack/react-query";
+var useGetActionDetail = ({
+  aid,
+  context,
+  enabled,
+  id,
+  model,
+  queryKey
+}) => {
+  const data = {
+    id,
+    model: model ?? "",
+    context
+  };
+  return useQuery11({
+    queryKey,
+    queryFn: async () => {
+      if (aid) {
+        const res = await view_service_default.getActionDetail(aid, context);
+        if (res && res.length > 0) {
+          return res[0];
+        }
+      } else {
+        const res = await form_service_default.getFormView({ data });
+        return res;
+      }
+    },
+    enabled,
+    refetchOnWindowFocus: false,
+    staleTime: Infinity
+  });
+};
+var use_get_action_detail_default = useGetActionDetail;
 
 // src/hooks/view/use-get-calendar.ts
 import { useQuery as useQuery12 } from "@tanstack/react-query";
+var useGetCalendar = (listDataProps, queryKey, enabled) => {
+  return useQuery12({
+    queryKey,
+    queryFn: () => model_service_default.getListCalendar({ data: listDataProps }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    enabled,
+    refetchOnWindowFocus: false,
+    staleTime: 0
+  });
+};
+var use_get_calendar_default = useGetCalendar;
 
 // src/hooks/view/use-get-groups.ts
 import { useQuery as useQuery13 } from "@tanstack/react-query";
+var useGetGroups = ({
+  model,
+  width_context
+}) => {
+  return useQuery13({
+    queryKey: [model, width_context],
+    queryFn: () => kanban_service_default.getGroups({
+      model,
+      width_context
+    }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_groups_default = useGetGroups;
 
 // src/hooks/view/use-get-list-data.ts
 import { useQuery as useQuery14 } from "@tanstack/react-query";
+var useGetListData = (listDataProps, queryKey, enabled) => {
+  return useQuery14({
+    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;
 
 // src/hooks/view/use-get-menu.ts
 import { useQuery as useQuery15 } from "@tanstack/react-query";
+var useGetMenu = (context, enabled) => {
+  return useQuery15({
+    queryKey: ["menus" /* MENU */, context],
+    queryFn: () => view_service_default.getMenu(context).then((res) => {
+      if (res && res?.records && res?.records?.length > 0) {
+        return res?.records;
+      }
+      return [];
+    }),
+    refetchOnWindowFocus: false,
+    staleTime: Infinity,
+    enabled
+  });
+};
+var use_get_menu_default = useGetMenu;
 
 // src/hooks/view/use-get-print-report.ts
 import { useMutation as useMutation34 } from "@tanstack/react-query";
+var useGetPrintReport = () => {
+  return useMutation34({
+    mutationFn: ({ id }) => action_service_default.getPrintReportName({
+      id
+    })
+  });
+};
+var use_get_print_report_default = useGetPrintReport;
 
 // src/hooks/view/use-get-progress-bar.ts
 import { useQuery as useQuery16 } from "@tanstack/react-query";
+var useGetProGressBar = ({
+  field,
+  color,
+  model,
+  width_context
+}) => {
+  return useQuery16({
+    queryKey: [],
+    queryFn: () => kanban_service_default.getProgressBar({
+      field,
+      color,
+      model,
+      width_context
+    }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_progress_bar_default = useGetProGressBar;
 
 // src/hooks/view/use-get-selection.ts
 import { useQuery as useQuery17 } from "@tanstack/react-query";
+var useGetSelection = ({
+  data,
+  queryKey,
+  enabled
+}) => {
+  return useQuery17({
+    queryKey,
+    queryFn: () => view_service_default.getSelectionItem({ data }),
+    enabled,
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_selection_default = useGetSelection;
 
 // src/hooks/view/use-get-view.ts
 import { useQuery as useQuery18 } from "@tanstack/react-query";
+var useGetView = (viewParams, actData) => {
+  return useQuery18({
+    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;
 
 // src/hooks/view/use-load-action.ts
 import { useMutation as useMutation35 } from "@tanstack/react-query";
+var useLoadAction = () => {
+  return useMutation35({
+    mutationFn: ({
+      idAction,
+      context
+    }) => {
+      return action_service_default.loadAction({
+        idAction,
+        context
+      });
+    }
+  });
+};
+var use_load_action_default = useLoadAction;
 
 // src/hooks/view/use-load-message.ts
 import { useQuery as useQuery19 } from "@tanstack/react-query";
+var useLoadMessage = () => {
+  return useQuery19({
+    queryKey: [`load-message-failure`],
+    queryFn: () => view_service_default.loadMessages(),
+    refetchOnWindowFocus: false
+  });
+};
+var use_load_message_default = useLoadMessage;
 
 // src/hooks/view/use-print.ts
 import { useMutation as useMutation36 } from "@tanstack/react-query";
+var usePrint = () => {
+  return useMutation36({
+    mutationFn: ({ id, report, db }) => action_service_default.print({
+      id,
+      report,
+      db
+    })
+  });
+};
+var use_print_default = usePrint;
 
 // src/hooks/view/use-remove-row.ts
 import { useMutation as useMutation37 } from "@tanstack/react-query";
+var useRemoveRow = () => {
+  return useMutation37({
+    mutationFn: ({
+      model,
+      ids,
+      context
+    }) => action_service_default.removeRows({
+      model,
+      ids,
+      context
+    })
+  });
+};
+var use_remove_row_default = useRemoveRow;
 
 // src/hooks/view/use-resequence.ts
 import { useQuery as useQuery20 } from "@tanstack/react-query";
+var useGetResequence = (model, resIds, context, offset) => {
+  return useQuery20({
+    queryKey: [],
+    queryFn: () => view_service_default.getResequence({
+      model,
+      ids: resIds,
+      context,
+      offset
+    }),
+    enabled: false,
+    refetchOnWindowFocus: false
+  });
+};
+var use_resequence_default = useGetResequence;
 
 // src/hooks/view/use-run-action.ts
 import { useMutation as useMutation38 } from "@tanstack/react-query";
+var useRunAction = () => {
+  return useMutation38({
+    mutationFn: ({
+      idAction,
+      context
+    }) => action_service_default.runAction({
+      idAction,
+      context
+    })
+  });
+};
+var use_run_action_default = useRunAction;
 
 // src/hooks/view/use-signin-sso.ts
 import { useMutation as useMutation39 } from "@tanstack/react-query";
+var useSignInSSO = () => {
+  return useMutation39({
+    mutationFn: ({
+      redirect_uri,
+      state,
+      client_id,
+      response_type,
+      path
+    }) => {
+      return view_service_default.signInSSO({
+        redirect_uri,
+        state,
+        client_id,
+        response_type,
+        path
+      });
+    }
+  });
+};
+var use_signin_sso_default = useSignInSSO;
 
 // src/hooks/view/use-verify-2FA.ts
 import { useMutation as useMutation40 } from "@tanstack/react-query";
+var useVerify2FA = () => {
+  return useMutation40({
+    mutationFn: ({
+      method,
+      with_context,
+      code,
+      device,
+      location
+    }) => {
+      return view_service_default.verify2FA({
+        method,
+        with_context,
+        code,
+        device,
+        location
+      });
+    }
+  });
+};
+var use_verify_2FA_default = useVerify2FA;
 
 // src/hooks/view/uset-get-2FA-method.ts
 import { useMutation as useMutation41 } from "@tanstack/react-query";
+var useGet2FAMethods = () => {
+  return useMutation41({
+    mutationFn: ({
+      method,
+      with_context
+    }) => {
+      return view_service_default.get2FAMethods({
+        method,
+        with_context
+      });
+    }
+  });
+};
+var uset_get_2FA_method_default = useGet2FAMethods;
 
 // src/hooks/view/use-get-fields-view-security.ts
 import { useMutation as useMutation42 } from "@tanstack/react-query";
+var useGetFieldsViewSecurity = () => {
+  return useMutation42({
+    mutationFn: ({
+      method,
+      token,
+      views
+    }) => {
+      return view_service_default.getFieldsViewSecurity({
+        method,
+        token,
+        views
+      });
+    }
+  });
+};
+var use_get_fields_view_security_default = useGetFieldsViewSecurity;
 
 // src/hooks/view/use-grant-access.ts
 import { useMutation as useMutation43 } from "@tanstack/react-query";
+var useGrantAccess = () => {
+  return useMutation43({
+    mutationFn: ({
+      redirect_uri,
+      state,
+      client_id,
+      scopes
+    }) => {
+      return view_service_default.grantAccess({
+        redirect_uri,
+        state,
+        client_id,
+        scopes
+      });
+    }
+  });
+};
+var use_grant_access_default = useGrantAccess;
 
 // src/hooks/view/use-remove-totp-setup.ts
 import { useMutation as useMutation44 } from "@tanstack/react-query";
+var useRemoveTotpSetup = () => {
+  return useMutation44({
+    mutationFn: ({ method, token }) => {
+      return view_service_default.removeTotpSetUp({
+        method,
+        token
+      });
+    }
+  });
+};
+var use_remove_totp_setup_default = useRemoveTotpSetup;
 
 // src/hooks/view/use-request-setup-totp.ts
 import { useMutation as useMutation45 } from "@tanstack/react-query";
+var useRequestSetupTotp = () => {
+  return useMutation45({
+    mutationFn: ({ method, token }) => {
+      return view_service_default.requestSetupTotp({
+        method,
+        token
+      });
+    }
+  });
+};
+var use_request_setup_totp_default = useRequestSetupTotp;
 
 // src/hooks/view/use-settings-web-read-2fa.ts
 import { useMutation as useMutation46 } from "@tanstack/react-query";
+var useSettingsWebRead2fa = () => {
+  return useMutation46({
+    mutationFn: ({
+      method,
+      token,
+      kwargs,
+      model
+    }) => {
+      return view_service_default.settingsWebRead2fa({
+        method,
+        model,
+        kwargs,
+        token
+      });
+    }
+  });
+};
+var use_settings_web_read_2fa_default = useSettingsWebRead2fa;
 
 // src/hooks/view/use-verify-totp.ts
 import { useMutation as useMutation47 } from "@tanstack/react-query";
+var useVerifyTotp = () => {
+  return useMutation47({
+    mutationFn: ({
+      method,
+      action_token,
+      code
+    }) => {
+      return view_service_default.verifyTotp({
+        method,
+        action_token,
+        code
+      });
+    }
+  });
+};
+var use_verify_totp_default = useVerifyTotp;
 
 // src/provider/version-gate-provider.tsx
 import { Fragment, jsx as jsx5 } from "react/jsx-runtime";
@@ -3842,10 +6591,100 @@ var VersionGate = ({ children }) => {
   }, [queryClient]);
   return ready ? /* @__PURE__ */ jsx5(Fragment, { children }) : null;
 };
+
+// src/provider/service-provider.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var ServiceContext = createContext2(null);
+var ServiceProvider = ({
+  children
+}) => {
+  const services = {
+    useForgotPassword: use_forgot_password_default,
+    useForgotPasswordSSO: use_forgotpassword_sso_default,
+    useGetProvider: use_get_provider_default,
+    useIsValidToken: use_isvalid_token_default,
+    useLoginCredential: use_login_credential_default,
+    useLoginSocial: use_login_socical_default,
+    useResetPassword: use_reset_password_default,
+    useResetPasswordSSO: use_reset_password_sso_default,
+    useUpdatePassword: use_update_password_default,
+    useLogout: use_logout_default,
+    useGetAccessByCode: use_get_access_by_code_default,
+    useValidateActionToken: use_validate_action_token_default,
+    useGetCompanyInfo: use_get_company_info_default,
+    useGetCurrentCompany: use_get_current_company_default,
+    useGetListCompany: use_get_list_company_default,
+    useExecuteImport: uss_execute_import_default,
+    useExportExcel: use_export_excel_default,
+    useGetFieldExport: use_get_field_export_default,
+    useGetFileExcel: use_get_file_excel_default,
+    useParsePreview: use_parse_preview_default,
+    useUploadFile: use_upload_file_default,
+    useUploadIdFile: use_upload_id_file_default,
+    useChangeStatus: use_change_status_default,
+    useDeleteComment: use_delete_comment_default,
+    useGetComment: use_get_comment_default,
+    useGetFormView: use_get_form_view_default,
+    useGetImage: use_get_image_default,
+    useSendComment: use_send_comment_default,
+    useUploadImage: use_upload_image_default,
+    useDelete: use_delete_default,
+    useGetAll: use_get_all_default,
+    useGetConversionRate: use_get_conversion_rate_default,
+    useGetCurrency: use_get_currency_default,
+    useGetDetail: use_get_detail_default,
+    useGetFieldOnChange: use_get_field_onchange_default,
+    useGetListMyBankAccount: use_get_list_my_bank_account_default,
+    useModel: use_model_default,
+    useOdooDataTransform: use_odoo_data_transform_default,
+    useOnChangeForm: use_onchange_form_default,
+    useSave: use_save_default,
+    useGetProfile: use_get_profile_default,
+    useGetUser: use_get_user_default,
+    useSwitchLocale: use_switch_locale_default,
+    useButton: use_button_default,
+    useDuplicateRecord: use_duplicate_record_default,
+    useGet2FAMethods: uset_get_2FA_method_default,
+    useGetActionDetail: use_get_action_detail_default,
+    useGetCalendar: use_get_calendar_default,
+    useGetGroups: use_get_groups_default,
+    useGetListData: use_get_list_data_default,
+    useGetMenu: use_get_menu_default,
+    useGetPrintReport: use_get_print_report_default,
+    useGetProGressBar: use_get_progress_bar_default,
+    useGetResequence: use_resequence_default,
+    useGetSelection: use_get_selection_default,
+    useGetView: use_get_view_default,
+    useLoadAction: use_load_action_default,
+    useLoadMessage: use_load_message_default,
+    usePrint: use_print_default,
+    useRemoveRow: use_remove_row_default,
+    useRunAction: use_run_action_default,
+    useSignInSSO: use_signin_sso_default,
+    useVerify2FA: use_verify_2FA_default,
+    useGetFieldsViewSecurity: use_get_fields_view_security_default,
+    useGrantAccess: use_grant_access_default,
+    useRemoveTotpSetup: use_remove_totp_setup_default,
+    useRequestSetupTotp: use_request_setup_totp_default,
+    useSettingsWebRead2fa: use_settings_web_read_2fa_default,
+    useVerifyTotp: use_verify_totp_default
+  };
+  return /* @__PURE__ */ jsx6(ServiceContext.Provider, { value: services, children });
+};
+var useService = () => {
+  const context = useContext2(ServiceContext);
+  if (!context) {
+    throw new Error("useService must be used within a ServiceProvider");
+  }
+  return context;
+};
 export {
   EnvProvider,
   MainProvider,
   ReactQueryProvider,
+  ServiceProvider,
   VersionGate,
-  useEnv
+  useEnv,
+  useService
 };