web-core-tcm 0.0.23 → 0.0.24

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

@@ -1,2 +0,0 @@
-export * from './meta';
-export * from './patient';

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

@@ -1,488 +0,0 @@
-import type { MetaState } from '@core/api/patient/alova/globals';
-import {
-  AppendixMeta,
-  ComplaintMeta,
-  ECGMeta,
-  FaceMeta,
-  Meta,
-  Metas,
-  MetaType,
-  PCGMeta,
-  PPGMeta,
-  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';
-
-export class AlovaMeta extends Meta {
-  override deserialize(): Promise<this> {
-    return Promise.resolve(this);
-  }
-  override inject(): Promise<this> {
-    return Promise.resolve(this);
-  }
-  override serialize(): ArrayBuffer {
-    return new ArrayBuffer(0);
-  }
-  override getObject(): Promise<string> {
-    return Promise.resolve('')
-  }
-  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 post(): Promise<this> {
-    throw new Error('Method not implemented.');
-  }
-  override async delete(): Promise<this> {
-    await deleteState(this.id);
-    return this;
-  }
-  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()
-    return patientApi.metaStateRestful
-      .queryMetaAndPatientState({
-        data: {
-          ...(ownerState && { ownerState }),
-          ...(type && { type }),
-          page: page,
-          pageSize: pageSize,
-          ...(startTime && { startTime }),
-          ...(endTime && { endTime }),
-          ...(sort && { sort }),
-          ...(patientName && { patientName }),
-          ...(patientPhoneNumber && { patientPhoneNumber }),
-          ...(patientStartBirthdate && { patientStartBirthdate }),
-          ...(patientEndBirthdate && { patientEndBirthdate }),
-          ...(patientGender && { patientGender }),
-          ...(tagsState && { tagsState }),
-        },
-        async transform(json) {
-          const data = [] as Meta[];
-          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!,
-          } as Page<Meta>;
-        },
-      })
-      .send();
-  }
-  static override query(
-    page: number,
-    pageSize: number,
-    owner?: Patient,
-    type?: string,
-    startTime?: string,
-    endTime?: string,
-    sort?: string,
-  ): Promise<Page<Meta>> {
-    const ownerState = owner?.state()
-    return patientApi.metaStateRestful
-      .queryMetaState({
-        data: {
-          ...(ownerState && { ownerState }),
-          ...(type && { type }),
-          ...(startTime && { startTime }),
-          ...(endTime && { endTime }),
-          ...(sort && { sort }),
-          page: page,
-          pageSize: pageSize,
-        },
-        async transform(json) {
-          const data = [];
-          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!,
-          };
-        },
-      })
-      .send();
-  }
-  static override queryMetaStateByExactMatch(
-    id?: string[],
-    owner?: Patient[],
-    type?: string[],
-    pageSize?: number,
-    page?: number,
-    startTime?: string,
-    endTime?: string,
-    sort?: string,
-  ): Promise<Page<Meta>> {
-    const ownerState = owner?.map(item => item.state())
-    return patientApi.metaStateRestful
-      .queryMetaStateByExactMatch({
-        data: {
-          ...{ ...(id && { id }) },
-          ...{ ...(ownerState && { ownerState }) },
-          ...{ ...(type && { type }) },
-          ...{ ...(pageSize && { pageSize }) },
-          ...{ ...(page && { page }) },
-          ...{ ...(startTime && { startTime }) },
-          ...{ ...(endTime && { endTime }) },
-          ...{ ...(sort && { sort }) },
-        },
-        async transform(json) {
-          const data = [];
-          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!,
-          };
-        },
-      })
-      .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()
-}
-const getState = (id: string): Promise<MetaState> => {
-  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[] => {
-  //上传照片
-  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()
-    );
-  });
-  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 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 post():Promise<this>{
-    return this.of(await postState(this.owner.id,this.type,this.serialize()))
-  }
-  override async delete():Promise<this>{
-    await deleteState(this.id)
-    return this;
-  }
-  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)
-  }
-}
-export class AlovaFaceMeta extends FaceMeta {
-  override async getObject() {
-    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 get(){
-    return this.of(await getState(this.id))
-  }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
-  }
-  override async delete(){
-    await deleteState(this.id)
-    return this;
-  }
-  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)
-  }
-}
-export class AlovaSceneMeta extends  SceneMeta{
-  override async getObject() {
-    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 get(){
-    return this.of(await getState(this.id))
-  }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
-  }
-  override async delete(){
-    await deleteState(this.id)
-    return 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))
-  }
-  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 put(){
-    return this.of(await putState(this.id,this.type,this.state()))
-  }
-  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
-    }
-    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)
-  }
-}
-export class AlovaPPGMeta extends PPGMeta {
-  override async getObject() {
-    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 get(){
-    return this.of(await getState(this.id))
-  }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
-  }
-  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
-    }
-    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)
-  }
-}
-export class AlovaPCGMeta extends PCGMeta {
-  override async getObject() {
-    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 get(){
-    return this.of(await getState(this.id))
-  }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
-  }
-  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
-    }
-    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)
-  }
-}
-export class AlovaECGMeta extends ECGMeta {
-  override async getObject() {
-    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 get(){
-    return this.of(await getState(this.id))
-  }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
-  }
-  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
-    }
-    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)
-  }
-}
-export class AlovaAppendixMeta extends AppendixMeta {
-  override async getObject() {
-    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 get(){
-    return this.of(await getState(this.id))
-  }
-  override async put(){
-    return this.of(await putState(this.id,this.type,this.state()))
-  }
-  override async delete(){
-    await deleteState(this.id)
-    return this;
-  }
-  override async analyze(overwrite=false):Promise<this>{
-    if(overwrite)this.tags = []
-    return Promise.resolve(this)
-  }
-}
-export class AlovaComplaintMeta extends ComplaintMeta {
-  override async getObject() {
-    if (this.text) return Promise.resolve(this.text);
-    return this.deserialize(await getMetaObject(this.id));
-  }
-  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 put() {
-    return this.of(await putState(this.id, this.type, this.state()));
-  }
-  override async delete() {
-    await deleteState(this.id);
-    return this;
-  }
-  override async analyze(overwrite=false):Promise<this>{
-    if(overwrite)this.tags = []
-    return Promise.resolve(this)
-  }
-}
-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);
-    else throw new Error('未知的Meta类型');
-  }
-}

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

@@ -1,77 +0,0 @@
-import { Patient } from '@core/api/patient/patient';
-import type { Page } from '@core/api/patient/core';
-
-export class AlovaPatient extends Patient{
-  override async get() {
-    return this.of(await patientApi.patientStateRestful.getPatientState({
-      pathParams: {
-        id: this.id,
-      },
-      priority: 'high',
-      async transform(json) {
-        return new AlovaPatient().of(json);
-      }
-    }).send())
-  }
-
-  override async put() {
-    return this.of(await patientApi.patientStateRestful.putPatientState({
-      pathParams: {
-        id: this.id,
-      },
-      data: this.state()
-    }).send(true));
-  }
-
-  override async post() {
-    return this.of(await patientApi.patientStateRestful.postPatientState({
-      data: this.state()
-    }).send(true))
-  }
-  override delete() {
-    void patientApi.patientStateRestful.deletePatientState({
-      pathParams: {
-        id: this.id,
-      }
-    }).send();
-    return Promise.resolve(this);
-  }
-  override async putRemarks(){
-    return this.of(await patientApi.patientStateRestful.putPatientState({
-      pathParams: {
-        id: this.id,
-      },
-      data: {
-        remarks: this.remarks,
-      }
-    }).send(true));
-  }
-  static override query(params: {
-        id?: string;
-        doctorId?: string;
-        name?: string;
-        gender?: string;
-        identity?: string;
-        pageSize: number;
-        page: number;
-        phoneNumber?: string;
-        startTime?: string;
-        endTime?: string;
-        sort?: string;
-      }): Promise<Page<Patient>> {
-      return patientApi.patientStateRestful.queryPatientState({
-        params: params,
-        async transform(json): Promise<Page<Patient>> {
-          const patient = await Promise.all(json.content!.map(item => new AlovaPatient().of(item)));
-          return {
-            data: patient,
-            total: json.totalElements!,
-            page: json.number!,
-            pageCount: json.totalPages!,
-            pageSize: json.size!,
-            isLastPage: json.last!,
-          }
-        }
-      }).send();
-  }
-}

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

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