web-core-tcm 0.0.23 → 0.0.25

package/src/api/patient/alova/implement/meta.ts

@@ -1,4 +1,4 @@
-import type { MetaState } from '@core/api/patient/alova/globals';
+import type { MetaState } from 'src/api/patient/alova/globals';
 import {
   AppendixMeta,
   ComplaintMeta,
@@ -12,14 +12,14 @@ import {
   PulsationMeta,
   SceneMeta,
   TongueMeta,
-} from '@core/api/patient/meta';
-import type { Page} from '@core/api/patient/core';
-import { Annotation, Tag } from '@core/api/patient/core';
-import { faceAnalyze, tongueAnalyze } from '@core/api/algorithm/inspectionsAlgorithm';
-import { base64ToArrayBuffer } from '@core/util/image';
-import { pulsationAnalysis, pulsationPreprocessing } from '@core/api/algorithm/pulsationsAlgorithm';
-import { analysisLisems } from '@core/api/algorithm/lisemsAlgorithm';
-import type { Patient } from '@core/api/patient/patient';
+} from 'src/api/patient/meta';
+import type { Page } from 'src/api/patient/core';
+import { Annotation, Tag } from 'src/api/patient/core';
+import { faceAnalyze, tongueAnalyze } from 'src/api/algorithm/inspectionsAlgorithm';
+import { base64ToArrayBuffer } from 'src/util/image';
+import { pulsationAnalysis, pulsationPreprocessing } from 'src/api/algorithm/pulsationsAlgorithm';
+import { analysisLisems } from 'src/api/algorithm/lisemsAlgorithm';
+import type { Patient } from 'src/api/patient/patient';
 
 export class AlovaMeta extends Meta {
   override deserialize(): Promise<this> {
@@ -32,7 +32,7 @@ export class AlovaMeta extends Meta {
     return new ArrayBuffer(0);
   }
   override getObject(): Promise<string> {
-    return Promise.resolve('')
+    return Promise.resolve('');
   }
   override async get(): Promise<this> {
     return this.of(await getState(this.id));
@@ -50,9 +50,23 @@ export class AlovaMeta extends Meta {
   override analyze(): Promise<this> {
     throw new Error('Method not implemented.');
   }
-  static override 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>> {
-    const tagsState = tags?.map(tag => tag.state())
-    const ownerState = owner?.state()
+  static override 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>> {
+    const tagsState = tags?.map((tag) => tag.state());
+    const ownerState = owner?.state();
     return patientApi.metaStateRestful
       .queryMetaAndPatientState({
         data: {
@@ -72,16 +86,16 @@ export class AlovaMeta extends Meta {
         },
         async transform(json) {
           const data = [] as Meta[];
-          for (const item of json.content!) {
+          for (const item of json.content) {
             data.push(await AlovaMetas.map(item));
           }
           return {
             data: data,
-            total: json.totalElements!,
-            page: json.number!,
-            pageSize: json.size!,
-            pageCount: json.totalPages!,
-            isLastPage: json.last!,
+            total: json.totalElements,
+            page: json.number,
+            pageSize: json.size,
+            pageCount: json.totalPages,
+            isLastPage: json.last,
           } as Page<Meta>;
         },
       })
@@ -96,7 +110,7 @@ export class AlovaMeta extends Meta {
     endTime?: string,
     sort?: string,
   ): Promise<Page<Meta>> {
-    const ownerState = owner?.state()
+    const ownerState = owner?.state();
     return patientApi.metaStateRestful
       .queryMetaState({
         data: {
@@ -110,16 +124,16 @@ export class AlovaMeta extends Meta {
         },
         async transform(json) {
           const data = [];
-          for (const item of json.content!) {
+          for (const item of json.content) {
             data.push(await AlovaMetas.map(item));
           }
           return {
             data: data,
-            total: json.totalElements!,
-            page: json.number!,
-            pageSize: json.size!,
-            pageCount: json.totalPages!,
-            isLastPage: json.last!,
+            total: json.totalElements,
+            page: json.number,
+            pageSize: json.size,
+            pageCount: json.totalPages,
+            isLastPage: json.last,
           };
         },
       })
@@ -135,7 +149,7 @@ export class AlovaMeta extends Meta {
     endTime?: string,
     sort?: string,
   ): Promise<Page<Meta>> {
-    const ownerState = owner?.map(item => item.state())
+    const ownerState = owner?.map((item) => item.state());
     return patientApi.metaStateRestful
       .queryMetaStateByExactMatch({
         data: {
@@ -150,302 +164,315 @@ export class AlovaMeta extends Meta {
         },
         async transform(json) {
           const data = [];
-          for (const item of json.content!) {
+          for (const item of json.content) {
             data.push(await AlovaMetas.map(item));
           }
           return {
             data: data,
-            total: json.totalElements!,
-            page: json.number!,
-            pageSize: json.size!,
-            pageCount: json.totalPages!,
-            isLastPage: json.last!,
+            total: json.totalElements,
+            page: json.number,
+            pageSize: json.size,
+            pageCount: json.totalPages,
+            isLastPage: json.last,
           };
         },
       })
       .send();
   }
 }
-const postState = (id: string,type: string, buffer: ArrayBuffer): Promise<MetaState> => {
-  return patientApi.metaStateRestful.postMetaState({
-    params: {
-      ownerId: id,
-      type: type
-    },
-    headers: {
-      'Content-Type': 'application/octet-stream'
-    },
-    duplex: 'half',
-    data: new Blob([buffer])
-  }).send()
-}
-const putState = (id: string,type: string, state: MetaState): Promise<MetaState> => {
-  return patientApi.metaStateRestful.putMetaState({
-    pathParams: {
-      id: id,
-      type: type
-    },
-    data: state
-  }).send()
-}
+const postState = (id: string, type: string, buffer: ArrayBuffer): Promise<MetaState> => {
+  return patientApi.metaStateRestful
+    .postMetaState({
+      params: {
+        ownerId: id,
+        type: type,
+      },
+      headers: {
+        'Content-Type': 'application/octet-stream',
+      },
+      duplex: 'half',
+      data: new Blob([buffer]),
+    })
+    .send();
+};
+const putState = (id: string, type: string, state: MetaState): Promise<MetaState> => {
+  return patientApi.metaStateRestful
+    .putMetaState({
+      pathParams: {
+        id: id,
+        type: type,
+      },
+      data: state,
+    })
+    .send();
+};
 const deleteState = (id: string): Promise<void> => {
-  void patientApi.metaStateRestful.deleteMetaState({
-    pathParams: {
-      id: id
-    }
-  }).send()
-  return Promise.resolve()
-}
+  void patientApi.metaStateRestful
+    .deleteMetaState({
+      pathParams: {
+        id: id,
+      },
+    })
+    .send();
+  return Promise.resolve();
+};
 const getState = (id: string): Promise<MetaState> => {
-  return patientApi.metaStateRestful.getMetaState({
-    pathParams: {
-      id: id
-    }
-  }).send()
-}
+  return patientApi.metaStateRestful
+    .getMetaState({
+      pathParams: {
+        id: id,
+      },
+    })
+    .send();
+};
 const getMetaObject = async (id: string): Promise<ArrayBuffer> => {
-  return patientApi.metaStateRestful.getMetaObject({
-    pathParams: {
-      id: id
-    },
-    priority: 'low',
-    transform(data: unknown) {
-      return (data as Response).arrayBuffer();
-    },
-  }).send()
-}
-const convertTags = (features: JSON,actor: string): Tag[] => {
+  return patientApi.metaStateRestful
+    .getMetaObject({
+      pathParams: {
+        id: id,
+      },
+      priority: 'low',
+      transform(data: unknown) {
+        return (data as Response).arrayBuffer();
+      },
+    })
+    .send();
+};
+const convertTags = (features: JSON, actor: string): Tag[] => {
   //上传照片
   const tags = [] as Tag[];
   const timestamp = Date.now().toString();
   Object.entries(features as object).forEach(([key, value]) => {
     tags.push(
-      Tag.builder().key(key).annotations([Annotation.builder().value(value).actor(actor).timestamp(timestamp).build()]).build()
+      Tag.builder()
+        .key(key)
+        .annotations([Annotation.builder().value(value).actor(actor).timestamp(timestamp).build()])
+        .build(),
     );
   });
-  return tags
-}
+  return tags;
+};
 export class AlovaTongueMeta extends TongueMeta {
-  override async getObject(){
-    if(this.base64Image)return Promise.resolve(this.base64Image)
-    return this.deserialize(await getMetaObject(this.id))
+  override async getObject() {
+    if (this.base64Image) return Promise.resolve(this.base64Image);
+    return this.deserialize(await getMetaObject(this.id));
   }
-  override async get():Promise<this>{
-    return this.of(await getState(this.id))
+  override async get(): Promise<this> {
+    return this.of(await getState(this.id));
   }
-  override async put():Promise<this>{
-    return this.of(await putState(this.id,this.type,this.state()))
+  override async put(): Promise<this> {
+    return this.of(await putState(this.id, this.type, this.state()));
   }
-  override async post():Promise<this>{
-    return this.of(await postState(this.owner.id,this.type,this.serialize()))
+  override async post(): Promise<this> {
+    return this.of(await postState(this.owner.id, this.type, this.serialize()));
   }
-  override async delete():Promise<this>{
-    await deleteState(this.id)
+  override async delete(): Promise<this> {
+    await deleteState(this.id);
     return this;
   }
-  override async analyze(overwrite=false):Promise<this>{
-    if(overwrite)this.tags = []
+  override async analyze(overwrite = false): Promise<this> {
+    if (overwrite) this.tags = [];
     const formData = new FormData();
     formData.append('files', new Blob([base64ToArrayBuffer(this.base64Image)]));
-    this.tags.push(...convertTags((await tongueAnalyze(formData).send()),'算法'))
-    return Promise.resolve(this)
+    this.tags.push(...convertTags(await tongueAnalyze(formData).send(), '算法'));
+    return Promise.resolve(this);
   }
 }
 export class AlovaFaceMeta extends FaceMeta {
   override async getObject() {
-    if(this.base64Image)return Promise.resolve(this.base64Image)
-    return this.deserialize(await getMetaObject(this.id))
+    if (this.base64Image) return Promise.resolve(this.base64Image);
+    return this.deserialize(await getMetaObject(this.id));
   }
-  override async post(){
-    return this.of(await postState(this.owner.id,this.type,this.serialize()))
+  override async post() {
+    return this.of(await postState(this.owner.id, this.type, this.serialize()));
   }
-  override async get(){
-    return this.of(await getState(this.id))
+  override async get() {
+    return this.of(await getState(this.id));
   }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
+  override async put() {
+    return this.of(await putState(this.id, this.type, this.state()));
   }
-  override async delete(){
-    await deleteState(this.id)
+  override async delete() {
+    await deleteState(this.id);
     return this;
   }
-  override async analyze(overwrite=false):Promise<this>{
-    if(overwrite)this.tags = []
+  override async analyze(overwrite = false): Promise<this> {
+    if (overwrite) this.tags = [];
     const formData = new FormData();
     formData.append('files', new Blob([base64ToArrayBuffer(this.base64Image)]));
-    this.tags.push(...convertTags((await faceAnalyze(formData).send()),'算法'))
-    return Promise.resolve(this)
+    this.tags.push(...convertTags(await faceAnalyze(formData).send(), '算法'));
+    return Promise.resolve(this);
   }
 }
-export class AlovaSceneMeta extends  SceneMeta{
+export class AlovaSceneMeta extends SceneMeta {
   override async getObject() {
-    if(this.base64Image)return Promise.resolve(this.base64Image)
-    return this.deserialize(await getMetaObject(this.id))
+    if (this.base64Image) return Promise.resolve(this.base64Image);
+    return this.deserialize(await getMetaObject(this.id));
   }
-  override async post(){
-    return this.of(await postState(this.owner.id,this.type,this.serialize()))
+  override async post() {
+    return this.of(await postState(this.owner.id, this.type, this.serialize()));
   }
-  override async get(){
-    return this.of(await getState(this.id))
+  override async get() {
+    return this.of(await getState(this.id));
   }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
+  override async put() {
+    return this.of(await putState(this.id, this.type, this.state()));
   }
-  override async delete(){
-    await deleteState(this.id)
+  override async delete() {
+    await deleteState(this.id);
     return this;
   }
 
-  override async analyze(overwrite=false):Promise<this>{
-    if(overwrite)this.tags = []
-    return Promise.resolve(this)
+  override async analyze(overwrite = false): Promise<this> {
+    if (overwrite) this.tags = [];
+    return Promise.resolve(this);
   }
 }
 export class AlovaPulsationMeta extends PulsationMeta {
   override async getObject() {
-    if(this.waves)return Promise.resolve(this.waves)
-    return this.deserialize(await getMetaObject(this.id))
+    if (this.waves) return Promise.resolve(this.waves);
+    return this.deserialize(await getMetaObject(this.id));
   }
-  override async post(){
-    return this.of(await postState(this.owner.id,this.type,this.serialize()))
+  override async post() {
+    return this.of(await postState(this.owner.id, this.type, this.serialize()));
   }
-  override async get(){
-    return this.of(await getState(this.id))
+  override async get() {
+    return this.of(await getState(this.id));
   }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
+  override async put() {
+    return this.of(await putState(this.id, this.type, this.state()));
   }
-  override async delete(){
-    await deleteState(this.id)
+  override async delete() {
+    await deleteState(this.id);
     return this;
   }
-  override async analyze(overwrite=false) : Promise<this>{
-    if(overwrite)this.tags = []
-    const pulsation = {} as {[key: string]:number[]}
-    for (const key in this.waves?.origin){
-      pulsation[key] = this.waves.origin[key]!.values
+  override async analyze(overwrite = false): Promise<this> {
+    if (overwrite) this.tags = [];
+    const pulsation = {} as { [key: string]: number[] };
+    for (const key in this.waves?.origin) {
+      pulsation[key] = this.waves.origin[key].values;
     }
-    this.tags.push(...convertTags((await pulsationAnalysis(pulsation).send()),'算法'))
-    return Promise.resolve(this)
+    this.tags.push(...convertTags(await pulsationAnalysis(pulsation).send(), '算法'));
+    return Promise.resolve(this);
   }
   override preprocess(origins: { [key: string]: number[] }): Promise<{ [key: string]: number[] }> {
-    return pulsationPreprocessing(origins)
+    return pulsationPreprocessing(origins);
   }
 }
 export class AlovaPPGMeta extends PPGMeta {
   override async getObject() {
-    if(this.waves)return Promise.resolve(this.waves)
-    return this.deserialize(await getMetaObject(this.id))
+    if (this.waves) return Promise.resolve(this.waves);
+    return this.deserialize(await getMetaObject(this.id));
   }
-  override async post(){
-    return this.of(await postState(this.owner.id,this.type,this.serialize()))
+  override async post() {
+    return this.of(await postState(this.owner.id, this.type, this.serialize()));
   }
-  override async get(){
-    return this.of(await getState(this.id))
+  override async get() {
+    return this.of(await getState(this.id));
   }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
+  override async put() {
+    return this.of(await putState(this.id, this.type, this.state()));
   }
-  override async delete(){
-    await deleteState(this.id)
+  override async delete() {
+    await deleteState(this.id);
     return this;
   }
-  override async analyze(overwrite=false):Promise<this>{
-    if(overwrite)this.tags = []
-    const waves = {} as {[key: string]:number[]}
-    for (const key in this.waves?.origin){
-      waves[key] = this.waves.origin[key]!.values
+  override async analyze(overwrite = false): Promise<this> {
+    if (overwrite) this.tags = [];
+    const waves = {} as { [key: string]: number[] };
+    for (const key in this.waves?.origin) {
+      waves[key] = this.waves.origin[key].values;
     }
-    this.tags.push(...convertTags((await analysisLisems(waves).send()),'算法'))
-    return Promise.resolve(this)
+    this.tags.push(...convertTags(await analysisLisems(waves).send(), '算法'));
+    return Promise.resolve(this);
   }
   override preprocess(origins: { [key: string]: number[] }): Promise<{ [key: string]: number[] }> {
-    return Promise.resolve(origins)
+    return Promise.resolve(origins);
   }
 }
 export class AlovaPCGMeta extends PCGMeta {
   override async getObject() {
-    if(this.waves)return Promise.resolve(this.waves)
-    return this.deserialize(await getMetaObject(this.id))
+    if (this.waves) return Promise.resolve(this.waves);
+    return this.deserialize(await getMetaObject(this.id));
   }
-  override async post(){
-    return this.of(await postState(this.owner.id,this.type,this.serialize()))
+  override async post() {
+    return this.of(await postState(this.owner.id, this.type, this.serialize()));
   }
-  override async get(){
-    return this.of(await getState(this.id))
+  override async get() {
+    return this.of(await getState(this.id));
   }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
+  override async put() {
+    return this.of(await putState(this.id, this.type, this.state()));
   }
-  override async delete(){
-    await deleteState(this.id)
+  override async delete() {
+    await deleteState(this.id);
     return this;
   }
-  override async analyze(overwrite=false):Promise<this>{
-    if(overwrite)this.tags = []
-    const waves = {} as {[key: string]:number[]}
-    for (const key in this.waves?.origin){
-      waves[key] = this.waves.origin[key]!.values
+  override async analyze(overwrite = false): Promise<this> {
+    if (overwrite) this.tags = [];
+    const waves = {} as { [key: string]: number[] };
+    for (const key in this.waves?.origin) {
+      waves[key] = this.waves.origin[key].values;
     }
-    this.tags.push(...convertTags((await analysisLisems(waves).send()),'算法'))
-    return Promise.resolve(this)
+    this.tags.push(...convertTags(await analysisLisems(waves).send(), '算法'));
+    return Promise.resolve(this);
   }
   override preprocess(origins: { [key: string]: number[] }): Promise<{ [key: string]: number[] }> {
-    return Promise.resolve(origins)
+    return Promise.resolve(origins);
   }
 }
 export class AlovaECGMeta extends ECGMeta {
   override async getObject() {
-    if(this.waves)return Promise.resolve(this.waves)
-    return this.deserialize(await getMetaObject(this.id))
+    if (this.waves) return Promise.resolve(this.waves);
+    return this.deserialize(await getMetaObject(this.id));
   }
-  override async post(){
-    return this.of(await postState(this.owner.id,this.type,this.serialize()))
+  override async post() {
+    return this.of(await postState(this.owner.id, this.type, this.serialize()));
   }
-  override async get(){
-    return this.of(await getState(this.id))
+  override async get() {
+    return this.of(await getState(this.id));
   }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
+  override async put() {
+    return this.of(await putState(this.id, this.type, this.state()));
   }
-  override async delete(){
-    await deleteState(this.id)
+  override async delete() {
+    await deleteState(this.id);
     return this;
   }
-  override async analyze(overwrite=false):Promise<this>{
-    if(overwrite)this.tags = []
-    const waves = {} as {[key: string]:number[]}
-    for (const key in this.waves?.origin){
-      waves[key] = this.waves.origin[key]!.values
+  override async analyze(overwrite = false): Promise<this> {
+    if (overwrite) this.tags = [];
+    const waves = {} as { [key: string]: number[] };
+    for (const key in this.waves?.origin) {
+      waves[key] = this.waves.origin[key].values;
     }
-    this.tags.push(...convertTags((await analysisLisems(waves).send()),'算法'))
-    return Promise.resolve(this)
+    this.tags.push(...convertTags(await analysisLisems(waves).send(), '算法'));
+    return Promise.resolve(this);
   }
   override preprocess(origins: { [key: string]: number[] }): Promise<{ [key: string]: number[] }> {
-    return Promise.resolve(origins)
+    return Promise.resolve(origins);
   }
 }
 export class AlovaAppendixMeta extends AppendixMeta {
   override async getObject() {
-    if(this.base64Images.length)return Promise.resolve(this.base64Images)
-    return this.deserialize(await getMetaObject(this.id))
+    if (this.base64Images.length) return Promise.resolve(this.base64Images);
+    return this.deserialize(await getMetaObject(this.id));
   }
-  override async post(){
-    return this.of(await postState(this.owner.id,this.type,this.serialize()))
+  override async post() {
+    return this.of(await postState(this.owner.id, this.type, this.serialize()));
   }
-  override async get(){
-    return this.of(await getState(this.id))
+  override async get() {
+    return this.of(await getState(this.id));
   }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
+  override async put() {
+    return this.of(await putState(this.id, this.type, this.state()));
   }
-  override async delete(){
-    await deleteState(this.id)
+  override async delete() {
+    await deleteState(this.id);
     return this;
   }
-  override async analyze(overwrite=false):Promise<this>{
-    if(overwrite)this.tags = []
-    return Promise.resolve(this)
+  override async analyze(overwrite = false): Promise<this> {
+    if (overwrite) this.tags = [];
+    return Promise.resolve(this);
   }
 }
 export class AlovaComplaintMeta extends ComplaintMeta {
@@ -466,23 +493,25 @@ export class AlovaComplaintMeta extends ComplaintMeta {
     await deleteState(this.id);
     return this;
   }
-  override async analyze(overwrite=false):Promise<this>{
-    if(overwrite)this.tags = []
-    return Promise.resolve(this)
+  override async analyze(overwrite = false): Promise<this> {
+    if (overwrite) this.tags = [];
+    return Promise.resolve(this);
   }
 }
-export class AlovaMetas extends Metas{
+export class AlovaMetas extends Metas {
   static override map(meta: MetaState) {
-    if (meta.type == MetaType.Pulsation)return new AlovaPulsationMeta().of(meta);
-    else if(meta.type == MetaType.Tongue)return new AlovaTongueMeta().of(meta);
-    else if(meta.type == MetaType.Complaint)return new AlovaComplaintMeta().of(meta);
-    else if(meta.type == MetaType.Face)return new AlovaFaceMeta().of(meta);
-    else if(meta.type == MetaType.Appendix)return new AlovaAppendixMeta().of(meta);
-    else if(meta.type == MetaType.ECG)return new AlovaECGMeta().of(meta);
-    else if(meta.type == MetaType.PCG)return new AlovaPCGMeta().of(meta);
-    else if(meta.type == MetaType.Scene)return new AlovaSceneMeta().of(meta);
-    else if(meta.type == MetaType.PPG)return new AlovaPPGMeta().of(meta);
-    else if(meta.type == MetaType.Meta)return new AlovaMeta().of(meta);
+    //将string转Type
+    const type = MetaType[meta.type]
+    if (type == MetaType.Pulsation) return new AlovaPulsationMeta().of(meta);
+    else if (type == MetaType.Tongue) return new AlovaTongueMeta().of(meta);
+    else if (type == MetaType.Complaint) return new AlovaComplaintMeta().of(meta);
+    else if (type == MetaType.Face) return new AlovaFaceMeta().of(meta);
+    else if (type == MetaType.Appendix) return new AlovaAppendixMeta().of(meta);
+    else if (type == MetaType.ECG) return new AlovaECGMeta().of(meta);
+    else if (type == MetaType.PCG) return new AlovaPCGMeta().of(meta);
+    else if (type == MetaType.Scene) return new AlovaSceneMeta().of(meta);
+    else if (type == MetaType.PPG) return new AlovaPPGMeta().of(meta);
+    else if (type == MetaType.Meta) return new AlovaMeta().of(meta);
     else throw new Error('未知的Meta类型');
   }
 }