4.6.4-alpha (#569)

projects/app/src/service/support/permission/auth/chat.ts

@@ -0,0 +1,59 @@
+import { ChatSchema } from '@fastgpt/global/core/chat/type';
+import { MongoChat } from '@fastgpt/service/core/chat/chatSchema';
+import { AuthModeType } from '@fastgpt/service/support/permission/type';
+import { authOutLink } from './outLink';
+import { ChatErrEnum } from '@fastgpt/global/common/error/code/chat';
+import { authUserRole } from '@fastgpt/service/support/permission/auth/user';
+import { TeamMemberRoleEnum } from '@fastgpt/global/support/user/team/constant';
+
+/* 
+  outLink: Must be the owner
+  token: team owner and chat owner have all permissions
+*/
+export async function autChatCrud({
+  chatId,
+  shareId,
+  outLinkUid,
+  per = 'owner',
+  ...props
+}: AuthModeType & {
+  chatId?: string;
+  shareId?: string;
+  outLinkUid?: string;
+}): Promise<{
+  chat?: ChatSchema;
+  isOutLink: boolean;
+  uid?: string;
+}> {
+  const isOutLink = Boolean(shareId && outLinkUid);
+  if (!chatId) return { isOutLink, uid: outLinkUid };
+
+  const chat = await MongoChat.findOne({ chatId }).lean();
+
+  if (!chat) return { isOutLink, uid: outLinkUid };
+
+  const { uid } = await (async () => {
+    // outLink Auth
+    if (shareId && outLinkUid) {
+      const { uid } = await authOutLink({ shareId, outLinkUid });
+
+      // auth outLinkUid
+      if (chat.shareId === shareId && chat.outLinkUid === uid) {
+        return { uid };
+      }
+      return Promise.reject(ChatErrEnum.unAuthChat);
+    }
+
+    // req auth
+    const { tmbId, role } = await authUserRole(props);
+    if (role === TeamMemberRoleEnum.owner) return { uid: outLinkUid };
+    if (String(tmbId) === String(chat.tmbId)) return { uid: outLinkUid };
+    return Promise.reject(ChatErrEnum.unAuthChat);
+  })();
+
+  return {
+    chat,
+    isOutLink,
+    uid
+  };
+}

projects/app/src/service/support/permission/auth/outLink.ts

@@ -1,31 +1,74 @@
-import { authOutLinkLimit } from '@/service/support/outLink/auth';
-import { AuthLinkChatProps } from '@fastgpt/global/support/outLink/api.d';
-import { AuthUserTypeEnum } from '@fastgpt/global/support/permission/constant';
-import { getUserAndAuthBalance } from './user';
+import { POST } from '@fastgpt/service/common/api/plusRequest';
+import type {
+  AuthOutLinkChatProps,
+  AuthOutLinkLimitProps,
+  AuthOutLinkInitProps,
+  AuthOutLinkResponse
+} from '@fastgpt/global/support/outLink/api.d';
 import { authOutLinkValid } from '@fastgpt/service/support/permission/auth/outLink';
+import { getUserAndAuthBalance } from '@fastgpt/service/support/user/controller';
+import { AuthUserTypeEnum } from '@fastgpt/global/support/permission/constant';
+import { OutLinkErrEnum } from '@fastgpt/global/common/error/code/outLink';
+import { OutLinkSchema } from '@fastgpt/global/support/outLink/type';
 
-export async function authOutLinkChat({
+export function authOutLinkInit(data: AuthOutLinkInitProps): Promise<AuthOutLinkResponse> {
+  if (!global.feConfigs?.isPlus) return Promise.resolve({ uid: data.outLinkUid });
+  return POST<AuthOutLinkResponse>('/support/outLink/authInit', data);
+}
+export function authOutLinkChatLimit(data: AuthOutLinkLimitProps): Promise<AuthOutLinkResponse> {
+  if (!global.feConfigs?.isPlus) return Promise.resolve({ uid: data.outLinkUid });
+  return POST<AuthOutLinkResponse>('/support/outLink/authChatStart', data);
+}
+
+export const authOutLink = async ({
+  shareId,
+  outLinkUid
+}: {
+  shareId?: string;
+  outLinkUid?: string;
+}): Promise<{
+  uid: string;
+  appId: string;
+  shareChat: OutLinkSchema;
+}> => {
+  if (!outLinkUid) {
+    return Promise.reject(OutLinkErrEnum.linkUnInvalid);
+  }
+  const result = await authOutLinkValid({ shareId });
+
+  const { uid } = await authOutLinkInit({
+    outLinkUid,
+    tokenUrl: result.shareChat.limit?.hookUrl
+  });
+
+  return {
+    ...result,
+    uid
+  };
+};
+
+export async function authOutLinkChatStart({
   shareId,
   ip,
-  authToken,
+  outLinkUid,
   question
-}: AuthLinkChatProps & {
+}: AuthOutLinkChatProps & {
   shareId: string;
 }) {
-  // get outLink
-  const { shareChat, app } = await authOutLinkValid({ shareId });
+  // get outLink and app
+  const { shareChat, appId } = await authOutLinkValid({ shareId });
 
-  const [user] = await Promise.all([
+  // check balance and chat limit
+  const [user, { uid }] = await Promise.all([
     getUserAndAuthBalance({ tmbId: shareChat.tmbId, minBalance: 0 }),
-    global.feConfigs?.isPlus
-      ? authOutLinkLimit({ outLink: shareChat, ip, authToken, question })
-      : undefined
+    authOutLinkChatLimit({ outLink: shareChat, ip, outLinkUid, question })
   ]);
 
   return {
     authType: AuthUserTypeEnum.token,
     responseDetail: shareChat.responseDetail,
     user,
-    app
+    appId,
+    uid
   };
 }

projects/app/src/service/support/permission/auth/user.ts

@@ -1,46 +0,0 @@
-import { AuthResponseType } from '@fastgpt/global/support/permission/type';
-import { parseHeaderCert } from '@fastgpt/service/support/permission/controller';
-import { AuthModeType } from '@fastgpt/service/support/permission/type';
-import { UserErrEnum } from '@fastgpt/global/common/error/code/user';
-import { UserType } from '@fastgpt/global/support/user/type';
-import { getUserDetail } from '@/service/support/user/controller';
-
-export async function getUserAndAuthBalance({
-  tmbId,
-  minBalance
-}: {
-  tmbId: string;
-  minBalance?: number;
-}) {
-  const user = await getUserDetail({ tmbId });
-
-  if (!user) {
-    return Promise.reject(UserErrEnum.unAuthUser);
-  }
-  if (minBalance !== undefined && global.feConfigs.isPlus && user.team.balance < minBalance) {
-    return Promise.reject(UserErrEnum.balanceNotEnough);
-  }
-
-  return user;
-}
-
-/* get user */
-export async function authUser({
-  minBalance,
-  ...props
-}: AuthModeType & {
-  minBalance?: number;
-}): Promise<
-  AuthResponseType & {
-    user: UserType;
-  }
-> {
-  const result = await parseHeaderCert(props);
-
-  return {
-    ...result,
-    user: await getUserAndAuthBalance({ tmbId: result.tmbId, minBalance }),
-    isOwner: true,
-    canWrite: true
-  };
-}