💻 기능 개발 - 프로그램

💡 프로그램 기능

 

요구사항

Open-Session-in-view 옵션: false (트랜잭션 내부의 프록시객체 초기화 필요)
@ManyToOne 단방향 매핑으로 진행
FetchType : Lazy

1. 프로그램 등록
2. 프로그램 수정
3. 프로그램 수정 (상담사 마이페이지)
4. 프로그램 조회 (상담사 마이페이지)
5. 프로그램 전체 조회 (상담사 마이페이지)
6. 프로그램 조회 (공통)
7. 프로그램 전체 조회 (공통)
8. 고민별 & 추천별 프로그램 조회
9. 프로그램 전체조회 (관리자)
10. 상담사의 상담이력 전체 조회 (관리자)
11. 프로그램 삭제 (관리자)

---

💡 소스코드

 

Entity

@Entity
@Getter
@Setter
@NoArgsConstructor
public class Program {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long programId;

    @Column(nullable = false, length = 50)
    private String title;

    @Column(nullable = false)
    private String content;

    private int userMax;

    private int userCount = 0;

    private int cost;

    private String image;

    private String announce;

    private String zoomLink;

    @Column(nullable = false)
    private String dateStart;

    @Column(nullable = false)
    private String dateEnd;

    @ElementCollection
    @CollectionTable(name = "SYMPTOM_TYPES", joinColumns = @JoinColumn(name = "PROGRAM_ID"))
    @Column(name = "SYMPTOM_TYPE")
    private Set<String> symptomTypes = new HashSet<>();

    @OneToMany(mappedBy = "program")
    private List<Pay> payList = new ArrayList<>();

    @ManyToOne(optional = false)
    @JoinColumn(name = "COUNSELOR_ID")
    private Counselor counselor;

    @Builder
    public Program(Long programId, String title, String content, int userMax, int userCount,
        int cost,
        String image, String announce, String zoomLink, String dateStart, String dateEnd,
        Set<String> symptomTypes, List<Pay> payList, Counselor counselor) {
        this.programId = programId;
        this.title = title;
        this.content = content;
        this.userMax = userMax;
        this.userCount = userCount;
        this.cost = cost;
        this.image = image;
        this.announce = announce;
        this.zoomLink = zoomLink;
        this.dateStart = dateStart;
        this.dateEnd = dateEnd;
        this.symptomTypes = symptomTypes;
        this.payList = payList;
        this.counselor = counselor;
    }

    public static Program of(Program program) {
        return Program.builder()
            .programId(program.getProgramId())
            .title(program.getTitle())
            .content(program.getContent())
            .userMax(program.getUserMax())
            .userCount(program.userCount)
            .cost(program.getCost())
            .image(program.getImage())
            .announce(program.getAnnounce())
            .zoomLink(program.getZoomLink())
            .dateStart(program.getDateStart())
            .dateEnd(program.getDateEnd())
            .symptomTypes(program.getSymptomTypes())
            .payList(program.getPayList())
            .counselor(program.getCounselor())
            .build();
    }
}

 

DTO

public class ProgramDto {

    @Getter
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class Post {

        @NotBlank
        private String title;

        @NotBlank
        private String content;
        private String image;

        @Min(1)
        private int userMax;

        @NotBlank
        private String dateStart;

        @NotBlank
        private String dateEnd;

        @NotBlank
        private int cost;

        private Set<String> symptomTypes;

        private Long counselorId;

        public static ProgramDto.Post of(ProgramDto.Post requestBody) {
            return Post.builder()
                .title(requestBody.getTitle())
                .content(requestBody.getContent())
                .image(requestBody.getImage())
                .userMax(requestBody.getUserMax())
                .dateStart(requestBody.getDateStart())
                .dateEnd(requestBody.getDateEnd())
                .cost(requestBody.getCost())
                .symptomTypes(requestBody.getSymptomTypes())
                .counselorId(requestBody.getCounselorId())
                .build();
        }
    }

    @Getter
    @Builder
    public static class Patch {

        @Setter
        private Long programId;

        @NotBlank
        private String title;

        @NotBlank
        private String content;
        private String image;

        @Min(1)
        private int userMax;

        @NotBlank
        private String dateStart;

        @NotBlank
        private String dateEnd;

        @NotBlank
        private int cost;

        private Set<String> symptomTypes;

        @NotBlank
        private Long counselorId;

        public static ProgramDto.Patch of(ProgramDto.Patch requestBody) {
            return ProgramDto.Patch.builder()
                .title(requestBody.getTitle())
                .content(requestBody.getContent())
                .image(requestBody.getImage())
                .userMax(requestBody.getUserMax())
                .dateStart(requestBody.getDateStart())
                .dateEnd(requestBody.getDateEnd())
                .cost(requestBody.getCost())
                .symptomTypes(requestBody.getSymptomTypes())
                .counselorId(requestBody.getCounselorId())
                .build();
        }
    }

    @Getter
    @Builder
    public static class PatchResponse {
        @Setter
        private Long programId;

        @NotBlank
        private String title;

        @NotBlank
        private String content;
        private String image;

        @Min(1)
        private int userMax;

        @NotBlank
        private String dateStart;

        @NotBlank
        private String dateEnd;

        @NotBlank
        private int cost;

        private Set<String> symptomTypes;

        @NotBlank
        private Long counselorId;

        public static ProgramDto.PatchResponse of(Program program) {
            return PatchResponse.builder()
                .programId(program.getProgramId())
                .title(program.getTitle())
                .content(program.getContent())
                .image(program.getImage())
                .userMax(program.getUserMax())
                .dateStart(program.getDateStart())
                .dateEnd(program.getDateEnd())
                .cost(program.getCost())
                .symptomTypes(program.getSymptomTypes())
                .counselorId(program.getCounselor().getCounselorId())
                .build();
        }
    }

    @Getter
    @Builder
    public static class PatchCounselor {
        @Setter
        private Long programId;
        private String zoomLink;
        private String announce;

        public static ProgramDto.PatchCounselor of(Program program) {
            return PatchCounselor.builder()
                .zoomLink(program.getZoomLink())
                .announce(program.getAnnounce())
                .build();
        }
    }

    @Getter
    @Builder
    public static class PatchCounselorResponse {
        private String zoomLink;
        private String announce;

        public static ProgramDto.PatchCounselorResponse of(Program program) {
            return PatchCounselorResponse.builder()
                .zoomLink(program.getZoomLink())
                .announce(program.getAnnounce())
                .build();
        }
    }

    @Getter
    @Builder
    public static class GetResponse {

        private Long programId;
        private String title;
        private String content;
        private int userMax;
        private int userCount;
        private int cost;
        private String image;
        private String dateStart;
        private String dateEnd;
        private Set<String> symptomTypes;
        private String counselorName;
        private String profile;
        private String introduce;
        private String expertiseField;


        public static ProgramDto.GetResponse of(Program program) {
            return ProgramDto.GetResponse.builder()
                .programId(program.getProgramId())
                .title(program.getTitle())
                .content(program.getContent())
                .userMax(program.getUserMax())
                .userCount(program.getUserCount())
                .cost(program.getCost())
                .image(program.getImage())
                .dateStart(program.getDateStart())
                .dateEnd(program.getDateEnd())
                .symptomTypes(program.getSymptomTypes())
                .counselorName(program.getCounselor().getCounselorName())
                .profile(program.getCounselor().getProfile())
                .introduce(program.getCounselor().getIntroduce())
                .expertiseField(program.getCounselor().getExpertiseField())
                .build();
        }
    }

    @Getter
    @Builder
    public static class PageResponse {

        private Long programId;
        private String title;
        private String dateStart;
        private String dateEnd;
        private Set<String> symptomTypes;
        private String counselorName;

        public static ProgramDto.PageResponse of(Program program) {
            return ProgramDto.PageResponse.builder()
                .programId(program.getProgramId())
                .title(program.getTitle())
                .dateStart(program.getDateStart())
                .dateEnd(program.getDateEnd())
                .symptomTypes(program.getSymptomTypes())
                .counselorName(program.getCounselor().getCounselorName())
                .build();
        }
    }

    @Getter
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class GetCounselorProgramResponse {
        private Long programId;
        private String title;
        private String dateStart;
        private String dateEnd;
        private int userMax;
        private int userCount;
        private String zoomLink;
        private String announce;
        private List<MemberInPayList> memberInPayList;

        public static ProgramDto.GetCounselorProgramResponse of(Program program, List<PayDto.MemberInPayList> memberInPayList) {
            return GetCounselorProgramResponse.builder()
                .programId(program.getProgramId())
                .title(program.getTitle())
                .dateStart(program.getDateStart())
                .dateEnd(program.getDateEnd())
                .userMax(program.getUserMax())
                .userCount(program.getUserCount())
                .zoomLink(program.getZoomLink())
                .announce(program.getAnnounce())
                .memberInPayList(memberInPayList)
                .build();
        }
    }

    @Getter
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class GetCounselorProgramsResponse {
        private Long programId;
        private String title;
        private String dateStart;
        private String dateEnd;
        private int userMax;
        private int userCount;

        public static ProgramDto.GetCounselorProgramsResponse of(Program program) {
            return GetCounselorProgramsResponse.builder()
                .programId(program.getProgramId())
                .title(program.getTitle())
                .dateStart(program.getDateStart())
                .dateEnd(program.getDateEnd())
                .userMax(program.getUserMax())
                .userCount(program.getUserCount())
                .build();
        }
    }

    @Getter
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class GetCounselorProgramsByAdminResponse {
        private Long programId;
        private String title;
        private String dateStart;
        private String dateEnd;
        private int userMax;
        private int userCount;
        private Long counselorId;
        private String counselorName;

        public static ProgramDto.GetCounselorProgramsByAdminResponse of(Program program) {
            return GetCounselorProgramsByAdminResponse.builder()
                .programId(program.getProgramId())
                .title(program.getTitle())
                .dateStart(program.getDateStart())
                .dateEnd(program.getDateEnd())
                .userMax(program.getUserMax())
                .userCount(program.getUserCount())
                .counselorId(program.getCounselor().getCounselorId())
                .counselorName(program.getCounselor().getCounselorName())
                .build();
        }
    }

    @Getter
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class GetAdminProgramResponse {

        private Long programId;
        private String title;
        private String dateStart;
        private String dateEnd;
        private int userMax;
        private int userCount;

        public static ProgramDto.GetAdminProgramResponse of(Program program) {
            return GetAdminProgramResponse.builder()
                .programId(program.getProgramId())
                .title(program.getTitle())
                .dateStart(program.getDateStart())
                .dateEnd(program.getDateEnd())
                .userMax(program.getUserMax())
                .userCount(program.getUserCount())
                .build();
        }
    }

    @Getter
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class AdminPageResponse {
        private Long programId;
        private String title;
        private String dateStart;
        private String dateEnd;
        private int userMax;
        private int userCount;

        public static ProgramDto.AdminPageResponse of(Program program) {
            return AdminPageResponse.builder()
                .programId(program.getProgramId())
                .title(program.getTitle())
                .dateStart(program.getDateStart())
                .dateEnd(program.getDateEnd())
                .userMax(program.getUserMax())
                .userCount(program.getUserCount())
                .build();
        }
    }
}

 

Mapper

@Mapper(componentModel = "spring")
public interface ProgramMapper {
    Program ProgramPostDtoToProgram(ProgramDto.Post requestBody);
    Program ProgramPatchDtoToProgram(ProgramDto.Patch requestBody);

    default ProgramDto.PatchResponse ProgramToPatchProgramResponseDto(Program program) {
        ProgramDto.PatchResponse response = ProgramDto.PatchResponse.of(program);
        return response;
    }

    Program PatchCounselorDtoToProgram(ProgramDto.PatchCounselor requestBody);
    ProgramDto.PatchCounselorResponse ProgramToPatchCounselorResponse(Program program);

    default ProgramDto.GetResponse ProgramToGetProgramResponseDto(Program program) {
        ProgramDto.GetResponse response = ProgramDto.GetResponse.of(program);
        return response;
    }
    default List<ProgramDto.PageResponse> ProgramsToProgramResponseDtos(List<Program> programs) {
        List<ProgramDto.PageResponse> list = new ArrayList<ProgramDto.PageResponse>(programs.size());

        for(Program program : programs) {
            list.add(ProgramDto.PageResponse.of(program));
        }
        return list;
    }

    default ProgramDto.GetCounselorProgramResponse ProgramToGetCounselorProgramResponseDto(Program program) {
        List<PayDto.MemberInPayList> member = new ArrayList<>(program.getPayList().size());
        List<Pay> payList = program.getPayList();
        for(int i = 0; i < payList.size(); i++) {
            member.add(i, MemberInPayList.of(payList.get(i)));
        }

        ProgramDto.GetCounselorProgramResponse response = ProgramDto.GetCounselorProgramResponse.of(program, member);
        return response;
    }
    List<ProgramDto.GetCounselorProgramsResponse> ProgramsToGetCounselorProgramsResponseDtos(List<Program> programs);

    default List<ProgramDto.GetCounselorProgramsByAdminResponse> ProgramsToGetCounselorProgramsByAdminResponseDtos(List<Program> programs) {
        List<ProgramDto.GetCounselorProgramsByAdminResponse> list = new ArrayList<>(programs.size());

        for(Program program : programs) {
            list.add(ProgramDto.GetCounselorProgramsByAdminResponse.of(program));
        }
        return list;
    }
    List<ProgramDto.GetAdminProgramResponse> ProgramsToGetAdminProgramResponseDtos(List<Program> programs);

}

 

Repository

public interface ProgramRepository extends JpaRepository<Program, Long> {

    @Query(value = "select * from program where counselor_id = :counselorId", nativeQuery = true)
    Page<Program> findAllByCounselor(long counselorId, Pageable pageable);

    Page<Program> findAllBySymptomTypes(String symptomTypes, Pageable pageable);

    Optional<Program> findByProgramIdAndCounselorCounselorId(long programId, long counselorId);
}

 

Service

@Service
@Transactional
@RequiredArgsConstructor
public class ProgramService {
    private final ProgramRepository programRepository;
    private final CustomBeanUtils<Program> beanUtils;

    public Program createProgram(Program program, Counselor counselor) {
        program.setCounselor(counselor);

        return programRepository.save(program);
    }

    public Program updateProgram(Program program, Counselor counselor) {
        // 유효한 program인지 검증
        Program findProgram = findVerifiedProgram(program.getProgramId());

        Optional.ofNullable(program.getTitle())
            .ifPresent(findProgram::setTitle);
        Optional.ofNullable(program.getContent())
            .ifPresent(findProgram::setContent);
        Optional.ofNullable(program.getImage())
            .ifPresent(findProgram::setImage);
        Optional.ofNullable(program.getUserMax())
            .ifPresent(findProgram::setUserMax);
        Optional.ofNullable(program.getDateStart())
            .ifPresent(findProgram::setDateStart);
        Optional.ofNullable(program.getDateEnd())
            .ifPresent(findProgram::setDateEnd);
        Optional.ofNullable(program.getCost())
            .ifPresent(findProgram::setCost);
        Optional.ofNullable(program.getSymptomTypes())
                .ifPresent(findProgram::setSymptomTypes);

        findProgram.setCounselor(counselor);

        return programRepository.save(findProgram);
    }

    public Program updateProgram(Program program) {
        Program findProgram = findVerifiedProgram(program.getProgramId());

        Optional.ofNullable(program.getZoomLink())
            .ifPresent(findProgram::setZoomLink);
        Optional.ofNullable(program.getAnnounce())
            .ifPresent(findProgram::setAnnounce);

        return programRepository.save(findProgram);
    }

    @Transactional(readOnly = true)
    public Page<Program> findPrograms(int page, int size) {
        return programRepository.findAll(PageRequest.of(page, size, Sort.by("programId").descending()));
    }

    @Transactional(readOnly = true)
    public Program findVerifiedProgram(long programId) {
        Optional<Program> optionalProgram = programRepository.findById(programId);
        Program findProgram = optionalProgram.orElseThrow(
            () -> new BusinessException(ErrorCode.PROGRAM_NOT_FOUND)
        );

        return findProgram;
    }

    public Program findVerifiedProgramByCounselorId(long counselorId, long programId) {
        Optional<Program> optionalProgram = programRepository.findByProgramIdAndCounselorCounselorId(programId, counselorId);
        Program findProgram = optionalProgram.orElseThrow(
            () -> new BusinessException(ErrorCode.PROGRAM_NOT_FOUND)
        );

        return findProgram;
    }

    public void deleteProgram(long programId) {
        Program findProgram = findVerifiedProgram(programId);

        programRepository.delete(findProgram);
    }

    public Program findVerifiedExistsReserveProgram(long memberId, long programId) {
        Program program = findVerifiedProgram(programId);
        List<Pay> payList = program.getPayList();

        for(Pay p : payList) {
            if(Objects.equals(p.getMember().getMemberId(), memberId)) {
                if(Status.COMPLETE_PAYMENT.equals(p.getStatus()) || Status.WAITING_CANCEL_PAYMENT.equals(p.getStatus())) {
                    throw new BusinessException(ErrorCode.RESERVATION_EXISTS);
                } else if (Status.CANCEL_PAYMENT.equals(p.getStatus())) {
                    return program;
                }
            }
        }

        return program;
    }

    @Transactional(readOnly = true)
    public Page<Program> searchCounselorProgram(Long counselorId, int page, int size) {
        Pageable pageable = PageRequest.of(page, size, Sort.by("program_id").descending());
        Page<Program> programPage = programRepository.findAllByCounselor(counselorId, pageable);
        return programPage;
    }

    public Page<Program> searchProgram(String search, int page, int size) {
        Pageable pageable = PageRequest.of(page, size, Sort.by("programId").descending());
        Page<Program> programPage = programRepository.findAllBySymptomTypes(search, pageable);

        return programPage;
    }
}

 

Controller

@RestController
@RequestMapping("/api/programs")
@RequiredArgsConstructor
public class ProgramController {
    private final ProgramService programService;
    private final ProgramMapper programMapper;
    private final CounselorService counselorService;

    // 화면정의서 30p
    // 프로그램 생성
    @PostMapping("/post")
    public ResponseEntity postProgram(@RequestBody ProgramDto.Post requestBody) {
        Program program = programMapper.ProgramPostDtoToProgram(requestBody);
        Counselor counselor = counselorService.findVerifiedCounselorByCounselorId(requestBody.getCounselorId());
        Program createdProgram = programService.createProgram(program, counselor);

        return new ResponseEntity<>(HttpStatus.CREATED);
    }

    // 화면정의서 31p
    // 프로그램 정보 수정
    @PatchMapping("/patch/{program-id}")
    public ResponseEntity patchProgram(@PathVariable("program-id") @Positive Long programId,
        @RequestBody ProgramDto.Patch requestBody) {
        requestBody.setProgramId(programId);
        Program program = programMapper.ProgramPatchDtoToProgram(requestBody);

        Counselor counselor = counselorService.findVerifiedCounselorByCounselorId(requestBody.getCounselorId());
        Program updatedProgram = programService.updateProgram(program, counselor);
        ProgramDto.PatchResponse response = programMapper.ProgramToPatchProgramResponseDto(updatedProgram);

        return new ResponseEntity<>(
            new SingleResponseDto<>(response), HttpStatus.OK);
    }

    // 화면정의서 26p
    // 상담사 - 마이페이지 나의 프로그램 수정
    @PatchMapping("/patch/counselor/{program-id}")
    public ResponseEntity patchCounselorProgram(@PathVariable("program-id") @Positive Long programId,
        @RequestBody ProgramDto.PatchCounselor requestBody) {
        requestBody.setProgramId(programId);
        Program program = programMapper.PatchCounselorDtoToProgram(requestBody);
        Program updatedProgram = programService.updateProgram(program);
        ProgramDto.PatchCounselorResponse response = programMapper.ProgramToPatchCounselorResponse(updatedProgram);

        return new ResponseEntity<>(
            new SingleResponseDto<>(response), HttpStatus.OK);
    }

    // 화면정의서 8p
    // 개별 프로그램 조회
    @GetMapping("/lookup/{program-id}")
    public ResponseEntity getProgram(@PathVariable("program-id") @Positive Long programId) {
        Program program = programService.findVerifiedProgram(programId);
        ProgramDto.GetResponse response = programMapper.ProgramToGetProgramResponseDto(program);
        return new ResponseEntity<>(
            new SingleResponseDto<>(response), HttpStatus.OK);
    }

    // 화면정의서 6p
    // 전체 프로그램 조회
    @GetMapping("/lookup/list")
    public ResponseEntity getPrograms(@Positive @RequestParam(defaultValue = "1") int page,
        @Positive @RequestParam(defaultValue = "10") int size) {
        Page<Program> programPage = programService.findPrograms(page-1, size);
        List<Program> programs = programPage.getContent();
        List<ProgramDto.PageResponse> response = programMapper.ProgramsToProgramResponseDtos(programs);

        return new ResponseEntity<>(
            new MultiResponseDto<>(response, programPage), HttpStatus.OK);
    }

    // 화면정의서 25p
    // 상담사 - 마이페이지 나의 프로그램 개별 조회
    @GetMapping("/counselors/{counselor-id}/lookup/{program-id}")
    public ResponseEntity getCounselorProgram(@PathVariable("counselor-id") @Positive Long counselorId,
        @PathVariable("program-id") @Positive Long programId) {
        Program program = programService.findVerifiedProgramByCounselorId(counselorId, programId);
        ProgramDto.GetCounselorProgramResponse response = programMapper.ProgramToGetCounselorProgramResponseDto(program);
        return new ResponseEntity<>(
            new SingleResponseDto<>(response), HttpStatus.OK);
    }

//    // 화면정의서 24p
//    // 상담사 - 상담사 상담 이력 전체 조회
//    @GetMapping("/counselors/{counselor-id}/lookup/list")
//    public ResponseEntity getCounselorPrograms(@PathVariable("counselor-id") @Positive Long counselorId,
//        @Positive @RequestParam(defaultValue = "1") int page,
//        @Positive @RequestParam(defaultValue = "10") int size) {
//
//        Page<Program> CounselorProgramPage = programService.searchCounselorProgram(counselorId, page-1, size);
//        List<Program> programList = CounselorProgramPage.getContent();
//        List<ProgramDto.GetCounselorProgramsResponse> response = programMapper.ProgramsToGetCounselorProgramsResponseDtos(programList);
//
//
//        return new ResponseEntity(
//            new MultiResponseDto<>(
//                response, CounselorProgramPage), HttpStatus.OK);
//    }


    // 화면정의서 24p
    // 상담사 - 상담사 상담 이력 전체 조회
    @GetMapping("/counselors/lookup/list")
    public ResponseEntity getCounselorPrograms(HttpServletRequest httpServletRequest,
                                               @Positive @RequestParam(defaultValue = "1") int page,
                                               @Positive @RequestParam(defaultValue = "10") int size) {
        Counselor counselor = counselorService.getLoginCounselor(httpServletRequest);
        Long counselorId = counselor.getCounselorId();

        Page<Program> CounselorProgramPage = programService.searchCounselorProgram(counselorId, page-1, size);
        List<Program> programList = CounselorProgramPage.getContent();
        List<ProgramDto.GetCounselorProgramsResponse> response = programMapper.ProgramsToGetCounselorProgramsResponseDtos(programList);


        return new ResponseEntity(
                new MultiResponseDto<>(
                        response, CounselorProgramPage), HttpStatus.OK);
    }

    // 화면정의서 29p
    // 관리자 - 개설 프로그램 전체 조회
    @GetMapping("/admin/lookup/list")
    public ResponseEntity getAdminPrograms(@Positive @RequestParam(defaultValue = "1") int page,
        @Positive @RequestParam(defaultValue = "10") int size) {
        Page<Program> programPage = programService.findPrograms(page-1, size);
        List<Program> programs = programPage.getContent();
        List<ProgramDto.GetAdminProgramResponse> response = programMapper.ProgramsToGetAdminProgramResponseDtos(programs);

        return new ResponseEntity<>(
            new MultiResponseDto<>(response, programPage), HttpStatus.OK);
    }

    // 화면정의서 35p
    // 관리자 - 상담사 상담이력 전체 조회
    @GetMapping("/admin/lookup/{counselor-id}/list")
    public ResponseEntity getCounselorProgramByAdmin(@PathVariable("counselor-id") @Positive Long counselorId,
        @Positive @RequestParam(defaultValue = "1") int page,
        @Positive @RequestParam(defaultValue = "10") int size) {
        Page<Program> programPage = programService.searchCounselorProgram(counselorId, page-1, size);
        List<Program> programList = programPage.getContent();

        List<ProgramDto.GetCounselorProgramsByAdminResponse> response = programMapper.ProgramsToGetCounselorProgramsByAdminResponseDtos(programList);
        return new ResponseEntity<>(
            new MultiResponseDto<>(response, programPage), HttpStatus.OK);
    }

    // 화면정의서 7p, 12p
    // 고민별 프로그램 조회, 추천 프로그램 조회
    @GetMapping("/lookup/search")
    public ResponseEntity searchProgramsBySymptom(@RequestParam String search,
        @Positive @RequestParam(defaultValue = "1") int page,
        @Positive @RequestParam(defaultValue = "10") int size) {
        Page<Program> searchProgramPage = programService.searchProgram(search, page-1, size);
        List<Program> searchProgramList = searchProgramPage.getContent();

        List<ProgramDto.PageResponse> response = programMapper.ProgramsToProgramResponseDtos(searchProgramList);

        return new ResponseEntity<>(
            new MultiResponseDto<>(response, searchProgramPage), HttpStatus.OK);
    }

    // 화면정의서 31p
    // 프로그램 삭제
    @DeleteMapping("/delete/{program-id}")
    public ResponseEntity deleteProgram(@PathVariable("program-id") @Positive Long programId) {
        programService.deleteProgram(programId);
        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    }
}