278 lines
12 KiB
Java
278 lines
12 KiB
Java
package ru.ulstu.conference.service;
|
|
|
|
import org.apache.commons.lang3.StringUtils;
|
|
import org.springframework.data.domain.Sort;
|
|
import org.springframework.stereotype.Service;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
import org.springframework.ui.ModelMap;
|
|
import ru.ulstu.conference.model.Conference;
|
|
import ru.ulstu.conference.model.ConferenceDto;
|
|
import ru.ulstu.conference.model.ConferenceFilterDto;
|
|
import ru.ulstu.conference.model.ConferenceUser;
|
|
import ru.ulstu.conference.repository.ConferenceRepository;
|
|
import ru.ulstu.deadline.model.Deadline;
|
|
import ru.ulstu.deadline.service.DeadlineService;
|
|
import ru.ulstu.paper.model.Paper;
|
|
import ru.ulstu.paper.service.PaperService;
|
|
import ru.ulstu.ping.service.PingService;
|
|
import ru.ulstu.timeline.service.EventService;
|
|
import ru.ulstu.user.model.User;
|
|
import ru.ulstu.user.service.UserService;
|
|
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
import java.util.stream.Collectors;
|
|
|
|
import static org.springframework.util.ObjectUtils.isEmpty;
|
|
import static ru.ulstu.core.util.StreamApiUtils.convert;
|
|
|
|
@Service
|
|
public class ConferenceService {
|
|
private final static int MAX_DISPLAY_SIZE = 40;
|
|
|
|
private final ConferenceRepository conferenceRepository;
|
|
private final ConferenceUserService conferenceUserService;
|
|
private final DeadlineService deadlineService;
|
|
private final PaperService paperService;
|
|
private final UserService userService;
|
|
private final PingService pingService;
|
|
private final ConferenceNotificationService conferenceNotificationService;
|
|
private final EventService eventService;
|
|
|
|
public ConferenceService(ConferenceRepository conferenceRepository,
|
|
ConferenceUserService conferenceUserService,
|
|
DeadlineService deadlineService,
|
|
PaperService paperService,
|
|
UserService userService,
|
|
PingService pingService,
|
|
ConferenceNotificationService conferenceNotificationService,
|
|
EventService eventService) {
|
|
this.conferenceRepository = conferenceRepository;
|
|
this.conferenceUserService = conferenceUserService;
|
|
this.deadlineService = deadlineService;
|
|
this.paperService = paperService;
|
|
this.userService = userService;
|
|
this.pingService = pingService;
|
|
this.conferenceNotificationService = conferenceNotificationService;
|
|
this.eventService = eventService;
|
|
}
|
|
|
|
public ConferenceDto getExistConferenceById(Integer id) {
|
|
ConferenceDto conferenceDto = findOneDto(id);
|
|
conferenceDto.setNotSelectedPapers(getNotSelectPapers(conferenceDto.getPaperIds()));
|
|
conferenceDto.setDisabledTakePart(isCurrentUserParticipant(conferenceDto.getUsers()));
|
|
return conferenceDto;
|
|
}
|
|
|
|
public ConferenceDto getNewConference() {
|
|
ConferenceDto conferenceDto = new ConferenceDto();
|
|
conferenceDto.setNotSelectedPapers(getNotSelectPapers(new ArrayList<Integer>()));
|
|
return conferenceDto;
|
|
}
|
|
|
|
|
|
public List<Conference> findAll() {
|
|
return conferenceRepository.findAll(new Sort(Sort.Direction.DESC, "beginDate"));
|
|
}
|
|
|
|
public List<ConferenceDto> findAllDto() {
|
|
List<ConferenceDto> conferences = convert(findAll(), ConferenceDto::new);
|
|
conferences.forEach(conferenceDto -> conferenceDto.setTitle(StringUtils.abbreviate(conferenceDto.getTitle(), MAX_DISPLAY_SIZE)));
|
|
return conferences;
|
|
}
|
|
|
|
public ConferenceDto findOneDto(Integer id) {
|
|
return new ConferenceDto(conferenceRepository.findOne(id));
|
|
}
|
|
|
|
public void save(ConferenceDto conferenceDto) throws IOException {
|
|
if (isEmpty(conferenceDto.getId())) {
|
|
create(conferenceDto);
|
|
} else {
|
|
update(conferenceDto);
|
|
}
|
|
}
|
|
|
|
@Transactional
|
|
public Integer create(ConferenceDto conferenceDto) throws IOException {
|
|
Conference newConference = copyFromDto(new Conference(), conferenceDto);
|
|
newConference = conferenceRepository.save(newConference);
|
|
conferenceNotificationService.sendCreateNotification(newConference);
|
|
eventService.createFromConference(newConference);
|
|
return newConference.getId();
|
|
}
|
|
|
|
@Transactional
|
|
public Integer update(ConferenceDto conferenceDto) throws IOException {
|
|
Conference conference = conferenceRepository.findOne(conferenceDto.getId());
|
|
List<Deadline> oldDeadlines = conference.getDeadlines().stream()
|
|
.map(this::copyDeadline)
|
|
.collect(Collectors.toList());
|
|
Date oldBeginDate = conference.getBeginDate();
|
|
Date oldEndDate = conference.getEndDate();
|
|
conferenceRepository.save(copyFromDto(conference, conferenceDto));
|
|
eventService.updateConferenceDeadlines(conference);
|
|
sendNotificationAfterUpdate(conference, oldDeadlines, oldBeginDate, oldEndDate);
|
|
conferenceDto.getRemovedDeadlineIds().forEach(deadlineService::remove);
|
|
return conference.getId();
|
|
}
|
|
|
|
@Transactional
|
|
public void delete(Integer conferenceId) {
|
|
if (conferenceRepository.exists(conferenceId)) {
|
|
conferenceRepository.delete(conferenceId);
|
|
}
|
|
}
|
|
|
|
public void removeDeadline(ConferenceDto conferenceDto, Integer deadlineIndex) throws IOException {
|
|
if (conferenceDto.getDeadlines().get(deadlineIndex).getId() != null) {
|
|
conferenceDto.getRemovedDeadlineIds().add(conferenceDto.getDeadlines().get(deadlineIndex).getId());
|
|
}
|
|
conferenceDto.getDeadlines().remove((int) deadlineIndex);
|
|
}
|
|
|
|
public void addPaper(ConferenceDto conferenceDto) {
|
|
Paper paper = new Paper();
|
|
paper.setTitle(userService.getCurrentUser().getLastName() + "_" + conferenceDto.getTitle() + "_" + (new Date()).getTime());
|
|
paper.setStatus(Paper.PaperStatus.DRAFT);
|
|
|
|
conferenceDto.getPapers().add(paper);
|
|
}
|
|
|
|
public void removePaper(ConferenceDto conferenceDto, Integer paperIndex) throws IOException {
|
|
Paper removedPaper = conferenceDto.getPapers().remove((int) paperIndex);
|
|
if (removedPaper.getId() != null) {
|
|
conferenceDto.getNotSelectedPapers().add(removedPaper);
|
|
}
|
|
}
|
|
|
|
public void takePart(ConferenceDto conferenceDto) throws IOException {
|
|
conferenceDto.getUsers().add(new ConferenceUser(userService.getCurrentUser()));
|
|
conferenceDto.setDisabledTakePart(true);
|
|
}
|
|
|
|
public List<Paper> getNotSelectPapers(List<Integer> paperIds) {
|
|
return paperService.findAllNotSelect(paperIds);
|
|
}
|
|
|
|
public List<User> getAllUsers() {
|
|
return userService.findAll();
|
|
}
|
|
|
|
public List<ConferenceUser.Participation> getAllParticipations() {
|
|
return Arrays.asList(ConferenceUser.Participation.values());
|
|
}
|
|
|
|
public List<ConferenceUser.Deposit> getAllDeposit() {
|
|
return Arrays.asList(ConferenceUser.Deposit.values());
|
|
}
|
|
|
|
private Conference copyFromDto(Conference conference, ConferenceDto conferenceDto) throws IOException {
|
|
conference.setTitle(conferenceDto.getTitle());
|
|
conference.setDescription(conferenceDto.getDescription());
|
|
conference.setUrl(conferenceDto.getUrl());
|
|
conference.setBeginDate(conferenceDto.getBeginDate());
|
|
conference.setEndDate(conferenceDto.getEndDate());
|
|
conference.getPapers().clear();
|
|
conferenceDto.getPapers().forEach(paper -> conference.getPapers().add(paper.getId() != null ? paperService.findPaperById(paper.getId()) : paperService.create(paper)));
|
|
conference.setDeadlines(deadlineService.saveOrCreate(conferenceDto.getDeadlines()));
|
|
conference.setUsers(conferenceUserService.saveOrCreate(conferenceDto.getUsers()));
|
|
if (conferenceDto.getPaperIds() != null && !conferenceDto.getPaperIds().isEmpty()) {
|
|
conferenceDto.getPaperIds().forEach(paperId ->
|
|
conference.getPapers().add(paperService.findPaperById(paperId)));
|
|
}
|
|
return conference;
|
|
}
|
|
|
|
|
|
public boolean isCurrentUserParticipant(List<ConferenceUser> conferenceUsers) {
|
|
return conferenceUsers.stream().anyMatch(participant -> participant.getUser().equals(userService.getCurrentUser()));
|
|
}
|
|
|
|
public List<ConferenceDto> filter(ConferenceFilterDto conferenceFilterDto) {
|
|
return convert(conferenceRepository.findByUserAndYear(
|
|
conferenceFilterDto.getFilterUserId() == null ? null : userService.findById(conferenceFilterDto.getFilterUserId()),
|
|
conferenceFilterDto.getYear()), ConferenceDto::new);
|
|
|
|
}
|
|
|
|
public List<ConferenceDto> findAllActiveDto() {
|
|
return convert(findAllActive(), ConferenceDto::new);
|
|
}
|
|
|
|
public List<Conference> findAllActive() {
|
|
return conferenceRepository.findAllActive(new Date());
|
|
}
|
|
|
|
public boolean isAttachedToConference(Integer paperId) {
|
|
return conferenceRepository.isPaperAttached(paperId);
|
|
}
|
|
|
|
@Transactional
|
|
public void ping(ConferenceDto conferenceDto) throws IOException {
|
|
pingService.addPing(findOne(conferenceDto.getId()));
|
|
conferenceRepository.updatePingConference(conferenceDto.getId());
|
|
}
|
|
|
|
public Conference findOne(Integer conferenceId) {
|
|
return conferenceRepository.findOne(conferenceId);
|
|
}
|
|
|
|
public void setChartData(ModelMap modelMap) {
|
|
//first, add the regional sales
|
|
Integer northeastSales = 17089;
|
|
Integer westSales = 10603;
|
|
Integer midwestSales = 5223;
|
|
Integer southSales = 10111;
|
|
|
|
modelMap.addAttribute("northeastSales", northeastSales);
|
|
modelMap.addAttribute("southSales", southSales);
|
|
modelMap.addAttribute("midwestSales", midwestSales);
|
|
modelMap.addAttribute("westSales", westSales);
|
|
|
|
//now add sales by lure type
|
|
List<Integer> inshoreSales = Arrays.asList(4074, 3455, 4112);
|
|
List<Integer> nearshoreSales = Arrays.asList(3222, 3011, 3788);
|
|
List<Integer> offshoreSales = Arrays.asList(7811, 7098, 6455);
|
|
|
|
modelMap.addAttribute("inshoreSales", inshoreSales);
|
|
modelMap.addAttribute("nearshoreSales", nearshoreSales);
|
|
modelMap.addAttribute("offshoreSales", offshoreSales);
|
|
}
|
|
|
|
public void sendNotificationAfterUpdate(Conference conference, List<Deadline> oldDeadlines, Date oldBeginDate, Date oldEndDate) {
|
|
boolean isSendNotificationAboutDeadlines = false;
|
|
if (oldDeadlines.size() != conference.getDeadlines().size()) {
|
|
isSendNotificationAboutDeadlines = true;
|
|
}
|
|
for (Deadline deadline : conference.getDeadlines()) {
|
|
if (isSendNotificationAboutDeadlines) {
|
|
break;
|
|
}
|
|
for (Deadline oldDeadline : oldDeadlines) {
|
|
if (deadline.getId().equals(oldDeadline.getId())) {
|
|
if (!deadline.getDescription().equals(oldDeadline.getDescription()) || !deadline.getDate().equals(oldDeadline.getDate())) {
|
|
isSendNotificationAboutDeadlines = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isSendNotificationAboutDeadlines) {
|
|
conferenceNotificationService.updateDeadlineNotification(conference);
|
|
}
|
|
if (!conference.getBeginDate().equals(oldBeginDate) || !conference.getEndDate().equals(oldEndDate)) {
|
|
conferenceNotificationService.updateConferencesDatesNotification(conference, oldBeginDate, oldEndDate);
|
|
}
|
|
}
|
|
|
|
public Deadline copyDeadline(Deadline oldDeadline) {
|
|
Deadline newDeadline = new Deadline(oldDeadline.getDate(), oldDeadline.getDescription());
|
|
newDeadline.setId(oldDeadline.getId());
|
|
return newDeadline;
|
|
}
|
|
}
|