package com.pollex.pam.service;
|
|
import com.pollex.pam.domain.AppointmentCustomerView;
|
import com.pollex.pam.domain.Consultant;
|
import com.pollex.pam.domain.CustomerFavoriteConsultant;
|
import com.pollex.pam.domain.Satisfaction;
|
import com.pollex.pam.enums.ContactStatusEnum;
|
import com.pollex.pam.enums.LoginResult;
|
import com.pollex.pam.repository.ConsultantRepository;
|
import com.pollex.pam.repository.CustomerFavoriteConsultantRepository;
|
import com.pollex.pam.security.SecurityUtils;
|
import com.pollex.pam.service.dto.*;
|
import com.pollex.pam.service.mapper.AppointmentCustomerViewMapper;
|
import com.pollex.pam.service.mapper.ConsultantMapper;
|
import com.pollex.pam.web.rest.errors.ConsultantNotFoundException;
|
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 java.util.Comparator;
|
import java.util.List;
|
import java.util.Optional;
|
import java.util.stream.Collectors;
|
|
@Service
|
public class ConsultantService {
|
|
private static final Logger log = LoggerFactory.getLogger(ConsultantService.class);
|
|
@Autowired
|
ConsultantRepository consultantRepository;
|
|
@Autowired
|
CustomerFavoriteConsultantRepository customerFavoriteConsultantRepository;
|
|
@Autowired
|
ConsultantMapper consultantMapper;
|
|
@Autowired
|
AppointmentService appointmentService;
|
|
@Autowired
|
LoginRecordService loginRecordService;
|
|
@Autowired
|
AppointmentCustomerViewMapper appointmentCustomerViewMapper;
|
|
@Autowired
|
SatisfactionService satisfactionService;
|
|
public List<CustomerFavoriteConsultantDTO> getMyConsultantList() {
|
Long customerId = SecurityUtils.getCustomerDBId();
|
|
return customerFavoriteConsultantRepository.findAllByCustomerId(customerId)
|
.stream()
|
.map(customerFavoriteConsultantRelation -> {
|
Consultant consultant = customerFavoriteConsultantRelation.getConsultant();
|
CustomerFavoriteConsultantDTO dto = consultantMapper.toCustomerFavoriteConsultantDto(consultant);
|
|
dto.setContactStatus(ContactStatusEnum.PICKED);
|
dto.setLatestAppointmentId(null);
|
dto.setLatestAppointmentDate(null);
|
dto.setLatestAppointmentScore(null);
|
dto.setCreateTime(customerFavoriteConsultantRelation.getLastModifiedDate());
|
|
setAppointmentInfo(
|
dto,
|
appointmentService.findAvailableByAgentNoAndCustomerId(consultant.getAgentNo(), customerId)
|
);
|
|
return dto;
|
|
}).collect(Collectors.toList());
|
}
|
|
private void setAppointmentInfo(CustomerFavoriteConsultantDTO dto, List<AppointmentCustomerView> appointmentList) {
|
List<AppointmentCustomerView> appointments = appointmentList.stream()
|
.sorted(Comparator.comparing(AppointmentCustomerView::getAppointmentDate).reversed())
|
.collect(Collectors.toList());
|
|
dto.setAppointments(appointmentCustomerViewMapper.toAppointmentCustomerViewDTO(appointments));
|
|
if (!appointments.isEmpty()) {
|
AppointmentCustomerView latestAppointment = appointments.get(0);
|
dto.setContactStatus(latestAppointment.getCommunicateStatus());
|
dto.setLatestAppointmentId(latestAppointment.getId());
|
dto.setLatestAppointmentDate(latestAppointment.getAppointmentDate());
|
dto.setUpdateTime(latestAppointment.getLastModifiedDate());
|
|
setLatestAppointmentScore(dto, latestAppointment);
|
}
|
}
|
|
private void setLatestAppointmentScore(CustomerFavoriteConsultantDTO dto, AppointmentCustomerView latestAppointment) {
|
Optional<Satisfaction> satisfactionOptional = satisfactionService.getByAppointmentId(latestAppointment.getId());
|
if(satisfactionOptional.isPresent()) {
|
Satisfaction satisfaction = satisfactionOptional.get();
|
dto.setLatestAppointmentScore(satisfaction.getScore());
|
}
|
else {
|
dto.setLatestAppointmentScore(null);
|
}
|
}
|
|
public List<ConsultantDTO> getRecommendConsultantList() {
|
return consultantRepository.findAllByRecommendIsTrue()
|
.stream()
|
.map(consultantMapper::toDto)
|
.collect(Collectors.toList());
|
}
|
|
public List<ConsultantDTO> strictQueryConsultant(StrictQueryConsultantParam param) {
|
return consultantRepository.findAll(ConsultantQuerySpec.getStrictQuerySpec(param))
|
.stream()
|
.map(consultantMapper::toDto)
|
.collect(Collectors.toList());
|
}
|
|
public List<ConsultantDTO> fastQueryConsultant(FastQueryConsultantParam param) {
|
return consultantRepository.findAll(ConsultantQuerySpec.getFastQuerySpec(param))
|
.stream()
|
.map(consultantMapper::toDto)
|
.collect(Collectors.toList());
|
}
|
|
public ConsultantDetailDTO getConsultantDetail(String agentNo) {
|
Consultant consultant = consultantRepository.findOneByAgentNo(agentNo).orElseThrow(ConsultantNotFoundException::new);
|
ConsultantDetailDTO consultantDetailDTO = consultantMapper.toDetailDto(consultant);
|
|
loginRecordService.findLatestLoginRecord(agentNo, LoginResult.SUCCESS)
|
.ifPresent(loginRecord -> consultantDetailDTO.setLatestLoginTime(loginRecord.getLoginDate()));
|
|
return consultantDetailDTO;
|
}
|
|
@Transactional
|
public void addConsultantToCustomList(AddConsultantParam param) {
|
List<String> agentNoList = param.getAgentNoList();
|
List<Consultant> consultants = consultantRepository.findAllByAgentNoIn(agentNoList);
|
Long userId = SecurityUtils.getCustomerDBId();
|
|
consultants.forEach(consultant -> {
|
boolean isConsultantInList = customerFavoriteConsultantRepository.findOneByCustomerIdAndConsultant(userId, consultant).isPresent();
|
|
if(!isConsultantInList) {
|
CustomerFavoriteConsultant customerFavoriteConsultant = new CustomerFavoriteConsultant();
|
customerFavoriteConsultant.setConsultant(consultant);
|
customerFavoriteConsultant.setCustomerId(userId);
|
|
customerFavoriteConsultantRepository.save(customerFavoriteConsultant);
|
}
|
else {
|
log.info("The consultant is in customer favorite list! customId = {}, consultant AgentNo = {}", userId, consultant.getAgentNo());
|
}
|
});
|
|
}
|
|
public List<AppointmentCustomerViewDTO> getMyAppointment() {
|
String agentNo = SecurityUtils.getAgentNo();
|
return appointmentService.getConsultantAppointments(agentNo);
|
}
|
|
public void removeConsultantFromCustomList(String agentNo) {
|
Long customId = SecurityUtils.getCustomerDBId();
|
Consultant consultant = consultantRepository.findOneByAgentNo(agentNo).orElseThrow(ConsultantNotFoundException::new);
|
CustomerFavoriteConsultant target = customerFavoriteConsultantRepository.findOneByCustomerIdAndConsultant(customId, consultant).orElse(null);
|
|
if(target != null) {
|
customerFavoriteConsultantRepository.delete(target);
|
}
|
else {
|
log.info("this consultant is not in customer list! agentNo = {}, customId = {}", agentNo, customId);
|
}
|
}
|
|
public void recordAllAppointmentsView() {
|
String agentNo = SecurityUtils.getAgentNo();
|
appointmentService.recordAllAppointmentsView(agentNo);
|
}
|
}
|
