ng-tracker/src/main/java/ru/ulstu/project/service/ProjectService.java

package ru.ulstu.project.service;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.thymeleaf.util.StringUtils;
import ru.ulstu.deadline.service.DeadlineService;
import ru.ulstu.file.service.FileService;
import ru.ulstu.grant.repository.GrantRepository;
import ru.ulstu.project.model.Project;
import ru.ulstu.project.model.ProjectDto;
import ru.ulstu.project.repository.ProjectRepository;
import ru.ulstu.user.model.User;
import ru.ulstu.user.service.UserService;
import ru.ulstu.user.model.User;

import java.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import static org.springframework.util.ObjectUtils.isEmpty;
import static ru.ulstu.core.util.StreamApiUtils.convert;
import static ru.ulstu.project.model.Project.ProjectStatus.TECHNICAL_TASK;

@Service
public class ProjectService {
    private final static int MAX_DISPLAY_SIZE = 40;

    private final ProjectRepository projectRepository;
    private final DeadlineService deadlineService;
    private final GrantRepository grantRepository;
    private final FileService fileService;
    private final UserService userService;

    public ProjectService(ProjectRepository projectRepository,
                          DeadlineService deadlineService,
                          GrantRepository grantRepository,
                          FileService fileService,
                          UserService userService) {
        this.projectRepository = projectRepository;
        this.deadlineService = deadlineService;
        this.grantRepository = grantRepository;
        this.fileService = fileService;
        this.userService = userService;
    }

    public List<Project> findAll() {
        return projectRepository.findAll();
    }

    public List<ProjectDto> findAllDto() {
        List<ProjectDto> projects = convert(findAll(), ProjectDto::new);
        projects.forEach(projectDto -> projectDto.setTitle(StringUtils.abbreviate(projectDto.getTitle(), MAX_DISPLAY_SIZE)));
        return projects;
    }

    public ProjectDto findOneDto(Integer id) {
        return new ProjectDto(projectRepository.findOne(id));
    }

    public List<Project.ProjectStatus> getProjectStatuses() {
        return Arrays.asList(Project.ProjectStatus.values());
    }

    @Transactional
    public Project create(ProjectDto projectDto) throws IOException {
        Project newProject = copyFromDto(new Project(), projectDto);
        newProject = projectRepository.save(newProject);
        if (projectDto.getStatus() == Project.ProjectStatus.IN_WORK) {
            userService.createActivityTookToWork(newProject.getExecutors());
        }
        return newProject;
    }

    @Transactional
    public Project update(ProjectDto projectDto) throws IOException {
        Project project = projectRepository.findOne(projectDto.getId());
        if (projectDto.getApplicationFileName() != null && project.getApplication() != null) {
            fileService.deleteFile(project.getApplication());
        }
        projectRepository.save(copyFromDto(project, projectDto));
        if (projectDto.getStatus() == Project.ProjectStatus.IN_WORK) {
            userService.createActivityTookToWork(project.getExecutors());
        }
        return project;
    }

    @Transactional
    public void delete(Integer projectId) throws IOException {
        Project project = projectRepository.findOne(projectId);
        if (project.getApplication() != null) {
            fileService.deleteFile(project.getApplication());
        }
        projectRepository.delete(project);
    }

    private Project copyFromDto(Project project, ProjectDto projectDto) throws IOException {
        project.setDescription(projectDto.getDescription());
        project.setStatus(projectDto.getStatus() == null ? TECHNICAL_TASK : projectDto.getStatus());
        project.setTitle(projectDto.getTitle());
        if (projectDto.getGrant() != null && projectDto.getGrant().getId() != null) {
            project.setGrant(grantRepository.findOne(projectDto.getGrant().getId()));
        }
        project.setRepository(projectDto.getRepository());
        project.setDeadlines(deadlineService.saveOrCreate(projectDto.getDeadlines()));
        if (projectDto.getApplicationFileName() != null) {
            project.setApplication(fileService.createFileFromTmp(projectDto.getApplicationFileName()));
        }
        return project;
    }

    public Project save(ProjectDto projectDto) throws IOException {
        if (isEmpty(projectDto.getId())) {
            return create(projectDto);
        } else {
            return update(projectDto);
        }
    }

    public void removeDeadline(ProjectDto projectDto, Integer deadlineId) {
        if (deadlineId != null) {
            projectDto.getRemovedDeadlineIds().add(deadlineId);
        }
        projectDto.getDeadlines().remove((int) deadlineId);
    }

    public Project findById(Integer id) {
        return projectRepository.findOne(id);
    }

    public List<Project> getByUserAndStatusAndInterval(User user, Project.ProjectStatus status, Date dateFrom, Date dateTo) {
        return projectRepository.findByAuthorHasAndStatus(user, status, dateFrom, dateTo);
    }

    public List<User> getProjectExecutors(ProjectDto projectDto) {
        List<User> users = userService.findAll();
        return users;
    }

}