web-core-tcm 0.0.23 → 0.0.25

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

@@ -1,77 +1,99 @@
-import { Patient } from '@core/api/patient/patient';
-import type { Page } from '@core/api/patient/core';
+import { Patient } from 'src/api/patient/patient';
+import type { Page } from 'src/api/patient/core';
 
-export class AlovaPatient extends Patient{
+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())
+    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));
+    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))
+    return this.of(
+      await patientApi.patientStateRestful
+        .postPatientState({
+          data: this.state(),
+        })
+        .send(true),
+    );
   }
   override delete() {
-    void patientApi.patientStateRestful.deletePatientState({
-      pathParams: {
-        id: this.id,
-      }
-    }).send();
+    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));
+  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({
+    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)));
+          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();
+            total: json.totalElements,
+            page: json.number,
+            pageCount: json.totalPages,
+            pageSize: json.size,
+            isLastPage: json.last,
+          };
+        },
+      })
+      .send();
   }
 }

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

@@ -1,8 +1,8 @@
 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';
+import { onAuthRequired, responded } from 'src/api/config/alova';
+import { getServiceEndpoint, ServiceType } from 'src/api/config';
 
 export const alovaInstance = createAlova({
   baseURL: getServiceEndpoint(ServiceType.Patient),
@@ -18,7 +18,5 @@ const Apis = createApis(alovaInstance, $$userConfigMap);
 
 mountApis(Apis);
 
+export * from './implement'
 export default Apis;
-
-
-

package/src/api/patient/core.ts

@@ -1,7 +1,7 @@
-import type { AnnotationState, TagState } from '@core/api/patient/alova/globals';
+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>{
+export class Page<T> {
   data: T[] = [];
   total: number = 0;
   page: number = 0;
@@ -11,22 +11,22 @@ export class Page<T>{
 }
 abstract class NetworkObject {
   static _default: typeof NetworkObject = NetworkObject;
-  static builder(): IBuilder<unknown>{
-    return Builder(this._default)
+  static builder(): IBuilder<unknown> {
+    return Builder(this._default);
   }
-  static default(): typeof NetworkObject{
-    return NetworkObject
+  static default(): typeof NetworkObject {
+    return NetworkObject;
   }
-  abstract of(json: unknown): Promise<this>
-  abstract state(): unknown
+  abstract of(json: unknown): Promise<this>;
+  abstract state(): unknown;
 }
 
-class Annotation extends NetworkObject{
+class Annotation extends NetworkObject {
   value: string = '';
   actor: string = '';
   timestamp: string = '';
-  static override builder(): IBuilder<Annotation>{
-    return Builder(Annotation) as unknown as IBuilder<Annotation>
+  static override builder(): IBuilder<Annotation> {
+    return Builder(Annotation) as unknown as IBuilder<Annotation>;
   }
   constructor(value: string = '', actor: string = '', timestamp: string = '') {
     super();
@@ -38,64 +38,69 @@ class Annotation extends NetworkObject{
     this.value = json.value!;
     this.actor = json.actor!;
     this.timestamp = json.timestamp!;
-    return Promise.resolve(this)
+    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>
+class Tag extends NetworkObject {
+  static override builder(): IBuilder<Tag> {
+    return Builder(Tag) as unknown as IBuilder<Tag>;
   }
-  static override default(): typeof Tag{
-    return Tag
+  static override default(): typeof Tag {
+    return Tag;
   }
   key: string = '';
   annotations: Annotation[] = [];
-  constructor(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))
+    for (const item of json.annotationsState) {
+      this.annotations.push(await new Annotation().of(item));
     }
-    return this
+    return this;
   }
   override state(): TagState {
     return {
       key: this.key,
-      annotationsState: this.annotations.map(item => item.state()),
-    }
+      annotationsState: this.annotations.map((item) => item.state()),
+    };
   }
-  getLastValue(): string{
-    return this.getLastAnnotation().value
+  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
+    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
+    return this;
   }
 }
 
@@ -103,29 +108,26 @@ class Sequence<T> {
   data: T[] = [];
   current: T = {} as T;
   showed: boolean = false;
-  constructor(
-    data: T[] = [],
-    current: T = {} as T,
-  ) {
+  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
+    return item;
   }
   choose(item: T): T {
     this.current = item;
-    return item
+    return item;
   }
   clear(): this {
     this.data.length = 0;
     this.current = {} as T;
-    return this
+    return this;
   }
-  show(): Sequence<T>{
-    this.showed = true
-    return this
+  show(): Sequence<T> {
+    this.showed = true;
+    return this;
   }
 }
-export { NetworkObject, Tag, Sequence, Annotation }
+export { NetworkObject, Tag, Sequence, Annotation };

package/src/api/patient/index.ts

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