330 lines
14 KiB
Java
330 lines
14 KiB
Java
package ru.ulstu.activity.conference.service;
|
||
|
||
import org.springframework.data.domain.Page;
|
||
import org.springframework.stereotype.Service;
|
||
import org.springframework.transaction.annotation.Transactional;
|
||
import org.springframework.ui.ModelMap;
|
||
import org.springframework.validation.Errors;
|
||
import ru.ulstu.activity.common.service.AbstractActivityService;
|
||
import ru.ulstu.activity.conference.model.Conference;
|
||
import ru.ulstu.activity.conference.model.ConferenceDto;
|
||
import ru.ulstu.activity.conference.model.ConferenceFilterDto;
|
||
import ru.ulstu.activity.conference.model.ConferenceListDto;
|
||
import ru.ulstu.activity.conference.model.ConferenceUser;
|
||
import ru.ulstu.activity.conference.repository.ConferenceRepository;
|
||
import ru.ulstu.activity.deadline.model.Deadline;
|
||
import ru.ulstu.activity.deadline.service.DeadlineService;
|
||
import ru.ulstu.activity.paper.model.Paper;
|
||
import ru.ulstu.activity.paper.service.PaperService;
|
||
import ru.ulstu.activity.ping.service.PingService;
|
||
import ru.ulstu.activity.timeline.service.EventService;
|
||
import ru.ulstu.core.jpa.OffsetablePageRequest;
|
||
import ru.ulstu.core.model.response.PageableItems;
|
||
import ru.ulstu.user.model.User;
|
||
import ru.ulstu.user.service.UserService;
|
||
|
||
import java.io.IOException;
|
||
import java.util.Arrays;
|
||
import java.util.Collections;
|
||
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 extends AbstractActivityService<ConferenceListDto, Conference, ConferenceDto> {
|
||
|
||
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.activityRepository = conferenceRepository;
|
||
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 = new ConferenceDto(conferenceRepository.getOne(id));
|
||
conferenceDto.setNotSelectedPapers(getNotSelectPapers(conferenceDto.getPaperIds()));
|
||
conferenceDto.setDisabledTakePart(isCurrentUserParticipant(conferenceDto.getUsers()));
|
||
return conferenceDto;
|
||
}
|
||
|
||
public PageableItems<Conference> findAll(int offset, int count) {
|
||
final Page<Conference> page = conferenceRepository.findAll(new OffsetablePageRequest(offset, count));
|
||
return new PageableItems<>(page.getTotalElements(), page.getContent());
|
||
}
|
||
|
||
public boolean save(ConferenceDto conferenceDto, Errors errors) throws IOException {
|
||
conferenceDto.setTitle(conferenceDto.getTitle());
|
||
filterEmptyDeadlines(conferenceDto);
|
||
checkEmptyFieldsOfDeadline(conferenceDto, errors);
|
||
checkEmptyFieldsOfDates(conferenceDto, errors);
|
||
if (!checkUniqueName(conferenceDto.getTitle(), conferenceDto.getId())) {
|
||
throw new RuntimeException("Название не уникально");
|
||
}
|
||
|
||
if (isEmpty(conferenceDto.getId())) {
|
||
create(conferenceDto);
|
||
} else {
|
||
update(conferenceDto);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
@Transactional
|
||
@Override
|
||
public ConferenceDto create(ConferenceDto conferenceDto) {
|
||
Conference newConference;
|
||
try {
|
||
newConference = copyFromDto(new Conference(), conferenceDto);
|
||
} catch (IOException e) {
|
||
throw new RuntimeException(e);
|
||
}
|
||
return new ConferenceDto(create(newConference));
|
||
}
|
||
|
||
@Transactional
|
||
@Override
|
||
public Conference create(Conference conference) {
|
||
conference = conferenceRepository.save(conference);
|
||
conferenceNotificationService.sendCreateNotification(conference);
|
||
eventService.createFromObject(conference, Collections.emptyList(), false, "конференции");
|
||
return conference;
|
||
}
|
||
|
||
@Transactional
|
||
@Override
|
||
public ConferenceDto update(ConferenceDto conferenceDto) {
|
||
Conference conference = conferenceRepository.getOne(conferenceDto.getId());
|
||
try {
|
||
conferenceRepository.save(copyFromDto(conference, conferenceDto));
|
||
} catch (IOException e) {
|
||
throw new RuntimeException(e);
|
||
}
|
||
return new ConferenceDto(update(conference));
|
||
}
|
||
|
||
@Transactional
|
||
@Override
|
||
public Conference update(Conference conference) {
|
||
List<Deadline> oldDeadlines = conference.getDeadlines().stream()
|
||
.map(this::copyDeadline)
|
||
.collect(Collectors.toList());
|
||
Date oldBeginDate = conference.getBeginDate();
|
||
Date oldEndDate = conference.getEndDate();
|
||
eventService.updateConferenceDeadlines(conference);
|
||
sendNotificationAfterUpdateDeadlines(conference, oldDeadlines);
|
||
if (!conference.getBeginDate().equals(oldBeginDate) || !conference.getEndDate().equals(oldEndDate)) {
|
||
conferenceNotificationService.updateConferencesDatesNotification(conference, oldBeginDate, oldEndDate);
|
||
}
|
||
return conference;
|
||
}
|
||
|
||
@Transactional
|
||
public boolean delete(Integer conferenceId) {
|
||
if (conferenceRepository.existsById(conferenceId)) {
|
||
eventService.removeConferencesEvent(conferenceRepository.getOne(conferenceId));
|
||
conferenceRepository.deleteById(conferenceId);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
@Override
|
||
protected ConferenceListDto getActivityListDto(Conference entity) {
|
||
return new ConferenceListDto(entity);
|
||
}
|
||
|
||
public ConferenceDto addDeadline(ConferenceDto conferenceDto) {
|
||
conferenceDto.getDeadlines().add(new Deadline());
|
||
return conferenceDto;
|
||
}
|
||
|
||
|
||
public ConferenceDto 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);
|
||
return conferenceDto;
|
||
}
|
||
|
||
public ConferenceDto 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);
|
||
return conferenceDto;
|
||
}
|
||
|
||
public ConferenceDto removePaper(ConferenceDto conferenceDto, Integer paperIndex) throws IOException {
|
||
Paper removedPaper = conferenceDto.getPapers().remove((int) paperIndex);
|
||
if (removedPaper.getId() != null) {
|
||
conferenceDto.getNotSelectedPapers().add(removedPaper);
|
||
}
|
||
return conferenceDto;
|
||
}
|
||
|
||
public ConferenceDto takePart(ConferenceDto conferenceDto) throws IOException {
|
||
conferenceDto.getUsers().add(new ConferenceUser(userService.getCurrentUser()));
|
||
conferenceDto.setDisabledTakePart(true);
|
||
return conferenceDto;
|
||
}
|
||
|
||
private 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;
|
||
}
|
||
|
||
|
||
private 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);
|
||
}
|
||
|
||
private 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());
|
||
}
|
||
|
||
private Conference findOne(Integer conferenceId) {
|
||
return conferenceRepository.getOne(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);
|
||
}
|
||
|
||
private void sendNotificationAfterUpdateDeadlines(Conference conference, List<Deadline> oldDeadlines) {
|
||
if (oldDeadlines.size() != conference.getDeadlines().size()) {
|
||
conferenceNotificationService.updateDeadlineNotification(conference);
|
||
return;
|
||
}
|
||
|
||
if (conference.getDeadlines()
|
||
.stream()
|
||
.filter(deadline -> !oldDeadlines.contains(deadline))
|
||
.count() > 0) {
|
||
conferenceNotificationService.updateDeadlineNotification(conference);
|
||
}
|
||
}
|
||
|
||
private Deadline copyDeadline(Deadline oldDeadline) {
|
||
Deadline newDeadline = new Deadline(oldDeadline.getDate(), oldDeadline.getDescription());
|
||
newDeadline.setId(oldDeadline.getId());
|
||
return newDeadline;
|
||
}
|
||
|
||
private void checkEmptyFieldsOfDeadline(ConferenceDto conferenceDto, Errors errors) {
|
||
for (Deadline deadline : conferenceDto.getDeadlines()) {
|
||
if (deadline.getDate() == null || deadline.getDescription().isEmpty()) {
|
||
errors.rejectValue("deadlines", "errorCode", "Все поля дедлайна должны быть заполнены");
|
||
}
|
||
}
|
||
}
|
||
|
||
private void checkEmptyFieldsOfDates(ConferenceDto conferenceDto, Errors errors) {
|
||
if (conferenceDto.getBeginDate() == null || conferenceDto.getEndDate() == null) {
|
||
errors.rejectValue("beginDate", "errorCode", "Даты должны быть заполнены");
|
||
}
|
||
}
|
||
|
||
public void filterEmptyDeadlines(ConferenceDto conferenceDto) {
|
||
conferenceDto.setDeadlines(conferenceDto.getDeadlines().stream()
|
||
.filter(dto -> dto.getDate() != null || !org.springframework.util.StringUtils.isEmpty(dto.getDescription()))
|
||
.collect(Collectors.toList()));
|
||
}
|
||
|
||
public Conference getActiveConferenceByUser(User user) {
|
||
return conferenceRepository.findActiveByUser(user);
|
||
}
|
||
}
|