feat: 랜딩페이지 입장시 프로젝트의 리더에게만 초대링크를 제공하도록 변경

backend/src/project/dto/InitLandingResponse.dto.ts

@@ -79,7 +79,7 @@ class ProjectLandingPageContentDto {
   sprint: null;
   memoList: MemoDto[];
   linkList: LinkDto[];
-  inviteLinkId: string;
+  inviteLinkId?: string;
 
   static of(
     project: Project,
@@ -112,7 +112,7 @@ class ProjectLandingPageContentDto {
     const linkDtoList = linkList.map((link) => LinkDto.of(link));
     dto.linkList = linkDtoList;
 
-    dto.inviteLinkId = project.inviteLinkId;
+    if (project.inviteLinkId) dto.inviteLinkId = project.inviteLinkId;
     return dto;
   }
 }

backend/src/project/project.controller.ts

@@ -61,7 +61,7 @@ export class ProjectController {
     if (!project) throw new NotFoundException();
 
     const isProjectMember = await this.projectService.isProjectMember(
-      project,
+      project.id,
       request.member,
     );
     if (isProjectMember)
@@ -71,7 +71,9 @@ export class ProjectController {
       await this.projectService.addMember(project, request.member);
     } catch (err) {
       if (err.message === 'Project reached its maximum member capacity')
-        throw new ConflictException('Project reached its maximum member capacity');
+        throw new ConflictException(
+          'Project reached its maximum member capacity',
+        );
       throw err;
     }
     this.projectWebsocketGateway.notifyJoinToConnectedMembers(

backend/src/project/project.repository.ts

@@ -95,11 +95,11 @@ export class ProjectRepository {
   }
 
   getProjectToMember(
-    project: Project,
+    projectId: number,
     member: Member,
   ): Promise<ProjectToMember | null> {
     return this.projectToMemberRepository.findOne({
-      where: { project: { id: project.id }, member: { id: member.id } },
+      where: { project: { id: projectId }, member: { id: member.id } },
     });
   }
 

backend/src/project/service/project.service.spec.ts

@@ -85,18 +85,6 @@ describe('ProjectService', () => {
     });
   });
 
-  describe('Get project', () => {
-    const project = Project.of('title', 'subject');
-    const projectId = 1;
-    it('should return project', async () => {
-      jest.spyOn(projectRepository, 'getProject').mockResolvedValue(project);
-      const result = await projectService.getProject(projectId);
-
-      expect(projectRepository.getProject).toHaveBeenCalledWith(projectId);
-      expect(result).toEqual(project);
-    });
-  });
-
   describe('Add Member', () => {
     const project = Project.of('title', 'subject');
     project.inviteLinkId = 'inviteUuid';

backend/src/project/service/project.service.ts

@@ -32,7 +32,7 @@ export class ProjectService {
     title: string,
     subject: string,
   ): Promise<boolean> {
-    if (!(await this.isProjectLeader(project, member))) {
+    if (!(await this.isProjectLeader(project.id, member))) {
       throw new Error('Member is not the project leader');
     }
     return this.projectRepository.updateProjectInfo(project, title, subject);
@@ -42,12 +42,29 @@ export class ProjectService {
     return await this.projectRepository.getProjectList(member);
   }
 
-  async getProject(projectId: number): Promise<Project | null> {
-    return await this.projectRepository.getProject(projectId);
+  private getProjectWithInviteLink(projectId: number) {
+    return this.projectRepository.getProject(projectId);
+  }
+  private async getProjectWithOutInviteLink(projectId: number) {
+    const project = await this.projectRepository.getProject(projectId);
+    delete project.inviteLinkId;
+    return project;
+  }
+
+  async getProject(projectId: number, member: Member): Promise<Project | null> {
+    if (!(await this.isExistProject(projectId)))
+      throw new Error('Project not found');
+    if (!(await this.isProjectMember(projectId, member))) {
+      throw new Error('Not project member');
+    }
+    if (await this.isProjectLeader(projectId, member)) {
+      return this.getProjectWithInviteLink(projectId);
+    }
+    return this.getProjectWithOutInviteLink(projectId);
   }
 
   async addMember(project: Project, member: Member): Promise<void> {
-    const isProjectMember = await this.isProjectMember(project, member);
+    const isProjectMember = await this.isProjectMember(project.id, member);
     if (isProjectMember) throw new Error('already joined member');
 
     if ((await this.getProjectMemberList(project)).length >= 10)
@@ -64,16 +81,21 @@ export class ProjectService {
     return this.projectRepository.getProjectMemberList(project);
   }
 
-  async isProjectMember(project: Project, member: Member): Promise<boolean> {
+  async isExistProject(projectId: number): Promise<boolean> {
+    const project = await this.projectRepository.getProject(projectId);
+    return !!project;
+  }
+
+  async isProjectMember(projectId: number, member: Member): Promise<boolean> {
     const projectToMember: ProjectToMember | null =
-      await this.projectRepository.getProjectToMember(project, member);
+      await this.projectRepository.getProjectToMember(projectId, member);
     if (!projectToMember) return false;
     return true;
   }
 
-  async isProjectLeader(project: Project, member: Member): Promise<boolean> {
+  async isProjectLeader(projectId: number, member: Member): Promise<boolean> {
     const projectToMember = await this.projectRepository.getProjectToMember(
-      project,
+      projectId,
       member,
     );
     return projectToMember?.role === MemberRole.LEADER;

backend/src/project/websocket.gateway.ts

@@ -226,13 +226,10 @@ export class ProjectWebsocketGateway
       client.projectId = parseInt(projectId[1], 10);
       if (isNaN(client.projectId)) throw new Error('Project is not number');
     }
-    const project = await this.projectService.getProject(client.projectId);
-    if (!project) throw new Error('Project not found');
-    const isProjectMember = await this.projectService.isProjectMember(
-      project,
+    const project = await this.projectService.getProject(
+      client.projectId,
       client.member,
     );
-    if (!isProjectMember) throw new Error('Not project member');
     client.project = project;
   }
 }

backend/src/project/ws-controller/ws-project.controller.ts

@@ -14,7 +14,7 @@ export class WsProjectController {
   async joinLandingPage(client: ClientSocket) {
     const [project, projectMemberList, memoListWithMember, linkList] =
       await Promise.all([
-        this.projectService.getProject(client.projectId),
+        this.projectService.getProject(client.projectId, client.member),
         this.projectService.getProjectMemberList(client.project),
         this.projectService.getProjectMemoListWithMember(client.project.id),
         this.projectService.getProjectLinkList(client.project),
@@ -67,7 +67,7 @@ export class WsProjectController {
   async joinSettingPage(client: ClientSocket) {
     if (
       !(await this.projectService.isProjectLeader(
-        client.project,
+        client.project.id,
         client.member,
       ))
     ) {
@@ -80,7 +80,7 @@ export class WsProjectController {
     client.join('setting');
 
     const [project, projectMemberList] = await Promise.all([
-      this.projectService.getProject(client.projectId),
+      this.projectService.getProject(client.projectId, client.member),
       this.projectService.getProjectMemberList(client.project),
     ]);
 

backend/test/project/ws-landing-page/ws-project-landing-page.e2e-spec.ts

@@ -77,7 +77,6 @@ describe('WS landing', () => {
         expect(content.sprint).toBeDefined();
         expect(content.memoList).toBeDefined();
         expect(content.linkList).toBeDefined();
-        expect(content.inviteLinkId).toBeDefined();
 
         resolve();
       });

backend/test/project/ws-landing-page/ws-role.e2e-spec.ts

@@ -73,5 +73,54 @@ describe('WS role', () => {
         });
       });
     };
+
+    it('should return invite link when member is project leader', async () => {
+      let socket1;
+      let socket2;
+      return new Promise<void>(async (resolve, reject) => {
+        // 회원1 회원가입 + 프로젝트 생성
+        const accessToken = (await createMember(memberFixture, app))
+          .accessToken;
+        const project = await createProject(accessToken, projectPayload, app);
+        const projectLinkId = await getProjectLinkId(accessToken, project.id);
+
+        // 회원2 회원가입 + 프로젝트 참여
+        const accessToken2 = (await createMember(memberFixture2, app))
+          .accessToken;
+        await joinProject(accessToken2, projectLinkId);
+
+        socket1 = connectServer(project.id, accessToken);
+        handleConnectErrorWithReject(socket1, reject);
+        handleErrorWithReject(socket1, reject);
+        await emitJoinLanding(socket1);
+        await expectInviteLink(socket1, MemberRole.LEADER);
+
+        socket2 = connectServer(project.id, accessToken2);
+        handleConnectErrorWithReject(socket2, reject);
+        handleErrorWithReject(socket2, reject);
+        await emitJoinLanding(socket2);
+        await expectInviteLink(socket2, MemberRole.MEMBER);
+
+        resolve();
+      }).finally(() => {
+        socket1.close();
+        socket2.close();
+      });
+    });
+
+    const expectInviteLink = async (socket: Socket, role: string) => {
+      await new Promise<void>((resolve, reject) => {
+        socket.once('landing', async (data) => {
+          const { action, domain, content } = data;
+          if (action === 'init' && domain === 'landing') {
+            if (role === MemberRole.LEADER)
+              expect(content.inviteLinkId).toBeDefined();
+            else if (role === MemberRole.MEMBER)
+              expect(content.inviteLinkId).toBeUndefined();
+            resolve();
+          } else reject();
+        });
+      });
+    };
   });
 });