diff --git a/.github/workflows/gradle.yml b/.github/workflows/gradle.yml index a6aafe8..4c56141 100644 --- a/.github/workflows/gradle.yml +++ b/.github/workflows/gradle.yml @@ -47,7 +47,7 @@ jobs: run: docker login -u ${{secrets.DOCKER_USERNAME}} -p ${{secrets.DOCKER_PASSWORD}} - name: Make docker image - run: docker build -f DockerFile -t ${{secrets.DOCKER_USERNAME}}/prdoit:latest . + run: docker build --no-cache -f DockerFile -t ${{secrets.DOCKER_USERNAME}}/prdoit:latest . - name: Push docker image run: docker push ${{secrets.DOCKER_USERNAME}}/prdoit:latest diff --git a/.gitignore b/.gitignore index fa63701..011d3b1 100644 --- a/.gitignore +++ b/.gitignore @@ -37,4 +37,6 @@ out/ .vscode/ ### Application Files ### -application.properties \ No newline at end of file +application.properties + +.DS_Store \ No newline at end of file diff --git a/src/main/java/com/example/prdoit/config/BacklogEnum.java b/src/main/java/com/example/prdoit/config/BacklogEnum.java index a400aa5..390d0aa 100644 --- a/src/main/java/com/example/prdoit/config/BacklogEnum.java +++ b/src/main/java/com/example/prdoit/config/BacklogEnum.java @@ -5,6 +5,7 @@ @Getter public enum BacklogEnum { + BACKLOG_NOT_YET(0, "Not Yet"), BACKLOG_TODO(1, "To Do"), BACKLOG_IN_PROGRESS(2, "In Progress"), BACKLOG_DONE(3, "Done"); @@ -12,10 +13,10 @@ public enum BacklogEnum { private final int code; private final String description; - public static BacklogEnum getBacklogEnum(int code){ + public static String getBacklogEnum(int code){ for(BacklogEnum backlogEnum : values()){ if(backlogEnum.code == code){ - return backlogEnum; + return backlogEnum.getDescription(); } } return null; diff --git a/src/main/java/com/example/prdoit/config/WebConfig.java b/src/main/java/com/example/prdoit/config/WebConfig.java new file mode 100644 index 0000000..24be647 --- /dev/null +++ b/src/main/java/com/example/prdoit/config/WebConfig.java @@ -0,0 +1,18 @@ +package com.example.prdoit.config; + +import org.springframework.context.annotation.Configuration; +import org.springframework.web.servlet.config.annotation.CorsRegistry; +import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; + +import java.nio.file.Watchable; + +@Configuration +public class WebConfig implements WebMvcConfigurer { + + @Override + public void addCorsMappings(CorsRegistry registry) { + registry.addMapping("/**") + .allowedOrigins("http://prdoit-s3-bucket.s3-website.ap-northeast-2.amazonaws.com") + .allowedMethods("GET", "POST", "PUT", "DELETE"); + } +} diff --git a/src/main/java/com/example/prdoit/controller/CommunityController.java b/src/main/java/com/example/prdoit/controller/CommunityController.java new file mode 100644 index 0000000..40433b0 --- /dev/null +++ b/src/main/java/com/example/prdoit/controller/CommunityController.java @@ -0,0 +1,98 @@ +package com.example.prdoit.controller; + +import com.example.prdoit.dto.community.CommunityPatchDto; +import com.example.prdoit.dto.community.CommunityRequestDto; +import com.example.prdoit.exception.CustomException; +import com.example.prdoit.service.community.CommunityService; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +@RestController +@Slf4j +@RequiredArgsConstructor +@CrossOrigin(origins = "*", allowedHeaders = "*") +@RequestMapping("/community") +public class CommunityController { + + private final CommunityService communityService; + + @PostMapping() + public ResponseEntity postCommunity(@RequestBody CommunityRequestDto communityRequestDto) { + log.info("[CommunityController] 글 작성 시작"); + try{ + communityService.postCommunity(communityRequestDto); + return ResponseEntity.ok("글 작성에 성공했습니다."); + } catch (CustomException e) { + log.error(e.getMessage()); + return ResponseEntity.badRequest().body(e.getMessage()); + } catch (RuntimeException e) { + log.error(e.getMessage()); + return ResponseEntity.internalServerError().body("글 작성에 실패했습니다."); + } + } + + @GetMapping() + public ResponseEntity getCommunity(@RequestParam(value = "query", required = false, defaultValue = "all") String query, + @RequestParam(value = "tag", required = false, defaultValue = "") String tag, + @RequestParam(value = "userId", required = false, defaultValue = "") String userId, + @RequestParam(value = "size", required = false, defaultValue = "10") int size, + @RequestParam(value = "page", required = false, defaultValue = "1") int page) { + log.info("[CommunityController] 글 목록 조회 시작"); + try{ + return ResponseEntity.ok(communityService.getCommunityList(query, tag, userId, size, page)); + } catch (CustomException e) { + log.error(e.getMessage()); + return ResponseEntity.badRequest().body(e.getMessage()); + } catch (RuntimeException e) { + log.error(e.getMessage()); + return ResponseEntity.internalServerError().body("글 목록 조회에 실패했습니다."); + } + } + + @PatchMapping() + public ResponseEntity patchCommunity(@RequestBody CommunityPatchDto communityPatchDto) { + log.info("[CommunityController] 글 수정 시작"); + try{ + communityService.patchCommunity(communityPatchDto); + return ResponseEntity.ok("글 수정에 성공했습니다."); + } catch (CustomException e) { + log.error(e.getMessage()); + return ResponseEntity.badRequest().body(e.getMessage()); + } catch (RuntimeException e) { + log.error(e.getMessage()); + return ResponseEntity.internalServerError().body("글 수정에 실패했습니다."); + } + } + + @DeleteMapping("/{communityId}") + public ResponseEntity deleteCommunity(@PathVariable String communityId) { + log.info("[CommunityController] 글 삭제 시작"); + try{ + communityService.deleteCommunity(communityId); + return ResponseEntity.ok("글 삭제에 성공했습니다."); + } catch (CustomException e) { + log.error(e.getMessage()); + return ResponseEntity.badRequest().body(e.getMessage()); + } catch (RuntimeException e) { + log.error(e.getMessage()); + return ResponseEntity.internalServerError().body("글 삭제에 실패했습니다."); + } + } + + @GetMapping("/{communityId}") + public ResponseEntity getCommunityDetail(@PathVariable String communityId) { + log.info("[CommunityController] 글 상세 조회 시작"); + try{ + return ResponseEntity.ok(communityService.getCommunityDetail(communityId)); + } catch (CustomException e) { + log.error(e.getMessage()); + return ResponseEntity.badRequest().body(e.getMessage()); + } catch (RuntimeException e) { + log.error(e.getMessage()); + return ResponseEntity.internalServerError().body("글 상세 조회에 실패했습니다."); + } + } + +} diff --git a/src/main/java/com/example/prdoit/controller/ContentController.java b/src/main/java/com/example/prdoit/controller/ContentController.java new file mode 100644 index 0000000..140fa45 --- /dev/null +++ b/src/main/java/com/example/prdoit/controller/ContentController.java @@ -0,0 +1,100 @@ +package com.example.prdoit.controller; + +import com.example.prdoit.dto.content.ContentRequestDto; +import com.example.prdoit.dto.content.ContentUpdateDto; +import com.example.prdoit.exception.CustomException; +import com.example.prdoit.service.content.ContentService; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +@RestController +@Slf4j +@CrossOrigin(origins = "*", allowedHeaders = "*") +@RequestMapping("/content") +@RequiredArgsConstructor +public class ContentController { + + private final ContentService contentService; + + @GetMapping() + public ResponseEntity getAllContent(@RequestParam(value = "query", required = false, defaultValue = "all") String query, + @RequestParam(value = "level", required = false, defaultValue = "-1") int level, + @RequestParam(value = "userId", required = false, defaultValue = "") String userId, + @RequestParam(value = "size", required = false, defaultValue = "5") int size, + @RequestParam(value = "page", required = false, defaultValue = "1") int page) { + try{ + if(level == -1 && userId.isEmpty()){ + return ResponseEntity.ok(contentService.getContentQuery(query, size, page)); + } else if(userId.isEmpty()){ + return ResponseEntity.ok(contentService.getContentQueryWithLevel(query, level, size, page)); + } else { + return ResponseEntity.ok(contentService.getContentWithUserId(userId, query, level, size, page)); + } + } catch (CustomException e) { + log.error("[getAllContent] 컨텐츠 조회 실패", e); + return ResponseEntity.badRequest().body(e.getMessage()); + } catch (Exception e) { + log.error("[getAllContent] 컨텐츠 조회 실패", e); + return ResponseEntity.internalServerError().body("컨텐츠 조회에 실패했습니다."); + } + } + + @PostMapping() + public ResponseEntity postContent(@RequestBody ContentRequestDto contentRequestDto) { + try { + contentService.postContent(contentRequestDto); + return ResponseEntity.ok("컨텐츠 등록에 성공했습니다."); + } catch (CustomException e) { + log.error("[postContent] 컨텐츠 등록 실패", e); + return ResponseEntity.badRequest().body(e.getMessage()); + } catch (Exception e) { + log.error("[postContent] 컨텐츠 등록 실패", e); + return ResponseEntity.internalServerError().body("컨텐츠 등록에 실패했습니다."); + } + } + + @PatchMapping() + public ResponseEntity updateContent(@RequestBody ContentUpdateDto contentUpdateDto) { + try { + contentService.updateContent(contentUpdateDto); + return ResponseEntity.ok("컨텐츠 수정에 성공했습니다."); + } catch (CustomException e) { + log.error("[updateContent] 컨텐츠 수정 실패", e); + return ResponseEntity.badRequest().body(e.getMessage()); + } catch (Exception e) { + log.error("[updateContent] 컨텐츠 수정 실패", e); + return ResponseEntity.internalServerError().body("컨텐츠 수정에 실패했습니다."); + } + } + + @GetMapping("/{contentId}") + public ResponseEntity getContentDetail(@PathVariable String contentId) { + try { + return ResponseEntity.ok(contentService.getContentDetail(contentId)); + } catch (CustomException e) { + log.error("[getContentDetail] 컨텐츠 상세 조회 실패", e); + return ResponseEntity.badRequest().body(e.getMessage()); + } catch (Exception e) { + log.error("[getContentDetail] 컨텐츠 상세 조회 실패", e); + return ResponseEntity.internalServerError().body("컨텐츠 상세 조회에 실패했습니다."); + } + } + + @GetMapping("/total/{userId}") + public ResponseEntity getTotalContent(@PathVariable String userId, + @RequestParam(value = "size", required = false, defaultValue = "5") int size, + @RequestParam(value = "page", required = false, defaultValue = "1") int page) { + try { + return ResponseEntity.ok(contentService.getTotalContent(userId, size, page)); + } catch (CustomException e) { + log.error("[getTotalContent] 총 컨텐츠 조회 실패", e); + return ResponseEntity.badRequest().body(e.getMessage()); + } catch (Exception e) { + log.error("[getTotalContent] 총 컨텐츠 조회 실패", e); + return ResponseEntity.internalServerError().body("총 컨텐츠 조회에 실패했습니다."); + } + } + +} diff --git a/src/main/java/com/example/prdoit/controller/ProjectController.java b/src/main/java/com/example/prdoit/controller/ProjectController.java index 1e55edd..a5e4bfe 100644 --- a/src/main/java/com/example/prdoit/controller/ProjectController.java +++ b/src/main/java/com/example/prdoit/controller/ProjectController.java @@ -1,20 +1,24 @@ package com.example.prdoit.controller; import com.example.prdoit.dto.project.*; -import com.example.prdoit.dto.project.backlog.BacklogDeleteDto; import com.example.prdoit.dto.project.backlog.BacklogPutDto; -import com.example.prdoit.dto.project.backlog.BacklogRequestDto; -import com.example.prdoit.dto.project.backlog.BacklogUpdateDto; -import com.example.prdoit.dto.project.content.ProjectContentDeleteDto; -import com.example.prdoit.dto.project.content.ProjectContentDto; +import com.example.prdoit.dto.project.burndown.BurndownPatchDto; +import com.example.prdoit.dto.project.burndown.BurndownPostDto; +import com.example.prdoit.dto.project.content.ContentDeleteDto; +import com.example.prdoit.dto.project.content.ContentDto; +import com.example.prdoit.dto.project.content.ContentPatchDto; import com.example.prdoit.service.project.ProjectService; +import io.swagger.v3.oas.annotations.tags.Tag; import jakarta.transaction.Transactional; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; +import org.springframework.context.annotation.Description; import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.*; +import java.util.List; + @Controller @Transactional @CrossOrigin(origins = "*", allowedHeaders = "*") @@ -22,11 +26,12 @@ @RequiredArgsConstructor @RequestMapping("/project") @Slf4j +@Tag(name = "Project", description = "프로젝트 API") public class ProjectController { private final ProjectService projectService; - @PostMapping("/management/store") + @PostMapping("/store") public ResponseEntity createProject(@RequestBody ProjectCreateDto projectCreateDto) { log.info("[createProject] 프로젝트 생성 요청"); try{ @@ -37,7 +42,7 @@ public ResponseEntity createProject(@RequestBody ProjectCreateDto projec } } - @GetMapping("/project/{projectId}") + @GetMapping("/{projectId}") public ResponseEntity getProject(@PathVariable String projectId) { log.info("[getProject] 프로젝트 조회 요청"); try{ @@ -48,11 +53,11 @@ public ResponseEntity getProject(@PathVariable String projectId) { } } - @GetMapping("/content/{projectId}/{level}") - public ResponseEntity getProjectContent(@PathVariable String projectId, @PathVariable int level) { + @GetMapping("/content/{projectId}/") + public ResponseEntity getProjectContent(@PathVariable String projectId) { log.info("[getProjectContent] 프로젝트 컨텐츠 조회 요청"); try{ - return ResponseEntity.ok(projectService.getProjectContent(projectId, level)); + return ResponseEntity.ok(projectService.getProjectContent(projectId)); } catch (RuntimeException e){ log.error("[getProjectContent] 프로젝트 컨텐츠 조회 실패"); return ResponseEntity.badRequest().body("프로젝트 컨텐츠 조회에 실패했습니다."); @@ -65,16 +70,16 @@ public ResponseEntity getProjectList(@PathVariable String userId) { try{ return ResponseEntity.ok(projectService.getProjectList(userId)); } catch (RuntimeException e){ - log.error("[getProjectList] 프로젝트 리스트 조회 실패"); + log.error(e.getMessage()); return ResponseEntity.badRequest().body("프로젝트 리스트 조회에 실패했습니다."); } } @PostMapping("/content") - public ResponseEntity createProjectContent(@RequestBody ProjectContentDto projectContentDto) { + public ResponseEntity createProjectContent(@RequestBody ContentDto contentDto) { log.info("[createProjectContent] 프로젝트 컨텐츠 생성 요청"); try{ - projectService.createProjectContent(projectContentDto); + projectService.createProjectContent(contentDto); return ResponseEntity.ok("프로젝트 컨텐츠 생성에 성공했습니다."); } catch (RuntimeException e){ log.error("[createProjectContent] {}", e.getMessage()); @@ -83,10 +88,10 @@ public ResponseEntity createProjectContent(@RequestBody ProjectContentDt } @PatchMapping("/content") - public ResponseEntity updateProjectContent(@RequestBody ProjectContentDto projectContentDto) { + public ResponseEntity updateProjectContent(@RequestBody ContentPatchDto contentDto) { log.info("[updateProjectContent] 프로젝트 컨텐츠 수정 요청"); try{ - projectService.updateProjectContent(projectContentDto); + projectService.patchProjectContent(contentDto); return ResponseEntity.ok("프로젝트 컨텐츠 수정에 성공했습니다."); } catch (RuntimeException e){ log.error("[updateProjectContent] {}", e.getMessage()); @@ -95,10 +100,11 @@ public ResponseEntity updateProjectContent(@RequestBody ProjectContentDt } @DeleteMapping("/content") - public ResponseEntity deleteProjectContent(@RequestBody ProjectContentDeleteDto projectContentDeleteDto) { + @Description("프로젝트 컨텐츠 삭제 API, backlog 삭제시 projectLevel=0으로") + public ResponseEntity deleteProjectContent(@RequestBody ContentDeleteDto contentDeleteDto) { log.info("[deleteProjectContent] 프로젝트 컨텐츠 삭제 요청"); try{ - projectService.deleteProjectContent(projectContentDeleteDto); + projectService.deleteProjectContent(contentDeleteDto); return ResponseEntity.ok("프로젝트 컨텐츠 삭제에 성공했습니다."); } catch (RuntimeException e){ log.error("[deleteProjectContent] {}", e.getMessage()); @@ -106,42 +112,18 @@ public ResponseEntity deleteProjectContent(@RequestBody ProjectContentDe } } - @PostMapping("/product") - public ResponseEntity createBacklog(@RequestBody BacklogRequestDto backLogRequestDto) { - log.info("[createBacklog] 백로그 생성 요청"); + @GetMapping("/burndown/{projectId}/{taskId}") + public ResponseEntity getBurndownList(@PathVariable String projectId, @PathVariable String taskId) { + log.info("[getBurndownList] 번다운 리스트 조회 요청"); try{ - projectService.createBacklog(backLogRequestDto); - return ResponseEntity.ok("백로그 생성에 성공했습니다."); + return ResponseEntity.ok(projectService.getBacklog(projectId, taskId)); } catch (RuntimeException e){ - log.error(e.getMessage()); - return ResponseEntity.badRequest().body("백로그 생성에 실패했습니다."); - } - } - - @PatchMapping("/product") - public ResponseEntity updateBacklog(@RequestBody BacklogUpdateDto backLogUpdateDto) { - log.info("[updateBacklog] 백로그 수정 요청"); - try{ - projectService.updateBacklog(backLogUpdateDto); - return ResponseEntity.ok("백로그 수정에 성공했습니다."); - } catch (RuntimeException e){ - log.error("[updateBacklog] {}", e.getMessage()); - return ResponseEntity.badRequest().body("백로그 수정에 실패했습니다."); - } - } - - @DeleteMapping("/product") - public ResponseEntity deleteBacklog(@RequestBody BacklogDeleteDto backlogDeleteDto) { - log.info("[deleteBacklog] 백로그 삭제 요청"); - try{ - projectService.deleteBacklog(backlogDeleteDto); - return ResponseEntity.ok("백로그 삭제에 성공했습니다."); - } catch (RuntimeException e){ - log.error("[deleteBacklog] {}", e.getMessage()); - return ResponseEntity.badRequest().body("백로그 삭제에 실패했습니다."); + log.error("[getBurndownList] {}", e.getMessage()); + return ResponseEntity.badRequest().body("번다운 리스트 조회에 실패했습니다."); } } +/* @PutMapping("/product") public ResponseEntity putBacklog(@RequestBody BacklogPutDto backlogPutDto) { log.info("[putBacklog] 백로그 이동 요청"); @@ -154,14 +136,5 @@ public ResponseEntity putBacklog(@RequestBody BacklogPutDto backlogPutDt } } - @GetMapping("/product/{projectId}") - public ResponseEntity getBacklogList(@PathVariable String projectId) { - log.info("[getBacklogList] 백로그 리스트 조회 요청"); - try{ - return ResponseEntity.ok(projectService.getBacklogList(projectId)); - } catch (RuntimeException e){ - log.error("[getBacklogList] 백로그 리스트 조회 실패"); - return ResponseEntity.badRequest().body("백로그 리스트 조회에 실패했습니다."); - } - } + */ } diff --git a/src/main/java/com/example/prdoit/controller/UserController.java b/src/main/java/com/example/prdoit/controller/UserController.java index 660613d..6f56d19 100644 --- a/src/main/java/com/example/prdoit/controller/UserController.java +++ b/src/main/java/com/example/prdoit/controller/UserController.java @@ -1,5 +1,6 @@ package com.example.prdoit.controller; +import com.example.prdoit.dto.user.ChangePasswordDto; import com.example.prdoit.dto.user.LoginDto; import com.example.prdoit.dto.user.UserDto; import com.example.prdoit.exception.CustomException; @@ -7,6 +8,7 @@ import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.http.ResponseEntity; +import org.springframework.security.core.parameters.P; import org.springframework.web.bind.annotation.*; @@ -75,18 +77,68 @@ public ResponseEntity checkNickname(@PathVariable String userNickname){ return ResponseEntity.badRequest().body(e.getMessage()); } } -/* + @PostMapping("/login") - public ResponseEntity login(@RequestBody LoginDto loginDto){ - log.info("[login] 로그인 로직 시작"); + public ResponseEntity login(@RequestBody LoginDto loginDto) { + log.info("[login] 로그인 시도 - ID: {}", loginDto.getUserId()); + + try { + userService.login(loginDto.getUserId(), loginDto.getPassword()); + return ResponseEntity.ok("로그인 성공"); + } catch (CustomException e) { + log.error("[login] 로그인 실패 - 이유: {}", e.getMessage()); + return ResponseEntity.badRequest().body(e.getMessage()); + } + } + + @GetMapping("/findId/{email}") + public ResponseEntity findId(@PathVariable String email){ + log.info("[findId] 아이디 찾기 시작"); + + try{ + return ResponseEntity.ok(userService.findId(email)); + } catch (CustomException e) { + log.error("[findId] 아이디 찾기 실패 - 이유: {}", e.getMessage()); + return ResponseEntity.badRequest().body(e.getMessage()); + } + } + + @GetMapping("/confirm/{userId}/{email}") + public ResponseEntity checkIdAndEmail(@PathVariable String userId, @PathVariable String email){ + log.info("[checkIdAndEmail] 아이디와 이메일 확인 시작"); try{ - userService.signIn(loginDto.getUserId(), loginDto.getPassword()); - return ResponseEntity.ok().body("로그인 성공"); + userService.checkIdAndEmail(userId, email); + return ResponseEntity.ok("아이디와 이메일이 일치합니다."); } catch (CustomException e) { - log.error("[login] 로그인 실패"); + log.error("[checkIdAndEmail] 아이디와 이메일 확인 실패 - 이유: {}", e.getMessage()); return ResponseEntity.badRequest().body(e.getMessage()); } } - */ + + @PatchMapping("/changePassword") + public ResponseEntity changePassword(@RequestBody ChangePasswordDto changePasswordDto){ + log.info("[changePassword] 비밀번호 변경 시작"); + try { + userService.changePassword(changePasswordDto.getUserId(), changePasswordDto.getNewPassword()); + return ResponseEntity.ok("비밀번호 변경에 성공했습니다."); + } catch (CustomException e) { + log.error("[changePassword] 비밀번호 변경 실패 - 이유: {}", e.getMessage()); + return ResponseEntity.badRequest().body(e.getMessage()); + } + } + + @PostMapping("/auth/password") + public ResponseEntity checkPassword(@RequestBody LoginDto loginDto) { + log.info("[checkPassword] 비밀번호 확인 시작"); + + try { + userService.checkPassword(loginDto.getUserId(), loginDto.getPassword()); + return ResponseEntity.ok("비밀번호가 일치합니다."); + } catch (CustomException e) { + log.error("[checkPassword] 비밀번호 불일치 - 이유: {}", e.getMessage()); + return ResponseEntity.badRequest().body(e.getMessage()); + } + } + } diff --git a/src/main/java/com/example/prdoit/controller/testController.java b/src/main/java/com/example/prdoit/controller/testController.java index 43e899e..3433da2 100644 --- a/src/main/java/com/example/prdoit/controller/testController.java +++ b/src/main/java/com/example/prdoit/controller/testController.java @@ -4,7 +4,7 @@ import org.springframework.web.bind.annotation.CrossOrigin; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; - +//// @RestController @Slf4j diff --git a/src/main/java/com/example/prdoit/dto/community/CommunityDetailResponseDto.java b/src/main/java/com/example/prdoit/dto/community/CommunityDetailResponseDto.java new file mode 100644 index 0000000..30e50f4 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/community/CommunityDetailResponseDto.java @@ -0,0 +1,25 @@ +package com.example.prdoit.dto.community; + +import com.example.prdoit.model.CommentTable; +import lombok.*; + +import java.time.LocalDateTime; +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class CommunityDetailResponseDto { + + private String communityId; + private String communityTitle; + private String communityContent; + private int communityView; + private String userNickname; + private LocalDateTime communityDate; + private List communityTagList; + private List commentList; + +} diff --git a/src/main/java/com/example/prdoit/dto/community/CommunityPatchDto.java b/src/main/java/com/example/prdoit/dto/community/CommunityPatchDto.java new file mode 100644 index 0000000..d4af342 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/community/CommunityPatchDto.java @@ -0,0 +1,19 @@ +package com.example.prdoit.dto.community; + +import lombok.*; + +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class CommunityPatchDto { + + private String communityId; + private String communityTitle; + private String communityContent; + private List communityTagList; + +} diff --git a/src/main/java/com/example/prdoit/dto/community/CommunityRequestDto.java b/src/main/java/com/example/prdoit/dto/community/CommunityRequestDto.java new file mode 100644 index 0000000..a3437b4 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/community/CommunityRequestDto.java @@ -0,0 +1,21 @@ +package com.example.prdoit.dto.community; + +import lombok.*; + +import java.time.LocalDateTime; +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class CommunityRequestDto { + + private String communityTitle; + private String communityContent; + private List communityTagList; + private LocalDateTime communityDate; + + private String userId; +} diff --git a/src/main/java/com/example/prdoit/dto/community/CommunityResponseDto.java b/src/main/java/com/example/prdoit/dto/community/CommunityResponseDto.java new file mode 100644 index 0000000..4cd16f7 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/community/CommunityResponseDto.java @@ -0,0 +1,22 @@ +package com.example.prdoit.dto.community; + +import lombok.*; + +import java.time.LocalDateTime; +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class CommunityResponseDto { + + private String communityId; + private String communityTitle; + private int commentCount; + private String userNickname; + private LocalDateTime communityCreatedDate; + + private List communityTagList; +} diff --git a/src/main/java/com/example/prdoit/dto/community/CommunityTagPatchDto.java b/src/main/java/com/example/prdoit/dto/community/CommunityTagPatchDto.java new file mode 100644 index 0000000..acbbb9d --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/community/CommunityTagPatchDto.java @@ -0,0 +1,14 @@ +package com.example.prdoit.dto.community; + +import lombok.*; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class CommunityTagPatchDto { + + private int communityTagId; + private String communityTag; +} diff --git a/src/main/java/com/example/prdoit/dto/community/CommunityTagResponseDto.java b/src/main/java/com/example/prdoit/dto/community/CommunityTagResponseDto.java new file mode 100644 index 0000000..0e537cb --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/community/CommunityTagResponseDto.java @@ -0,0 +1,14 @@ +package com.example.prdoit.dto.community; + +import lombok.*; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class CommunityTagResponseDto { + + private int communityTagId; + private String communityTag; +} diff --git a/src/main/java/com/example/prdoit/dto/content/ContentDetailDto.java b/src/main/java/com/example/prdoit/dto/content/ContentDetailDto.java new file mode 100644 index 0000000..04e6ecf --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/content/ContentDetailDto.java @@ -0,0 +1,21 @@ +package com.example.prdoit.dto.content; + +import lombok.*; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class ContentDetailDto { + + private String contentId; + private String contentTitle; + private String contentContent; + private int contentView; + private int contentLike; + private int contentLevel; + private int isVideo; + private String writer; + +} diff --git a/src/main/java/com/example/prdoit/dto/content/ContentRequestDto.java b/src/main/java/com/example/prdoit/dto/content/ContentRequestDto.java new file mode 100644 index 0000000..eb8ae0c --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/content/ContentRequestDto.java @@ -0,0 +1,18 @@ +package com.example.prdoit.dto.content; + +import lombok.*; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class ContentRequestDto { + + private String contentTitle; + private String contentContent; + private int contentLevel; + private int isVideo; + private String userId; + +} diff --git a/src/main/java/com/example/prdoit/dto/content/ContentResponseDto.java b/src/main/java/com/example/prdoit/dto/content/ContentResponseDto.java new file mode 100644 index 0000000..8ad5230 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/content/ContentResponseDto.java @@ -0,0 +1,17 @@ +package com.example.prdoit.dto.content; + +import lombok.*; + +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class ContentResponseDto { + + private int total; + private List contentList; + +} diff --git a/src/main/java/com/example/prdoit/dto/content/ContentTitleDto.java b/src/main/java/com/example/prdoit/dto/content/ContentTitleDto.java new file mode 100644 index 0000000..890fc92 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/content/ContentTitleDto.java @@ -0,0 +1,18 @@ +package com.example.prdoit.dto.content; + +import lombok.*; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class ContentTitleDto { + + private String contentId; + private String contentTitle; + private int contentView; + private int contentLike; + private int contentLevel; + private String writer; +} diff --git a/src/main/java/com/example/prdoit/dto/content/ContentUpdateDto.java b/src/main/java/com/example/prdoit/dto/content/ContentUpdateDto.java new file mode 100644 index 0000000..846c378 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/content/ContentUpdateDto.java @@ -0,0 +1,18 @@ +package com.example.prdoit.dto.content; + +import lombok.*; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class ContentUpdateDto { + + private String contentId; + private String contentTitle; + private String contentContent; + private int contentLevel; + private int isVideo; + +} diff --git a/src/main/java/com/example/prdoit/dto/content/TotalContentDto.java b/src/main/java/com/example/prdoit/dto/content/TotalContentDto.java new file mode 100644 index 0000000..b535ff0 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/content/TotalContentDto.java @@ -0,0 +1,21 @@ +package com.example.prdoit.dto.content; + +import lombok.*; +import org.springframework.data.domain.Page; + +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class TotalContentDto { + + private int totalContent; + private int totalView; + private int totalLike; + + private List ContentList; + +} diff --git a/src/main/java/com/example/prdoit/dto/project/ProjectContentResponseDto.java b/src/main/java/com/example/prdoit/dto/project/ProjectContentResponseDto.java deleted file mode 100644 index c5902d8..0000000 --- a/src/main/java/com/example/prdoit/dto/project/ProjectContentResponseDto.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.example.prdoit.dto.project; - -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.Getter; - -@Getter -@Builder -@AllArgsConstructor -public class ProjectContentResponseDto { - - private String projectContent; - private int projectLevel; - -} diff --git a/src/main/java/com/example/prdoit/dto/project/ProjectResponseDto.java b/src/main/java/com/example/prdoit/dto/project/ProjectResponseDto.java index 7fc0f1e..a1dd5c9 100644 --- a/src/main/java/com/example/prdoit/dto/project/ProjectResponseDto.java +++ b/src/main/java/com/example/prdoit/dto/project/ProjectResponseDto.java @@ -1,12 +1,12 @@ package com.example.prdoit.dto.project; -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.Getter; +import lombok.*; @Getter @Builder +@Setter @AllArgsConstructor +@NoArgsConstructor public class ProjectResponseDto { private String projectId; diff --git a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogAddDto.java b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogAddDto.java new file mode 100644 index 0000000..f2707db --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogAddDto.java @@ -0,0 +1,17 @@ +package com.example.prdoit.dto.project.backlog; + +import lombok.*; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class BacklogAddDto { + + private int backlogId; + private String backlogTask; + private String backlogWorker; + private String backlogEstimate; + +} diff --git a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogDeleteDto.java b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogDeleteDto.java deleted file mode 100644 index 28c37ae..0000000 --- a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogDeleteDto.java +++ /dev/null @@ -1,14 +0,0 @@ -package com.example.prdoit.dto.project.backlog; - -import lombok.Builder; -import lombok.Getter; - -import java.util.List; - -@Getter -@Builder -public class BacklogDeleteDto { - - private String projectId; - private List backlogTaskIdList; -} diff --git a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogListDto.java b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogListDto.java index bd9aa9b..44e5952 100644 --- a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogListDto.java +++ b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogListDto.java @@ -13,7 +13,6 @@ public class BacklogListDto { private int backlogPriority; private String backlogTask; private String backlogDescription; - private String backlogStatus; private String backlogWorker; private String backlogTaskId; private String backlogEstimate; diff --git a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogUpdateListDto.java b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogPatchDto.java similarity index 75% rename from src/main/java/com/example/prdoit/dto/project/backlog/BacklogUpdateListDto.java rename to src/main/java/com/example/prdoit/dto/project/backlog/BacklogPatchDto.java index 942e9a6..a052f0b 100644 --- a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogUpdateListDto.java +++ b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogPatchDto.java @@ -1,20 +1,21 @@ package com.example.prdoit.dto.project.backlog; +import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Getter; @Getter @Builder -public class BacklogUpdateListDto { - +@AllArgsConstructor +public class BacklogPatchDto { + + private int backlogId; private String backlogUserStory; private int backlogPriority; private String backlogTask; private String backlogDescription; - private String backlogStatus; private String backlogWorker; private String backlogTaskId; private String backlogEstimate; - private String postTaskId; } diff --git a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogPutDto.java b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogPutDto.java index cef2446..419f7a5 100644 --- a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogPutDto.java +++ b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogPutDto.java @@ -1,5 +1,6 @@ package com.example.prdoit.dto.project.backlog; +import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Getter; @@ -7,6 +8,7 @@ @Getter @Builder +@AllArgsConstructor public class BacklogPutDto { private String projectId; diff --git a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogPutListDto.java b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogPutListDto.java index f80b30e..abcef7e 100644 --- a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogPutListDto.java +++ b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogPutListDto.java @@ -1,17 +1,18 @@ package com.example.prdoit.dto.project.backlog; +import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Getter; @Getter @Builder +@AllArgsConstructor public class BacklogPutListDto { private String backlogUserStory; private int backlogPriority; private String backlogTask; private String backlogDescription; - private String backlogStatus; private String backlogWorker; private String backlogTaskId; private String backlogEstimate; diff --git a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogResponseDto.java b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogResponseDto.java index 512f8db..6fe3686 100644 --- a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogResponseDto.java +++ b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogResponseDto.java @@ -1,17 +1,20 @@ package com.example.prdoit.dto.project.backlog; -import lombok.Builder; -import lombok.Getter; +import lombok.*; @Getter @Builder +@Setter +@AllArgsConstructor +@NoArgsConstructor public class BacklogResponseDto { + private int backlogId; private String backlogUserStory; private int backlogPriority; private String backlogTask; private String backlogDescription; - private String backlogStatus; + private int backlogStatus; private String backlogWorker; private String backlogTaskId; private String backlogEstimate; diff --git a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogUpdateDto.java b/src/main/java/com/example/prdoit/dto/project/backlog/BacklogUpdateDto.java deleted file mode 100644 index a1560ab..0000000 --- a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogUpdateDto.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.example.prdoit.dto.project.backlog; - -import lombok.Builder; -import lombok.Getter; - -import java.util.List; - -@Getter -@Builder -public class BacklogUpdateDto { - - private String projectId; - private List backlogListDto; - -} diff --git a/src/main/java/com/example/prdoit/dto/project/burndown/BurndownDto.java b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownDto.java new file mode 100644 index 0000000..98f78ed --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownDto.java @@ -0,0 +1,20 @@ +package com.example.prdoit.dto.project.burndown; + +import lombok.*; + +import java.time.LocalDateTime; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class BurndownDto { + + private int backlogId; + private LocalDateTime backlogEndDate; + private String backlogEndTime; + private int backlogStatus; + private String backlogWorker; + +} diff --git a/src/main/java/com/example/prdoit/dto/project/burndown/BurndownListDto.java b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownListDto.java new file mode 100644 index 0000000..ec0ff81 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownListDto.java @@ -0,0 +1,25 @@ +package com.example.prdoit.dto.project.burndown; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.NoArgsConstructor; + +import java.time.LocalDateTime; + +@Getter +@Builder +@AllArgsConstructor +@NoArgsConstructor +public class BurndownListDto { + + private int backlogId; + private String backlogTask; + private int backlogStatus; + private String backlogWorker; + private String backlogTaskId; + private String backlogEstimate; + private LocalDateTime backlogEndDate; + private String backlogEndTime; + +} diff --git a/src/main/java/com/example/prdoit/dto/project/burndown/BurndownPatchDto.java b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownPatchDto.java new file mode 100644 index 0000000..2f6ef8b --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownPatchDto.java @@ -0,0 +1,17 @@ +package com.example.prdoit.dto.project.burndown; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; + +import java.time.LocalDateTime; +import java.util.List; + +@Getter +@Builder +@AllArgsConstructor +public class BurndownPatchDto { + + private int iteration; + private List burndownDtoList; +} diff --git a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogRequestDto.java b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownPostDto.java similarity index 52% rename from src/main/java/com/example/prdoit/dto/project/backlog/BacklogRequestDto.java rename to src/main/java/com/example/prdoit/dto/project/burndown/BurndownPostDto.java index 829858f..6154394 100644 --- a/src/main/java/com/example/prdoit/dto/project/backlog/BacklogRequestDto.java +++ b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownPostDto.java @@ -1,4 +1,4 @@ -package com.example.prdoit.dto.project.backlog; +package com.example.prdoit.dto.project.burndown; import lombok.AllArgsConstructor; import lombok.Builder; @@ -9,10 +9,9 @@ @Getter @Builder @AllArgsConstructor -public class BacklogRequestDto { +public class BurndownPostDto { private String projectId; - private List backlogListDto; - private int iteration; + private List burndownPostListDto; } diff --git a/src/main/java/com/example/prdoit/dto/project/burndown/BurndownPostListDto.java b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownPostListDto.java new file mode 100644 index 0000000..577dd00 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownPostListDto.java @@ -0,0 +1,15 @@ +package com.example.prdoit.dto.project.burndown; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; + +@Getter +@Builder +@AllArgsConstructor +public class BurndownPostListDto { + + private int backlogId; + private int iteration; + +} diff --git a/src/main/java/com/example/prdoit/dto/project/burndown/BurndownResponseDto.java b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownResponseDto.java new file mode 100644 index 0000000..01e1417 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/project/burndown/BurndownResponseDto.java @@ -0,0 +1,17 @@ +package com.example.prdoit.dto.project.burndown; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; + +import java.util.List; + +@Getter +@Builder +@AllArgsConstructor +public class BurndownResponseDto { + + private int iteration; + private List burndownListDto; + +} diff --git a/src/main/java/com/example/prdoit/dto/project/content/ProjectContentDto.java b/src/main/java/com/example/prdoit/dto/project/content/ContentDeleteDto.java similarity index 64% rename from src/main/java/com/example/prdoit/dto/project/content/ProjectContentDto.java rename to src/main/java/com/example/prdoit/dto/project/content/ContentDeleteDto.java index e520ee1..3e39f07 100644 --- a/src/main/java/com/example/prdoit/dto/project/content/ProjectContentDto.java +++ b/src/main/java/com/example/prdoit/dto/project/content/ContentDeleteDto.java @@ -3,12 +3,13 @@ import lombok.Builder; import lombok.Getter; +import java.util.List; + @Getter @Builder -public class ProjectContentDto { +public class ContentDeleteDto { private String projectId; private int projectLevel; - private String projectContent; - + private List backlogIdList; } diff --git a/src/main/java/com/example/prdoit/dto/project/content/ContentDto.java b/src/main/java/com/example/prdoit/dto/project/content/ContentDto.java new file mode 100644 index 0000000..6476d06 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/project/content/ContentDto.java @@ -0,0 +1,20 @@ +package com.example.prdoit.dto.project.content; + +import com.example.prdoit.dto.project.backlog.BacklogListDto; +import com.example.prdoit.dto.project.burndown.BurndownPostListDto; +import lombok.Builder; +import lombok.Getter; + +import java.util.List; + +@Getter +@Builder +public class ContentDto { + + private String projectId; + private int projectLevel; + private String projectContent; + private List backlogListDto; + private List burndownPostListDto; + +} diff --git a/src/main/java/com/example/prdoit/dto/project/content/ContentPatchDto.java b/src/main/java/com/example/prdoit/dto/project/content/ContentPatchDto.java new file mode 100644 index 0000000..81cdb83 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/project/content/ContentPatchDto.java @@ -0,0 +1,21 @@ +package com.example.prdoit.dto.project.content; + +import com.example.prdoit.dto.project.backlog.BacklogPatchDto; +import com.example.prdoit.dto.project.burndown.BurndownPatchDto; +import lombok.*; + +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class ContentPatchDto { + + private String projectId; + private int projectLevel; + private String projectContent; + private List backlogPatchDtoList; + private List burndownPatchDtoList; +} diff --git a/src/main/java/com/example/prdoit/dto/project/content/ContentResponseDto.java b/src/main/java/com/example/prdoit/dto/project/content/ContentResponseDto.java new file mode 100644 index 0000000..a4e2f65 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/project/content/ContentResponseDto.java @@ -0,0 +1,25 @@ +package com.example.prdoit.dto.project.content; + +import lombok.*; + +@Getter +@Builder +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class ContentResponseDto { + + private int levelContentId; + private String projectContent; + private int projectLevel; + + @Override + public String toString() { + return "ContentResponseDto{" + + "levelContentId=" + levelContentId + + ", projectContent='" + projectContent + '\'' + + ", projectLevel=" + projectLevel + + '}'; + } + +} diff --git a/src/main/java/com/example/prdoit/dto/project/content/ProjectContentDeleteDto.java b/src/main/java/com/example/prdoit/dto/project/content/ProjectContentDeleteDto.java deleted file mode 100644 index 7aa182b..0000000 --- a/src/main/java/com/example/prdoit/dto/project/content/ProjectContentDeleteDto.java +++ /dev/null @@ -1,12 +0,0 @@ -package com.example.prdoit.dto.project.content; - -import lombok.Builder; -import lombok.Getter; - -@Getter -@Builder -public class ProjectContentDeleteDto { - - private String projectId; - private int projectLevel; -} diff --git a/src/main/java/com/example/prdoit/dto/project/content/ProjectContentResponseDto.java b/src/main/java/com/example/prdoit/dto/project/content/ProjectContentResponseDto.java new file mode 100644 index 0000000..82829a7 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/project/content/ProjectContentResponseDto.java @@ -0,0 +1,20 @@ +package com.example.prdoit.dto.project.content; + +import com.example.prdoit.dto.project.backlog.BacklogResponseDto; +import com.example.prdoit.dto.project.burndown.BurndownResponseDto; +import lombok.*; + +import java.util.List; + +@Getter +@Setter +@Builder +@AllArgsConstructor +@NoArgsConstructor +public class ProjectContentResponseDto { + + private List contentResponseDtoList; + private List backlogResponseDtoList; + private List burndownResponseDtoList; + +} diff --git a/src/main/java/com/example/prdoit/dto/user/ChangePasswordDto.java b/src/main/java/com/example/prdoit/dto/user/ChangePasswordDto.java new file mode 100644 index 0000000..fae7755 --- /dev/null +++ b/src/main/java/com/example/prdoit/dto/user/ChangePasswordDto.java @@ -0,0 +1,14 @@ +package com.example.prdoit.dto.user; + +import lombok.*; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class ChangePasswordDto { + + private String userId; + private String newPassword; +} diff --git a/src/main/java/com/example/prdoit/dto/user/UserDto.java b/src/main/java/com/example/prdoit/dto/user/UserDto.java index b215738..d70b12d 100644 --- a/src/main/java/com/example/prdoit/dto/user/UserDto.java +++ b/src/main/java/com/example/prdoit/dto/user/UserDto.java @@ -14,15 +14,5 @@ public class UserDto { private String name; private String email; private String nickname; -// - @Override - public String toString() { - return "UserDto{" + - "id='" + id + '\'' + - ", password='" + password + '\'' + - ", name='" + name + '\'' + - ", email='" + email + '\'' + - ", nickname='" + nickname + '\'' + - '}'; - } + } diff --git a/src/main/java/com/example/prdoit/model/BacklogTable.java b/src/main/java/com/example/prdoit/model/BacklogTable.java index a2e9323..e8dfb9f 100644 --- a/src/main/java/com/example/prdoit/model/BacklogTable.java +++ b/src/main/java/com/example/prdoit/model/BacklogTable.java @@ -40,7 +40,7 @@ public class BacklogTable { private String backlogEndTime; - private String backlogIteration; + private int backlogIteration; @ManyToOne @JoinColumn(name = "levelContentId") diff --git a/src/main/java/com/example/prdoit/model/CommentCommentTable.java b/src/main/java/com/example/prdoit/model/CommentCommentTable.java new file mode 100644 index 0000000..ffea9ba --- /dev/null +++ b/src/main/java/com/example/prdoit/model/CommentCommentTable.java @@ -0,0 +1,30 @@ +package com.example.prdoit.model; + +import jakarta.persistence.*; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.time.LocalDateTime; + +@Entity +@Data +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class CommentCommentTable { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private int commentCommentId; + + private String commentCommentContent; + + private String userNickname; + + private LocalDateTime commentCommentDate; + + @ManyToOne + @JoinColumn(name = "commentId") + private CommentTable commentId; +} diff --git a/src/main/java/com/example/prdoit/model/CommentTable.java b/src/main/java/com/example/prdoit/model/CommentTable.java new file mode 100644 index 0000000..b51a072 --- /dev/null +++ b/src/main/java/com/example/prdoit/model/CommentTable.java @@ -0,0 +1,42 @@ +package com.example.prdoit.model; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import jakarta.persistence.*; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.time.LocalDateTime; +import java.util.List; + +@Entity +@Data +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class CommentTable { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private int commentId; + + private String commentContent; + + private String commentNickname; + + private LocalDateTime commentDate; + + @ManyToOne + @JoinColumn(name = "contentId", nullable = true) + private ContentTable contentId; + + @ManyToOne + @JoinColumn(name = "communityId", nullable = true) + private CommunityTable communityId; + + @OneToMany(mappedBy = "commentId") + @JsonIgnore + private List commentCommentTable; + +} diff --git a/src/main/java/com/example/prdoit/model/CommunityTable.java b/src/main/java/com/example/prdoit/model/CommunityTable.java index 23493cd..28ecb48 100644 --- a/src/main/java/com/example/prdoit/model/CommunityTable.java +++ b/src/main/java/com/example/prdoit/model/CommunityTable.java @@ -1,5 +1,6 @@ package com.example.prdoit.model; +import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; import lombok.AllArgsConstructor; import lombok.Builder; @@ -7,6 +8,7 @@ import lombok.NoArgsConstructor; import java.time.LocalDateTime; +import java.util.List; @Entity @Data @@ -16,18 +18,25 @@ public class CommunityTable { @Id - @GeneratedValue(strategy = GenerationType.IDENTITY) - private int communityId; + private String communityId; private String communityContent; private String communityTitle; - private String communityTag; - private LocalDateTime communityDate; + private int communityView; + @ManyToOne @JoinColumn(name = "id") private IdTable id; + + @OneToMany(mappedBy = "communityId", cascade = CascadeType.REMOVE, orphanRemoval = true, fetch = FetchType.EAGER) + @JsonIgnore + private List commentTable; + + @OneToMany(mappedBy = "communityId", cascade = CascadeType.REMOVE, orphanRemoval = true, fetch = FetchType.EAGER) + @JsonIgnore + private List communityTagTable; } diff --git a/src/main/java/com/example/prdoit/model/ReportTable.java b/src/main/java/com/example/prdoit/model/CommunityTagTable.java similarity index 61% rename from src/main/java/com/example/prdoit/model/ReportTable.java rename to src/main/java/com/example/prdoit/model/CommunityTagTable.java index 5c02a0c..3fb24ff 100644 --- a/src/main/java/com/example/prdoit/model/ReportTable.java +++ b/src/main/java/com/example/prdoit/model/CommunityTagTable.java @@ -11,19 +11,15 @@ @AllArgsConstructor @NoArgsConstructor @Builder -public class ReportTable { +public class CommunityTagTable { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) - private int reportId; + private int communityTagId; - private String reportReason; - - private int reportNumber; - - private String reportType; + private String communityTag; @ManyToOne - @JoinColumn(name = "id") - private IdTable id; + @JoinColumn(name = "communityId") + private CommunityTable communityId; } diff --git a/src/main/java/com/example/prdoit/model/ContentTable.java b/src/main/java/com/example/prdoit/model/ContentTable.java new file mode 100644 index 0000000..3b8b4ed --- /dev/null +++ b/src/main/java/com/example/prdoit/model/ContentTable.java @@ -0,0 +1,39 @@ +package com.example.prdoit.model; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import jakarta.persistence.*; +import lombok.*; + +import java.util.List; + +@Data +@Entity +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class ContentTable { + + @Id + private String contentId; + + private String contentTitle; + + private String contentContent; + + private int contentLevel; + + private int contentView; + + private int isVideo; + + private int contentLike; + + @ManyToOne + @JoinColumn(name = "userId") + @JsonIgnore + private IdTable userId; + + @OneToMany(mappedBy = "contentId", cascade = CascadeType.REMOVE, orphanRemoval = true, fetch = FetchType.EAGER) + @JsonIgnore + private List commentTable; +} diff --git a/src/main/java/com/example/prdoit/model/GuideLineTable.java b/src/main/java/com/example/prdoit/model/GuideLineTable.java deleted file mode 100644 index 9f95485..0000000 --- a/src/main/java/com/example/prdoit/model/GuideLineTable.java +++ /dev/null @@ -1,31 +0,0 @@ -package com.example.prdoit.model; - -import jakarta.persistence.Entity; -import jakarta.persistence.GeneratedValue; -import jakarta.persistence.GenerationType; -import jakarta.persistence.Id; -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.Data; -import lombok.NoArgsConstructor; - -@Entity -@Data -@AllArgsConstructor -@NoArgsConstructor -@Builder -public class GuideLineTable { - - @Id - @GeneratedValue(strategy = GenerationType.IDENTITY) - private int guideLineId; - - private String guideLinePainPoint; - private String guideLineTarget; - private String guideLineUseCase; - private String guideLineUserStory; - private String guideLineFunction; - private String guideLineTask; - private String guideLineProductBacklog; - private String guideLineBurnDownChart; -} diff --git a/src/main/java/com/example/prdoit/model/IdTable.java b/src/main/java/com/example/prdoit/model/IdTable.java index df48ef1..eaec3ef 100644 --- a/src/main/java/com/example/prdoit/model/IdTable.java +++ b/src/main/java/com/example/prdoit/model/IdTable.java @@ -39,13 +39,12 @@ public class IdTable { @JsonIgnore private List readTable; - @OneToMany(mappedBy = "id", cascade = CascadeType.REMOVE, orphanRemoval = true, fetch = FetchType.EAGER) - @JsonIgnore - private List reportTable; - @OneToMany(mappedBy = "id", cascade = CascadeType.REMOVE, orphanRemoval = true, fetch = FetchType.EAGER) @JsonIgnore private List communityTable; + @OneToMany(mappedBy = "userId", cascade = CascadeType.REMOVE, orphanRemoval = true, fetch = FetchType.EAGER) + @JsonIgnore + private List contentTable; } diff --git a/src/main/java/com/example/prdoit/model/ProjectTable.java b/src/main/java/com/example/prdoit/model/ProjectTable.java index 8ceb050..ded09af 100644 --- a/src/main/java/com/example/prdoit/model/ProjectTable.java +++ b/src/main/java/com/example/prdoit/model/ProjectTable.java @@ -44,8 +44,5 @@ public class ProjectTable { @JoinColumn(name = "id") private IdTable id; - @OneToMany(mappedBy = "projectId", cascade = CascadeType.REMOVE, orphanRemoval = true, fetch = FetchType.EAGER) - @JsonIgnore - private List projectLevelContentTable; } diff --git a/src/main/java/com/example/prdoit/repository/BacklogTableRepository.java b/src/main/java/com/example/prdoit/repository/BacklogTableRepository.java index 311db44..13ab37d 100644 --- a/src/main/java/com/example/prdoit/repository/BacklogTableRepository.java +++ b/src/main/java/com/example/prdoit/repository/BacklogTableRepository.java @@ -1,9 +1,13 @@ package com.example.prdoit.repository; +import com.example.prdoit.dto.project.backlog.BacklogAddDto; +import com.example.prdoit.dto.project.backlog.BacklogResponseDto; +import com.example.prdoit.dto.project.burndown.BurndownListDto; import com.example.prdoit.model.BacklogTable; import com.example.prdoit.model.ProjectLevelContentTable; -import com.example.prdoit.model.ProjectTable; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; import org.springframework.stereotype.Repository; import java.util.List; @@ -11,6 +15,22 @@ @Repository public interface BacklogTableRepository extends JpaRepository { - Optional findByBacklogTaskIdAndLevelContentId(String backlogTaskId, ProjectLevelContentTable levelContentId); - List findAllByLevelContentId(ProjectLevelContentTable levelContentId); + + @Query("SELECT new com.example.prdoit.dto.project.backlog.BacklogResponseDto(b.backlogId, b.backlogUserStory, " + + "b.backlogPriority, b.backlogTask, b.backlogDescription, b.backlogStatus, " + + "b.backlogWorker, b.backlogTaskId, b.backlogEstimate) FROM BacklogTable b " + + "WHERE b.levelContentId=:levelContentId") + List findAllByLevelContentId(@Param("levelContentId") ProjectLevelContentTable levelContentId); + + @Query("SELECT new com.example.prdoit.dto.project.burndown.BurndownListDto(b.backlogId, b.backlogTask, " + + "b.backlogStatus, b.backlogWorker, b.backlogTaskId, b.backlogEstimate, b.backlogEndDate, b.backlogEndTime) FROM BacklogTable b " + + "WHERE b.levelContentId=:levelContentId AND b.backlogIteration=:iteration") + List findAllByLevelContentIdAndBacklogIteration(ProjectLevelContentTable levelContentId, int iteration); + + + @Query("SELECT new com.example.prdoit.dto.project.backlog.BacklogAddDto(b.backlogId, b.backlogTask, " + + "b.backlogWorker, b.backlogEstimate) FROM BacklogTable b " + + "WHERE b.levelContentId=:levelContentId AND b.backlogTaskId=:backlogTaskId") + Optional findByLevelContentIdAndBacklogTaskId(ProjectLevelContentTable levelContentId, String backlogTaskId); + } diff --git a/src/main/java/com/example/prdoit/repository/CommentCommentTableRepository.java b/src/main/java/com/example/prdoit/repository/CommentCommentTableRepository.java new file mode 100644 index 0000000..cc9c441 --- /dev/null +++ b/src/main/java/com/example/prdoit/repository/CommentCommentTableRepository.java @@ -0,0 +1,13 @@ +package com.example.prdoit.repository; + +import com.example.prdoit.model.CommentCommentTable; +import com.example.prdoit.model.CommentTable; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface CommentCommentTableRepository extends JpaRepository { + List findAllByCommentId(CommentTable commentId); +} diff --git a/src/main/java/com/example/prdoit/repository/CommentTableRepository.java b/src/main/java/com/example/prdoit/repository/CommentTableRepository.java new file mode 100644 index 0000000..a0f58d1 --- /dev/null +++ b/src/main/java/com/example/prdoit/repository/CommentTableRepository.java @@ -0,0 +1,9 @@ +package com.example.prdoit.repository; + +import com.example.prdoit.model.CommentTable; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +@Repository +public interface CommentTableRepository extends JpaRepository { +} diff --git a/src/main/java/com/example/prdoit/repository/CommunityTableRepository.java b/src/main/java/com/example/prdoit/repository/CommunityTableRepository.java new file mode 100644 index 0000000..783cc16 --- /dev/null +++ b/src/main/java/com/example/prdoit/repository/CommunityTableRepository.java @@ -0,0 +1,21 @@ +package com.example.prdoit.repository; + +import com.example.prdoit.dto.community.CommunityResponseDto; +import com.example.prdoit.model.CommunityTable; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.Pageable; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface CommunityTableRepository extends JpaRepository { + + @Query("SELECT c FROM CommunityTable c WHERE c.communityTitle LIKE %:query% OR c.communityContent LIKE %:query%") + Page findAllByCommunityTitleContaining(String query, Pageable pageable); + + @Query("SELECT c FROM CommunityTable c WHERE c.id.id = :userId") + Page findAllByUserId(String userId, Pageable pageable); +} diff --git a/src/main/java/com/example/prdoit/repository/CommunityTagTableRepository.java b/src/main/java/com/example/prdoit/repository/CommunityTagTableRepository.java new file mode 100644 index 0000000..99f7d9f --- /dev/null +++ b/src/main/java/com/example/prdoit/repository/CommunityTagTableRepository.java @@ -0,0 +1,18 @@ +package com.example.prdoit.repository; + +import com.example.prdoit.model.CommunityTable; +import com.example.prdoit.model.CommunityTagTable; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.Pageable; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface CommunityTagTableRepository extends JpaRepository { + + Page findAllByCommunityTag(String communityTag, Pageable pageable); + + CommunityTagTable findByCommunityIdAndCommunityTagId(CommunityTable communityId, int communityTagId); +} diff --git a/src/main/java/com/example/prdoit/repository/ContentTableRepository.java b/src/main/java/com/example/prdoit/repository/ContentTableRepository.java new file mode 100644 index 0000000..bb4c090 --- /dev/null +++ b/src/main/java/com/example/prdoit/repository/ContentTableRepository.java @@ -0,0 +1,88 @@ +package com.example.prdoit.repository; + +import com.example.prdoit.dto.content.ContentTitleDto; +import com.example.prdoit.model.ContentTable; +import com.example.prdoit.model.IdTable; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.Pageable; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; + +import javax.swing.text.AbstractDocument; +import java.util.List; + +public interface ContentTableRepository extends JpaRepository { + + @Query("SELECT new com.example.prdoit.dto.content.ContentTitleDto" + + "(c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel, c.userId.nickname) " + + "FROM ContentTable c LEFT JOIN CommentTable cc ON c.contentId = cc.contentId.contentId " + + "WHERE c.contentTitle LIKE %:query% GROUP BY c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel " + + "ORDER BY (c.contentView * 0.33) + (c.contentLike * 0.33) + (COUNT(cc.commentId) * 0.33) DESC " + + "LIMIT :size OFFSET :offset") + List findAllByQueryContaining(@Param("query") String query, @Param("size") int size, @Param("offset") int offset); + + @Query("SELECT c FROM ContentTable c WHERE c.contentTitle LIKE %:query% OR c.contentContent LIKE %:query%") + List findAllByContentTitleContaining(String query); + + @Query("SELECT new com.example.prdoit.dto.content.ContentTitleDto" + + "(c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel, c.userId.nickname) " + + "FROM ContentTable c LEFT JOIN CommentTable cc ON c.contentId = cc.contentId.contentId " + + "GROUP BY c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel " + + "ORDER BY (c.contentView * 0.33) + (c.contentLike * 0.33) + (COUNT(cc.commentId) * 0.33) DESC " + + "LIMIT :size OFFSET :offset") + List findAllList(@Param("size") int size, @Param("offset") int offset); + + + @Query("SELECT new com.example.prdoit.dto.content.ContentTitleDto" + + "(c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel, c.userId.nickname) " + + "FROM ContentTable c LEFT JOIN CommentTable cc on c.contentId = cc.contentId.contentId WHERE c.contentTitle LIKE %:query% AND c.contentLevel = :level " + + "GROUP BY c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel " + + "ORDER BY (c.contentView * 0.33) + (c.contentLike * 0.33) + (COUNT(cc.commentId) * 0.33) DESC " + + "LIMIT :size OFFSET :offset") + List findAllQueryContainingAndContentLevel(@Param("query")String query, @Param("level")int level, @Param("size") int size, @Param("offset") int offset); + + @Query("SELECT c FROM ContentTable c WHERE (c.contentTitle LIKE %:query% OR c.contentContent LIKE %:query%) AND c.contentLevel = :level") + List findAllByQueryContainingAndContentLevel(String query, int level); + + @Query("SELECT new com.example.prdoit.dto.content.ContentTitleDto" + + "(c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel, c.userId.nickname) " + + "FROM ContentTable c LEFT JOIN CommentTable cc ON c.contentId = cc.contentId.contentId WHERE c.contentLevel = :level " + + "GROUP BY c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel " + + "ORDER BY (c.contentView * 0.33) + (c.contentLike * 0.33) + (COUNT(cc.commentId) * 0.33) DESC " + + "LIMIT :size OFFSET :offset") + List findAllByContentLevel(@Param("level") int level, @Param("size") int size, @Param("offset") int offset); + + List findAllByContentLevel(int level); + + @Query("SELECT new com.example.prdoit.dto.content.ContentTitleDto" + + "(c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel, c.userId.nickname) " + + "FROM ContentTable c WHERE c.userId.id = :userId") + Page findAllByUserIdPagination(@Param("userId") String userId, Pageable pageable); + + List findAllByUserId(IdTable userId); + + @Query("SELECT new com.example.prdoit.dto.content.ContentTitleDto" + + "(c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel, c.userId.nickname) " + + "FROM ContentTable c WHERE c.userId.id = :userId AND c.contentLevel = :level") + Page findAllByUserIdAndContentLevel(String userId, int level, Pageable pageable); + + List findAllByUserIdAndContentLevel(IdTable userId, int level); + + @Query("SELECT new com.example.prdoit.dto.content.ContentTitleDto" + + "(c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel, c.userId.nickname) " + + "FROM ContentTable c WHERE c.userId.id = :userId AND c.contentTitle LIKE %:query%") + Page findAllByUserIdAndQueryContaining(String userId, String query, Pageable pageable); + + @Query("SELECT c FROM ContentTable c WHERE c.userId = :userId AND (c.contentTitle LIKE %:query% or c.contentContent LIKE %:query%)") + List findAllByUserIdAndQueryContaining(IdTable userId, String query); + + @Query("SELECT new com.example.prdoit.dto.content.ContentTitleDto" + + "(c.contentId, c.contentTitle, c.contentView, c.contentLike, c.contentLevel, c.userId.nickname) " + + "FROM ContentTable c WHERE c.userId.id = :userId AND c.contentLevel = :level AND c.contentTitle LIKE %:query%") + Page findAllByUserIdAndContentLevelAndQueryContaining(String userId, int level, String query, Pageable pageable); + + @Query("SELECT c FROM ContentTable c WHERE c.userId = :userId AND c.contentLevel = :level AND (c.contentTitle LIKE %:query% or c.contentContent LIKE %:query%)") + List findAllByUserIdAndContentLevelAndQueryContaining(IdTable userId, int level, String query); + +} diff --git a/src/main/java/com/example/prdoit/repository/GuideLineTableRepository.java b/src/main/java/com/example/prdoit/repository/GuideLineTableRepository.java deleted file mode 100644 index 92699fa..0000000 --- a/src/main/java/com/example/prdoit/repository/GuideLineTableRepository.java +++ /dev/null @@ -1,7 +0,0 @@ -package com.example.prdoit.repository; - -import com.example.prdoit.model.GuideLineTable; -import org.springframework.data.jpa.repository.JpaRepository; - -public interface GuideLineTableRepository extends JpaRepository { -} diff --git a/src/main/java/com/example/prdoit/repository/IdTableRepository.java b/src/main/java/com/example/prdoit/repository/IdTableRepository.java index d10a471..0a6c996 100644 --- a/src/main/java/com/example/prdoit/repository/IdTableRepository.java +++ b/src/main/java/com/example/prdoit/repository/IdTableRepository.java @@ -3,7 +3,9 @@ import com.example.prdoit.model.IdTable; import org.springframework.data.jpa.repository.JpaRepository; +import java.util.Optional; + public interface IdTableRepository extends JpaRepository { - IdTable findByEmail(String userEmail); + Optional findByEmail(String userEmail); IdTable findByNickname(String userNickname); } diff --git a/src/main/java/com/example/prdoit/repository/ProjectLevelContentTableRepository.java b/src/main/java/com/example/prdoit/repository/ProjectLevelContentTableRepository.java index 2dbfe8f..a4b68cb 100644 --- a/src/main/java/com/example/prdoit/repository/ProjectLevelContentTableRepository.java +++ b/src/main/java/com/example/prdoit/repository/ProjectLevelContentTableRepository.java @@ -1,10 +1,22 @@ package com.example.prdoit.repository; +import com.example.prdoit.dto.project.content.ContentResponseDto; import com.example.prdoit.model.ProjectLevelContentTable; import com.example.prdoit.model.ProjectTable; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; + +import javax.swing.text.AbstractDocument; +import java.util.List; +import java.util.Optional; public interface ProjectLevelContentTableRepository extends JpaRepository { ProjectLevelContentTable findByProjectId(ProjectTable projectId); - ProjectLevelContentTable findByProjectIdAndProjectLevel(ProjectTable projectId, int projectLevel); + Optional findByProjectIdAndProjectLevel(ProjectTable projectId, int projectLevel); + + @Query("SELECT new com.example.prdoit.dto.project.content.ContentResponseDto" + + "(c.levelContentId, c.projectLevelContent, c.projectLevel) " + + "FROM ProjectLevelContentTable c WHERE c.projectId=:projectId") + List findAllByProjectId(@Param("projectId")ProjectTable projectTable); } diff --git a/src/main/java/com/example/prdoit/repository/ProjectTableRepository.java b/src/main/java/com/example/prdoit/repository/ProjectTableRepository.java index fc8a4ef..99b8b3d 100644 --- a/src/main/java/com/example/prdoit/repository/ProjectTableRepository.java +++ b/src/main/java/com/example/prdoit/repository/ProjectTableRepository.java @@ -1,5 +1,6 @@ package com.example.prdoit.repository; +import com.example.prdoit.dto.project.ProjectResponseDto; import com.example.prdoit.model.IdTable; import com.example.prdoit.model.ProjectTable; import org.springframework.data.jpa.repository.JpaRepository; @@ -10,6 +11,18 @@ public interface ProjectTableRepository extends JpaRepository { - @Query("SELECT p FROM ProjectTable p WHERE p.id = :id") - List findAllByUserId(@Param("id") IdTable userId); + @Query("SELECT new com.example.prdoit.dto.project.ProjectResponseDto(" + + "p.projectId, p.projectName, p.projectIdea, p.projectLevel1, " + + "p.projectLevel2, p.projectLevel3, p.projectLevel4, p.projectLevel5, " + + "p.projectLevel6, p.projectLevel7, p.projectLevel8) " + + "FROM ProjectTable p WHERE p.id = :id") + List findAllByUserId(@Param("id") IdTable userId); + + @Query("SELECT new com.example.prdoit.dto.project.ProjectResponseDto(" + + "p.projectId, p.projectName, p.projectIdea, p.projectLevel1, " + + "p.projectLevel2, p.projectLevel3, p.projectLevel4, p.projectLevel5, " + + "p.projectLevel6, p.projectLevel7, p.projectLevel8) " + + "FROM ProjectTable p WHERE p.projectId = :id") + ProjectResponseDto findByProjectId(@Param("id") String projectId); + } diff --git a/src/main/java/com/example/prdoit/repository/SurveyTableRepository.java b/src/main/java/com/example/prdoit/repository/SurveyTableRepository.java index d8d9cbd..5233c48 100644 --- a/src/main/java/com/example/prdoit/repository/SurveyTableRepository.java +++ b/src/main/java/com/example/prdoit/repository/SurveyTableRepository.java @@ -9,5 +9,5 @@ @Repository public interface SurveyTableRepository extends JpaRepository { - Optional findById(IdTable idTable); + SurveyTable findByIdId(String userId); } diff --git a/src/main/java/com/example/prdoit/service/community/CommunityService.java b/src/main/java/com/example/prdoit/service/community/CommunityService.java new file mode 100644 index 0000000..c39de56 --- /dev/null +++ b/src/main/java/com/example/prdoit/service/community/CommunityService.java @@ -0,0 +1,22 @@ +package com.example.prdoit.service.community; + +import com.example.prdoit.dto.community.CommunityDetailResponseDto; +import com.example.prdoit.dto.community.CommunityPatchDto; +import com.example.prdoit.dto.community.CommunityRequestDto; +import com.example.prdoit.dto.community.CommunityResponseDto; + +import java.util.List; + +public interface CommunityService { + + void postCommunity(CommunityRequestDto communityRequestDto); + + List getCommunityList(String query, String tag, String userId, int size, int page); + + void patchCommunity(CommunityPatchDto communityPatchDto); + + void deleteCommunity(String communityId); + + CommunityDetailResponseDto getCommunityDetail(String communityId); +} + diff --git a/src/main/java/com/example/prdoit/service/community/CommunityServiceImpl.java b/src/main/java/com/example/prdoit/service/community/CommunityServiceImpl.java new file mode 100644 index 0000000..6786adc --- /dev/null +++ b/src/main/java/com/example/prdoit/service/community/CommunityServiceImpl.java @@ -0,0 +1,204 @@ +package com.example.prdoit.service.community; + +import com.example.prdoit.dto.community.*; +import com.example.prdoit.model.CommunityTable; +import com.example.prdoit.model.CommunityTagTable; +import com.example.prdoit.model.IdTable; +import com.example.prdoit.repository.CommunityTableRepository; +import com.example.prdoit.repository.CommunityTagTableRepository; +import com.example.prdoit.repository.IdTableRepository; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.data.domain.PageRequest; +import org.springframework.data.domain.Pageable; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.UUID; + +@Service +@RequiredArgsConstructor +@Slf4j +public class CommunityServiceImpl implements CommunityService { + + private final CommunityTableRepository communityTableRepository; + private final IdTableRepository idTableRepository; + private final CommunityTagTableRepository communityTagTableRepository; + + @Override + public void postCommunity(CommunityRequestDto communityRequestDto) { + log.info("[CommunityServiceImpl] 글 작성 시작"); + IdTable idTable = idTableRepository.findById(communityRequestDto.getUserId()).orElseThrow(() -> new IllegalArgumentException("해당 아이디가 없습니다.")); + + try{ + CommunityTable communityTable = CommunityTable.builder() + .communityId(UUID.randomUUID().toString()) + .communityTitle(communityRequestDto.getCommunityTitle()) + .communityContent(communityRequestDto.getCommunityContent()) + .communityDate(communityRequestDto.getCommunityDate()) + .communityView(0) + .id(idTable) + .build(); + + List communityTagTableList = communityRequestDto.getCommunityTagList().stream() + .map(tag -> CommunityTagTable.builder() + .communityTag(tag) + .communityId(communityTable) + .build()) + .toList(); + communityTableRepository.save(communityTable); + communityTagTableRepository.saveAll(communityTagTableList); + log.info("[CommunityServiceImpl] 글 작성 성공"); + } catch (Exception e) { + log.error(e.getMessage()); + throw new IllegalArgumentException("글 작성에 실패했습니다."); + } + } + + @Override + public List getCommunityList(String query, String tag, String userId, int size, int page){ + log.info("[CommunityServiceImpl] 글 목록 조회 시작"); + Pageable pageable = PageRequest.of(page - 1, size); + try { + if (!query.equals("all")) { + List communityTableList = communityTableRepository.findAllByCommunityTitleContaining(query, pageable).toList(); + return communityTableList.stream() + .map(communityTable -> CommunityResponseDto.builder() + .communityId(communityTable.getCommunityId()) + .communityTitle(communityTable.getCommunityTitle()) + .commentCount(communityTable.getCommentTable().size()) + .userNickname(communityTable.getId().getNickname()) + .communityCreatedDate(communityTable.getCommunityDate()) + .communityTagList(communityTable.getCommunityTagTable().stream() + .map(CommunityTagTable -> CommunityTagResponseDto.builder() + .communityTagId(CommunityTagTable.getCommunityTagId()) + .communityTag(CommunityTagTable.getCommunityTag()) + .build()) + .toList()) + .build()) + .toList(); + } + + if (!tag.isEmpty()) { + List communityTagTableList = communityTagTableRepository.findAllByCommunityTag(tag, pageable).toList(); + return communityTagTableList.stream() + .map(communityTagTable -> CommunityResponseDto.builder() + .communityId(communityTagTable.getCommunityId().getCommunityId()) + .communityTitle(communityTagTable.getCommunityId().getCommunityTitle()) + .commentCount(communityTagTable.getCommunityId().getCommentTable().size()) + .userNickname(communityTagTable.getCommunityId().getId().getNickname()) + .communityCreatedDate(communityTagTable.getCommunityId().getCommunityDate()) + .communityTagList(communityTagTable.getCommunityId().getCommunityTagTable().stream() + .map(CommunityTagTable -> CommunityTagResponseDto.builder() + .communityTagId(CommunityTagTable.getCommunityTagId()) + .communityTag(CommunityTagTable.getCommunityTag()) + .build()) + .toList()) + .build()) + .toList(); + } + + if(!userId.isEmpty()) { + List communityTableList = communityTableRepository.findAllByUserId(userId, pageable).toList(); + return communityTableList.stream() + .map(communityTable -> CommunityResponseDto.builder() + .communityId(communityTable.getCommunityId()) + .communityTitle(communityTable.getCommunityTitle()) + .commentCount(communityTable.getCommentTable().size()) + .userNickname(communityTable.getId().getNickname()) + .communityCreatedDate(communityTable.getCommunityDate()) + .communityTagList(communityTable.getCommunityTagTable().stream() + .map(CommunityTagTable -> CommunityTagResponseDto.builder() + .communityTagId(CommunityTagTable.getCommunityTagId()) + .communityTag(CommunityTagTable.getCommunityTag()) + .build()) + .toList()) + .build()) + .toList(); + } + + return communityTableRepository.findAll(pageable).stream() + .map(communityTable -> CommunityResponseDto.builder() + .communityId(communityTable.getCommunityId()) + .communityTitle(communityTable.getCommunityTitle()) + .commentCount(communityTable.getCommentTable().size()) + .userNickname(communityTable.getId().getNickname()) + .communityCreatedDate(communityTable.getCommunityDate()) + .communityTagList(communityTable.getCommunityTagTable().stream() + .map(CommunityTagTable -> CommunityTagResponseDto.builder() + .communityTagId(CommunityTagTable.getCommunityTagId()) + .communityTag(CommunityTagTable.getCommunityTag()) + .build()) + .toList()) + .build()) + .toList(); + } catch (Exception e) { + log.error(e.getMessage()); + throw new IllegalArgumentException("글 목록 조회에 실패했습니다."); + } + } + + @Override + public void patchCommunity(CommunityPatchDto communityPatchDto) { + log.info("[CommunityServiceImpl] 글 수정 시작"); + CommunityTable communityTable = communityTableRepository.findById(communityPatchDto.getCommunityId()).orElseThrow(() -> new IllegalArgumentException("해당 글이 없습니다.")); + try{ + communityTable.setCommunityTitle(communityPatchDto.getCommunityTitle()); + communityTable.setCommunityContent(communityPatchDto.getCommunityContent()); + + for(CommunityTagPatchDto communityTagPatchDto : communityPatchDto.getCommunityTagList()) { + CommunityTagTable communityTagTable = communityTagTableRepository.findByCommunityIdAndCommunityTagId(communityTable, communityTagPatchDto.getCommunityTagId()); + if(communityTagPatchDto.getCommunityTag().isEmpty()) { + communityTagTableRepository.delete(communityTagTable); + continue; + } else { + communityTagTable.setCommunityTag(communityTagPatchDto.getCommunityTag()); + } + communityTagTableRepository.save(communityTagTable); + } + + communityTableRepository.save(communityTable); + log.info("[CommunityServiceImpl] 글 수정 성공"); + } catch (Exception e) { + log.error(e.getMessage()); + throw new IllegalArgumentException("글 수정에 실패했습니다."); + } + } + + @Override + public void deleteCommunity(String communityId) { + log.info("[CommunityServiceImpl] 글 삭제 시작"); + CommunityTable communityTable = communityTableRepository.findById(communityId).orElseThrow(() -> new IllegalArgumentException("해당 글이 없습니다.")); + try { + communityTableRepository.delete(communityTable); + } catch (Exception e) { + log.error(e.getMessage()); + throw new IllegalArgumentException("글 삭제에 실패했습니다."); + } + } + + @Override + public CommunityDetailResponseDto getCommunityDetail(String communityId) { + log.info("[CommunityServiceImpl] 글 상세 조회 시작"); + CommunityTable communityTable = communityTableRepository.findById(communityId).orElseThrow(() -> new IllegalArgumentException("해당 글이 없습니다.")); + try { + communityTable.setCommunityView(communityTable.getCommunityView() + 1); + communityTableRepository.save(communityTable); + return CommunityDetailResponseDto.builder() + .communityId(communityTable.getCommunityId()) + .communityTitle(communityTable.getCommunityTitle()) + .communityContent(communityTable.getCommunityContent()) + .communityDate(communityTable.getCommunityDate()) + .communityView(communityTable.getCommunityView()) + .userNickname(communityTable.getId().getNickname()) + .communityTagList(communityTable.getCommunityTagTable().stream() + .map(CommunityTagTable::getCommunityTag) + .toList()) + .commentList(communityTable.getCommentTable()) + .build(); + } catch (Exception e) { + log.error(e.getMessage()); + throw new IllegalArgumentException("글 상세 조회에 실패했습니다."); + } + } +} diff --git a/src/main/java/com/example/prdoit/service/content/ContentService.java b/src/main/java/com/example/prdoit/service/content/ContentService.java new file mode 100644 index 0000000..02b60cc --- /dev/null +++ b/src/main/java/com/example/prdoit/service/content/ContentService.java @@ -0,0 +1,23 @@ +package com.example.prdoit.service.content; + +import com.example.prdoit.dto.content.*; + +import java.util.List; +// +public interface ContentService { + + ContentResponseDto getContentQuery(String query, int size, int page); + + ContentResponseDto getContentQueryWithLevel(String query, int level, int size, int page); + + ContentResponseDto getContentWithUserId(String userId, String query, int level, int size, int page); + + void updateContent(ContentUpdateDto contentUpdateDto); + + void postContent(ContentRequestDto contentRequestDto); + + ContentDetailDto getContentDetail(String contentId); + + TotalContentDto getTotalContent(String userId, int size, int page); + +} diff --git a/src/main/java/com/example/prdoit/service/content/ContentServiceImpl.java b/src/main/java/com/example/prdoit/service/content/ContentServiceImpl.java new file mode 100644 index 0000000..409455f --- /dev/null +++ b/src/main/java/com/example/prdoit/service/content/ContentServiceImpl.java @@ -0,0 +1,251 @@ +package com.example.prdoit.service.content; + +import com.example.prdoit.dto.content.*; +import com.example.prdoit.exception.CustomException; +import com.example.prdoit.model.ContentTable; +import com.example.prdoit.model.IdTable; +import com.example.prdoit.repository.ContentTableRepository; +import com.example.prdoit.repository.IdTableRepository; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.data.domain.PageRequest; +import org.springframework.data.domain.Pageable; +import org.springframework.stereotype.Service; + +import javax.swing.text.AbstractDocument; +import java.util.List; +import java.util.UUID; + +@Service +@Slf4j +@RequiredArgsConstructor +public class ContentServiceImpl implements ContentService { + + private final ContentTableRepository contentRepository; + private final IdTableRepository IdTableRepository; + + @Override + public ContentResponseDto getContentQuery(String query, int size, int page){ + log.info("[getContentQuery] 쿼리 조회 로직 시작"); + List contentTableList = contentRepository.findAll(); + int offset = (page - 1) * size; + if(contentTableList.isEmpty()) { + throw new RuntimeException("등록된 컨텐츠가 없습니다."); + } + try { + if(!query.equals("all")){ + List contentTableListQuery = contentRepository.findAllByContentTitleContaining(query); + List contentTitleDtoList = contentRepository.findAllByQueryContaining(query, size, offset); + if (contentTitleDtoList.isEmpty()) { + throw new RuntimeException("검색 결과가 없습니다."); + } else { + return ContentResponseDto.builder() + .total(contentTableListQuery.size()) + .contentList(contentTitleDtoList) + .build(); + } + } else{ + List contentResponseDtoList = contentRepository.findAllList(size, offset); + if (contentResponseDtoList.isEmpty()) { + throw new RuntimeException("등록된 컨텐츠가 없습니다."); + } else { + return ContentResponseDto.builder() + .total(contentTableList.size()) + .contentList(contentResponseDtoList) + .build(); + } + } + } catch (Exception e) { + log.error("[getContentQuery] 쿼리 조회 실패"); + throw new RuntimeException("쿼리 조회에 실패했습니다."); + } + } + + @Override + public ContentResponseDto getContentQueryWithLevel(String query, int level, int size, int page){ + List contentTableList = contentRepository.findAll(); + if(contentTableList.isEmpty()) { + throw new RuntimeException("등록된 컨텐츠가 없습니다."); + } + int offset = (page - 1) * size; + try{ + if(!query.equals("all")){ + List contentTableListAll = contentRepository.findAllByQueryContainingAndContentLevel(query, level); + List contentResponseDtoList = contentRepository.findAllQueryContainingAndContentLevel(query, level, size, offset); + if(contentResponseDtoList.isEmpty()){ + throw new RuntimeException("검색 결과가 없습니다."); + } else { + return ContentResponseDto.builder() + .total(contentTableListAll.size()) + .contentList(contentResponseDtoList) + .build(); + } + } else { + List contentTableListAll = contentRepository.findAllByContentLevel(level); + List contentResponseDtoList = contentRepository.findAllByContentLevel(level, size, offset); + if(contentResponseDtoList.isEmpty()){ + throw new RuntimeException("등록된 컨텐츠가 없습니다."); + } else { + return ContentResponseDto.builder() + .total(contentTableListAll.size()) + .contentList(contentResponseDtoList) + .build(); + } + } + } catch (Exception e) { + log.error("[getContentQueryWithLevel] 쿼리 조회 실패"); + throw new RuntimeException("쿼리 조회에 실패했습니다."); + } + } + + @Override + public ContentResponseDto getContentWithUserId(String userId, String query, int level, int size, int page){ + IdTable idTable = IdTableRepository.findById(userId).orElseThrow + (() -> new RuntimeException("존재하지 않는 사용자입니다.")); + if(idTable.getContentTable().isEmpty()) { + throw new RuntimeException("등록된 컨텐츠가 없습니다."); + } + int offset = (page - 1) * size; + try{ + if(query.equals("all") && level == -1){ + List contentTableList = contentRepository.findAllByUserId(idTable); + List contentResponseDtoList = contentRepository.findAllByUserIdPagination(userId, PageRequest.of(page-1, size)).stream().toList(); + if(contentResponseDtoList.isEmpty()){ + throw new CustomException("검색 결과가 없습니다."); + } else { + return ContentResponseDto.builder() + .total(contentTableList.size()) + .contentList(contentResponseDtoList) + .build(); + } + } else if(!query.equals("all") && level == -1){ + List contentTableList = contentRepository.findAllByUserIdAndQueryContaining(idTable, query); + List contentResponseDtoList = contentRepository.findAllByUserIdAndQueryContaining(userId, query, PageRequest.of(page-1, size)).stream().toList(); + if(contentResponseDtoList.isEmpty()){ + throw new CustomException("검색 결과가 없습니다."); + } else { + return ContentResponseDto.builder() + .total(contentTableList.size()) + .contentList(contentResponseDtoList) + .build(); + } + } else if(query.equals("all")){ + List contentTableList = contentRepository.findAllByUserIdAndContentLevel(idTable, level); + List contentResponseDtoList = contentRepository.findAllByUserIdAndContentLevel(userId, level, PageRequest.of(page-1, size)).stream().toList(); + if(contentResponseDtoList.isEmpty()){ + throw new CustomException("검색 결과가 없습니다."); + } else { + return ContentResponseDto.builder() + .total(contentTableList.size()) + .contentList(contentResponseDtoList) + .build(); + } + } else { + List contentTableList = contentRepository.findAllByUserIdAndContentLevelAndQueryContaining(idTable, level, query); + List contentResponseDtoList = contentRepository.findAllByUserIdAndContentLevelAndQueryContaining(userId, level, query, PageRequest.of(page-1, size)).stream().toList(); + if(contentResponseDtoList.isEmpty()){ + throw new CustomException("검색 결과가 없습니다."); + } else { + return ContentResponseDto.builder() + .total(contentTableList.size()) + .contentList(contentResponseDtoList) + .build(); + } + } + } catch (CustomException e) { + log.error(e.getMessage()); + throw new CustomException("검색 결과가 없습니다."); + } catch (RuntimeException e) { + log.error(e.getMessage()); + throw new RuntimeException("조회 실패"); + } + } + + @Override + public void postContent(ContentRequestDto contentRequestDto){ + IdTable idTable = IdTableRepository.findById(contentRequestDto.getUserId()).orElseThrow + (() -> new RuntimeException("존재하지 않는 사용자입니다.")); + log.info("[postContent] 컨텐츠 등록 로직 시작"); + try { + ContentTable contentTable = ContentTable.builder() + .contentId(UUID.randomUUID().toString()) + .contentTitle(contentRequestDto.getContentTitle()) + .contentContent(contentRequestDto.getContentContent()) + .contentLevel(contentRequestDto.getContentLevel()) + .isVideo(contentRequestDto.getIsVideo()) + .userId(idTable) + .build(); + contentRepository.save(contentTable); + } catch (Exception e) { + log.error(e.getMessage()); + throw new RuntimeException(e.getMessage()); + } + } + + @Override + public void updateContent(ContentUpdateDto contentUpdateDto){ + log.info("[updateContent] 컨텐츠 수정 로직 시작"); + try { + ContentTable contentTable = contentRepository.findById(contentUpdateDto.getContentId()).orElseThrow + (() -> new RuntimeException("존재하지 않는 컨텐츠입니다.")); + contentTable.setContentTitle(contentUpdateDto.getContentTitle()); + contentTable.setContentContent(contentUpdateDto.getContentContent()); + contentTable.setContentLevel(contentUpdateDto.getContentLevel()); + contentTable.setIsVideo(contentUpdateDto.getIsVideo()); + contentRepository.save(contentTable); + } catch (Exception e) { + log.error(e.getMessage()); + throw new RuntimeException(e.getMessage()); + } + } + + @Override + public ContentDetailDto getContentDetail(String contentId){ + log.info("[getContentDetail] 컨텐츠 상세 조회 로직 시작"); + try { + ContentTable contentTable = contentRepository.findById(contentId).orElseThrow + (() -> new RuntimeException("존재하지 않는 컨텐츠입니다.")); + contentTable.setContentView(contentTable.getContentView() + 1); + contentRepository.save(contentTable); + return ContentDetailDto.builder() + .contentId(contentTable.getContentId()) + .contentTitle(contentTable.getContentTitle()) + .contentContent(contentTable.getContentContent()) + .contentLevel(contentTable.getContentLevel()) + .contentView(contentTable.getContentView()) + .isVideo(contentTable.getIsVideo()) + .contentLike(contentTable.getContentLike()) + .writer(contentTable.getUserId().getNickname()) + .build(); + } catch (Exception e) { + log.error(e.getMessage()); + throw new RuntimeException(e.getMessage()); + } + } + + @Override + public TotalContentDto getTotalContent(String userId, int size, int page){ + IdTable idTable = IdTableRepository.findById(userId).orElseThrow + (() -> new RuntimeException("존재하지 않는 사용자입니다.")); + if(idTable.getContentTable().isEmpty()) { + throw new RuntimeException("등록된 컨텐츠가 없습니다."); + } + Pageable pageable = PageRequest.of(page-1, size); + try{ + int totalContent = idTable.getContentTable().size(); + int totalView = idTable.getContentTable().stream().mapToInt(ContentTable::getContentView).sum(); + int totalLike = idTable.getContentTable().stream().mapToInt(ContentTable::getContentLike).sum(); + List contentResponseDtoList = contentRepository.findAllByUserIdPagination(userId, pageable).stream().toList(); + return TotalContentDto.builder() + .totalContent(totalContent) + .totalView(totalView) + .totalLike(totalLike) + .ContentList(contentResponseDtoList) + .build(); + } catch (Exception e) { + log.error(e.getMessage()); + throw new RuntimeException("쿼리 조회에 실패했습니다."); + } + } + +} diff --git a/src/main/java/com/example/prdoit/service/project/ProjectService.java b/src/main/java/com/example/prdoit/service/project/ProjectService.java index bfe9d17..4d71133 100644 --- a/src/main/java/com/example/prdoit/service/project/ProjectService.java +++ b/src/main/java/com/example/prdoit/service/project/ProjectService.java @@ -1,9 +1,11 @@ package com.example.prdoit.service.project; import com.example.prdoit.dto.project.*; -import com.example.prdoit.dto.project.backlog.*; -import com.example.prdoit.dto.project.content.ProjectContentDeleteDto; -import com.example.prdoit.dto.project.content.ProjectContentDto; +import com.example.prdoit.dto.project.backlog.BacklogAddDto; +import com.example.prdoit.dto.project.content.ContentDeleteDto; +import com.example.prdoit.dto.project.content.ContentDto; +import com.example.prdoit.dto.project.content.ContentPatchDto; +import com.example.prdoit.dto.project.content.ProjectContentResponseDto; import java.util.List; @@ -12,23 +14,15 @@ public interface ProjectService { ProjectResponseDto getProject(String projectId); - ProjectContentResponseDto getProjectContent(String projectId, int projectLevel); + ProjectContentResponseDto getProjectContent(String projectId); List getProjectList(String userId); - void createProjectContent(ProjectContentDto projectContentDto); + void createProjectContent(ContentDto contentDto); - void updateProjectContent(ProjectContentDto projectContentDto); + void patchProjectContent(ContentPatchDto contentPatchDto); - void deleteProjectContent(ProjectContentDeleteDto projectContentDeleteDto); + void deleteProjectContent(ContentDeleteDto contentDeleteDto); - void createBacklog(BacklogRequestDto backLogRequestDto); - - void updateBacklog(BacklogUpdateDto backlogUpdateDto); - - void deleteBacklog(BacklogDeleteDto backlogDeleteDto); - - void putBacklog(BacklogPutDto backlogPutDto); - - List getBacklogList(String projectId); + BacklogAddDto getBacklog(String projectId, String backlogTaskId); } diff --git a/src/main/java/com/example/prdoit/service/project/ProjectServiceImpl.java b/src/main/java/com/example/prdoit/service/project/ProjectServiceImpl.java index cf2f162..17c1ab7 100644 --- a/src/main/java/com/example/prdoit/service/project/ProjectServiceImpl.java +++ b/src/main/java/com/example/prdoit/service/project/ProjectServiceImpl.java @@ -3,8 +3,8 @@ import com.example.prdoit.config.BacklogEnum; import com.example.prdoit.dto.project.*; import com.example.prdoit.dto.project.backlog.*; -import com.example.prdoit.dto.project.content.ProjectContentDeleteDto; -import com.example.prdoit.dto.project.content.ProjectContentDto; +import com.example.prdoit.dto.project.burndown.*; +import com.example.prdoit.dto.project.content.*; import com.example.prdoit.exception.CustomException; import com.example.prdoit.model.BacklogTable; import com.example.prdoit.model.IdTable; @@ -14,14 +14,13 @@ import com.example.prdoit.repository.IdTableRepository; import com.example.prdoit.repository.ProjectLevelContentTableRepository; import com.example.prdoit.repository.ProjectTableRepository; -import io.micrometer.observation.annotation.Observed; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; -import java.util.List; -import java.util.Objects; -import java.util.UUID; +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; import static java.lang.Integer.parseInt; import static java.lang.Integer.valueOf; @@ -59,70 +58,6 @@ public String createProject(ProjectCreateDto projectCreateDto) { .build(); try{ projectTableRepository.save(projectTable); - if(projectCreateDto.getPainPoint() == 1){ - ProjectLevelContentTable projectLevelContentTable = ProjectLevelContentTable.builder() - .projectId(projectTable) - .projectLevelContent("") - .projectLevel(1) - .build(); - projectLevelContentTableRepository.save(projectLevelContentTable); - } - if(projectCreateDto.getTarget() == 1){ - ProjectLevelContentTable projectLevelContentTable = ProjectLevelContentTable.builder() - .projectId(projectTable) - .projectLevelContent("") - .projectLevel(2) - .build(); - projectLevelContentTableRepository.save(projectLevelContentTable); - } - if(projectCreateDto.getUseCase() == 1){ - ProjectLevelContentTable projectLevelContentTable = ProjectLevelContentTable.builder() - .projectId(projectTable) - .projectLevelContent("") - .projectLevel(3) - .build(); - projectLevelContentTableRepository.save(projectLevelContentTable); - } - if(projectCreateDto.getUserStory() == 1){ - ProjectLevelContentTable projectLevelContentTable = ProjectLevelContentTable.builder() - .projectId(projectTable) - .projectLevelContent("") - .projectLevel(4) - .build(); - projectLevelContentTableRepository.save(projectLevelContentTable); - } - if(projectCreateDto.getFunction() == 1){ - ProjectLevelContentTable projectLevelContentTable = ProjectLevelContentTable.builder() - .projectId(projectTable) - .projectLevelContent("") - .projectLevel(5) - .build(); - projectLevelContentTableRepository.save(projectLevelContentTable); - } - if(projectCreateDto.getTask() == 1){ - ProjectLevelContentTable projectLevelContentTable = ProjectLevelContentTable.builder() - .projectId(projectTable) - .projectLevelContent("") - .projectLevel(6) - .build(); - projectLevelContentTableRepository.save(projectLevelContentTable); - } - if(projectCreateDto.getBacklog() == 1){ - ProjectLevelContentTable projectLevelContentTable = ProjectLevelContentTable.builder() - .projectId(projectTable) - .projectLevelContent("") - .projectLevel(7) - .build(); - projectLevelContentTableRepository.save(projectLevelContentTable); - } - if(projectCreateDto.getBurndown() == 1){ - ProjectLevelContentTable projectLevelContentTable = ProjectLevelContentTable.builder() - .projectId(projectTable) - .projectLevelContent("") - .projectLevel(8) - .build(); - projectLevelContentTableRepository.save(projectLevelContentTable); - } log.info("[createProject] 프로젝트 생성 완료"); return uuid; } catch (CustomException e){ @@ -138,356 +73,363 @@ public String createProject(ProjectCreateDto projectCreateDto) { public ProjectResponseDto getProject(String projectId) { log.info("[getProject] 프로젝트 조회 시작"); ProjectTable projectTable = projectTableRepository.findById(projectId).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); - - return ProjectResponseDto.builder() - .projectId(projectTable.getProjectId()) - .projectName(projectTable.getProjectName()) - .projectIdea(projectTable.getProjectIdea()) - .projectLevel1(projectTable.getProjectLevel1()) - .projectLevel2(projectTable.getProjectLevel2()) - .projectLevel3(projectTable.getProjectLevel3()) - .projectLevel4(projectTable.getProjectLevel4()) - .projectLevel5(projectTable.getProjectLevel5()) - .projectLevel6(projectTable.getProjectLevel6()) - .projectLevel7(projectTable.getProjectLevel7()) - .projectLevel8(projectTable.getProjectLevel8()) - .build(); + try { + return projectTableRepository.findByProjectId(projectId); + } catch (CustomException e) { + log.error(e.getMessage()); + throw new CustomException(e.getMessage()); + } catch (RuntimeException e) { + log.error(e.getMessage()); + throw e; + } } @Override - public ProjectContentResponseDto getProjectContent(String projectId, int projectLevel) { + public ProjectContentResponseDto getProjectContent(String projectId) { log.info("[getProjectContent] 프로젝트 컨텐츠 조회 시작"); ProjectTable projectTable = projectTableRepository.findById(projectId).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); - ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository.findByProjectIdAndProjectLevel(projectTable, projectLevel); - return ProjectContentResponseDto.builder() - .projectContent(projectLevelContentTable.getProjectLevelContent()) - .projectLevel(projectLevelContentTable.getProjectLevel()) - .build(); + + try { + List projectLevelContentTableList = projectLevelContentTableRepository.findAllByProjectId(projectTable); + ProjectContentResponseDto projectContentResponseDto = new ProjectContentResponseDto(new ArrayList<>(), new ArrayList<>(), new ArrayList<>()); + for (ContentResponseDto contentResponseDto : projectLevelContentTableList) { + + projectContentResponseDto.getContentResponseDtoList().add(contentResponseDto); + + if(contentResponseDto.getProjectLevel() == 7){ + + ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository + .findById(contentResponseDto.getLevelContentId()) + .orElseThrow(() -> new CustomException("존재하지 않는 컨텐츠입니다.")); + + List backlogResponseDtoList = backlogTableRepository.findAllByLevelContentId(projectLevelContentTable); + projectContentResponseDto.setBacklogResponseDtoList(backlogResponseDtoList); + + } else if(contentResponseDto.getProjectLevel() == 8){ + projectContentResponseDto.setBurndownResponseDtoList(getBurnDownChart(projectId)); + } + } + return projectContentResponseDto; + } catch (CustomException e) { + log.error(e.getMessage()); + throw new CustomException(e.getMessage()); + } catch (RuntimeException e) { + log.error(e.getMessage()); + throw e; + } } @Override public List getProjectList(String userId) { log.info("[getProjectList] 프로젝트 리스트 조회 시작"); - IdTable idTable = idTableRepository.findById(userId).orElseThrow(() -> new CustomException("존재하지 않는 사용자입니다.")); - List projectTableList = projectTableRepository.findAllByUserId(idTable); - - return projectTableList.stream().map(projectTable -> ProjectResponseDto.builder() - .projectId(projectTable.getProjectId()) - .projectName(projectTable.getProjectName()) - .projectIdea(projectTable.getProjectIdea()) - .projectLevel1(projectTable.getProjectLevel1()) - .projectLevel2(projectTable.getProjectLevel2()) - .projectLevel3(projectTable.getProjectLevel3()) - .projectLevel4(projectTable.getProjectLevel4()) - .projectLevel5(projectTable.getProjectLevel5()) - .projectLevel6(projectTable.getProjectLevel6()) - .projectLevel7(projectTable.getProjectLevel7()) - .projectLevel8(projectTable.getProjectLevel8()) - .build()).toList(); + IdTable idTable = idTableRepository.findById(userId).orElseThrow + (() -> new CustomException("존재하지 않는 사용자입니다.")); + return projectTableRepository.findAllByUserId(idTable); } @Override - public void createProjectContent(ProjectContentDto projectContentDto) { + public void createProjectContent(ContentDto contentDto) { log.info("[createProjectContent] 프로젝트 컨텐츠 생성 시작"); - ProjectTable projectTable = projectTableRepository.findById(projectContentDto.getProjectId()).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); - ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository.findByProjectIdAndProjectLevel(projectTable, projectContentDto.getProjectLevel()); - if(projectLevelContentTable == null){ - throw new CustomException("존재하지 않는 프로젝트 레벨입니다."); - } - if(!Objects.equals(projectLevelContentTable.getProjectLevelContent(), "")){ - throw new CustomException("이미 컨텐츠가 생성되어 있습니다."); - } - - try{ - projectLevelContentTable.setProjectLevelContent(projectContentDto.getProjectContent()); - projectLevelContentTableRepository.save(projectLevelContentTable); - switch (projectContentDto.getProjectLevel()){ - case 1: - projectTable.setProjectLevel1(2); - break; - case 2: - projectTable.setProjectLevel2(2); - break; - case 3: - projectTable.setProjectLevel3(2); - break; - case 4: - projectTable.setProjectLevel4(2); - break; - case 5: - projectTable.setProjectLevel5(2); - break; - case 6: - projectTable.setProjectLevel6(2); - break; - case 7: - projectTable.setProjectLevel7(2); - break; - case 8: - projectTable.setProjectLevel8(2); - break; + ProjectTable projectTable = projectTableRepository.findById(contentDto.getProjectId()).orElseThrow + (() -> new CustomException("존재하지 않는 프로젝트입니다.")); + try { + ProjectLevelContentTable projectLevelContentTable = + createContent(contentDto.getProjectId(), contentDto.getProjectLevel(), contentDto.getProjectContent()); + + if(contentDto.getBacklogListDto() != null){ + projectTable.setProjectLevel7(2); + createBacklog(projectLevelContentTable, contentDto.getBacklogListDto()); + } else if(contentDto.getBurndownPostListDto() != null){ + projectTable.setProjectLevel8(2); + createBurndown(contentDto); } - projectTableRepository.save(projectTable); - } catch (CustomException e){ + } catch (CustomException e) { log.error(e.getMessage()); throw new CustomException(e.getMessage()); - } catch (RuntimeException e){ - log.error("[createProjectContent] 서버 오류"); + } catch (RuntimeException e) { + log.error(e.getMessage()); throw e; } } @Override - public void updateProjectContent(ProjectContentDto projectContentDto) { - log.info("[updateProjectContent] 프로젝트 컨텐츠 수정 시작"); - ProjectTable projectTable = projectTableRepository.findById(projectContentDto.getProjectId()).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); - ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository.findByProjectIdAndProjectLevel(projectTable, projectContentDto.getProjectLevel()); - if(projectLevelContentTable == null){ - throw new CustomException("존재하지 않는 프로젝트 레벨입니다."); - } - if(Objects.equals(projectLevelContentTable.getProjectLevelContent(), "")){ - throw new CustomException("컨텐츠가 생성되어 있지 않습니다."); - } - - try{ - projectLevelContentTable.setProjectLevelContent(projectContentDto.getProjectContent()); + public void patchProjectContent(ContentPatchDto contentPatchDto){ + log.info("[patchProjectContent] 프로젝트 컨텐츠 수정 시작"); + ProjectTable projectTable = projectTableRepository.findById(contentPatchDto.getProjectId()).orElseThrow + (() -> new CustomException("존재하지 않는 프로젝트입니다.")); + try { + ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository + .findByProjectIdAndProjectLevel(projectTable, contentPatchDto.getProjectLevel()) + .orElseThrow(() -> new CustomException("존재하지 않는 컨텐츠입니다.")); + + projectLevelContentTable.setProjectLevelContent(contentPatchDto.getProjectContent()); projectLevelContentTableRepository.save(projectLevelContentTable); - } catch (CustomException e){ + if(contentPatchDto.getBacklogPatchDtoList() != null){ + patchBacklog(contentPatchDto.getBacklogPatchDtoList()); + } else if(contentPatchDto.getBurndownPatchDtoList() != null){ + patchBurndown(contentPatchDto.getBurndownPatchDtoList()); + } + } catch (CustomException e) { log.error(e.getMessage()); throw new CustomException(e.getMessage()); - } catch (RuntimeException e){ - log.error("[updateProjectContent] 서버 오류"); + } catch (RuntimeException e) { + log.error(e.getMessage()); throw e; } } @Override - public void deleteProjectContent(ProjectContentDeleteDto projectContentDeleteDto) { + public void deleteProjectContent(ContentDeleteDto contentDeleteDto){ log.info("[deleteProjectContent] 프로젝트 컨텐츠 삭제 시작"); - - ProjectTable projectTable = projectTableRepository.findById(projectContentDeleteDto.getProjectId()).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); - ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository.findByProjectIdAndProjectLevel(projectTable, projectContentDeleteDto.getProjectLevel()); - - if(projectLevelContentTable == null){ - throw new CustomException("존재하지 않는 프로젝트 레벨입니다."); - } - - if(Objects.equals(projectLevelContentTable.getProjectLevelContent(), "")){ - throw new CustomException("컨텐츠가 생성되어 있지 않습니다."); - } - - try{ - projectLevelContentTable.setProjectLevelContent(""); - projectLevelContentTableRepository.save(projectLevelContentTable); - switch (projectContentDeleteDto.getProjectLevel()){ - case 1: - projectTable.setProjectLevel1(1); - break; - case 2: - projectTable.setProjectLevel2(1); - break; - case 3: - projectTable.setProjectLevel3(1); - break; - case 4: - projectTable.setProjectLevel4(1); - break; - case 5: - projectTable.setProjectLevel5(1); - break; - case 6: - projectTable.setProjectLevel6(1); - break; - case 7: - projectTable.setProjectLevel7(1); - break; - case 8: - projectTable.setProjectLevel8(1); - break; + ProjectTable projectTable = projectTableRepository.findById(contentDeleteDto.getProjectId()).orElseThrow + (() -> new CustomException("존재하지 않는 프로젝트입니다.")); + try { + if(contentDeleteDto.getProjectLevel() != 0) { + ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository + .findByProjectIdAndProjectLevel(projectTable, contentDeleteDto.getProjectLevel()) + .orElseThrow(() -> new CustomException("존재하지 않는 컨텐츠입니다.")); + projectLevelContentTableRepository.delete(projectLevelContentTable); } - projectTableRepository.save(projectTable); - - } catch (CustomException e){ + if(contentDeleteDto.getBacklogIdList() != null){ + for (int backlogId : contentDeleteDto.getBacklogIdList()) { + BacklogTable backlogTable = backlogTableRepository.findById(backlogId) + .orElseThrow(() -> new CustomException("존재하지 않는 백로그입니다.")); + backlogTableRepository.delete(backlogTable); + } + } + } catch (CustomException e) { log.error(e.getMessage()); throw new CustomException(e.getMessage()); - } catch (RuntimeException e){ - log.error("[deleteProjectContent] 서버 오류"); + } catch (RuntimeException e) { + log.error(e.getMessage()); throw e; } } @Override - public void createBacklog(BacklogRequestDto backLogRequestDto) { - log.info("[createBacklog] 백로그 생성 시작"); - ProjectTable projectTable = projectTableRepository.findById(backLogRequestDto.getProjectId()).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); - if(projectTable.getProjectLevel7() == 0){ - throw new CustomException("백로그를 생성할 수 없는 프로젝트입니다."); - } - ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository.findByProjectIdAndProjectLevel(projectTable, 7); - if(!Objects.equals(projectLevelContentTable.getProjectLevelContent(), "")){ - throw new CustomException("이미 백로그가 생성되어 있습니다."); - } + public BacklogAddDto getBacklog(String projectId, String backlogTaskId) { + log.info("[getBacklogList] 백로그 리스트 조회 시작"); - try{ - List backlogListDtos = backLogRequestDto.getBacklogListDto(); - for(BacklogListDto backlogListDto : backlogListDtos){ - BacklogTable backlogTable = BacklogTable.builder() - .backlogUserStory(backlogListDto.getBacklogUserStory()) - .backlogPriority(backlogListDto.getBacklogPriority()) - .backlogTask(backlogListDto.getBacklogTask()) - .backlogTaskId(backlogListDto.getBacklogTaskId()) - .backlogDescription(backlogListDto.getBacklogDescription()) - .backlogStatus(BacklogEnum.BACKLOG_TODO.getCode()) - .backlogEstimate(backlogListDto.getBacklogEstimate()) - .levelContentId(projectLevelContentTable) - .build(); - backlogTableRepository.save(backlogTable); - } - projectLevelContentTable.setProjectLevelContent(String.valueOf(backLogRequestDto.getIteration())); - projectLevelContentTableRepository.save(projectLevelContentTable); - projectTable.setProjectLevel7(2); - projectTableRepository.save(projectTable); - } catch (CustomException e){ + try { + ProjectTable projectTable = projectTableRepository.findById(projectId).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); + ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository + .findByProjectIdAndProjectLevel(projectTable, 7).orElseThrow(() -> new CustomException("존재하지 않는 컨텐츠입니다.")); + + return backlogTableRepository.findByLevelContentIdAndBacklogTaskId(projectLevelContentTable, backlogTaskId) + .orElseThrow(() -> new CustomException("존재하지 않는 백로그입니다.")); + } catch (CustomException e) { log.error(e.getMessage()); throw new CustomException(e.getMessage()); - } catch (RuntimeException e){ + } catch (RuntimeException e) { log.error(e.getMessage()); throw e; } + } - @Override - public void updateBacklog(BacklogUpdateDto backlogUpdateDto) { - log.info("[updateBacklog] 백로그 수정 시작"); - ProjectTable projectTable = projectTableRepository.findById(backlogUpdateDto.getProjectId()).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); - if(projectTable.getProjectLevel7() == 0){ - throw new CustomException("백로그를 수정할 수 없는 프로젝트입니다."); + // internal method + //ContentDto를 받아서 ProjectLevelContentTable을 생성 + public ProjectLevelContentTable createContent(String projectId, int projectLevel, String projectContent) { + log.info("[createContent] 프로젝트 컨텐츠 생성 시작"); + ProjectTable projectTable = projectTableRepository.findById(projectId).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); + switch (projectLevel) { + case 1: + projectTable.setProjectLevel1(2); + break; + case 2: + projectTable.setProjectLevel2(2); + break; + case 3: + projectTable.setProjectLevel3(2); + break; + case 4: + projectTable.setProjectLevel4(2); + break; + case 5: + projectTable.setProjectLevel5(2); + break; + case 6: + projectTable.setProjectLevel6(2); + break; + case 7: + projectTable.setProjectLevel7(2); + break; + case 8: + projectTable.setProjectLevel8(2); + break; + default: + throw new CustomException("존재하지 않는 프로젝트 레벨입니다."); } - ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository.findByProjectIdAndProjectLevel(projectTable, 7); - if (Objects.equals(projectLevelContentTable.getProjectLevelContent(), "")) { - throw new CustomException("백로그가 생성되어 있지 않습니다."); + projectTableRepository.save(projectTable); + return projectLevelContentTableRepository.findByProjectIdAndProjectLevel(projectTable, projectLevel).orElseGet(() -> { + ProjectLevelContentTable projectLevelContentTable1 = ProjectLevelContentTable.builder() + .projectLevelContent(projectContent) + .projectLevel(projectLevel) + .projectId(projectTable) + .build(); + projectLevelContentTableRepository.save(projectLevelContentTable1); + return projectLevelContentTable1; + }); + } + + //ContentDto를 받아서 번다운 차트를 생성 + public void createBurndown(ContentDto contentDto){ + log.info("[createBurndown] 번다운 차트 생성 시작"); + + ProjectTable projectTable = projectTableRepository.findById(contentDto.getProjectId()).orElseThrow + (() -> new CustomException("존재하지 않는 프로젝트입니다.")); + + if(projectTable.getProjectLevel8() == 0){ + throw new CustomException("번다운 차트를 생성할 수 없는 프로젝트입니다."); } try{ - List backlogUpdateListDtos = backlogUpdateDto.getBacklogListDto(); - for(BacklogUpdateListDto backlogListDto : backlogUpdateListDtos){ - BacklogTable backlogTable = backlogTableRepository.findByBacklogTaskIdAndLevelContentId(backlogListDto.getPostTaskId(), projectLevelContentTable).orElseThrow(() -> new CustomException("존재하지 않는 백로그입니다.")); - backlogTable.setBacklogUserStory(backlogListDto.getBacklogUserStory()); - backlogTable.setBacklogPriority(backlogListDto.getBacklogPriority()); - backlogTable.setBacklogTask(backlogListDto.getBacklogTask()); - backlogTable.setBacklogTaskId(backlogListDto.getBacklogTaskId()); - backlogTable.setBacklogDescription(backlogListDto.getBacklogDescription()); - backlogTable.setBacklogEstimate(backlogListDto.getBacklogEstimate()); + for(BurndownPostListDto burndownPostListDto : contentDto.getBurndownPostListDto()){ + BacklogTable backlogTable = backlogTableRepository.findById(burndownPostListDto.getBacklogId()) + .orElseThrow(() -> new CustomException("존재하지 않는 백로그입니다.")); + backlogTable.setBacklogIteration(burndownPostListDto.getIteration()); backlogTableRepository.save(backlogTable); } - } catch (CustomException e){ + } catch (CustomException e) { log.error(e.getMessage()); throw new CustomException(e.getMessage()); - } catch (RuntimeException e){ - log.error("[updateBacklog] 서버 오류"); + } catch (RuntimeException e) { + log.error(e.getMessage()); throw e; } } - @Override - public void deleteBacklog(BacklogDeleteDto backlogDeleteDto) { - log.info("[deleteBacklog] 백로그 삭제 시작"); - ProjectTable projectTable = projectTableRepository.findById(backlogDeleteDto.getProjectId()).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); - if(projectTable.getProjectLevel7() == 0){ - throw new CustomException("백로그를 삭제할 수 없는 프로젝트입니다."); - } - ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository.findByProjectIdAndProjectLevel(projectTable, 7); - if (Objects.equals(projectLevelContentTable.getProjectLevelContent(), "")) { - throw new CustomException("백로그가 생성되어 있지 않습니다."); - } - - try{ - List backlogTaskIdList = backlogDeleteDto.getBacklogTaskIdList(); - for(String taskId : backlogTaskIdList){ - BacklogTable backlogTable = backlogTableRepository.findByBacklogTaskIdAndLevelContentId(taskId, projectLevelContentTable).orElseThrow(() -> new CustomException("존재하지 않는 백로그입니다.")); - backlogTableRepository.delete(backlogTable); + //ContentDto를 받아서 백로그를 생성 + public void createBacklog(ProjectLevelContentTable projectLevelContentTable, List backlogListDto){ + log.info("[createBacklog] 백로그 생성 시작"); + try { + List backlogResponseDtoList = backlogTableRepository.findAllByLevelContentId(projectLevelContentTable); + List localBacklogListDto = new ArrayList<>(); + if(backlogResponseDtoList.isEmpty()){ + localBacklogListDto = backlogListDto; } - List backlogTableList = backlogTableRepository.findAllByLevelContentId(projectLevelContentTable); - if(backlogTableList.isEmpty()){ - projectLevelContentTable.setProjectLevelContent(""); - projectLevelContentTableRepository.save(projectLevelContentTable); - projectTable.setProjectLevel7(1); - projectTableRepository.save(projectTable); + else { + for (BacklogListDto backlogListDto1 : backlogListDto) { + boolean isExist = false; + for (BacklogResponseDto backlogResponseDto : backlogResponseDtoList) { + if (backlogResponseDto.getBacklogTaskId().equals(backlogListDto1.getBacklogTaskId())) { + isExist = true; + break; + } + } + if (!isExist) { + localBacklogListDto.add(backlogListDto1); + } + } } - } catch (CustomException e){ + + List backlogTableList = localBacklogListDto.stream().map(backlogListDto1 -> BacklogTable.builder() + .levelContentId(projectLevelContentTable) + .backlogUserStory(backlogListDto1.getBacklogUserStory()) + .backlogPriority(backlogListDto1.getBacklogPriority()) + .backlogTask(backlogListDto1.getBacklogTask()) + .backlogDescription(backlogListDto1.getBacklogDescription()) + .backlogStatus(BacklogEnum.BACKLOG_NOT_YET.getCode()) + .backlogWorker(backlogListDto1.getBacklogWorker()) + .backlogTaskId(backlogListDto1.getBacklogTaskId()) + .backlogEstimate(backlogListDto1.getBacklogEstimate()) + .build()).collect(Collectors.toList()); + + backlogTableRepository.saveAll(backlogTableList); + } catch (CustomException e) { log.error(e.getMessage()); throw new CustomException(e.getMessage()); - } catch (RuntimeException e){ - log.error("[deleteBacklog] 서버 오류"); + } catch (RuntimeException e) { + log.error(e.getMessage()); throw e; } } - @Override - public void putBacklog(BacklogPutDto backlogPutDto) { - log.info("[putBacklog] 백로그 이동 시작"); - ProjectTable projectTable = projectTableRepository.findById(backlogPutDto.getProjectId()).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); - if(projectTable.getProjectLevel7() == 0){ - throw new CustomException("백로그를 이동할 수 없는 프로젝트입니다."); - } - ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository.findByProjectIdAndProjectLevel(projectTable, 7); - if (Objects.equals(projectLevelContentTable.getProjectLevelContent(), "")) { - throw new CustomException("백로그가 생성되어 있지 않습니다."); + //projectId를 받아서 번다운 차트를 조회 + public List getBurnDownChart(String projectId) { + log.info("[getBurnDownChart] 번다운 차트 조회 시작"); + + List burndownResponseDtoList = new ArrayList<>(); + ProjectTable projectTable = projectTableRepository.findById(projectId).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); + + if (projectTable.getProjectLevel8() == 0) { + throw new CustomException("번다운 차트를 조회할 수 없는 프로젝트입니다."); } - try{ - List backlogListDtos = backlogPutDto.getBacklogPutListDto(); - for(BacklogPutListDto backlogListDto : backlogListDtos){ - BacklogTable backlogtable = BacklogTable.builder() - .backlogEstimate(backlogListDto.getBacklogEstimate()) - .backlogDescription(backlogListDto.getBacklogDescription()) - .backlogTaskId(backlogListDto.getBacklogTaskId()) - .backlogTask(backlogListDto.getBacklogTask()) - .backlogPriority(backlogListDto.getBacklogPriority()) - .backlogUserStory(backlogListDto.getBacklogUserStory()) - .backlogStatus(BacklogEnum.BACKLOG_TODO.getCode()) - .levelContentId(projectLevelContentTable) + ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository. + findByProjectIdAndProjectLevel(projectTable, 7).orElseThrow(() -> new CustomException("번다운 차트가 생성되어있지 않습니다.")); + + try { + for ( int i = 1 ; i <= parseInt(projectLevelContentTable.getProjectLevelContent()) ; i++){ + List backlogTableList = backlogTableRepository.findAllByLevelContentIdAndBacklogIteration(projectLevelContentTable, i); + if(backlogTableList.isEmpty()){ + continue; + } + BurndownResponseDto burndownResponseDto = BurndownResponseDto.builder() + .iteration(i) + .burndownListDto(backlogTableList) .build(); - backlogTableRepository.save(backlogtable); + burndownResponseDtoList.add(burndownResponseDto); } - } catch (CustomException e){ + return burndownResponseDtoList; + } catch (CustomException e) { log.error(e.getMessage()); throw new CustomException(e.getMessage()); - } catch (RuntimeException e){ - log.error("[putBacklog] 서버 오류"); + } catch (RuntimeException e) { + log.error(e.getMessage()); throw e; } } - @Override - public List getBacklogList(String projectId) { - log.info("[getBacklogList] 백로그 리스트 조회 시작"); - ProjectTable projectTable = projectTableRepository.findById(projectId).orElseThrow(() -> new CustomException("존재하지 않는 프로젝트입니다.")); - if (projectTable.getProjectLevel7() == 0) { - throw new CustomException("백로그를 조회할 수 없는 프로젝트입니다."); - } - ProjectLevelContentTable projectLevelContentTable = projectLevelContentTableRepository.findByProjectIdAndProjectLevel(projectTable, 7); - if (Objects.equals(projectLevelContentTable.getProjectLevelContent(), "")) { - throw new CustomException("백로그가 생성되어 있지 않습니다."); + //ContentDto를 받아서 백로그를 수정 + public void patchBacklog(List backlogPatchDtoList){ + log.info("[patchBacklog] 백로그 수정 시작"); + try { + for (BacklogPatchDto backlogPatchDto : backlogPatchDtoList) { + BacklogTable backlogTable = backlogTableRepository.findById(backlogPatchDto.getBacklogId()) + .orElseThrow(() -> new CustomException("존재하지 않는 백로그입니다.")); + backlogTable.setBacklogUserStory(backlogPatchDto.getBacklogUserStory()); + backlogTable.setBacklogPriority(backlogPatchDto.getBacklogPriority()); + backlogTable.setBacklogTask(backlogPatchDto.getBacklogTask()); + backlogTable.setBacklogDescription(backlogPatchDto.getBacklogDescription()); + backlogTable.setBacklogWorker(backlogPatchDto.getBacklogWorker()); + backlogTable.setBacklogTaskId(backlogPatchDto.getBacklogTaskId()); + backlogTable.setBacklogEstimate(backlogPatchDto.getBacklogEstimate()); + backlogTableRepository.save(backlogTable); + } + } catch (CustomException e) { + log.error(e.getMessage()); + throw new CustomException(e.getMessage()); + } catch (RuntimeException e) { + log.error(e.getMessage()); + throw e; } - try{ - List backlogTableList = backlogTableRepository.findAllByLevelContentId(projectLevelContentTable); - return backlogTableList.stream().map(backlogTable -> BacklogResponseDto.builder() - .backlogUserStory(backlogTable.getBacklogUserStory()) - .backlogPriority(backlogTable.getBacklogPriority()) - .backlogTask(backlogTable.getBacklogTask()) - .backlogDescription(backlogTable.getBacklogDescription()) - .backlogStatus(BacklogEnum.getBacklogEnum(backlogTable.getBacklogStatus()).getDescription()) - .backlogWorker(backlogTable.getBacklogWorker()) - .backlogTaskId(backlogTable.getBacklogTaskId()) - .backlogEstimate(backlogTable.getBacklogEstimate()) - .build()).toList(); - } catch (CustomException e){ + } + + //ContentDto를 받아서 번다운 차트를 수정 + public void patchBurndown(List burndownPatchDtoList){ + log.info("[patchBurndown] 번다운 차트 수정 시작"); + try { + for (BurndownPatchDto burndownPatchDto : burndownPatchDtoList) { + for(BurndownDto burndownDto : burndownPatchDto.getBurndownDtoList()){ + BacklogTable backlogTable = backlogTableRepository.findById(burndownDto.getBacklogId()) + .orElseThrow(() -> new CustomException("존재하지 않는 백로그입니다.")); + backlogTable.setBacklogIteration(burndownPatchDto.getIteration()); + backlogTable.setBacklogEndDate(burndownDto.getBacklogEndDate()); + backlogTable.setBacklogEndTime(burndownDto.getBacklogEndTime()); + backlogTable.setBacklogIteration(burndownPatchDto.getIteration()); + backlogTable.setBacklogWorker(burndownDto.getBacklogWorker()); + backlogTable.setBacklogStatus(burndownDto.getBacklogStatus()); + backlogTableRepository.save(backlogTable); + } + } + } catch (CustomException e) { log.error(e.getMessage()); throw new CustomException(e.getMessage()); - } catch (RuntimeException e){ - log.error("[getBacklogList] 서버 오류"); + } catch (RuntimeException e) { + log.error(e.getMessage()); throw e; } } + } diff --git a/src/main/java/com/example/prdoit/service/survey/SurveyServiceImpl.java b/src/main/java/com/example/prdoit/service/survey/SurveyServiceImpl.java index bb35ee9..a5f6d3b 100644 --- a/src/main/java/com/example/prdoit/service/survey/SurveyServiceImpl.java +++ b/src/main/java/com/example/prdoit/service/survey/SurveyServiceImpl.java @@ -11,7 +11,6 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; -import java.util.Optional; @@ -28,12 +27,15 @@ public class SurveyServiceImpl implements SurveyService { public void saveSurvey(SurveyDto surveyDto) { log.info("[saveSurvey] 설문조사 저장 로직 시작"); + // DB 사용자 조회 IdTable idTable = idTableRepository.findById(surveyDto.getId()) .orElseThrow(() -> new CustomException("사용자를 찾을 수 없습니다.")); + // 기존 설문조사 존재 여부 확인 - Optional existingSurvey = surveyTableRepository.findById(idTable); - if(existingSurvey.isPresent()) { - log.error("[saveSurvey] 이미 설문조사가 존재함"); + SurveyTable existingSurvey = surveyTableRepository.findByIdId(surveyDto.getId()); + + if(existingSurvey!=null) { + log.info("[saveSurvey] 이미 설문조사가 존재함"); throw new CustomException("이미 설문조사가 존재합니다."); } @@ -58,61 +60,45 @@ public void saveSurvey(SurveyDto surveyDto) { public SurveyDto getSurvey(String id) { log.info("[getSurvey] 설문조사 조회 로직 시작"); - // IdTable 먼저 찾기 - IdTable idTable = idTableRepository.findById(id) - .orElseThrow(() -> new CustomException("사용자를 찾을 수 없습니다.")); - // SurveyTable 찾기 - SurveyTable survey = surveyTableRepository.findById(idTable) - .orElseThrow(() -> { - log.error("[getSurvey] 설문조사를 찾을 수 없음"); - return new CustomException("설문조사 정보를 찾을 수 없습니다."); - }); + SurveyTable survey = surveyTableRepository.findByIdId(id); + if(survey == null) { + log.error("[getSurvey] 설문조사를 찾을 수 없음"); + throw new CustomException("설문조사 정보를 찾을 수 없습니다."); + } - return convertToDto(survey); + return SurveyDto.builder() + .surveyNum1(survey.getSurveyNum1()) + .surveyNum2(survey.getSurveyNum2()) + .surveyNum3(survey.getSurveyNum3()) + .surveyNum4(survey.getSurveyNum4()) + .id(survey.getId().getId()) + .build(); } - @Override public void updateSurvey(SurveyDto surveyDto) { log.info("[updateSurvey] 설문조사 수정 로직 시작"); - // DTO에서 ID를 가져와서 IdTable 객체 조회 - IdTable idTable = idTableRepository.findById(surveyDto.getId()) - .orElseThrow(() -> { - log.error("[updateSurvey] IdTable 조회 실패"); - return new CustomException("사용자를 찾을 수 없습니다."); - }); - - // IdTable을 사용하여 SurveyTable 조회 - SurveyTable survey = surveyTableRepository.findById(idTable) - .orElseThrow(() -> { - log.error("[updateSurvey] 수정할 설문조사를 찾을 수 없음"); - return new CustomException("수정할 설문조사를 찾을 수 없습니다."); - }); + SurveyTable survey = surveyTableRepository.findByIdId(surveyDto.getId()); + + if(survey == null) { + log.error("[getSurvey] 설문조사를 찾을 수 없음"); + throw new CustomException("설문조사 정보를 찾을 수 없습니다."); + } try { - // 직접 필드 값을 변경 (엔터티 내 메서드 없이) survey.setSurveyNum1(surveyDto.getSurveyNum1()); survey.setSurveyNum2(surveyDto.getSurveyNum2()); survey.setSurveyNum3(surveyDto.getSurveyNum3()); survey.setSurveyNum4(surveyDto.getSurveyNum4()); - // JPA의 변경 감지(Dirty Checking)로 자동 업데이트 + surveyTableRepository.save(survey); + log.info("[updateSurvey] 설문조사 수정 성공"); } catch (Exception e) { log.error("[updateSurvey] 데이터베이스 접근 오류", e); throw new CustomException("데이터베이스 접근 중 오류가 발생했습니다."); } } - - private SurveyDto convertToDto(SurveyTable survey) { - return SurveyDto.builder() - .surveyNum1(survey.getSurveyNum1()) - .surveyNum2(survey.getSurveyNum2()) - .surveyNum3(survey.getSurveyNum3()) - .surveyNum4(survey.getSurveyNum4()) - .id(survey.getId().getId()) - .build(); - } } \ No newline at end of file diff --git a/src/main/java/com/example/prdoit/service/user/UserService.java b/src/main/java/com/example/prdoit/service/user/UserService.java index f57b1ab..39c3793 100644 --- a/src/main/java/com/example/prdoit/service/user/UserService.java +++ b/src/main/java/com/example/prdoit/service/user/UserService.java @@ -12,6 +12,14 @@ public interface UserService { void checkNickname(String nickname); - void signIn(String userId, String password); + void login(String userId, String password); + + String findId(String email); + + void checkIdAndEmail(String userId, String email); + + void changePassword(String userId, String password); + + void checkPassword(String userId, String password); } diff --git a/src/main/java/com/example/prdoit/service/user/UserServiceImpl.java b/src/main/java/com/example/prdoit/service/user/UserServiceImpl.java index 7495f23..6efdd20 100644 --- a/src/main/java/com/example/prdoit/service/user/UserServiceImpl.java +++ b/src/main/java/com/example/prdoit/service/user/UserServiceImpl.java @@ -65,7 +65,7 @@ public void checkId(String userId) { public void checkEmail(String email) { log.info("[checkEmail] 이메일 중복 확인 로직 시작"); - IdTable findUser = idTableRepository.findByEmail(email); + IdTable findUser = idTableRepository.findByEmail(email).orElseGet(() -> null); if(findUser != null){ log.info("[checkEmail] 이메일 중복"); @@ -87,15 +87,84 @@ public void checkNickname(String nickname) { } @Override - public void signIn(String userId, String password){ - log.info("[signIn] 로그인 로직 시작"); + public void login(String userId, String password) { + log.info("[login] 로그인 시도 - ID: {}", userId); - IdTable findUser = idTableRepository.findById(userId).orElseThrow(() -> new CustomException("존재하지 않는 아이디입니다.")); + Optional findUser = idTableRepository.findById(userId); - if(!passwordEncoder.matches(password, findUser.getPassword())){ - log.info("[signIn] 비밀번호 불일치"); - throw new CustomException("비밀번호가 일치하지 않습니다."); + if (findUser.isEmpty()) { + log.info("[login] 아이디 없음"); + throw new CustomException("아이디 또는 비밀번호가 잘못되었습니다."); + } + + IdTable user = findUser.get(); + + // 비밀번호 맞나 안맞나 + if (!passwordEncoder.matches(password, user.getPassword())) { + log.info("[login] 비밀번호 불일치"); + throw new CustomException("아이디 또는 비밀번호가 잘못되었습니다."); } + + log.info("[login] 로그인 성공 - ID: {}", userId); } + @Override + public String findId(String email){ + IdTable idTable = idTableRepository.findByEmail(email).orElseThrow(() -> new CustomException("해당 이메일로 가입된 아이디가 없습니다.")); + try{ + return idTable.getId(); + } catch (Exception e){ + log.info(e.getMessage()); + throw new CustomException(e.getMessage()); + } + } + + @Override + public void checkIdAndEmail(String userId, String email) { + log.info("[checkIdAndEmail] 아이디와 이메일 확인 로직 시작"); + + try { + IdTable idTable = idTableRepository.findById(userId).orElseThrow(() -> new CustomException("해당 아이디로 가입된 정보가 없습니다.")); + if(!idTable.getEmail().equals(email)){ + throw new CustomException("해당 아이디와 이메일로 가입된 정보가 없습니다."); + } + } catch (CustomException e){ + log.info(e.getMessage()); + throw new CustomException("해당 아이디와 이메일로 가입된 정보가 없습니다."); + } catch (Exception e){ + log.info(e.getMessage()); + throw new CustomException(e.getMessage()); + } + } + + @Override + public void changePassword(String userId, String password) { + log.info("[changePassword] 비밀번호 변경 로직 시작"); + + IdTable idTable = idTableRepository.findById(userId).orElseThrow(() -> new CustomException("해당 아이디로 가입된 정보가 없습니다.")); + try{ + idTable.setPassword(passwordEncoder.encode(password)); + idTableRepository.save(idTable); + } catch (Exception e){ + log.info(e.getMessage()); + throw new CustomException(e.getMessage()); + } + } + + @Override + public void checkPassword(String userId, String password){ + log.info("[checkPassword] 비밀번호 확인 로직 시작"); + try { + IdTable idTable = idTableRepository.findById(userId).orElseThrow(() -> new CustomException("해당 아이디로 가입된 정보가 없습니다.")); + if (!passwordEncoder.matches(password, idTable.getPassword())) { + throw new CustomException("비밀번호가 일치하지 않습니다."); + } + } catch (CustomException e){ + log.info(e.getMessage()); + throw new CustomException("비밀번호가 일치하지 않습니다."); + } catch (Exception e){ + log.info(e.getMessage()); + throw new CustomException(e.getMessage()); + } + } }