@fctc/edu-logic-lib 1.0.9 → 1.0.10

package/dist/models.js

@@ -1,26 +1,1115 @@
 'use strict';
 
-var chunkOADBRQ4A_js = require('./chunk-OADBRQ4A.js');
-var chunkFVGPSTJ7_js = require('./chunk-FVGPSTJ7.js');
-require('./chunk-P2IGWJDZ.js');
-require('./chunk-GGOFXFSX.js');
-require('./chunk-S7YF2I23.js');
-require('./chunk-4K3QAEZ6.js');
-require('./chunk-RZBHZYXG.js');
-require('./chunk-UY6GNZNB.js');
-require('./chunk-IXDDYGKE.js');
+var toolkit = require('@reduxjs/toolkit');
+var axios = require('axios');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var axios__default = /*#__PURE__*/_interopDefault(axios);
 
-Object.defineProperty(exports, "CompanyModel", {
-  enumerable: true,
-  get: function () { return chunkOADBRQ4A_js.company_model_default; }
+// 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`;
+  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/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;
+var initialState = {
+  baseUrl: "",
+  requests: null,
+  companies: [],
+  user: {},
+  envFile: null,
+  defaultCompany: {
+    id: null,
+    logo: "",
+    secondary_color: "",
+    primary_color: ""
+  },
+  context: {
+    uid: null,
+    allowed_company_ids: [],
+    lang: "vi_VN",
+    tz: "Asia/Saigon"
+  }
+};
+var envSlice = toolkit.createSlice({
+  name: "env",
+  initialState,
+  reducers: {
+    setEnv: (state, action) => {
+      Object.assign(state, action.payload);
+    },
+    setUid: (state, action) => {
+      state.context.uid = action.payload;
+    },
+    setAllowCompanies: (state, action) => {
+      state.context.allowed_company_ids = action.payload;
+    },
+    setCompanies: (state, action) => {
+      state.companies = action.payload;
+    },
+    setDefaultCompany: (state, action) => {
+      state.defaultCompany = action.payload;
+    },
+    setLang: (state, action) => {
+      state.context.lang = action.payload;
+    },
+    setUser: (state, action) => {
+      state.user = action.payload;
+    },
+    setEnvFile: (state, action) => {
+      state.envFile = action.payload;
+    }
+  }
+});
+var {
+  setEnv,
+  setUid,
+  setLang,
+  setAllowCompanies,
+  setCompanies,
+  setDefaultCompany,
+  setUser,
+  setEnvFile
+} = envSlice.actions;
+var env_slice_default = envSlice.reducer;
+var initialState2 = {
+  dataParse: null,
+  idFile: null,
+  isFileLoaded: false,
+  loadingImport: false,
+  selectedFile: null,
+  errorData: null
+};
+var excelSlice = toolkit.createSlice({
+  name: "excel",
+  initialState: initialState2,
+  reducers: {
+    setDataParse: (state, action) => {
+      state.dataParse = action.payload;
+    },
+    setIdFile: (state, action) => {
+      state.idFile = action.payload;
+    },
+    setIsFileLoaded: (state, action) => {
+      state.isFileLoaded = action.payload;
+    },
+    setLoadingImport: (state, action) => {
+      state.loadingImport = action.payload;
+    },
+    setSelectedFile: (state, action) => {
+      state.selectedFile = action.payload;
+    },
+    setErrorData: (state, action) => {
+      state.errorData = action.payload;
+    }
+  }
+});
+var {
+  setDataParse,
+  setIdFile,
+  setIsFileLoaded,
+  setLoadingImport,
+  setSelectedFile,
+  setErrorData
+} = excelSlice.actions;
+var excel_slice_default = excelSlice.reducer;
+var initialState3 = {
+  viewDataStore: {},
+  isShowingModalDetail: false,
+  isShowModalTranslate: false,
+  formSubmitComponent: {},
+  fieldTranslation: null,
+  listSubject: {},
+  dataUser: {}
+};
+var formSlice = toolkit.createSlice({
+  name: "form",
+  initialState: initialState3,
+  reducers: {
+    setViewDataStore: (state, action) => {
+      state.viewDataStore = action.payload;
+    },
+    setIsShowingModalDetail: (state, action) => {
+      state.isShowingModalDetail = action.payload;
+    },
+    setIsShowModalTranslate: (state, action) => {
+      state.isShowModalTranslate = action.payload;
+    },
+    setFormSubmitComponent: (state, action) => {
+      state.formSubmitComponent[action.payload.key] = action.payload.component;
+    },
+    setFieldTranslate: (state, action) => {
+      state.fieldTranslation = action.payload;
+    },
+    setListSubject: (state, action) => {
+      state.listSubject = action.payload;
+    },
+    setDataUser: (state, action) => {
+      state.dataUser = action.payload;
+    }
+  }
+});
+var {
+  setViewDataStore,
+  setIsShowingModalDetail,
+  setIsShowModalTranslate,
+  setFormSubmitComponent,
+  setFieldTranslate,
+  setListSubject,
+  setDataUser
+} = formSlice.actions;
+var form_slice_default = formSlice.reducer;
+var initialState4 = {
+  pageLimit: 10,
+  fields: {},
+  order: "",
+  selectedRowKeys: [],
+  indexRowTableModal: -2,
+  footerGroupTable: {},
+  page: 0,
+  domainTable: []
+};
+var listSlice = toolkit.createSlice({
+  name: "list",
+  initialState: initialState4,
+  reducers: {
+    setPageLimit: (state, action) => {
+      state.pageLimit = action.payload;
+    },
+    setFields: (state, action) => {
+      state.fields = action.payload;
+    },
+    setOrder: (state, action) => {
+      state.order = action.payload;
+    },
+    setSelectedRowKeys: (state, action) => {
+      state.selectedRowKeys = action.payload;
+    },
+    setIndexRowTableModal: (state, action) => {
+      state.indexRowTableModal = action.payload;
+    },
+    setPage: (state, action) => {
+      state.page = action.payload;
+    },
+    setDomainTable: (state, action) => {
+      state.domainTable = action.payload;
+    }
+  }
+});
+var {
+  setPageLimit,
+  setFields,
+  setOrder,
+  setSelectedRowKeys,
+  setIndexRowTableModal,
+  setPage,
+  setDomainTable
+} = listSlice.actions;
+var list_slice_default = listSlice.reducer;
+var initialState5 = {
+  menuList: []
+};
+var navbarSlice = toolkit.createSlice({
+  name: "navbar",
+  initialState: initialState5,
+  reducers: {
+    setMenuList: (state, action) => {
+      state.menuList = action.payload;
+    }
+  }
+});
+var { setMenuList } = navbarSlice.actions;
+var navbar_slice_default = navbarSlice.reducer;
+var initialState6 = {
+  profile: {}
+};
+var profileSlice = toolkit.createSlice({
+  name: "profile",
+  initialState: initialState6,
+  reducers: {
+    setProfile: (state, action) => {
+      state.profile = action.payload;
+    }
+  }
+});
+var { setProfile } = profileSlice.actions;
+var profile_slice_default = profileSlice.reducer;
+var initialState7 = {
+  groupByDomain: null,
+  tableHead: [],
+  searchString: "",
+  hoveredIndexSearchList: null,
+  selectedTags: [],
+  firstDomain: null,
+  searchMap: {},
+  typeFieldsSearch: "",
+  modelSearch: "",
+  filterBy: [],
+  groupBy: []
+};
+var searchSlice = toolkit.createSlice({
+  name: "search",
+  initialState: initialState7,
+  reducers: {
+    setGroupByDomain: (state, action) => {
+      state.groupByDomain = action.payload;
+    },
+    setTableHead: (state, action) => {
+      state.tableHead = action.payload;
+    },
+    setSearchString: (state, action) => {
+      state.searchString = action.payload;
+    },
+    setHoveredIndexSearchList: (state, action) => {
+      state.hoveredIndexSearchList = action.payload;
+    },
+    setSelectedTags: (state, action) => {
+      state.selectedTags = action.payload;
+    },
+    setFirstDomain: (state, action) => {
+      state.firstDomain = action.payload;
+    },
+    setTypeFieldsSearch: (state, action) => {
+      state.typeFieldsSearch = action.payload;
+    },
+    setModelSearch: (state, action) => {
+      state.modelSearch = action.payload;
+    },
+    setFilterBy: (state, action) => {
+      state.filterBy = action.payload;
+    },
+    setGroupBy: (state, action) => {
+      state.groupBy = action.payload;
+    },
+    setSearchMap: (state, action) => {
+      state.searchMap = action.payload;
+    },
+    updateSearchMap: (state, action) => {
+      if (!state.searchMap[action.payload.key]) {
+        state.searchMap[action.payload.key] = [];
+      }
+      state.searchMap[action.payload.key].push(action.payload.value);
+    },
+    removeKeyFromSearchMap: (state, action) => {
+      const { key, item } = action.payload;
+      const values = state.searchMap[key];
+      if (!values) return;
+      if (item) {
+        const filtered = values.filter((value) => value.name !== item.name);
+        if (filtered.length > 0) {
+          state.searchMap[key] = filtered;
+        } else {
+          delete state.searchMap[key];
+        }
+      } else {
+        delete state.searchMap[key];
+      }
+    },
+    clearSearchMap: (state) => {
+      state.searchMap = {};
+    }
+  }
 });
-Object.defineProperty(exports, "UserModel", {
-  enumerable: true,
-  get: function () { return chunkOADBRQ4A_js.user_model_default; }
+var {
+  setGroupByDomain,
+  setSelectedTags,
+  setSearchString,
+  setHoveredIndexSearchList,
+  setFirstDomain,
+  setTableHead,
+  setFilterBy,
+  setTypeFieldsSearch,
+  setModelSearch,
+  setSearchMap,
+  updateSearchMap,
+  removeKeyFromSearchMap,
+  setGroupBy,
+  clearSearchMap
+} = searchSlice.actions;
+var search_slice_default = searchSlice.reducer;
+
+// node_modules/redux/dist/redux.mjs
+function formatProdErrorMessage(code) {
+  return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
+}
+var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
+var ActionTypes = {
+  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
+  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
+  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
+};
+var actionTypes_default = ActionTypes;
+function isPlainObject(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  let proto = obj;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
+}
+function miniKindOf(val) {
+  if (val === void 0)
+    return "undefined";
+  if (val === null)
+    return "null";
+  const type = typeof val;
+  switch (type) {
+    case "boolean":
+    case "string":
+    case "number":
+    case "symbol":
+    case "function": {
+      return type;
+    }
+  }
+  if (Array.isArray(val))
+    return "array";
+  if (isDate(val))
+    return "date";
+  if (isError(val))
+    return "error";
+  const constructorName = ctorName(val);
+  switch (constructorName) {
+    case "Symbol":
+    case "Promise":
+    case "WeakMap":
+    case "WeakSet":
+    case "Map":
+    case "Set":
+      return constructorName;
+  }
+  return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, "");
+}
+function ctorName(val) {
+  return typeof val.constructor === "function" ? val.constructor.name : null;
+}
+function isError(val) {
+  return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
+}
+function isDate(val) {
+  if (val instanceof Date)
+    return true;
+  return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
+}
+function kindOf(val) {
+  let typeOfVal = typeof val;
+  if (process.env.NODE_ENV !== "production") {
+    typeOfVal = miniKindOf(val);
+  }
+  return typeOfVal;
+}
+function warning(message) {
+  if (typeof console !== "undefined" && typeof console.error === "function") {
+    console.error(message);
+  }
+  try {
+    throw new Error(message);
+  } catch (e) {
+  }
+}
+function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
+  const reducerKeys = Object.keys(reducers);
+  const argumentName = action && action.type === actionTypes_default.INIT ? "preloadedState argument passed to createStore" : "previous state received by the reducer";
+  if (reducerKeys.length === 0) {
+    return "Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers.";
+  }
+  if (!isPlainObject(inputState)) {
+    return `The ${argumentName} has unexpected type of "${kindOf(inputState)}". Expected argument to be an object with the following keys: "${reducerKeys.join('", "')}"`;
+  }
+  const unexpectedKeys = Object.keys(inputState).filter((key) => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]);
+  unexpectedKeys.forEach((key) => {
+    unexpectedKeyCache[key] = true;
+  });
+  if (action && action.type === actionTypes_default.REPLACE)
+    return;
+  if (unexpectedKeys.length > 0) {
+    return `Unexpected ${unexpectedKeys.length > 1 ? "keys" : "key"} "${unexpectedKeys.join('", "')}" found in ${argumentName}. Expected to find one of the known reducer keys instead: "${reducerKeys.join('", "')}". Unexpected keys will be ignored.`;
+  }
+}
+function assertReducerShape(reducers) {
+  Object.keys(reducers).forEach((key) => {
+    const reducer = reducers[key];
+    const initialState8 = reducer(void 0, {
+      type: actionTypes_default.INIT
+    });
+    if (typeof initialState8 === "undefined") {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : `The slice reducer for key "${key}" returned undefined during initialization. If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.`);
+    }
+    if (typeof reducer(void 0, {
+      type: actionTypes_default.PROBE_UNKNOWN_ACTION()
+    }) === "undefined") {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : `The slice reducer for key "${key}" returned undefined when probed with a random type. Don't try to handle '${actionTypes_default.INIT}' or other actions in "redux/*" namespace. They are considered private. Instead, you must return the current state for any unknown actions, unless it is undefined, in which case you must return the initial state, regardless of the action type. The initial state may not be undefined, but can be null.`);
+    }
+  });
+}
+function combineReducers(reducers) {
+  const reducerKeys = Object.keys(reducers);
+  const finalReducers = {};
+  for (let i = 0; i < reducerKeys.length; i++) {
+    const key = reducerKeys[i];
+    if (process.env.NODE_ENV !== "production") {
+      if (typeof reducers[key] === "undefined") {
+        warning(`No reducer provided for key "${key}"`);
+      }
+    }
+    if (typeof reducers[key] === "function") {
+      finalReducers[key] = reducers[key];
+    }
+  }
+  const finalReducerKeys = Object.keys(finalReducers);
+  let unexpectedKeyCache;
+  if (process.env.NODE_ENV !== "production") {
+    unexpectedKeyCache = {};
+  }
+  let shapeAssertionError;
+  try {
+    assertReducerShape(finalReducers);
+  } catch (e) {
+    shapeAssertionError = e;
+  }
+  return function combination(state = {}, action) {
+    if (shapeAssertionError) {
+      throw shapeAssertionError;
+    }
+    if (process.env.NODE_ENV !== "production") {
+      const warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);
+      if (warningMessage) {
+        warning(warningMessage);
+      }
+    }
+    let hasChanged = false;
+    const nextState = {};
+    for (let i = 0; i < finalReducerKeys.length; i++) {
+      const key = finalReducerKeys[i];
+      const reducer = finalReducers[key];
+      const previousStateForKey = state[key];
+      const nextStateForKey = reducer(previousStateForKey, action);
+      if (typeof nextStateForKey === "undefined") {
+        const actionType = action && action.type;
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(14) : `When called with an action of type ${actionType ? `"${String(actionType)}"` : "(unknown type)"}, the slice reducer for key "${key}" returned undefined. To ignore an action, you must explicitly return the previous state. If you want this reducer to hold no value, you can return null instead of undefined.`);
+      }
+      nextState[key] = nextStateForKey;
+      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
+    }
+    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
+    return hasChanged ? nextState : state;
+  };
+}
+
+// src/store/store.ts
+var rootReducer = combineReducers({
+  env: env_slice_default,
+  navbar: navbar_slice_default,
+  list: list_slice_default,
+  search: search_slice_default,
+  form: form_slice_default,
+  excel: excel_slice_default,
+  profile: profile_slice_default
 });
-Object.defineProperty(exports, "BaseModel", {
-  enumerable: true,
-  get: function () { return chunkFVGPSTJ7_js.base_model_default; }
+var envStore = toolkit.configureStore({
+  reducer: rootReducer,
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+    serializableCheck: false
+  })
 });
+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__default.default.create({
+      adapter: axios__default.default.defaults.adapter,
+      baseURL: config.baseUrl,
+      timeout: 5e4,
+      paramsSerializer: (params) => new URLSearchParams(params).toString()
+    });
+    if (typeof window !== "undefined") {
+      const isMaint = window.localStorage.getItem(MAINT_KEY) === "true";
+      const onMaintenancePage = window.location.pathname === "/maintenance";
+      if (isMaint && !onMaintenancePage) {
+        hasRedirectedToMaintenance = true;
+        window.location.replace("/maintenance");
+      }
+      if (isMaint && onMaintenancePage) {
+        const healthUrl = config.healthUrl || `${(config.baseUrl || "").replace(/\/+$/, "")}/health`;
+        (async () => {
+          try {
+            await axios__default.default.get(healthUrl, { timeout: 8e3 });
+            await clearMaintenanceAndExit(() => 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__default.default.post(
+                `${config.baseUrl}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
+                }
+              ).then(async (res) => {
+                const data = res.data;
+                await 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;
+                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;
+  }
+};
+
+// 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 = axiosClient.init(env2);
+    dispatch(setEnv({ ...env2, requests }));
+    this.setup();
+  }
+  setUid(uid) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setUid(uid));
+    this.setup();
+  }
+  setLang(lang) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setLang(lang));
+    this.setup();
+  }
+  setAllowCompanies(allowCompanies) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setAllowCompanies(allowCompanies));
+    this.setup();
+  }
+  setCompanies(companies) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setCompanies(companies));
+    this.setup();
+  }
+  setDefaultCompany(company) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setDefaultCompany(company));
+    this.setup();
+  }
+  setUserInfo(userInfo) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setUser(userInfo));
+    this.setup();
+  }
+};
+var env = null;
+function getEnv() {
+  if (!env) env = new EnvStore(envStore);
+  return env;
+}
+
+// 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/user-service/index.ts
+var UserService = {
+  async getProfile() {
+    const env2 = getEnv();
+    return env2.requests.get("/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/models/company-model/index.ts
+var CompanyModel = class extends base_model_default {
+  constructor(init) {
+    super(init);
+  }
+  async getCurrentCompany() {
+    return await company_service_default.getCurrentCompany();
+  }
+  async getUserCompany(id) {
+    return await company_service_default.getInfoCompany(id);
+  }
+};
+var company_model_default = CompanyModel;
+
+// src/models/user-model/index.ts
+var UserModel = class extends base_model_default {
+  constructor(init) {
+    super(init);
+  }
+  async getProfile() {
+    return await user_service_default.getProfile();
+  }
+};
+var user_model_default = UserModel;
+
+exports.BaseModel = base_model_default;
+exports.CompanyModel = company_model_default;
+exports.UserModel = user_model_default;