web-core-tcm 0.0.24 → 0.0.25

package/src/api/check/alova/implement/check.ts

@@ -0,0 +1,165 @@
+import { Check, Payment } from 'src/api/check/check';
+
+export class AlovaCheck extends Check {
+  override async get() {
+    return this.of(
+      await checkApi.checkStateRestful
+        .getCheckState({
+          pathParams: {
+            id: this.id,
+          },
+          async transform(res) {
+            return new AlovaCheck().of(res);
+          },
+        })
+        .send(),
+    );
+  }
+
+  override async put() {
+    return this.of(
+      await checkApi.checkStateRestful
+        .putCheckState({
+          pathParams: {
+            id: this.id,
+          },
+          data: this.state(),
+        })
+        .send(true),
+    );
+  }
+
+  override async post() {
+    return this.of(
+      await checkApi.checkStateRestful
+        .postCheckState({
+          data: this.state(),
+        })
+        .send(true),
+    );
+  }
+  override delete() {
+    void checkApi.checkStateRestful
+      .deleteCheckState({
+        pathParams: {
+          id: this.id,
+        },
+      })
+      .send();
+    return Promise.resolve();
+  }
+  static override query(
+    page: number,
+    pageSize: number,
+    sort: string,
+    patientId?: string,
+    doctorId?: string,
+    startTime?: string,
+    endTime?: string,
+    patientName?: string,
+    patientGender?: string,
+    patientPhoneNumber?: string,
+  ) {
+    return checkApi.checkStateRestful
+      .queryCheckState({
+        params: {
+          ...{ ...(patientId && { patientId }) },
+          ...{ ...(doctorId && { doctorId }) },
+          ...{ ...(startTime && { startTime }) },
+          ...{ ...(endTime && { endTime }) },
+          ...{ ...(patientName && { patientName }) },
+          ...{ ...(patientGender && { patientGender }) },
+          ...{ ...(patientPhoneNumber && { patientPhoneNumber }) },
+          pageSize,
+          page,
+          sort,
+        },
+        async transform(res) {
+          const data = await Promise.all(
+            res.content.map((item) => {
+              return new AlovaCheck().of(item);
+            }),
+          );
+          return {
+            data: data,
+            total: res.totalElements,
+            page: res.number,
+            pageSize: res.size,
+            pageCount: res.totalPages,
+            isLastPage: res.last,
+          };
+        },
+      })
+      .send();
+  }
+  static override queryPayment(
+    page: number,
+    pageSize: number,
+    doctorId?: string,
+    patientId?: string,
+    patientName?: string,
+    patientPhone?: string,
+    prescriptionPaymentStatus?: number,
+    outboundStatus?: number,
+  ) {
+    return checkApi.checkStateRestful
+      .queryPaymentState({
+        params: {
+          ...{ ...(doctorId && { doctorId }) },
+          ...{ ...(patientId && { patientId }) },
+          ...{ ...(patientName && { patientName }) },
+          ...{ ...(patientPhone && { patientPhone }) },
+          ...{ ...(prescriptionPaymentStatus && { prescriptionPaymentStatus }) },
+          ...{ ...(outboundStatus && { outboundStatus }) },
+          pageSize: pageSize,
+          page: page,
+        },
+        async transform(res) {
+          const data = await Promise.all(
+            res.content.map((item) => {
+              return new AlovaPayment().of(item);
+            }),
+          );
+          return {
+            data: data,
+            total: res.totalElements,
+            page: res.number,
+            pageSize: res.size,
+            pageCount: res.totalPages,
+            isLastPage: res.last,
+          };
+        },
+      })
+      .send();
+  }
+}
+export class AlovaPayment extends Payment {
+  override async putOutboundStatus(status: number) {
+    this.outboundStatus = status;
+    await checkApi.checkStateRestful
+      .putCheckState({
+        pathParams: {
+          id: this.id,
+        },
+        data: {
+          outboundStatus: status,
+        },
+      })
+      .send(true);
+    return Promise.resolve(this);
+  }
+  override async putPrescriptionPaymentStatus(status: number) {
+    this.prescriptionPaymentStatus = status;
+    await checkApi.checkStateRestful
+      .putCheckState({
+        pathParams: {
+          id: this.id,
+        },
+        data: {
+          prescriptionPaymentStatus: status,
+        },
+      })
+      .send(true);
+    return Promise.resolve(this);
+  }
+}

package/src/api/check/alova/implement/index.ts

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

package/src/api/check/alova/index.ts

@@ -0,0 +1,22 @@
+import { createAlova } from 'alova';
+import fetchAdapter from 'alova/fetch';
+import { createApis, withConfigType, mountApis } from './createApis';
+import { onAuthRequired, responded } from 'src/api/config/alova';
+import { getServiceEndpoint, ServiceType } from 'src/api/config';
+
+export const alovaInstance = createAlova({
+  baseURL: getServiceEndpoint(ServiceType.Check),
+  requestAdapter: fetchAdapter(),
+  beforeRequest: onAuthRequired(),
+  cacheFor: null,
+  responded: responded,
+});
+
+export const $$userConfigMap = withConfigType({});
+
+const Apis = createApis(alovaInstance, $$userConfigMap);
+
+mountApis(Apis);
+
+export default Apis;
+export * from './implement';

package/src/api/check/check.ts

@@ -0,0 +1,217 @@
+import { Patient } from 'src/api/patient/patient';
+import type { Page } from 'src/api/patient/core';
+import { Tag } from 'src/api/patient/core';
+import { NetworkObject, Sequence } from 'src/api/patient/core';
+import type { CheckState, PaymentState } from 'src/api/check/alova/globals';
+import { Metas } from 'src/api/patient/meta';
+import { Prescription } from 'src/api/prescription/prescription';
+import { AlovaPrescription } from 'src/api/prescription/alova/implement/prescription';
+import type { PrescriptionState } from 'src/api/prescription/alova/globals';
+import { extractPlainText } from 'src/util/RichTextUtil';
+import { Doctor } from 'src/api/doctor/doctor';
+import { Herbal } from 'src/api/prescription';
+import type { IBuilder } from 'builder-pattern';
+import { Builder } from 'builder-pattern';
+
+export abstract class Check extends NetworkObject {
+  static override builder(): IBuilder<Check> {
+    return Builder(this._default) as unknown as IBuilder<Check>;
+  }
+  static override default(): typeof Check {
+    return this._default as unknown as typeof Check;
+  }
+  id: string = '';
+  doctor: Doctor = Doctor.builder().build();
+  patient: Patient = Patient.builder().build();
+  diagnosis: string = '';
+  tags: Tag[] = [] as Tag[];
+  prescriptions: Sequence<Prescription> = new Sequence<Prescription>();
+  createdTimestamp: string = Date.now().toString();
+  updatedTimestamp: string = Date.now().toString();
+  prescriptionPaymentStatus: number = 0;
+  outboundStatus: number = 0;
+  //购买类型
+  paymentType: string = '医保';
+  //就诊方式
+  outpatientType: string = '预约';
+  draft: boolean = false;
+  isEditing: boolean = false;
+  metas: Metas = Metas.builder().build();
+  constructor() {
+    super();
+    const prescription = Prescription.builder().build();
+    prescription.herbals.push(Herbal.builder().build());
+    this.prescriptions.data.push(prescription);
+  }
+  async of(json: CheckState) {
+    if (json.tagsState != undefined)
+      this.tags = await Promise.all(
+        json.tagsState.map((item) => {
+          const clTag = new Tag();
+          return clTag.of(item);
+        }),
+      );
+    if (json.id != undefined) this.id = json.id;
+    if (json.prescriptionsState != undefined) {
+      this.prescriptions = new Sequence<AlovaPrescription>();
+      const prescriptionStates = JSON.parse(json.prescriptionsState) as PrescriptionState[];
+      const prescription = await Promise.all(
+        prescriptionStates.map(async (item) => {
+          return new AlovaPrescription().of(item);
+        }),
+      );
+      this.prescriptions.data.push(...prescription);
+    }
+    if (this.prescriptions.data.length === 0)
+      this.prescriptions.data.push(Prescription.builder().build());
+    if (json.diagnosis != undefined) {
+      if (json.diagnosis.indexOf('脉证') !== 0 && json.diagnosis.indexOf('\n脉证') === -1) {
+        json.diagnosis = json.diagnosis.replaceAll('脉证', '\n脉证');
+      }
+      if (json.diagnosis.indexOf('\n方证') === -1) {
+        json.diagnosis = json.diagnosis.replaceAll('方证', '\n方证');
+      }
+      this.diagnosis = extractPlainText(json.diagnosis);
+    }
+    if (json.doctorState != undefined) this.doctor = await this.doctor.of(json.doctorState);
+    if (json.patientState != undefined) this.patient = await this.patient.of(json.patientState);
+    if (json.createdTimestamp != undefined) this.createdTimestamp = json.createdTimestamp!;
+    if (json.updatedTimestamp != undefined) this.updatedTimestamp = json.updatedTimestamp!;
+    if (json.prescriptionPaymentStatus != undefined)
+      this.prescriptionPaymentStatus = json.prescriptionPaymentStatus!;
+    if (json.outboundStatus != undefined) this.outboundStatus = json.outboundStatus!;
+    if (json.paymentType != undefined) this.paymentType = json.paymentType!;
+    if (json.outpatientType != undefined) this.outpatientType = json.outpatientType!;
+    if (json.metasState != undefined) {
+      this.metas.addMetas(await Promise.all(json.metasState.map((item) => Metas.map(item))));
+    }
+    return this;
+  }
+
+  state() {
+    console.log(this);
+    const state = {} as CheckState;
+    state.id = this.id;
+    state.doctorState = this.doctor.state();
+    state.patientState = this.patient.state();
+    state.outpatientType = this.outpatientType;
+    state.paymentType = this.paymentType;
+    // Note: We can't populate metaIds here as it would create a circular dependency
+    // The metaIds should be populated by the caller if needed
+    state.diagnosis = extractPlainText(this.diagnosis.replace('</div>', '\n<div>'));
+    state.createdTimestamp = this.createdTimestamp;
+    // Note: We'll leave prescriptions handling for the caller due to complexity
+    state.diagnosis = this.diagnosis;
+    state.tagsState = this.tags.map((item) => item.state());
+    state.createdTimestamp = this.createdTimestamp;
+    state.updatedTimestamp = this.updatedTimestamp;
+    state.prescriptionsState = JSON.stringify(this.prescriptions.data.map((item) => item.state()));
+    state.metasState = Metas.standards().flatMap((type) =>
+      this.metas[type].data.map((item) => item.state()),
+    );
+    return state;
+  }
+  abstract get(): Promise<this>;
+  abstract put(): Promise<this>;
+  abstract post(): Promise<this>;
+  abstract delete(): Promise<void>;
+
+  static query(
+    page: number,
+    pageSize: number,
+    sort: string,
+    patientId?: string,
+    doctorId?: string,
+    startTime?: string,
+    endTime?: string,
+    patientName?: string,
+    patientGender?: string,
+    patientPhoneNumber?: string,
+  ): Promise<Page<Check>> {
+    return Check.default().query(
+      page,
+      pageSize,
+      sort,
+      patientId,
+      doctorId,
+      startTime,
+      endTime,
+      patientName,
+      patientGender,
+      patientPhoneNumber,
+    );
+  }
+  static queryPayment(
+    page: number,
+    pageSize: number,
+    doctorId?: string,
+    patientId?: string,
+    patientName?: string,
+    patientPhone?: string,
+    prescriptionPaymentStatus?: number,
+    outboundStatus?: number,
+  ): Promise<Page<Payment>> {
+    return Check.default().queryPayment(
+      page,
+      pageSize,
+      doctorId,
+      patientId,
+      patientName,
+      patientPhone,
+      prescriptionPaymentStatus,
+      outboundStatus,
+    );
+  }
+}
+export abstract class Payment extends NetworkObject {
+  static override builder(): IBuilder<Payment> {
+    return Builder(this._default) as unknown as IBuilder<Payment>;
+  }
+  static override default(): typeof Payment {
+    return this._default as unknown as typeof Payment;
+  }
+  id: string = '';
+  prescription: string = '';
+  doctorId: string = '';
+  patientId: string = '';
+  patientName: string = '';
+  patientPhone: string = '';
+  patientGender: string = '';
+  createdTimestamp: number = 0;
+  updatedTimestamp: number = 0;
+  prescriptionPaymentStatus: number = 0;
+  outboundStatus: number = 0;
+  async of(json: PaymentState) {
+    this.id = json.id!;
+    this.prescription = json.prescription ? json.prescription : '';
+    this.doctorId = json.doctorId!;
+    this.patientId = json.patientId!;
+    this.patientName = json.patientName ? json.patientName : '';
+    this.patientPhone = json.patientPhone ? json.patientPhone : '';
+    this.patientGender = json.patientGender ? json.patientGender : '';
+    this.createdTimestamp = json.createdTimestamp ? json.createdTimestamp : 0;
+    this.updatedTimestamp = json.updatedTimestamp ? json.updatedTimestamp : 0;
+    this.prescriptionPaymentStatus = json.prescriptionPaymentStatus
+      ? json.prescriptionPaymentStatus
+      : 0;
+    this.outboundStatus = json.outboundStatus ? json.outboundStatus : 0;
+    return Promise.resolve(this);
+  }
+  state(): PaymentState {
+    return {
+      id: this.id,
+      prescription: this.prescription,
+      doctorId: this.doctorId,
+      patientId: this.patientId,
+      patientName: this.patientName,
+      patientPhone: this.patientPhone,
+      patientGender: this.patientGender,
+      createdTimestamp: this.createdTimestamp,
+      updatedTimestamp: this.updatedTimestamp,
+      prescriptionPaymentStatus: this.prescriptionPaymentStatus,
+      outboundStatus: this.outboundStatus,
+    };
+  }
+  abstract putOutboundStatus(status: number): Promise<this>;
+  abstract putPrescriptionPaymentStatus(status: number): Promise<this>;
+}

package/src/api/check/index.ts

@@ -0,0 +1,2 @@
+export * from './check';
+export * from './alova';

package/src/api/config/alova/index.ts

@@ -0,0 +1,71 @@
+import { createClientTokenAuthentication } from 'alova/client';
+import { storageHelper } from 'src/util/helper';
+import { jwtDecode } from 'jwt-decode';
+import type { Method } from 'alova';
+
+export const { onAuthRequired } = createClientTokenAuthentication({
+  assignToken: (method) => {
+    if (!storageHelper.getItem('token')) {
+      return;
+    }
+    method.config.headers.Authorization = 'Bearer ' + storageHelper.getItem('token');
+  },
+  visitorMeta: {
+    isVisitor: true,
+  },
+  login: {
+    metaMatches: {
+      login: true,
+    },
+    handler: async (response: Response) => {
+      if (response.status != 200) throw new Error('登录失败' + (await response.text()));
+      await response.json().then((data) => {
+        storageHelper.setItem('token', data.token);
+      });
+    },
+  },
+  refreshToken: {
+    // 在请求前触发，将接收到method参数，并返回boolean表示token是否过期
+    isExpired: () => {
+      if (!storageHelper.getItem('token')) return false;
+      const decoded = jwtDecode(storageHelper.getItem('token'));
+      // 如果没有 exp 声明，默认永不过期
+      if (decoded.exp === undefined) return false;
+
+      // 获取当前时间（秒）
+      const currentTime = Date.now() / 1000;
+
+      // 检查是否过期
+      return decoded.exp < currentTime;
+    },
+
+    // 当token过期时触发，在此函数中触发刷新token
+    handler: async () => {
+      // token刷新失败，跳转回登录页
+      storageHelper.removeItem('token');
+      window.location.href = '登录';
+      return await Promise.resolve();
+    },
+  },
+});
+export const responded = {
+  onSuccess: async (response: Response, method: Method) => {
+    if (response.status == 401) {
+      if (method.meta['Login']) {
+        throw new Error(response.status.toString());
+      }
+      console.log('未登录');
+      storageHelper.removeItem('token');
+      window.location.href = process.env.APP_URL!;
+    }
+    if ('application/octet-stream' == response.headers.get('Content-Type')) return response;
+    if (response.status == 200 || response.status == 201 || response.status == 204) {
+      const raw = await response.text();
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
+      }
+    }
+  },
+};

package/src/api/config/index.ts

@@ -0,0 +1,132 @@
+import punycode from 'punycode';
+//设置服务类型有哪些
+export enum ServiceType {
+  OAuth = 'OAuth',
+  OAuthRedirect = 'OAuthRedirect',
+  Doctor = 'Doctor',
+  Patient = 'Patient',
+  Scientist = 'Scientist',
+  Outpatient = 'Outpatient',
+  Check = 'Check',
+  Prescription = 'Prescription',
+  Authorization = 'Authorization',
+  InspectionsAlgorithm = 'InspectionsAlgorithm',
+  PulsationsAlgorithm = 'PulsationsAlgorithm',
+  InquiriesAlgorithm = 'InquiriesAlgorithm',
+  LisemsAlgorithm = 'LisemsAlgorithm',
+  ComprehensiveAlgorithm = 'ComprehensiveAlgorithm',
+}
+//设置服务类型有哪些
+export enum EnvironmentType {
+  Dev = 'Dev',
+  Prod = 'Prod',
+  Local = 'Local',
+}
+export const getServiceEndpoint = (serviceType: ServiceType, env?: EnvironmentType) => {
+  if (env == undefined) {
+    if (punycode.toUnicode(window.location.hostname).includes('测试')) env = EnvironmentType.Dev;
+    else if (
+      window.location.hostname.includes('localhost') ||
+      window.location.hostname.includes('127.0.0.1')
+    )
+      env = EnvironmentType.Prod;
+    else env = EnvironmentType.Prod;
+  }
+  if (env == EnvironmentType.Prod) {
+    switch (serviceType) {
+      case ServiceType.OAuth:
+        return 'https://用户.仪联中.中国';
+      case ServiceType.OAuthRedirect:
+        return 'https://用户.仪联中.中国/互联/服务/互联/授权?response_type=code&state=1223&client_id=tcm&scope=profile';
+      case ServiceType.Doctor:
+        return 'https://中医.仪联中.中国';
+      case ServiceType.Patient:
+        return 'https://中医.仪联中.中国';
+      case ServiceType.Scientist:
+        return 'https://中医.仪联中.中国';
+      case ServiceType.Outpatient:
+        return 'https://中医.仪联中.中国';
+      case ServiceType.Check:
+        return 'https://中医.仪联中.中国';
+      case ServiceType.Prescription:
+        return 'https://中医.仪联中.中国';
+      case ServiceType.Authorization:
+        return 'https://中医.仪联中.中国';
+      case ServiceType.InspectionsAlgorithm:
+        return 'https://中医.仪联中.中国/望诊/算法';
+      case ServiceType.PulsationsAlgorithm:
+        return 'https://中医.仪联中.中国/切诊/算法';
+      case ServiceType.InquiriesAlgorithm:
+        return 'https://中医.仪联中.中国/问诊/算法';
+      case ServiceType.LisemsAlgorithm:
+        return 'https://中医.仪联中.中国/闻诊/算法';
+      case ServiceType.ComprehensiveAlgorithm:
+        return 'https://中医.仪联中.中国/四诊合参/算法';
+    }
+  } else if (env == EnvironmentType.Dev) {
+    switch (serviceType) {
+      case ServiceType.OAuth:
+        return 'https://用户测试.仪联中.中国';
+      case ServiceType.OAuthRedirect:
+        return 'https://用户测试.仪联中.中国/互联/服务/互联/授权?response_type=code&state=1223&client_id=tcm&scope=profile';
+      case ServiceType.Doctor:
+        return 'https://中医测试.仪联中.中国';
+      case ServiceType.Patient:
+        return 'https://中医测试.仪联中.中国';
+      case ServiceType.Scientist:
+        return 'https://中医测试.仪联中.中国';
+      case ServiceType.Outpatient:
+        return 'https://中医测试.仪联中.中国';
+      case ServiceType.Check:
+        return 'https://中医测试.仪联中.中国';
+      case ServiceType.Prescription:
+        return 'https://中医测试.仪联中.中国';
+      case ServiceType.Authorization:
+        return 'https://中医测试.仪联中.中国';
+      case ServiceType.InspectionsAlgorithm:
+        return 'https://中医测试.仪联中.中国/望诊/算法';
+      case ServiceType.PulsationsAlgorithm:
+        return 'https://中医测试.仪联中.中国/切诊/算法';
+      case ServiceType.InquiriesAlgorithm:
+        return 'https://中医测试.仪联中.中国/问诊/算法';
+      case ServiceType.LisemsAlgorithm:
+        return 'https://中医测试.仪联中.中国/闻诊/算法';
+      case ServiceType.ComprehensiveAlgorithm:
+        return 'https://中医测试.仪联中.中国/四诊合参/算法';
+    }
+  } else if (env == EnvironmentType.Local) {
+    switch (serviceType) {
+      case ServiceType.OAuth:
+        return 'http://localhost:8080';
+      case ServiceType.OAuthRedirect:
+        return 'https://用户.仪联中.中国/互联/服务/互联/授权?response_type=code&state=1223&client_id=tcm&scope=profile';
+      case ServiceType.Doctor:
+        return 'http://localhost:8080';
+      case ServiceType.Patient:
+        return 'http://localhost:8080';
+      case ServiceType.Scientist:
+        return 'http://localhost:8080';
+      case ServiceType.Outpatient:
+        return 'http://localhost:8080';
+      case ServiceType.Check:
+        return 'http://localhost:8080';
+      case ServiceType.Prescription:
+        return 'http://localhost:8080';
+      case ServiceType.Authorization:
+        return 'http://localhost:8080';
+      case ServiceType.InspectionsAlgorithm:
+        return 'http://localhost:8080';
+      case ServiceType.PulsationsAlgorithm:
+        return 'http://localhost:8080';
+      case ServiceType.InquiriesAlgorithm:
+        return 'http://localhost:8080';
+      case ServiceType.LisemsAlgorithm:
+        return 'http://localhost:8080';
+      case ServiceType.ComprehensiveAlgorithm:
+        return 'http://localhost:8080';
+    }
+  }
+  throw new Error('环境错误');
+};
+
+export * from './alova';

package/src/api/device/device.js

@@ -0,0 +1,58 @@
+import { ref } from 'vue';
+import { useQuasar } from 'quasar';
+
+const $q = useQuasar();
+export const port = ref();
+
+export async function connectToSerialPort() {
+  try {
+    const SerialOptions = {
+      baudRate: 115200,
+      dataBits: 8,
+      stopBits: 1,
+      bufferSize: 1024,
+    };
+    port.value = await navigator.serial.requestPort();
+    if (!port.value) {
+      $q.dialog({
+        title: '错误',
+        message: '未选择串口',
+      });
+      return false;
+    }
+    await port.value.open(SerialOptions);
+    console.log('port', port.value.getInfo());
+    return true;
+  } catch (error) {
+    console.error('Error connecting to serial port:', error);
+    $q.dialog({
+      title: '错误',
+      message: '连接串口失败',
+    });
+    return false;
+  }
+}
+export function getPortInfo() {
+  return port.value?.getInfo();
+}
+export async function disconnectToSerialPort() {
+  if (!port.value) {
+    console.error('Serial port not available');
+    return;
+  }
+  await port.value.close();
+  port.value = null;
+  console.log('Serial port disconnected');
+}
+
+export async function sendText(text) {
+  if (port.value) {
+    const writer = port.value.writable.getWriter();
+    console.log('text', text);
+
+    await writer.write(new TextEncoder().encode(text));
+    await writer.close();
+  } else {
+    console.error('Serial port not available');
+  }
+}