GymMembershipService.java

- 헬스장 이용권 CRUD

@Service
public class GymMembershipService {
    private final GymMembershipRepository gymMembershipRepository;
    private final MemberRepository memberRepository;
    private final MemberService memberService;
    private final ModelMapper modelMapper;
    public GymMembershipService (GymMembershipRepository gymMembershipRepository, MemberRepository memberRepository,
                                 MemberService memberService, ModelMapper modelMapper){
        this.gymMembershipRepository = gymMembershipRepository;
        this.memberRepository = memberRepository;
        this.memberService = memberService;
        this.modelMapper = modelMapper;
    }

    @Transactional
    public GymMembershipDTO createGymMembershipService(GymMembershipDTO requestDTO, String memberEmail) {
        Member member = memberRepository.findByEmail(memberEmail)
                .orElseThrow(() -> new EntityNotFoundException("Member not found with email: " + memberEmail));

        GymMembership gymMembership = modelMapper.map(requestDTO, GymMembership.class);
        gymMembership.setMember(member);
        GymMembership savedGymMembership = gymMembershipRepository.save(gymMembership);
        GymMembershipDTO responseDTO = modelMapper.map(savedGymMembership, GymMembershipDTO.class);
        responseDTO.setName(member.getName());
        return responseDTO;
    }

    @Transactional
    public List<GymMembershipDTO> getAllGymMemberships() {
        List<GymMembership> gymMemberships = gymMembershipRepository.findAll();
        return gymMemberships.stream()
                .map(gymMembership -> {
                    GymMembershipDTO dto = modelMapper.map(gymMembership, GymMembershipDTO.class);
                    dto.setName(gymMembership.getMember().getName());
                    return dto;
                })
                .collect(Collectors.toList());
    }
    @Transactional
    public GymMembershipDTO getGymMembershipByMe() {
        MemberResponseDto myInfoBySecurity = memberService.getMyInfoBySecurity();
        Member member = memberRepository.findById(myInfoBySecurity.getId())
                .orElseThrow(() -> new EntityNotFoundException("Member not found"));
        GymMembership gymMembership = member.getGymMembership();
        GymMembershipDTO dto = modelMapper.map(gymMembership, GymMembershipDTO.class);
        dto.setName(gymMembership.getMember().getName());
        return dto;
    }

    @Transactional
    public GymMembershipDTO updateGymMembership(GymMembershipDTO requestDTO, String memberEmail) {
        Member member = memberRepository.findByEmail(memberEmail).orElse(null);
        GymMembership gymMembership = member.getGymMembership();
        if (requestDTO.getStartDate()!= null) {
            System.out.println(requestDTO.getStartDate());
            gymMembership.setStartDate(requestDTO.getStartDate());
        }
        if (requestDTO.getEndDate()!= null) {
            gymMembership.setEndDate(requestDTO.getEndDate());
        }
        requestDTO.setName(gymMembership.getMember().getName());
        GymMembership savedGymMembership = gymMembershipRepository.save(gymMembership);
        return modelMapper.map(savedGymMembership, GymMembershipDTO.class);
    }

    @Transactional
    public void deleteGymMembership(String memberEmail) {
        Member member = memberRepository.findByEmail(memberEmail).orElse(null);
        GymMembership gymMembership = member.getGymMembership();
        gymMembershipRepository.delete(gymMembership);
    }
}

PTSubscriptionService.java

- 헬스장 PT 이용권 CRUD

@Service
@Component
@EnableScheduling
public class PTSubscriptionService {
    private final PTSubscriptionRepository ptSubscriptionRepository;
    private final ReservationRepository reservationRepository;

    private final MemberRepository memberRepository;
    private final TrainerRepository trainerRepository;
    private final MemberService memberService;
    private final ModelMapper modelMapper;

    public PTSubscriptionService(PTSubscriptionRepository ptSubscriptionRepository, ReservationRepository reservationRepository, MemberService memberService,
                                 MemberRepository memberRepository, ModelMapper modelMapper, TrainerRepository trainerRepository) {
        this.ptSubscriptionRepository = ptSubscriptionRepository;
        this.reservationRepository = reservationRepository;
        this.memberService = memberService;
        this.memberRepository = memberRepository;
        this.trainerRepository = trainerRepository;
        this.modelMapper = modelMapper;
    }

    @Transactional
    public PTSubscriptionRequestDTO createPTSubscription(PTSubscriptionRequestDTO requestDTO,String memberEmail) {
        Member member = memberRepository.findByEmail(memberEmail)
                .orElseThrow(() -> new EntityNotFoundException("Member not found with email: " + memberEmail));
        System.out.println(member.getName());

        PTSubscription ptSubscription = modelMapper.map(requestDTO, PTSubscription.class);
        ptSubscription.setMember(member);

        PTSubscription savedPtSubscription = ptSubscriptionRepository.save(ptSubscription);
        System.out.println(savedPtSubscription.getMember().getName());
        PTSubscriptionRequestDTO responseDTO = modelMapper.map(savedPtSubscription, PTSubscriptionRequestDTO.class);
        responseDTO.setName(member.getName());
        return responseDTO;
    }

    @Transactional
    public List<PTSubscriptionRequestDTO> getAllPTSubscriptions() {
        List<PTSubscription> ptSubscriptions = ptSubscriptionRepository.findAll();
        return ptSubscriptions.stream()
                .map(ptSubscription -> {
                    PTSubscriptionRequestDTO dto = modelMapper.map(ptSubscription, PTSubscriptionRequestDTO.class);
                    dto.setName(ptSubscription.getMember().getName());
                    return dto;
                })
                .collect(Collectors.toList());
    }
    @Transactional
    public PTSubscriptionRequestDTO getPTSubscriptionByMe() {
        MemberResponseDto myInfoBySecurity = memberService.getMyInfoBySecurity();
        Member member = memberRepository.findById(myInfoBySecurity.getId())
                .orElseThrow(() -> new EntityNotFoundException("Member not found"));
        PTSubscription ptSubscription = member.getPtSubscription();
        PTSubscriptionRequestDTO dto = modelMapper.map(ptSubscription, PTSubscriptionRequestDTO.class);
        dto.setName(ptSubscription.getMember().getName());
        return dto;
    }

    @Transactional
    public PTSubscriptionRequestDTO updatePTSubscription(PTSubscriptionRequestDTO requestDTO,String memberEmail) {
        Member member = memberRepository.findByEmail(memberEmail).orElse(null);
        PTSubscription ptSubscription = member.getPtSubscription();
        if (requestDTO.getAvailableCount() != null) {
            ptSubscription.setAvailableCount(requestDTO.getAvailableCount());
        }
        if (requestDTO.getUsedCount() != null) {
            ptSubscription.setUsedCount(requestDTO.getUsedCount());
        }
        PTSubscription savedPtSubscription = ptSubscriptionRepository.save(ptSubscription);
        PTSubscriptionRequestDTO dto = modelMapper.map(savedPtSubscription, PTSubscriptionRequestDTO.class);
        dto.setName(ptSubscription.getMember().getName());
        return dto;
    }

    @Transactional
    public void deletePTSubscription(String memberEmail) {
        Member member = memberRepository.findByEmail(memberEmail).orElse(null);
        PTSubscription ptSubscription = member.getPtSubscription();
        ptSubscriptionRepository.delete(ptSubscription);
    }
}

ReservationService.java

- PT예약 정보 CRUD

- 스케줄링을 이용해 예약정보 시간과 비교하여 이용권 차감

@Service
public class ReservationService {
    private final ReservationRepository reservationRepository;
    private final PTSubscriptionRepository ptSubscriptionRepository;
    private final MemberService memberService;
    private final ModelMapper modelMapper;
    private final MemberRepository memberRepository;
    private final TrainerRepository trainerRepository;

    public ReservationService(ReservationRepository reservationRepository, PTSubscriptionRepository ptSubscriptionRepository, MemberService memberService
                              ,ModelMapper modelMapper,MemberRepository memberRepository, TrainerRepository trainerRepository){
        this.reservationRepository = reservationRepository;
        this.ptSubscriptionRepository = ptSubscriptionRepository;
        this.memberService = memberService;
        this.modelMapper = modelMapper;
        this.memberRepository = memberRepository;
        this.trainerRepository = trainerRepository;
    }

    // PT 예약 생성
    public ReservationRequestDTO createReservation(ReservationRequestDTO requestDTO) {
        MemberResponseDto myInfoBySecurity = memberService.getMyInfoBySecurity();
        requestDTO.setMemberId(myInfoBySecurity.getId());

        Reservation reservation = modelMapper.map(requestDTO, Reservation.class);
        Member member = memberRepository.findById(myInfoBySecurity.getId())
                .orElseThrow(() -> new EntityNotFoundException("Member not found"));
        System.out.println(requestDTO.getReservationTrainerId());
        Trainer trainer = trainerRepository.findById(requestDTO.getReservationTrainerId()).orElse(null);
        reservation.setMember(member);
        reservation.setTrainer(trainer);
        Reservation savedReservation = reservationRepository.save(reservation);

        return modelMapper.map(savedReservation, ReservationRequestDTO.class);
    }

    @Transactional
    public List<ReservationRequestDTO> getAllReservations() {
        List<Reservation> reservations = reservationRepository.findAll();
        return reservations.stream()
                .map(reservation -> {
                    ReservationRequestDTO dto = modelMapper.map(reservation, ReservationRequestDTO.class);
                    dto.setMemberName(reservation.getMember().getName()); // 멤버 이름 설정
                    dto.setTrainerName(reservation.getTrainer().getName()); // 트레이너 이름 설정
                    dto.setMemberEmail(reservation.getMember().getEmail());
                    return dto;
                })
                .collect(Collectors.toList());
    }

    @Transactional
    public ReservationRequestDTO updateReservation(Long id, ReservationRequestDTO requestDTO){
        Reservation reservation = reservationRepository.findById(id).orElse(null);

        if (requestDTO.getReservationTrainerId() != null) {
            reservation.setTrainer(trainerRepository.findById(requestDTO.getReservationTrainerId()).orElse(null));
        }
        if (requestDTO.getReservationTime() != null) {
            reservation.setReservationTime(requestDTO.getReservationTime());
        }
        requestDTO.setMemberName(reservation.getMember().getName());
        requestDTO.setTrainerName(reservation.getTrainer().getName());
        requestDTO.setMemberEmail(reservation.getMember().getEmail());
        Reservation savedReservation = reservationRepository.save(reservation);
        return modelMapper.map(savedReservation,ReservationRequestDTO.class);
    }


    @Transactional
    public ReservationRequestDTO updateMyReservation(ReservationRequestDTO requestDTO){
        MemberResponseDto myInfoBySecurity = memberService.getMyInfoBySecurity();
        requestDTO.setMemberId(myInfoBySecurity.getId());
        Reservation reservation = reservationRepository.findById(myInfoBySecurity.getId()).orElse(null);
        if (requestDTO.getReservationTrainerId() != null) {
            reservation.setTrainer(trainerRepository.findById(requestDTO.getReservationTrainerId()).orElse(null));
        }
        if (requestDTO.getReservationTime() != null) {
            reservation.setReservationTime(requestDTO.getReservationTime());
        }
        requestDTO.setMemberName(reservation.getMember().getName());
        requestDTO.setTrainerName(reservation.getTrainer().getName());
        requestDTO.setMemberEmail(reservation.getMember().getEmail());
        Reservation savedReservation = reservationRepository.save(reservation);
        return modelMapper.map(savedReservation,ReservationRequestDTO.class);
        }



    // PT 예약 취소
    @Transactional
    public void cancelReservationMe() {
        MemberResponseDto myInfoBySecurity = memberService.getMyInfoBySecurity();
        Member member = memberRepository.findById(myInfoBySecurity.getId())
                .orElseThrow(() -> new EntityNotFoundException("Member not found"));
        LocalDateTime currentDateTime = LocalDateTime.now();

        // 현재 사용자의 정보를 기반으로 현재 시간 이후의 예약 정보를 가져옵니다.
        List<Reservation> reservations = reservationRepository.findByMemberAndReservationTimeAfter(member, currentDateTime);


        for (Reservation reservation : reservations) {
            reservationRepository.delete(reservation);
        }

    }
    @Transactional
    public void cancelReservation(Long id) {
        Reservation reservation = reservationRepository.findById(id).orElse(null);
        reservationRepository.delete(reservation);

    }

    @Transactional
    public List<ReservationRequestDTO> getReservationsByMe() {
        MemberResponseDto myInfoBySecurity = memberService.getMyInfoBySecurity();
        Member member = memberRepository.findById(myInfoBySecurity.getId())
                .orElseThrow(() -> new EntityNotFoundException("Member not found"));

        List<Reservation> reservations = member.getReservations();

        if (reservations.isEmpty()) {
            throw new EntityNotFoundException("Reservations not found for the member");
        }

        return reservations.stream()
                .map(reservation -> {
                    ReservationRequestDTO reservationRequestDTO = modelMapper.map(reservation, ReservationRequestDTO.class);
                    reservationRequestDTO.setMemberName(member.getName());
                    reservationRequestDTO.setTrainerName(reservation.getTrainer().getName());
                    reservationRequestDTO.setMemberEmail(reservation.getMember().getEmail());
                    return reservationRequestDTO;
                })
                .collect(Collectors.toList());
    }

    @Scheduled(cron = "0 * * * * *") // 매 시간마다 실행
    public void deductPTSubscriptionAutomatically() {
        LocalDateTime currentDateTime = LocalDateTime.now();

        // 예약된 PT 이용권 중 현재 시간에 해당하는 것을 차감
        List<Reservation> reservations = reservationRepository.findByReservationTimeBefore(currentDateTime);

        for (Reservation reservation : reservations) {
            Member member = reservation.getMember();
            if (member.getPtSubscription() != null && member.getPtSubscription().getAvailableCount() > 0 && !reservation.isExpired()) {
                PTSubscription ptSubscription = member.getPtSubscription();

                // 사용 가능한 횟수 차감
                int availableCount = ptSubscription.getAvailableCount();
                ptSubscription.setAvailableCount(availableCount - 1);

                // 사용된 횟수 증가
                int usedCount = ptSubscription.getUsedCount();
                ptSubscription.setUsedCount(usedCount + 1);
                reservation.setExpired(true);

                reservationRepository.save(reservation);
                // PTSubscription 엔티티 저장
                ptSubscriptionRepository.save(ptSubscription);
            }
        }
    }

TrainerService.java

- 트레이너 CRUD

@Service
@Component
public class TrainerService {
    private final TrainerRepository trainerRepository;
    private final ModelMapper modelMapper;

    public TrainerService(TrainerRepository trainerRepository, ModelMapper modelMapper){
        this.trainerRepository = trainerRepository;
        this.modelMapper = modelMapper;
    }

    public TrainerDto createTrainer(TrainerDto trainerDto){
        Trainer trainer = modelMapper.map(trainerDto,Trainer.class);
        System.out.println(trainer.getName());
        Trainer savedTrainer = trainerRepository.save(trainer);
        TrainerDto savedDto = modelMapper.map(savedTrainer,TrainerDto.class);
        return savedDto;
    }

    public List<TrainerDto> getAllTrainer(){
        List<Trainer> trainers = trainerRepository.findAll();
        return trainers.stream()
                .map(trainer -> modelMapper.map(trainer,TrainerDto.class))
                .collect(Collectors.toList());
    }

}