Optimize the project structure and introduce DDD design (#394)

projects/app/src/web/common/api/bill.ts

@@ -0,0 +1,27 @@
+import { GET, POST, PUT, DELETE } from '@/web/common/api/request';
+import type { CreateTrainingBillType } from '@/global/common/api/billReq.d';
+import type { PaySchema } from '@/types/mongoSchema';
+import type { PagingData, RequestPaging } from '@/types';
+import { UserBillType } from '@/types/user';
+
+export const getUserBills = (data: RequestPaging) =>
+  POST<PagingData<UserBillType>>(`/user/getBill`, data);
+
+export const postCreateTrainingBill = (data: CreateTrainingBillType) =>
+  POST<string>(`/common/bill/createTrainingBill`, data);
+
+export const getPayOrders = () => GET<PaySchema[]>(`/user/getPayOrders`);
+
+export const getPayCode = (amount: number) =>
+  GET<{
+    codeUrl: string;
+    payId: string;
+  }>(`/plusApi/user/pay/getPayCode`, { amount });
+
+export const checkPayResult = (payId: string) =>
+  GET<number>(`/plusApi/user/pay/checkPayResult`, { payId }).then(() => {
+    try {
+      GET('/user/account/paySuccess');
+    } catch (error) {}
+    return 'success';
+  });

projects/app/src/web/common/api/fetch.ts

@@ -0,0 +1,115 @@
+import { sseResponseEventEnum, TaskResponseKeyEnum } from '@/constants/chat';
+import { getErrText } from '@/utils/tools';
+import { parseStreamChunk, SSEParseData } from '@/utils/sse';
+import type { ChatHistoryItemResType } from '@/types/chat';
+import { StartChatFnProps } from '@/components/ChatBox';
+import { getToken } from '@/utils/user';
+
+type StreamFetchProps = {
+  url?: string;
+  data: Record<string, any>;
+  onMessage: StartChatFnProps['generatingMessage'];
+  abortSignal: AbortController;
+};
+export const streamFetch = ({
+  url = '/api/v1/chat/completions',
+  data,
+  onMessage,
+  abortSignal
+}: StreamFetchProps) =>
+  new Promise<{
+    responseText: string;
+    [TaskResponseKeyEnum.responseData]: ChatHistoryItemResType[];
+  }>(async (resolve, reject) => {
+    try {
+      const response = await window.fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          token: getToken()
+        },
+        signal: abortSignal.signal,
+        body: JSON.stringify({
+          ...data,
+          detail: true,
+          stream: true
+        })
+      });
+
+      if (!response?.body) {
+        throw new Error('Request Error');
+      }
+
+      const reader = response.body?.getReader();
+
+      // response data
+      let responseText = '';
+      let errMsg = '';
+      let responseData: ChatHistoryItemResType[] = [];
+
+      const parseData = new SSEParseData();
+
+      const read = async () => {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            if (response.status === 200 && !errMsg) {
+              return resolve({
+                responseText,
+                responseData
+              });
+            } else {
+              return reject({
+                message: errMsg || '响应过程出现异常~',
+                responseText
+              });
+            }
+          }
+          const chunkResponse = parseStreamChunk(value);
+
+          chunkResponse.forEach((item) => {
+            // parse json data
+            const { eventName, data } = parseData.parse(item);
+
+            if (!eventName || !data) return;
+
+            if (eventName === sseResponseEventEnum.answer && data !== '[DONE]') {
+              const answer: string = data?.choices?.[0]?.delta?.content || '';
+              onMessage({ text: answer });
+              responseText += answer;
+            } else if (
+              eventName === sseResponseEventEnum.moduleStatus &&
+              data?.name &&
+              data?.status
+            ) {
+              onMessage(data);
+            } else if (
+              eventName === sseResponseEventEnum.appStreamResponse &&
+              Array.isArray(data)
+            ) {
+              responseData = data;
+            } else if (eventName === sseResponseEventEnum.error) {
+              errMsg = getErrText(data, '流响应错误');
+            }
+          });
+          read();
+        } catch (err: any) {
+          if (err?.message === 'The user aborted a request.') {
+            return resolve({
+              responseText,
+              responseData
+            });
+          }
+          reject({
+            responseText,
+            message: getErrText(err, '请求异常')
+          });
+        }
+      };
+      read();
+    } catch (err: any) {
+      console.log(err, 'fetch error');
+
+      reject(getErrText(err, '请求异常'));
+    }
+  });

projects/app/src/web/common/api/plugin.ts

@@ -0,0 +1,6 @@
+import { GET, POST, PUT, DELETE } from './request';
+
+import type { FetchResultItem } from '@/global/common/api/pluginRes.d';
+
+export const postFetchUrls = (urlList: string[]) =>
+  POST<FetchResultItem[]>(`/plugins/urlFetch`, { urlList });

projects/app/src/web/common/api/request.ts

@@ -0,0 +1,140 @@
+import axios, {
+  Method,
+  InternalAxiosRequestConfig,
+  AxiosResponse,
+  AxiosProgressEvent
+} from 'axios';
+import { clearToken, getToken } from '@/utils/user';
+import { TOKEN_ERROR_CODE } from '@/service/errorCode';
+
+interface ConfigType {
+  headers?: { [key: string]: string };
+  hold?: boolean;
+  timeout?: number;
+  onUploadProgress?: (progressEvent: AxiosProgressEvent) => void;
+  cancelToken?: AbortController;
+}
+interface ResponseDataType {
+  code: number;
+  message: string;
+  data: any;
+}
+
+/**
+ * 请求开始
+ */
+function requestStart(config: InternalAxiosRequestConfig): InternalAxiosRequestConfig {
+  if (config.headers) {
+    config.headers.token = getToken();
+  }
+
+  return config;
+}
+
+/**
+ * 请求成功,检查请求头
+ */
+function responseSuccess(response: AxiosResponse<ResponseDataType>) {
+  return response;
+}
+/**
+ * 响应数据检查
+ */
+function checkRes(data: ResponseDataType) {
+  if (data === undefined) {
+    console.log('error->', data, 'data is empty');
+    return Promise.reject('服务器异常');
+  } else if (data.code < 200 || data.code >= 400) {
+    return Promise.reject(data);
+  }
+  return data.data;
+}
+
+/**
+ * 响应错误
+ */
+function responseError(err: any) {
+  console.log('error->', '请求错误', err);
+
+  if (!err) {
+    return Promise.reject({ message: '未知错误' });
+  }
+  if (typeof err === 'string') {
+    return Promise.reject({ message: err });
+  }
+  // 有报错响应
+  if (err?.code in TOKEN_ERROR_CODE) {
+    clearToken();
+    window.location.replace(
+      `/login?lastRoute=${encodeURIComponent(location.pathname + location.search)}`
+    );
+    return Promise.reject({ message: 'token过期，重新登录' });
+  }
+  if (err?.response?.data) {
+    return Promise.reject(err?.response?.data);
+  }
+  return Promise.reject(err);
+}
+
+/* 创建请求实例 */
+const instance = axios.create({
+  timeout: 60000, // 超时时间
+  headers: {
+    'content-type': 'application/json'
+  }
+});
+
+/* 请求拦截 */
+instance.interceptors.request.use(requestStart, (err) => Promise.reject(err));
+/* 响应拦截 */
+instance.interceptors.response.use(responseSuccess, (err) => Promise.reject(err));
+
+function request(
+  url: string,
+  data: any,
+  { cancelToken, ...config }: ConfigType,
+  method: Method
+): any {
+  /* 去空 */
+  for (const key in data) {
+    if (data[key] === null || data[key] === undefined) {
+      delete data[key];
+    }
+  }
+
+  return instance
+    .request({
+      baseURL: '/api',
+      url,
+      method,
+      data: ['POST', 'PUT'].includes(method) ? data : null,
+      params: !['POST', 'PUT'].includes(method) ? data : null,
+      signal: cancelToken?.signal,
+      ...config // 用户自定义配置，可以覆盖前面的配置
+    })
+    .then((res) => checkRes(res.data))
+    .catch((err) => responseError(err));
+}
+
+/**
+ * api请求方式
+ * @param {String} url
+ * @param {Any} params
+ * @param {Object} config
+ * @returns
+ */
+export function GET<T>(url: string, params = {}, config: ConfigType = {}): Promise<T> {
+  return request(url, params, config, 'GET');
+}
+
+export function POST<T>(url: string, data = {}, config: ConfigType = {}): Promise<T> {
+  return request(url, data, config, 'POST');
+}
+
+export function PUT<T>(url: string, data = {}, config: ConfigType = {}): Promise<T> {
+  return request(url, data, config, 'PUT');
+}
+
+export function DELETE<T>(url: string, data = {}, config: ConfigType = {}): Promise<T> {
+  return request(url, data, config, 'DELETE');
+}

projects/app/src/web/common/api/system.ts

@@ -0,0 +1,21 @@
+import { GET, POST, PUT } from './request';
+import type { InitDateResponse } from '@/global/common/api/systemRes';
+import { AxiosProgressEvent } from 'axios';
+
+export const getSystemInitData = () => GET<InitDateResponse>('/system/getInitData');
+
+export const postUploadImg = (base64Img: string) =>
+  POST<string>('/system/file/uploadImage', { base64Img });
+
+export const postUploadFiles = (
+  data: FormData,
+  onUploadProgress: (progressEvent: AxiosProgressEvent) => void
+) =>
+  POST<string[]>('/system/file/upload', data, {
+    onUploadProgress,
+    headers: {
+      'Content-Type': 'multipart/form-data; charset=utf-8'
+    }
+  });
+
+export const getFileViewUrl = (fileId: string) => GET<string>('/system/file/readUrl', { fileId });