core/src/main/java/modules/RepositoryModule.java

@@ -25,6 +25,8 @@ import se.su.dsv.scipro.report.GradingReportTemplateRepo;
 import se.su.dsv.scipro.report.GradingReportTemplateRepoImpl;
 import se.su.dsv.scipro.report.OppositionReportRepo;
 import se.su.dsv.scipro.report.OppositionReportRepoImpl;
+import se.su.dsv.scipro.report.SupervisorGradingReportRepository;
+import se.su.dsv.scipro.report.SupervisorGradingReportRepositoryImpl;
 import se.su.dsv.scipro.reviewing.DecisionRepository;
 import se.su.dsv.scipro.reviewing.DecisionRepositoryImpl;
 import se.su.dsv.scipro.reviewing.ReviewerTargetRepository;
@@ -59,5 +61,6 @@ public class RepositoryModule extends AbstractModule {
         bind(FinalSeminarRepository.class).to(FinalSeminarRepositoryImpl.class);
         bind(ReviewerTargetRepository.class).to(ReviewerTargetRepositoryImpl.class);
         bind(DecisionRepository.class).to(DecisionRepositoryImpl.class);
+        bind(SupervisorGradingReportRepository.class).to(SupervisorGradingReportRepositoryImpl.class);
     }
 }

core/src/main/java/se/su/dsv/scipro/report/GradingReportService.java

@@ -3,14 +3,13 @@ package se.su.dsv.scipro.report;
 import se.su.dsv.scipro.finalseminar.FinalSeminarOpposition;
 import se.su.dsv.scipro.grading.GradingBasis;
 import se.su.dsv.scipro.project.Project;
-import se.su.dsv.scipro.system.GenericService;
 import se.su.dsv.scipro.system.User;
 import se.su.dsv.scipro.util.Either;
 
 import java.time.Instant;
 import java.util.List;
 
-public interface GradingReportService extends GenericService<GradingReport, Long> {
+public interface GradingReportService {
 
     SupervisorGradingReport getSupervisorGradingReport(Project project, User student);
 

core/src/main/java/se/su/dsv/scipro/report/GradingReportServiceImpl.java

@@ -2,43 +2,42 @@ package se.su.dsv.scipro.report;
 
 import com.google.common.eventbus.EventBus;
 import com.google.inject.persist.Transactional;
-import jakarta.persistence.EntityManager;
 import se.su.dsv.scipro.finalseminar.FinalSeminarOpposition;
 import se.su.dsv.scipro.grading.GradingBasis;
 import se.su.dsv.scipro.grading.ThesisSubmissionHistoryService;
 import se.su.dsv.scipro.project.Project;
-import se.su.dsv.scipro.system.AbstractServiceImpl;
 import se.su.dsv.scipro.system.Language;
 import se.su.dsv.scipro.system.User;
 import se.su.dsv.scipro.util.Either;
 
 import jakarta.inject.Inject;
-import jakarta.inject.Named;
-import jakarta.inject.Provider;
 import java.time.Clock;
 import java.time.Instant;
 import java.util.*;
 
-@Named
+public class GradingReportServiceImpl implements GradingReportService {
-public class GradingReportServiceImpl extends AbstractServiceImpl<GradingReport, Long> implements GradingReportService {
 
     public static final String OPPOSITION_SWEDISH = "Ö1 Oppositionsrapport";
     public static final String OPPOSITION_ENGLISH = "Ö1 Opposition report";
     private final EventBus eventBus;
     private final ThesisSubmissionHistoryService thesisSubmissionHistoryService;
     private final Clock clock;
+    private final SupervisorGradingReportRepository supervisorGradingReportRepository;
+    private final GradingReportTemplateRepo gradingReportTemplateRepo;
 
     @Inject
     public GradingReportServiceImpl(
-            Provider<EntityManager> em,
             EventBus eventBus,
             ThesisSubmissionHistoryService thesisSubmissionHistoryService,
-            Clock clock)
+            Clock clock,
+            SupervisorGradingReportRepository supervisorGradingReportRepository,
+            GradingReportTemplateRepo gradingReportTemplateRepo)
     {
-        super(em, GradingReport.class, QGradingReport.gradingReport);
         this.eventBus = eventBus;
         this.thesisSubmissionHistoryService = thesisSubmissionHistoryService;
         this.clock = clock;
+        this.supervisorGradingReportRepository = supervisorGradingReportRepository;
+        this.gradingReportTemplateRepo = gradingReportTemplateRepo;
     }
 
     @Override
@@ -49,7 +48,7 @@ public class GradingReportServiceImpl extends AbstractServiceImpl<GradingReport,
             if (isOppositionCriterion && betterGrade) {
                 gradingCriterion.setFeedback(opposition.getFeedback());
                 gradingCriterion.setPoints(opposition.getPoints());
-                save(report);
+                supervisorGradingReportRepository.save(report);
                 return true;
             }
         }
@@ -88,7 +87,7 @@ public class GradingReportServiceImpl extends AbstractServiceImpl<GradingReport,
             }
             supervisorGradingReport.setMotivation(gradingBasis.getOverallMotivation());
             supervisorGradingReport.setRejectionCommentFeedback(gradingBasis.getRejectionCommentFeedback());
-            save(supervisorGradingReport);
+            supervisorGradingReportRepository.save(supervisorGradingReport);
         }
         return getGradingBasis(project);
     }
@@ -138,22 +137,18 @@ public class GradingReportServiceImpl extends AbstractServiceImpl<GradingReport,
     @Override
     @Transactional
     public SupervisorGradingReport getSupervisorGradingReport(Project project, User user) {
-        SupervisorGradingReport supervisorGradingReport = from(QSupervisorGradingReport.supervisorGradingReport)
+        SupervisorGradingReport supervisorGradingReport = supervisorGradingReportRepository.getReport(project, user);
-                .where(QSupervisorGradingReport.supervisorGradingReport.user.eq(user).and(
-                        QSupervisorGradingReport.supervisorGradingReport.project.eq(project)))
-                .fetchOne();
         if (supervisorGradingReport == null) {
-            supervisorGradingReport = save(getTemplate(project).createSupervisorReport(project, user));
+            GradingReportTemplate template = getTemplate(project);
+            SupervisorGradingReport supervisorReport = template.createSupervisorReport(project, user);
+            supervisorGradingReport = supervisorGradingReportRepository.save(supervisorReport);
         }
         return supervisorGradingReport;
     }
 
     @Override
     public GradingReportTemplate getTemplate(Project project) {
-        QGradingReportTemplate template = QGradingReportTemplate.gradingReportTemplate;
+        return gradingReportTemplateRepo.getTemplate(project);
-        return from(template)
-                .where(template.projectType.eq(project.getProjectType()).and(template.credits.eq(project.getCredits())))
-                .fetchOne();
     }
 
     @Override
@@ -192,7 +187,7 @@ public class GradingReportServiceImpl extends AbstractServiceImpl<GradingReport,
                     rejectionCommentFeedback);
         }
 
-        save(supervisorGradingReport);
+        supervisorGradingReportRepository.save(supervisorGradingReport);
         return Either.right(supervisorGradingReport);
     }
 

core/src/main/java/se/su/dsv/scipro/report/GradingReportTemplateRepo.java

@@ -1,8 +1,8 @@
 package se.su.dsv.scipro.report;
 
 import org.springframework.data.jpa.repository.JpaRepository;
-import se.su.dsv.scipro.system.ProjectType;
+import se.su.dsv.scipro.project.Project;
 
 public interface GradingReportTemplateRepo extends JpaRepository<GradingReportTemplate, Long> {
-    GradingReportTemplate findByProjectTypeAndCredits(ProjectType projectType, int credits);
+    GradingReportTemplate getTemplate(Project project);
 }

core/src/main/java/se/su/dsv/scipro/report/GradingReportTemplateRepoImpl.java

@@ -1,12 +1,11 @@
 package se.su.dsv.scipro.report;
 
+import se.su.dsv.scipro.project.Project;
 import se.su.dsv.scipro.system.GenericRepo;
-import se.su.dsv.scipro.system.ProjectType;
 
 import jakarta.inject.Inject;
 import jakarta.inject.Provider;
 import jakarta.persistence.EntityManager;
-import jakarta.persistence.TypedQuery;
 
 public class GradingReportTemplateRepoImpl extends GenericRepo<GradingReportTemplate, Long> implements GradingReportTemplateRepo {
     @Inject
@@ -15,10 +14,8 @@ public class GradingReportTemplateRepoImpl extends GenericRepo<GradingReportTemp
     }
 
     @Override
-    public GradingReportTemplate findByProjectTypeAndCredits(ProjectType projectType, int credits) {
+    public GradingReportTemplate getTemplate(Project project) {
-        TypedQuery<GradingReportTemplate> query = em().createQuery("select distinct template from GradingReportTemplate template where template.projectType = :projectType and template.credits = :credits", GradingReportTemplate.class);
+        QGradingReportTemplate template = QGradingReportTemplate.gradingReportTemplate;
-        query.setParameter("projectType", projectType);
+        return findOne(template.projectType.eq(project.getProjectType()).and(template.credits.eq(project.getCredits())));
-        query.setParameter("credits", credits);
-        return query.getSingleResult();
     }
 }

core/src/main/java/se/su/dsv/scipro/report/OppositionReportServiceImpl.java

@@ -33,7 +33,7 @@ public class OppositionReportServiceImpl implements OppositionReportService {
         if (oppositionReport != null) {
             return oppositionReport;
         } else {
-            OppositionReport newReport = gradingReportTemplateRepo.findByProjectTypeAndCredits(finalSeminarOpposition.getProjectType(), finalSeminarOpposition.getProject().getCredits())
+            OppositionReport newReport = gradingReportTemplateRepo.getTemplate(finalSeminarOpposition.getProject())
                     .createOppositionReport(finalSeminarOpposition);
             return oppositionReportRepo.save(newReport);
         }

core/src/main/java/se/su/dsv/scipro/report/SupervisorGradingReportRepository.java

@@ -0,0 +1,10 @@
+package se.su.dsv.scipro.report;
+
+import se.su.dsv.scipro.project.Project;
+import se.su.dsv.scipro.system.User;
+
+public interface SupervisorGradingReportRepository {
+    SupervisorGradingReport save(SupervisorGradingReport report);
+
+    SupervisorGradingReport getReport(Project project, User author);
+}

core/src/main/java/se/su/dsv/scipro/report/SupervisorGradingReportRepositoryImpl.java

@@ -0,0 +1,37 @@
+package se.su.dsv.scipro.report;
+
+import jakarta.inject.Inject;
+import jakarta.inject.Provider;
+import jakarta.persistence.EntityManager;
+import se.su.dsv.scipro.project.Project;
+import se.su.dsv.scipro.system.AbstractRepository;
+import se.su.dsv.scipro.system.User;
+
+public class SupervisorGradingReportRepositoryImpl extends AbstractRepository
+        implements SupervisorGradingReportRepository
+{
+    @Inject
+    public SupervisorGradingReportRepositoryImpl(Provider<EntityManager> em) {
+        super(em);
+    }
+
+    @Override
+    public SupervisorGradingReport save(SupervisorGradingReport report) {
+        EntityManager entityManager = em();
+        if (entityManager.contains(report)) {
+            return entityManager.merge(report);
+        }
+        else {
+            entityManager.persist(report);
+            return report;
+        }
+    }
+
+    @Override
+    public SupervisorGradingReport getReport(Project project, User author) {
+        return from(QSupervisorGradingReport.supervisorGradingReport)
+                .where(QSupervisorGradingReport.supervisorGradingReport.user.eq(author).and(
+                        QSupervisorGradingReport.supervisorGradingReport.project.eq(project)))
+                .fetchOne();
+    }
+}

core/src/test/java/se/su/dsv/scipro/report/OppositionReportServiceImplTest.java

@@ -13,6 +13,7 @@ import se.su.dsv.scipro.file.FileService;
 import se.su.dsv.scipro.finalseminar.FinalSeminar;
 import se.su.dsv.scipro.finalseminar.FinalSeminarOpposition;
 import se.su.dsv.scipro.finalseminar.FinalSeminarOppositionRepo;
+import se.su.dsv.scipro.project.Project;
 import se.su.dsv.scipro.system.DegreeType;
 import se.su.dsv.scipro.system.ProjectType;
 import se.su.dsv.scipro.system.User;
@@ -25,7 +26,6 @@ import java.util.*;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyInt;
 
 @ExtendWith(MockitoExtension.class)
 public class OppositionReportServiceImplTest {
@@ -73,7 +73,7 @@ public class OppositionReportServiceImplTest {
     public void create_report_if_not_existing() {
         GradingReportTemplate template = Mockito.mock(GradingReportTemplate.class);
         Mockito.when(template.createOppositionReport(any(FinalSeminarOpposition.class))).thenReturn(oppositionReport);
-        Mockito.when(gradingReportTemplateRepo.findByProjectTypeAndCredits(any(ProjectType.class), anyInt())).thenReturn(template);
+        Mockito.when(gradingReportTemplateRepo.getTemplate(any(Project.class))).thenReturn(template);
         Mockito.when(oppositionReportRepo.save(oppositionReport)).thenReturn(oppositionReport);
         assertEquals(oppositionReport, oppositionReportService.findOrCreateReport(createFinalSeminarOpposition()));
     }