user feedback and admin mark (#228)

* fix: csv empty data

* feat: user feedback and mark answer

* version intro

* perf: chat logs sort

client/src/pages/api/app/getChatLogs.ts

@@ -1,6 +1,6 @@
 import type { NextApiRequest, NextApiResponse } from 'next';
 import { jsonRes } from '@/service/response';
-import { Chat, ChatItem, connectToDatabase } from '@/service/mongo';
+import { Chat, connectToDatabase } from '@/service/mongo';
 import { authUser } from '@/service/utils/auth';
 import type { PagingData } from '@/types';
 import { AppLogsListItemType } from '@/types/app';
@@ -30,25 +30,48 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     const [data, total] = await Promise.all([
       Chat.aggregate([
         { $match: where },
-        { $sort: { updateTime: -1 } },
-        { $skip: (pageNum - 1) * pageSize },
-        { $limit: pageSize },
         {
           $lookup: {
             from: 'chatitems',
             localField: 'chatId',
             foreignField: 'chatId',
-            as: 'messageCount'
+            as: 'chatitems'
           }
         },
+        {
+          $addFields: {
+            feedbackCount: {
+              $size: {
+                $filter: {
+                  input: '$chatitems',
+                  as: 'item',
+                  cond: { $ifNull: ['$$item.userFeedback', false] }
+                }
+              }
+            },
+            markCount: {
+              $size: {
+                $filter: {
+                  input: '$chatitems',
+                  as: 'item',
+                  cond: { $ifNull: ['$$item.adminFeedback', false] }
+                }
+              }
+            }
+          }
+        },
+        { $sort: { feedbackCount: -1, updateTime: -1 } },
+        { $skip: (pageNum - 1) * pageSize },
+        { $limit: pageSize },
         {
           $project: {
             id: '$chatId',
             title: 1,
             source: 1,
             time: '$updateTime',
-            messageCount: { $size: '$messageCount' },
-            callbackCount: { $literal: 0 }
+            messageCount: { $size: '$chatitems' },
+            feedbackCount: 1,
+            markCount: 1
           }
         }
       ]),

client/src/pages/api/chat/feedback/adminUpdate.ts

@@ -0,0 +1,40 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@/service/response';
+import { connectToDatabase, ChatItem } from '@/service/mongo';
+import { AdminUpdateFeedbackParams } from '@/api/request/chat';
+import { authUser } from '@/service/utils/auth';
+
+/* 初始化我的聊天框，需要身份验证 */
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  try {
+    await connectToDatabase();
+    const { chatItemId, kbId, dataId, content = undefined } = req.body as AdminUpdateFeedbackParams;
+
+    if (!chatItemId || !kbId || !dataId || !content) {
+      throw new Error('missing parameter');
+    }
+
+    const { userId } = await authUser({ req, authToken: true });
+
+    await ChatItem.findOneAndUpdate(
+      {
+        userId,
+        dataId: chatItemId
+      },
+      {
+        adminFeedback: {
+          kbId,
+          dataId,
+          content
+        }
+      }
+    );
+
+    jsonRes(res);
+  } catch (err) {
+    jsonRes(res, {
+      code: 500,
+      error: err
+    });
+  }
+}

client/src/pages/api/chat/feedback/userUpdate.ts

@@ -0,0 +1,34 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@/service/response';
+import { connectToDatabase, ChatItem } from '@/service/mongo';
+
+/* 初始化我的聊天框，需要身份验证 */
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  try {
+    await connectToDatabase();
+    const { chatItemId, userFeedback = undefined } = req.body as {
+      chatItemId: string;
+      userFeedback?: string;
+    };
+
+    if (!chatItemId) {
+      throw new Error('chatItemId is required');
+    }
+
+    await ChatItem.findOneAndUpdate(
+      {
+        dataId: chatItemId
+      },
+      {
+        ...(userFeedback ? { userFeedback } : { $unset: { userFeedback: '' } })
+      }
+    );
+
+    jsonRes(res);
+  } catch (err) {
+    jsonRes(res, {
+      code: 500,
+      error: err
+    });
+  }
+}

client/src/pages/api/chat/init.ts

@@ -54,7 +54,7 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
                 chatId,
                 userId
               },
-              `dataId obj value ${TaskResponseKeyEnum.responseData}`
+              `dataId obj value adminFeedback userFeedback ${TaskResponseKeyEnum.responseData}`
             )
               .sort({ _id: -1 })
               .limit(30)

client/src/pages/api/openapi/kb/updateData.ts

@@ -25,7 +25,10 @@ export default withNextCors(async function handler(req: NextApiRequest, res: Nex
     await connectToDatabase();
 
     // auth user and get kb
-    const [{ userId }, kb] = await Promise.all([authUser({ req }), KB.findById(kbId, 'model')]);
+    const [{ userId }, kb] = await Promise.all([
+      authUser({ req }),
+      KB.findById(kbId, 'vectorModel')
+    ]);
 
     if (!kb) {
       throw new Error("Can't find database");

client/src/pages/api/plugins/kb/data/insertData.ts

@@ -0,0 +1,88 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { jsonRes } from '@/service/response';
+import { connectToDatabase, KB } from '@/service/mongo';
+import { authKb, authUser } from '@/service/utils/auth';
+import { withNextCors } from '@/service/utils/tools';
+import { PgTrainingTableName } from '@/constants/plugin';
+import { insertKbItem, PgClient } from '@/service/pg';
+import { modelToolMap } from '@/utils/plugin';
+import { getVectorModel } from '@/service/utils/data';
+import { getVector } from '@/pages/api/openapi/plugin/vector';
+
+export type Props = {
+  kbId: string;
+  data: { a: string; q: string; source?: string };
+};
+
+export default withNextCors(async function handler(req: NextApiRequest, res: NextApiResponse<any>) {
+  try {
+    await connectToDatabase();
+
+    const { kbId, data = { q: '', a: '' } } = req.body as Props;
+
+    if (!kbId || !data?.q) {
+      throw new Error('缺少参数');
+    }
+
+    // 凭证校验
+    const { userId } = await authUser({ req });
+
+    // auth kb
+    const kb = await authKb({ kbId, userId });
+
+    const q = data?.q?.replace(/\\n/g, '\n').trim().replace(/'/g, '"');
+    const a = data?.a?.replace(/\\n/g, '\n').trim().replace(/'/g, '"');
+
+    // token check
+    const token = modelToolMap.countTokens({
+      model: 'gpt-3.5-turbo',
+      messages: [{ obj: 'System', value: q }]
+    });
+
+    if (token > getVectorModel(kb.vectorModel).maxToken) {
+      throw new Error('Over Tokens');
+    }
+
+    const { rows: existsRows } = await PgClient.query(`
+    SELECT COUNT(*) > 0 AS exists
+    FROM  ${PgTrainingTableName} 
+    WHERE md5(q)=md5('${q}') AND md5(a)=md5('${a}') AND user_id='${userId}' AND kb_id='${kbId}'
+  `);
+    const exists = existsRows[0]?.exists || false;
+
+    if (exists) {
+      throw new Error('已经存在完全一致的数据');
+    }
+
+    const { vectors } = await getVector({
+      model: kb.vectorModel,
+      input: [q],
+      userId
+    });
+
+    const response = await insertKbItem({
+      userId,
+      kbId,
+      data: [
+        {
+          q,
+          a,
+          source: data.source,
+          vector: vectors[0]
+        }
+      ]
+    });
+
+    // @ts-ignore
+    const id = response?.rows?.[0]?.id || '';
+
+    jsonRes(res, {
+      data: id
+    });
+  } catch (err) {
+    jsonRes(res, {
+      code: 500,
+      error: err
+    });
+  }
+});