web-core-tcm 0.0.25 → 0.0.27

package/src/api/patient/core.ts

@@ -1,133 +0,0 @@
-import type { AnnotationState, TagState } from 'src/api/patient/alova/globals';
-import type { IBuilder } from 'builder-pattern';
-import { Builder } from 'builder-pattern';
-export class Page<T> {
-  data: T[] = [];
-  total: number = 0;
-  page: number = 0;
-  pageSize: number = 0;
-  pageCount: number = 0;
-  isLastPage: boolean = false;
-}
-abstract class NetworkObject {
-  static _default: typeof NetworkObject = NetworkObject;
-  static builder(): IBuilder<unknown> {
-    return Builder(this._default);
-  }
-  static default(): typeof NetworkObject {
-    return NetworkObject;
-  }
-  abstract of(json: unknown): Promise<this>;
-  abstract state(): unknown;
-}
-
-class Annotation extends NetworkObject {
-  value: string = '';
-  actor: string = '';
-  timestamp: string = '';
-  static override builder(): IBuilder<Annotation> {
-    return Builder(Annotation) as unknown as IBuilder<Annotation>;
-  }
-  constructor(value: string = '', actor: string = '', timestamp: string = '') {
-    super();
-    this.value = value;
-    this.actor = actor;
-    this.timestamp = timestamp;
-  }
-  override of(json: AnnotationState) {
-    this.value = json.value!;
-    this.actor = json.actor!;
-    this.timestamp = json.timestamp!;
-    return Promise.resolve(this);
-  }
-  override state(): AnnotationState {
-    return {
-      value: this.value,
-      actor: this.actor,
-      timestamp: this.timestamp,
-    };
-  }
-}
-
-class Tag extends NetworkObject {
-  static override builder(): IBuilder<Tag> {
-    return Builder(Tag) as unknown as IBuilder<Tag>;
-  }
-  static override default(): typeof Tag {
-    return Tag;
-  }
-  key: string = '';
-  annotations: Annotation[] = [];
-  constructor(key: string = '', annotations: Annotation[] = []) {
-    super();
-    this.key = key;
-    this.annotations = annotations;
-  }
-  override async of(json: TagState): Promise<this> {
-    this.key = json.key!;
-    for (const item of json.annotationsState) {
-      this.annotations.push(await new Annotation().of(item));
-    }
-    return this;
-  }
-  override state(): TagState {
-    return {
-      key: this.key,
-      annotationsState: this.annotations.map((item) => item.state()),
-    };
-  }
-  getLastValue(): string {
-    return this.getLastAnnotation().value;
-  }
-  getLastAnnotation(): Annotation {
-    return this.annotations[this.annotations.length - 1];
-  }
-  static getValueTagSet(tags: Tag[]): Tag[] {
-    const filterTag = [] as Tag[];
-    tags.forEach((tag) => {
-      const key = tag.key;
-      const value = tag.getLastAnnotation().value.slice(0, 10);
-      if (
-        filterTag.find(
-          (tag) => tag.key == key && tag.getLastAnnotation().value.slice(0, 10) == value,
-        )
-      )
-        return;
-      filterTag.push(tag);
-    });
-    return filterTag;
-  }
-  assign(tag: Tag) {
-    this.key = tag.key;
-    this.annotations = tag.annotations;
-    return this;
-  }
-}
-
-class Sequence<T> {
-  data: T[] = [];
-  current: T = {} as T;
-  showed: boolean = false;
-  constructor(data: T[] = [], current: T = {} as T) {
-    this.data = data;
-    this.current = current;
-  }
-  delete(item: T): T {
-    this.data.splice(this.data.indexOf(item), 1);
-    return item;
-  }
-  choose(item: T): T {
-    this.current = item;
-    return item;
-  }
-  clear(): this {
-    this.data.length = 0;
-    this.current = {} as T;
-    return this;
-  }
-  show(): Sequence<T> {
-    this.showed = true;
-    return this;
-  }
-}
-export { NetworkObject, Tag, Sequence, Annotation };

package/src/api/patient/meta.ts

@@ -1,570 +0,0 @@
-import type { Page } from 'src/api/patient/core';
-import { Sequence, Tag } from 'src/api/patient/core';
-import { NetworkObject } from 'src/api/patient/core';
-import { arrayBufferToImageBase64 } from 'src/util/image';
-import type { WaveMap } from 'src/proto/types/WaveMap_pb';
-import { WaveMapSchema, WaveSchema } from 'src/proto/types/WaveMap_pb';
-import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
-import type { MetaState } from 'src/api/patient/alova/globals';
-import type { Image, Images } from 'src/proto/types/Images_pb';
-import { ImageSchema, ImagesSchema } from 'src/proto/types/Images_pb';
-import { Patient } from 'src/api/patient/patient';
-import type { IBuilder } from 'builder-pattern';
-import { Builder } from 'builder-pattern';
-//Enum Type
-export enum MetaType {
-  Pulsation = 'pulsation',
-  Tongue = 'tongue',
-  Appendix = 'appendix',
-  PPG = 'ppg',
-  PCG = 'pcg',
-  ECG = 'ecg',
-  Scene = 'scene',
-  Face = 'face',
-  Complaint = 'complaint',
-  Meta = 'meta',
-}
-export abstract class Meta extends NetworkObject {
-  static override builder(): IBuilder<unknown> {
-    return Builder(this._default) as unknown as IBuilder<Meta>;
-  }
-  static override default(): typeof Meta {
-    return this._default as unknown as typeof Meta;
-  }
-  id: string = '';
-  owner: Patient = Patient.builder().build();
-  type: MetaType = MetaType.Face;
-  tags: Tag[] = [] as Tag[];
-  createdTimestamp: string = '0';
-  updatedTimestamp: string = '0';
-
-  isSelected: boolean = false;
-  override async of(json: MetaState): Promise<this> {
-    if (json.id != undefined) this.id = json.id;
-    if (json.ownerState != undefined)
-      this.owner = await Patient.builder().build().of(json.ownerState);
-    if (json.tagsState != undefined)
-      this.tags = await Promise.all(json.tagsState.map((tag) => Tag.builder().build().of(tag)));
-    if (json.createdTimestamp != undefined) this.createdTimestamp = json.createdTimestamp;
-    if (json.updatedTimestamp != undefined) this.updatedTimestamp = json.updatedTimestamp;
-    if (json.type != undefined) this.type = json.type as MetaType;
-    return Promise.resolve(this);
-  }
-  override state(): MetaState {
-    return {
-      id: this.id,
-      ownerState: this.owner.state(),
-      type: this.type,
-      tagsState: this.tags.map((tag) => tag.state()),
-      createdTimestamp: this.createdTimestamp,
-      updatedTimestamp: this.updatedTimestamp,
-    };
-  }
-  getTagValue(key: string): string | undefined {
-    const annotation = this.tags.find((tag) => tag.key == key)?.getLastAnnotation();
-    return annotation ? annotation.value : '';
-  }
-  putTags() {
-    return patientApi.metaStateRestful.putMetaState({
-      pathParams: {
-        id: this.id,
-      },
-      data: {
-        id: this.id,
-        tagsState: this.tags.map((tag) => tag.state()),
-      },
-    });
-  }
-  addTag(tag: Tag) {
-    this.tags.push(tag);
-    return this.putTags();
-  }
-  removeTag(tag: Tag) {
-    this.tags.splice(this.tags.indexOf(tag), 1);
-    return this.putTags();
-  }
-  abstract analyze(): Promise<this>;
-  abstract getObject(): Promise<unknown>;
-  abstract get(): Promise<this>;
-  abstract put(): Promise<this>;
-  abstract post(): Promise<this>;
-  abstract delete(): Promise<this>;
-  abstract serialize(object: unknown): ArrayBuffer;
-  abstract deserialize(buffer: ArrayBuffer): unknown;
-  abstract inject(object: unknown): Promise<this>;
-  static queryMetaWithPatient(
-    page: number,
-    pageSize: number,
-    owner?: Patient,
-    type?: string,
-    startTime?: string,
-    endTime?: string,
-    sort?: string,
-    patientName?: string,
-    patientPhoneNumber?: string,
-    patientStartBirthdate?: string,
-    patientEndBirthdate?: string,
-    patientGender?: string,
-    tags?: Tag[],
-  ): Promise<Page<Meta>> {
-    return this.default().queryMetaWithPatient(
-      page,
-      pageSize,
-      owner,
-      type,
-      startTime,
-      endTime,
-      sort,
-      patientName,
-      patientPhoneNumber,
-      patientStartBirthdate,
-      patientEndBirthdate,
-      patientGender,
-      tags,
-    );
-  }
-  static query(
-    page: number,
-    pageSize: number,
-    owner?: Patient,
-    type?: string,
-    startTime?: string,
-    endTime?: string,
-    sort = 'createdTimestamp:asc',
-  ): Promise<Page<Meta>> {
-    return this.default().query(page, pageSize, owner, type, startTime, endTime, sort);
-  }
-  static queryMetaStateByExactMatch(
-    id?: string[],
-    owner?: Patient[],
-    type?: string[],
-    pageSize?: number,
-    page?: number,
-    startTime?: string,
-    endTime?: string,
-    sort?: string,
-  ): Promise<Page<Meta>> {
-    return this.default().queryMetaStateByExactMatch(
-      id,
-      owner,
-      type,
-      pageSize,
-      page,
-      startTime,
-      endTime,
-      sort,
-    );
-  }
-}
-export abstract class ImageMeta extends Meta {
-  image?: Image;
-  base64Image: string = '';
-  // 测试序列化往返
-
-  override serialize(): ArrayBuffer {
-    if (!this.image) throw new Error('not found');
-    return toBinary(ImageSchema, this.image).buffer;
-  }
-  override deserialize(buffer: ArrayBuffer): string {
-    this.image = fromBinary(ImageSchema, new Uint8Array(buffer));
-    this.base64Image = arrayBufferToImageBase64(this.image.bytes);
-    return this.base64Image;
-  }
-  override inject(buffer: ArrayBuffer): Promise<this> {
-    if (buffer) {
-      this.image = create(ImageSchema, {
-        bytes: new Uint8Array(buffer),
-      });
-      this.base64Image = arrayBufferToImageBase64(new Uint8Array(buffer));
-    }
-    return Promise.resolve(this);
-  }
-  abstract override getObject(): Promise<string>;
-}
-export abstract class ImagesMeta extends Meta {
-  images?: Images;
-  base64Images: string[] = [];
-  override serialize(): ArrayBuffer {
-    if (!this.images) throw new Error('not found');
-    return toBinary(ImagesSchema, this.images).buffer;
-  }
-  override deserialize(buffer: ArrayBuffer): string[] {
-    this.images = fromBinary(ImagesSchema, new Uint8Array(buffer));
-    this.base64Images = this.images.images.map((item) => arrayBufferToImageBase64(item.bytes));
-    return this.base64Images;
-  }
-  override inject(buffers?: ArrayBuffer[]): Promise<this> {
-    if (buffers) {
-      this.images = create(ImagesSchema, {
-        images: buffers.map((buffer) => {
-          return create(ImageSchema, {
-            bytes: new Uint8Array(buffer),
-          });
-        }),
-      });
-      this.base64Images = buffers.map((buffer) => {
-        return arrayBufferToImageBase64(new Uint8Array(buffer));
-      });
-    }
-    return Promise.resolve(this);
-  }
-  abstract override getObject(): Promise<string[]>;
-}
-export abstract class TextMeta extends Meta {
-  text: string = '';
-  constructor() {
-    super();
-  }
-  override serialize(): ArrayBuffer {
-    return new TextEncoder().encode(this.text).buffer;
-  }
-  override deserialize(buffer: ArrayBuffer): string {
-    this.text = new TextDecoder().decode(buffer);
-    return this.text;
-  }
-  override inject(text?: string): Promise<this> {
-    if (text) {
-      this.text = text;
-    }
-    return Promise.resolve(this);
-  }
-  abstract override getObject(): Promise<string>;
-}
-export abstract class WavesMeta extends Meta {
-  waves: WaveMap | undefined;
-  override serialize(): ArrayBuffer {
-    console.log('serialize', this.waves);
-    if (this.waves) {
-      console.log('seruia');
-      console.log(toBinary(WaveMapSchema, this.waves), toBinary(WaveMapSchema, this.waves).buffer);
-      console.log('sss');
-    }
-    if (!this.waves) throw new Error('not found');
-    return toBinary(WaveMapSchema, this.waves).buffer;
-  }
-  override deserialize(buffer: ArrayBuffer): WaveMap {
-    this.waves = fromBinary(WaveMapSchema, new Uint8Array(buffer));
-    return this.waves;
-  }
-  abstract preprocess(origins: { [key: string]: number[] }): Promise<{ [key: string]: number[] }>;
-  override async inject(
-    origins?: { [key: string]: number[] },
-    smooths?: { [key: string]: number[] },
-  ): Promise<this> {
-    if (!smooths && origins) {
-      smooths = await this.preprocess(origins);
-    }
-    console.log(origins, smooths);
-    if (origins && smooths) {
-      console.log(this.waves);
-      this.waves = create(WaveMapSchema, {
-        origin: Object.fromEntries(
-          Object.entries(origins).map(([key, value]) => [
-            key,
-            create(WaveSchema, {
-              values: value,
-            }),
-          ]),
-        ),
-        smooth: Object.fromEntries(
-          Object.entries(smooths).map(([key, value]) => [
-            key,
-            create(WaveSchema, {
-              values: value,
-            }),
-          ]),
-        ),
-      });
-      console.log(this.waves);
-    }
-    return Promise.resolve(this);
-  }
-  abstract override getObject(): Promise<WaveMap>;
-}
-export abstract class TongueMeta extends ImageMeta {
-  static override builder(): IBuilder<TongueMeta> {
-    return Builder(this._default) as unknown as IBuilder<TongueMeta>;
-  }
-  static override default(): typeof TongueMeta {
-    return this._default as unknown as typeof TongueMeta;
-  }
-  constructor() {
-    super();
-    this.type = MetaType.Tongue;
-  }
-}
-export abstract class FaceMeta extends ImageMeta {
-  static override builder(): IBuilder<FaceMeta> {
-    return Builder(this._default) as unknown as IBuilder<FaceMeta>;
-  }
-  static override default(): typeof FaceMeta {
-    return this._default as unknown as typeof FaceMeta;
-  }
-  constructor() {
-    super();
-    this.type = MetaType.Face;
-  }
-}
-export abstract class SceneMeta extends ImageMeta {
-  static override builder(): IBuilder<SceneMeta> {
-    return Builder(this._default) as unknown as IBuilder<SceneMeta>;
-  }
-  static override default(): typeof SceneMeta {
-    return this._default as unknown as typeof SceneMeta;
-  }
-  constructor() {
-    super();
-    this.type = MetaType.Scene;
-  }
-}
-export abstract class PulsationMeta extends WavesMeta {
-  static override builder(): IBuilder<PulsationMeta> {
-    return Builder(this._default) as unknown as IBuilder<PulsationMeta>;
-  }
-  static override default(): typeof PulsationMeta {
-    return this._default as unknown as typeof PulsationMeta;
-  }
-  constructor() {
-    super();
-    this.type = MetaType.Pulsation;
-  }
-}
-export abstract class PPGMeta extends WavesMeta {
-  static override builder(): IBuilder<PPGMeta> {
-    return Builder(this._default) as unknown as IBuilder<PPGMeta>;
-  }
-  static override default(): typeof PPGMeta {
-    return this._default as unknown as typeof PPGMeta;
-  }
-  constructor() {
-    super();
-    this.type = MetaType.PPG;
-  }
-}
-export abstract class PCGMeta extends WavesMeta {
-  static override builder(): IBuilder<PCGMeta> {
-    return Builder(this._default) as unknown as IBuilder<PCGMeta>;
-  }
-  static override default(): typeof PCGMeta {
-    return this._default as unknown as typeof PCGMeta;
-  }
-  constructor() {
-    super();
-    this.type = MetaType.PCG;
-  }
-}
-export abstract class ECGMeta extends WavesMeta {
-  static override builder(): IBuilder<ECGMeta> {
-    return Builder(this._default) as unknown as IBuilder<ECGMeta>;
-  }
-  static override default(): typeof ECGMeta {
-    return this._default as unknown as typeof ECGMeta;
-  }
-  constructor() {
-    super();
-    this.type = MetaType.ECG;
-  }
-}
-export abstract class AppendixMeta extends ImagesMeta {
-  static override builder(): IBuilder<AppendixMeta> {
-    return Builder(this._default) as unknown as IBuilder<AppendixMeta>;
-  }
-  static override default(): typeof AppendixMeta {
-    return this._default as unknown as typeof AppendixMeta;
-  }
-  constructor() {
-    super();
-    this.type = MetaType.Appendix;
-  }
-}
-export abstract class ComplaintMeta extends TextMeta {
-  static override builder(): IBuilder<ComplaintMeta> {
-    return Builder(this._default) as unknown as IBuilder<ComplaintMeta>;
-  }
-  static override default(): typeof ComplaintMeta {
-    return this._default as unknown as typeof ComplaintMeta;
-  }
-  constructor() {
-    super();
-    this.type = MetaType.Complaint;
-  }
-}
-
-export class MetaSequence<T extends Meta> extends Sequence<T> {
-  type: MetaType;
-  owner?: Patient;
-  expand: boolean = false;
-  constructor(type: MetaType, owner?: Patient) {
-    super();
-    this.type = type;
-    if (owner) this.owner = owner;
-  }
-  init(owner: Patient) {
-    this.clear();
-    this.owner = Patient.builder().id(owner.id).build();
-  }
-  async query(
-    page: number,
-    pageSize: number,
-    startTime?: string,
-    endTime?: string,
-    sort?: string,
-  ): Promise<Page<Meta>> {
-    this.clear();
-    return this.append(page, pageSize, startTime, endTime, sort);
-  }
-  async append(
-    page: number,
-    pageSize: number,
-    startTime?: string,
-    endTime?: string,
-    sort?: string,
-  ): Promise<Page<Meta>> {
-    const pageable = await Meta.query(
-      page,
-      pageSize,
-      this.owner,
-      this.type,
-      startTime,
-      endTime,
-      sort,
-    );
-    this.data.unshift(...(pageable.data.reverse() as T[]));
-    return pageable;
-  }
-  async appendMetaWithPatient(
-    page: number,
-    pageSize: number,
-    type?: string,
-    startTime?: string,
-    endTime?: string,
-    sort?: string,
-    name?: string,
-    phoneNumber?: string,
-    startBirthdate?: string,
-    endBirthdate?: string,
-    gender?: string,
-    tags?: Tag[],
-  ): Promise<Page<Meta>> {
-    const pageable = await Meta.queryMetaWithPatient(
-      page,
-      pageSize,
-      this.owner,
-      type,
-      startTime,
-      endTime,
-      sort,
-      name,
-      phoneNumber,
-      startBirthdate,
-      endBirthdate,
-      gender,
-      tags,
-    );
-    this.data.unshift(...(pageable.data.reverse() as T[]));
-    return pageable;
-  }
-}
-export const MetaTypeConfig = {
-  [MetaType.Face]: { type: FaceMeta, name: '面象', icon: 'face', color: '#FF6B6B' },
-  [MetaType.Tongue]: { type: TongueMeta, name: '舌象', icon: 'face', color: '#4ECDC4' },
-  [MetaType.Complaint]: { type: ComplaintMeta, name: '主诉', icon: 'message', color: '#FFD166' },
-  [MetaType.Pulsation]: { type: PulsationMeta, name: '脉象', icon: 'ssid_chart', color: '#06D6A0' },
-  [MetaType.ECG]: { type: ECGMeta, name: '心电', icon: 'ssid_chart', color: '#118AB2' },
-  [MetaType.PCG]: { type: PCGMeta, name: '心音', icon: 'ssid_chart', color: '#073B4C' },
-  [MetaType.PPG]: { type: PPGMeta, name: '心光', icon: 'ssid_chart', color: '#7209B7' },
-  [MetaType.Scene]: { type: SceneMeta, name: '场景', icon: 'house', color: '#F72585' },
-  [MetaType.Appendix]: { type: AppendixMeta, name: '附件', icon: 'folder_open', color: '#3A86FF' },
-  [MetaType.Meta]: { type: Meta, name: '元', icon: 'tag', color: '#8338EC' },
-};
-export abstract class Metas {
-  static _default: typeof Metas;
-  static builder(): IBuilder<Metas> {
-    return Builder(this._default) as unknown as IBuilder<Metas>;
-  }
-  static default(): typeof Metas {
-    return this._default as unknown as typeof Metas;
-  }
-
-  [MetaType.Face] = new MetaSequence<FaceMeta>(MetaType.Face);
-  [MetaType.Tongue] = new MetaSequence<TongueMeta>(MetaType.Tongue);
-  [MetaType.Complaint] = new MetaSequence<ComplaintMeta>(MetaType.Complaint);
-  [MetaType.Pulsation] = new MetaSequence<PulsationMeta>(MetaType.Pulsation);
-  [MetaType.ECG] = new MetaSequence<ECGMeta>(MetaType.ECG);
-  [MetaType.PCG] = new MetaSequence<PCGMeta>(MetaType.PCG);
-  [MetaType.PPG] = new MetaSequence<PPGMeta>(MetaType.PPG);
-  [MetaType.Scene] = new MetaSequence<SceneMeta>(MetaType.Scene);
-  [MetaType.Appendix] = new MetaSequence<AppendixMeta>(MetaType.Appendix);
-  [MetaType.Meta] = new MetaSequence<Meta>(MetaType.Meta);
-  faces = this[MetaType.Face];
-  tongues = this[MetaType.Tongue];
-  complaints = this[MetaType.Complaint];
-  pulsations = this[MetaType.Pulsation];
-  ecgs = this[MetaType.ECG];
-  pcgs = this[MetaType.PCG];
-  ppgs = this[MetaType.PPG];
-  scenes = this[MetaType.Scene];
-  appendixes = this[MetaType.Appendix];
-  metas = this[MetaType.Meta];
-  constructor(metas?: Meta[]) {
-    if (metas) this.addMetas(metas);
-  }
-  init(owner: Patient): this {
-    for (const type of Object.values(MetaType)) {
-      this[type].init(owner);
-    }
-    return this;
-  }
-  async query(
-    page: number,
-    pageSize: number,
-    startTime?: string,
-    endTime?: string,
-    sort?: string,
-  ): Promise<this> {
-    for (const type of Object.values(MetaType)) {
-      //print
-      const metas = await this[type].query(page, pageSize, startTime, endTime, sort);
-      for (const meta of metas.data) {
-        (this[type].data as Meta[]).push(meta);
-      }
-    }
-    return this;
-  }
-  addMetas(metas: Meta[]) {
-    for (const meta of metas) {
-      this.addMeta(meta);
-    }
-    return this;
-  }
-  addMeta(meta: Meta) {
-    const exist = this[meta.type].data.find((item) => item.id == meta.id);
-    if (!exist) (this[meta.type].data as Meta[]).unshift(meta);
-    else void exist.of(meta);
-    return this;
-  }
-  clear() {
-    for (const type of Object.values(MetaType)) {
-      this[type].clear();
-    }
-  }
-  static map(meta: MetaState): Promise<Meta> {
-    return Metas.default().map(meta);
-  }
-  static mapText(type: MetaType) {
-    return MetaTypeConfig[type].name;
-  }
-  static standards(): MetaType[] {
-    return [
-      MetaType.Face,
-      MetaType.Tongue,
-      MetaType.Complaint,
-      MetaType.Pulsation,
-      MetaType.ECG,
-      MetaType.PCG,
-      MetaType.PPG,
-      MetaType.Scene,
-      MetaType.Appendix,
-    ];
-  }
-}