@oinone/kunlun-vue-admin-layout 6.2.0

package/src/component/user/DefaultUser.vue

@@ -0,0 +1,92 @@
+<template>
+  <a-dropdown :trigger="['click']" placement="bottomLeft" overlayClassName="top-bar-common-dropdown">
+    <div class="k-user">
+      <img :src="pamirsUser.avatarUrl || genStaticPath('man_1651543408256.png')" />
+      <span v-if="hasCurrentUser">{{ pamirsUser.nickname || pamirsUser.name || pamirsUser.realname }}</span>
+      <caret-down-outlined :style="{ fontSize: '12px', color: 'var(--oio-icon-color)' }" />
+    </div>
+    <template #overlay>
+      <a-menu class="k-user-dropdown">
+        <a-menu-item @click="onUserCenter">
+          <div class="menu-user">
+            <img :src="pamirsUser.avatarUrl || genStaticPath('man_1651543408256.png')" />
+            <span v-if="hasCurrentUser">{{ pamirsUser.nickname || pamirsUser.name || pamirsUser.realname }}</span>
+          </div>
+        </a-menu-item>
+
+        <div class="k-user-dropdown-group" v-for="(item, index) in actionGroups" :key="index">
+          <a-menu-item
+            class="k-user-dropdown-action"
+            v-for="action in item.actions"
+            :key="action.id"
+            @click="executeAction(action)"
+          >
+            <oio-icon
+              v-if="action.attributes"
+              :icon="action.attributes.icon || 'oinone-yingyong'"
+              :size="action.attributes.size || 14"
+              :style="{ 'margin-right': '12px', color: action.attributes.color || 'var(--user-dropdown-icon-color)' }"
+            />
+            {{ $translate(action.displayName) }}
+          </a-menu-item>
+        </div>
+      </a-menu>
+    </template>
+  </a-dropdown>
+</template>
+<script lang="ts">
+import { CaretDownOutlined } from '@ant-design/icons-vue';
+import { UserInfo } from '@oinone/kunlun-engine';
+
+import { OioIcon } from '@oinone/kunlun-vue-ui-antd';
+import { computed, defineComponent, PropType } from 'vue';
+
+export default defineComponent({
+  name: 'DefaultUser',
+  inheritAttrs: false,
+  components: {
+    CaretDownOutlined,
+    OioIcon
+  },
+  props: {
+    userInfo: {
+      type: Object as PropType<UserInfo>,
+      default: () => ({})
+    },
+    executeAction: {
+      type: Function,
+      required: true
+    },
+    genStaticPath: {
+      type: Function,
+      required: true
+    }
+  },
+  setup(props) {
+    const pamirsUser = computed(() => (props.userInfo ? props.userInfo.pamirsUser || {} : {}));
+
+    const hasCurrentUser = computed(() => {
+      return !!props.userInfo?.pamirsUser;
+    });
+
+    const userCenterAction = computed(() => {
+      return props.userInfo.userAvatarAction;
+    });
+
+    const actionGroups = computed(() => {
+      if (!props.userInfo) {
+        return [];
+      }
+      return props.userInfo.actionGroups || [];
+    });
+
+    const onUserCenter = () => {
+      if (userCenterAction.value) {
+        props.executeAction!(userCenterAction.value);
+      }
+    };
+
+    return { actionGroups, pamirsUser, onUserCenter, hasCurrentUser };
+  }
+});
+</script>

package/src/component/user/UserWidget.ts

@@ -0,0 +1,129 @@
+import {
+  baseActionTokenSymbol,
+  ClearCache,
+  executeServerAction,
+  executeUrlAction,
+  executeViewAction,
+  getDefaultBrowser,
+  isRuntimeClientAction,
+  isRuntimeServerAction,
+  isRuntimeUrlAction,
+  isRuntimeViewAction,
+  MultiTabsRuntimeManifestMergedConfigManager,
+  OioProvider,
+  PamirsUser,
+  ReloadMaskCallChainingParameters,
+  RuntimeAction,
+  ServerActionCache,
+  UrlActionCache,
+  UserInfo,
+  ViewActionCache
+} from '@oinone/kunlun-engine';
+import { GlobalConfig, IURLAction, ViewActionTarget } from '@oinone/kunlun-meta';
+import { setSessionPath, useSessionPath } from '@oinone/kunlun-request';
+import { Matched, Router, useMatched } from '@oinone/kunlun-router';
+import { SPI, SPIOperator } from '@oinone/kunlun-spi';
+import { useRouter } from '@oinone/kunlun-vue-router';
+import { Widget, WidgetSubjection } from '@oinone/kunlun-vue-widget';
+import { MaskWidget } from '../../basic';
+import { TopBarService } from '../../service';
+import { pamirsUserSymbol } from '../../typing';
+import DefaultUser from './DefaultUser.vue';
+
+@SPI.ClassFactory(MaskWidget.Token({ widget: 'user' }))
+export class UserWidget extends MaskWidget {
+  protected router!: Router;
+
+  protected matched!: Matched;
+
+  @Widget.SubContext(pamirsUserSymbol)
+  private pamirsUser$!: WidgetSubjection<PamirsUser>;
+
+  public initialize(props) {
+    super.initialize(props);
+    this.setComponent(DefaultUser);
+    return this;
+  }
+
+  @Widget.Reactive()
+  protected userInfo: UserInfo | undefined;
+
+  @Widget.Method()
+  public async executeAction(action: RuntimeAction) {
+    const { model, name } = action;
+
+    if (isRuntimeViewAction(action)) {
+      const viewAction = await useSessionPath(action.sessionPath, () => ViewActionCache.get(model, name));
+      if (viewAction) {
+        if (MultiTabsRuntimeManifestMergedConfigManager.isEnabled() && viewAction.target === ViewActionTarget.Router) {
+          viewAction.target = ViewActionTarget.OpenWindow;
+        }
+        executeViewAction(viewAction, this.router, this.matched);
+      }
+    } else if (isRuntimeServerAction(action)) {
+      const serverAction = await useSessionPath(action.sessionPath, () => ServerActionCache.get(model, name));
+      if (serverAction) {
+        await executeServerAction(serverAction, {});
+      }
+      if (name === 'logout') {
+        this.logout();
+      }
+    } else if (isRuntimeUrlAction(action)) {
+      const urlAction = await useSessionPath(action.sessionPath, () => UrlActionCache.get(model, name));
+      await executeUrlAction(urlAction as unknown as IURLAction);
+    } else if (isRuntimeClientAction(action)) {
+      const actionOptions = {
+        actionType: action.actionType,
+        model: action.model,
+        name: action.fun,
+        widget: action.widget
+      };
+
+      // eslint-disable-next-line @typescript-eslint/no-shadow
+      const Widget = SPIOperator.selector(baseActionTokenSymbol, actionOptions) as any;
+      const actionWidget = new Widget();
+      actionWidget.initialize({ action });
+      await actionWidget.click();
+    }
+  }
+
+  public logout() {
+    const loginPath = GlobalConfig.getConfigByName('login') as string;
+    let url = loginPath;
+    if (loginPath.startsWith('/')) {
+      url = loginPath.slice(1);
+    }
+    OioProvider.setBrowserConfig(getDefaultBrowser());
+    setSessionPath(undefined);
+    ClearCache.clear();
+    this.router.push({ segments: [{ path: url }] });
+    OioProvider.refreshSystemMajorConfig();
+  }
+
+  protected fetchUserInfo(): Promise<UserInfo> {
+    return TopBarService.getUserInfo();
+  }
+
+  protected async initUserInfo(): Promise<void> {
+    if (!this.userInfo) {
+      const data = await this.fetchUserInfo();
+      this.userInfo = data;
+    }
+  }
+
+  protected reloadMaskProcess(reloadParameters: ReloadMaskCallChainingParameters) {
+    return this.initUserInfo();
+  }
+
+  protected $$mounted() {
+    super.$$mounted();
+    this.matched = useMatched().matched;
+    this.router = useRouter().router;
+
+    this.pamirsUser$.subscribe((v) => {
+      if (v && Object.keys(v).length) {
+        this.userInfo!.pamirsUser = JSON.parse(JSON.stringify(v));
+      }
+    });
+  }
+}

package/src/component/user/index.ts

@@ -0,0 +1 @@
+export * from './UserWidget';

package/src/config/DebugConfig.ts

@@ -0,0 +1,30 @@
+import { ConfigHelper, EnabledConfig } from '@oinone/kunlun-engine';
+import { RuntimeConfig, RuntimeConfigOptions } from '@oinone/kunlun-meta';
+
+/**
+ * 调试配置
+ */
+export interface DebugConfig extends RuntimeConfigOptions, EnabledConfig {
+  /**
+   * 是否启用
+   */
+  enabled?: boolean;
+}
+
+export class DebugConfigManager {
+  private constructor() {
+    // reject create object
+  }
+
+  public static getConfig(): DebugConfig {
+    return ConfigHelper.getConfig(RuntimeConfig.getConfig('debug'));
+  }
+
+  public static isEnabled(): boolean {
+    let { enabled } = DebugConfigManager.getConfig();
+    if (enabled == null) {
+      enabled = true;
+    }
+    return enabled;
+  }
+}

package/src/config/PartnerSwitcherConfig.ts

@@ -0,0 +1,30 @@
+import { ConfigHelper, EnabledConfig } from '@oinone/kunlun-engine';
+import { RuntimeConfig, RuntimeConfigOptions } from '@oinone/kunlun-meta';
+
+/**
+ * 合作伙伴切换配置
+ */
+export interface PartnerSwitcherConfig extends RuntimeConfigOptions, EnabledConfig {
+  /**
+   * 是否启用
+   */
+  enabled?: boolean;
+}
+
+export class PartnerSwitcherConfigManager {
+  private constructor() {
+    // reject create object
+  }
+
+  public static getConfig(): PartnerSwitcherConfig {
+    return ConfigHelper.getConfig(RuntimeConfig.getConfig('partnerSwitcher'));
+  }
+
+  public static isEnabled(): boolean {
+    let { enabled } = PartnerSwitcherConfigManager.getConfig();
+    if (enabled == null) {
+      enabled = false;
+    }
+    return enabled;
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,2 @@
+export * from './DebugConfig';
+export * from './PartnerSwitcherConfig';

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from './config';
+export * from './spi';
+export * from './tags';
+
+export * from './basic';
+export * from './component';
+export * from './service';
+export * from './template';
+export * from './typing';
+export * from './util';
+export * from './utils';

package/src/service/index.ts

@@ -0,0 +1,5 @@
+export * from './menu-service';
+export * from './message-service';
+export * from './module-service';
+export * from './top-bar-service';
+export * from './user-service';

package/src/service/menu-service.ts

@@ -0,0 +1,105 @@
+import { ModuleCache } from '@oinone/kunlun-engine';
+import { IMenu } from '@oinone/kunlun-meta';
+import { Comparator, TreeHelper, TreeNode } from '@oinone/kunlun-shared';
+import { MenuUrlParameters, RuntimeMenu } from '../typing';
+
+const defaultCompareFunction: Comparator<TreeNode<RuntimeMenu>> = (a, b) => {
+  const ap = a.value?.priority;
+  const bp = b.value?.priority;
+  if (ap == null || bp == null) {
+    return 0;
+  }
+  return Number(ap) - Number(bp);
+};
+
+export class MenuService {
+  public static async queryMenus(moduleName: string): Promise<IMenu[]> {
+    const module = await ModuleCache.get(moduleName);
+    if (module) {
+      return module.allMenus || [];
+    }
+    return [];
+  }
+
+  public static convert(menus: IMenu[]): TreeNode<RuntimeMenu>[] {
+    const nodes: TreeNode<RuntimeMenu>[] = TreeHelper.convert(
+      menus,
+      (v) => v.name,
+      (v) => v.parentName,
+      (v) => {
+        const runtimeValue = v as RuntimeMenu;
+        runtimeValue.title = v.displayName || v.name;
+        return runtimeValue;
+      }
+    );
+    return MenuService.clearInvalidNodes(nodes);
+  }
+
+  private static clearInvalidNodes(nodes: TreeNode<RuntimeMenu>[]): TreeNode<RuntimeMenu>[] {
+    return nodes.filter((node) => {
+      if (node.value) {
+        node.children = MenuService.clearInvalidNodes(node.children);
+        return true;
+      }
+      return false;
+    });
+  }
+
+  public static sort(nodes: TreeNode<RuntimeMenu>[]): void {
+    nodes.sort(defaultCompareFunction);
+    for (const node of nodes) {
+      MenuService.sort(node.children || []);
+    }
+  }
+
+  public static findSelectedMenuItemByAction(
+    nodes: TreeNode<RuntimeMenu>[],
+    action: string
+  ): TreeNode<RuntimeMenu> | undefined {
+    for (const node of nodes) {
+      const { children, value } = node;
+      const key = value?.viewAction?.name;
+      if (key && key === action) {
+        return node;
+      }
+      if (children && children.length) {
+        const selectedMenu = MenuService.findSelectedMenuItemByAction(children, action);
+        if (selectedMenu) {
+          return selectedMenu;
+        }
+      }
+    }
+  }
+
+  public static findSelectedMenuItemByKey(
+    nodes: TreeNode<RuntimeMenu>[],
+    key: string
+  ): TreeNode<RuntimeMenu> | undefined {
+    for (const node of nodes) {
+      const { key: targetKey, children } = node;
+      if (targetKey === key) {
+        return node;
+      }
+      if (children && children.length) {
+        const selectedMenu = MenuService.findSelectedMenuItemByKey(children, key);
+        if (selectedMenu) {
+          return selectedMenu;
+        }
+      }
+    }
+  }
+
+  public static generatorMenuUrlParameters(selected: TreeNode<RuntimeMenu>): MenuUrlParameters {
+    const selectedKeys: string[] = [selected.key];
+    let openKeys: string[] = [];
+    let currentNode: TreeNode<RuntimeMenu> | undefined = selected;
+    while (currentNode) {
+      openKeys = [currentNode.key, ...openKeys];
+      currentNode = currentNode.parent;
+    }
+    return {
+      selectedKeys,
+      openKeys
+    };
+  }
+}

package/src/service/message-service.ts

@@ -0,0 +1,65 @@
+import { SYSTEM_MODULE_NAME } from '@oinone/kunlun-meta';
+import { gql } from '@oinone/kunlun-request';
+import { http } from '@oinone/kunlun-service';
+
+export interface PamirsMessage {
+  id: string;
+  messageType: string;
+  createDate: string;
+  message: { body: string; id: string; resId: string; workFlowTaskType: string };
+}
+
+export class MessageService {
+  public static async unreadWorkflowList() {
+    const body = gql`
+      {
+        unreadMessageQuery {
+          unreadWorkflowList(data: {}) {
+            id
+            messageType
+            createDate
+            message {
+              body
+              name
+              extendIcon
+              id
+              resId
+              workFlowTaskType
+              messageType
+            }
+          }
+        }
+      }
+    `;
+    const result = await http.query<PamirsMessage[]>(SYSTEM_MODULE_NAME.MESSAGE, body);
+    return result.data.unreadMessageQuery.unreadWorkflowList;
+  }
+
+  public static async readWorkflowMessage(id: string) {
+    const query = gql`
+      {
+        unreadMessageQuery {
+          readWorkflowMessage(data: { id: ${id} }) {
+            id
+            messageType
+            createDate
+          }
+        }
+      }
+    `;
+    const result = await http.query(SYSTEM_MODULE_NAME.MESSAGE, query);
+    return result.data.unreadMessageQuery.readWorkflowMessage;
+  }
+
+  public static async unreadCount() {
+    const body = gql`
+      {
+        unreadMessageQuery {
+          unreadCount(data: {})
+        }
+      }
+    `;
+    const result = await http.query<number>(SYSTEM_MODULE_NAME.MESSAGE, body);
+    return result.data.unreadMessageQuery.unreadCount;
+  }
+}

package/src/service/module-service.ts

@@ -0,0 +1,69 @@
+import {
+  ClearCache,
+  ModelCache,
+  QueryPageResult,
+  RuntimeViewAction
+} from '@oinone/kunlun-engine';
+import { IModule, SYSTEM_MODULE_NAME } from '@oinone/kunlun-meta';
+import { gql } from '@oinone/kunlun-request';
+import { http } from '@oinone/kunlun-service';
+
+export class ModuleService {
+  public static apps: IModule[] = [];
+
+  public static async queryApplications(): Promise<IModule[]> {
+    if (ModuleService.apps.length) {
+      return ModuleService.apps;
+    }
+
+    ClearCache.register(() => {
+      ModuleService.apps = [];
+    });
+    const model = await ModelCache.get('apps.AppsManagementModule');
+    const bindUrlFieldExist = (model?.modelFields ?? []).filter(it => it.data === 'urlHomePage').length > 0;
+
+    const body = gql`
+      {
+        appSwitcherModuleProxyQuery {
+          queryPage(
+            page: { currentPage: 1, size: -1, sort: { orders: { field: "priority", direction: ASC } } }
+            queryWrapper: {}
+          ) {
+            content {
+              id
+              homepageViewId
+              homePageModel
+              homepageViewSystemSource
+              displayName
+              name
+              logo
+              like
+              systemSource
+              category
+              module
+              state
+              priority
+              application
+              latestVersion
+              platformVersion
+              ${bindUrlFieldExist ? 'urlHomePage {\ntarget\nurl\n}' : ''}
+            }
+            size
+            totalPages
+            totalElements
+          }
+        }
+      }
+    `;
+    const res = await http.query<QueryPageResult<IModule>>(SYSTEM_MODULE_NAME.BASE, body, {}, {batch: true});
+    // fixme @zbh 20230417 后端排序未生效
+    return (ModuleService.apps = res.data.appSwitcherModuleProxyQuery.queryPage.content.sort(
+      (a, b) => Number(a.priority) - Number(b.priority)
+    ));
+  }
+
+  public static generatorViewTitle(action: RuntimeViewAction): string {
+    const {resView} = action;
+    return action.title || resView?.title || resView?.name || '未命名';
+  }
+}

package/src/service/top-bar-service.ts

@@ -0,0 +1,144 @@
+import { ClearCache, CurrentLanguage, UserInfo, UserLang } from '@oinone/kunlun-engine';
+import { MetadataFragment, SYSTEM_MODULE_NAME } from '@oinone/kunlun-meta';
+import { gql } from '@oinone/kunlun-request';
+import { http } from '@oinone/kunlun-service';
+import { RuntimeLanguage } from '@oinone/kunlun-vue-ui-common';
+
+export class TopBarService {
+  private static userInfoCache: Promise<UserInfo> | null | undefined;
+
+  static {
+    ClearCache.register(() => {
+      TopBarService.userInfoCache = null;
+    });
+  }
+
+  public static getUserInfo(): Promise<UserInfo> {
+    if (TopBarService.userInfoCache) {
+      return TopBarService.userInfoCache;
+    }
+    TopBarService.userInfoCache = TopBarService.queryUserInfo();
+    return TopBarService.userInfoCache;
+  }
+
+  public static async getCurrentLang(): Promise<UserLang | undefined> {
+    try {
+      return await CurrentLanguage.get();
+    } catch (error) {
+      return undefined;
+    }
+  }
+
+  public static async queryUserInfo(): Promise<UserInfo> {
+    const body = gql`
+      {
+        topBarUserBlockQuery {
+          construct(data: {}) {
+            userAvatarAction {
+              ...Action
+            }
+            actionGroups {
+              actions {
+                ...Action
+              }
+            }
+            pamirsUser {
+              name
+              nickname
+              realname
+              id
+              userType
+              birthday
+              gender
+              phone
+              idCard
+              contactPhone
+              contactEmail
+              avatarBig {
+                name
+                id
+                url
+              }
+              avatarUrl
+              lang {
+                code
+                isoCode
+                active
+                installState
+                name
+                id
+              }
+              email
+            }
+          }
+        }
+      }
+
+      ${MetadataFragment.Action}
+    `;
+    try {
+      const res = await http.mutate<UserInfo>(SYSTEM_MODULE_NAME.USER, body);
+      return res.data.topBarUserBlockQuery.construct;
+    } catch (e) {
+      console.error('error query user info.', e);
+      return {} as UserInfo;
+    }
+  }
+
+  public static async queryLanguageList(): Promise<RuntimeLanguage[]> {
+    const body = `
+      {
+        resourceLangQuery {
+          queryListByWrapper(queryWrapper: { rsql: "active == 'ACTIVE' and installState == true" }) {
+            id
+            name
+            active
+            installState
+            code
+            isoCode
+          }
+        }
+      }
+    `;
+    try {
+      const res = await http.query<RuntimeLanguage[]>(SYSTEM_MODULE_NAME.RESOURCE, body);
+      return res.data.resourceLangQuery.queryListByWrapper;
+    } catch (e) {
+      console.error('error query language list.', e);
+      return [];
+    }
+  }
+
+  public static async activeLang(id: string) {
+    const body = gql`
+    mutation {
+        topBarLangTransientModelMutation {
+          activeLang(topBarLangTransientModel: { id: ${id} }) {
+            id
+            langList {
+              groupingRule
+              name
+              timezoneType
+              thousandsSep
+              installState
+              id
+              decimalPoint
+              timeFormat
+              calendarType
+              writeDate
+              isoCode
+              weekStart
+              dateFormat
+              active
+              code
+              iconId
+              direction
+            }
+          }
+        }
+    }
+    `;
+    const res = await http.mutate(SYSTEM_MODULE_NAME.USER, body);
+    return res.data.topBarLangTransientModelMutation.activeLang;
+  }
+}