web-core-tcm 0.0.24 → 0.0.25

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

@@ -0,0 +1,51 @@
+import { Doctor } from 'src/api/doctor/doctor';
+
+export class AlovaDoctor extends Doctor {
+  override async get() {
+    return this.of(
+      await doctorApi.doctorStateRestful
+        .getDoctorState({
+          pathParams: {
+            id: this.id,
+          },
+          async transform(res) {
+            return new AlovaDoctor().of(res);
+          },
+        })
+        .send(),
+    );
+  }
+
+  override async put() {
+    return this.of(
+      await doctorApi.doctorStateRestful
+        .putDoctorState({
+          pathParams: {
+            id: this.id,
+          },
+          data: this.state(),
+        })
+        .send(),
+    );
+  }
+
+  override async post() {
+    return this.of(
+      await doctorApi.doctorStateRestful
+        .postDoctorState({
+          data: this.state(),
+        })
+        .send(),
+    );
+  }
+  override async delete() {
+    await doctorApi.doctorStateRestful
+      .deleteDoctorState({
+        pathParams: {
+          id: this.id,
+        },
+      })
+      .send();
+    return Promise.resolve();
+  }
+}

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

@@ -0,0 +1 @@
+export * from './doctor';

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

@@ -0,0 +1,23 @@
+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.Doctor),
+  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/doctor/doctor.ts

@@ -0,0 +1,53 @@
+import { NetworkObject } from 'src/api/patient/core';
+import type { DoctorState } from 'src/api/doctor/alova/globals';
+import type { IBuilder } from 'builder-pattern';
+import { Builder } from 'builder-pattern';
+
+export abstract class Doctor extends NetworkObject {
+  static override builder(): IBuilder<Doctor> {
+    return Builder(this._default) as unknown as IBuilder<Doctor>;
+  }
+  static override default(): typeof Doctor {
+    return this._default as unknown as typeof Doctor;
+  }
+  id: string = '';
+  name: string = '';
+  createdTimestamp: string = '';
+  updatedTimestamp: string = '';
+  gender: string = '';
+  identityNumber: string = '';
+  phoneNumber: string = '';
+  birthdate: string = '';
+  custom: string = '标准模式';
+  override of(json: DoctorState) {
+    if (json.id != undefined) this.id = json.id;
+    if (json.name != undefined) this.name = json.name;
+    if (json.createdTimestamp != undefined) this.createdTimestamp = json.createdTimestamp;
+    if (json.updatedTimestamp != undefined) this.updatedTimestamp = json.updatedTimestamp;
+    if (json.gender != undefined) this.gender = json.gender;
+    if (json.identityNumber != undefined) this.identityNumber = json.identityNumber;
+    if (json.phoneNumber != undefined) this.phoneNumber = json.phoneNumber;
+    if (json.birthdate != undefined) this.birthdate = json.birthdate;
+    return Promise.resolve(this);
+  }
+  override state() {
+    const state = {} as DoctorState;
+    if (this.id) state.id = this.id;
+    if (this.name) state.name = this.name;
+    if (this.createdTimestamp) state.createdTimestamp = this.createdTimestamp;
+    if (this.updatedTimestamp) state.updatedTimestamp = this.updatedTimestamp;
+    if (this.gender) state.gender = this.gender;
+    if (this.identityNumber) state.identityNumber = this.identityNumber;
+    if (this.phoneNumber) state.phoneNumber = this.phoneNumber;
+    if (this.birthdate) state.birthdate = this.birthdate;
+    return state;
+  }
+
+  abstract get(): Promise<Doctor>;
+
+  abstract put(): Promise<Doctor>;
+
+  abstract post(): Promise<Doctor>;
+
+  abstract delete(): Promise<void>;
+}

package/src/api/doctor/index.ts

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

package/src/api/index.ts

@@ -0,0 +1,12 @@
+export * as AlgorithmApi from './algorithm/index';
+export * as AuthorizationApi from './authorization/index';
+export * as CheckApi from './check/index';
+export * as ConfigApi from './config/index';
+export * as DoctorApi from './doctor/index';
+export * as MetricApi from './metric/index';
+export * as OAuthApi from './oauth/index';
+export * as OutPatientApi from './outpatient/index';
+export * as PatientApi from './patient/index';
+export * as PrescriptionApi from './prescription/index';
+export * as ScientistApi from './scientist/index';
+export * as DeviceApi from './device/device';

package/src/api/metric/implement/index.ts

@@ -0,0 +1 @@
+export * from './metric';

package/src/api/metric/implement/metric.ts

@@ -0,0 +1,108 @@
+import type { MetaType } from 'src/api/patient/meta';
+import { Metric } from 'src/api/metric/metric';
+import type {
+  AgeDistribute,
+  DateDistribute,
+  GenderDistribute,
+} from 'src/api/patient/alova/globals';
+
+export class AlovaMetric extends Metric {
+  // 科研相关统计
+  static override getPatientTodayCount(): Promise<number> {
+    return patientApi.metricRestful.totalOfPatientByToday().send();
+  }
+
+  static override getPatientTotalCount(): Promise<number> {
+    return patientApi.metricRestful.totalOfPatient().send();
+  }
+
+  static override getPatientDateDistribute(): Promise<DateDistribute[]> {
+    return patientApi.metricRestful.dateDistributeOfPatient().send();
+  }
+
+  static override getPatientAgeDistribute(): Promise<AgeDistribute[]> {
+    return patientApi.metricRestful.ageDistributeOfPatient().send();
+  }
+
+  static override getPatientGenderDistribute(): Promise<GenderDistribute[]> {
+    return patientApi.metricRestful.genderDistributeOfPatient().send();
+  }
+
+  // 面象相关统计
+  static override getMetaTodayCount(type: MetaType): Promise<number> {
+    return patientApi.metricRestful
+      .totalOfMetaByToday({
+        params: {
+          type: type,
+        },
+      })
+      .send();
+  }
+
+  static override getMetaTotalCount(type: MetaType): Promise<number> {
+    return patientApi.metricRestful
+      .totalOfMeta({
+        params: {
+          type: type,
+        },
+      })
+      .send();
+  }
+
+  static override getMetaDateDistribute(type: MetaType): Promise<DateDistribute[]> {
+    return patientApi.metricRestful
+      .datesOfMeta({
+        params: {
+          type: type,
+        },
+      })
+      .send();
+  }
+
+  // 病例相关统计
+  static override getCheckGenderDistribute(): Promise<GenderDistribute[]> {
+    return checkApi.checkStateRestful.genderDistributeOfCheckState().send();
+  }
+
+  static override getCheckAgeDistribute(): Promise<AgeDistribute[]> {
+    return checkApi.checkStateRestful.ageDistributeOfCheckState().send();
+  }
+
+  static override getCheckTotalCount(): Promise<number> {
+    return checkApi.checkStateRestful.totalOfCheckState().send();
+  }
+
+  static override getCheckDateDistribute(): Promise<DateDistribute[]> {
+    return checkApi.checkStateRestful.datesOfCheckState().send();
+  }
+
+  static override getCheckTodayCount(): Promise<number> {
+    return checkApi.checkStateRestful.totalOfCheckByTodayState().send();
+  }
+
+  // 医生相关统计
+  static override getDoctorTotalCount(): Promise<number> {
+    return doctorApi.doctorStateRestful.totalOfDoctor().send();
+  }
+
+  static override getDoctorDateDistribute(): Promise<DateDistribute[]> {
+    return doctorApi.doctorStateRestful.datesOfDoctor().send();
+  }
+
+  static override getDoctorTodayCount(): Promise<number> {
+    return doctorApi.doctorStateRestful.totalOfDoctorByToday().send();
+  }
+
+  // 排队相关统计
+  static override getQueuerTotalCount(): Promise<number> {
+    return outpatientApi.metricRestful.totalOfQueuerState().send();
+  }
+
+  static override getQueuerDateDistribute(): Promise<DateDistribute[]> {
+    return outpatientApi.metricRestful.datesOfQueuerState().send();
+  }
+
+  static override getQueuerTodayCount(): Promise<number> {
+    return outpatientApi.metricRestful.totalOfQueuerTodayState().send();
+  }
+}

package/src/api/metric/index.ts

@@ -0,0 +1,2 @@
+export * from './implement';
+export * from './metric';

package/src/api/metric/metric.ts

@@ -0,0 +1,114 @@
+import type { MetaType } from 'src/api/patient/meta';
+import type { IBuilder } from 'builder-pattern';
+import { Builder } from 'builder-pattern';
+import type { DateDistribute } from 'src/api/patient/alova/globals';
+import type { AgeDistribute, GenderDistribute } from 'src/api/check/alova/globals';
+
+export class Metric {
+  static _default: typeof Metric;
+  static builder(): IBuilder<unknown> {
+    return Builder(this._default) as unknown as IBuilder<Metric>;
+  }
+  static default(): typeof Metric {
+    return this._default as unknown as typeof Metric;
+  }
+  // 科研相关统计
+  static getPatientTodayCount(): Promise<number> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getPatientTodayCount();
+  }
+
+  static getPatientTotalCount(): Promise<number> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getPatientTotalCount();
+  }
+
+  static getPatientDateDistribute(): Promise<DateDistribute[]> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getPatientDateDistribute();
+  }
+
+  static getPatientAgeDistribute(): Promise<AgeDistribute[]> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getPatientAgeDistribute();
+  }
+
+  static getPatientGenderDistribute(): Promise<GenderDistribute[]> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getPatientGenderDistribute();
+  }
+
+  // 面象相关统计
+  static getMetaTodayCount(type: MetaType): Promise<number> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getMetaTodayCount(type);
+  }
+
+  static getMetaTotalCount(type: MetaType): Promise<number> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getMetaTotalCount(type);
+  }
+
+  static getMetaDateDistribute(type: MetaType): Promise<DateDistribute[]> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getMetaDateDistribute(type);
+  }
+
+  // 病例相关统计
+  static getCheckGenderDistribute(): Promise<GenderDistribute[]> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getCheckGenderDistribute();
+  }
+
+  static getCheckAgeDistribute(): Promise<AgeDistribute[]> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getCheckAgeDistribute();
+  }
+
+  static getCheckTotalCount(): Promise<number> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getCheckTotalCount();
+  }
+
+  static getCheckDateDistribute(): Promise<DateDistribute[]> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getCheckDateDistribute();
+  }
+
+  static getCheckTodayCount(): Promise<number> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getCheckTodayCount();
+  }
+
+  // 医生相关统计
+  static getDoctorTotalCount(): Promise<number> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getDoctorTotalCount();
+  }
+
+  static getDoctorDateDistribute(): Promise<DateDistribute[]> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getDoctorDateDistribute();
+  }
+
+  static getDoctorTodayCount(): Promise<number> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getDoctorTodayCount();
+  }
+
+  // 排队相关统计
+  static getQueuerTotalCount(): Promise<number> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getQueuerTotalCount();
+  }
+
+  static getQueuerDateDistribute(): Promise<DateDistribute[]> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getQueuerDateDistribute();
+  }
+
+  static getQueuerTodayCount(): Promise<number> {
+    //表单格式的body，不是Json格式的
+    return Metric.default().getQueuerTodayCount();
+  }
+}

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

@@ -0,0 +1,26 @@
+/// <reference types='./globals.d.ts' />
+/* tslint:disable */
+ 
+/**
+ * OpenAPI definition - version v0
+ *
+ *
+ *
+ * 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 {
+  'userStateRestful.getUserState': ['GET', '/互联/服务/用户'],
+  'userStateRestful.putUserState': ['PUT', '/互联/服务/用户'],
+  'phoneVerifyRestful.verifySMSCode': ['POST', '/互联/服务/电话/验证短信'],
+  'phoneVerifyRestful.sendSMSCode': ['GET', '/互联/服务/电话/发送短信'],
+  'phoneVerifyRestful.authToken': ['GET', '/互联/服务/电话/令牌认证'],
+  'authorizationRestful.consent': ['GET', '/互联/服务/授权/许可'],
+  'authorizationRestful.getClientDescription': ['GET', '/互联/服务/授权/客户端介绍'],
+};

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

@@ -0,0 +1,114 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI definition - version v0
+ *
+ *
+ *
+ * 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 oauthApi, {
+    get(_, property) {
+      return createFunctionalProxy([property], alovaInstance, configMap);
+    },
+  });
+  return Apis;
+};
+export const mountApis = (Apis: oauthApi) => {
+  // define global variable `Apis`
+  (globalThis as any).oauthApi = 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 oauthApi
+  ? Url extends keyof oauthApi[Tag]
+    ? oauthApi[Tag][Url] extends (...args: any) => any
+      ? Parameters<oauthApi[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;