@oinone/kunlun-vue-admin-layout 6.2.0

package/src/component/notification/NotificationWidget.ts

@@ -0,0 +1,332 @@
+import { SPI } from '@oinone/kunlun-spi';
+import { Widget } from '@oinone/kunlun-vue-widget';
+import {
+  IResourceDateTimeFormat,
+  RedirectTargetEnum,
+  executeViewAction,
+  queryResourceDateTimeFormat
+} from '@oinone/kunlun-engine';
+import { getModel } from '@oinone/kunlun-service';
+import {
+  CastHelper,
+  DateUtil,
+  defaultDateFormatKey,
+  defaultFormat,
+  defaultTimeFormatKey,
+  ObjectUtils
+} from '@oinone/kunlun-shared';
+import { isDev } from '@oinone/kunlun-router';
+import { MaskWidget } from '../../basic';
+import { MessageService, PamirsMessage } from '../../service';
+import DefaultNotification from './DefaultNotification.vue';
+
+type ReturnBeforeClick = (message, messageInfo) => Promise<Boolean | null | undefined>;
+
+enum BeforeClickMapName {
+  wait = 'wait',
+  copy = 'copy',
+  write = 'write',
+  mail = 'mail'
+}
+
+type BeforeClickMapKey = keyof typeof BeforeClickMapName;
+
+export enum NotificationTypeEnum {
+  WORKFLOW = 'WORKFLOW',
+  NOTIFICATION = 'NOTIFICATION',
+  COPY = 'COPY'
+}
+
+@SPI.ClassFactory(MaskWidget.Token({ widget: 'notification' }))
+export class NotificationWidget extends MaskWidget {
+  public initialize(props) {
+    super.initialize(props);
+    this.setComponent(DefaultNotification);
+    return this;
+  }
+
+  public async getCopyAction() {
+    return {
+      name: 'workflow_detail',
+      title: '查看工作流用户任务待办',
+      displayName: '查看',
+      actionType: 'VIEW',
+      target: 'ROUTER',
+      viewType: 'DETAIL',
+      contextType: 'SINGLE',
+      bindingType: ['TABLE'],
+      model: 'workbench.WorkBenchWorkflowUserTaskCopy',
+      resModel: 'workbench.WorkBenchWorkflowUserTaskCopy',
+      moduleName: 'workflow',
+      resModule: 'workflow',
+      resModuleName: 'workflow',
+      priority: 100,
+      sessionPath: '/workflow/WorkflowMenus_WorkBenchMenu_CopyUserTaskMenu'
+    };
+  }
+
+  public async getWaitAction() {
+    return {
+      name: 'workflow_wait',
+      title: '审批工作流用户任务待办',
+      displayName: '审批',
+      actionType: 'VIEW',
+      target: 'ROUTER',
+      viewType: 'FORM',
+      contextType: 'SINGLE',
+      bindingType: ['TABLE'],
+      model: 'workbench.WorkBenchWorkflowUserTaskActive',
+      resModel: 'workbench.WorkBenchWorkflowUserTaskActive',
+      invisible: "!(activeRecord.taskType == 'APPROVE' && activeRecord.status == 'ACTIVE')",
+      moduleName: 'workflow',
+      resModule: 'workflow',
+      resModuleName: 'workflow',
+      priority: 100,
+      sessionPath: '/workflow/WorkflowMenus_WorkBenchMenu_ActiveUserTaskMenu'
+    };
+  }
+
+  public async getWriteAction() {
+    return {
+      name: 'workflow_write',
+      title: '填写工作流用户任务待办',
+      displayName: '填写',
+      actionType: 'VIEW',
+      target: 'ROUTER',
+      viewType: 'FORM',
+      contextType: 'SINGLE',
+      bindingType: ['TABLE'],
+      model: 'workbench.WorkBenchWorkflowUserTaskActive',
+      resModel: 'workbench.WorkBenchWorkflowUserTaskActive',
+      invisible: "!(activeRecord.taskType == 'WRITE' && activeRecord.status == 'ACTIVE')",
+      moduleName: 'workflow',
+      resModule: 'workflow',
+      resModuleName: 'workflow',
+      priority: 100,
+      sessionPath: '/workflow/WorkflowMenus_WorkBenchMenu_ActiveUserTaskMenu'
+    };
+  }
+
+  private beforeClickMap = {
+    [BeforeClickMapName.wait]: async (message, messageInfo) => {
+      return true;
+    },
+
+    [BeforeClickMapName.copy]: async (message, messageInfo) => {
+      return true;
+    },
+
+    [BeforeClickMapName.write]: async (message, messageInfo) => {
+      return true;
+    },
+
+    [BeforeClickMapName.mail]: async (message, messageInfo) => {
+      return true;
+    }
+  };
+
+  public async beforeClick(key: Partial<Record<BeforeClickMapKey, ReturnBeforeClick>>);
+  public async beforeClick(key: BeforeClickMapKey, cb: ReturnBeforeClick);
+  public async beforeClick(
+    args: BeforeClickMapKey | Partial<Record<BeforeClickMapKey, ReturnBeforeClick>>,
+    cb?: ReturnBeforeClick
+  ) {
+    if (typeof args === 'string') {
+      this.beforeClickMap[args as any] = cb;
+    } else {
+      Object.entries(args).forEach(([key, val]) => {
+        this.beforeClickMap[key as any] = val;
+      });
+    }
+  }
+
+  @Widget.Reactive()
+  public messageTextMap = {
+    WORKFLOW: {
+      title: '工作流',
+      desc: '待处理的审批/填写任务',
+      btn: '去处理',
+      icon: 'oinone-tianxie',
+      color: 'rgb(122, 32, 233)'
+    },
+    NOTIFICATION: {
+      title: '站内信',
+      desc: '未读的站内信',
+      btn: '去查看',
+      icon: 'oinone-xitongtongzhi'
+    },
+    COPY: {
+      title: '抄送',
+      desc: '未查看的抄送',
+      btn: '去查看',
+      icon: 'oinone-tianxie'
+    }
+  };
+
+  @Widget.Reactive()
+  public messageType = NotificationTypeEnum.WORKFLOW;
+
+  @Widget.Reactive()
+  public get messageInfo() {
+    return this.messageTextMap[this.messageType];
+  }
+
+  @Widget.Reactive()
+  public confirmModalTitle = '查看消息';
+
+  @Widget.Reactive()
+  public currentMessage = {} as any;
+
+  @Widget.Reactive()
+  public isShowConfirmModal = false;
+
+  @Widget.Reactive()
+  public currentMessageId = '';
+
+  @Widget.Method()
+  public changeMessageType(type: NotificationTypeEnum) {
+    this.messageType = type;
+  }
+
+  @Widget.Method()
+  public toggleDialog() {
+    this.isShowConfirmModal = !this.isShowConfirmModal;
+  }
+
+  @Widget.Method()
+  public async onWorkflowUserTask() {
+    const model = await getModel('workflow.WorkflowUserTask');
+    const action = model.viewActionList?.find((a) => a.name === 'workflow#任务待办');
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    action &&
+      executeViewAction(CastHelper.cast(action), undefined, undefined, {
+        module: action.moduleName
+      });
+  }
+
+  @Widget.Method()
+  public async onDetail(message, messageInfo) {
+    if (messageInfo.messageType === 'WORKFLOW' || messageInfo.messageType === 'COPY') {
+      let action;
+
+      if (message.workFlowTaskType === '审批') {
+        const rst = await this.beforeClickMap['wait'](message, messageInfo);
+
+        if (!rst) {
+          return;
+        }
+
+        action = await this.getWaitAction();
+      } else {
+        const rst = await this.beforeClickMap['write'](message, messageInfo);
+
+        if (!rst) {
+          return;
+        }
+        action = await this.getWriteAction();
+      }
+
+      if (message.messageType === 'COPY') {
+        const rst = await this.beforeClickMap['copy'](message, messageInfo);
+
+        if (!rst) {
+          return;
+        }
+        action = await this.getCopyAction();
+      }
+
+      if (action) {
+        executeViewAction(
+          action,
+          undefined,
+          undefined,
+          {
+            id: message.resId,
+            module: action.resModuleName || action.moduleName
+          },
+          RedirectTargetEnum.BLANK
+        );
+      }
+    } else {
+      const rst = await this.beforeClickMap['mail'](message, messageInfo);
+
+      if (!rst) {
+        return;
+      }
+      this.currentMessage = message;
+      this.currentMessageId = messageInfo.id;
+      this.isShowConfirmModal = true;
+    }
+  }
+
+  @Widget.Method()
+  protected formatDateTime(value: string) {
+    if (!value) {
+      return value;
+    }
+
+    const dateFormat = defaultDateFormatKey;
+    const timeFormat = defaultTimeFormatKey;
+
+    const resourceDateFormat = ObjectUtils.toUpperSnakeCase(
+      this.resourceDateTimeFormat.resourceDateFormat as unknown as Record<string, string>
+    );
+    const resourceTimeFormat = ObjectUtils.toUpperSnakeCase(
+      this.resourceDateTimeFormat.resourceTimeFormat as unknown as Record<string, string>
+    );
+
+    const format = [resourceDateFormat[dateFormat!], resourceTimeFormat[timeFormat!]].filter(Boolean).join(' ');
+    return DateUtil.dateFormat(DateUtil.toDate(value, defaultFormat), format);
+  }
+
+  @Widget.Reactive()
+  protected msgTotal = 0;
+
+  @Widget.Reactive()
+  protected resourceDateTimeFormat = {} as IResourceDateTimeFormat;
+
+  protected async getMsgTotal() {
+    this.msgTotal = await MessageService.unreadCount();
+  }
+
+  @Widget.Reactive()
+  protected messageList = [] as PamirsMessage[];
+
+  @Widget.Method()
+  protected async getMessageInfo() {
+    this.messageList = await MessageService.unreadWorkflowList();
+  }
+
+  @Widget.Method()
+  protected readMessage(msgId: string) {
+    return MessageService.readWorkflowMessage(msgId);
+  }
+
+  protected msgTimer;
+
+  /**
+   * 轮询间隔时间，单位: 秒
+   * @protected
+   */
+  protected msgDelay = 5000;
+
+  protected async $$created() {
+    super.$$created();
+    this.resourceDateTimeFormat = await queryResourceDateTimeFormat();
+  }
+
+  protected mounted() {
+    super.mounted();
+    this.getMsgTotal();
+    if (!isDev()) {
+      this.msgTimer = setInterval(() => {
+        this.getMsgTotal();
+      }, this.msgDelay || 5000);
+    }
+  }
+
+  protected beforeUnmount() {
+    this.msgTimer && clearInterval(this.msgTimer);
+    super.beforeUnmount();
+  }
+}

package/src/component/notification/index.ts

@@ -0,0 +1,2 @@
+export { default as DefaultNotification } from './DefaultNotification.vue';
+export * from './NotificationWidget';

package/src/component/order-statistic/OrderStatistic.vue

@@ -0,0 +1,12 @@
+<template>
+  <div class="order-statistic">
+    <div v-for="(data, i) in showData" :key="i" class="item">{{ data.displayName }} : {{ data.value }}</div>
+  </div>
+</template>
+<script lang="ts">
+import { defineComponent } from 'vue';
+
+export default defineComponent({
+  props: ['showData'],
+});
+</script>

package/src/component/order-statistic/index.ts

@@ -0,0 +1,146 @@
+import { Condition, HttpClient } from '@oinone/kunlun-request';
+import { useMatched } from '@oinone/kunlun-router';
+import { getModel } from '@oinone/kunlun-service';
+import { SPI } from '@oinone/kunlun-spi';
+import { Widget } from '@oinone/kunlun-vue-widget';
+import { MaskWidget } from '../../basic';
+
+import OrderStatisticComponent from './OrderStatistic.vue';
+
+interface IData {
+  name: string;
+  displayName: string;
+  value: string;
+}
+
+const ModelName = 'libra.trade.LibraOrderQuantityCalculate';
+
+@SPI.ClassFactory(MaskWidget.Token({ widget: 'order-statistic' }))
+export class OrderStatistic extends MaskWidget {
+  @Widget.Reactive()
+  private layoutTemplate = '';
+
+  @Widget.Reactive()
+  private showFields: string[] = [];
+
+  @Widget.Reactive()
+  private showData: IData[] = [];
+
+  @Widget.Reactive()
+  private activedModel = '';
+
+  private http = HttpClient.getInstance();
+
+  public initialize(props) {
+    const { dslNode } = props;
+
+    const { fields = '' } = dslNode;
+    this.showFields = (fields as string).split(',').filter((v) => v);
+
+    super.initialize(props);
+    this.setComponent(OrderStatisticComponent);
+    return this;
+  }
+
+  @Widget.Method()
+  public async mounted() {
+    const page = useMatched().matched.segmentParams.page;
+    this.activedModel = page.model || '';
+    await this.loadData('', page.scene || '');
+
+    useMatched()
+      .getMatched$()
+      .subscribe((val) => {
+        const { searchBody, scene } = val.segmentParams.page;
+
+        if (searchBody) {
+          const condition = new Condition('1==1');
+          condition.and(this.buildSearchConditions(JSON.parse(searchBody)));
+
+          this.loadData(condition.toString() === '1==1' ? '' : condition, scene);
+        }
+      });
+  }
+
+  @Widget.Method()
+  private async loadData(condition, scene) {
+    if (!this.showFields.length) {
+      return;
+    }
+
+    try {
+      const result = await this.queryData(condition, scene);
+      const model = await getModel(ModelName);
+      this.showData = this.showFields.map((f) => {
+        const displayName = (model.modelFields.find((m) => m.name === f) || {}).displayName;
+        return {
+          displayName,
+          name: f,
+          value: result[f]
+        };
+      }) as any;
+    } catch (error) {
+      console.error(error);
+    }
+  }
+
+  @Widget.Method()
+  private async queryData(condition, scene) {
+    const queryFields = this.showFields.join('\n');
+
+    const body = `
+      query{
+        libraDeliveryOrderQuery{
+          calculateQuantity(calculate:{modelModel:"${this.activedModel}", rsql:"${condition}"}){
+             ${queryFields}
+          }
+        }
+      }
+    `;
+
+    const result = await this.http.query('base', body, undefined, {
+      __queryParams: { scene }
+    });
+    return result.data.libraDeliveryOrderQuery.calculateQuantity;
+  }
+
+  @Widget.Method()
+  public buildSearchConditions(content: Record<string, unknown>) {
+    const { page } = useMatched().matched.segmentParams;
+    const extraConditions: { leftValue: string[]; operator: string; right: unknown }[] =
+      (page.searchConditions && JSON.parse(decodeURIComponent(page.searchConditions))) || [];
+    const extraContent: Record<string, unknown> =
+      (page.searchBody && JSON.parse(decodeURIComponent(page.searchBody))) || {};
+
+    const condition = new Condition('1==1');
+    const mixedContent = { ...content, ...extraContent };
+    Object.keys(mixedContent).forEach((c) => {
+      if (mixedContent[c] !== null && mixedContent[c] !== undefined && mixedContent[c] !== '') {
+        const val = mixedContent[c];
+        if (typeof val === 'string') {
+          condition.and(new Condition(c).equal(mixedContent[c] as string));
+        }
+      }
+    });
+    extraConditions
+      .map((c) => {
+        if (c.operator === '=like=' || c.operator === '=notlike=') {
+          return { ...c, right: `%${c.right}%` };
+        }
+        return c;
+      })
+      .forEach((con) => {
+        const left = con.leftValue[con.leftValue.length - 1];
+        if (con.operator !== 'between') {
+          condition.and(new Condition(left).append(con.operator).append(new Condition(con.right as string).toString()));
+        } else {
+          condition.and(
+            new Condition(left)
+              .greaterThanOrEuqalTo((<string[]>con.right)[0])
+              .and(new Condition(left).lessThanOrEqualTo((<string[]>con.right)[1]))
+          );
+        }
+      });
+    return condition;
+  }
+}

package/src/component/partner-switcher/PartnerSwitcher.vue

@@ -0,0 +1,75 @@
+<template>
+  <oio-dropdown v-if="currentPartner" :trigger="['click']" placement="bottomCenter">
+    <div class="k-layout-partner-switcher">
+      <span>{{ currentPartner.name }}</span>
+      <caret-down-outlined :style="{ fontSize: '12px', color: '#c3c4c6' }" />
+    </div>
+    <template #overlay>
+      <a-menu class="k-layout-partner-switcher-overlay" @click="onSelect">
+        <a-menu-item v-for="item in partnerList" :key="item.id" :title="item.name">{{ item.name }}</a-menu-item>
+      </a-menu>
+    </template>
+  </oio-dropdown>
+</template>
+<script lang="ts">
+import { CaretDownOutlined } from '@ant-design/icons-vue';
+import { OioDropdown } from '@oinone/kunlun-vue-ui-antd';
+import { Menu as AMenu, MenuItem as AMenuItem } from 'ant-design-vue';
+import { defineComponent, PropType } from 'vue';
+import { PartnerItem } from './typing';
+
+export default defineComponent({
+  name: 'PartnerSwitcher',
+  components: {
+    AMenu,
+    AMenuItem,
+    CaretDownOutlined,
+    OioDropdown
+  },
+  inheritAttrs: false,
+  props: {
+    currentPartner: {
+      type: Object as PropType<PartnerItem>
+    },
+    partnerList: {
+      type: Array as PropType<PartnerItem[]>
+    },
+    onChangePartner: {
+      type: Function as PropType<(item: PartnerItem) => void>
+    }
+  },
+  setup(props) {
+    const onSelect = (e: { key: string }) => {
+      const { key } = e;
+      const target = props.partnerList?.find((v) => v.id === key);
+      if (target) {
+        props.onChangePartner?.(target);
+      }
+    };
+
+    return {
+      onSelect
+    };
+  }
+});
+</script>
+<style lang="scss">
+.k-layout-partner-switcher {
+  display: flex;
+  align-items: center;
+  line-height: 48px;
+  cursor: pointer;
+
+  span {
+    margin-left: 10px;
+  }
+
+  &:hover {
+    color: #606cee;
+  }
+}
+
+.k-layout-partner-switcher-overlay {
+  max-height: 500px !important;
+}
+</style>

package/src/component/partner-switcher/PartnerSwitcherWidget.ts

@@ -0,0 +1,70 @@
+import { SPI } from '@oinone/kunlun-spi';
+import { Widget } from '@oinone/kunlun-vue-widget';
+import { MaskWidget } from '../../basic';
+import PartnerSwitcher from './PartnerSwitcher.vue';
+import { PartnerSwitcherService, PartnerSwitcherServiceToken } from './service';
+import { PartnerInfoSession, PartnerInfoSessionToken, PartnerSessionStore } from './session';
+import { PartnerInfo, PartnerItem } from './typing';
+
+@SPI.ClassFactory(MaskWidget.Token({ widget: 'partner-switcher' }))
+export class PartnerSwitcherWidget extends MaskWidget {
+  protected partnerSwitcherService!: PartnerSwitcherService;
+
+  protected partnerInfoSession!: PartnerInfoSession<PartnerSessionStore>;
+
+  public constructor(handle: string) {
+    super(handle);
+    this.partnerSwitcherService = SPI.RawInstantiate(PartnerSwitcherServiceToken)!;
+    this.partnerInfoSession = SPI.RawInstantiate(PartnerInfoSessionToken) as PartnerInfoSession<PartnerSessionStore>;
+  }
+
+  @Widget.Reactive()
+  protected currentPartner: PartnerItem | undefined;
+
+  @Widget.Reactive()
+  protected partnerList: PartnerItem[] | undefined;
+
+  public initialize(props) {
+    super.initialize(props);
+    this.setComponent(PartnerSwitcher);
+    return this;
+  }
+
+  @Widget.Method()
+  public async onChangePartner(item: PartnerItem) {
+    const partnerInfo = await this.partnerSwitcherService?.changePartner(item);
+    this.reloadPartnerInfo(partnerInfo);
+  }
+
+  protected reloadPartnerInfo(target: PartnerInfo | undefined, predict?: (target: PartnerInfo) => boolean) {
+    if (!target) {
+      this.partnerInfoSession?.clear();
+      return;
+    }
+    const { currentPartner, partnerList } = target;
+    const currentPartnerId = currentPartner?.id;
+    if (!currentPartnerId) {
+      this.partnerInfoSession?.clear();
+      return;
+    }
+    if (!predict || predict(target)) {
+      this.currentPartner = currentPartner;
+      this.partnerList = partnerList || [];
+      this.partnerInfoSession?.setPartnerInfo(target);
+    }
+  }
+
+  protected async mounted() {
+    const partnerInfo = await this.partnerSwitcherService?.queryPartnerInfo();
+    this.reloadPartnerInfo(partnerInfo, (target) => {
+      const currentPartnerId = target.currentPartner.id;
+      const store = this.partnerInfoSession?.getCurrentPartnerStore();
+      if (store && (store.sid !== currentPartnerId || store.lid !== currentPartnerId)) {
+        window.location.href = '/';
+        this.partnerInfoSession?.setPartnerInfo(target);
+        return false;
+      }
+      return true;
+    });
+  }
+}

package/src/component/partner-switcher/index.ts

@@ -0,0 +1,6 @@
+export * from './service';
+export * from './session';
+export * from './spi';
+export * from './typing';
+export * from './PartnerSwitcherWidget';
+export { default as PartnerSwitcher } from './PartnerSwitcher.vue';

package/src/component/partner-switcher/service/PartnerSwitcherService.ts

@@ -0,0 +1,20 @@
+import { ServiceIdentifier } from '@oinone/kunlun-spi';
+import { PartnerInfo, PartnerItem } from '../typing';
+
+/**
+ * 合作伙伴选择服务
+ */
+export interface PartnerSwitcherService {
+  /**
+   * 查询合作伙伴信息
+   */
+  queryPartnerInfo(): Promise<PartnerInfo | undefined>;
+
+  /**
+   * 选择合作伙伴
+   * @param target
+   */
+  changePartner(target: PartnerItem): Promise<PartnerInfo | undefined>;
+}
+
+export const PartnerSwitcherServiceToken = ServiceIdentifier<PartnerSwitcherService>('PartnerSwitcherService');