cnhis-design-vue 3.3.1-beta.7 → 3.3.1-release.4

package/es/components/ai-chat/src/hooks/useProgram.js

@@ -0,0 +1,306 @@
+import { computed, nextTick } from 'vue';
+import { $message, formatType, isValidJSON } from '../utils/index.js';
+import { uuidGenerator } from '../../../../shared/utils/index.js';
+import { callbackApi } from '../api/index.js';
+import { useIntervalFn, useThrottleFn } from '@vueuse/core';
+import { format } from 'date-fns';
+
+const messageTypeMap = {
+  inquiry: "\u95EE\u8BCA\u8BB0\u5F55",
+  medical: "\u7535\u5B50\u75C5\u5386",
+  diagnosis: "\u63A8\u8350\u8BCA\u65AD",
+  diagnosis_added: "\u68C0\u9A8C\u68C0\u67E5",
+  treatment_plan: "\u6CBB\u7597\u65B9\u6848",
+  report_message: "\u62A5\u544A",
+  medical_added: "\u5F00\u7ACB\u5355"
+};
+function useProgram({
+  props,
+  state,
+  appendMessage,
+  emit,
+  chatMainRef
+}) {
+  let time = 0;
+  const {
+    pause,
+    resume
+  } = useIntervalFn(() => {
+    time++;
+  }, 1e3);
+  const handleScroll = useThrottleFn(() => {
+    if (chatMainRef.value) {
+      chatMainRef.value.scrollTop = 0;
+    }
+  }, 2e3);
+  const baseParams = computed(() => {
+    var _a;
+    return {
+      appCode: props.appCode,
+      sessionId: props.sessionId || ((_a = props.configs) == null ? void 0 : _a.vaa07)
+    };
+  });
+  function toNext(bpmnProcessId, variables) {
+    var _a;
+    state.bpmnProcessDoing = true;
+    const _bpmnProcessId = bpmnProcessId || state.bpmnProcessId;
+    console.log("toNext ==>", _bpmnProcessId);
+    if (typeof ((_a = window._programArrange) == null ? void 0 : _a.next) !== "function")
+      return;
+    window._programArrange.next({
+      bpmnProcessId,
+      startToken: bpmnProcessId ? "" : state.startToken,
+      variables,
+      programTaskSetting: {
+        showLoading: false
+      }
+    }, (obj) => {
+      var _a2, _b;
+      state.bpmnProcessDoing = false;
+      console.log("\u83B7\u53D6\u56DE\u8C03\u6570\u636E\uFF1A", obj);
+      clearTimer();
+      state.loading = false;
+      if ((_a2 = obj == null ? void 0 : obj.data) == null ? void 0 : _a2.msg) {
+        $message.error((_b = obj == null ? void 0 : obj.data) == null ? void 0 : _b.msg);
+      }
+      console.log("_bpmnProcessId ==>", _bpmnProcessId);
+      window._programArrange.removeAiConditions((obj == null ? void 0 : obj.programArrangeId) || _bpmnProcessId);
+    });
+  }
+  function toBindAiConditions() {
+    console.log("toBindAiConditions ==>");
+    let flag = true;
+    window._programArrange.bindAiConditions(state.bpmnProcessId, async (res) => {
+      var _a, _b, _c, _d;
+      console.log("---\u83B7\u53D6AI\u6570\u636E", res);
+      const {
+        programData,
+        config = {}
+      } = res || {};
+      const {
+        webType,
+        renderType,
+        renderContent,
+        content: _content = {}
+      } = config;
+      if (webType !== "ai") {
+        state.loading = false;
+      }
+      if (webType === "error") {
+        state.bpmnProcessDoing = false;
+        clearTimer();
+        flag = true;
+        return;
+      }
+      const msgId = uuidGenerator();
+      if (webType === "render") {
+        const messageItem = {
+          msgId,
+          ...baseParams.value
+        };
+        if (renderType == 0) {
+          const {
+            messageType,
+            json,
+            title
+          } = formatType(renderContent);
+          if (messageType && Object.keys(messageTypeMap).includes(messageType)) {
+            Object.assign(messageItem, {
+              contents: [{
+                role: "system",
+                content: json,
+                contentType: "json",
+                messageType
+              }]
+            });
+            appendMessage({
+              ...messageItem,
+              __title: title
+            });
+            if (messageType === "inquiry") {
+              if ((_a = json.details) == null ? void 0 : _a.autoBackFillData) {
+                state.showRight = false;
+                await nextTick();
+                state.consultationContent = messageItem;
+                state.showRight = true;
+              }
+            } else if (messageType === "medical") {
+              emit("program", {
+                key: "medical",
+                params: {},
+                type: 1
+              });
+            }
+            toReplyAiConditions({
+              programData,
+              params: {
+                data: json
+              }
+            });
+            const data = await callbackApi(messageItem);
+            if ((data == null ? void 0 : data.id) && messageType === "inquiry" && state.showRight) {
+              state.consultationContent.id = data.id;
+            }
+            return;
+          }
+          Object.assign(messageItem, {
+            contents: [{
+              role: "system",
+              content: renderContent,
+              contentType: "text"
+            }]
+          });
+        } else if (renderType == 4) {
+          Object.assign(messageItem, {
+            contents: [{
+              role: "system",
+              content: renderContent,
+              contentType: "text"
+            }]
+          });
+          state.needSubmitMsg = {
+            programData
+          };
+          appendMessage(messageItem);
+          callbackApi(messageItem);
+          return;
+        } else if (renderType == 1) {
+          Object.assign(messageItem, {
+            contents: [{
+              role: "system",
+              content: config,
+              contentType: "json",
+              messageType: "card"
+            }]
+          });
+        } else if (renderType == 2) {
+          Object.assign(messageItem, {
+            contents: [{
+              role: "system",
+              content: renderContent,
+              contentType: "text"
+            }]
+          });
+        } else if (renderType == 3) {
+          Object.assign(messageItem, {
+            contents: [{
+              role: "system",
+              content: {
+                info: config.linkTitle || "",
+                creationTime: format(new Date(), "yyyy-MM-dd HH:mm:ss"),
+                linkType: (_b = config.linkType) != null ? _b : 0,
+                linkURL: config.linkURL || "",
+                linkProcess: config.linkProcess || "",
+                linkParams: config.linkParams || {}
+              },
+              contentType: "json",
+              messageType: "link"
+            }]
+          });
+        }
+        appendMessage(messageItem);
+        callbackApi(messageItem);
+        toReplyAiConditions({
+          programData
+        });
+        return;
+      }
+      if (webType === "form") {
+        const messageItem = {
+          msgId,
+          contents: [{
+            role: "system",
+            content: config,
+            contentType: "json",
+            messageType: webType,
+            __programData: programData
+          }],
+          ...baseParams.value
+        };
+        appendMessage(messageItem);
+        callbackApi(messageItem);
+        return;
+      }
+      if (webType === "ai") {
+        if (isValidJSON(_content.data)) {
+          const json = JSON.parse(_content.data);
+          const {
+            finish_reason = "",
+            delta = {}
+          } = ((_c = json.choices) == null ? void 0 : _c[0]) || {};
+          const {
+            content = "",
+            role
+          } = delta;
+          let messageItem = state.record[0];
+          if (flag) {
+            time = 0;
+            resume();
+            state.loading = true;
+            messageItem = {
+              msgId,
+              contents: [{
+                role: "system",
+                content,
+                contentType: "text"
+              }],
+              ...baseParams.value
+            };
+            appendMessage(messageItem);
+            flag = false;
+          } else {
+            messageItem.contents[0].content += content;
+            state.record.splice(0, 1, messageItem);
+            handleScroll();
+            console.log("AI\u6E32\u67D3ing ==>", state.record[0]);
+            if (finish_reason === "stop") {
+              const currentMessage = state.record.find((item) => item.msgId === messageItem.msgId);
+              if ((_d = currentMessage == null ? void 0 : currentMessage.contents) == null ? void 0 : _d.length) {
+                currentMessage.contents[0].__showMore = true;
+                currentMessage.contents[0].msgSource = role;
+                currentMessage.contents[0].countTime = time;
+              }
+              clearTimer();
+              state.loading = false;
+              callbackApi(currentMessage);
+              toReplyAiConditions({
+                programData,
+                params: {
+                  data: messageItem.contents[0].content
+                }
+              });
+              flag = true;
+              console.log("AI\u6E32\u67D3\u5B8C\u6210 ==>", state.record[0]);
+            }
+          }
+        }
+        return;
+      }
+    });
+  }
+  function toReplyAiConditions(params) {
+    console.log("\u7F16\u6392\u63D0\u4EA4 ==> bpmnProcessId", state.bpmnProcessId, params);
+    state.loading = true;
+    window._programArrange.replyAiConditions(state.bpmnProcessId, params);
+  }
+  function toFinishProgram(bpmnProcessId) {
+    var _a;
+    console.log("\u7ED3\u675F\u672C\u6B21\u6D41\u7A0B ==> bpmnProcessId", bpmnProcessId);
+    state.bpmnProcessDoing = false;
+    if (!bpmnProcessId)
+      return;
+    (_a = window._programArrange) == null ? void 0 : _a.finishProgram(bpmnProcessId);
+  }
+  function clearTimer() {
+    pause();
+    time = 0;
+  }
+  return {
+    toNext,
+    toBindAiConditions,
+    toReplyAiConditions,
+    toFinishProgram
+  };
+}
+
+export { useProgram };

package/es/components/ai-chat/src/hooks/useSSE.d.ts

@@ -0,0 +1,9 @@
+import { AnyObject } from '../../../../shared/types';
+export declare function useSSE({ state, props, appendMessage, params, emit, formatProcessInfo }: {
+    state: AnyObject;
+    props: AnyObject;
+    appendMessage: Function;
+    params: AnyObject;
+    emit: (event: 'button-click' | 'program', ...args: any[]) => void;
+    formatProcessInfo: (str: string) => void;
+}): void;

package/es/components/ai-chat/src/hooks/useSSE.js

@@ -0,0 +1,138 @@
+import { fetchEventSource } from '@microsoft/fetch-event-source';
+import { isArray, isString } from 'lodash-es';
+import { isValidJSON, $message } from '../utils/index.js';
+import { uuidGenerator } from '../../../../shared/utils/index.js';
+
+const url = "/flow/ai/api/conversation";
+function useSSE({
+  state,
+  props,
+  appendMessage,
+  params,
+  emit,
+  formatProcessInfo
+}) {
+  var _a, _b;
+  const {
+    opType,
+    firstSubmit
+  } = params;
+  let sseFlag = false;
+  const contentStr = state.inquiryStr && !firstSubmit ? `${state.inquiryStr}
+\u5B8C\u5584\u4FE1\u606F
+${state.sendContent}` : state.sendContent;
+  const multContents = state.inquiryStr && !firstSubmit ? {
+    multContents: [{
+      role: "user",
+      content: state.sendContent,
+      contentType: "text"
+    }]
+  } : {};
+  if (firstSubmit) {
+    state.inquiryStr = "";
+  }
+  const parentMsgId = (_a = state.record.find((item) => item.msgId && !item.fromMe)) == null ? void 0 : _a.msgId;
+  state.loading = true;
+  fetchEventSource(url, {
+    method: "POST",
+    headers: {
+      Authorization: "bearer " + props.token,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      appCode: props.appCode,
+      appId: 0,
+      conversationMode: "",
+      extra: {},
+      model: "",
+      msgId: "",
+      parentMsgId,
+      platform: "",
+      requestId: uuidGenerator(),
+      sessionId: props.sessionId || ((_b = props.configs) == null ? void 0 : _b.vaa07),
+      sessionType: "",
+      shortcutFlag: true,
+      traceId: "",
+      contents: [{
+        role: "user",
+        content: contentStr,
+        contentType: "text"
+      }],
+      ...multContents,
+      configs: props.configs,
+      ...params
+    }),
+    async onopen(res) {
+      console.log("onopen ==>", "\u8FDE\u63A5\u5DF2\u6253\u5F00", res);
+      sseFlag = true;
+    },
+    onmessage(event) {
+      var _a2, _b2, _c, _d;
+      console.log("event ==>", event);
+      state.loading = false;
+      if (!isValidJSON(event.data))
+        return;
+      const res = JSON.parse(event.data);
+      const {
+        result,
+        contents
+      } = res;
+      console.log("result ==>", result, "contents ==>", contents);
+      if (isArray(contents) && contents.length > 0) {
+        if (((_a2 = contents[0]) == null ? void 0 : _a2.contentType) === "json") {
+          appendMessage(res);
+          return;
+        }
+        if (((_b2 = contents[0]) == null ? void 0 : _b2.contentType) === "text") {
+          if (sseFlag) {
+            appendMessage(res);
+            sseFlag = false;
+          }
+          const {
+            content
+          } = ((_d = (_c = state.record[0]) == null ? void 0 : _c.contents) == null ? void 0 : _d[0]) || {};
+          if (isString(content)) {
+            state.record[0].contents[0].content += contents[0].content;
+          }
+        }
+      }
+      formatProcessInfo(result);
+      if (isString(contents) && contents === "STOP") {
+        state.loading = false;
+        state.sendContent = "";
+        if (["diagnosis", "medical_order"].includes(opType)) {
+          if (state.showRightSlot) {
+            let key = "cliRefreshDiagnosis";
+            if (opType === "medical_order") {
+              key = "cliRefreshMedical";
+            }
+            emit("program", {
+              key,
+              type: "refresh",
+              params: {}
+            });
+          }
+        }
+        if (opType === "create_medical") {
+          state.showRight = false;
+          state.showRightSlot = false;
+        }
+      }
+      console.log("state.startToken ==>", state.startToken);
+    },
+    onclose() {
+      console.log("onclose ==>", "\u8FDE\u63A5\u5173\u95ED");
+      state.loading = false;
+      state.sendContent = "";
+    },
+    onerror(err) {
+      console.log("onerror ==>", err);
+      state.loading = false;
+      $message.error("\u5BF9\u8BDD\u8FDE\u63A5\u5931\u8D25\uFF01");
+      throw Error(err);
+    },
+    openWhenHidden: true
+  });
+}
+
+export { useSSE };

package/es/components/ai-chat/src/hooks/useWebsocket.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { AnyObject } from '../../../../shared/types';
+import { initData } from './useData';
+export declare function useWebsocket(props: AnyObject, data: ReturnType<typeof initData>, sessionId: Ref<string>): void;

package/es/components/ai-chat/src/hooks/useWebsocket.js

@@ -0,0 +1,66 @@
+import { watch, onBeforeUnmount } from 'vue';
+import { isValidJSON } from '../utils/index.js';
+
+const ORIGIN = "/flow/ai/app";
+function useWebsocket(props, data, sessionId) {
+  let isReady = false;
+  let webSocket = null;
+  function connect() {
+    if (!props.appCode || !sessionId.value)
+      return;
+    try {
+      isReady = false;
+      const {
+        appendMessage
+      } = data;
+      const protocol = window.location.protocol;
+      const host = window.location.host;
+      const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
+      const wsUrl = `${wsProtocol}//${host}${ORIGIN}/${props.appCode}_${sessionId.value}`;
+      webSocket = new WebSocket(wsUrl);
+      webSocket.onopen = () => {
+        isReady = true;
+        console.log("0 websocket\u8FDE\u63A5\u6210\u529F ==>");
+      };
+      webSocket.onerror = () => console.log("WebSocket\u8FDE\u63A5\u5931\u8D25");
+      webSocket.onmessage = (event) => {
+        const {
+          data: data2
+        } = event || {};
+        if (!isValidJSON(data2))
+          return;
+        const json = JSON.parse(data2);
+        appendMessage(json || {});
+      };
+      (async function toTry(times = 0) {
+        if (times > 5) {
+          return console.log("websocket\u8FDE\u63A5\u5931\u8D25 ==>");
+        }
+        if (isReady) {
+          return console.log("websocket\u8FDE\u63A5\u6210\u529F ==>");
+        }
+        setTimeout(() => {
+          toTry(++times);
+        }, 100);
+      })();
+    } catch (error) {
+      console.log("error ==>", error);
+    }
+  }
+  watch(() => sessionId.value, (value) => {
+    if ((webSocket == null ? void 0 : webSocket.readyState) !== WebSocket.CLOSED) {
+      webSocket == null ? void 0 : webSocket.close();
+    }
+    webSocket = null;
+    isReady = false;
+    connect();
+  }, {
+    immediate: true
+  });
+  onBeforeUnmount(() => {
+    webSocket == null ? void 0 : webSocket.close();
+    webSocket = null;
+  });
+}
+
+export { useWebsocket };

package/es/components/ai-chat/src/types/index.d.ts

@@ -1,7 +1,5 @@
-import { InjectionKey, VNodeChild } from 'vue';
+import { VNodeChild } from 'vue';
 import { AnyObject } from '../../../../shared/types';
-export declare const InjectionAIChat: InjectionKey<AnyObject>;
-export declare const InjectionAIChatEmits: InjectionKey<(event: string, ...args: any[]) => void>;
 export type MessageItem = {
     role: string;
     contentType: 'json' | 'text';

package/es/components/ai-chat/src/types/index.js

@@ -1 +1 @@
-const t=Symbol("InjectionAIChat"),o=Symbol("InjectionAIChatEmits");export{t as InjectionAIChat,o as InjectionAIChatEmits};
+

package/es/components/ai-chat/src/utils/index.d.ts

@@ -1 +1,7 @@
+export declare const $message: import("naive-ui").MessageApi, $dialog: unknown;
 export declare function isValidJSON(str: string): boolean;
+export declare function formatType(str: string): {
+    messageType: string;
+    json: {};
+    title: string;
+};

package/es/components/ai-chat/src/utils/index.js

@@ -1 +1,41 @@
-function r(r){try{return JSON.parse(r),!0}catch(r){return!1}}export{r as isValidJSON};
+import { createDiscreteApi } from 'naive-ui';
+
+const {
+  message: $message,
+  dialog: $dialog
+} = createDiscreteApi(["message"]);
+function isValidJSON(str) {
+  try {
+    if (!str)
+      return false;
+    JSON.parse(str);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function formatType(str) {
+  const res = {
+    messageType: "",
+    json: {},
+    title: ""
+  };
+  const regexPattern = /##(.*?)##(.*)/;
+  const match = str.match(regexPattern);
+  if (match) {
+    const arr = str.split("##");
+    if (arr.length === 4) {
+      res.title = arr[2];
+      res.messageType = arr[1];
+      res.json = isValidJSON(arr[3]) ? JSON.parse(arr[2]) : {};
+    } else {
+      const enclosedString = match[1];
+      const remainingPart = match[2];
+      res.messageType = enclosedString;
+      res.json = isValidJSON(remainingPart) ? JSON.parse(remainingPart) : {};
+    }
+  }
+  return res;
+}
+
+export { $dialog, $message, formatType, isValidJSON };