Merge branch 'develop' into feature-be-#279

Author: summersummerwhy

apps/backend/src/workspace/workspace.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { UserRepository } from '../user/user.repository';
 import { WorkspaceRepository } from './workspace.repository';
 import { RoleRepository } from '../role/role.repository';
@@ -11,14 +11,33 @@ import { NotWorkspaceOwnerException } from '../exception/workspace-auth.exceptio
 import { TokenService } from '../auth/token/token.service';
 import { ForbiddenAccessException } from '../exception/access.exception';
 
+enum MainWorkspace {
+  OWNER_SNOWFLAKEID = 'admin',
+  OWNER_PROVIDER_ID = 'adminProviderId',
+  OWNER_PROVIDER = 'adminProvider',
+  OWNER_EMAIL = '[email protected]',
+  WORKSPACE_SNOWFLAKEID = 'main',
+  WORKSPACE_TITLE = 'main workspace',
+  WORKSPACE_DESCRIPTION = '모든 유저가 접근 가능한 메인 workspace',
+  WORKSPACE_VISIBILITY = 'public',
+}
+
 @Injectable()
 export class WorkspaceService {
+  private readonly logger = new Logger(WorkspaceService.name); // 클래스 이름을 context로 설정
+
   constructor(
     private readonly workspaceRepository: WorkspaceRepository,
     private readonly userRepository: UserRepository,
     private readonly roleRepository: RoleRepository,
     private readonly tokenService: TokenService,
-  ) {}
+  ) {
+    console.log('환경 : ', process.env.NODE_ENV);
+    if (process.env.NODE_ENV !== 'test') {
+      this.initializeMainWorkspace();
+    }
+  }
+
 
   async createWorkspace(
     userId: number,
@@ -186,4 +205,62 @@ export class WorkspaceService {
     // 권한이 없으면 예외 발생
     throw new ForbiddenAccessException();
   }
+  
+  // 가장 처음에 모두가 접속할 수 있는 main workspace를 생성한다.
+  async initializeMainWorkspace() {
+    let findOwner = await this.userRepository.findOneBy({
+      snowflakeId: MainWorkspace.OWNER_SNOWFLAKEID,
+    });
+
+    // 존재하지 않을 때만 생성한다.
+    if (!findOwner) {
+      // main workspace owner를 생성한다.
+      const owner = await this.userRepository.save({
+        snowflakeId: MainWorkspace.OWNER_SNOWFLAKEID,
+        providerId: MainWorkspace.OWNER_PROVIDER_ID,
+        provider: MainWorkspace.OWNER_PROVIDER,
+        email: MainWorkspace.OWNER_EMAIL,
+      });
+
+      findOwner = owner;
+    }
+    this.logger.log('main workspace owner가 존재합니다.');
+
+    // main workspace를 찾는다.
+    let findWorkspace = await this.workspaceRepository.findOneBy({
+      snowflakeId: MainWorkspace.WORKSPACE_SNOWFLAKEID,
+    });
+
+    // owner는 존재하지만 워크스페이스가 없으면 생성한다.
+    if (!findWorkspace) {
+      findWorkspace = await this.workspaceRepository.save({
+        snowflakeId: MainWorkspace.WORKSPACE_SNOWFLAKEID,
+        owner: findOwner,
+        title: MainWorkspace.WORKSPACE_TITLE,
+        description: MainWorkspace.WORKSPACE_DESCRIPTION,
+        visibility: MainWorkspace.WORKSPACE_VISIBILITY,
+      });
+      this.logger.log('main workspace를 생성했습니다.');
+    }
+    this.logger.log('main workspace가 존재합니다.');
+
+    // owner의 role을 찾는다.
+    const role = await this.roleRepository.findOne({
+      where: {
+        workspaceId: findWorkspace.id,
+        userId: findOwner.id,
+      },
+    });
+
+    // owner의 role이 없으면 생성한다.
+    if (!role) {
+      await this.roleRepository.save({
+        workspaceId: findWorkspace.id,
+        userId: findOwner.id,
+        workspace: findWorkspace,
+        user: findOwner,
+        role: 'owner',
+      });
+    }
+  }
 }

apps/backend/src/yjs/yjs.service.ts

@@ -44,7 +44,9 @@ export class YjsService
     private readonly pageService: PageService,
     private readonly edgeService: EdgeService,
     private readonly redisService: RedisService,
-  ) {}
+  ) {
+    
+  }
 
   @WebSocketServer()
   server: Server;
@@ -153,6 +155,9 @@ export class YjsService
         for (const [key, change] of event.changes.keys) {
           if (change.action === 'update') {
             const node: any = nodesMap.get(key);
+            if (node.type !== 'note') {
+              continue;
+            }
             const { title, id } = node.data; // TODO: 이모지 추가
             const { x, y } = node.position;
             const isHolding = node.isHolding;

apps/frontend/src/features/canvas/model/calculateHandles.ts

@@ -1,34 +1,61 @@
-import { Position, Node } from "@xyflow/react";
+import { Position, Node, XYPosition } from "@xyflow/react";
 
-export const getHandlePosition = (node: Node, handleId: Position) => {
+const getAbsolutePosition = (node: Node, nodes: Node[]): XYPosition => {
+  if (!node.parentId) {
+    return node.position;
+  }
+
+  const parentNode = nodes.find((n) => n.id === node.parentId);
+  if (!parentNode) {
+    return node.position;
+  }
+
+  const parentPosition: XYPosition = getAbsolutePosition(parentNode, nodes);
+  return {
+    x: parentPosition.x + node.position.x,
+    y: parentPosition.y + node.position.y,
+  };
+};
+
+export const getHandlePosition = (
+  node: Node,
+  handleId: Position,
+  nodes: Node[],
+) => {
   const nodeElement = document.querySelector(`[data-id="${node.id}"]`);
   const nodeRect = nodeElement!.getBoundingClientRect();
   const nodeWidth = nodeRect.width;
   const nodeHeight = nodeRect.height;
 
+  const absolutePosition = getAbsolutePosition(node, nodes);
+
   const positions = {
     [Position.Left]: {
-      x: node.position.x,
-      y: node.position.y + nodeHeight / 2,
+      x: absolutePosition.x,
+      y: absolutePosition.y + nodeHeight / 2,
     },
     [Position.Right]: {
-      x: node.position.x + nodeWidth,
-      y: node.position.y + nodeHeight / 2,
+      x: absolutePosition.x + nodeWidth,
+      y: absolutePosition.y + nodeHeight / 2,
     },
     [Position.Top]: {
-      x: node.position.x + nodeWidth / 2,
-      y: node.position.y,
+      x: absolutePosition.x + nodeWidth / 2,
+      y: absolutePosition.y,
     },
     [Position.Bottom]: {
-      x: node.position.x + nodeWidth / 2,
-      y: node.position.y + nodeHeight,
+      x: absolutePosition.x + nodeWidth / 2,
+      y: absolutePosition.y + nodeHeight,
     },
   };
 
   return positions[handleId];
 };
 
-export const calculateBestHandles = (sourceNode: Node, targetNode: Node) => {
+export const calculateBestHandles = (
+  sourceNode: Node,
+  targetNode: Node,
+  nodes: Node[],
+) => {
   const handlePositions = [
     Position.Left,
     Position.Right,
@@ -42,9 +69,9 @@ export const calculateBestHandles = (sourceNode: Node, targetNode: Node) => {
   };
 
   handlePositions.forEach((sourceHandle) => {
-    const sourcePosition = getHandlePosition(sourceNode, sourceHandle);
+    const sourcePosition = getHandlePosition(sourceNode, sourceHandle, nodes);
     handlePositions.forEach((targetHandle) => {
-      const targetPosition = getHandlePosition(targetNode, targetHandle);
+      const targetPosition = getHandlePosition(targetNode, targetHandle, nodes);
       const distance = Math.hypot(
         sourcePosition.x - targetPosition.x,
         sourcePosition.y - targetPosition.y,

apps/frontend/src/features/canvas/model/getPosition.ts

@@ -0,0 +1,11 @@
+import { type Node } from "@xyflow/react";
+
+export const getRelativePosition = (node: Node, parentNode: Node) => ({
+  x: node.position.x - parentNode.position.x,
+  y: node.position.y - parentNode.position.y,
+});
+
+export const getAbsolutePosition = (node: Node, parentNode: Node) => ({
+  x: parentNode.position.x + node.position.x,
+  y: parentNode.position.y + node.position.y,
+});