@fctc/interface-logic 1.10.7 → 1.10.8

package/dist/provider.mjs

@@ -3058,6 +3058,11 @@ 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,/;
@@ -3426,6 +3431,157 @@ function getEnv() {
   return env?.getEnv();
 }
 
+// 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 env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } 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) {
@@ -3942,6 +4098,58 @@ var FormService = {
 };
 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 = {
@@ -4321,131 +4529,578 @@ var UserService = {
 };
 var user_service_default = UserService;
 
-// 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]
+// 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 ({
@@ -5425,81 +6080,480 @@ 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";
@@ -5588,7 +6642,33 @@ var ServiceProvider = ({
     useSave: use_save_default,
     useGetProfile: use_get_profile_default,
     useGetUser: use_get_user_default,
-    useSwitchLocale: use_switch_locale_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 });
 };