web-core-tcm 0.0.23 → 0.0.24

package/src/api/patient/core.ts

@@ -1,131 +0,0 @@
-import type { AnnotationState, TagState } from '@core/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/index.ts

@@ -1,4 +0,0 @@
-export * from './core';
-export * from './meta';
-export * from './patient';
-export * from './alova/index';

package/src/api/patient/meta.ts

@@ -1,466 +0,0 @@
-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 { 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 { 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]
-  }
-}

package/src/api/patient/patient.ts

@@ -1,98 +0,0 @@
-import type { Page} from '@core/api/patient/core';
-import { Tag } from '@core/api/patient/core';
-import { NetworkObject } from '@core/api/patient/core';
-import type { PatientState } from '@core/api/patient/alova/globals';
-import { Metas } from '@core/api/patient/meta';
-import type { IBuilder } from 'builder-pattern';
-import { Builder } from 'builder-pattern';
-import { getName } from '@core/util/string';
-
-export abstract class Patient extends NetworkObject {
-  static override builder(): IBuilder<Patient>{
-    return Builder(this._default) as unknown as IBuilder<Patient>;
-  }
-  static override default(): typeof Patient {
-    return this._default as unknown as typeof Patient;
-  }
-  id = '';
-  name = '';
-  gender = '';
-  phoneNumber = '';
-  birthdate = '';
-  identity = '';
-  age = 0;
-  tags: Tag[] = [];
-  remarks: string[] = [];
-  doctorId = '';
-  createdTimestamp = '';
-  updatedTimestamp = '';
-  mainSymptom = '';
-  metas: Metas = Metas.builder().build();
-  init(id?: string, metas?: Metas) {
-    if(id)this.id = id;
-    if(metas)this.metas = metas;
-    this.metas.init(this)
-  }
-
-  override async of(json: PatientState) {
-    if(json.id != undefined)this.id = json.id;
-    if(json.name != undefined)this.name = getName(json.name);
-    if(json.gender != undefined)this.gender = json.gender;
-    if(json.phoneNumber != undefined)this.phoneNumber = json.phoneNumber;
-    if(json.birthdate != undefined){
-      this.birthdate = json.birthdate;
-      //计算年龄
-      this.age = new Date().getFullYear() - new Date(json.birthdate).getFullYear();
-    }
-    if(json.identity != undefined)this.identity = json.identity;
-    if(json.tagsState != undefined)this.tags = await Promise.all(json.tagsState.map(tag => Tag.builder().build().of(tag)));
-    if(json.remarks != undefined){
-
-      this.remarks = json.remarks;
-    }
-    if(json.doctorId != undefined)this.doctorId = json.doctorId;
-    if(json.createdTimestamp != undefined)this.createdTimestamp = json.createdTimestamp;
-    if(json.updatedTimestamp != undefined)this.updatedTimestamp = json.updatedTimestamp;
-    if(json.mainSymptom != undefined)this.mainSymptom = json.mainSymptom;
-    this.metas = this.metas.init(this)
-    return this;
-  }
-
-  override state() {
-    const state = {} as PatientState;
-    if (this.id) state.id = this.id;
-    if (this.name) state.name = this.name;
-    if (this.gender) state.gender = this.gender;
-    if (this.phoneNumber) state.phoneNumber = this.phoneNumber;
-    if (this.birthdate) state.birthdate = this.birthdate;
-    if (this.identity) state.identity = this.identity;
-    if (this.tags.length > 0) state.tagsState = this.tags.map(item => item.state());
-    if (this.doctorId) state.doctorId = this.doctorId;
-    if (this.createdTimestamp) state.createdTimestamp = this.createdTimestamp;
-    if (this.updatedTimestamp) state.updatedTimestamp = this.updatedTimestamp;
-    if (this.mainSymptom) state.mainSymptom = this.mainSymptom;
-    if (this.remarks.length > 0) state.remarks = this.remarks;
-    return state;
-  }
-
-  abstract get(): Promise<this>;
-  abstract put(): Promise<this>;
-  abstract post(): Promise<this>;
-  abstract delete(): Promise<this>;
-  abstract putRemarks(): Promise<this>;
-  static 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 this.default().query(params);
-  }
-}