问诊室模块 ​

{
      path: '/room',
      component: () => import('@/views/Room/index.vue'),
      meta: { title: '问诊室' }
    },

import io from "socket.io-client";
// 参数1：不传默认是当前服务域名，开发中传入服务器地址
// 参数2：配置参数，根据需要再来介绍
const socket = io();

socket.on("connect", () => {
  // 建立连接成功
});

// chat message 发送消息事件，由后台约定，可变
socket.emit("chat message", "消息内容");

// chat message 接收消息事件，由后台约定，可变
socket.on("chat message", (ev) => {
  // ev 是服务器发送的消息
});

// 离开组件需要使用
socket.close();

import type { Socket } from "socket.io-client";
import { io } from "socket.io-client";
import { onMounted, onUnmounted } from "vue";
import { baseURL } from "@/utils/request";
import { useUserStore } from "@/stores";
import { useRoute } from "vue-router";

const store = useUserStore();
const route = useRoute();

let socket: Socket;
onUnmounted(() => {
  socket.close();
});
onMounted( () => {
  // 建立链接，创建 socket.io 实例
  socket = io(baseURL, {
    auth: {
      token: `Bearer ${store.userInfo?.token}`,
    },
    query: {
      orderId: route.query.orderId,
    },
  });

  socket.on("connect", () => {
    // 建立连接成功
    console.log("connect");
  });

});

/** 消息类型 */
export enum MsgType {
  /** 文字聊天 */
  MsgText = 1,
  /** 图片消息 */
  MsgImage = 4,
  /** 患者信息 */
  CardPat = 21,
  /** 处方信息 */
  CardPre = 22,
  /** 未评价信息 */
  CardEvaForm = 23,
  /** 已评价信息 */
  CardEva = 24,
  /** 通用通知 */
  Notify = 31,
  /** 温馨提示 */
  NotifyTip = 32,
  /** 取消提示 */
  NotifyCancel = 33,
}

/** 处方状态 */
export enum PrescriptionStatus {
  /** 未付款 */
  NotPayment = 1,
  /** 已付款 */
  Payment = 2,
  /** 已失效 */
  Invalid = 3,
}

import { MsgType, PrescriptionStatus } from "@/enums";
import type { Consult, Image } from "./consult";
import type { Patient } from "./user";

export type Medical = {
  /** 药品ID */
  id: string;
  /** 药品名称 */
  name: string;
  /** 金额 */
  amount: string;
  /** 药品图片 */
  avatar: string;
  /** 规格信息 */
  specs: string;
  /** 用法用量 */
  usageDosag: string;
  /** 数量 */
  quantity: string;
  /** 是否处方，0 不是 1 是 */
  prescriptionFlag: 0 | 1;
};

export type Prescription = {
  /** 处方ID */
  id: string;
  /** 药品订单ID */
  orderId: string;
  /** 创建时间 */
  createTime: string;
  /** 患者名称 */
  name: string;
  /** 问诊记录ID */
  recordId: string;
  /** 性别 0 女 1 男 */
  gender: 0 | 1;
  /** 性别文字 */
  genderValue: "";
  /** 年龄 */
  age: number;
  /** 诊断信息 */
  diagnosis: string;
  /** 处方状态 */
  status: PrescriptionStatus;
  /** 药品清单 */
  medicines: Medical[];
};

export type EvaluateDoc = {
  /** 评价ID */
  id?: string;
  /** 评分 */
  score?: number;
  /** 内容 */
  content?: string;
  /** 创建时间 */
  createTime?: string;
  /** 创建人 */
  creator?: string;
};


// 消息类型
export type Message = {
  /** 消息ID */
  id: string;
  /** 消息类型 */
  msgType: MsgType;
  /** 发信人 */
  from?: string;
  /** 发信人ID */
  fromAvatar?: string;
  /** 收信人 */
  to?: string;
  /** 收信人头像 */
  toAvatar?: string;
  /** 创建时间 */
  createTime: string;
  /** 消息主体 */
  msg: {
    /** 文本内容 */
    content?: string;
    /** 图片对象 */
    picture?: Image;
    /** 问诊记录，患者信息 */
    consultRecord?: Consult & {
      patientInfo: Patient;
    };
    /** 处方信息 */
    prescription?: Prescription;
    /** 评价信息 */
    evaluateDoc?: EvaluateDoc;
  };
};

/** 消息分组列表 */
export type TimeMessages = {
  /** 分组消息最早时间 */
  createTime: string;
  /** 消息数组 */
  items: Message[];
  /** 订单ID */
  orderId: string;
  /** 会话ID */
  sid: string;
};

import { MsgType } from "@/enums";
import type { Message, TimeMessages } from "@/types/room";

const list = ref<Message[]>([]);

// 聊天记录
socket.on("chatMsgList", ({ data }: { data: TimeMessages[] }) => {  
    list.value.push(...data[0].items)
});

defineProps<{ list: Message[] }>();

const timeOptions = [
  { label: '一周内', value: IllnessTime.Week },
  { label: '一月内', value: IllnessTime.Month },
  { label: '半年内', value: IllnessTime.HalfYear },
  { label: '大于半年', value: IllnessTime.More }
]
const flagOptions = [
  { label: '就诊过', value: 0 },
  { label: '没就诊过', value: 1 }
]

const getIllnessTimeText = (time: IllnessTime) => {
  return timeOptions.find((item) => item.value === time)?.label
}

const getConsultFlagText = (flag: 0 | 1) => {
  return flagOptions.find((item) => item.value === flag)?.label
}

import { showImagePreview } from "vant";

const onPreview = (pics?: Image[]) => {
  if (!pics || !pics.length) return
  const urls = pics.map((item) => item.url)
  showImagePreview(urls)
}

/** 问诊订单的状态 */
export enum OrderType {
  /** 待支付 */
  ConsultPay = 1,
  /** 待接诊 */
  ConsultWait = 2,
  /** 问诊中 */
  ConsultChat = 3,
  /** 问诊完成 */
  ConsultComplete = 4,
  /** 取消问诊 */
  ConsultCancel = 5,
  /** 药品订单 */
  /** 待支付 */
  MedicinePay = 10,
  /** 待发货 */
  MedicineSend = 11,
  /** 待收货 */
  MedicineTake = 12,
  /** 已完成 */
  MedicineComplete = 13,
  /** 取消订单 */
  MedicineCancel = 14,
}

/** 问诊订单单项信息 */
export type ConsultOrderItem = Consult & {
  /** 创建时间 */
  createTime: string;
  /** 医生信息 */
  docInfo?: Doctor;
  /** 患者信息 */
  patientInfo: Patient;
  /** 订单编号 */
  orderNo: string;
  /** 订单状态 */
  status: OrderType;
  /** 状态文字 */
  statusValue: string;
  /** 类型问诊文字 */
  typeValue: string;
  /** 倒计时时间 */
  countdown: number;
  /** 处方ID */
  prescriptionId?: string;
  /** 评价ID */
  evaluateId: number;
  /** 应付款 */
  payment: number;
  /** 优惠券抵扣 */
  couponDeduction: number;
  /** 积分抵扣 */
  pointDeduction: number;
  /** 实付款 */
  actualPayment: number;
};

/** 获取订单详情API */
export const getOrderDetailAPI = (orderId: string) => {
  return request({ url: '/patient/consult/order/detail', params: { orderId } })
}

import type { ConsultOrderItem } from "@/types/consult";
import { getOrderDetailAPI } from "@/services/consult";

const consult = ref<ConsultOrderItem>();
const loadDetailData = async () => {
  const res = await getOrderDetailAPI(route.query.orderId as string);
  consult.value = res.data;
};

onMounted(loadDetailData);

// 订单状态 在onMounted注册
socket.on("statusChange", loadDetailData);

import { OrderType } from "@/enums";

interface Props {
  status?: OrderType;
  countdown?: number;
}

const { status, countdown = 0 } = defineProps<Props>();

defineProps<{ disabled: boolean }>();

import { ref } from "vue";
const text = ref("");

const emit = defineEmits<{
  (e: "send-text", text: string): void;
}>();

const onSendText = () => {
  emit("send-text", text.value);
  text.value = "";
};

const sendText = (text: string) => {
  // 发送消息
};

const sendText = (text: string) => {
  // 发送信息需要  发送人  收消息人  消息类型  消息内容
  socket.emit("sendChatMsg", {
    from: store.userInfo?.id,
    to: consult.value?.docInfo?.id,
    msgType: MsgType.MsgText,
    msg: { content: text },
  });
};

// 接收消息 在onMounted注册
socket.on("receiveChatMsg", async (event) => {
  list.value.push(event);
  nextTick(() => {
    window.scrollTo(0, document.body.scrollHeight);
  });
});

import dayjs from "dayjs";

const formatTime = (time: string) => dayjs(time).format("HH:mm");

import { uploadImageAPI } from "@/services/consult";
import type { Image } from "@/types/consult";
import type { UploaderAfterRead } from "vant/lib/uploader/types";

const onSendImage: UploaderAfterRead = async (data) => {
  if (Array.isArray(data)) return;
  if (!data.file) return;
  const t = showLoadingToast("正在上传");
  const res = await uploadImageAPI(data.file);
  t.close();
  emit("send-image", res.data);
};

import type { Image } from "@/types/consult";

const onSendImage = (img: Image) => {
  socket.emit("sendChatMsg", {
    from: store.userInfo?.id,
    to: consult.value?.docInfo?.id,
    msgType: MsgType.MsgImage,
    msg: { picture: img },
  });
};

const loading = ref(false);
const onRefresh = () => {
  // 触发下拉
};

const nextTime = ref('');

const onRefresh = () => {
  socket.emit("getChatMsgList", 20, time.value, route.query.orderId);
};

const finished = ref(false)

// 建立连接成功
socket.on("connect", () => {
  list.value = [];
});

/** 查看处方API */
export const getPrescriptionPicAPI = (id: string) => {
  return request(`/patient/consult/prescription/${id}`)
}

import { getPrescriptionPicAPI } from "@/services/consult";
import { showImagePreview } from "vant";

const showPrescription = async (id?: string) => {
  if (id) {
    const res = await getPrescriptionPicAPI(id);
    showImagePreview([res.data.url]);
  }
};

import { useRouter } from "vue-router";
import { PrescriptionStatus } from "@/enums";

// 点击处方的跳转
const router = useRouter();
const onBuy = (pre: Prescription) => {
  if (pre.status === PrescriptionStatus.Invalid) return showToast("处方已失效");
  if (pre.status === PrescriptionStatus.NotPayment && !pre.orderId)
    return router.push(`/order/pay?id=${pre.id}`);
  router.push(`/order/${pre.orderId}`);
};

import type { EvaluateDoc } from "@/types/room";

defineProps<{
  evaluateDoc?: EvaluateDoc;
}>();

import { computed, inject, ref } from "vue";

const score = ref(0);
const anonymousFlag = ref(false);
const content = ref("");
const disabled = computed(() => !score.value || !content.value);

const onSubmit = async () => {
  if (!score.value) return showToast("请选择评分");
  if (!content.value) return showToast("请输入评价");
};

type EvaluateOrderParams = {
  docId: string;
  orderId: string;
  score: number;
  content: string;
  anonymousFlag: 0 | 1;
};

// 评价问诊
export const evaluateOrderAPI = (data: EvaluateOrderParams) => {
  return request({ url: "/patient/order/evaluate", method: "POST", data });
};

import { provide } from "vue";
// ...
provide("consult", consult);

import { inject, type Ref } from "vue";
import type { ConsultOrderItem } from "@/types/consult";

const consult = inject<Ref<ConsultOrderItem>>("consult");

const completeEva = (score: number) => {
  const item = list.value.find((item) => item.msgType === MsgType.CardEvaForm);
  if (item) {
    item.msg.evaluateDoc = { score };
    item.msgType = MsgType.CardEva;
  }
};
provide("completeEva", completeEva);