web-core-tcm 0.0.23 → 0.0.25

package/src/api/patient/meta.ts

@@ -1,18 +1,18 @@
-import type { Page} from '@core/api/patient/core';
-import { Sequence, Tag } from '@core/api/patient/core';
-import { NetworkObject } from '@core/api/patient/core';
-import { arrayBufferToImageBase64 } from '@core/util/image';
-import type { WaveMap} from '@core/proto/types/WaveMap_pb';
-import { WaveMapSchema, WaveSchema } from '@core/proto/types/WaveMap_pb';
+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 '@core/api/patient/alova/globals';
-import type { Image,Images} from '@core/proto/types/Images_pb';
-import { ImageSchema,ImagesSchema } from '@core/proto/types/Images_pb';
-import { Patient } from '@core/api/patient/patient';
+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{
+export enum MetaType {
   Pulsation = 'pulsation',
   Tongue = 'tongue',
   Appendix = 'appendix',
@@ -22,10 +22,10 @@ export enum MetaType{
   Scene = 'scene',
   Face = 'face',
   Complaint = 'complaint',
-  Meta = 'meta'
+  Meta = 'meta',
 }
-export abstract class Meta extends NetworkObject{
-  static override builder(): IBuilder<unknown>{
+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 {
@@ -39,28 +39,30 @@ export abstract class Meta extends NetworkObject{
   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;
+  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{
+  override state(): MetaState {
     return {
       id: this.id,
       ownerState: this.owner.state(),
       type: this.type,
-      tagsState: this.tags.map(tag => tag.state()),
+      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: '';
+  getTagValue(key: string): string | undefined {
+    const annotation = this.tags.find((tag) => tag.key == key)?.getLastAnnotation();
+    return annotation ? annotation.value : '';
   }
   putTags() {
     return patientApi.metaStateRestful.putMetaState({
@@ -69,35 +71,89 @@ export abstract class Meta extends NetworkObject{
       },
       data: {
         id: this.id,
-        tagsState: this.tags.map(tag => tag.state()),
-      }
-    })
+        tagsState: this.tags.map((tag) => tag.state()),
+      },
+    });
   }
-  addTag(tag: Tag){
-    this.tags.push(tag)
-    return this.putTags()
+  addTag(tag: Tag) {
+    this.tags.push(tag);
+    return this.putTags();
   }
-  removeTag(tag: Tag){
+  removeTag(tag: Tag) {
     this.tags.splice(this.tags.indexOf(tag), 1);
-    return this.putTags()
+    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)
+  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 {
@@ -106,53 +162,53 @@ export abstract class ImageMeta extends Meta {
   // 测试序列化往返
 
   override serialize(): ArrayBuffer {
-    if (!this.image)throw new Error("not found")
-    return toBinary(ImageSchema, this.image).buffer
+    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.image = fromBinary(ImageSchema, new Uint8Array(buffer));
     this.base64Image = arrayBufferToImageBase64(this.image.bytes);
-    return this.base64Image
+    return this.base64Image;
   }
   override inject(buffer: ArrayBuffer): Promise<this> {
     if (buffer) {
       this.image = create(ImageSchema, {
-        bytes: new Uint8Array(buffer)
+        bytes: new Uint8Array(buffer),
       });
       this.base64Image = arrayBufferToImageBase64(new Uint8Array(buffer));
     }
-    return Promise.resolve(this)
+    return Promise.resolve(this);
   }
-  abstract override getObject():Promise<string>
+  abstract override getObject(): Promise<string>;
 }
-export abstract class ImagesMeta extends Meta{
+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
+    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
+    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 => {
+        images: buffers.map((buffer) => {
           return create(ImageSchema, {
-            bytes: new Uint8Array(buffer)
+            bytes: new Uint8Array(buffer),
           });
-        })
+        }),
       });
-      this.base64Images = buffers.map(buffer => {
+      this.base64Images = buffers.map((buffer) => {
         return arrayBufferToImageBase64(new Uint8Array(buffer));
       });
     }
-    return Promise.resolve(this)
+    return Promise.resolve(this);
   }
-  abstract override getObject():Promise<string[]>
+  abstract override getObject(): Promise<string[]>;
 }
 export abstract class TextMeta extends Meta {
   text: string = '';
@@ -160,44 +216,47 @@ export abstract class TextMeta extends Meta {
     super();
   }
   override serialize(): ArrayBuffer {
-    return new TextEncoder().encode(this.text).buffer
+    return new TextEncoder().encode(this.text).buffer;
   }
   override deserialize(buffer: ArrayBuffer): string {
     this.text = new TextDecoder().decode(buffer);
-    return this.text
+    return this.text;
   }
   override inject(text?: string): Promise<this> {
     if (text) {
       this.text = text;
     }
-    return Promise.resolve(this)
+    return Promise.resolve(this);
   }
-  abstract override getObject():Promise<string>
+  abstract override getObject(): Promise<string>;
 }
-export abstract class WavesMeta extends Meta{
-  waves: WaveMap|undefined;
+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')
+    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
+    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
+    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)
+  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)
+    console.log(origins, smooths);
+    if (origins && smooths) {
+      console.log(this.waves);
       this.waves = create(WaveMapSchema, {
         origin: Object.fromEntries(
           Object.entries(origins).map(([key, value]) => [
@@ -205,7 +264,7 @@ export abstract class WavesMeta extends Meta{
             create(WaveSchema, {
               values: value,
             }),
-          ])
+          ]),
         ),
         smooth: Object.fromEntries(
           Object.entries(smooths).map(([key, value]) => [
@@ -213,29 +272,29 @@ export abstract class WavesMeta extends Meta{
             create(WaveSchema, {
               values: value,
             }),
-          ])
+          ]),
         ),
       });
-      console.log(this.waves)
+      console.log(this.waves);
     }
-    return Promise.resolve(this)
+    return Promise.resolve(this);
   }
-  abstract override getObject():Promise<WaveMap>
+  abstract override getObject(): Promise<WaveMap>;
 }
 export abstract class TongueMeta extends ImageMeta {
-  static override builder(): IBuilder<TongueMeta>{
+  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(){
+  constructor() {
     super();
     this.type = MetaType.Tongue;
   }
 }
 export abstract class FaceMeta extends ImageMeta {
-  static override builder(): IBuilder<FaceMeta>{
+  static override builder(): IBuilder<FaceMeta> {
     return Builder(this._default) as unknown as IBuilder<FaceMeta>;
   }
   static override default(): typeof FaceMeta {
@@ -247,7 +306,7 @@ export abstract class FaceMeta extends ImageMeta {
   }
 }
 export abstract class SceneMeta extends ImageMeta {
-  static override builder(): IBuilder<SceneMeta>{
+  static override builder(): IBuilder<SceneMeta> {
     return Builder(this._default) as unknown as IBuilder<SceneMeta>;
   }
   static override default(): typeof SceneMeta {
@@ -259,7 +318,7 @@ export abstract class SceneMeta extends ImageMeta {
   }
 }
 export abstract class PulsationMeta extends WavesMeta {
-  static override builder(): IBuilder<PulsationMeta>{
+  static override builder(): IBuilder<PulsationMeta> {
     return Builder(this._default) as unknown as IBuilder<PulsationMeta>;
   }
   static override default(): typeof PulsationMeta {
@@ -271,7 +330,7 @@ export abstract class PulsationMeta extends WavesMeta {
   }
 }
 export abstract class PPGMeta extends WavesMeta {
-  static override builder(): IBuilder<PPGMeta>{
+  static override builder(): IBuilder<PPGMeta> {
     return Builder(this._default) as unknown as IBuilder<PPGMeta>;
   }
   static override default(): typeof PPGMeta {
@@ -283,7 +342,7 @@ export abstract class PPGMeta extends WavesMeta {
   }
 }
 export abstract class PCGMeta extends WavesMeta {
-  static override builder(): IBuilder<PCGMeta>{
+  static override builder(): IBuilder<PCGMeta> {
     return Builder(this._default) as unknown as IBuilder<PCGMeta>;
   }
   static override default(): typeof PCGMeta {
@@ -295,7 +354,7 @@ export abstract class PCGMeta extends WavesMeta {
   }
 }
 export abstract class ECGMeta extends WavesMeta {
-  static override builder(): IBuilder<ECGMeta>{
+  static override builder(): IBuilder<ECGMeta> {
     return Builder(this._default) as unknown as IBuilder<ECGMeta>;
   }
   static override default(): typeof ECGMeta {
@@ -307,7 +366,7 @@ export abstract class ECGMeta extends WavesMeta {
   }
 }
 export abstract class AppendixMeta extends ImagesMeta {
-  static override builder(): IBuilder<AppendixMeta>{
+  static override builder(): IBuilder<AppendixMeta> {
     return Builder(this._default) as unknown as IBuilder<AppendixMeta>;
   }
   static override default(): typeof AppendixMeta {
@@ -319,7 +378,7 @@ export abstract class AppendixMeta extends ImagesMeta {
   }
 }
 export abstract class ComplaintMeta extends TextMeta {
-  static override builder(): IBuilder<ComplaintMeta>{
+  static override builder(): IBuilder<ComplaintMeta> {
     return Builder(this._default) as unknown as IBuilder<ComplaintMeta>;
   }
   static override default(): typeof ComplaintMeta {
@@ -340,7 +399,7 @@ export class MetaSequence<T extends Meta> extends Sequence<T> {
     this.type = type;
     if (owner) this.owner = owner;
   }
-  init(owner: Patient){
+  init(owner: Patient) {
     this.clear();
     this.owner = Patient.builder().id(owner.id).build();
   }
@@ -361,14 +420,49 @@ export class MetaSequence<T extends Meta> extends Sequence<T> {
     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
+    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 = {
@@ -381,11 +475,11 @@ export const MetaTypeConfig = {
   [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' }
+  [MetaType.Meta]: { type: Meta, name: '元', icon: 'tag', color: '#8338EC' },
 };
-export abstract class Metas{
-  static _default: typeof Metas
-  static builder(): IBuilder<Metas>{
+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 {
@@ -413,13 +507,13 @@ export abstract class Metas{
   appendixes = this[MetaType.Appendix];
   metas = this[MetaType.Meta];
   constructor(metas?: Meta[]) {
-    if(metas)this.addMetas(metas)
+    if (metas) this.addMetas(metas);
   }
-  init(owner: Patient): this{
+  init(owner: Patient): this {
     for (const type of Object.values(MetaType)) {
       this[type].init(owner);
     }
-    return this
+    return this;
   }
   async query(
     page: number,
@@ -431,36 +525,46 @@ export abstract class Metas{
     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){
+      for (const meta of metas.data) {
         (this[type].data as Meta[]).push(meta);
       }
     }
-    return this
+    return this;
   }
-  addMetas(metas: Meta[]){
-    for(const meta of metas){
-      this.addMeta(meta)
+  addMetas(metas: Meta[]) {
+    for (const meta of metas) {
+      this.addMeta(meta);
     }
-    return this
+    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
+  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(){
+  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]
+    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,
+    ];
   }
 }