web-core-tcm 0.0.24 → 0.0.25

package/src/api/prescription/alova/implement/herbal.ts

@@ -0,0 +1,68 @@
+import { Herbal } from 'src/api/prescription/herbal';
+import type { Doctor } from 'src/api/doctor/doctor';
+
+export class AlovaHerbal extends Herbal {
+  static override query(
+    page: number = 0,
+    pageSize: number = 9999999,
+    owner?: Doctor,
+    name?: string,
+    price?: number,
+  ) {
+    const ownerState = owner?.state();
+    return prescriptionApi.herbalRestful
+      .queryHerbalState({
+        data: {
+          ...(ownerState && { ownerState }),
+          ...(name && { name }),
+          ...(price !== undefined && { price }),
+          page: page,
+          pageSize,
+        },
+        async transform(res) {
+          return {
+            data: (await Promise.all(
+              res.content.map((item) => new AlovaHerbal().of(item)),
+            )) as Herbal[],
+            total: res.totalElements,
+            page: res.number,
+            pageSize: res.size,
+            pageCount: res.totalPages,
+            isLastPage: res.last,
+          };
+        },
+      })
+      .send();
+  }
+  async put() {
+    return this.of(
+      await prescriptionApi.herbalRestful
+        .putHerbalState({
+          pathParams: {
+            id: this.id,
+          },
+          data: this.state(),
+        })
+        .send(true),
+    );
+  }
+  async post() {
+    return this.of(
+      await prescriptionApi.herbalRestful
+        .postHerbalState({
+          data: this.state(),
+        })
+        .send(true),
+    );
+  }
+  async delete() {
+    void prescriptionApi.herbalRestful
+      .deleteHerbalState({
+        pathParams: {
+          id: this.id,
+        },
+      })
+      .send();
+    return Promise.resolve();
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './herbal';
+export * from './prescription';

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

@@ -0,0 +1,62 @@
+import { Prescription } from 'src/api/prescription/prescription';
+import type { Doctor } from 'src/api/doctor/doctor';
+
+export class AlovaPrescription extends Prescription {
+  static override query(
+    page: number = 0,
+    pageSize: number = 9999999,
+    owner?: Doctor,
+    name?: string,
+  ) {
+    const ownerState = owner?.state();
+    return prescriptionApi.prescriptionRestful
+      .queryPrescriptionState({
+        data: {
+          ...(ownerState && { ownerState }),
+          ...(name && { name }),
+          page: page,
+          pageSize,
+        },
+        async transform(res) {
+          return {
+            data: await Promise.all(res.content.map((item) => new AlovaPrescription().of(item))),
+            total: res.totalElements,
+            page: res.number,
+            pageSize: res.size,
+            pageCount: res.totalPages,
+            isLastPage: res.last,
+          };
+        },
+      })
+      .send();
+  }
+  //put
+  override async put() {
+    return this.of(
+      await prescriptionApi.prescriptionRestful
+        .putPrescriptionState({ pathParams: { id: this.id }, data: this.state() })
+        .send(),
+    );
+  }
+  //post
+  override async post() {
+    return this.of(
+      await prescriptionApi.prescriptionRestful
+        .postPrescriptionState({
+          data: this.state(),
+        })
+        .send(),
+    );
+  }
+  //delete
+  override async delete() {
+    await prescriptionApi.prescriptionRestful
+      .deletePrescriptionState({
+        pathParams: {
+          id: this.id,
+        },
+      })
+      .send();
+    return this;
+  }
+}

package/src/api/prescription/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.Prescription),
+  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/prescription/herbal.ts

@@ -0,0 +1,51 @@
+import type { Page } from 'src/api/patient/core';
+import { NetworkObject } from 'src/api/patient/core';
+import type { HerbalState } from 'src/api/prescription/alova/globals';
+import type { IBuilder } from 'builder-pattern';
+import { Builder } from 'builder-pattern';
+import { Doctor } from 'src/api/doctor/doctor';
+
+export abstract class Herbal extends NetworkObject {
+  static override builder(): IBuilder<Herbal> {
+    return Builder(this._default) as unknown as IBuilder<Herbal>;
+  }
+  static override default(): typeof Herbal {
+    return this._default as unknown as typeof Herbal;
+  }
+  id: string = '';
+  name: string = '';
+  price: number = 0;
+  weight: number = 0;
+  owner: Doctor = Doctor.builder().build();
+
+  override async of(json: HerbalState) {
+    if (json.id != undefined) this.id = json.id;
+    if (json.name != undefined) this.name = json.name;
+    if (json.price != undefined) this.price = json.price;
+    if (json.weight != undefined) this.weight = json.weight;
+    if (json.ownerState != undefined)
+      this.owner = await Doctor.builder().build().of(json.ownerState);
+    return this;
+  }
+  override state() {
+    return {
+      id: this.id,
+      name: this.name,
+      price: this.price,
+      weight: this.weight,
+      ownerState: this.owner.state(),
+    } as HerbalState;
+  }
+  static query(
+    page: number = 0,
+    pageSize: number = 9999999,
+    owner?: Doctor,
+    name?: string,
+    price?: number,
+  ): Promise<Page<Herbal>> {
+    return Herbal.default().query(page, pageSize, owner, name, price);
+  }
+  abstract put(): Promise<this>;
+  abstract post(): Promise<this>;
+  abstract delete(): Promise<void>;
+}

package/src/api/prescription/index.ts

@@ -0,0 +1,3 @@
+export * from './herbal';
+export * from './prescription';
+export * from './alova';

package/src/api/prescription/prescription.ts

@@ -0,0 +1,76 @@
+import { Herbal } from 'src/api/prescription/herbal';
+import type { PrescriptionState } from 'src/api/prescription/alova/globals';
+import type { Page } from 'src/api/patient/core';
+import { NetworkObject } from 'src/api/patient/core';
+import type { IBuilder } from 'builder-pattern';
+import { Builder } from 'builder-pattern';
+import { Doctor } from 'src/api/doctor/doctor';
+
+export abstract class Prescription extends NetworkObject {
+  static override builder(): IBuilder<Prescription> {
+    return Builder(this._default) as unknown as IBuilder<Prescription>;
+  }
+  static override default(): typeof Prescription {
+    return this._default as unknown as typeof Prescription;
+  }
+  id: string = '';
+  createdTimestamp: string = '';
+  updatedTimestamp: string = '';
+  name: string = '匿名药方';
+  owner: Doctor = Doctor.builder().build();
+  totalAmount: number = 0;
+  useAmount: number = 0;
+  craftType: string = '自煎';
+  useWay: string[] = ['煎服'];
+  useTime: string[] = ['早上', '晚上'];
+  herbals: Herbal[] = [];
+  override async of(json: PrescriptionState) {
+    if (json.id != undefined) this.id = json.id;
+    if (json.createdTimestamp != undefined) this.createdTimestamp = json.createdTimestamp;
+    if (json.updatedTimestamp != undefined) this.updatedTimestamp = json.updatedTimestamp;
+    if (json.name != undefined) this.name = json.name;
+    if (json.ownerState != undefined)
+      this.owner = await Doctor.builder().build().of(json.ownerState);
+    if (json.totalAmount != undefined) this.totalAmount = json.totalAmount;
+    if (json.useAmount != undefined) this.useAmount = json.useAmount;
+    if (json.craftType != undefined) this.craftType = json.craftType;
+    if (json.useWay != undefined) this.useWay = json.useWay;
+    if (json.useTime != undefined) this.useTime = json.useTime;
+    if (json.herbalsState != undefined) {
+      this.herbals = await Promise.all(
+        json.herbalsState.map((item) => Herbal.builder().build().of(item)),
+      );
+    }
+    return Promise.resolve(this);
+  }
+  override state(): PrescriptionState {
+    return {
+      id: this.id,
+      createdTimestamp: this.createdTimestamp,
+      updatedTimestamp: this.updatedTimestamp,
+      name: this.name,
+      ownerState: this.owner.state(),
+      totalAmount: this.totalAmount,
+      useAmount: this.useAmount,
+      craftType: this.craftType,
+      useWay: this.useWay,
+      useTime: this.useTime,
+      herbalsState: this.herbals.map((herbal) => herbal.state()),
+    } as PrescriptionState;
+  }
+  static query(
+    page: number = 0,
+    pageSize: number = 9999999,
+    owner?: Doctor,
+    name?: string,
+  ): Promise<Page<Prescription>> {
+    return Prescription.default().query(page, pageSize, owner, name);
+  }
+
+  //put
+  abstract put(): Promise<this>;
+  //post
+  abstract post(): Promise<this>;
+  //delete
+  abstract delete(): Promise<this>;
+}

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

@@ -0,0 +1,27 @@
+/// <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 {
+  'scientistStateRestful.getScientistState': ['GET', '/科研/服务/{id}'],
+  'scientistStateRestful.putScientistState': ['PUT', '/科研/服务/{id}'],
+  'scientistStateRestful.deleteScientistState': ['DELETE', '/科研/服务/{id}'],
+  'scientistStateRestful.queryScientistState': ['GET', '/科研/服务'],
+  'scientistStateRestful.postScientistState': ['POST', '/科研/服务'],
+  'scientistStateRestful.datesOfScientist': ['GET', '/科研/服务/统计/科研/日期'],
+  'scientistStateRestful.totalOfScientist': ['GET', '/科研/服务/统计/科研/总数'],
+  'scientistStateRestful.todayOfScientistByToday': ['GET', '/科研/服务/统计/科研/今日'],
+};

package/src/api/scientist/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 scientistApi, {
+    get(_, property) {
+      return createFunctionalProxy([property], alovaInstance, configMap);
+    },
+  });
+  return Apis;
+};
+export const mountApis = (Apis: scientistApi) => {
+  // define global variable `Apis`
+  (globalThis as any).scientistApi = 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 scientistApi
+  ? Url extends keyof scientistApi[Tag]
+    ? scientistApi[Tag][Url] extends (...args: any) => any
+      ? Parameters<scientistApi[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;