Seong Ui-Je


게시판 기능 심화

Q1) 게시판타입을 추가하는 API를 작성해 보세요

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

동일한 게시판 제목이 있는 경우 
 - status:200
 - result:false
 - message: 이미 동일한 게시판이 존재합니다
게시판 이름은 필수항목

public interface BoardService {
    ServiceResult addBoard(BoardTypeInput boardTypeInput);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardTypeRepository boardTypeRepository;

    @Override
    public ServiceResult addBoard(BoardTypeInput boardTypeInput) {
        BoardType boardType = boardTypeRepository.findByBoardName(boardTypeInput.getName());
        if (boardType != null && boardTypeInput.getName().equals(boardType.getBoardName())) {
            return ServiceResult.fail("이미 동일한 게시판이 존재합니다.");
        }
        BoardType addBoardType = BoardType.builder()
                .boardName(boardTypeInput.getName())
                .regDate(LocalDateTime.now())
                .build();
        boardTypeRepository.save(addBoardType);

        return ServiceResult.success();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;

    @PostMapping("/api/board/type")
    public ResponseEntity<?> addBoardType(@RequestBody @Valid BoardTypeInput boardTypeInput, Errors errors) {
        if (errors.hasErrors()) {
            List<ResponseError> responseErrors = ResponseError.of(errors.getAllErrors());
            return new ResponseEntity<>(
                    ResponseMessage.fail("입력값이 정확하지 않습니다", responseErrors), HttpStatus.BAD_REQUEST);
        }

        ServiceResult result = boardService.addBoard(boardTypeInput);
        if(!result.isResult()){
            return ResponseEntity.ok().body(ResponseMessage.fail(result.getMessage()));
        }

        return ResponseEntity.ok().build();
    }
}

Q2) 게시판타입명을 수정하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

게시판명이 동일할 경우 "수정할 이름이 동일한 게시판명 입니다." 리턴

public interface BoardService {
    ServiceResult updateBoard(Long id,BoardTypeInput boardTypeInput);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardTypeRepository boardTypeRepository;
    
    @Override
    public ServiceResult updateBoard(Long id, BoardTypeInput boardTypeInput) {
        Optional<BoardType> optionalBoardType = boardTypeRepository.findById(id);
        if (optionalBoardType.isEmpty()) {
            return ServiceResult.fail("수정할 게시판이 없습니다.");
        }

        BoardType boardType = optionalBoardType.get();

        if(boardType.getBoardName().equals(boardTypeInput.getName())){
            return ServiceResult.fail("수정할 이름이 동일한 게시판명 입니다.");
        }

        boardType.setBoardName(boardTypeInput.getName());
        boardType.setUpdateDate(LocalDateTime.now());
        boardTypeRepository.save(boardType);

        return ServiceResult.success();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;
 
    @PutMapping("/api/board/type/{id}")
    public ResponseEntity<?> updateBoardType(@PathVariable Long id, @RequestBody @Valid BoardTypeInput boardTypeInput, Errors errors) {
        if (errors.hasErrors()) {
            List<ResponseError> responseErrors = ResponseError.of(errors.getAllErrors());
            return new ResponseEntity<>(
                    ResponseMessage.fail("입력값이 정확하지 않습니다", responseErrors), HttpStatus.BAD_REQUEST);
        }

        ServiceResult result = boardService.updateBoard(id, boardTypeInput);
        if (!result.isResult()) {
            return ResponseEntity.ok().body(ResponseMessage.fail(result.getMessage()));
        }

        return ResponseEntity.ok().build();
    }
}

Q3) 게시판타입을 삭제하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

삭제시 게시글이 있다면 삭제 불가

public interface BoardService {
    ServiceResult deleteBoard(Long id);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardTypeRepository boardTypeRepository;
    private final BoardRepository boardRepository;
    
    @Override
    public ServiceResult deleteBoard(Long id) {
        Optional<BoardType> optionalBoardType = boardTypeRepository.findById(id);

        if (optionalBoardType.isEmpty()) {
            return ServiceResult.fail("삭제할 게시판타입이 없습니다.");
        }

        BoardType boardType = optionalBoardType.get();

        if (boardRepository.countByBoardType(boardType) > 0) {
            return ServiceResult.fail("삭제할 게시판타입의 게시글이 존재합니다.");
        }
        boardTypeRepository.delete(boardType);
        return ServiceResult.success();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;
    
    @DeleteMapping("/api/board/type/{id}")
    public ResponseEntity<?> deleteBoardType(@PathVariable Long id) {
        ServiceResult result = boardService.deleteBoard(id);
        if (!result.isResult()) {
            return ResponseEntity.ok().body(ResponseMessage.fail(result.getMessage()));
        }

        return ResponseEntity.ok().body(ResponseMessage.success());
    }
}

Q4) 게시판타입의 목록을 리턴하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public interface BoardService {
    List<BoardType> getAllBoardType();
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardTypeRepository boardTypeRepository;
    
    @Override
    public List<BoardType> getAllBoardType() {
        return boardTypeRepository.findAll();
    }
}


@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;
    
    @GetMapping("/api/board/type")
    public ResponseEntity<?> boardType() {
        List<BoardType> boardTypeList = boardService.getAllBoardType();
        return ResponseEntity.ok().body(ResponseMessage.success(boardTypeList));
    }
}

Q5) 게시판타입의 사용여부를 설정하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

public interface BoardService {
    ServiceResult setBoardTypeUsing(Long id, BoardTypeUsing boardTypeUsing);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardTypeRepository boardTypeRepository;
    
    @Override
    public ServiceResult setBoardTypeUsing(Long id, BoardTypeUsing boardTypeUsing) {
        Optional<BoardType> optionalBoardType = boardTypeRepository.findById(id);
        if (optionalBoardType.isEmpty()) {
            return ServiceResult.fail("삭제할 게시판이 없습니다.");
        }

        BoardType boardType = optionalBoardType.get();

        boardType.setUsingYn(boardTypeUsing.isUsingYn());
        boardTypeRepository.save(boardType);

        return ServiceResult.success();
    }
}


@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;
    
    @PatchMapping("/api/board/type/{id}/using")
    public ResponseEntity<?> usingBoardType(@PathVariable Long id, @RequestBody BoardTypeUsing boardTypeUsing) {
        ServiceResult result = boardService.setBoardTypeUsing(id, boardTypeUsing);
        if (!result.isResult()) {
            return ResponseEntity.ok().body(ResponseMessage.fail(result.getMessage()));
        }
        return ResponseEntity.ok().body(ResponseMessage.success());
    }
}

Q6) 게시판별 작성된 게시글의 개수를 리턴하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

현재 사용가능한 게시판에 대해서 게시글의 개수를 리턴

public interface BoardService {
    List<BoardTypeCount> getBoardTypeCount();
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardTypeCustomRepository boardTypeCustomRepository;
    
    @Override
    public List<BoardTypeCount> getBoardTypeCount() {
        return boardTypeCustomRepository.getBoardTypeCount();
    } 
}

@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;
    
    @GetMapping("/api/board/type/count")
    public ResponseEntity<?> boardTypeCount() {
        List<BoardTypeCount> list = boardService.getBoardTypeCount();
        return ResponseEntity.ok().body(list);
    }
}

Q7) 게시판 게시글을 최상단에 배치 또는 최상단에서 글을 내리는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

public interface BoardService {
    ServiceResult setBoardTop(Long id, boolean topYn);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardTypeRepository boardTypeRepository;
    private final BoardTypeCustomRepository boardTypeCustomRepository;
    private final BoardRepository boardRepository;
    
    @Override
    public ServiceResult setBoardTop(Long id, boolean topYn) {
        Optional<Board> optionalBoard = boardRepository.findById(id);
        if (optionalBoard.isEmpty()) {
            return ServiceResult.fail("게시글이 존재하지 않습니다.");
        }
        Board board = optionalBoard.get();
        if (board.isTopYn() == topYn) {
            if (topYn) {
                return ServiceResult.fail("이미 게시글이 최상단에 배치되어 있습니다.");
            } else {
                return ServiceResult.fail("이미 게시글이 최상단에 배치가 해제되어 있습니다.");
            }
        }

        board.setTopYn(true);
        boardRepository.save(board);
        return ServiceResult.success();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;
    
    @PatchMapping("/api/board/{id}/top")
    public ResponseEntity<?> boardPostTop(@PathVariable Long id) {
        return ResponseEntity.ok().body(boardService.setBoardTop(id, true));
    }
    
    @PatchMapping("/api/board/{id}/top/clear")
    public ResponseEntity<?> boardPostTopClear(@PathVariable Long id) {
        return ResponseEntity.ok().body(boardService.setBoardTop(id, false));
    }
}

Q8) 게시글의 게시기간을 시작일과 종료일로 설정하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public interface BoardService {
    ServiceResult setBoardPeriod(Long id, BoardPeriod boardPeriod);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardRepository boardRepository;
    
    @Override
    public ServiceResult setBoardPeriod(Long id, BoardPeriod boardPeriod) {
        Optional<Board> optionalBoard = boardRepository.findById(id);
        if (optionalBoard.isEmpty()) {
            return ServiceResult.fail("게시글이 존재하지 않습니다.");
        }
        
        Board board = optionalBoard.get();
        board.setPublishStartDate(boardPeriod.getStartDate());
        board.setPublishEndDate(boardPeriod.getEndDate());
        boardRepository.save(board);
        return ServiceResult.success();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;
    
    ServiceResult result = boardService.setBoardPeriod(id, boardPeriod);
        if (!result.isResult()) {
            return ResponseResult.fail(result.getMessage());
        }
        return ResponseResult.success();
}

Q9) 게시글의 조회수를 증가시키는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

동일 사용자 게시글 조회수 증가 방지에 대한 로직 구현 (JWT 인증을 통과한 사용자에 대해서 진행)

public interface BoardService {
    ServiceResult setBoardHits(Long id, String email);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardTypeRepository boardTypeRepository;
    private final BoardTypeCustomRepository boardTypeCustomRepository;
    private final BoardRepository boardRepository;
    private final BoardHitsRepository boardHitsRepository;
    private final MemberRepository memberRepository;
}

@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;
    
    @PatchMapping("/api/board/{id}/hits")
    public ResponseEntity<?> boardHits(@PathVariable Long id,
                                       @RequestHeader("Z-TOKEN") String token) {
        String email = "";
        try {
            email = JWTUtils.getIssuer(token);
        } catch (JWTVerificationException e) {
            return ResponseResult.fail("토큰 정보가 정확하지 않습니다.");
        }

        ServiceResult result = boardService.setBoardHits(id, email);
        if (result.isFail()) {
            return ResponseResult.fail(result.getMessage());
        }
        return ResponseResult.success();
    }
}

Q10) 게시글에 대한 좋아요 기능을 수행하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

public interface BoardService {
    ServiceResult setBoardLike(Long id, String email);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardRepository boardRepository;
    private final BoardLikeRepository boardLikeRepository;
    private final MemberRepository memberRepository;

    @Override
    public ServiceResult setBoardLike(Long id, String email) {
        Optional<Board> optionalBoard = boardRepository.findById(id);
        if (optionalBoard.isEmpty()) {
            return ServiceResult.fail("게시글이 존재하지 않습니다.");
        }
        Board board = optionalBoard.get();

        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            return ServiceResult.fail("회원 정보가 존재하지 않습니다.");
        }
        Member member = optionalMember.get();

        Long boardLikeCount = boardLikeRepository.countByBoardAndMember(board, member);
        if (boardLikeCount > 0) {
            return ServiceResult.fail("이미 좋아요한 내용이 있습니다.");
        }
        boardLikeRepository.save(BoardLike.builder()
                .board(board)
                .member(member)
                .regDate(LocalDateTime.now()).build());
        return ServiceResult.success();
    } 
}

@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;

    @PutMapping("/api/board/{id}/like")
    public ResponseEntity<?> boardLike(@PathVariable Long id,
                                       @RequestHeader("Z-TOKEN") String token) {
        String email = "";
        try {
            email = JWTUtils.getIssuer(token);
        } catch (JWTVerificationException e) {
            return ResponseResult.fail("토큰 정보가 정확하지 않습니다.");
        }
        ServiceResult result = boardService.setBoardLike(id, email);
        return ResponseResult.result(result);
    }
}

Q11) 게시글의 좋아요한 내용을 취소하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

public interface BoardService {
    ServiceResult setBoardUnLike(Long id, String email);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardRepository boardRepository;
    private final BoardLikeRepository boardLikeRepository;
    private final MemberRepository memberRepository;

    @Override
    public ServiceResult setBoardUnLike(Long id, String email) {
        Optional<Board> optionalBoard = boardRepository.findById(id);
        if (optionalBoard.isEmpty()) {
            return ServiceResult.fail("게시글이 존재하지 않습니다.");
        }
        Board board = optionalBoard.get();

        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            return ServiceResult.fail("회원 정보가 존재하지 않습니다.");
        }
        Member member = optionalMember.get();

        Optional<BoardLike> optionalBoardLike = boardLikeRepository.findByBoardAndMember(board, member);
        if (optionalBoardLike.isEmpty()) {
            return ServiceResult.fail("좋아요한 내용이 없습니다.");
        }
        BoardLike boardLike = optionalBoardLike.get();
        boardLikeRepository.delete(boardLike);
        return ServiceResult.success();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;
    
    @PutMapping("/api/board/{id}/unlike")
    public ResponseEntity<?> boardUnLike(@PathVariable Long id,
                                       @RequestHeader("Z-TOKEN") String token) {
        String email = "";
        try {
            email = JWTUtils.getIssuer(token);
        } catch (JWTVerificationException e) {
            return ResponseResult.fail("토큰 정보가 정확하지 않습니다.");
        }
        ServiceResult result = boardService.setBoardUnLike(id, email);
        return ResponseResult.result(result);
    }
}

Q12) 게시된 게시글에 대해서 문제가 있는 게시글을 신고하는 기능의 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

public interface BoardService {
    ServiceResult addBadReport(Long id, String email, BoardBadReportInput boardBadReportInput);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardRepository boardRepository;
    private final MemberRepository memberRepository;
    private final BoardBadReportRepository boardBadReportRepository;

    @Override
    public ServiceResult addBadReport(Long id, String email, BoardBadReportInput boardBadReportInput) {
        Optional<Board> optionalBoard = boardRepository.findById(id);
        if (optionalBoard.isEmpty()) {
            return ServiceResult.fail("게시글이 존재하지 않습니다.");
        }
        Board board = optionalBoard.get();

        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            return ServiceResult.fail("회원 정보가 존재하지 않습니다.");
        }
        Member member = optionalMember.get();

        boardBadReportRepository.save(BoardBadReport.builder()
                .memberId(member.getId())
                .memberName(member.getMemberName())
                .memberEmail(member.getEmail())
                .boardId(board.getId())
                .boardTitle(board.getTitle())
                .boardContents(board.getContents())
                .boardContents(board.getContents())
                .boardRegDate(board.getRegDate())
                .comments(boardBadReportInput.getComments())
                .regDate(LocalDateTime.now())
                .build());
        
        return ServiceResult.success();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiBoardController {
    private final BoardService boardService;

    @PutMapping("/api/board/{id}/badreport")
    public ResponseEntity<?> boardBadRepost(@PathVariable Long id,
                                            @RequestHeader("Z-TOKEN") String token,
                                            @RequestBody BoardBadReportInput boardBadReportInput) {

        String email = "";
        try {
            email = JWTUtils.getIssuer(token);
        } catch (JWTVerificationException e) {
            return ResponseResult.fail("토큰 정보가 정확하지 않습니다.");
        }

        ServiceResult result = boardService.addBadReport(id, email, boardBadReportInput);
        return ResponseResult.result(result);
    }
}

관리자 기능

Q1) 게시글의 신고하기 목록을 조회하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public interface BoardService {
    List<BoardBadReport> badReportList();
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardBadReportRepository boardBadReportRepository;

    @Override
    public List<BoardBadReport> badReportList() {
        return boardBadReportRepository.findAll();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiAdminBoardController {
    private final BoardService boardService;
    
    @GetMapping("/api/admin/board/badreport")
    public ResponseEntity<?> badReport() {
        List<BoardBadReport> list = boardService.badReportList();
        return ResponseResult.success(list);
    }
}

Q2) 게시글의 스크랩을 추가하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

public interface BoardService {
    ServiceResult scrap(Long id, String email);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardRepository boardRepository;
    private final MemberRepository memberRepository;
    private final BoardScrapRepository boardScrapRepository;

    @Override
    public ServiceResult scrap(Long id, String email) {
        Optional<Board> optionalBoard = boardRepository.findById(id);
        if (optionalBoard.isEmpty()) {
            return ServiceResult.fail("게시글이 존재하지 않습니다.");
        }
        Board board = optionalBoard.get();

        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            return ServiceResult.fail("회원 정보가 존재하지 않습니다.");
        }
        Member member = optionalMember.get();

        boardScrapRepository.save(BoardScrap.builder()
                .member(member)
                .boardId(board.getId())
                .boardTypeId(board.getBoardType().getId())
                .boardTitle(board.getTitle())
                .boardContents(board.getContents())
                .boardRegDate(board.getRegDate())
                .regDate(LocalDateTime.now())
                .build());

        return ServiceResult.success();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiBoardScrapController {
    private final BoardService boardService;

    @PutMapping("/api/board/{id}/scrap")
    public ResponseEntity<?> boardScrap(@PathVariable Long id,
                                        @RequestHeader("Z-TOKEN") String token) {
        String email = "";
        try {
            email = JWTUtils.getIssuer(token);
        } catch (JWTVerificationException e) {
            return ResponseResult.fail("토큰 정보가 정확하지 않습니다.");
        }

        return ResponseResult.result(boardService.scrap(id, email));
    }
}

Q3) 게시글의 스크랩을 삭제하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

public interface BoardService {
    ServiceResult removeScrap(Long id, String email);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final MemberRepository memberRepository;
    private final BoardScrapRepository boardScrapRepository;

    @Override
    public ServiceResult removeScrap(Long id, String email) {
        Optional<BoardScrap> optionBoardScrap = boardScrapRepository.findById(id);
        if (optionBoardScrap.isEmpty()) {
            return ServiceResult.fail("삭제할 스크랩이 없습니다.");
        }
        BoardScrap boardScrap = optionBoardScrap.get();

        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            return ServiceResult.fail("회원 정보가 존재하지 않습니다.");
        }
        Member member = optionalMember.get();

        // 내 스크랩인지 확인 필요
        if (!Objects.equals(member.getId(), boardScrap.getMember().getId())) {
            return ServiceResult.fail("본인의 스크랩만 삭제할 수 있습니다.");
        }

        boardScrapRepository.delete(boardScrap);
        return ServiceResult.success();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiBoardScrapController {
    private final BoardService boardService;

    @DeleteMapping("/api/scrap/{id}")
    public ResponseEntity<?> deleteBoardScrap(@PathVariable Long id,
                                 @RequestHeader("Z-TOKEN") String token) {
        String email = "";
        try {
            email = JWTUtils.getIssuer(token);
        } catch (JWTVerificationException e) {
            return ResponseResult.fail("토큰 정보가 정확하지 않습니다.");
        }

        return ResponseResult.result(boardService.removeScrap(id, email));
    }
}

Q4) 게시글의 북마크를 추가/삭제하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

public interface BoardService {
    ServiceResult addBookmark(Long id, String email);
    ServiceResult removeBookmark(Long id, String email);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardRepository boardRepository;
    private final MemberRepository memberRepository;
    private final BoardBookmarkRepository boardBookmarkRepository;


    private String getBoardUrl(long boardId) {
        return String.format("/board/%d", boardId);
    }

    @Override
    public ServiceResult addBookmark(Long id, String email) {
        Optional<Board> optionalBoard = boardRepository.findById(id);
        if (optionalBoard.isEmpty()) {
            return ServiceResult.fail("게시글이 존재하지 않습니다.");
        }
        Board board = optionalBoard.get();

        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            return ServiceResult.fail("회원 정보가 존재하지 않습니다.");
        }
        Member member = optionalMember.get();

        BoardBookmark boardBookmark = BoardBookmark.builder()
                .member(member)
                .boardId(board.getId())
                .boardTypeId(board.getBoardType().getId())
                .boardTitle(board.getTitle())
                .boardUrl(getBoardUrl(board.getId()))
                .regDate(LocalDateTime.now())
                .build();
        boardBookmarkRepository.save(boardBookmark);
        return ServiceResult.success();
    }

    @Override
    public ServiceResult removeBookmark(Long id, String email) {
        Optional<BoardBookmark> optionalBoardBookmark = boardBookmarkRepository.findById(id);
        if (optionalBoardBookmark.isEmpty()) {
            return ServiceResult.fail("삭제할 북마크가 없습니다.");
        }
        BoardBookmark boardBookmark = optionalBoardBookmark.get();

        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            return ServiceResult.fail("회원 정보가 존재하지 않습니다.");
        }
        Member member = optionalMember.get();

        // 내 북마크인지 확인 필요
        if(!Objects.equals(member.getId(), boardBookmark.getMember().getId())){
            return ServiceResult.fail("본인의 북마크만 삭제할 수 있습니다.");
        }

        boardBookmarkRepository.delete(boardBookmark);
        return ServiceResult.success();
    }
}


@RequiredArgsConstructor
@RestController
public class ApiBoardBookmarkController {
    private final BoardService boardService;

    @PutMapping("/api/board/{id}/bookmark")
    public ResponseEntity<?> boardBookmark(@PathVariable Long id,
                                           @RequestHeader("Z-TOKEN") String token) {
        String email = "";
        try {
            email = JWTUtils.getIssuer(token);
        } catch (JWTVerificationException e) {
            return ResponseResult.fail("토큰 정보가 정확하지 않습니다.");
        }

        return ResponseResult.result(boardService.addBookmark(id,email));
    }
    
    @DeleteMapping("/api/bookmark/{id}")
    public ResponseEntity<?> deleteBookmark(@PathVariable Long id,
                                            @RequestHeader("Z-TOKEN") String token) {
        String email = "";
        try {
            email = JWTUtils.getIssuer(token);
        } catch (JWTVerificationException e) {
            return ResponseResult.fail("토큰 정보가 정확하지 않습니다.");
        }

        return ResponseResult.result(boardService.removeBookmark(id,email))
    }
}

Q5) 관심사용자에 등록하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

public interface MemberService {
    ServiceResult addInterestMember(Long id, String email);
}

@Service
@RequiredArgsConstructor
public class MemberServiceImpl implements MemberService {
    private final MemberRepository memberRepository;
    private final MemberInterestRepository memberInterestRepository;
    
    @Override
    public ServiceResult addInterestMember(Long id, String email) {
        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            return ServiceResult.fail("회원 정보가 존재하지 않습니다.");
        }
        Member member = optionalMember.get();

        Optional<Member> optionalInterestMember = memberRepository.findById(id);
        if (optionalInterestMember.isEmpty()) {
            return ServiceResult.fail("관심사용자의 추가 회원 정보가 존재하지 않습니다.");
        }
        Member interestMember = optionalInterestMember.get();

        if(Objects.equals(member.getId(), interestMember.getId())){
            return ServiceResult.fail("자기 자신은 추가할 수 없습니다");
        }

        if (memberInterestRepository.countByMemberAndInterestMember(member, interestMember) > 0) {
            return ServiceResult.fail("이미 관심사용자 목록에 추가하였습니다.");
        }

        MemberInterest memberInterest = MemberInterest.builder()
                .member(member)
                .interestMember(interestMember)
                .regDate(LocalDateTime.now())
                .build();

        memberInterestRepository.save(memberInterest);
        return ServiceResult.success();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiMemberInterestController {
    private final MemberService memberService;

    @PutMapping("/api/member/{id}/interest")
    public ResponseEntity<?> interestMember(@PathVariable Long id,
                                            @RequestHeader("Z-TOKEN") String token) {
        String email = "";
        try {
            email = JWTUtils.getIssuer(token);
        } catch (JWTVerificationException e) {
            return ResponseResult.fail("토큰 정보가 정확하지 않습니다.");
        }

        ServiceResult result = memberService.addInterestMember(id, email);
        return ResponseResult.result(result);
    }
}

Q6) 관심사용자를 삭제하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

public interface MemberService {
    ServiceResult removeInterestMember(Long id, String email);
}

@Service
@RequiredArgsConstructor
public class MemberServiceImpl implements MemberService {
    private final MemberRepository memberRepository;
    private final MemberInterestRepository memberInterestRepository;
    
    @Override
    public ServiceResult removeInterestMember(Long id, String email) {
        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            return ServiceResult.fail("회원 정보가 존재하지 않습니다.");
        }
        Member member = optionalMember.get();

        Optional<MemberInterest> optionalMemberInterest = memberInterestRepository.findById(id);
        if (optionalMemberInterest.isEmpty()) {
            return ServiceResult.fail("삭제할 정보가 없습니다.");
        }

        MemberInterest memberInterest = optionalMemberInterest.get();

        if(Objects.equals(member.getId(), memberInterest.getMember().getId())){
            return ServiceResult.fail("본인의 관심자 정보만 삭제할 수 있습니다.");
        }

        memberInterestRepository.delete(memberInterest);
        return ServiceResult.success();
    }
}

@RestController
@RequiredArgsConstructor
public class ApiMemberInterestController {
    private final MemberService memberService;

    @DeleteMapping("/api/member/interest/{id}")
    public ResponseEntity<?> deleteInterestMember(@PathVariable Long id,
                                            @RequestHeader("Z-TOKEN") String token) {
        String email = "";
        try {
            email = JWTUtils.getIssuer(token);
        } catch (JWTVerificationException e) {
            return ResponseResult.fail("토큰 정보가 정확하지 않습니다.");
        }

        ServiceResult result = memberService.removeInterestMember(id, email);
        return ResponseResult.result(result);
    }
}

Q7) 내가 작성한 게시글 목록을 리턴하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

public interface BoardService {
    List<Board> postList(String email);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardRepository boardRepository;
    private final MemberRepository memberRepository;

	@Override
    public List<Board> postList(String email) {
        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            throw new BizException("회원정보가 존재하지 않습니다.");
        }
        Member member = optionalMember.get();

        return boardRepository.findByMember(member);
    }
}


@RestController
@RequiredArgsConstructor
public class ApiMemberController {
    private final BoardService boardService;

    @GetMapping("/api/member/board/post")
    public ResponseEntity<?> myPost(@RequestHeader("Z-TOKEN") String token) {
        String email = "";

        try {
            email = JWTUtils.getIssuer(token);
        } catch (SignatureVerificationException e) {
            return ResponseResult.fail("토큰정보가 정확하지 않습니다.");
        }

        List<Board> list = boardService.postList(email);
        return ResponseResult.success(list);
    }
}

Q8) 내가 작성한 게시글의 코멘트 목록을 리턴하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

public interface BoardService {
    List<BoardComment> commentList(String email);
}

@Service
@RequiredArgsConstructor
public class BoardServiceImpl implements BoardService {
    private final BoardRepository boardRepository;
    private final MemberRepository memberRepository;
    private final BoardCommentRepository boardCommentRepository;

	@Override
    public List<BoardComment> commentList(String email) {
        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            throw new BizException("회원정보가 존재하지 않습니다.");
        }
        Member member = optionalMember.get();

        return boardCommentRepository.findByMember(member);
    }
}


@RestController
@RequiredArgsConstructor
public class ApiMemberController {
    private final BoardService boardService;

    @GetMapping("/api/member/board/comment")
    public ResponseEntity<?> myComments(@RequestHeader("Z-TOKEN") String token) {
        String email = "";

        try {
            email = JWTUtils.getIssuer(token);
        } catch (SignatureVerificationException e) {
            return ResponseResult.fail("토큰정보가 정확하지 않습니다.");
        }

        List<BoardComment> list = boardService.commentList(email);
        return ResponseResult.success(list);
    }
}

Q9) 사용자의 포인트 정보를 만들고 게시글을 작성할 경우, 포인트를 누적하는 API를 작성해 보세요.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

public interface PointService {
    ServiceResult addPoint(String email, MemberPointInput memberPointInput);
}

@RequiredArgsConstructor
@Service
public class PointServiceImpl implements PointService {
    private final MemberRepository memberRepository;
    private final MemberPointRepository memberPointRepository;

    @Override
    public ServiceResult addPoint(String email, MemberPointInput memberPointInput) {
        Optional<Member> optionalMember = memberRepository.findByEmail(email);
        if (optionalMember.isEmpty()) {
            return ServiceResult.fail("회원 정보가 존재하지 않습니다.");
        }

        Member member = optionalMember.get();

        memberPointRepository.save(MemberPoint.builder()
                .member(member)
                .memberPointType(memberPointInput.getMemberPointType())
                .point(memberPointInput.getMemberPointType().getValue())
                .build());
        return ServiceResult.success();
    }
}


@RestController
@RequiredArgsConstructor
public class ApiMemberController {
    private final BoardService boardService;
    private final PointService pointService;

    @PostMapping("/api/member/point")
    public ResponseEntity<?> memberPoint(@RequestHeader("Z-TOKEN") String token,
                                         @RequestBody MemberPointInput memberPointInput) {
        String email = "";

        try {
            email = JWTUtils.getIssuer(token);
        } catch (SignatureVerificationException e) {
            return ResponseResult.fail("토큰정보가 정확하지 않습니다.");
        }

        ServiceResult result = pointService.addPoint(email,memberPointInput);
        return ResponseResult.result(result);
    }
}

Entity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Entity
public class BoardType {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column private String boardName;
    @Column private LocalDateTime regDate;
    @Column private LocalDateTime updateDate;
    @Column private boolean usingYn;
}

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Entity
public class Board {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn
    private Member member;

    @ManyToOne
    @JoinColumn
    private BoardType boardType;
    
    @Column private String title;
    @Column private String contents;
    @Column private LocalDateTime regDate;
    @Column private boolean topYn;
    @Column private LocalDate publishStartDate;
    @Column private LocalDate publishEndDate;
}

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Entity
public class BoardHits {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn
    private Board board;

    @ManyToOne
    @JoinColumn
    private Member member;

    @Column
    private LocalDateTime regDate;
}

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Entity
public class BoardLike {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn
    private Board board;

    @ManyToOne
    @JoinColumn
    private Member member;

    @Column
    private LocalDateTime regDate;
}

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Entity
public class BoardBadReport {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 신고자
    @Column private Long memberId;
    @Column private String memberName;
    @Column private String memberEmail;

    // 신고게시글 정보
    @Column private Long boardId;
    @Column private Long boardMemberId;
    @Column private String boardTitle;
    @Column private String boardContents;
    @Column private LocalDateTime boardRegDate;

    // 신고내용
    @Column private String comments;
    @Column private LocalDateTime regDate;
}

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Entity
public class BoardScrap {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn
    private Member member;

    // 스크랩글정보
    @Column private Long boardId;
    @Column private Long boardTypeId;
    @Column private Long boardMemberId;
    @Column private String boardTitle;
    @Column private String boardContents;
    @Column private LocalDateTime boardRegDate;

    @Column private LocalDateTime regDate;
}

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Entity
public class BoardBookmark {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn
    private Member member;

    @Column private Long boardId;
    @Column private Long boardTypeId;
    @Column private String boardTitle;
    @Column private String boardUrl;

    @Column private LocalDateTime regDate;
}

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Entity
public class MemberInterest {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn
    private Member member;

    @ManyToOne
    @JoinColumn
    private Member interestMember;

    @Column
    private LocalDateTime regDate;
}

@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
@Builder
@Entity
public class BoardComment {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn
    private Member member;

    @ManyToOne
    @JoinColumn
    private Board board;

    @Column private String comments;
    @Column private LocalDateTime regDate;
}

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Entity
public class MemberPoint {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn
    private Member member;

    @Enumerated(EnumType.STRING)
    @Column
    private MemberPointType memberPointType;
    
    @Column private int point;
}


Repository

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

@Repository
public interface BoardTypeRepository extends JpaRepository<BoardType, Long> {
    BoardType findByBoardName(String name);
}

@Repository
public interface BoardRepository extends JpaRepository<Board, Long> {
    Long countByBoardType(BoardType boardType);
    List<Board> findByMember(Member member);
}

@Repository
public interface BoardHitsRepository extends JpaRepository<BoardHits, Long> {
    Long countByBoardAndMember(Board board, Member member);
}

@Repository
public interface BoardLikeRepository extends JpaRepository<BoardLike, Long> {
    Long countByBoardAndMember(Board board, Member member);
    Optional<BoardLike> findByBoardAndMember(Board board, Member member);
}

@Repository
public interface BoardBadReportRepository extends JpaRepository<BoardBadReport, Long> {
}

@Repository
public interface BoardScrapRepository extends JpaRepository<BoardScrap, Long> {
}

@Repository
public interface BoardBookmarkRepository extends JpaRepository<BoardBookmark, Long> {
}

@Repository
public interface MemberInterestRepository extends JpaRepository<MemberInterest, Long> {
    long countByMemberAndInterestMember(Member member, Member interestMember);
}

@Repository
public interface BoardCommentRepository extends JpaRepository<BoardComment, Long> {
    List<BoardComment> findByMember(Member member);
}

@Repository
public interface MemberPointRepository extends JpaRepository<MemberPoint, Long> {
}


Model

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

public class ResponseResult {
    public static ResponseEntity<?> fail(String message) {
        return ResponseEntity.badRequest().body(ResponseMessage.fail(message));
    }

    public static ResponseEntity<?> success() {
        return success(null);
    }

    public static ResponseEntity<?> success(Object data) {
        return ResponseEntity.ok().body(ResponseMessage.success(data));
    }

    public static ResponseEntity<?> result(ServiceResult result) {
        if (result.isFail()) {
            return fail(result.getMessage());
        }
        return success();
    }
}

@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class ResponseError {
    private String field;
    private String message;
    
    public static List<ResponseError> of(List<ObjectError> errors) {
        List<ResponseError> responseErrors = new ArrayList<>();
        if (errors != null) {
            errors.forEach((e) -> responseErrors.add(ResponseError.of((FieldError)e)));
        }
        return responseErrors;
    }
}


@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class ResponseMessage {
    private ResponseMessageHeader header;
    private Object body;
    
    public static ResponseMessage fail(String message,Object data) {
        return ResponseMessage.builder()
                .header(ResponseMessageHeader.builder()
                        .result(false)
                        .resultCode("")
                        .message(message)
                        .status(HttpStatus.BAD_REQUEST.value())
                        .build())
                .body(data).build();
    }
}


@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ServiceResult {
    private boolean result;
    private String message;

    public static ServiceResult fail(String message) {
        return ServiceResult.builder()
                .result(false)
                .message(message)
                .build();
    }

    public static ServiceResult success() {
        return ServiceResult.builder()
                .result(true)
                .build();
    }
    
    public boolean isFail() {
        return !result;
    }
}

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class BoardTypeUsing {
    private boolean usingYn;
}

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class BoardTypeCount {
    private int id;
    private String boardName;
    private LocalDateTime regDate;
    private boolean usingYn;
    private int boardCount;
    
    public BoardTypeCount(Object[] arrObj) {
        this.id = ((Number) arrObj[0]).longValue();
        this.boardName = (String) arrObj[1];
        this.regDate = ((Timestamp) arrObj[2]).toLocalDateTime();
        this.usingYn = (Boolean) arrObj[3];
        this.boardCount = ((Number) arrObj[4]).longValue();
    }
}

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class BoardPeriod {
    private LocalDate startDate;
    private LocalDate endDate;
}

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class BoardBadReportInput {
    private String comments;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class MemberPointInput {
    private MemberPointType memberPointType;
}

@Getter
public enum MemberPointType {
    NONE(0),
    USER_RESISTER(100),
    ADD_POST(200),
    ADD_COMMENT(150),
    ADD_LIKE(50);

    private final int value;

    MemberPointType(int value) {
        this.value = value;
    }
}


Common

1
2
3
4
5

public class BizException extends RuntimeException {
    public BizException(String message) {
        super(message);
    }
}

카테고리:

업데이트:

댓글남기기