@maketribe/ms-app 3.0.30 → 3.0.32

package/src/core/menu/MenuNode.ts

@@ -0,0 +1,53 @@
+import { PermissionPoint } from "../PermissionPointManager";
+import { Route } from "../../dataview";
+
+interface MenuNodeOptions {
+  id: string;
+  route?: Route | null;
+  iconName: string;
+  title: string;
+  permissionPoints: PermissionPoint[];
+  children: MenuNode[];
+  type: string;
+  parent?: MenuNode | null;
+}
+
+export class MenuNode {
+  id: string;
+
+  iconName: string;
+  title: string;
+  permissionPoints: PermissionPoint[];
+  route: Route | null;
+  type: string;
+  children: MenuNode[];
+  parent: MenuNode | null;
+
+  constructor(options: MenuNodeOptions) {
+    const { id, children, route, iconName, title, permissionPoints, type } =
+      options;
+
+    this.id = id;
+    this.route = route ?? null;
+    this.iconName = iconName;
+    this.type = type;
+    this.title = title;
+    this.children = children;
+    this.parent = options.parent ?? null;
+    this.permissionPoints = permissionPoints;
+  }
+
+  getMenuNodePath(): MenuNode[] {
+    const path: MenuNode[] = [];
+
+    let menuNode: MenuNode | null = this;
+
+    while (menuNode) {
+      path.unshift(menuNode);
+
+      menuNode = menuNode.parent;
+    }
+
+    return path;
+  }
+}

package/src/core/menu/index.ts

@@ -0,0 +1,2 @@
+export * from "./Menu";
+export * from "./MenuNode";

package/src/core/resolver/ITypeResolver.ts

@@ -0,0 +1,5 @@
+export interface ITypeResolver<T> {
+  resolveType(type: string): string;
+
+  resolveItemType(item: T): string;
+}

package/src/core/tabs/Tab.ts

@@ -0,0 +1,59 @@
+import { Disposable, Event } from "@maketribe/utils";
+import { Route } from "../../dataview";
+import type { Tabs } from "./Tabs";
+
+export interface TabOptions {
+  id: string;
+
+  title: string;
+
+  affix?: boolean;
+
+  realRoute: any;
+
+  route: Route;
+
+  tabs: Tabs;
+}
+
+export class Tab extends Disposable {
+  id: string;
+
+  title: string;
+
+  affix: boolean;
+
+  realRoute: any;
+
+  route: Route;
+
+  beforeCloseEvent: Event = this.register(new Event());
+
+  refreshEvent: Event = this.register(new Event());
+
+  beforeSwitchEvent: Event = this.register(new Event());
+
+  tabs: Tabs;
+
+  constructor(options: TabOptions) {
+    super();
+    this.id = options.id;
+    this.title = options.title;
+    this.affix = options.affix ?? false;
+    this.realRoute = options.realRoute;
+    this.route = options.route;
+    this.tabs = options.tabs;
+  }
+
+  getTitle() {
+    return this.title;
+  }
+
+  getID() {
+    return this.id;
+  }
+
+  close() {
+    this.tabs.closeTab(this);
+  }
+}

package/src/core/tabs/Tabs.ts

@@ -0,0 +1,187 @@
+import { Disposable, Event } from "@maketribe/utils";
+import { Tab, TabOptions } from "./Tab";
+import type { UserSession } from "../UserSession";
+
+export class Tabs extends Disposable {
+  userSession: UserSession;
+
+  _tabs: Tab[] = [];
+  _currentTab: Tab | null = null;
+
+  currentTabChangeEvent: Event<{ currentTab: Tab | null }> = this.register(
+    new Event()
+  );
+  tabsChangeEvent: Event<{ tabs: Tab[] }> = this.register(new Event());
+
+  constructor(userSession: UserSession) {
+    super();
+    this.userSession = userSession;
+  }
+
+  init() {
+    const getAffixRoutes = () => {
+      let routes = this.userSession.vueRouter.getRoutes().slice();
+
+      const affixRoutes: any[] = [];
+
+      for (let i = 0; i < routes.length; i++) {
+        const route = routes[i];
+
+        if (route.meta?.affix === true) {
+          affixRoutes.push(route);
+        }
+      }
+
+      return affixRoutes;
+    };
+
+    const getAffixTabs = () => {
+      return getAffixRoutes()
+        .map((affixRoute) => {
+          const route = this.userSession.router.getRouteByName(
+            affixRoute.name as string
+          );
+
+          if (!route) {
+            return null;
+          }
+
+          return this.createTab({
+            id: affixRoute.path,
+            title: route.title,
+            affix: true,
+            route: route,
+            realRoute: affixRoute,
+          });
+        })
+        .filter(Boolean) as Tab[];
+    };
+
+    this.setTabs(getAffixTabs());
+  }
+
+  getTabs() {
+    return this._tabs;
+  }
+
+  getCurrentTab() {
+    return this._currentTab;
+  }
+
+  setCurrentTab(tab: Tab | null) {
+    if (this._currentTab === tab) {
+      return;
+    }
+
+    this._currentTab = tab;
+
+    this.currentTabChangeEvent.emit({ currentTab: tab });
+  }
+
+  getTabByID(id: string) {
+    return this._tabs.find((tab) => tab.id === id) ?? null;
+  }
+
+  createTab(options: Omit<TabOptions, "tabs">) {
+    return this.register(new Tab({ ...options, tabs: this }));
+  }
+
+  setTabs(tabs: Tab[]): void {
+    this._tabs = tabs;
+
+    this.tabsChangeEvent.emit({ tabs });
+  }
+
+  switchTab(tab: Tab | null) {
+    // TODO 暂时用不到Tab
+
+    // if (
+    //   this.getCurrentTab()?.realRoute?.fullPath === tab?.realRoute?.fullPath
+    // ) {
+    //   return;
+    // }
+
+    this.setCurrentTab(tab);
+    return;
+
+    // if (!tab) {
+    //   this.setCurrentTab(null);
+    //   return;
+    // }
+
+    // let _tab = this._tabs.find((item) => item.getID() === tab.getID());
+
+    // if (!_tab) {
+    //   this.setTabs([...this.getTabs(), tab]);
+    // }
+
+    // this.setCurrentTab(tab);
+  }
+
+  findTabByID(id: Tab["id"]) {
+    return this.getTabs().find((tab) => tab.id === id) ?? null;
+  }
+
+  async closeTab(tab: Tab) {
+    if ((await tab.beforeCloseEvent.emitAsync()) === false) {
+      return;
+    }
+
+    const tabItemList = this.getTabs().slice();
+
+    if (this.getCurrentTab()?.getID() !== tab.getID()) {
+      this.setTabs(tabItemList.filter((item) => item.getID() !== tab.getID()));
+
+      return;
+    }
+
+    const index = tabItemList.findIndex((item) => item.getID() === tab.getID());
+
+    if (index === -1) {
+      return;
+    }
+
+    const deleteTab = tabItemList[index];
+    deleteTab.dispose();
+
+    tabItemList.splice(index, 1);
+    this.setTabs(tabItemList);
+
+    this.setCurrentTab(this._tabs[this._tabs.length - 1] ?? null);
+  }
+
+  closeAll() {
+    const affixTabs = this.getTabs().filter((tab) => tab.affix);
+
+    if (affixTabs.length) {
+      this.setTabs(affixTabs);
+      this.setCurrentTab(affixTabs[0]);
+      return;
+    }
+
+    this.setTabs([this.getCurrentTab() ?? this.getTabs()[0]]);
+    this.setCurrentTab(this.getTabs()[0]);
+  }
+
+  closeOther() {
+    const currentTab = this.getCurrentTab();
+
+    if (!currentTab) {
+      return;
+    }
+
+    const affixTabs = this.getTabs().filter((tab) => tab.affix);
+
+    if (affixTabs.length) {
+      if (affixTabs.find((item) => item.getID() === currentTab.getID())) {
+        this.setTabs(affixTabs);
+      } else {
+        this.setTabs([...affixTabs, currentTab]);
+      }
+
+      return;
+    }
+
+    this.setTabs([currentTab]);
+  }
+}

package/src/core/tabs/index.ts

@@ -0,0 +1,2 @@
+export * from "./Tab";
+export * from "./Tabs";

package/src/dataview/config/ConfigForm.ts

@@ -0,0 +1,142 @@
+import {
+  DataForm,
+  DataFormOptions,
+  FormColumn,
+  IComponents,
+} from "@maketribe/dm";
+import { defineDataForm } from "../../define-data-form";
+import { ConfigComponents, ITypeResolver } from "../../core";
+
+export type Config<T = any> = {
+  id: string;
+  key: string;
+  type: string;
+  value: T;
+};
+
+export type ConfigFormOptions = DataFormOptions & {
+  typeResolver?: ITypeResolver<Config>;
+  configComponent?: IComponents;
+};
+
+export class ConfigForm
+  extends DataForm<Config>
+  implements ITypeResolver<Config>
+{
+  configComponent: IComponents;
+
+  constructor(options: ConfigFormOptions = {}) {
+    super({ name: "ms-cfg", ...options });
+
+    this.configComponent = options.configComponent ?? new ConfigComponents();
+  }
+
+  protected async initialize() {
+    await super.initialize();
+
+    const defaultType = "string";
+    this.setColumns([
+      new FormColumn({ name: "id", label: "编号" }),
+      new FormColumn({ name: "key", label: "配置键", required: true }),
+      new FormColumn({
+        name: "type",
+        label: "类型",
+        componentInfo: "MKFormDataSelect",
+        defaultValue: defaultType,
+        required: true,
+        componentProps: {
+          options: [
+            { value: "string", label: "字符串" },
+            { value: "int", label: "整数" },
+            { value: "json", label: "JSON" },
+          ],
+          onChange: () => {
+            this.handleTypeChange(this.data);
+
+            if (this.data) {
+              this.data.value = null;
+            }
+          },
+        },
+      }),
+      new FormColumn({
+        name: "value",
+        label: "配置值",
+        required: true,
+        defaultValue: null,
+        rules: [
+          {
+            validator: (rule, value, callback) => {
+              if (this.data?.type === "json") {
+                try {
+                  JSON.parse(value);
+                } catch (e) {
+                  callback(new Error("JSON格式错误"));
+                }
+              }
+
+              callback();
+            },
+          },
+        ],
+        componentInfo: this.resolveType(defaultType),
+      }),
+      new FormColumn({
+        name: "memo",
+        label: "备注",
+        defaultValue: "",
+      }),
+    ]);
+
+    this.dataChangeEvent.on(({ data }) => {
+      this.handleTypeChange(data);
+    });
+  }
+
+  handleTypeChange(data: Config | null) {
+    if (!data) {
+      return;
+    }
+
+    const valueFormColumn = this.getColumn("value")!;
+    valueFormColumn.componentInfo =
+      this.configComponent.resolveComponent(this.resolveItemType(data!)) ||
+      this.configComponent.resolveComponent("MKFormInput")!;
+  }
+
+  formatItem(item: Config): Config {
+    let value = item.value;
+
+    if (item.type !== "json") {
+      try {
+        value = JSON.parse(item.value);
+      } catch (e) {}
+    }
+
+    return { ...item, value };
+  }
+
+  formatSubmitData(data: any) {
+    return {
+      ...data,
+      value: data.type === "json" ? data.value : JSON.stringify(data.value),
+    };
+  }
+
+  resolveType(type: string) {
+    switch (type) {
+      case "int":
+        return "MKConfigInputNumber";
+      case "json":
+        return "MKConfigJsonEditor";
+      default:
+        return "MKConfigInput";
+    }
+  }
+
+  resolveItemType(config: Config) {
+    return this.resolveType(config.type);
+  }
+}
+
+defineDataForm(ConfigForm);

package/src/dataview/config/ConfigTable.ts

@@ -0,0 +1,72 @@
+import { Where } from "@maketribe/request";
+import {
+  DataTable,
+  DataTableOptions,
+  TableColumn,
+  TableActionColumn,
+} from "@maketribe/dm";
+import { Config } from "./ConfigForm";
+import { R, ResponseConfig } from "@maketribe/request";
+import { defineDataTable } from "../../define-data-table";
+
+export class ConfigTable extends DataTable<Config> {
+  private static _instance: ConfigTable | null = null;
+
+  static get instance(): ConfigTable {
+    if (!ConfigTable._instance) {
+      ConfigTable._instance = new ConfigTable();
+      ConfigTable._instance.dataFilter.setReady();
+    }
+
+    return ConfigTable._instance;
+  }
+
+  constructor(options: DataTableOptions = {}) {
+    super({ name: "ms-cfg", ...options });
+  }
+
+  protected async initialize() {
+    await super.initialize();
+
+    this.setColumns([
+      new TableColumn({ name: "key", label: "配置键" }),
+      new TableColumn({ name: "memo", label: "备注" }),
+      new TableActionColumn(),
+    ]);
+  }
+
+  formatItem(item: Config): Config {
+    let value = item.value;
+
+    try {
+      value = JSON.parse(value);
+    } catch (e) {}
+
+    return { ...item, value };
+  }
+
+  static async loadConfig<T = any>(
+    key: string
+  ): Promise<ResponseConfig<R<Config<T>>>> {
+    const where = new Where();
+
+    where.addCondition("key", "=", key);
+
+    const dataViewRequest = ConfigTable.instance.dataViewRequest;
+    const response = await dataViewRequest.allList({
+      data: { condition: where },
+    });
+
+    return {
+      ...response,
+      data: {
+        ...response.data,
+        data: response.data.data?.[0] ?? null,
+      },
+    };
+  }
+}
+
+(window as any).ConfigTable = ConfigTable;
+
+defineDataTable(ConfigTable);

package/src/dataview/config/index.ts

@@ -0,0 +1,2 @@
+export * from "./ConfigForm";
+export * from "./ConfigTable";

package/src/dataview/deny-ip-access-list/DenyIPAccessListForm.ts

@@ -0,0 +1,33 @@
+import { DataForm, FormColumn } from "@maketribe/dm";
+import { defineDataForm } from "../../define-data-form";
+import { IP_PATTERN } from "../../constants";
+
+export type DenyIPAccessList = {
+  id: string;
+  ipAddress: string;
+};
+
+export class DenyIPAccessListForm<T = DenyIPAccessList, F = T> extends DataForm<
+  T,
+  F
+> {
+  constructor(options = {}) {
+    super({ name: "ms-deny-access-ip-list", ...options });
+  }
+
+  async initialize() {
+    await super.initialize();
+
+    this.setColumns([
+      new FormColumn({ name: "id", label: "编号" }),
+      new FormColumn({
+        name: "ipAddress",
+        label: "IP地址",
+        required: true,
+        rules: [{ message: "请输入正确的IP", pattern: IP_PATTERN }],
+      }),
+    ]);
+  }
+}
+
+defineDataForm(DenyIPAccessListForm);

package/src/dataview/deny-ip-access-list/DenyIPAccessListTable.ts

@@ -0,0 +1,84 @@
+import {
+  ActionButton,
+  DataTable,
+  DeleteButton,
+  EditButton,
+  TableActionColumn,
+  TableColumn,
+  Messager,
+} from "@maketribe/dm";
+import { defineDataTable } from "../../define-data-table";
+import { DenyIPAccessList } from "./DenyIPAccessListForm";
+
+export class DenyIPAccessListTable<
+  T = DenyIPAccessList,
+  F = T
+> extends DataTable<T, F> {
+  constructor(options = {}) {
+    super({ name: "ms-deny-access-ip-list", ...options });
+  }
+
+  async initialize() {
+    await super.initialize();
+
+    this.setColumns([
+      new TableColumn({ name: "ipAddress", label: "IP地址" }),
+      new TableColumn({ name: "createdAt", label: "创建时间" }),
+      new TableActionColumn({
+        width: "180px",
+        buttons: [
+          new EditButton(),
+          new DeleteButton({ label: "移除" }),
+          new ActionButton({
+            label: "禁用",
+            type: "danger",
+            handler: async (row) => {
+              this.loadingManager.startLoading();
+
+              const result = await this.dataViewRequest.callDVRequest({
+                action: `disable/${row.id}`,
+              });
+
+              this.loadingManager.completeLoading();
+              if (result.data.code !== 200) {
+                Messager.instance.error({
+                  message: result.data.msg || "禁用失败",
+                });
+                return;
+              }
+              Messager.instance.success({ message: "禁用成功" });
+
+              this.load();
+            },
+            predicate: (row) => row.valid === 1,
+          }),
+          new ActionButton({
+            label: "启用",
+            type: "success",
+            handler: async (row) => {
+              this.loadingManager.startLoading();
+
+              const result = await this.dataViewRequest.callDVRequest({
+                action: `enable/${row.id}`,
+              });
+
+              this.loadingManager.completeLoading();
+              if (result.data.code !== 200) {
+                Messager.instance.error({
+                  message: result.data.msg || "启用失败",
+                });
+                return;
+              }
+              Messager.instance.success({ message: "启用成功" });
+
+              this.load();
+            },
+            predicate: (row) => row.valid === 0,
+          }),
+        ],
+      }),
+    ]);
+  }
+}
+
+defineDataTable(DenyIPAccessListTable);

package/src/dataview/deny-ip-access-list/index.ts

@@ -0,0 +1,2 @@
+export * from "./DenyIPAccessListForm";
+export * from "./DenyIPAccessListTable";

package/src/dataview/department/DepartmentForm.ts

@@ -0,0 +1,41 @@
+import { DataForm, DataFormOptions, FormColumn } from "@maketribe/dm";
+import { defineDataForm } from "../../define-data-form";
+
+export type Department = {
+  id: string;
+  name: string;
+  pid: string | null;
+};
+
+export class DepartmentForm extends DataForm<Department> {
+  constructor(options: DataFormOptions = {}) {
+    super({ name: "ms-dept", ...options });
+  }
+
+  protected async initialize() {
+    await super.initialize();
+
+    this.setColumns([
+      new FormColumn({ name: "id", label: "编号" }),
+      new FormColumn({ name: "name", label: "名称", required: true }),
+      new FormColumn({ name: "pid", label: "父部门ID", visible: false }),
+    ]);
+  }
+
+  formatSubmitData(data: any) {
+    return {
+      ...data,
+      pid: data.pid || null,
+    };
+  }
+
+  formatItem(item: Department): Department {
+    return {
+      id: item.id,
+      name: item.name || "",
+      pid: item.pid || null,
+    };
+  }
+}
+
+defineDataForm(DepartmentForm);