@orsetra/shared-ui 1.1.19 → 1.1.21

package/utils/permission.ts

@@ -0,0 +1,136 @@
+import type { LoginUserInfo, PermissionBase } from '@/api';
+
+export interface ResourceAction {
+  resource: string;
+  action: string;
+}
+
+export class ResourceName {
+  type: string;
+  value: string;
+  next?: ResourceName;
+  constructor(value: string) {
+    const index = value.indexOf('/', 1);
+    let node = value;
+    if (index > -1) {
+      node = value.slice(0, index);
+    }
+    const tn = node.split(':');
+    if (tn.length == 2) {
+      this.type = tn[0];
+      this.value = tn[1];
+    } else {
+      this.type = tn[0];
+      this.value = '*';
+    }
+    if (index > -1) {
+      const nextValue = value.slice(index + 1);
+      if (nextValue != '') {
+        this.next = new ResourceName(value.slice(index + 1));
+      }
+    }
+  }
+}
+
+export function checkPermission(
+  request?: ResourceAction,
+  project?: string,
+  userInfo?: LoginUserInfo,
+) {
+  if (!request) {
+    return true;
+  }
+  if (!userInfo) {
+    return false;
+  }
+
+  if (!userInfo.platformPermissions && !userInfo.projectPermissions) {
+    return false;
+  }
+  // check platform permissions
+  if (!project) {
+    if (!userInfo.platformPermissions || userInfo.platformPermissions.length == 0) {
+      return false;
+    }
+  }
+
+  let permissions = userInfo.platformPermissions || [];
+
+  // check project permissions
+  if (project && userInfo.projectPermissions) {
+    if (project == '?') {
+      Object.keys(userInfo.projectPermissions).map((key) => {
+        if (userInfo.projectPermissions) {
+          const perms = userInfo.projectPermissions[key];
+          if (perms) {
+            permissions = permissions.concat(perms);
+          }
+        }
+      });
+    } else {
+      const userPermissions = userInfo.projectPermissions[project];
+      if (userPermissions) {
+        permissions = permissions.concat(userPermissions);
+      }
+    }
+  }
+  for (let i = 0; i < permissions.length; i++) {
+    const effect = permissions[i].effect.toLowerCase();
+    if (effect == 'deny' && match(request, permissions[i])) {
+      return false;
+    }
+  }
+  for (let i = 0; i < permissions.length; i++) {
+    const effect = permissions[i].effect.toLowerCase();
+    if ((effect == 'allow' || effect == '') && match(request, permissions[i])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function match(request: ResourceAction, permission: PermissionBase) {
+  if (!permission.actions.includes(request.action) && !permission.actions.includes('*')) {
+    return false;
+  }
+  if (!permission.resources?.length) {
+    return false;
+  }
+  for (let i = 0; i < permission.resources?.length; i++) {
+    if (
+      resourceMatch(new ResourceName(request.resource), new ResourceName(permission.resources[i]))
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function resourceMatch(requestResource: ResourceName, permissionResource: ResourceName) {
+  let current: undefined | ResourceName = permissionResource;
+  let targetCurrent: undefined | ResourceName = requestResource;
+  while (current && current.type) {
+    if (current.type == '*') {
+      return true;
+    }
+    if (!targetCurrent || !targetCurrent.type) {
+      return false;
+    }
+    if (current.type != targetCurrent.type) {
+      return false;
+    }
+    if (
+      current.value != targetCurrent.value &&
+      current.value != '*' &&
+      targetCurrent.value != '?'
+    ) {
+      return false;
+    }
+    current = current.next;
+    targetCurrent = targetCurrent.next;
+  }
+  if (targetCurrent && targetCurrent.type) {
+    return false;
+  }
+  return true;
+}

package/utils/resetLogin.ts

@@ -0,0 +1,35 @@
+"use client";
+
+import i18n from '../i18n';
+
+class ResetLogin {
+  private static singleton: ResetLogin;
+  public reset: React.ReactNode | null;
+  constructor() {
+    this.reset = this.resetDom();
+  }
+  private resetDom(): React.ReactNode | null {
+    // Check if running in browser environment
+    if (typeof window === 'undefined') {
+      return null;
+    }
+    
+    if (window.location.href.indexOf('/login') === -1) {
+      // Trigger logout and redirect
+      localStorage.removeItem('token');
+      localStorage.removeItem('refreshToken');
+      window.location.href = '/login';
+      return null;
+    } else {
+      return null;
+    }
+  }
+  static getInstance() {
+    if (!ResetLogin.singleton) {
+      ResetLogin.singleton = new ResetLogin();
+    }
+    return ResetLogin.singleton;
+  }
+}
+
+export default ResetLogin;

package/utils/storage.ts

@@ -0,0 +1,21 @@
+const token_key = 'token';
+
+export function getToken() {
+  return localStorage.getItem(token_key) || '';
+}
+
+export function setToken(token: string | string[]) {
+  if (Array.isArray(token)) {
+    localStorage.setItem(token_key, token[0]);
+  } else if (typeof token === 'string') {
+    localStorage.setItem(token_key, token);
+  }
+}
+
+export function removeToken() {
+  localStorage.removeItem(token_key);
+}
+
+export function hasToken() {
+  return !!getToken();
+}

package/utils/utils.ts

@@ -0,0 +1,216 @@
+import _ from 'lodash';
+
+import type { ComponentDefinitionsBase,Endpoint  } from '@/api';
+
+type SelectGroupType = Array<{
+  label: string;
+  children: Array<{ label: string; value: string }>;
+}>;
+
+// code from https://github.com/kubernetes-client/javascript/blob/master/src/util.ts#L17
+export function findSuffix(quantity: string): string {
+  let ix = quantity.length - 1;
+  while (ix >= 0 && !/[\.0-9]/.test(quantity.charAt(ix))) {
+    ix--;
+  }
+  return ix === -1 ? '' : quantity.substring(ix + 1);
+}
+
+// code from https://github.com/kubernetes-client/javascript/blob/master/src/util.ts#L17
+export function quantityToScalar(quantity: string): number | bigint {
+  if (!quantity) {
+    return 0;
+  }
+  const suffix = findSuffix(quantity);
+  if (suffix === '') {
+    const num = Number(quantity).valueOf();
+    if (isNaN(num)) {
+      throw new Error('Unknown quantity ' + quantity);
+    }
+    return num;
+  }
+  switch (suffix) {
+    case 'n':
+      return Number(quantity.substr(0, quantity.length - 1)).valueOf() / 100_000_000.0;
+    case 'm':
+      return Number(quantity.substr(0, quantity.length - 1)).valueOf() / 1000.0;
+    case 'Ki':
+      return BigInt(quantity.substr(0, quantity.length - 2)) * BigInt(1024);
+    case 'Mi':
+      return BigInt(quantity.substr(0, quantity.length - 2)) * BigInt(1024 * 1024);
+    case 'Gi':
+      return BigInt(quantity.substr(0, quantity.length - 2)) * BigInt(1024 * 1024 * 1024);
+    case 'Ti':
+      return (
+        BigInt(quantity.substr(0, quantity.length - 2)) * BigInt(1024 * 1024 * 1024) * BigInt(1024)
+      );
+    case 'Pi':
+      return (
+        BigInt(quantity.substr(0, quantity.length - 2)) *
+        BigInt(1024 * 1024 * 1024) *
+        BigInt(1024 * 1024)
+      );
+    case 'Ei':
+      return (
+        BigInt(quantity.substr(0, quantity.length - 2)) *
+        BigInt(1024 * 1024 * 1024) *
+        BigInt(1024 * 1024 * 1024)
+      );
+    default:
+      throw new Error(`Unknown suffix: ${suffix}`);
+  }
+}
+
+export function transComponentDefinitions(componentDefinitions: ComponentDefinitionsBase[]) {
+  const defaultCoreDataSource = ['k8s-objects', 'task', 'webservice', 'worker'];
+  const cloud: SelectGroupType = [
+    {
+      label: 'Cloud',
+      children: [],
+    },
+  ];
+  const core: SelectGroupType = [
+    {
+      label: 'Core',
+      children: [],
+    },
+  ];
+  const custom: SelectGroupType = [
+    {
+      label: 'Custom',
+      children: [],
+    },
+  ];
+  (componentDefinitions || []).map((item: { name: string; workloadType?: string }) => {
+    if (item.workloadType === 'configurations.terraform.core.oam.dev') {
+      cloud[0].children.push({
+        label: item.name,
+        value: item.name,
+      });
+    } else if (defaultCoreDataSource.includes(item.name)) {
+      core[0].children.push({
+        label: item.name,
+        value: item.name,
+      });
+    } else {
+      custom[0].children.push({
+        label: item.name,
+        value: item.name,
+      });
+    }
+  });
+  return [...core, ...custom, ...cloud];
+}
+
+export function getLink(endpointObj: Endpoint) {
+  const { appProtocol, host } = endpointObj.endpoint;
+  let { port, protocol = '', path = '' } = endpointObj.endpoint;
+  protocol = protocol.toLocaleLowerCase();
+  if (appProtocol && appProtocol !== '') {
+    protocol = appProtocol;
+  }
+  // Support to open this address in a new window directly.
+  if (protocol == 'tcp') {
+    protocol = 'http';
+  }
+  if (host == '') {
+    return path;
+  }
+  if (path === '/') {
+    path = '';
+  }
+  if ((protocol === 'https' && port == 443) || (protocol === 'http' && port === 80)) {
+    port = '';
+  } else {
+    port = ':' + port;
+  }
+  return protocol + '://' + host + port + path;
+}
+
+export function getValue(key: string, value: any): any {
+  if (key.indexOf('.') > -1) {
+    const currentKey: string = key.substring(0, key.indexOf('.'));
+    const nextKey: string = key.substring(key.indexOf('.') + 1);
+    return getValue(nextKey, value[currentKey]);
+  }
+  if (!value) {
+    return null;
+  }
+  return value[key];
+}
+
+export function getSelectLabel(
+  data: Array<{ name: string; alias?: string }>,
+): Array<{ label: string; value: string }> {
+  return (data || []).map((item: { name: string; alias?: string }) => {
+    return { label: item.alias || item.name, value: item.name };
+  });
+}
+
+export function getMatchParamObj(match: { params: any }, name: string) {
+  return match.params && match.params[name];
+}
+
+/**
+ * Get browser name agent version
+ * return browser name version
+ * */
+export function getBrowserNameAndVersion() {
+  // Check if running in browser environment
+  if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+    return 'unknown';
+  }
+  
+  const agent = navigator.userAgent.toLowerCase();
+  const regStr_ie = /msie [\d.]+/gi;
+  const regStr_ff = /firefox\/[\d.]+/gi;
+  const regStr_chrome = /chrome\/[\d.]+/gi;
+  const regStr_saf = /safari\/[\d.]+/gi;
+  let browserNV: any;
+  //IE
+  if (agent.indexOf('msie') > 0) {
+    browserNV = agent.match(regStr_ie);
+  }
+  //firefox
+  if (agent.indexOf('firefox') > 0) {
+    browserNV = agent.match(regStr_ff);
+  }
+  //Chrome
+  if (agent.indexOf('chrome') > 0) {
+    browserNV = agent.match(regStr_chrome);
+  }
+  //Safari
+  if (agent.indexOf('safari') > 0 && agent.indexOf('chrome') < 0) {
+    browserNV = agent.match(regStr_saf);
+  }
+  browserNV = browserNV.toString();
+  //other
+  if ('' == browserNV) {
+    browserNV = 'Is not a standard browser';
+  }
+  //Here does not display "/"
+  if (browserNV.indexOf('firefox') != -1 || browserNV.indexOf('chrome') != -1) {
+    browserNV = browserNV.replace('/', '');
+  }
+  //Here does not display space
+  if (browserNV.indexOf('msie') != -1) {
+    //msie replace IE & trim space
+    browserNV = browserNV.replace('msie', 'ie').replace(/\s/g, '');
+  }
+  //return eg:ie9.0 firefox34.0 chrome37.0
+  return browserNV;
+}
+
+export function downloadStringFile(content: string, filename: string) {
+  // Check if running in browser environment
+  if (typeof window === 'undefined' || typeof document === 'undefined') {
+    return;
+  }
+  
+  const element = document.createElement("a");
+  const file = new Blob([content], {type: 'text/plain'});
+  element.href = URL.createObjectURL(file);
+  element.download = filename;
+  document.body.appendChild(element);
+  element.click();
+}