web-core-tcm 0.0.24 → 0.0.25

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

@@ -0,0 +1,91 @@
+import { Queuer } from 'src/api/outpatient/outpatient';
+import type { Page } from 'src/api/patient/core';
+
+export class AlovaQueuer extends Queuer {
+  override async get() {
+    return this.of(
+      await outpatientApi.queuerRestful
+        .getQueuerState({
+          pathParams: {
+            id: this.id,
+          },
+        })
+        .send(),
+    );
+  }
+
+  override async put() {
+    return this.of(
+      await outpatientApi.queuerRestful
+        .putQueuerState({
+          pathParams: {
+            id: this.id,
+          },
+          data: this.state(),
+        })
+        .send(true),
+    );
+  }
+  override async delete() {
+    await outpatientApi.queuerRestful
+      .deleteQueuerState({
+        pathParams: {
+          id: this.id,
+        },
+      })
+      .send();
+    return Promise.resolve(this);
+  }
+  override async post() {
+    return this.of(
+      await outpatientApi.queuerRestful
+        .postQueuerState({
+          data: this.state(),
+        })
+        .send(true),
+    );
+  }
+
+  override async putStatus(status?: number) {
+    if (status) this.status = status;
+    return this.of(
+      await outpatientApi.queuerRestful
+        .putQueuerState({
+          pathParams: {
+            id: this.id,
+          },
+          data: {
+            status: this.status,
+          },
+        })
+        .send(true),
+    );
+  }
+  static override query(
+    page: number,
+    pageSize: number,
+    doctorId?: string,
+    patientId?: string,
+  ): Promise<Page<Queuer>> {
+    return outpatientApi.queuerRestful
+      .queryQueuerState({
+        params: {
+          ...(doctorId && { doctorId }),
+          ...(patientId && { patientId }),
+          page: page,
+          pageSize,
+        },
+        async transform(json) {
+          return {
+            data: await Promise.all(json.content.map((item) => new AlovaQueuer().of(item))),
+            total: json.totalElements,
+            page: json.number,
+            pageSize: json.size,
+            pageCount: json.totalPages,
+            isLastPage: json.last,
+          };
+        },
+      })
+      .send();
+  }
+}

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

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

package/src/api/outpatient/index.ts

@@ -0,0 +1,2 @@
+export * from './outpatient';
+export * from './alova';

package/src/api/outpatient/outpatient.ts

@@ -0,0 +1,67 @@
+import type { Page } from 'src/api/patient/core';
+import { NetworkObject } from 'src/api/patient/core';
+import type { QueuerState } from 'src/api/outpatient/alova/globals';
+import type { IBuilder } from 'builder-pattern';
+import { Builder } from 'builder-pattern';
+import { Patient } from 'src/api/patient/patient';
+import { Doctor } from 'src/api/doctor/doctor';
+
+export enum QueuerStatus {
+  Waiting = 0,
+  InTreatment = 1,
+  Finished = 2,
+}
+export const QueuerStatusConfig = {
+  [QueuerStatus.Finished]: { name: '完成' },
+  [QueuerStatus.InTreatment]: { name: '就诊' },
+  [QueuerStatus.Waiting]: { name: '等待' },
+};
+export abstract class Queuer extends NetworkObject {
+  static override builder(): IBuilder<Queuer> {
+    return Builder(this._default) as unknown as IBuilder<Queuer>;
+  }
+  static override default(): typeof Queuer {
+    return this._default as unknown as typeof Queuer;
+  }
+  id: string = '';
+  patient: Patient = Patient.builder().build();
+  doctor: Doctor = Doctor.builder().build();
+  createdTimestamp: string = '';
+  updatedTimestamp: string = '';
+  status: QueuerStatus = 0;
+
+  override async of(json: QueuerState): Promise<this> {
+    //修改下面逻辑，改为判空，为空就不覆盖
+    if (json.id != undefined) this.id = json.id;
+    if (json.patientState != undefined) await this.patient.of(json.patientState);
+    if (json.doctorState != undefined) await this.doctor.of(json.doctorState);
+    if (json.createdTimestamp != undefined) this.createdTimestamp = json.createdTimestamp;
+    if (json.updatedTimestamp != undefined) this.updatedTimestamp = json.updatedTimestamp;
+    if (json.status != undefined) this.status = json.status;
+    return Promise.resolve(this);
+  }
+
+  override state() {
+    return {
+      id: this.id,
+      patientState: this.patient.state(),
+      doctorState: this.doctor.state(),
+      createdTimestamp: this.createdTimestamp,
+      updatedTimestamp: this.updatedTimestamp,
+      status: this.status,
+    } as QueuerState;
+  }
+  static query(
+    page: number,
+    pageSize: number,
+    doctorId?: string,
+    patientId?: string,
+  ): Promise<Page<Queuer>> {
+    return Queuer.default().query(page, pageSize, doctorId, patientId);
+  }
+  abstract get(): Promise<this>;
+  abstract put(): Promise<this>;
+  abstract putStatus(status?: number): Promise<this>;
+  abstract delete(): Promise<this>;
+  abstract post(): Promise<this>;
+}

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

@@ -0,0 +1,41 @@
+/// <reference types='./globals.d.ts' />
+/* tslint:disable */
+ 
+/**
+ * 患者服务 - version v1.0
+ *
+ * 支持Restful风格的患者服务
+ *
+ * OpenAPI version: 3.1.0
+ *
+ *
+ * NOTE: This file is auto generated by the alova's vscode plugin.
+ *
+ * https://alova.js.org/devtools/vscode
+ *
+ * **Do not edit the file manually.**
+ */
+export default {
+  'metaStateRestful.getMetaState': ['GET', '/患者/服务/元/{id}'],
+  'metaStateRestful.putMetaState': ['PUT', '/患者/服务/元/{id}'],
+  'metaStateRestful.deleteMetaState': ['DELETE', '/患者/服务/元/{id}'],
+  'patientStateRestful.getPatientState': ['GET', '/患者/服务/{id}'],
+  'patientStateRestful.putPatientState': ['PUT', '/患者/服务/{id}'],
+  'patientStateRestful.deletePatientState': ['DELETE', '/患者/服务/{id}'],
+  'patientStateRestful.queryPatientState': ['GET', '/患者/服务'],
+  'patientStateRestful.postPatientState': ['POST', '/患者/服务'],
+  'patientStateRestful.queryPatientStateByExactMatch': ['POST', '/患者/服务/精确匹配'],
+  'metaStateRestful.postMetaState': ['POST', '/患者/服务/元'],
+  'metaStateRestful.queryMetaAndPatientState': ['POST', '/患者/服务/元/级联查询'],
+  'metaStateRestful.queryMetaStateByExactMatch': ['POST', '/患者/服务/元/精确匹配'],
+  'metaStateRestful.queryMetaState': ['POST', '/患者/服务/元/条件查询'],
+  'metricRestful.totalOfPatient': ['GET', '/患者/服务/统计/患者/总数'],
+  'metricRestful.ageDistributeOfPatient': ['GET', '/患者/服务/统计/患者/性别/分布'],
+  'metricRestful.genderDistributeOfPatient': ['GET', '/患者/服务/统计/患者/年龄/分布'],
+  'metricRestful.dateDistributeOfPatient': ['GET', '/患者/服务/统计/患者/分布'],
+  'metricRestful.totalOfPatientByToday': ['GET', '/患者/服务/统计/患者/今日'],
+  'metricRestful.datesOfMeta': ['GET', '/患者/服务/统计/元/日期'],
+  'metricRestful.totalOfMeta': ['GET', '/患者/服务/统计/元/总数'],
+  'metricRestful.totalOfMetaByToday': ['GET', '/患者/服务/统计/元/今日'],
+  'metaStateRestful.getMetaObject': ['GET', '/患者/服务/元/{id}/元象'],
+};

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

@@ -0,0 +1,114 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * 患者服务 - version v1.0
+ *
+ * 支持Restful风格的患者服务
+ *
+ * OpenAPI version: 3.1.0
+ *
+ *
+ * NOTE: This file is auto generated by the alova's vscode plugin.
+ *
+ * https://alova.js.org/devtools/vscode
+ *
+ * **Do not edit the file manually.**
+ */
+import type { Alova, MethodType, AlovaGenerics, AlovaMethodCreateConfig } from 'alova';
+import { Method } from 'alova';
+import apiDefinitions from './apiDefinitions';
+
+const cache = Object.create(null);
+const createFunctionalProxy = (
+  array: (string | symbol)[],
+  alovaInstance: Alova<AlovaGenerics>,
+  configMap: any,
+) => {
+  const apiPathKey = array.join('.') as keyof typeof apiDefinitions;
+  if (cache[apiPathKey]) {
+    return cache[apiPathKey];
+  }
+  // create a new proxy instance
+  const proxy = new Proxy(function () {}, {
+    get(_, property) {
+      // record the target property, so that it can get the completed accessing paths
+      const newArray = [...array, property];
+      // always return a new proxy to continue recording accessing paths.
+      return createFunctionalProxy(newArray, alovaInstance, configMap);
+    },
+    apply(_, __, [config]) {
+      const apiItem = apiDefinitions[apiPathKey];
+      if (!apiItem) {
+        throw new Error(`the api path of \`${apiPathKey}\` is not found`);
+      }
+      const mergedConfig = {
+        ...configMap[apiPathKey],
+        ...config,
+      };
+      const [method, url] = apiItem;
+      const pathParams = mergedConfig.pathParams;
+      const urlReplaced = url!.replace(/\{([^}]+)\}/g, (_, key) => {
+        const pathParam = pathParams[key];
+        return pathParam;
+      });
+      delete mergedConfig.pathParams;
+      let data = mergedConfig.data;
+      if (
+        Object.prototype.toString.call(data) === '[object Object]' &&
+        typeof FormData !== 'undefined'
+      ) {
+        let hasBlobData = false;
+        const formData = new FormData();
+        for (const key in data) {
+          formData.append(key, data[key]);
+          if (data[key] instanceof Blob) {
+            hasBlobData = true;
+          }
+        }
+        data = hasBlobData ? formData : data;
+      }
+      return new Method(
+        method!.toUpperCase() as MethodType,
+        alovaInstance,
+        urlReplaced,
+        mergedConfig,
+        data,
+      );
+    },
+  });
+  cache[apiPathKey] = proxy;
+  return proxy;
+};
+
+export const createApis = (alovaInstance: Alova<AlovaGenerics>, configMap: any) => {
+  const Apis = new Proxy({} as patientApi, {
+    get(_, property) {
+      return createFunctionalProxy([property], alovaInstance, configMap);
+    },
+  });
+  return Apis;
+};
+export const mountApis = (Apis: patientApi) => {
+  // define global variable `Apis`
+  (globalThis as any).patientApi = Apis;
+};
+type MethodConfig<T> = AlovaMethodCreateConfig<
+  (typeof import('./index'))['alovaInstance'] extends Alova<infer AG> ? AG : any,
+  any,
+  T
+>;
+type APISofParameters<Tag extends string, Url extends string> = Tag extends keyof patientApi
+  ? Url extends keyof patientApi[Tag]
+    ? patientApi[Tag][Url] extends (...args: any) => any
+      ? Parameters<patientApi[Tag][Url]>
+      : any
+    : any
+  : any;
+type MethodsConfigMap = {
+  [P in keyof typeof import('./apiDefinitions').default]?: MethodConfig<
+    P extends `${infer Tag}.${infer Url}`
+      ? Parameters<NonNullable<APISofParameters<Tag, Url>[0]>['transform']>[0]
+      : any
+  >;
+};
+export const withConfigType = <Config extends MethodsConfigMap>(config: Config) => config;