@fctc/edu-logic-lib 1.0.7 → 1.0.8

package/dist/base-model-type-DvO53Lwi.d.mts

@@ -0,0 +1,7 @@
+interface BaseModelInit {
+    name: string;
+    view: Record<string, any>;
+    actContext?: Record<string, any>;
+}
+
+export type { BaseModelInit as B };

package/dist/base-model-type-DvO53Lwi.d.ts

@@ -0,0 +1,7 @@
+interface BaseModelInit {
+    name: string;
+    view: Record<string, any>;
+    actContext?: Record<string, any>;
+}
+
+export type { BaseModelInit as B };

package/dist/chunk-4K3QAEZ6.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var chunkRZBHZYXG_js = require('./chunk-RZBHZYXG.js');
+var chunkUY6GNZNB_js = require('./chunk-UY6GNZNB.js');
+
+// src/environment/EnvStore.ts
+var EnvStore = class {
+  envStore;
+  baseUrl;
+  requests;
+  context;
+  defaultCompany;
+  config;
+  companies;
+  user;
+  db;
+  localStorageUtils;
+  sessionStorageUtils;
+  constructor(envStore2, localStorageUtils, sessionStorageUtils) {
+    this.envStore = envStore2;
+    this.localStorageUtils = localStorageUtils;
+    this.sessionStorageUtils = sessionStorageUtils;
+    this.setup();
+  }
+  setup() {
+    const env2 = this.envStore.getState().env;
+    this.baseUrl = env2?.baseUrl;
+    this.requests = env2?.requests;
+    this.context = env2?.context;
+    this.defaultCompany = env2?.defaultCompany;
+    this.config = env2?.config;
+    this.companies = env2?.companies || [];
+    this.user = env2?.user;
+    this.db = env2?.db;
+  }
+  setupEnv(envConfig) {
+    const dispatch = this.envStore.dispatch;
+    const env2 = {
+      ...envConfig,
+      localStorageUtils: this.localStorageUtils,
+      sessionStorageUtils: this.sessionStorageUtils
+    };
+    const requests = chunkUY6GNZNB_js.axiosClient.init(env2);
+    dispatch(chunkRZBHZYXG_js.setEnv({ ...env2, requests }));
+    this.setup();
+  }
+  setUid(uid) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(chunkRZBHZYXG_js.setUid(uid));
+    this.setup();
+  }
+  setLang(lang) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(chunkRZBHZYXG_js.setLang(lang));
+    this.setup();
+  }
+  setAllowCompanies(allowCompanies) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(chunkRZBHZYXG_js.setAllowCompanies(allowCompanies));
+    this.setup();
+  }
+  setCompanies(companies) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(chunkRZBHZYXG_js.setCompanies(companies));
+    this.setup();
+  }
+  setDefaultCompany(company) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(chunkRZBHZYXG_js.setDefaultCompany(company));
+    this.setup();
+  }
+  setUserInfo(userInfo) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(chunkRZBHZYXG_js.setUser(userInfo));
+    this.setup();
+  }
+};
+exports.env = null;
+function initEnv({}) {
+  exports.env = new EnvStore(chunkRZBHZYXG_js.envStore);
+  return exports.env;
+}
+function getEnv() {
+  if (!exports.env) exports.env = new EnvStore(chunkRZBHZYXG_js.envStore);
+  return exports.env;
+}
+
+exports.EnvStore = EnvStore;
+exports.getEnv = getEnv;
+exports.initEnv = initEnv;

package/dist/chunk-6BLY7NZ6.mjs

@@ -0,0 +1,120 @@
+import { WIDGETAVATAR } from './chunk-S7B3VKMJ.mjs';
+
+// 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: { ...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;
+
+export { base_model_default };

package/dist/chunk-6QXB3XX7.mjs

@@ -0,0 +1,256 @@
+import axios from 'axios';
+
+// src/config/axios-client.ts
+var MAINT_KEY = "MAINTENANCE_ACTIVE";
+var MAINT_AT = "MAINTENANCE_AT";
+var MAINT_LAST_PATH = "MAINTENANCE_LAST_PATH";
+var hasRedirectedToMaintenance = false;
+function setMaintenanceFlags() {
+  if (typeof window === "undefined") return;
+  const { pathname, search } = window.location;
+  const lastPath = pathname + (search || "");
+  if (pathname !== "/maintenance" && !window.localStorage.getItem(MAINT_LAST_PATH)) {
+    window.localStorage.setItem(MAINT_LAST_PATH, lastPath);
+  }
+  window.localStorage.setItem(MAINT_KEY, "true");
+  window.localStorage.setItem(MAINT_AT, String(Date.now()));
+}
+async function clearMaintenanceAndExit(getToken, opts) {
+  if (typeof window === "undefined") return;
+  const forceLogin = opts?.forceLogin === true;
+  const clearTokenOnForce = opts?.clearTokenOnForce !== false;
+  window.localStorage.removeItem(MAINT_KEY);
+  window.localStorage.removeItem(MAINT_AT);
+  const lastPath = window.localStorage.getItem(MAINT_LAST_PATH);
+  window.localStorage.removeItem(MAINT_LAST_PATH);
+  try {
+    if (forceLogin) {
+      if (clearTokenOnForce) {
+        try {
+          await opts?.clearToken?.();
+        } catch {
+        }
+      }
+      window.location.replace("/login");
+      return;
+    }
+    const token = await getToken();
+    if (token) {
+      const target = lastPath && lastPath !== "/maintenance" ? lastPath : "/";
+      window.location.replace(target);
+    } else {
+      window.location.replace("/login");
+    }
+  } catch {
+    window.location.replace("/login");
+  }
+}
+var axiosClient = {
+  init(config) {
+    const localStorage = config.localStorageUtils;
+    const sessionStorage = config.sessionStorageUtils;
+    const db = config.db;
+    let isRefreshing = false;
+    let failedQueue = [];
+    const processQueue = (error, token = null) => {
+      failedQueue?.forEach((prom) => {
+        if (error) {
+          prom.reject(error);
+        } else {
+          prom.resolve(token);
+        }
+      });
+      failedQueue = [];
+    };
+    const instance = axios.create({
+      adapter: axios.defaults.adapter,
+      baseURL: config.baseUrl,
+      timeout: 5e4,
+      paramsSerializer: (params) => new URLSearchParams(params).toString()
+    });
+    if (typeof window !== "undefined") {
+      const isMaint = window.localStorage.getItem(MAINT_KEY) === "true";
+      const onMaintenancePage = window.location.pathname === "/maintenance";
+      if (isMaint && !onMaintenancePage) {
+        hasRedirectedToMaintenance = true;
+        window.location.replace("/maintenance");
+      }
+      if (isMaint && onMaintenancePage) {
+        const healthUrl = config.healthUrl || `${(config.baseUrl || "").replace(/\/+$/, "")}/health`;
+        (async () => {
+          try {
+            await axios.get(healthUrl, { timeout: 8e3 });
+            await clearMaintenanceAndExit(() => localStorage.getAccessToken(), {
+              forceLogin: true,
+              clearTokenOnForce: true,
+              clearToken: () => localStorage.clearToken()
+            });
+          } catch {
+          }
+        })();
+      }
+    }
+    instance.interceptors.request.use(
+      async (configReq) => {
+        const token = await localStorage.getAccessToken();
+        if (token) {
+          configReq.headers["Authorization"] = "Bearer " + token;
+        }
+        return configReq;
+      },
+      (error) => Promise.reject(error)
+    );
+    instance.interceptors.response.use(
+      (response) => {
+        if (typeof window !== "undefined") {
+          const isMaint = window.localStorage.getItem(MAINT_KEY) === "true";
+          const onMaintenancePage = window.location.pathname === "/maintenance";
+          if (isMaint && onMaintenancePage) {
+            (async () => {
+              await clearMaintenanceAndExit(
+                () => localStorage.getAccessToken(),
+                {
+                  forceLogin: true,
+                  clearTokenOnForce: true,
+                  clearToken: () => localStorage.clearToken()
+                }
+              );
+            })();
+          } else if (isMaint) {
+            window.localStorage.removeItem(MAINT_KEY);
+            window.localStorage.removeItem(MAINT_AT);
+            window.localStorage.removeItem(MAINT_LAST_PATH);
+          }
+        }
+        return handleResponse(response);
+      },
+      async (error) => {
+        const status = error?.response?.status;
+        if (status === 503) {
+          if (typeof window !== "undefined") {
+            setMaintenanceFlags();
+            if (!hasRedirectedToMaintenance && window.location.pathname !== "/maintenance") {
+              hasRedirectedToMaintenance = true;
+              window.location.replace("/maintenance");
+            }
+          }
+          return Promise.reject({
+            code: 503,
+            message: "SERVICE_UNAVAILABLE",
+            original: error?.response?.data
+          });
+        }
+        const handleError = async (err) => {
+          if (!err.response) {
+            return err;
+          }
+          const { data } = err.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((token) => {
+              originalRequest.headers["Authorization"] = "Bearer " + token;
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage.getBrowserSession();
+          const refreshToken = await 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.post(
+                `${config.baseUrl}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
+                }
+              ).then(async (res) => {
+                const data = res.data;
+                await localStorage.setToken(data.access_token);
+                await localStorage.setRefreshToken(data.refresh_token);
+                axios.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_BAD_REQUEST")) {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  const { error_code } = err.response?.data || {};
+                  if (error_code === "AUTHEN_FAIL") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
+          }
+        }
+        return Promise.reject(await handleError(error));
+      }
+    );
+    const handleResponse = (res) => {
+      if (res && res.data) {
+        return res.data;
+      }
+      return res;
+    };
+    const clearAuthToken = async () => {
+      await localStorage.clearToken();
+      if (typeof window !== "undefined") {
+        window.location.href = `/login`;
+      }
+    };
+    function formatUrl(url, db2) {
+      return url + (db2 ? "?db=" + db2 : "");
+    }
+    const responseBody = (response) => response;
+    const requests = {
+      get: (url, headers) => instance.get(formatUrl(url, db), headers).then(responseBody),
+      post: (url, body, headers) => instance.post(formatUrl(url, db), body, { headers }).then(responseBody),
+      post_excel: (url, body, headers) => instance.post(formatUrl(url, db), body, {
+        responseType: "arraybuffer",
+        headers: {
+          "Content-Type": typeof window !== "undefined" ? "application/json" : "application/javascript",
+          Accept: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        }
+      }).then(responseBody),
+      put: (url, body, headers) => instance.put(formatUrl(url, db), body, headers).then(responseBody),
+      patch: (url, body) => instance.patch(formatUrl(url, db), body).then(responseBody),
+      delete: (url, body) => instance.delete(formatUrl(url, db), body).then(responseBody)
+    };
+    return requests;
+  }
+};
+
+export { axiosClient };

package/dist/chunk-7JD5GMIZ.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/chunk-AYUH66EE.mjs

@@ -0,0 +1,62 @@
+import { view_service_default } from './chunk-RWRHCIQI.mjs';
+import { envStore } from './chunk-QLUONJPQ.mjs';
+import { useState, useEffect } from 'react';
+import { QueryClient, QueryClientProvider, useQueryClient } from '@tanstack/react-query';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { Provider } from 'react-redux';
+
+var ReactQueryProvider = ({ children }) => {
+  const [queryClient] = useState(
+    () => new QueryClient({
+      defaultOptions: {
+        queries: {
+          refetchOnWindowFocus: false,
+          refetchOnMount: false,
+          refetchOnReconnect: false,
+          retry: false
+        }
+      }
+    })
+  );
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children });
+};
+var ReduxProvider = ({ children }) => {
+  return /* @__PURE__ */ jsx(Provider, { store: envStore, children });
+};
+var MainProvider = ({ children }) => {
+  return /* @__PURE__ */ jsx(ReduxProvider, { children: /* @__PURE__ */ jsx(ReactQueryProvider, { children }) });
+};
+var VersionGate = ({ children }) => {
+  const queryClient = useQueryClient();
+  const [ready, setReady] = useState(false);
+  useEffect(() => {
+    const clearVersion = () => {
+      queryClient.clear();
+      localStorage.removeItem("__api_version__");
+    };
+    const validateVersion = async () => {
+      const serverVersion = await view_service_default.getVersion();
+      const cached = localStorage.getItem("__api_version__");
+      if (cached !== serverVersion?.api_version) {
+        clearVersion();
+        localStorage.setItem("__api_version__", serverVersion?.api_version);
+      } else {
+        console.log("Api version:", serverVersion?.api_version);
+      }
+      setReady(true);
+    };
+    validateVersion();
+    if (typeof window !== "undefined") {
+      const onKey = (e) => {
+        const key = e.key.toLowerCase();
+        const isHardRefresh = (key === "f5" || key === "r") && e.ctrlKey && (key !== "r" || e.shiftKey) || key === "r" && e.metaKey && e.shiftKey || key === "r" && e.metaKey && e.altKey;
+        if (isHardRefresh) clearVersion();
+      };
+      window.addEventListener("keydown", onKey);
+      return () => window.removeEventListener("keydown", onKey);
+    }
+  }, [queryClient]);
+  return ready ? /* @__PURE__ */ jsx(Fragment, { children }) : null;
+};
+
+export { MainProvider, ReactQueryProvider, VersionGate };