Merge branch '個資同意'

wayne

2021-12-03 6576d44fb39c4875fa56eaa105956153bec3efd8

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
package com.pollex.pam.service;
 
import java.time.Instant;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
 
import com.pollex.pam.enums.AppointmentStatusEnum;
import com.pollex.pam.service.dto.AppointmentDTO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import com.pollex.pam.domain.Appointment;
import com.pollex.pam.domain.AppointmentCustomerView;
import com.pollex.pam.enums.ContactStatusEnum;
import com.pollex.pam.repository.AppointmentCustomerViewRepository;
import com.pollex.pam.repository.AppointmentRepository;
import com.pollex.pam.security.SecurityUtils;
import com.pollex.pam.service.dto.AppointmentCreateDTO;
import com.pollex.pam.service.dto.AppointmentCustomerViewDTO;
import com.pollex.pam.service.mapper.AppointmentCustomerViewMapper;
import com.pollex.pam.service.mapper.AppointmentDTOMapper;
import com.pollex.pam.web.rest.errors.AppointmentNotFoundException;
 
import static com.pollex.pam.enums.AppointmentStatusEnum.AVAILABLE;
import static com.pollex.pam.enums.AppointmentStatusEnum.DELETED;
 
@Service
@Transactional
public class AppointmentService {
 
    private static final Logger log = LoggerFactory.getLogger(AppointmentService.class);
 
    @Autowired
    AppointmentRepository appointmentRepository;
 
    @Autowired
    AppointmentDTOMapper appointmentDTOMapper;
 
    @Autowired
    ConsultantService consultantService;
 
    @Autowired
    AppointmentCustomerViewMapper appointmentCustomerViewMapper;
 
    @Autowired
    AppointmentCustomerViewRepository appointmentCustomerViewRepository;
 
    @Autowired
    SatisfactionService satisfactionService;
 
    public void customerCreateAppointment(AppointmentCreateDTO appointmentCreateDTO) {
        Appointment appointment = appointmentDTOMapper.toAppointment(appointmentCreateDTO);
        appointment.setStatus(AVAILABLE);
        appointment.setCustomerId(SecurityUtils.getCustomerDBId());
        appointment.setCommunicateStatus(ContactStatusEnum.RESERVED);
        appointmentRepository.save(appointment);
    }
 
    public void updateAppointment(AppointmentDTO appointmentDTO) {
        Appointment appointment = appointmentDTOMapper.toAppointment(appointmentDTO);
        appointment.setStatus(AVAILABLE);
        appointmentRepository.save(appointment);
    }
 
    public void markAppointmentDeleted(Long appointmentId) {
        Appointment appointment = appointmentRepository.findById(appointmentId).get();
        appointment.setStatus(DELETED);
        appointmentRepository.save(appointment);
    }
 
    public List<Appointment> findByAgentNo(String agentNo) {
        return appointmentRepository.findByAgentNo(agentNo);
    }
 
    public Appointment markAsContacted(Long appointmentId) {
 
        Appointment appointment = appointmentRepository.findById(appointmentId).get();
        appointment.setCommunicateStatus(ContactStatusEnum.CONTACTED);
        appointment.setContactTime(Instant.now());
        return appointmentRepository.save(appointment);
    }
 
    public AppointmentCustomerViewDTO getAppointmentDetail(Long appointmentId) {
        AppointmentCustomerView appointment = appointmentCustomerViewRepository.findById(appointmentId)
                .orElseThrow(AppointmentNotFoundException::new);
        return appointmentCustomerViewMapper.toAppointmentCustomerViewDTO(appointment);
    }
 
    public List<AppointmentCustomerView> findAvailableByAgentNoAndCustomerId(String agentNo, Long customerId) {
        return appointmentCustomerViewRepository.findByAgentNoAndCustomerId(agentNo, customerId)
            .stream()
            .filter(appointmentCustomerView -> appointmentCustomerView.getStatus() == AVAILABLE)
            .collect(Collectors.toList());
    }
 
    public void recordConsultantReadTime(Long appointmentId) {
        Appointment appointment = appointmentRepository.findById(appointmentId).get();
 
        if(appointment.getConsultantReadTime() == null) {
            appointment.setConsultantReadTime(Instant.now());
            appointmentRepository.save(appointment);
        }
        else {
            log.debug("this appointment was read, read time = {}", appointment.getConsultantReadTime());
        }
    }
 
    public void recordAllAppointmentsView(String agentNo) {
        List<Appointment> consultantNotViewAppointments = findByAgentNo(agentNo)
            .stream()
            .filter(appointment -> Objects.isNull(appointment.getConsultantViewTime()))
            .collect(Collectors.toList());
 
        consultantNotViewAppointments.forEach(appointment -> appointment.setConsultantViewTime(Instant.now()));
        appointmentRepository.saveAll(consultantNotViewAppointments);
    }
 
    public List<AppointmentCustomerViewDTO> getConsultantAppointments(String agentNo) {
        return appointmentCustomerViewRepository.findByAgentNo(agentNo).stream()
            .filter(appointment -> appointment.getStatus() != DELETED)
            .map(appointmentCustomerViewMapper::toAppointmentCustomerViewDTO)
            .collect(Collectors.toList());
    }
}