@mu-cabin/opms-permission 0.1.0

package/dist/index.mjs

@@ -0,0 +1,490 @@
+// src/utils/storage.ts
+var Storage = class {
+  setSystemId(systemId) {
+    this.systemId = systemId;
+  }
+  prefixKey(key) {
+    return this.systemId !== void 0 ? `systemId-${this.systemId}-${key}` : key;
+  }
+  /**
+   * Set an item in localStorage, with optional expiration in minutes
+   */
+  setItem(key, value, expireMinutes) {
+    const data = {
+      value,
+      expire: expireMinutes ? Date.now() + expireMinutes * 60 * 1e3 : null
+    };
+    localStorage.setItem(this.prefixKey(key), JSON.stringify(data));
+  }
+  /**
+   * Get an item from localStorage, returns undefined if expired or not found
+   */
+  getItem(key) {
+    const raw = localStorage.getItem(this.prefixKey(key));
+    if (!raw) return void 0;
+    try {
+      const data = JSON.parse(raw);
+      if (data.expire && Date.now() > data.expire) {
+        localStorage.removeItem(this.prefixKey(key));
+        return void 0;
+      }
+      return data.value;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Remove an item from localStorage
+   */
+  removeItem(key) {
+    localStorage.removeItem(this.prefixKey(key));
+  }
+};
+var storage = new Storage();
+
+// src/utils/dataHandler.ts
+function getCompletePath(item) {
+  const menuUrl = item.openIndicator === "INNER_COMPONENT" ? item.componentPath : item.defaultUrl;
+  return menuUrl ?? "";
+}
+function getMenuName(item) {
+  return item.resourceType !== "FOLDER" ? item.resourceName || "" : (item.showName ?? item.resourceName) || "";
+}
+function createResourceMap(items) {
+  const resourceMap = {};
+  const widgetMap = {};
+  function addToMap(items2) {
+    items2.forEach((item) => {
+      const newItem = { ...item };
+      if (newItem.defaultResourceType === "WIDGET") {
+        if (newItem.componentPath) widgetMap[newItem.componentPath] = newItem;
+      } else {
+        const path = getCompletePath(newItem);
+        if (path) {
+          resourceMap[path] = newItem;
+        }
+      }
+      if (newItem.children) {
+        addToMap(newItem.children);
+      }
+    });
+  }
+  addToMap(items);
+  return { resourceMap, widgetMap };
+}
+function isMenuItem(item) {
+  const resourceType = item.resourceType ?? item.defaultResourceType;
+  return resourceType !== "WIDGET";
+}
+function createMenuList(items) {
+  const menus = [];
+  const menuMap = {};
+  const filterMenus = (items2, container) => {
+    items2.forEach((item) => {
+      const icon = item.icon || item.defaultIcon;
+      const path = getCompletePath(item);
+      const name = getMenuName(item);
+      const newItem = {
+        icon,
+        path,
+        name,
+        children: [],
+        openIndicator: item.openIndicator,
+        resourceId: item.resourceId
+      };
+      menuMap[newItem.resourceId] = newItem;
+      if (isMenuItem(item)) {
+        container.push(newItem);
+      }
+      if (item.children) {
+        filterMenus(item.children, newItem.children);
+      }
+    });
+  };
+  filterMenus(items, menus);
+  return { menuList: menus, menuMap };
+}
+function iterateNestedArray(items, callback) {
+  function trevel(items2, parent) {
+    return items2.map((item) => {
+      const handledItem = callback(item, parent);
+      if (handledItem && handledItem.children) {
+        handledItem.children = trevel(handledItem.children, handledItem);
+      }
+      return handledItem;
+    }).filter((v) => v);
+  }
+  return trevel(items);
+}
+function findFirstEnableCode(data) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return null;
+  }
+  let queue = [...data];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    if (!node?.disabled) {
+      return node?.value || null;
+    }
+    if (Array.isArray(node.children) && node.children.length > 0) {
+      queue = queue.concat(node.children);
+    }
+  }
+  return null;
+}
+function findAllEnableTopLevelCodes(nodes) {
+  const codes = [];
+  function findEnabledNodes(nodes2) {
+    for (const node of nodes2) {
+      if (!node.disabled) {
+        codes.push(node.value);
+      } else if (node.children) {
+        findEnabledNodes(node.children);
+      }
+    }
+  }
+  findEnabledNodes(nodes);
+  return codes;
+}
+
+// src/api.ts
+import axios from "axios";
+
+// src/config.ts
+var USER_INFO_KEY = "opms_user_info";
+var RESOURCE_KEY = "opms_resources";
+var TOKEN_KEY = "omps_authorization";
+var ORG_COMPANY_KEY = "opms_org_company";
+
+// src/api.ts
+var axiosClient = axios.create();
+axiosClient.interceptors.request.use((config) => {
+  const token = storage.getItem(TOKEN_KEY);
+  if (token) {
+    config.headers.Authorization = token;
+  }
+  return config;
+});
+axiosClient.interceptors.response.use(
+  (response) => {
+    const res = response.data;
+    const { code, msg } = res;
+    if (code !== 200) {
+      throw new Error(msg);
+    }
+    return res;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+async function login(baseUrl, authorizationCode) {
+  return await axiosClient.get(
+    `${baseUrl}/opmsDefaultAuth/oauthLogin`,
+    {
+      params: { authorizationCode }
+    }
+  );
+}
+async function logout(baseUrl) {
+  return await axiosClient.post(
+    `${baseUrl}/opmsDefaultAuth/logout`
+  );
+}
+async function getUserInfo(baseUrl) {
+  return await axiosClient.post(
+    `${baseUrl}/opmsDefaultUser/userInfo`,
+    {}
+  );
+}
+async function queryResource(baseUrl, params) {
+  return await axiosClient.post(
+    `${baseUrl}/opmsDefaultUser/userResource`,
+    params
+  );
+}
+async function getUserOrgTree(baseUrl, params) {
+  return await axiosClient.post(
+    `${baseUrl}/opmsDefaultUser/orgTree`,
+    params
+  );
+}
+async function queryOrgCompanies(baseUrl, params) {
+  return await axiosClient.post(
+    `${baseUrl}/opmsDefaultUser/branches`,
+    params
+  );
+}
+
+// src/permission.ts
+var Permission = class {
+  constructor(options) {
+    this._userInfo = null;
+    this._orgTree = null;
+    this._orgCompany = null;
+    this.resources = [];
+    this.resourceMap = {};
+    this.widgetMap = {};
+    this.menuList = [];
+    this.menuMap = {};
+    this.baseUrl = options.baseUrl;
+    this.systemId = options.systemId;
+    storage.setSystemId(this.systemId);
+  }
+  /**
+   * Login using code from URL, save userInfo
+   */
+  async login() {
+    const url = new URL(window.location.href);
+    const code = url.searchParams.get("code");
+    if (!code) throw new Error("No code found in URL");
+    const { obj, success, msg } = await login(this.baseUrl, code);
+    if (!success) {
+      throw new Error(msg);
+    }
+    const { token } = obj;
+    url.searchParams.delete("code");
+    storage.setItem(TOKEN_KEY, token);
+    return token;
+  }
+  /**
+   * Logout and clear userInfo
+   */
+  async logout() {
+    await logout(this.baseUrl);
+    this.clear();
+  }
+  clear() {
+    this._userInfo = null;
+    this._orgTree = null;
+    this._orgCompany = null;
+    this.resources = [];
+    this.resourceMap = {};
+    this.widgetMap = {};
+    this.menuList = [];
+    this.menuMap = {};
+    storage.removeItem(RESOURCE_KEY);
+    storage.removeItem(TOKEN_KEY);
+    storage.removeItem(USER_INFO_KEY);
+    storage.removeItem(ORG_COMPANY_KEY);
+  }
+  async getUserInfo() {
+    const data = await getUserInfo(this.baseUrl);
+    const { obj, success, msg } = data;
+    if (!success) {
+      return Promise.reject(new Error(msg));
+    }
+    this._userInfo = obj;
+    return obj;
+  }
+  /**
+   * Get resources and process to menuList, menuMap, widgetMap (matches app store logic)
+   */
+  async getResources() {
+    const resourcesObj = storage.getItem(RESOURCE_KEY) || null;
+    if (resourcesObj) {
+      const { menuList: menuList2, menuMap: menuMap2 } = createMenuList(resourcesObj.resources);
+      return {
+        resources: resourcesObj.resources,
+        resourceMap: resourcesObj.resourceMap,
+        widgetMap: resourcesObj.widgetMap,
+        menuList: menuList2,
+        menuMap: menuMap2
+      };
+    }
+    const { obj, success, msg } = await queryResource(this.baseUrl, {
+      systemId: this.systemId
+    });
+    if (!success) {
+      return Promise.reject(new Error(msg));
+    }
+    const resources = obj;
+    const { resourceMap, widgetMap } = createResourceMap(resources);
+    const { menuList, menuMap } = createMenuList(resources);
+    this.resources = resources;
+    this.resourceMap = resourceMap;
+    this.widgetMap = widgetMap;
+    this.menuList = menuList;
+    this.menuMap = menuMap;
+    storage.setItem(
+      RESOURCE_KEY,
+      {
+        resources,
+        resourceMap,
+        widgetMap
+      },
+      60 * 24
+      // 24 hours
+    );
+    return {
+      resources,
+      resourceMap,
+      widgetMap,
+      menuList,
+      menuMap
+    };
+  }
+  /**
+   * Query and process organization tree
+   */
+  async queryOrgs() {
+    try {
+      const data = await getUserOrgTree(this.baseUrl, {
+        systemId: this.systemId,
+        name: "COS"
+      });
+      const { obj, success, msg } = data;
+      if (!success) {
+        return Promise.reject(new Error(msg));
+      }
+      const orgTree = obj;
+      const newTree = iterateNestedArray([orgTree], (item) => {
+        return {
+          label: item.orgShortName,
+          value: item.orgCode,
+          title: item.orgShortName,
+          key: item.orgCode,
+          nodeLevel: item.nodeLevel,
+          children: item.children,
+          disabled: !item.hasPermission,
+          orgType: item.orgType
+        };
+      })?.[0];
+      this._orgTree = newTree;
+      return newTree;
+    } catch (error) {
+      console.log(error);
+      return null;
+    }
+  }
+  async queryCompanies() {
+    try {
+      let orgCompanyList = storage.getItem(ORG_COMPANY_KEY);
+      if (!orgCompanyList) {
+        const { obj } = await queryOrgCompanies(this.baseUrl, { queryAllBranches: true });
+        orgCompanyList = obj;
+        storage.setItem(ORG_COMPANY_KEY, orgCompanyList);
+      }
+      this._orgCompany = orgCompanyList;
+    } catch (error) {
+      console.log(error);
+    }
+  }
+  isLogin() {
+    return !!storage.getItem(TOKEN_KEY);
+  }
+  getToken() {
+    return storage.getItem(TOKEN_KEY);
+  }
+  // --- Getters ---
+  get userInfo() {
+    if (!this._userInfo) {
+      this._userInfo = storage.getItem(USER_INFO_KEY);
+    }
+    if (!this._userInfo) return null;
+    const { account, name, ehrId, crewCode, crewId } = this._userInfo;
+    return { account, name, ehrId, crewCode, crewId };
+  }
+  get hasRootAuth() {
+    const orgs = this._userInfo?.organizations || [];
+    const first = orgs[0];
+    if (!first) return false;
+    return first.searchPath === "#1";
+  }
+  get userOrganizations() {
+    return this._userInfo?.userOrganizations || [];
+  }
+  get allCompanyOptions() {
+    const orgCompany = this._orgCompany;
+    if (!orgCompany) return [];
+    const list = orgCompany.map((v) => ({
+      label: v.orgName,
+      value: v.orgCode
+    }));
+    list.unshift({ label: "\u5168\u516C\u53F8", value: "EA" });
+    return list;
+  }
+  get companyOptions() {
+    const orgTree = this._orgTree;
+    if (!orgTree) return [];
+    const list = (orgTree.children || []).map(
+      ({ children, ...others }) => ({ ...others, disabled: false })
+    );
+    if (this.hasRootAuth) {
+      list.unshift({ ...orgTree, label: "\u5168\u516C\u53F8", children: [] });
+    }
+    return list;
+  }
+  get firstCompanyOrgCode() {
+    return this.companyOptions?.[0]?.value ?? "";
+  }
+  get unitOptions() {
+    const orgTree = this._orgTree;
+    if (!orgTree) return [];
+    return orgTree.disabled ? orgTree.children ?? [] : [orgTree];
+  }
+  get allUnitOptions() {
+    const orgTree = this._orgTree;
+    if (!orgTree) return [];
+    const newTree = iterateNestedArray(
+      [orgTree],
+      ({ disabled, ...other }) => ({ ...other })
+    )?.[0];
+    return newTree ? newTree.children ?? [] : [];
+  }
+  get firstUnitOrgCode() {
+    if (this.hasRootAuth) {
+      return this.companyOptions[1]?.value ?? "";
+    }
+    const orgTree = this._orgTree;
+    if (!orgTree) return "";
+    return findFirstEnableCode([orgTree]) ?? "";
+  }
+  get topLevelUnitOrgCodes() {
+    const orgTree = this._orgTree;
+    if (!orgTree) return [];
+    return findAllEnableTopLevelCodes(
+      Array.isArray(orgTree) ? orgTree : [orgTree]
+    );
+  }
+};
+
+// src/sso.ts
+function jumpToSSOLogin({
+  baseUrl,
+  redirectUrl,
+  clientId = "testSA19"
+}) {
+  const { location } = window;
+  const ssoUrl = new URL(`${baseUrl}/idp/oauth2/authorize`);
+  const defaultUrl = new URL(
+    location.origin + location.pathname + location.search
+  );
+  ssoUrl.searchParams.set("client_id", clientId);
+  ssoUrl.searchParams.set("response_type", "code");
+  ssoUrl.searchParams.set("redirect_uri", redirectUrl || defaultUrl.toString());
+  window.location.href = ssoUrl.toString();
+}
+function jumpToSSOLogout({
+  baseUrl,
+  redirectToUrl,
+  clientId = "testSA19"
+}) {
+  if (!baseUrl) {
+    throw new Error("baseUrl is required");
+  }
+  const { location } = window;
+  const ssoLoginUrl = `${baseUrl}/idp/oauth2/authorize?client_id=${clientId}&response_type=code&redirect_uri=${location.origin}/`;
+  const redirectUrl = encodeURIComponent(redirectToUrl || ssoLoginUrl);
+  const logoutUrl = new URL(`${baseUrl}/idp/profile/OAUTH2/Redirect/GLO`);
+  logoutUrl.searchParams.set("response_type", "code");
+  logoutUrl.searchParams.set("entityId", clientId);
+  logoutUrl.searchParams.set("redirectToLogin", "true");
+  logoutUrl.searchParams.set("redirctToUrl", redirectUrl);
+  window.location.href = logoutUrl.toString();
+}
+export {
+  Permission as OpmsPermission,
+  jumpToSSOLogin,
+  jumpToSSOLogout
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@mu-cabin/opms-permission",
+  "version": "0.1.0",
+  "description": "Frontend SDK for OPMS permission and auth management.",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.mjs.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format cjs,esm",
+    "dev": "tsup src/index.ts --watch --dts --format cjs,esm",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run build",
+    "publish:package": "npm run clean && npm run build && npm publish"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": ["opms", "permission", "auth", "sdk"],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "axios": "^1.6.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "rimraf": "^5.0.5"
+  },
+  "dependencies": {}
+}