fix another controller

src/main/java/ru/ulstu/activity/api/ActivityRepository.java

@@ -1,9 +1,15 @@
 package ru.ulstu.activity.api;
 
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.repository.query.Param;
 
 public interface ActivityRepository<T> {
     String findByNameAndNotId(@Param("name") String name, @Param("id") Integer id);
 
     T save(T t);
+
+    T getById(Integer id);
+
+    Page<T> findAll(Pageable pageable);
 }

src/main/java/ru/ulstu/activity/common/service/ActivityService.java

@@ -1,11 +1,13 @@
 package ru.ulstu.activity.common.service;
 
+import org.springframework.data.domain.Page;
 import org.springframework.transaction.annotation.Transactional;
 import ru.ulstu.activity.api.ActivityRepository;
 import ru.ulstu.activity.api.model.ActivityDto;
 import ru.ulstu.activity.api.model.ActivityListDto;
 import ru.ulstu.activity.common.model.AbstractActivity;
 import ru.ulstu.activity.ping.service.PingService;
+import ru.ulstu.core.jpa.OffsetablePageRequest;
 import ru.ulstu.core.model.response.PageableItems;
 
 import java.io.IOException;
@@ -37,6 +39,22 @@ public abstract class ActivityService<L extends ActivityListDto, T extends Abstr
         return getNewActivityDto(create(newEntity));
     }
 
+    @Transactional
+    public T update(T entity) {
+        return activityRepository.save(entity);
+    }
+
+    @Transactional
+    public D update(D entityDto) {
+        T newEntity;
+        try {
+            newEntity = copyFromDto(activityRepository.getById(entityDto.getId()), entityDto);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        return getNewActivityDto(update(newEntity));
+    }
+
     @Transactional
     public T create(T entity) {
         T newEntity = activityRepository.save(entity);
@@ -44,15 +62,15 @@ public abstract class ActivityService<L extends ActivityListDto, T extends Abstr
         return newEntity;
     }
 
-    public abstract T update(T entity);
-
-    public abstract D update(D entity);
-
     public abstract boolean delete(Integer id);
 
     public abstract T findById(Integer id);
 
-    public abstract PageableItems<T> findAll(int offset, int count);
+
+    public PageableItems<T> findAll(int offset, int count) {
+        final Page<T> page = activityRepository.findAll(new OffsetablePageRequest(offset, count));
+        return new PageableItems<>(page.getTotalElements(), page.getContent());
+    }
 
     public PageableItems<L> findAllDto(int offset, int count) {
         return convertPageable(findAll(offset, count), entity -> getActivityListDto(entity));

src/main/java/ru/ulstu/activity/conference/service/ConferenceService.java

@@ -71,11 +71,6 @@ public class ConferenceService extends ActivityService<ConferenceListDto, Confer
         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);

src/main/java/ru/ulstu/activity/grant/service/GrantService.java

@@ -20,7 +20,6 @@ import ru.ulstu.activity.paper.model.Paper;
 import ru.ulstu.activity.paper.model.PaperDto;
 import ru.ulstu.activity.paper.service.PaperService;
 import ru.ulstu.activity.ping.service.PingService;
-import ru.ulstu.activity.project.model.ProjectDto;
 import ru.ulstu.activity.project.service.ProjectService;
 import ru.ulstu.activity.timeline.service.EventService;
 import ru.ulstu.core.jpa.OffsetablePageRequest;
@@ -172,12 +171,6 @@ public class GrantService extends ActivityService<GrantListDto, Grant, GrantDto>
         return grant;
     }
 
-
-    public void createProject(GrantDto grantDto) throws IOException {
-        grantDto.setProject(
-                new ProjectDto(projectService.save(new ProjectDto(grantDto.getTitle()))));
-    }
-
     @Transactional
     public boolean delete(Integer grantId) {
         Grant grant = findById(grantId);

src/main/java/ru/ulstu/activity/paper/service/PaperService.java

@@ -102,13 +102,6 @@ public class PaperService extends ActivityService<PaperListDto, Paper, PaperDto>
         return new PageableItems<>(activePapersPage.getTotalElements(), sortPapers(activePapersPage.getContent()));
     }
 
-    public Paper update(Paper paper) {
-        paperRepository.save(paper);
-        paperNotificationService.sendCreateNotification(paper, oldAuthors);
-        paperNotificationService.statusChangeNotification(paper, oldStatus);
-        return paper;
-    }
-
     @Transactional
     public PaperDto update(PaperDto paperDto) {
         Paper paper = findById(paperDto.getId());

src/main/java/ru/ulstu/activity/project/controller/ProjectController.java

@@ -1,127 +1,68 @@
 package ru.ulstu.activity.project.controller;
 
-import org.springframework.stereotype.Controller;
-import org.springframework.ui.ModelMap;
-import org.springframework.validation.Errors;
+import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.ResponseBody;
-import ru.ulstu.activity.deadline.model.Deadline;
-import ru.ulstu.activity.grant.model.GrantDto;
-import ru.ulstu.activity.project.model.Project;
+import org.springframework.web.bind.annotation.RestController;
+import ru.ulstu.activity.api.ActivityController;
+import ru.ulstu.activity.project.model.ProjectDashboardDto;
 import ru.ulstu.activity.project.model.ProjectDto;
+import ru.ulstu.activity.project.model.ProjectListDto;
 import ru.ulstu.activity.project.service.ProjectService;
-import ru.ulstu.user.model.User;
-import springfox.documentation.annotations.ApiIgnore;
+import ru.ulstu.configuration.Constants;
+import ru.ulstu.core.model.response.PageableItems;
+import ru.ulstu.core.model.response.Response;
 
 import javax.validation.Valid;
-import java.io.IOException;
-import java.util.List;
-import java.util.stream.Collectors;
 
-import static org.springframework.util.StringUtils.isEmpty;
-
-@Controller()
-@RequestMapping(value = "/projects")
-@ApiIgnore
-public class ProjectController {
+@RestController
+@RequestMapping(Constants.API_1_0 + "projects")
+public class ProjectController implements ActivityController<ProjectListDto, ProjectDashboardDto, ProjectDto> {
     private final ProjectService projectService;
 
     public ProjectController(ProjectService projectService) {
         this.projectService = projectService;
     }
 
-    @GetMapping("/dashboard")
-    public void getDashboard(ModelMap modelMap) {
-        modelMap.put("projects", projectService.findAllDto());
-    }
-
-    @GetMapping("/projects")
-    public void getProjects(ModelMap modelMap) {
-        modelMap.put("projects", projectService.findAllDto());
-    }
-
-    @GetMapping("/project")
-    public void getProject(ModelMap modelMap, @RequestParam(value = "id") Integer id) {
-        if (id != null && id > 0) {
-            ProjectDto projectDto = projectService.findOneDto(id);
-            attachGrant(projectDto);
-            modelMap.put("projectDto", projectService.findOneDto(id));
-        } else {
-            modelMap.put("projectDto", new ProjectDto());
-        }
-    }
-
-    @ModelAttribute("allStatuses")
-    public List<Project.ProjectStatus> getProjectStatuses() {
-        return projectService.getProjectStatuses();
-    }
-
-    @PostMapping(value = "/project", params = "save")
-    public String save(@Valid ProjectDto projectDto, Errors errors) throws IOException {
-        filterEmptyDeadlines(projectDto);
-        if (projectDto.getDeadlines().isEmpty()) {
-            errors.rejectValue("deadlines", "errorCode", "Не может быть пустым");
-        }
-        if (errors.hasErrors()) {
-            return "/projects/project";
-        }
-        projectService.save(projectDto);
-        return String.format("redirect:%s", "/projects/projects");
-    }
-
-    @PostMapping(value = "/project", params = "attachGrant")
-    public String attachGrant(ProjectDto projectDto) {
-        projectService.attachGrant(projectDto);
-        return "/projects/project";
-    }
-
-    @PostMapping(value = "/project", params = "addDeadline")
-    public String addDeadline(@Valid ProjectDto projectDto, Errors errors) {
-        filterEmptyDeadlines(projectDto);
-        if (errors.hasErrors()) {
-            return "/projects/project";
-        }
-        projectDto.getDeadlines().add(new Deadline());
-        return "/projects/project";
+    @GetMapping("list")
+    public Response<PageableItems<ProjectListDto>> getList(@RequestParam(value = "offset", defaultValue = "0") int offset,
+                                                           @RequestParam(value = "count", defaultValue = "10") int count) {
+        return new Response<>(projectService.findAllDto(offset, count));
     }
 
-    @PostMapping(value = "/project", params = "removeDeadline")
-    public String removeDeadline(ProjectDto projectDto,
-                                 @RequestParam(value = "removeDeadline") Integer deadlineId) {
-        projectService.removeDeadline(projectDto, deadlineId);
-        return "/projects/project";
+    @GetMapping("dashboard")
+    public Response<PageableItems<ProjectDashboardDto>> getDashboard(@RequestParam(value = "offset", defaultValue = "0") int offset,
+                                                                     @RequestParam(value = "count", defaultValue = "10") int count) {
+        return new Response<>(projectService.findAllActiveDto(offset, count));
     }
 
-    @GetMapping("/delete/{project-id}")
-    public String delete(@PathVariable("project-id") Integer projectId) throws IOException {
-        projectService.delete(projectId);
-        return String.format("redirect:%s", "/projects/projects");
+    @GetMapping("{project-id}")
+    public Response<ProjectDto> get(@PathVariable("project-id") Integer projectId) {
+        return new Response<>(projectService.findProjectById(projectId));
     }
 
-    @ModelAttribute("allExecutors")
-    public List<User> getAllExecutors(ProjectDto projectDto) {
-        return projectService.getProjectExecutors(projectDto);
+    @PostMapping
+    public Response<ProjectDto> create(@RequestBody @Valid ProjectDto projectDto) {
+        return new Response<>(projectService.create(projectDto));
     }
 
-    @ModelAttribute("allGrants")
-    public List<GrantDto> getAllGrants() {
-        return projectService.getAllGrants();
+    @PutMapping
+    public Response<ProjectDto> update(@RequestBody @Valid ProjectDto projectDto) {
+        return new Response<>(projectService.update(projectDto));
     }
 
-    private void filterEmptyDeadlines(ProjectDto projectDto) {
-        projectDto.setDeadlines(projectDto.getDeadlines().stream()
-                .filter(dto -> dto.getDate() != null || !isEmpty(dto.getDescription()))
-                .collect(Collectors.toList()));
+    @DeleteMapping("/{project-id}")
+    public Response<Boolean> delete(@PathVariable("project-id") Integer projectId) {
+        return new Response<>(projectService.delete(projectId));
     }
 
-    @ResponseBody
-    @PostMapping(value = "/ping")
-    public void ping(@RequestParam("projectId") int projectId) throws IOException {
+    @PostMapping("ping/{project-id}")
+    public void ping(@PathVariable("project-id") int projectId) {
         projectService.ping(projectId);
     }
 }

src/main/java/ru/ulstu/activity/project/model/ProjectDashboardDto.java

@@ -0,0 +1,27 @@
+package ru.ulstu.activity.project.model;
+
+import ru.ulstu.activity.api.model.ActivityDashboardDto;
+import ru.ulstu.activity.common.model.ScienceGroupMemberDto;
+
+import java.util.List;
+
+import static ru.ulstu.core.util.StreamApiUtils.convert;
+
+public class ProjectDashboardDto extends ActivityDashboardDto {
+    private final Project.ProjectStatus status;
+    private final List<ScienceGroupMemberDto> executors;
+
+    public ProjectDashboardDto(Project project) {
+        super(project.getId(), project.getTitle());
+        this.status = project.getStatus();
+        this.executors = convert(project.getExecutors(), ScienceGroupMemberDto::new);
+    }
+
+    public Project.ProjectStatus getStatus() {
+        return status;
+    }
+
+    public List<ScienceGroupMemberDto> getExecutors() {
+        return executors;
+    }
+}

src/main/java/ru/ulstu/activity/project/model/ProjectDto.java

@@ -2,7 +2,7 @@ package ru.ulstu.activity.project.model;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import org.thymeleaf.util.StringUtils;
+import ru.ulstu.activity.api.model.ActivityDto;
 import ru.ulstu.activity.deadline.model.Deadline;
 import ru.ulstu.activity.file.model.FileDataDto;
 import ru.ulstu.activity.grant.model.GrantDto;
@@ -14,13 +14,10 @@ import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 import static ru.ulstu.core.util.StreamApiUtils.convert;
 
-public class ProjectDto {
-    private Integer id;
-
+public class ProjectDto extends ActivityDto {
     @NotEmpty
     private String title;
     private Project.ProjectStatus status;
@@ -35,15 +32,6 @@ public class ProjectDto {
     private List<Integer> grantIds;
     private List<GrantDto> grants;
 
-    private final static int MAX_EXECUTORS_LENGTH = 40;
-
-    public ProjectDto() {
-    }
-
-    public ProjectDto(String title) {
-        this.title = title;
-    }
-
     @JsonCreator
     public ProjectDto(@JsonProperty("id") Integer id,
                       @JsonProperty("title") String title,
@@ -57,7 +45,7 @@ public class ProjectDto {
                       @JsonProperty("executors") List<UserDto> executors,
                       @JsonProperty("grantIds") List<Integer> grantIds,
                       @JsonProperty("grants") List<GrantDto> grants) {
-        this.id = id;
+        super(id);
         this.title = title;
         this.status = status;
         this.description = description;
@@ -73,8 +61,8 @@ public class ProjectDto {
 
 
     public ProjectDto(Project project) {
-        Set<User> users = new HashSet<User>(project.getExecutors());
-        this.id = project.getId();
+        super(project.getId());
+        Set<User> users = new HashSet<>(project.getExecutors());
         this.title = project.getTitle();
         this.status = project.getStatus();
         this.description = project.getDescription();
@@ -88,14 +76,6 @@ public class ProjectDto {
         this.grants = convert(project.getGrants(), GrantDto::new);
     }
 
-    public Integer getId() {
-        return id;
-    }
-
-    public void setId(Integer id) {
-        this.id = id;
-    }
-
     public String getTitle() {
         return title;
     }
@@ -176,13 +156,6 @@ public class ProjectDto {
         this.executors = executors;
     }
 
-    public String getExecutorsString() {
-        return StringUtils.abbreviate(executors
-                .stream()
-                .map(executor -> executor.getLastName())
-                .collect(Collectors.joining(", ")), MAX_EXECUTORS_LENGTH);
-    }
-
     public List<Integer> getGrantIds() {
         return grantIds;
     }

src/main/java/ru/ulstu/activity/project/model/ProjectListDto.java

@@ -0,0 +1,27 @@
+package ru.ulstu.activity.project.model;
+
+import ru.ulstu.activity.api.model.ActivityListDto;
+import ru.ulstu.activity.common.model.ScienceGroupMemberDto;
+
+import java.util.List;
+
+import static ru.ulstu.core.util.StreamApiUtils.convert;
+
+public class ProjectListDto extends ActivityListDto {
+    private final Project.ProjectStatus status;
+    private final List<ScienceGroupMemberDto> executors;
+
+    public ProjectListDto(Project project) {
+        super(project.getId(), project.getTitle());
+        this.status = project.getStatus();
+        this.executors = convert(project.getExecutors(), ScienceGroupMemberDto::new);
+    }
+
+    public Project.ProjectStatus getStatus() {
+        return status;
+    }
+
+    public List<ScienceGroupMemberDto> getExecutors() {
+        return executors;
+    }
+}

src/main/java/ru/ulstu/activity/project/repository/ProjectRepository.java

@@ -1,8 +1,14 @@
 package ru.ulstu.activity.project.repository;
 
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import ru.ulstu.activity.api.ActivityRepository;
 import ru.ulstu.activity.project.model.Project;
 
-public interface ProjectRepository extends JpaRepository<Project, Integer> {
-
+public interface ProjectRepository extends JpaRepository<Project, Integer>, ActivityRepository<Project> {
+    @Query("SELECT p FROM Project p WHERE p.status NOT IN (:statuses)")
+    Page<Project> findAllWithoutStatuses(Pageable pageable, @Param("statuses") Project.ProjectStatus... statuses);
 }

src/main/java/ru/ulstu/activity/project/service/ProjectNotificationService.java

@@ -0,0 +1,20 @@
+package ru.ulstu.activity.project.service;
+
+import org.springframework.stereotype.Service;
+import ru.ulstu.activity.common.service.ActivityNotificationService;
+import ru.ulstu.activity.project.model.Project;
+import ru.ulstu.user.service.MailService;
+
+@Service
+public class ProjectNotificationService extends ActivityNotificationService<Project> {
+
+    private final MailService mailService;
+
+    public ProjectNotificationService(MailService mailService) {
+        this.mailService = mailService;
+    }
+
+    public void sendCreateNotification(Project project) {
+        throw new RuntimeException("not implemented yet");
+    }
+}

src/main/java/ru/ulstu/activity/project/service/ProjectService.java

@@ -1,100 +1,68 @@
 package ru.ulstu.activity.project.service;
 
+import org.springframework.data.domain.Page;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import org.thymeleaf.util.StringUtils;
+import ru.ulstu.activity.common.service.ActivityService;
 import ru.ulstu.activity.deadline.service.DeadlineService;
-import ru.ulstu.activity.file.model.FileDataDto;
 import ru.ulstu.activity.file.service.FileService;
-import ru.ulstu.activity.grant.model.GrantDto;
-import ru.ulstu.activity.grant.repository.GrantRepository;
+import ru.ulstu.activity.grant.service.GrantService;
 import ru.ulstu.activity.ping.service.PingService;
 import ru.ulstu.activity.project.model.Project;
+import ru.ulstu.activity.project.model.ProjectDashboardDto;
 import ru.ulstu.activity.project.model.ProjectDto;
+import ru.ulstu.activity.project.model.ProjectListDto;
 import ru.ulstu.activity.project.repository.ProjectRepository;
-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.List;
 
 import static java.util.stream.Collectors.toList;
-import static org.springframework.util.ObjectUtils.isEmpty;
+import static ru.ulstu.activity.project.model.Project.ProjectStatus.CLOSED;
+import static ru.ulstu.activity.project.model.Project.ProjectStatus.FAILED;
 import static ru.ulstu.activity.project.model.Project.ProjectStatus.TECHNICAL_TASK;
-import static ru.ulstu.core.util.StreamApiUtils.convert;
+import static ru.ulstu.core.util.StreamApiUtils.convertPageable;
 
 @Service
-public class ProjectService {
-    private final static int MAX_DISPLAY_SIZE = 40;
-
+public class ProjectService extends ActivityService<ProjectListDto, Project, ProjectDto> {
     private final ProjectRepository projectRepository;
     private final DeadlineService deadlineService;
-    private final GrantRepository grantRepository;
+    private final GrantService grantService;
     private final FileService fileService;
-    private final EventService eventService;
     private final UserService userService;
     private final PingService pingService;
 
     public ProjectService(ProjectRepository projectRepository,
+                          ProjectNotificationService projectNotificationService,
                           DeadlineService deadlineService,
-                          GrantRepository grantRepository,
+                          GrantService grantService,
                           FileService fileService,
-                          EventService eventService,
                           UserService userService,
                           PingService pingService) {
+        super(projectRepository, projectNotificationService, pingService);
         this.projectRepository = projectRepository;
         this.deadlineService = deadlineService;
-        this.grantRepository = grantRepository;
+        this.grantService = grantService;
         this.fileService = fileService;
-        this.eventService = eventService;
         this.userService = userService;
         this.pingService = pingService;
     }
 
-    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.getOne(id));
-    }
-
-    public List<Project.ProjectStatus> getProjectStatuses() {
-        return Arrays.asList(Project.ProjectStatus.values());
+    public PageableItems<ProjectDashboardDto> findAllActiveDto(int offset, int count) {
+        return convertPageable(findAllActive(offset, count), ProjectDashboardDto::new);
     }
 
-    @Transactional
-    public Project create(ProjectDto projectDto) throws IOException {
-        Project newProject = copyFromDto(new Project(), projectDto);
-        newProject = projectRepository.save(newProject);
-        eventService.createFromObject(newProject, Collections.emptyList(), false, "проекта");
-        return newProject;
+    private PageableItems<Project> findAllActive(int offset, int count) {
+        Page<Project> activeProjectPage = projectRepository.findAllWithoutStatuses(new OffsetablePageRequest(offset, count), CLOSED, FAILED);
+        return new PageableItems<>(activeProjectPage.getTotalElements(), activeProjectPage.getContent());
     }
 
     @Transactional
-    private Project update(ProjectDto projectDto) throws IOException {
-        Project project = projectRepository.getOne(projectDto.getId());
-        projectRepository.save(copyFromDto(project, projectDto));
-        eventService.updateProjectDeadlines(project);
-        for (FileDataDto file : projectDto.getFiles().stream()
-                .filter(f -> f.isDeleted() && f.getId() != null)
-                .collect(toList())) {
-            fileService.delete(file.getId());
-        }
-        return project;
-    }
-
-    @Transactional
-    public boolean delete(Integer projectId) throws IOException {
+    public boolean delete(Integer projectId) {
         if (projectRepository.existsById(projectId)) {
             Project project = projectRepository.getOne(projectId);
             projectRepository.delete(project);
@@ -103,12 +71,12 @@ public class ProjectService {
         return false;
     }
 
-    private Project copyFromDto(Project project, ProjectDto projectDto) throws IOException {
+    protected 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.getOne(projectDto.getGrant().getId()));
+            project.setGrant(grantService.findById(projectDto.getGrant().getId()));
         }
         project.setRepository(projectDto.getRepository());
         project.setDeadlines(deadlineService.saveOrCreate(projectDto.getDeadlines()));
@@ -117,17 +85,24 @@ public class ProjectService {
                 .collect(toList())));
         project.getGrants().clear();
         if (projectDto.getGrantIds() != null && !projectDto.getGrantIds().isEmpty()) {
-            projectDto.getGrantIds().forEach(grantIds -> project.getGrants().add(grantRepository.findGrantById(grantIds)));
+            projectDto.getGrantIds().forEach(grantIds -> project.getGrants().add(grantService.findById(grantIds)));
         }
         return project;
     }
 
-    public Project save(ProjectDto projectDto) throws IOException {
-        if (isEmpty(projectDto.getId())) {
-            return create(projectDto);
-        } else {
-            return update(projectDto);
-        }
+    @Override
+    protected ProjectListDto getActivityListDto(Project entity) {
+        return new ProjectListDto(entity);
+    }
+
+    @Override
+    protected Project getNewActivity() {
+        return new Project();
+    }
+
+    @Override
+    protected ProjectDto getNewActivityDto(Project entity) {
+        return new ProjectDto(entity);
     }
 
     public ProjectDto removeDeadline(ProjectDto projectDto, Integer deadlineId) {
@@ -146,26 +121,7 @@ public class ProjectService {
         return userService.findAll();
     }
 
-    @Transactional
-    public void ping(int projectId) {
-        pingService.addPing(findById(projectId));
-    }
-
-    public List<GrantDto> getAllGrants() {
-        return convert(grantRepository.findAll(), GrantDto::new);
+    public ProjectDto findProjectById(Integer projectId) {
+        return getNewActivityDto(findById(projectId));
     }
-
-    private List<GrantDto> getProjectGrants(List<Integer> grantIds) {
-        return convert(grantRepository.findAllById(grantIds), GrantDto::new);
-    }
-
-    public void attachGrant(ProjectDto projectDto) {
-        if (!projectDto.getGrantIds().isEmpty()) {
-            projectDto.getGrants().clear();
-            projectDto.setGrants(getProjectGrants(projectDto.getGrantIds()));
-        } else {
-            projectDto.getGrants().clear();
-        }
-    }
-
-}
+}

src/test/java/project/ProjectServiceTest.java

@@ -93,7 +93,7 @@ public class ProjectServiceTest {
     @Test
     public void findAll() {
         when(projectRepository.findAll()).thenReturn(projects);
-        assertEquals(projects, projectService.findAll());
+        assertEquals(projects, projectService.findAll(0, 100).getItems());
     }
 
     @Test
@@ -137,8 +137,8 @@ public class ProjectServiceTest {
     }
 
     @Test
-    public void removeDeadline() throws IOException {
-        ProjectDto newProjectDto = new ProjectDto();
+    public void removeDeadline() {
+        ProjectDto newProjectDto = new ProjectDto(null);
         newProjectDto.getRemovedDeadlineIds().add(INDEX);
         projectDto.getDeadlines().add(deadline);
         ProjectDto result = projectService.removeDeadline(projectDto, INDEX);