feat: 태스크 생성, 수정, 삭제 API 구현

backend/src/app.module.ts

@@ -31,6 +31,7 @@ import { Memo } from './project/entity/memo.entity';
 import { Link } from './project/entity/link.entity.';
 import { Epic } from './project/entity/epic.entity';
 import { Story } from './project/entity/story.entity';
+import { Task } from './project/entity/task.entity';
 
 @Module({
   imports: [
@@ -53,6 +54,7 @@ import { Story } from './project/entity/story.entity';
           Link,
           Epic,
           Story,
+		  Task
         ],
         synchronize: ConfigService.get('NODE_ENV') == 'PROD' ? false : true,
       }),

backend/src/project/dto/task/TaskCreateNotify.dto.ts

@@ -0,0 +1,37 @@
+import { Task, TaskStatus } from 'src/project/entity/task.entity';
+class TaskDto {
+  id: number;
+  displayId: number;
+  title: string;
+  expectedTime: number|null;
+  actualTime: number|null;
+  status: TaskStatus;
+  assignedMemberId: number|null;
+  storyId: number;
+  static of(task: Task) {
+    const dto = new TaskDto();
+    dto.id = task.id;
+	dto.displayId = task.displayId;
+    dto.title = task.title;
+    dto.expectedTime = task.expectedTime;
+    dto.actualTime = task.actualTime;
+    dto.status = task.status;
+    dto.assignedMemberId = task.assignedMemberId;
+    dto.storyId = task.storyId;
+    return dto;
+  }
+}
+
+export class TaskCreateNotifyDto {
+  domain: string;
+  action: string;
+  content: TaskDto;
+
+  static of(task: Task) {
+    const dto = new TaskCreateNotifyDto();
+    dto.domain = 'task';
+    dto.action = 'create';
+    dto.content = TaskDto.of(task);
+    return dto;
+  }
+}

backend/src/project/dto/task/TaskCreateRequest.dto.ts

@@ -0,0 +1,74 @@
+import { Type } from 'class-transformer';
+import {
+  IsEnum,
+  IsInt,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  Length,
+  Matches,
+  ValidateNested,
+} from 'class-validator';
+import { TaskStatus } from 'src/project/entity/task.entity';
+
+import {
+  registerDecorator,
+  ValidationOptions,
+  ValidationArguments,
+} from 'class-validator';
+
+export function IsOneDecimalPlace(validationOptions?: ValidationOptions) {
+  return function (object: Object, propertyName: string) {
+    registerDecorator({
+      name: 'IsOneDecimalPlace',
+      target: object.constructor,
+      propertyName: propertyName,
+      options: validationOptions,
+      validator: {
+        validate(value: any, args: ValidationArguments) {
+          const decimalPattern = /^\d+(\.\d{1})?$/;
+          return (
+            typeof value === 'number' && decimalPattern.test(value.toString())
+          );
+        },
+        defaultMessage(args: ValidationArguments) {
+          return `${args.property} must be a number with exactly one decimal place`;
+        },
+      },
+    });
+  };
+}
+
+class Task {
+  @IsString()
+  @Length(0, 100, { message: 'Title must be 100 characters or less' })
+  title: string;
+
+  @IsOptional()
+  @IsOneDecimalPlace()
+  expectedTime: number;
+
+  @IsOptional()
+  @IsOneDecimalPlace()
+  actualTime: number;
+
+  @IsEnum(TaskStatus)
+  status: TaskStatus;
+
+  @IsOptional()
+  @IsInt()
+  assignedMemberId: number;
+
+  @IsInt()
+  storyId: number;
+}
+
+export class TaskCreateRequestDto {
+  @Matches(/^create$/)
+  action: string;
+
+  @IsNotEmpty()
+  @ValidateNested()
+  @Type(() => Task)
+  content: Task;
+}

backend/src/project/dto/task/TaskDeleteNotify.dto.ts

@@ -0,0 +1,22 @@
+class Task {
+  id: number;
+  static of(id: number) {
+    const dto = new Task();
+    dto.id = id;
+    return dto;
+  }
+}
+
+export class TaskDeleteNotifyDto {
+  domain: string;
+  action: string;
+  content: Task;
+
+  static of(id: number) {
+    const dto = new TaskDeleteNotifyDto();
+    dto.domain = 'task';
+    dto.action = 'delete';
+    dto.content = Task.of(id);
+    return dto;
+  }
+}

backend/src/project/dto/task/TaskDeleteRequest.dto.ts

@@ -0,0 +1,17 @@
+import { Type } from 'class-transformer';
+import { IsInt, IsNotEmpty, Matches, ValidateNested } from 'class-validator';
+
+class Task {
+  @IsInt()
+  id: number;
+}
+
+export class TaskDeleteRequestDto {
+  @Matches(/^delete$/)
+  action: string;
+
+  @IsNotEmpty()
+  @ValidateNested()
+  @Type(() => Task)
+  content: Task;
+}

backend/src/project/dto/task/TaskUpdateNotify.dto.ts

@@ -0,0 +1,61 @@
+import { TaskStatus } from 'src/project/entity/task.entity';
+
+class Task {
+  id: number;
+  storyId?: number;
+  title?: string;
+  expectedTime?: number;
+  actualTime?: number;
+  status?: TaskStatus;
+  assignedMemberId?: number;
+
+  static of(
+    id: number,
+    storyId: number | undefined,
+    title: string | undefined,
+    expectedTime: number | undefined,
+    actualTime: number | undefined,
+    status: TaskStatus | undefined,
+    assignedMemberId: number | undefined,
+  ) {
+    const dto = new Task();
+    dto.id = id;
+    if (storyId) dto.storyId = storyId;
+    if (title) dto.title = title;
+    if (expectedTime) dto.expectedTime = expectedTime;
+    if (actualTime) dto.actualTime = actualTime;
+    if (status) dto.status = status;
+    if (assignedMemberId) dto.assignedMemberId = assignedMemberId;
+    return dto;
+  }
+}
+
+export class TaskUpdateNotifyDto {
+  domain: string;
+  action: string;
+  content: Task;
+
+  static of(
+    id: number,
+    storyId: number | undefined,
+    title: string | undefined,
+    expectedTime: number | undefined,
+    actualTime: number | undefined,
+    status: TaskStatus | undefined,
+    assignedMemberId: number | undefined,
+  ) {
+    const dto = new TaskUpdateNotifyDto();
+    dto.domain = 'task';
+    dto.action = 'update';
+    dto.content = Task.of(
+      id,
+      storyId,
+      title,
+      expectedTime,
+      actualTime,
+      status,
+      assignedMemberId,
+    );
+    return dto;
+  }
+}

backend/src/project/dto/task/TaskUpdateRequest.dto.ts

@@ -0,0 +1,51 @@
+import { Type } from 'class-transformer';
+import {
+  IsEnum,
+  IsInt,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  Matches,
+  ValidateNested,
+} from 'class-validator';
+import { TaskStatus } from 'src/project/entity/task.entity';
+import { IsOneDecimalPlace } from './TaskCreateRequest.dto';
+
+class Task {
+  @IsInt()
+  id: number;
+
+  @IsOptional()
+  @IsInt()
+  storyId?: number;
+
+  @IsOptional()
+  @IsString()
+  title?: string;
+
+  @IsOptional()
+  @IsOneDecimalPlace()
+  expectedTime?: number;
+
+  @IsOptional()
+  @IsOneDecimalPlace()
+  actualTime?: number;
+
+  @IsOptional()
+  @IsInt()
+  assignedMemberId?: number;
+
+  @IsOptional()
+  @IsEnum(TaskStatus)
+  status?: TaskStatus;
+}
+
+export class TaskUpdateRequestDto {
+  @Matches(/^update$/)
+  action: string;
+
+  @IsNotEmpty()
+  @ValidateNested()
+  @Type(() => Task)
+  content: Task;
+}

backend/src/project/entity/project.entity.ts

@@ -45,10 +45,14 @@ export class Project {
   @OneToMany(() => Link, (link) => link.id)
   linkList: Link[];
 
+  @Column({type: 'int', nullable: false})
+  displayIdCount: number;
+
   static of(title: string, subject: string) {
     const newProject = new Project();
     newProject.title = title;
     newProject.subject = subject;
+	newProject.displayIdCount = 0;
     return newProject;
   }
 }

backend/src/project/entity/task.entity.ts

@@ -0,0 +1,81 @@
+import { Member } from 'src/member/entity/member.entity';
+import {
+  Column,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+} from 'typeorm';
+import { Project } from './project.entity';
+import { Story } from './story.entity';
+
+export enum TaskStatus {
+  NotStarted = '시작전',
+  InProgress = '진행중',
+  Completed = '완료',
+}
+
+@Entity()
+export class Task {
+  @PrimaryGeneratedColumn('increment', { type: 'int' })
+  id: number;
+
+  @Column({ type: 'int', name: 'project_id', nullable: false })
+  projectId: number;
+
+  @ManyToOne(() => Project, (project) => project.id, { nullable: false })
+  @JoinColumn({ name: 'project_id' })
+  project: Project;
+
+  @Column({ type: 'int', name: 'story_id', nullable: false })
+  storyId: number;
+
+  @ManyToOne(() => Story, (story) => story.id, { nullable: false })
+  @JoinColumn({ name: 'story_id' })
+  story: Story;
+
+  @Column({ type: 'varchar', length: 99, nullable: false })
+  title: string;
+
+  @Column({ type: 'int', nullable: false })
+  displayId: number;
+
+  @Column({ type: 'double', nullable: true })
+  expectedTime: number;
+
+  @Column({ type: 'double', nullable: true })
+  actualTime: number;
+
+  @Column({ type: 'varchar', length: 255, nullable: false })
+  status: TaskStatus;
+
+  @Column({ type: 'int', name: 'member_id', nullable: true })
+  assignedMemberId: number;
+
+  @ManyToOne(() => Member, (member) => member.id, { nullable: true })
+  @JoinColumn({ name: 'member_id' })
+  member: Member;
+
+  static of(
+    project: Project,
+    storyId: number,
+    title: string,
+    displayId: number,
+    expectedTime: number,
+    actualTime: number,
+    memberId: number,
+    status: TaskStatus,
+  ) {
+    const newTask = new Task();
+    newTask.project = project;
+    newTask.storyId = storyId;
+    newTask.title = title;
+    newTask.displayId = displayId;
+
+    newTask.expectedTime = expectedTime;
+    newTask.actualTime = actualTime;
+    newTask.assignedMemberId = memberId;
+    newTask.status = status;
+    return newTask;
+  }
+}