@fctc/interface-logic 5.1.0 → 5.1.3

package/dist/chunk-Q5YXX4OR.js

@@ -0,0 +1,322 @@
+'use strict';
+
+var chunkJDXUTKMX_js = require('./chunk-JDXUTKMX.js');
+var axios = require('axios');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+function removeLanguages(acceptLang, removeList) {
+  return acceptLang.split(",").map((x) => x.trim()).filter((item) => !removeList?.some((lang) => item?.startsWith(lang))).join(",");
+}
+var axiosClient = {
+  init(config) {
+    const localStorage = config?.localStorageUtils ?? chunkJDXUTKMX_js.localStorageUtils();
+    const sessionStorage = config?.sessionStorageUtils ?? chunkJDXUTKMX_js.sessionStorageUtils;
+    const db = config?.db;
+    const database = config?.config?.database;
+    const isSupabaseMode = config?.isSupaMode;
+    let isRefreshing = false;
+    let failedQueue = [];
+    const processQueue = (error, token = null) => {
+      failedQueue?.forEach((prom) => {
+        if (error) {
+          prom.reject(error);
+        } else {
+          prom.resolve(token);
+        }
+      });
+      failedQueue = [];
+    };
+    const instance = axios__default.default.create({
+      adapter: axios__default.default.defaults.adapter,
+      baseURL: config?.baseUrl,
+      timeout: 5e4,
+      paramsSerializer: (params) => new URLSearchParams(params).toString()
+    });
+    instance.interceptors.request.use(async (configReq) => {
+      const rawLang = navigator.languages?.join(",") || navigator.language;
+      const useRefreshToken = configReq.headers["X-Use-Refresh-Token"] === "true";
+      const useActionToken = configReq.headers["X-Use-Action-Token"] === "true";
+      const actionToken = configReq.headers["X-Action-Token"];
+      const cleaned = removeLanguages(rawLang, config?.excludeLanguages);
+      let token = null;
+      if (useActionToken && actionToken) {
+        token = actionToken;
+      } else {
+        const getToken = useRefreshToken ? localStorage.getRefreshToken : localStorage.getAccessToken;
+        token = await getToken?.();
+      }
+      if (token) {
+        configReq.headers["Authorization"] = `Bearer ${token}`;
+      }
+      if (database) {
+        configReq.headers["DATABASE"] = database;
+      }
+      configReq.headers["Accept-Language"] = cleaned;
+      return configReq;
+    }, Promise.reject);
+    const buildRefreshUrl = () => {
+      if (!config.refreshTokenEndpoint) {
+        return `${getBaseUrl(config?.baseUrl)}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
+      }
+      const ep = String(config.refreshTokenEndpoint);
+      if (/^https?:\/\//i.test(ep)) return ep;
+      const cleanBase = String(config?.baseUrl || "").replace(/\/$/, "");
+      const cleanEp = ep.startsWith("/") ? ep : `/${ep}`;
+      return `${cleanBase}${cleanEp}`;
+    };
+    instance.interceptors.response.use(
+      (response) => handleResponse(response),
+      async (error) => {
+        const handleError2 = async (err) => {
+          if (!err.response) return err;
+          const { data } = err.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401, "ERR_2FA_006"].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((newToken) => {
+              originalRequest.headers["Authorization"] = "Bearer " + newToken;
+              originalRequest.data = chunkJDXUTKMX_js.updateTokenParamInOriginalRequest(
+                originalRequest,
+                newToken
+              );
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage.getBrowserSession();
+          const refreshToken = await localStorage.getRefreshToken();
+          const accessTokenExp = await localStorage.getAccessToken();
+          isRefreshing = true;
+          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
+            await clearAuthToken();
+          } else {
+            const payload = Object.fromEntries(
+              Object.entries({
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+                client_id: config.config.clientId,
+                client_secret: config.config.clientSecret
+              }).filter(([_, v]) => !!v)
+            );
+            const refreshUrl = buildRefreshUrl();
+            return new Promise(function(resolve) {
+              axios__default.default.post(refreshUrl, payload, {
+                headers: {
+                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                  Authorization: `Bearer ${accessTokenExp}`
+                }
+              }).then(async (res) => {
+                const data = res.data;
+                await localStorage.setToken(data.access_token);
+                await localStorage.setRefreshToken(data.refresh_token);
+                axios__default.default.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.data = chunkJDXUTKMX_js.updateTokenParamInOriginalRequest(
+                  originalRequest,
+                  data.access_token
+                );
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_2FA_006")) {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  const { error_code } = err.response?.data || {};
+                  const { code } = err;
+                  if (error_code === "AUTHEN_FAIL" || code === "ERR_2FA_006") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
+          }
+        }
+        return Promise.reject(await handleError2(error));
+      }
+    );
+    instance.interceptors.response.use(
+      (response) => {
+        return handleResponse(response);
+      },
+      async (error) => {
+        const handleError2 = async (error2) => {
+          if (!error2.response) {
+            return error2;
+          }
+          const { data } = error2.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401, "ERR_2FA_006"].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((token) => {
+              originalRequest.headers["Authorization"] = "Bearer " + token;
+              originalRequest.data = chunkJDXUTKMX_js.updateTokenParamInOriginalRequest(
+                originalRequest,
+                token
+              );
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage.getBrowserSession();
+          const refreshToken = await localStorage.getRefreshToken();
+          const accessTokenExp = await localStorage.getAccessToken();
+          isRefreshing = true;
+          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
+            await clearAuthToken();
+          } else {
+            const payload = Object.fromEntries(
+              Object.entries({
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+                client_id: config.config.clientId,
+                client_secret: config.config.clientSecret
+              }).filter(([_, value]) => !!value)
+            );
+            return new Promise(function(resolve) {
+              axios__default.default.post(
+                `${config?.baseUrl}${config.refreshTokenEndpoint ?? "/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
+                }
+              ).then(async (res) => {
+                const data = res.data;
+                await localStorage.setToken(data.access_token);
+                await localStorage.setRefreshToken(data.refresh_token);
+                axios__default.default.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.data = chunkJDXUTKMX_js.updateTokenParamInOriginalRequest(
+                  originalRequest,
+                  data.access_token
+                );
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                console.log("catch error: ", err);
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_2FA_006")) {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  console.log("err response code: ", err);
+                  console.log("err response: ", err.response);
+                  const { error_code } = err.response?.data || {};
+                  const { code } = err;
+                  if (error_code === "AUTHEN_FAIL" || code === "ERR_2FA_006") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
+          }
+        }
+        return Promise.reject(await handleError2(error));
+      }
+    );
+    const handleResponse = (res) => {
+      if (res && res.data) {
+        return res.data;
+      }
+      return res;
+    };
+    const clearAuthToken = async () => {
+      await localStorage.clearToken();
+      if (typeof window !== "undefined") {
+        window.location.href = `/login`;
+      }
+    };
+    function formatUrl(url, db2) {
+      return url + (db2 ? "?db=" + db2 : "");
+    }
+    const getBaseUrl = (baseUrl, hardService) => {
+      return isSupabaseMode ? "" : `${baseUrl.replace(/\/$/, "")}/${hardService || sessionStorage.getMenuFocus().service || config?.default_service}/api/v2`;
+    };
+    const getHeaders = (header) => {
+      const headers = {
+        headers: {
+          ...header.headers,
+          ...sessionStorage.getXNode() ? { "X-Node": sessionStorage.getXNode() } : {}
+        }
+      };
+      return headers;
+    };
+    const responseBody = (response) => response;
+    const requests = {
+      get: (url, headers, hardService) => instance.get(
+        formatUrl(getBaseUrl(config?.baseUrl, hardService) + url, db),
+        getHeaders(headers)
+      ).then(responseBody),
+      post: async (url, body, headers, hardService) => instance.post(
+        formatUrl(getBaseUrl(config?.baseUrl, hardService) + url, db),
+        body,
+        getHeaders(headers)
+      ).then(responseBody),
+      post_excel: (url, body, headers, hardService) => instance.post(
+        formatUrl(getBaseUrl(config?.baseUrl, hardService) + url, db),
+        body,
+        {
+          responseType: "arraybuffer",
+          headers: {
+            "Content-Type": typeof window !== "undefined" ? "application/json" : "application/javascript",
+            Accept: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            ...headers,
+            ...sessionStorage.getXNode() ? { "X-Node": sessionStorage.getXNode() } : {}
+          }
+        }
+      ).then(responseBody),
+      put: (url, body, headers, hardService) => instance.put(
+        formatUrl(getBaseUrl(config?.baseUrl, hardService) + url, db),
+        body,
+        getHeaders(headers)
+      ).then(responseBody),
+      patch: (url, body, headers, hardService) => instance.patch(
+        formatUrl(getBaseUrl(config?.baseUrl, hardService) + url, db),
+        body,
+        getHeaders(headers)
+      ).then(responseBody),
+      delete: (url, headers, hardService) => instance.delete(
+        formatUrl(getBaseUrl(config?.baseUrl, hardService) + url, db),
+        getHeaders(headers)
+      ).then(responseBody)
+    };
+    return requests;
+  }
+};
+
+exports.axiosClient = axiosClient;

package/dist/chunk-QOXPJWSN.mjs

@@ -0,0 +1,114 @@
+import { WIDGETAVATAR } from './chunk-VBYRP2P7.mjs';
+
+// src/models/base-model/index.ts
+var BaseModel = class {
+  name;
+  view;
+  fields;
+  constructor(init) {
+    this.name = init.name;
+    this.view = init.view;
+    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: { id: {}, display_name: {} },
+                    modelsData,
+                    model: relation,
+                    modelRoot: model
+                  });
+                }
+              } else {
+                spec[field?.name] = {
+                  fields: {
+                    id: {},
+                    display_name: {},
+                    ...field?.widget === "many2many_binary" ? { mimetype: {} } : {},
+                    ...field?.widget === "many2many_binary" && relation === "ir.attachment" ? { datas: {} } : {}
+                  }
+                };
+              }
+            } 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 */ || field?.type_co === "kanban" /* KANBAN */) {
+          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;
+  }
+};
+
+export { BaseModel };

package/dist/chunk-RPWKWEMA.js

@@ -0,0 +1,116 @@
+'use strict';
+
+var chunkWBGK2SHU_js = require('./chunk-WBGK2SHU.js');
+
+// src/models/base-model/index.ts
+var BaseModel = class {
+  name;
+  view;
+  fields;
+  constructor(init) {
+    this.name = init.name;
+    this.view = init.view;
+    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: { id: {}, display_name: {} },
+                    modelsData,
+                    model: relation,
+                    modelRoot: model
+                  });
+                }
+              } else {
+                spec[field?.name] = {
+                  fields: {
+                    id: {},
+                    display_name: {},
+                    ...field?.widget === "many2many_binary" ? { mimetype: {} } : {},
+                    ...field?.widget === "many2many_binary" && relation === "ir.attachment" ? { datas: {} } : {}
+                  }
+                };
+              }
+            } else if (modelsData?.[model]?.[field?.name]?.type === "many2one" /* MANY2ONE */) {
+              spec[field?.name] = {
+                fields: {
+                  id: {},
+                  display_name: {},
+                  ...chunkWBGK2SHU_js.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 */ || field?.type_co === "kanban" /* KANBAN */) {
+          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;
+  }
+};
+
+exports.BaseModel = BaseModel;