v4.6 -1 (#459)

projects/app/src/pages/api/common/bill/createTrainingBill.ts

@@ -1,47 +0,0 @@
-import type { NextApiRequest, NextApiResponse } from 'next';
-import { jsonRes } from '@/service/response';
-import { connectToDatabase, Bill } from '@/service/mongo';
-import { authUser } from '@fastgpt/service/support/user/auth';
-import { BillSourceEnum } from '@/constants/user';
-import { CreateTrainingBillType } from '@fastgpt/global/common/bill/types/billReq.d';
-
-export default async function handler(req: NextApiRequest, res: NextApiResponse) {
-  try {
-    await connectToDatabase();
-    const { name } = req.body as CreateTrainingBillType;
-
-    const { userId } = await authUser({ req, authToken: true, authApiKey: true });
-
-    const qaModel = global.qaModels[0];
-
-    const { _id } = await Bill.create({
-      userId,
-      appName: name,
-      source: BillSourceEnum.training,
-      list: [
-        {
-          moduleName: '索引生成',
-          model: 'embedding',
-          amount: 0,
-          tokenLen: 0
-        },
-        {
-          moduleName: 'QA 拆分',
-          model: qaModel?.name,
-          amount: 0,
-          tokenLen: 0
-        }
-      ],
-      total: 0
-    });
-
-    jsonRes<string>(res, {
-      data: _id
-    });
-  } catch (err) {
-    jsonRes(res, {
-      code: 500,
-      error: err
-    });
-  }
-}

projects/app/src/pages/api/common/file/read.ts

@@ -0,0 +1,43 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@fastgpt/service/common/response';
+import { connectToDatabase } from '@/service/mongo';
+import { authFileToken } from '@fastgpt/service/support/permission/controller';
+import jschardet from 'jschardet';
+import { getDownloadBuf, getFileById } from '@fastgpt/service/common/file/gridfs/controller';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
+  try {
+    await connectToDatabase();
+
+    const { token } = req.query as { token: string };
+
+    const { fileId, teamId, tmbId, bucketName } = await authFileToken(token);
+
+    if (!fileId) {
+      throw new Error('fileId is empty');
+    }
+
+    const [file, buffer] = await Promise.all([
+      getFileById({ bucketName, fileId }),
+      getDownloadBuf({ bucketName, fileId })
+    ]);
+
+    const encoding = jschardet.detect(buffer)?.encoding;
+
+    res.setHeader('Content-Type', `${file.contentType}; charset=${encoding}`);
+    res.setHeader('Cache-Control', 'public, max-age=3600');
+    res.setHeader('Content-Disposition', `inline; filename="${encodeURIComponent(file.filename)}"`);
+
+    res.end(buffer);
+  } catch (error) {
+    jsonRes(res, {
+      code: 500,
+      error
+    });
+  }
+}
+export const config = {
+  api: {
+    responseLimit: '32mb'
+  }
+};

projects/app/src/pages/api/common/file/upload.ts

@@ -0,0 +1,118 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@fastgpt/service/common/response';
+import { connectToDatabase } from '@/service/mongo';
+import { authCert } from '@fastgpt/service/support/permission/auth/common';
+import { customAlphabet } from 'nanoid';
+import multer from 'multer';
+import path from 'path';
+import { uploadFile } from '@fastgpt/service/common/file/gridfs/controller';
+import { BucketNameEnum } from '@fastgpt/global/common/file/constants';
+
+const nanoid = customAlphabet('1234567890abcdef', 12);
+
+type FileType = {
+  fieldname: string;
+  originalname: string;
+  encoding: string;
+  mimetype: string;
+  filename: string;
+  path: string;
+  size: number;
+};
+
+/**
+ * Creates the multer uploader
+ */
+const maxSize = 500 * 1024 * 1024;
+class UploadModel {
+  uploader = multer({
+    limits: {
+      fieldSize: maxSize
+    },
+    preservePath: true,
+    storage: multer.diskStorage({
+      filename: (_req, file, cb) => {
+        const { ext } = path.parse(decodeURIComponent(file.originalname));
+        cb(null, nanoid() + ext);
+      }
+    })
+  }).any();
+
+  async doUpload(req: NextApiRequest, res: NextApiResponse) {
+    return new Promise<{
+      files: FileType[];
+      bucketName: `${BucketNameEnum}`;
+      metadata: Record<string, any>;
+    }>((resolve, reject) => {
+      // @ts-ignore
+      this.uploader(req, res, (error) => {
+        if (error) {
+          return reject(error);
+        }
+
+        resolve({
+          files:
+            // @ts-ignore
+            req.files?.map((file) => ({
+              ...file,
+              originalname: decodeURIComponent(file.originalname)
+            })) || [],
+          bucketName: req.body.bucketName,
+          metadata: (() => {
+            if (!req.body?.metadata) return {};
+            try {
+              return JSON.parse(req.body.metadata);
+            } catch (error) {
+              console.log(error);
+
+              return {};
+            }
+          })()
+        });
+      });
+    });
+  }
+}
+
+const upload = new UploadModel();
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
+  try {
+    await connectToDatabase();
+    const { userId, teamId, tmbId } = await authCert({ req, authToken: true });
+
+    const { files, bucketName, metadata } = await upload.doUpload(req, res);
+
+    const upLoadResults = await Promise.all(
+      files.map((file) =>
+        uploadFile({
+          teamId,
+          tmbId,
+          bucketName,
+          path: file.path,
+          filename: file.originalname,
+          metadata: {
+            ...metadata,
+            contentType: file.mimetype,
+            userId
+          }
+        })
+      )
+    );
+
+    jsonRes(res, {
+      data: upLoadResults
+    });
+  } catch (error) {
+    jsonRes(res, {
+      code: 500,
+      error
+    });
+  }
+}
+
+export const config = {
+  api: {
+    bodyParser: false
+  }
+};

projects/app/src/pages/api/common/file/uploadImage.ts

@@ -0,0 +1,27 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@fastgpt/service/common/response';
+import { connectToDatabase } from '@/service/mongo';
+import { authCert } from '@fastgpt/service/support/permission/auth/common';
+import { uploadMongoImg } from '@fastgpt/service/common/file/image/controller';
+
+type Props = { base64Img: string };
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  try {
+    await connectToDatabase();
+    const { userId } = await authCert({ req, authToken: true });
+    const { base64Img } = req.body as Props;
+
+    const data = await uploadMongoImg({
+      userId,
+      base64Img
+    });
+
+    jsonRes(res, { data });
+  } catch (error) {
+    jsonRes(res, {
+      code: 500,
+      error
+    });
+  }
+}

projects/app/src/pages/api/common/system/unlockTask.ts

@@ -0,0 +1,32 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@fastgpt/service/common/response';
+import { connectToDatabase } from '@/service/mongo';
+import { MongoDatasetTraining } from '@fastgpt/service/core/dataset/training/schema';
+import { startQueue } from '@/service/utils/tools';
+import { authCert } from '@fastgpt/service/support/permission/auth/common';
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
+  try {
+    await connectToDatabase();
+    const { userId } = await authCert({ req, authToken: true });
+    await unlockTask(userId);
+  } catch (error) {}
+  jsonRes(res);
+}
+
+async function unlockTask(userId: string) {
+  try {
+    await MongoDatasetTraining.updateMany(
+      {
+        userId
+      },
+      {
+        lockTime: new Date('2000/1/1')
+      }
+    );
+
+    startQueue();
+  } catch (error) {
+    unlockTask(userId);
+  }
+}