.gitea/workflows/demo.yaml

@@ -3,25 +3,6 @@ run-name: ${{ gitea.actor }} is testing out Gitea Actions 🚀
 on: [push]
 
 jobs:
-  test:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Set up JDK 17
-      uses: actions/setup-java@v3
-      with:
-        java-version: '17'
-        distribution: 'temurin'
-        cache: maven
-    - name: Set up Maven
-      uses: stCarolas/setup-maven@v4.5
-      with:
-        maven-version: 3.8.2
-    - name: Build with Maven
-      run: mvn -B package --file backend/pom.xml
-
   build-and-push-frontend:
     runs-on: ubuntu-latest
     steps:

backend/pom.xml

@@ -21,6 +21,11 @@
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-data-jpa</artifactId>
 		</dependency>
+		<dependency>
+			<groupId>org.quartz-scheduler</groupId>
+			<artifactId>quartz</artifactId>
+			<version>2.3.2</version>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-security</artifactId>

backend/src/main/java/core/DemoApplication.java

@@ -2,15 +2,25 @@ package core;
 
 import core.entities.RoleEntity;
 import core.entities.UserRole;
+import core.entities.timemanager.AdvancedTaskSchedule;
 import core.repositories.RoleRepository;
 import core.repositories.UserRepository;
 import core.services.PropertyService;
+import core.services.TaskScheduleService;
+import core.services.ntfy.TaskSchedulingService;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.List;
 
 @SpringBootApplication
+@EnableScheduling
 public class DemoApplication{
 
 	public static void main(String[] args) {
@@ -18,19 +28,12 @@ public class DemoApplication{
 	}
 
 
-	/*@Bean
+	@Bean
-	public CommandLineRunner init(RoleRepository roleRepository, UserRepository userRepository, PropertyService propertyService) {
+	public CommandLineRunner init(TaskSchedulingService taskSchedulingService) {
 		return args -> {
-			for (UserRole userRole :  UserRole.values()) {
+			taskSchedulingService.scheduleStartReminders();
-				if(!roleRepository.existsByName(userRole)) {
-					roleRepository.save(new RoleEntity(userRole));
-				}
-			}
-
-			propertyService.init();
-
-			FirstUserObserver observer = new FirstUserObserver(userRepository);
-			observer.start();
 		};
-	}*/
+	}
+
+
 }

backend/src/main/java/core/api/controller/NtfyController.java

@@ -0,0 +1,55 @@
+package core.api.controller;
+
+import core.api.models.auth.SimpleStatusResponse;
+import core.api.models.users.NtfyInformation;
+import core.entities.User;
+import core.repositories.UserRepository;
+import core.services.UserService;
+import core.services.ntfy.TaskSchedulingService;
+import org.quartz.SchedulerException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import java.util.Optional;
+
+@CrossOrigin(origins = "*", maxAge = 3600)
+@RestController
+@RequestMapping("/api")
+public class NtfyController {
+
+    @Autowired private UserRepository userRepository;
+    @Autowired private UserService userService;
+    @Autowired private TaskSchedulingService taskSchedulingService;
+    @GetMapping("/ntfy")
+    public ResponseEntity<?> getNtfyInformation() {
+        String username = SecurityContextHolder.getContext().getAuthentication().getName();
+
+        Optional<User> userOptional = userRepository.findByUsername(username);
+        if(userOptional.isPresent()) {
+            return ResponseEntity.ok(new NtfyInformation(userOptional.get()));
+        } else {
+            return ResponseEntity.status(404).body(new SimpleStatusResponse("failed"));
+        }
+    }
+
+    @PostMapping("/ntfy")
+    public ResponseEntity<?> editNtfyInformation(@Valid @RequestBody NtfyInformation ntfyInformation) {
+        String username = SecurityContextHolder.getContext().getAuthentication().getName();
+        Optional<User> user = userRepository.findByUsername(username);
+        if(user.isPresent()) {
+            userService.editNtfyInformation(user.get(), ntfyInformation);
+            try {
+                taskSchedulingService.scheduleStartReminders();
+            } catch (SchedulerException e) {
+                throw new RuntimeException(e);
+            }
+            return ResponseEntity.ok(new SimpleStatusResponse("success"));
+        } else {
+            return ResponseEntity.status(404).body(new SimpleStatusResponse("failed"));
+        }
+    }
+}

backend/src/main/java/core/api/controller/ScheduleController.java

@@ -9,6 +9,8 @@ import core.entities.timemanager.AdvancedTaskSchedule;
 import core.entities.timemanager.BasicTaskSchedule;
 import core.entities.timemanager.Task;
 import core.services.*;
+import core.services.ntfy.TaskSchedulingService;
+import org.quartz.SchedulerException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.context.SecurityContextHolder;
@@ -27,6 +29,7 @@ public class ScheduleController {
 
     @Autowired private TaskScheduleService taskScheduleService;
     @Autowired private TaskService taskService;
+    @Autowired private TaskSchedulingService taskSchedulingService;
     @GetMapping("/schedules")
     public ResponseEntity<?> loadAllSchedulesOfUser() {
         String username = SecurityContextHolder.getContext().getAuthentication().getName();
@@ -172,6 +175,7 @@ public class ScheduleController {
         if(scheduleResult.getExitCode() == ServiceExitCode.ENTITY_ALREADY_EXIST) {
             return ResponseEntity.status(409).body(new SimpleStatusResponse("failed"));
         } else {
+            taskSchedulingService.sendRunningTaskNotification(scheduleResult.getResult());
             return ResponseEntity.ok(scheduleResult.getResult().toScheduleInfo());
         }
     }
@@ -198,6 +202,15 @@ public class ScheduleController {
         }
 
         ServiceResult<AbstractSchedule> serviceResult = taskScheduleService.activateSchedule(permissionResult.getResult());
+        if(serviceResult.getResult() instanceof AdvancedTaskSchedule) {
+            try {
+                taskSchedulingService.stopStartReminderNotification((AdvancedTaskSchedule) serviceResult.getResult());
+
+            } catch (SchedulerException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        taskSchedulingService.sendRunningTaskNotification(serviceResult.getResult());
         return ResponseEntity.ok(new ScheduleActivateResponse(serviceResult.getResult().getStartTime()));
     }
 

backend/src/main/java/core/api/models/users/NtfyInformation.java

@@ -0,0 +1,53 @@
+package core.api.models.users;
+
+import core.entities.User;
+
+public class NtfyInformation {
+
+    private String ntfy_host;
+    private String ntfy_topic;
+    private String ntfy_user;
+    private String ntfy_token;
+
+    public NtfyInformation(User user) {
+        this.ntfy_host = user.getNtfy_host();
+        this.ntfy_topic = user.getNtfy_topic();
+        this.ntfy_user = "****";
+        this.ntfy_token =  "****";
+    }
+
+    public NtfyInformation() {
+    }
+
+    public String getNtfy_host() {
+        return ntfy_host;
+    }
+
+    public void setNtfy_host(String ntfy_host) {
+        this.ntfy_host = ntfy_host;
+    }
+
+    public String getNtfy_topic() {
+        return ntfy_topic;
+    }
+
+    public void setNtfy_topic(String ntfy_topic) {
+        this.ntfy_topic = ntfy_topic;
+    }
+
+    public String getNtfy_user() {
+        return ntfy_user;
+    }
+
+    public void setNtfy_user(String ntfy_user) {
+        this.ntfy_user = ntfy_user;
+    }
+
+    public String getNtfy_token() {
+        return ntfy_token;
+    }
+
+    public void setNtfy_token(String ntfy_token) {
+        this.ntfy_token = ntfy_token;
+    }
+}

backend/src/main/java/core/entities/User.java

@@ -42,6 +42,11 @@ public class User {
                 inverseJoinColumns = @JoinColumn(name = "role_id"))
     private Set<RoleEntity> roles = new HashSet<>();
 
+    private String ntfy_host;
+    private String ntfy_topic;
+    private String ntfy_username;
+    private String ntfy_token;
+
     public User() {
     }
 
@@ -98,6 +103,38 @@ public class User {
         this.roles = roles;
     }
 
+    public String getNtfy_host() {
+        return ntfy_host;
+    }
+
+    public void setNtfy_host(String ntfy_host) {
+        this.ntfy_host = ntfy_host;
+    }
+
+    public String getNtfy_topic() {
+        return ntfy_topic;
+    }
+
+    public void setNtfy_topic(String ntfy_topic) {
+        this.ntfy_topic = ntfy_topic;
+    }
+
+    public String getNtfy_username() {
+        return ntfy_username;
+    }
+
+    public void setNtfy_username(String ntfy_username) {
+        this.ntfy_username = ntfy_username;
+    }
+
+    public String getNtfy_token() {
+        return ntfy_token;
+    }
+
+    public void setNtfy_token(String ntfy_token) {
+        this.ntfy_token = ntfy_token;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

backend/src/main/java/core/repositories/timemanager/AdvancedScheduleRepository.java

@@ -0,0 +1,15 @@
+package core.repositories.timemanager;
+
+import core.entities.timemanager.AdvancedTaskSchedule;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Repository;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@Repository
+public interface AdvancedScheduleRepository extends CrudRepository<AdvancedTaskSchedule, Long> {
+
+
+}

backend/src/main/java/core/repositories/timemanager/ScheduleRepository.java

@@ -19,4 +19,5 @@ public interface ScheduleRepository extends CrudRepository<AbstractSchedule, Lon
 
     @Query(value = "SELECT s FROM AbstractSchedule s WHERE s.task.taskgroup.user.username = ?1 AND s.startTime is NOT NULL and s.stopTime is NULL")
     Optional<AbstractSchedule> getActiveScheduleOfUser(String username);
+
 }

backend/src/main/java/core/services/TaskScheduleService.java

@@ -12,6 +12,7 @@ import core.entities.timemanager.AdvancedTaskSchedule;
 import core.entities.timemanager.BasicTaskSchedule;
 import core.entities.timemanager.Task;
 import core.repositories.UserRepository;
+import core.repositories.timemanager.AdvancedScheduleRepository;
 import core.repositories.timemanager.ScheduleRepository;
 import core.repositories.timemanager.TaskRepository;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -32,6 +33,7 @@ public class TaskScheduleService {
     @Autowired private UserRepository userRepository;
     @Autowired
     private TaskRepository taskRepository;
+    @Autowired private AdvancedScheduleRepository advancedScheduleRepository;
 
     public List<AbstractSchedule> getAllSchedulesOfUser(String username) {
         return scheduleRepository.findAllByUsername(username);
@@ -225,6 +227,19 @@ public class TaskScheduleService {
         return findScheduleByDate(allSchedules, date);
     }
 
+    public List<AdvancedTaskSchedule> findSchedulesByDate(LocalDate date) {
+        Iterable<AdvancedTaskSchedule> allSchedules = advancedScheduleRepository.findAll();
+        List<AdvancedTaskSchedule> schedulesToday = new ArrayList<>();
+        for(AdvancedTaskSchedule advancedTaskSchedule : allSchedules) {
+            if(advancedTaskSchedule.getScheduleStart().toLocalDate().equals(date) && advancedTaskSchedule.getStartTime() == null &&
+                    advancedTaskSchedule.getScheduleStart().isBefore(LocalDateTime.now())) {
+                schedulesToday.add(advancedTaskSchedule);
+            }
+        }
+        return schedulesToday;
+
+    }
+
     private List<AbstractSchedule> findScheduleByDate(List<AbstractSchedule> schedules, LocalDate date) {
         List<AbstractSchedule> filteredSchedules = new ArrayList<>();
         for(AbstractSchedule schedule : schedules) {

backend/src/main/java/core/services/UserService.java

@@ -3,6 +3,7 @@ package core.services;
 import core.api.models.account.AccountDeleteRequest;
 import core.api.models.account.EmailChangeRequest;
 import core.api.models.account.PasswordChangeRequest;
+import core.api.models.users.NtfyInformation;
 import core.api.models.users.UserAddInfo;
 import core.api.models.users.UserInfo;
 import core.api.models.users.UserUpdateInfo;
@@ -152,4 +153,13 @@ public class UserService {
         userRepository.deleteByUsername(username);
         return 0;
     }
+
+    public void editNtfyInformation(User user, NtfyInformation ntfyInformation) {
+        user.setNtfy_host(ntfyInformation.getNtfy_host());
+        user.setNtfy_topic(ntfyInformation.getNtfy_topic());
+        user.setNtfy_username(ntfyInformation.getNtfy_user());
+        user.setNtfy_token(ntfyInformation.getNtfy_token());
+
+        userRepository.save(user);
+    }
 }

backend/src/main/java/core/services/ntfy/NtfyTask.java

@@ -0,0 +1,29 @@
+package core.services.ntfy;
+
+import org.quartz.Job;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+
+import java.io.IOException;
+import java.net.*;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+
+public class NtfyTask implements Job {
+    @Override
+    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
+        HttpClient httpClient = HttpClient.newHttpClient();
+
+        try {
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(new URI("http://localhost:4280/Test"))
+                    .POST(HttpRequest.BodyPublishers.ofString(jobExecutionContext.getMergedJobDataMap().getString("data")))
+                    .build();
+
+            httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString());
+        } catch (URISyntaxException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

backend/src/main/java/core/services/ntfy/NtfyTaskStartNotification.java

@@ -0,0 +1,39 @@
+package core.services.ntfy;
+
+import org.quartz.Job;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+
+public class NtfyTaskStartNotification implements Job {
+
+
+
+    @Override
+    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
+        HttpClient httpClient = HttpClient.newHttpClient();
+        String msg = "Task " + jobExecutionContext.getMergedJobDataMap().getString("task") + " should have been started by now!";
+
+
+        try {
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(new URI(jobExecutionContext.getMergedJobDataMap().getString("ntfy_host") + "/Test"))
+                    .POST(HttpRequest.BodyPublishers.ofString(msg))
+                    .header("Tags", "warning")
+                    .header("Title", "Task Starting Reminder")
+                    .header("Actions", "view, Open TimeScheduler, "+jobExecutionContext.getMergedJobDataMap().getString("frontend_domain")+", clear=true")
+                    .build();
+
+            httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString());
+        } catch (URISyntaxException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

backend/src/main/java/core/services/ntfy/TaskSchedulingService.java

@@ -0,0 +1,90 @@
+package core.services.ntfy;
+
+
+import core.entities.User;
+import core.entities.timemanager.AbstractSchedule;
+import core.entities.timemanager.AdvancedTaskSchedule;
+import core.repositories.timemanager.ScheduleRepository;
+import core.repositories.timemanager.TaskRepository;
+import core.services.TaskScheduleService;
+import org.quartz.*;
+import org.quartz.impl.StdSchedulerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Service;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Date;
+import java.util.List;
+
+@Service
+public class TaskSchedulingService {
+
+    @Value("${frontend.domain}")
+    private String frontend_domain;
+
+    @Autowired private TaskScheduleService taskScheduleService;
+
+    private Scheduler scheduler;
+
+    public void scheduleStartingTask(AdvancedTaskSchedule advancedTaskSchedule) throws SchedulerException {
+        scheduler = StdSchedulerFactory.getDefaultScheduler();
+        scheduler.start();
+
+        JobDetail job = JobBuilder.newJob(NtfyTaskStartNotification.class)
+                .withIdentity(String.valueOf(advancedTaskSchedule.getScheduleID()))
+                .build();
+        job.getJobDataMap().put("task", advancedTaskSchedule.getTask().getTaskName());
+        job.getJobDataMap().put("ntfy_host", advancedTaskSchedule.getTask().getTaskgroup().getUser().getNtfy_host());
+        job.getJobDataMap().put("ntfy_topic", advancedTaskSchedule.getTask().getTaskgroup().getUser().getNtfy_topic());
+        job.getJobDataMap().put("frontend_domain", frontend_domain);
+
+        Trigger trigger = TriggerBuilder.newTrigger().startAt(calculateDelayInMillis(advancedTaskSchedule.getScheduleStart())).build();
+
+        scheduler.scheduleJob(job, trigger);
+    }
+
+    public void sendRunningTaskNotification(AbstractSchedule abstractSchedule) {
+        HttpClient httpClient = HttpClient.newHttpClient();
+        User user = abstractSchedule.getTask().getTaskgroup().getUser();
+        try {
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(new URI(user.getNtfy_host()+ "/" + user.getNtfy_topic()))
+                    .POST(HttpRequest.BodyPublishers.ofString("Running Task " + abstractSchedule.getTask().getTaskName()))
+                    .header("Tags", "heavy_check_mark")
+                    .header("Title", "Task Running")
+                    .header("Actions", "view, Open TimeScheduler, "+frontend_domain+", clear=true")
+                    .build();
+
+            httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString());
+        } catch (URISyntaxException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static Date calculateDelayInMillis(LocalDateTime executionTime) {
+        return  Date.from(executionTime.atZone(ZoneId.systemDefault()).toInstant());
+    }
+
+    @Scheduled(cron = "0 0 0 * * *")
+    public void scheduleStartReminders() throws SchedulerException {
+        List<AdvancedTaskSchedule> advancedTaskSchedules = taskScheduleService.findSchedulesByDate(LocalDate.now());
+        for(AdvancedTaskSchedule advancedTaskSchedule : advancedTaskSchedules) {
+            if(advancedTaskSchedule.getTask().getTaskgroup().getUser().getNtfy_host() != null) {
+                scheduleStartingTask(advancedTaskSchedule);
+            }
+        }
+    }
+
+    public void stopStartReminderNotification(AdvancedTaskSchedule schedule) throws SchedulerException {
+        scheduler.deleteJob(JobKey.jobKey(String.valueOf(schedule.getScheduleID())));
+    }
+}

backend/src/main/resources/application.properties

@@ -27,6 +27,7 @@ spring.jpa.open-in-view=false
 
 
 
+
 # Spring Data Rest Setup
 spring.data.rest.base-path=/api
 
@@ -43,3 +44,7 @@ demo.webapp.jwtSecret=demoWebappSecretKey
 demo.webapp.jwtExpirationMS=86400000
 spring.jackson.time-zone=UTC
 server.servlet.session.cookie.samesite=None
+
+ntfy.host=http://localhost:4280
+ntfy.topic=Test
+frontend.domain=http://localhost:4200

backend/src/test/java/core/DemoApplicationTests.java

@@ -1,13 +0,0 @@
-package core;
-
-import org.junit.jupiter.api.Test;
-import org.springframework.boot.test.context.SpringBootTest;
-
-/*@SpringBootTest*/
-class DemoApplicationTests {
-
-	/*@Test
-	void contextLoads() {
-	}*/
-
-}

backend/src/test/java/core/schedules/ScheduleRepositoryTest.java

@@ -1,57 +0,0 @@
-package core.schedules;
-
-import core.entities.User;
-import core.entities.timemanager.AbstractSchedule;
-import core.repositories.timemanager.ScheduleRepository;
-import core.services.ServiceResult;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
-import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
-import org.springframework.test.context.jdbc.Sql;
-import org.springframework.test.context.jdbc.SqlGroup;
-import org.springframework.test.context.junit.jupiter.SpringExtension;
-
-import java.util.Optional;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-@ExtendWith(SpringExtension.class)
-@DataJpaTest
-public class ScheduleRepositoryTest {
-
-    @Autowired private ScheduleRepository scheduleRepository;
-    @Autowired private TestEntityManager entityManager;
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void getAllSchedulesOfUser() {
-        User referenceUser_1 = entityManager.find(User.class, 1L);
-        User referenceUser_2 = entityManager.find(User.class, 2L);
-
-        assertEquals(0, scheduleRepository.findAllByUsername(referenceUser_2.getUsername()).size());
-        assertEquals(5, scheduleRepository.findAllByUsername(referenceUser_1.getUsername()).size());
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void getActiveScheduleOfUser() {
-        User referenceUser_1 = entityManager.find(User.class, 1L);
-        User referenceUser_2 = entityManager.find(User.class, 2L);
-
-        Optional<AbstractSchedule> result_1 = scheduleRepository.getActiveScheduleOfUser(referenceUser_2.getUsername());
-        assertTrue(result_1.isEmpty());
-
-        Optional<AbstractSchedule> result_2 = scheduleRepository.getActiveScheduleOfUser(referenceUser_1.getUsername());
-        assertTrue(result_2.isPresent());
-    }
-}

backend/src/test/java/core/schedules/ScheduleServiceTest.java

@@ -1,321 +0,0 @@
-package core.schedules;
-
-import core.api.models.timemanager.taskSchedule.scheduleInfos.AdvancedScheduleFieldInfo;
-import core.api.models.timemanager.taskSchedule.scheduleInfos.AdvancedScheduleInfo;
-import core.api.models.timemanager.taskSchedule.scheduleInfos.BasicScheduleFieldInfo;
-import core.api.models.timemanager.taskSchedule.ForgottenScheduleInfo;
-import core.entities.timemanager.AbstractSchedule;
-import core.entities.timemanager.AdvancedTaskSchedule;
-import core.entities.timemanager.BasicTaskSchedule;
-import core.entities.timemanager.Task;
-import core.services.ServiceExitCode;
-import core.services.ServiceResult;
-import core.services.TaskScheduleService;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.test.context.jdbc.Sql;
-import org.springframework.test.context.jdbc.SqlGroup;
-
-import javax.persistence.EntityManager;
-import javax.transaction.Transactional;
-
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.util.List;
-
-import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
-
-@SpringBootTest
-@Transactional
-public class ScheduleServiceTest {
-
-
-    @Autowired
-    private EntityManager entityManager;
-
-    @Autowired private TaskScheduleService taskScheduleService;
-
-    private static final String username = "Testuser1";
-    private static final String username2 = "Testuser2";
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void getAllSchedulesOfUser() {
-        assertEquals(0, taskScheduleService.getAllSchedulesOfUser(username2).size());
-
-        List<AbstractSchedule> result_1 = taskScheduleService.getAllSchedulesOfUser(username);
-        assertEquals(5, result_1.size());
-        assertTrue(result_1.contains(entityManager.find(AbstractSchedule.class, 1L)));
-        assertTrue(result_1.contains(entityManager.find(AbstractSchedule.class, 2L)));
-        assertTrue(result_1.contains(entityManager.find(AbstractSchedule.class, 3L)));
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void scheduleBasic() {
-        //Situation 1: Schedule finished Task
-        ServiceResult<AbstractSchedule> result_1 = taskScheduleService.scheduleBasic(entityManager.find(Task.class, 2L), new BasicScheduleFieldInfo(LocalDate.now()));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_1.getExitCode());
-
-        //Situation 2: Schedule before today
-        ServiceResult<AbstractSchedule> result_2 = taskScheduleService.scheduleBasic(entityManager.find(Task.class, 1L), new BasicScheduleFieldInfo(LocalDate.of(2010, 3, 14)));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_2.getExitCode());
-
-        //Situation 3: Valid schedule
-        ServiceResult<AbstractSchedule> result_3 = taskScheduleService.scheduleBasic(entityManager.find(Task.class, 1L), new BasicScheduleFieldInfo(LocalDate.now()));
-        assertEquals(ServiceExitCode.OK, result_3.getExitCode());
-        assertThat(entityManager.find(BasicTaskSchedule.class, result_3.getResult().getScheduleID())).isNotNull();
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void editBasicSchedule() {
-        //Situation 1: Reschedule finished task
-        ServiceResult<AbstractSchedule> result_1 = taskScheduleService.editBasicSchedule(entityManager.find(BasicTaskSchedule.class, 2L), new BasicScheduleFieldInfo(LocalDate.now()));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_1.getExitCode());
-
-        //Situation 2: Reschedule unfinished task with invalid reschedule date
-        ServiceResult<AbstractSchedule> result_2 = taskScheduleService.editBasicSchedule(entityManager.find(BasicTaskSchedule.class, 1L), new BasicScheduleFieldInfo(LocalDate.of(2011, 3, 4)));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_2.getExitCode());
-
-        //Situation 3: Reschedule unfinished task with valid reschedule date
-        LocalDate oldDate = entityManager.find(BasicTaskSchedule.class, 1L).getScheduleDate();
-        ServiceResult<AbstractSchedule> result_3 = taskScheduleService.editBasicSchedule(entityManager.find(BasicTaskSchedule.class, 1L), new BasicScheduleFieldInfo(LocalDate.now()));
-        assertEquals(ServiceExitCode.OK, result_3.getExitCode());
-        assertNotEquals(((BasicTaskSchedule) result_3.getResult()).getScheduleDate(), oldDate);
-
-        //Situation 4: Reschedule already running schedule
-        ServiceResult<AbstractSchedule> result_4 = taskScheduleService.editBasicSchedule(entityManager.find(BasicTaskSchedule.class, 4L),
-                new BasicScheduleFieldInfo(LocalDate.now()));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_4.getExitCode());
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void deleteSchedule() {
-        for(long i=1; i<=2; i++) {
-            taskScheduleService.deleteSchedule(entityManager.find(BasicTaskSchedule.class, i));
-            assertThat(entityManager.find(BasicTaskSchedule.class, i)).isNull();
-        }
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void getFilteredScheduledOfUser() {
-        //Invalid user
-        assertEquals(0, taskScheduleService.getFilteredScheduledOfUser(LocalDate.now(), false, "Quatsch").size());
-        assertEquals(0, taskScheduleService.getFilteredScheduledOfUser(LocalDate.now(), true, "Quatsch").size());
-
-        //User with no tasks/schedules
-        assertEquals(0, taskScheduleService.getFilteredScheduledOfUser(LocalDate.now(), false, username2).size());
-        assertEquals(0, taskScheduleService.getFilteredScheduledOfUser(LocalDate.now(), true, username2).size());
-
-        //user with tasks and schedules
-        List<AbstractSchedule> result_1 = taskScheduleService.getFilteredScheduledOfUser(LocalDate.of(2024,11,11), false, username);
-        assertEquals(3, result_1.size());
-        assertTrue(result_1.contains(entityManager.find(BasicTaskSchedule.class, 3L)));
-        assertTrue(result_1.contains(entityManager.find(BasicTaskSchedule.class, 4L)));
-        assertTrue(result_1.contains(entityManager.find(BasicTaskSchedule.class, 5L)));
-
-        List<AbstractSchedule> result_2 = taskScheduleService.getFilteredScheduledOfUser(LocalDate.of(2024,11,11), true, username);
-        assertEquals(1, result_2.size());
-    }
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void scheduleNow() {
-        //Situation 1: Task has already an active schedule
-        ServiceResult<AbstractSchedule> result_1 = taskScheduleService.scheduleNow(entityManager.find(Task.class, 3L));
-        assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, result_1.getExitCode());
-
-        //Situation 2: Task is already finished
-        ServiceResult<AbstractSchedule> result_2 = taskScheduleService.scheduleNow(entityManager.find(Task.class, 2L));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_2.getExitCode());
-
-        //Situation 3: Task can be scheduled and started
-        ServiceResult<AbstractSchedule> result_3 = taskScheduleService.scheduleNow(entityManager.find(Task.class, 5L));
-        assertEquals(ServiceExitCode.OK, result_3.getExitCode());
-        assertThat(entityManager.find(BasicTaskSchedule.class, result_3.getResult().getScheduleID())).isNotNull();
-
-        //Situation 4: Running Advanced Schedule
-        ServiceResult<AbstractSchedule> result_4 = taskScheduleService.scheduleNow(entityManager.find(Task.class, 17L));
-        assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, result_4.getExitCode());
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void activateSchedule() {
-        //Activate already running schedule
-        ServiceResult<AbstractSchedule> result_1 = taskScheduleService.activateSchedule(entityManager.find(BasicTaskSchedule.class, 4L));
-        assertNotNull(result_1.getResult().getStartTime());
-        assertNull(result_1.getResult().getStopTime());
-
-        entityManager.remove(entityManager.find(BasicTaskSchedule.class, 4L));
-        assertThat(entityManager.find(BasicTaskSchedule.class, 4L)).isNull();
-
-        //Activate not running schedule
-        ServiceResult<AbstractSchedule> result_2 = taskScheduleService.activateSchedule(entityManager.find(BasicTaskSchedule.class, 5L));
-        assertNotNull(result_2.getResult().getStartTime());
-        assertNull(result_2.getResult().getStopTime());
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void stopSchedule() {
-        //Stop schedule that is not running 4
-        ServiceResult<AbstractSchedule> result_1 = taskScheduleService.stopSchedule(entityManager.find(BasicTaskSchedule.class, 5L), false);
-        assertNull(result_1.getResult().getStartTime());
-        assertNull(result_1.getResult().getStopTime());
-
-        //Stop schedule (without finishing)
-        ServiceResult<AbstractSchedule> result_2 = taskScheduleService.stopSchedule(entityManager.find(BasicTaskSchedule.class, 4L), false);
-        assertNotNull(result_2.getResult().getStartTime());
-        assertNotNull(result_2.getResult().getStopTime());
-
-        //Stop schedule with finishing
-        ServiceResult<AbstractSchedule> result_3 = taskScheduleService.stopSchedule(entityManager.find(BasicTaskSchedule.class, 7L), true);
-        assertNotNull(result_3.getResult().getStartTime());
-        assertNotNull(result_3.getResult().getStopTime());
-        assertTrue(result_3.getResult().getTask().isFinished());
-        assertFalse(result_3.getResult().isStartable());
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void registerForgottenSchedule() {
-        //Register task schedule for task that is already finished
-        LocalDateTime startTime = LocalDateTime.now().minusMinutes(10L);
-        LocalDateTime finishTime = LocalDateTime.now();
-
-        ServiceResult<AbstractSchedule> result_1 = taskScheduleService.registerForgottenSchedule(entityManager.find(Task.class, 2L), new ForgottenScheduleInfo(startTime, finishTime));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_1.getExitCode());
-
-        ServiceResult<AbstractSchedule> result_2 = taskScheduleService.registerForgottenSchedule(entityManager.find(Task.class, 5L), new ForgottenScheduleInfo(startTime, finishTime));
-        assertEquals(ServiceExitCode.OK, result_2.getExitCode());
-        assertEquals(startTime, result_2.getResult().getStartTime());
-        assertEquals(finishTime, result_2.getResult().getStopTime());
-        assertThat(entityManager.find(BasicTaskSchedule.class, result_2.getResult().getScheduleID())).isNotNull();
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void getAllMissedSchedulesOfUser() {
-        assertEquals(1, taskScheduleService.getAllMissedSchedulesOfUser(username).size());
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void scheduleAdvanced() {
-        //Situation 1: Schedule finished Task
-        ServiceResult<AbstractSchedule> result_1 = taskScheduleService.scheduleAdvanced(entityManager.find(Task.class, 18L),
-                new AdvancedScheduleFieldInfo(LocalDateTime.now().plusHours(1L), LocalDateTime.now().plusHours(2L)));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_1.getExitCode());
-
-        //Situation 2: Schedule Start is before today
-        ServiceResult<AbstractSchedule> result_2 = taskScheduleService.scheduleAdvanced(entityManager.find(Task.class, 17L),
-                new AdvancedScheduleFieldInfo(LocalDateTime.now().minusDays(1L), LocalDateTime.now().plusHours(2L)));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_2.getExitCode());
-
-        //Situation 3: Schedule End is before today
-        ServiceResult<AbstractSchedule> result_3 = taskScheduleService.scheduleAdvanced(entityManager.find(Task.class, 17L),
-                new AdvancedScheduleFieldInfo(LocalDateTime.now().minusDays(2L), LocalDateTime.now().minusDays(1L)));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_3.getExitCode());
-
-        //Situation 4: Start after stop
-        ServiceResult<AbstractSchedule> result_4 = taskScheduleService.scheduleAdvanced(entityManager.find(Task.class, 17L),
-                new AdvancedScheduleFieldInfo(LocalDateTime.now().plusHours(2L), LocalDateTime.now().plusHours(1L)));
-        assertEquals(ServiceExitCode.INVALID_PARAMETER, result_4.getExitCode());
-
-        //Situation 5: Valid schedule
-        ServiceResult<AbstractSchedule> result_5 = taskScheduleService.scheduleAdvanced(entityManager.find(Task.class, 17L),
-                new AdvancedScheduleFieldInfo(LocalDateTime.now(), LocalDateTime.now().plusHours(1L)));
-        assertEquals(ServiceExitCode.OK, result_5.getExitCode());
-        assertThat(entityManager.find(AdvancedTaskSchedule.class, result_5.getResult().getScheduleID())).isNotNull();
-
-
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void editscheduleAdvanced() {
-        //Situation 1: Schedule finished Task
-        ServiceResult<AbstractSchedule> result_1 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 12L),
-                new AdvancedScheduleFieldInfo(LocalDateTime.now().plusHours(1L), LocalDateTime.now().plusHours(2L)));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_1.getExitCode());
-
-        //Situation 2: Schedule Start is before today
-        ServiceResult<AbstractSchedule> result_2 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 11L),
-                new AdvancedScheduleFieldInfo(LocalDateTime.now().minusDays(1L), LocalDateTime.now().plusHours(2L)));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_2.getExitCode());
-
-        //Situation 3: Schedule End is before today
-        ServiceResult<AbstractSchedule> result_3 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 11L),
-                new AdvancedScheduleFieldInfo(LocalDateTime.now().minusDays(2L), LocalDateTime.now().minusDays(1L)));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_3.getExitCode());
-
-        //Situation 4: Start after stop
-        ServiceResult<AbstractSchedule> result_4 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 11L),
-                new AdvancedScheduleFieldInfo(LocalDateTime.now().plusHours(2L), LocalDateTime.now().plusHours(1L)));
-        assertEquals(ServiceExitCode.INVALID_PARAMETER, result_4.getExitCode());
-
-        //Situation 5: Valid schedule
-        ServiceResult<AbstractSchedule> result_5 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 11L),
-                new AdvancedScheduleFieldInfo(LocalDateTime.now(), LocalDateTime.now().plusHours(1L)));
-        assertEquals(ServiceExitCode.OK, result_5.getExitCode());
-        assertThat(entityManager.find(AdvancedTaskSchedule.class, result_5.getResult().getScheduleID())).isNotNull();
-
-        //Situation 6: reschedule already running schedule
-        ServiceResult<AbstractSchedule> result_6 = taskScheduleService.editAdvancedSchedule(entityManager.find(AdvancedTaskSchedule.class, 9L),
-                new AdvancedScheduleFieldInfo(LocalDateTime.now(), LocalDateTime.now().plusHours(1L)));
-        assertEquals(ServiceExitCode.INVALID_OPERATION, result_6.getExitCode());
-    }
-}

backend/src/test/java/core/taskgroups/TaskgroupRepsitoryTest.java

@@ -1,93 +0,0 @@
-package core.taskgroups;
-
-import core.entities.User;
-import core.entities.timemanager.Task;
-import core.entities.timemanager.Taskgroup;
-import core.repositories.timemanager.TaskgroupRepository;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
-import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
-import org.springframework.test.context.jdbc.Sql;
-import org.springframework.test.context.junit.jupiter.SpringExtension;
-
-import java.util.List;
-
-import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
-
-@ExtendWith(SpringExtension.class)
-@DataJpaTest
-public class TaskgroupRepsitoryTest {
-
-    @Autowired private TaskgroupRepository taskgroupRepository;
-    @Autowired private TestEntityManager testEntityManager;
-
-    @Test
-    @Sql("classpath:taskgroupRepositoryTestEntries.sql")
-    void findAllByUser() {
-        User testUser1 = testEntityManager.find(User.class, 1L);
-        User testUser2 = testEntityManager.find(User.class, 2L);
-
-        List<Taskgroup> result_user2 = taskgroupRepository.findAllByUser(testUser2.getUsername());
-        assertEquals(0, result_user2.size());
-
-        List<Taskgroup> result_user1 = taskgroupRepository.findAllByUser(testUser1.getUsername());
-        assertEquals(8, result_user1.size());
-    }
-
-    @Test
-    @Sql("classpath:taskgroupRepositoryTestEntries.sql")
-    void findAllTopTaskgroupsByUser() {
-        User testUser1 = testEntityManager.find(User.class, 1L);
-        User testUser2 = testEntityManager.find(User.class, 2L);
-
-        //Situation 1: Empty user, no taskgroups
-        assertEquals(0, taskgroupRepository.findAllTopTaskgroupsByUser(testUser2.getUsername()).size());
-
-        //Situation 2: Only top taskgroups are returned
-        List<Taskgroup> topgroups_user1 = taskgroupRepository.findAllTopTaskgroupsByUser(testUser1.getUsername());
-        assertEquals(3, topgroups_user1.size());
-        assertTrue(topgroups_user1.contains(testEntityManager.find(Taskgroup.class, 1L)));
-        assertTrue(topgroups_user1.contains(testEntityManager.find(Taskgroup.class, 2L)));
-        assertTrue(topgroups_user1.contains(testEntityManager.find(Taskgroup.class, 5L)));
-
-        //Situation 3: User with username does not exist
-        assertEquals(0, taskgroupRepository.findAllTopTaskgroupsByUser("Rotzbakke").size());
-    }
-    @Test
-    @Sql("classpath:taskgroupRepositoryTestEntries.sql")
-    void deleteAllByUser() {
-        User testUser1 = testEntityManager.find(User.class, 1L);
-        User testUser2 = testEntityManager.find(User.class, 2L);
-
-        taskgroupRepository.deleteAllByUser(testUser2);
-        for(long i=1; i<=8; i++) {
-            assertThat(testEntityManager.find(Taskgroup.class, i)).isNotNull();
-        }
-
-        taskgroupRepository.deleteAllByUser(testUser1);
-        for(long i=1; i<=8; i++) {
-            assertThat(testEntityManager.find(Taskgroup.class, i)).isNull();
-        }
-    }
-
-    @Test
-    @Sql("classpath:taskgroupRepositoryTestEntries.sql")
-    void delete() {
-        Taskgroup no_children = testEntityManager.find(Taskgroup.class, 1L);
-        Taskgroup taskgroup_with_children = testEntityManager.find(Taskgroup.class, 5L);
-
-        taskgroupRepository.delete(no_children);
-        assertThat(testEntityManager.find(Taskgroup.class, 1L)).isNull();
-        for(long i=2; i<=8; i++) {
-            assertThat(testEntityManager.find(Taskgroup.class, i)).isNotNull();
-        }
-
-        taskgroupRepository.delete(taskgroup_with_children);
-        for(long i=5; i<=8; i++) {
-            assertThat(testEntityManager.find(Taskgroup.class, i)).isNull();
-        }
-    }
-}

backend/src/test/java/core/taskgroups/TaskgroupServiceTest.java

@@ -1,202 +0,0 @@
-package core.taskgroups;
-
-import core.api.models.timemanager.taskgroup.TaskgroupFieldInfo;
-import core.entities.User;
-import core.entities.timemanager.Task;
-import core.entities.timemanager.Taskgroup;
-import core.repositories.UserRepository;
-import core.repositories.timemanager.TaskgroupRepository;
-import core.services.PermissionResult;
-import core.services.ServiceExitCode;
-import core.services.ServiceResult;
-import core.services.TaskgroupService;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
-import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.test.context.jdbc.Sql;
-import org.springframework.test.context.jdbc.SqlGroup;
-import org.springframework.test.context.junit.jupiter.SpringExtension;
-import org.springframework.test.context.junit4.SpringRunner;
-
-import javax.persistence.EntityManager;
-import javax.transaction.Transactional;
-import java.util.List;
-import java.util.NoSuchElementException;
-import java.util.Optional;
-
-import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
-
-@SpringBootTest
-@Transactional
-public class TaskgroupServiceTest {
-
-    @Autowired
-    private TaskgroupRepository taskgroupRepository;
-    @Autowired
-    private TaskgroupService taskgroupService;
-    @Autowired
-    private EntityManager entityManager;
-
-    private static final String username = "Testuser1";
-    private static final String username2 = "Testuser2";
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void getTaskgroupByIDAndUsername() {
-        //Situation 1: correct taskgroup and username
-        assertFalse(taskgroupRepository.findById(1L).isEmpty());
-
-        PermissionResult<Taskgroup> permissionResult = taskgroupService.getTaskgroupByIDAndUsername(1L, username);
-        assertThat(permissionResult).isNotNull();
-        assertTrue(permissionResult.isHasPermissions());
-        assertEquals(ServiceExitCode.OK, permissionResult.getExitCode());
-        assertEquals(taskgroupRepository.findById(1L).get(), permissionResult.getResult());
-
-        //Situation 2: invalid taskgroup
-        PermissionResult<Taskgroup> invalid_group = taskgroupService.getTaskgroupByIDAndUsername(-1L, username);
-        assertThat(invalid_group).isNotNull();
-        assertEquals(ServiceExitCode.MISSING_ENTITY, invalid_group.getExitCode());
-        assertFalse(invalid_group.isHasPermissions());
-
-        //Situation 3: invalid user
-        PermissionResult<Taskgroup> invalid_user = taskgroupService.getTaskgroupByIDAndUsername(1L, "Rotzbakke");
-        assertThat(invalid_user).isNotNull();
-        assertEquals(ServiceExitCode.OK, invalid_user.getExitCode());
-        assertFalse(invalid_user.isHasPermissions());
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void addTaskgroup() {
-        TaskgroupFieldInfo taskgroupFieldInfo = new TaskgroupFieldInfo("Taskgroup", -1);
-        //Situation 1: No such user
-        assertThrows(NoSuchElementException.class, () -> taskgroupService.addTaskgroup(taskgroupFieldInfo, "Rotzbakke"));
-
-        //Situation 2: Taskgroup already exists
-        Taskgroup taskgroup = taskgroupRepository.findById(1L).get();
-        ServiceResult<Taskgroup> creationResult = taskgroupService.addTaskgroup(new TaskgroupFieldInfo(taskgroup.getTaskgroupName(), -1), username);
-        assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, creationResult.getExitCode());
-        assertThat(creationResult.getResult()).isNull();
-
-        //Situation 3: Taskgroup does not exist, no parent
-        ServiceResult<Taskgroup> creationResult_3 = taskgroupService.addTaskgroup(taskgroupFieldInfo, username);
-        assertEquals(ServiceExitCode.OK, creationResult_3.getExitCode());
-        assertTrue(taskgroupRepository.existsById(creationResult_3.getResult().getTaskgroupID()));
-
-        //Situation 4: Taskgroup does not exist, with parent; invalid parent (no existent)
-        ServiceResult<Taskgroup> creationResult_4 = taskgroupService.addTaskgroup(new TaskgroupFieldInfo("Situation 4", 100L), username);
-        assertEquals(ServiceExitCode.MISSING_ENTITY, creationResult_4.getExitCode());
-
-        //Situation 5: Taskgroup does not exist, parent exist
-        ServiceResult<Taskgroup> creationResult_5 = taskgroupService.addTaskgroup(new TaskgroupFieldInfo("Situation 5", 2L), username);
-        assertEquals(ServiceExitCode.OK, creationResult_5.getExitCode());
-        assertTrue(taskgroupRepository.existsById(creationResult_5.getResult().getTaskgroupID()));
-
-        //Situation 6: taskgroup exist on another user
-        ServiceResult<Taskgroup> creationResult_6 = taskgroupService.addTaskgroup(new TaskgroupFieldInfo(taskgroup.getTaskgroupName(), -1), username2);
-        assertEquals(ServiceExitCode.OK, creationResult_6.getExitCode());
-        assertTrue(taskgroupRepository.existsById(creationResult_6.getResult().getTaskgroupID()));
-
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void editTaskgroup() {
-        Taskgroup taskgroup = taskgroupRepository.findById(1L).get();
-        //Situation 1: Nothing changed
-        ServiceExitCode exitCode_1 = taskgroupService.editTaskgroup(taskgroup, new TaskgroupFieldInfo(taskgroup.getTaskgroupName(),-1));
-        assertEquals(ServiceExitCode.OK, exitCode_1);
-
-        //Situation 2: Name is already taken
-        ServiceExitCode exitCode_2 = taskgroupService.editTaskgroup(taskgroup, new TaskgroupFieldInfo("Taskgroup 1", -1));
-        assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, exitCode_2);
-
-        //Situation 3: All fine
-        ServiceExitCode exitCode_3 = taskgroupService.editTaskgroup(taskgroup, new TaskgroupFieldInfo("Situation 3", -1));
-        assertEquals(ServiceExitCode.OK, exitCode_3);
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void deleteTaskgroup() {
-        taskgroupService.deleteTaskgroup(entityManager.find(Taskgroup.class, 1L));
-        assertThat(entityManager.find(Taskgroup.class, 1L)).isNull();
-
-        taskgroupService.deleteTaskgroup(entityManager.find(Taskgroup.class, 2L));
-        assertThat(entityManager.find(Taskgroup.class, 2L)).isNull();
-        assertThat(entityManager.find(Taskgroup.class, 3L)).isNull();
-        for(long i=1; i<=14; i++) {
-            assertThat(entityManager.find(Task.class, i)).isNull();
-        }
-
-        taskgroupService.deleteTaskgroup(entityManager.find(Taskgroup.class, 5L));
-        assertThat(entityManager.find(Taskgroup.class, 5L)).isNull();
-        assertThat(entityManager.find(Taskgroup.class, 6L)).isNull();
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void getTopTaskgroupsByUser() {
-        //Situation 1: User without taskgroups
-        List<Taskgroup> taskgroups_user2 = taskgroupService.getTopTaskgroupsByUser(username2);
-        assertEquals(0, taskgroups_user2.size());
-
-
-        //Situation 2: user with taskgroups
-        List<Taskgroup> taskgroups_user1 = taskgroupService.getTopTaskgroupsByUser(username);
-        assertEquals(3, taskgroups_user1.size());
-        assertTrue(taskgroups_user1.contains(entityManager.find(Taskgroup.class, 1L)));
-        assertTrue(taskgroups_user1.contains(entityManager.find(Taskgroup.class, 2L)));
-        assertTrue(taskgroups_user1.contains(entityManager.find(Taskgroup.class, 5L)));
-
-        //Situation 3: No existent username
-        assertEquals(0, taskgroupService.getTopTaskgroupsByUser("Rotzbakke").size());
-    }
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void deleteTaskgroupByUser() {
-        User referenceUser1 = entityManager.find(User.class, 1L);
-        User referenceUser2 = entityManager.find(User.class, 2L);
-
-        taskgroupService.deleteTaskgroupByUser(referenceUser2);
-        for(long i=1; i<=8; i++) {
-            assertThat(entityManager.find(Taskgroup.class, i)).isNotNull();
-        }
-
-        taskgroupService.deleteTaskgroupByUser(referenceUser1);
-        for(long i=1; i<=8; i++) {
-            assertThat(entityManager.find(Taskgroup.class, i)).isNull();
-        }
-        for(long i=1; i<=14; i++) {
-            assertThat(entityManager.find(Task.class, i)).isNull();
-        }
-    }
-
-}

backend/src/test/java/core/tasks/TaskRepositoryTest.java

@@ -1,160 +0,0 @@
-package core.tasks;
-
-import core.entities.User;
-import core.entities.timemanager.Task;
-import core.entities.timemanager.Taskgroup;
-import core.repositories.timemanager.TaskRepository;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
-import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
-import org.springframework.test.context.jdbc.Sql;
-import org.springframework.test.context.jdbc.SqlGroup;
-import org.springframework.test.context.junit.jupiter.SpringExtension;
-
-import java.time.LocalDate;
-import java.util.List;
-
-import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-
-@ExtendWith(SpringExtension.class)
-@DataJpaTest
-public class TaskRepositoryTest {
-
-    @Autowired private TaskRepository taskRepository;
-    @Autowired private TestEntityManager testEntityManager;
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void findAllByUser() {
-        User testUser1 = testEntityManager.find(User.class, 1L);
-        User testUser2 = testEntityManager.find(User.class, 2L);
-
-        //Situation 1: Non existent user
-        assertEquals(0, taskRepository.findAllByUser("Rotzbakke", true).size());
-        assertEquals(0, taskRepository.findAllByUser("Rotzbakke", false).size());
-
-        //Situation 2: User with no tasks at all
-        assertEquals(0, taskRepository.findAllByUser(testUser2.getUsername(), false).size());
-        assertEquals(0, taskRepository.findAllByUser(testUser2.getUsername(), true).size());
-
-        //Situation 3: User with finished and unfinished tasks
-        List<Task> tasks_user1_false = taskRepository.findAllByUser(testUser1.getUsername(), false);
-        List<Task> tasks_user1_true = taskRepository.findAllByUser(testUser1.getUsername(), true);
-        assertEquals(7, tasks_user1_true.size());
-        assertEquals(8, tasks_user1_false.size());
-
-        assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 1L)));
-        assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 3L)));
-        assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 5L)));
-        assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 7L)));
-        assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 9L)));
-        assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 11L)));
-        assertTrue(tasks_user1_false.contains(testEntityManager.find(Task.class, 12L)));
-
-        assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 2L)));
-        assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 4L)));
-        assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 6L)));
-        assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 8L)));
-        assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 10L)));
-        assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 13L)));
-        assertTrue(tasks_user1_true.contains(testEntityManager.find(Task.class, 14L)));
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void deleteAllByTaskgroup() {
-        Taskgroup taskgroup_no_tasks = testEntityManager.find(Taskgroup.class, 1L);
-        taskRepository.deleteAllByTaskgroup(taskgroup_no_tasks);
-
-        for(long i=1; i<=14; i++) {
-            assertThat(testEntityManager.find(Task.class, i)).isNotNull();
-        }
-
-        Taskgroup taskgroup_with_task = testEntityManager.find(Taskgroup.class, 2L);
-        taskRepository.deleteAllByTaskgroup(taskgroup_with_task);
-        for(long i=1; i<=14; i++) {
-            Task task  = testEntityManager.find(Task.class, i);
-            assertThat(task).isNull();
-        }
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void deleteByTaskID() {
-      taskRepository.deleteByTaskID(-1);
-      for(long i=1; i<=14; i++) {
-          assertThat(testEntityManager.find(Task.class, i)).isNotNull();
-      }
-
-      taskRepository.deleteByTaskID(1);
-      assertThat(testEntityManager.find(Task.class, 1L)).isNull();
-      for(long i=2; i<=14; i++) {
-          assertThat(testEntityManager.find(Task.class, i)).isNotNull();
-      }
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void findAllOverdue() {
-        User testuser1 = testEntityManager.find(User.class, 1L);
-        LocalDate referenceDate = LocalDate.of(2023, 10, 11);
-
-        List<Task> overdue = taskRepository.findAllOverdue(testuser1.getUsername(), referenceDate);
-        assertEquals(2, overdue.size());
-        assertTrue(overdue.contains(testEntityManager.find(Task.class, 3L)));
-        assertTrue(overdue.contains(testEntityManager.find(Task.class, 5L)));
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void findAllUpcoming() {
-        User testuser1 = testEntityManager.find(User.class, 1L);
-        LocalDate referenceDate = LocalDate.of(2023, 10, 11);
-
-        List<Task> upcoming = taskRepository.findAllUpcoming(testuser1.getUsername(), referenceDate);
-        assertEquals(2, upcoming.size());
-        assertTrue(upcoming.contains(testEntityManager.find(Task.class, 7L)));
-        assertTrue(upcoming.contains(testEntityManager.find(Task.class, 9L)));
-
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql")
-    })
-    void findAllActive() {
-        User testuser1 = testEntityManager.find(User.class, 1L);
-        LocalDate referenceDate = LocalDate.of(2023, 10, 11);
-
-        List<Task> active = taskRepository.findAllActive(testuser1.getUsername(), referenceDate);
-        //1,3,5,11,12
-        assertEquals(6, active.size());
-        assertTrue(active.contains(testEntityManager.find(Task.class, 1L)));
-        assertTrue(active.contains(testEntityManager.find(Task.class, 3L)));
-        assertTrue(active.contains(testEntityManager.find(Task.class, 5L)));
-        assertTrue(active.contains(testEntityManager.find(Task.class, 11L)));
-        assertTrue(active.contains(testEntityManager.find(Task.class, 12L)));
-    }
-
-}

backend/src/test/java/core/tasks/TaskServiceTest.java

@@ -1,287 +0,0 @@
-package core.tasks;
-
-import core.api.models.timemanager.tasks.TaskFieldInfo;
-import core.api.models.timemanager.tasks.TaskScope;
-import core.entities.timemanager.BasicTaskSchedule;
-import core.entities.timemanager.Task;
-import core.entities.timemanager.Taskgroup;
-import core.repositories.timemanager.TaskRepository;
-import core.repositories.timemanager.TaskgroupRepository;
-import core.services.*;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.test.annotation.Rollback;
-import org.springframework.test.context.jdbc.Sql;
-import org.springframework.test.context.jdbc.SqlGroup;
-
-import javax.persistence.EntityManager;
-import javax.transaction.Transactional;
-
-import java.time.LocalDate;
-import java.util.List;
-
-import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
-
-@SpringBootTest
-@Transactional
-public class TaskServiceTest {
-
-
-    @Autowired
-    private TaskService taskService;
-    @Autowired
-    private EntityManager entityManager;
-
-    private static final String username = "Testuser1";
-    private static final String username2 = "Testuser2";
-    @Autowired
-    private TaskRepository taskRepository;
-    @Autowired
-    private TaskgroupRepository taskgroupRepository;
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void createTask() {
-        //Situation 1: Task with that name already exists in a taskgroup
-        TaskFieldInfo taskFieldInfo_1 = new TaskFieldInfo(entityManager.find(Task.class, 1L).getTaskName(), 0, null, null);
-        ServiceResult<Task> situation_1 = taskService.createTask(entityManager.find(Taskgroup.class, 2L), taskFieldInfo_1);
-        assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, situation_1.getExitCode());
-
-        //Situation 2: Task with that name exists in another taskgroup
-        TaskFieldInfo taskFieldInfo_2 = new TaskFieldInfo(entityManager.find(Task.class, 1L).getTaskName(), 0, null, null);
-        ServiceResult<Task> result_2 = taskService.createTask(entityManager.find(Taskgroup.class, 1L), taskFieldInfo_2);
-        assertEquals(ServiceExitCode.OK, result_2.getExitCode());
-        assertThat(entityManager.find(Task.class, result_2.getResult().getTaskID())).isNotNull();
-
-        //Situation 3: Normal, everything fine
-        TaskFieldInfo taskFieldInfo_3 = new TaskFieldInfo("Situation 3", 0, null, null);
-        ServiceResult<Task> result_3 = taskService.createTask(entityManager.find(Taskgroup.class, 1L), taskFieldInfo_3);
-        assertEquals(ServiceExitCode.OK, result_3.getExitCode());
-        assertThat(entityManager.find(Task.class, result_3.getResult().getTaskID())).isNotNull();
-
-        //Robustness - Test for invalid dates
-        //Situation 4: Deadline, no start
-        TaskFieldInfo taskFieldInfo_4 = new TaskFieldInfo("Situation 4", 0, null, LocalDate.now());
-        ServiceResult<Task> result_4 = taskService.createTask(entityManager.find(Taskgroup.class, 1L), taskFieldInfo_4);
-        assertEquals(ServiceExitCode.OK, result_4.getExitCode());
-        assertThat(entityManager.find(Task.class, result_4.getResult().getTaskID())).isNotNull();
-
-        //Situation 5: Start but no deadline
-        TaskFieldInfo taskFieldInfo_5 = new TaskFieldInfo("Situation 5", 0, LocalDate.now(),null);
-        ServiceResult<Task> result_5 = taskService.createTask(entityManager.find(Taskgroup.class, 1L), taskFieldInfo_5);
-        assertEquals(ServiceExitCode.OK, result_5.getExitCode());
-        assertThat(entityManager.find(Task.class, result_5.getResult().getTaskID())).isNotNull();
-
-        //Situation 6: Deadline before start (invalid)
-        TaskFieldInfo taskFieldInfo_6 = new TaskFieldInfo("Situation 6", 0, LocalDate.now(),LocalDate.of(2010, 3, 20));
-        ServiceResult<Task> result_6= taskService.createTask(entityManager.find(Taskgroup.class, 1L), taskFieldInfo_6);
-        assertEquals(ServiceExitCode.INVALID_PARAMETER, result_6.getExitCode());
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void getTaskPermissions() {
-        //Situation 1: correct task and username
-        PermissionResult<Task> permissionResult_1 = taskService.getTaskPermissions(1L, username);
-        assertEquals(ServiceExitCode.OK, permissionResult_1.getExitCode());
-        assertTrue(permissionResult_1.isHasPermissions());
-        assertEquals(entityManager.find(Task.class, 1L), permissionResult_1.getResult());
-
-        //Situation 2: invalid taskgroup
-        PermissionResult<Task> permissionResult_2 = taskService.getTaskPermissions(200L, username);
-        assertEquals(ServiceExitCode.MISSING_ENTITY, permissionResult_2.getExitCode());
-        assertFalse(permissionResult_2.isHasPermissions());
-        assertThat(permissionResult_2.getResult()).isNull();
-
-        //Situation 3: invalid user
-        PermissionResult<Task> permissionResult_3 = taskService.getTaskPermissions(1L, username2);
-        assertEquals(ServiceExitCode.OK, permissionResult_3.getExitCode());
-        assertFalse(permissionResult_2.isHasPermissions());
-        assertEquals(entityManager.find(Task.class, 1L), permissionResult_3.getResult());
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void editTask() {
-        //Situation 1: Nothing is updated
-        Task task_1 = entityManager.find(Task.class, 1L);
-        TaskFieldInfo taskFieldInfo_1 = new TaskFieldInfo(entityManager.find(Task.class, 1L).getTaskName(), 0, null, null);
-        ServiceResult<Task> result_1 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_1);
-        assertEquals(ServiceExitCode.OK, result_1.getExitCode());
-        assertEquals(task_1, result_1.getResult());
-
-        //Situation 2: Name is updated to name that already exists within the taskgroup
-        Task task_2 = entityManager.find(Task.class, 1L);
-        TaskFieldInfo taskFieldInfo_2 = new TaskFieldInfo(entityManager.find(Task.class, 2L).getTaskName(), 0, null, null);
-        ServiceResult<Task> result_2 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_2);
-        task_2.setTaskName(entityManager.find(Task.class, 2L).getTaskName());
-        assertEquals(ServiceExitCode.ENTITY_ALREADY_EXIST, result_2.getExitCode());
-        assertNotEquals(task_2, result_2.getResult());
-
-        //Situation 3: Name is updated to nonexistend Name
-        Task task_3 = entityManager.find(Task.class, 1L);
-        TaskFieldInfo taskFieldInfo_3 = new TaskFieldInfo("Situation 3", 0, null, null);
-        ServiceResult<Task> result_3 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_3);
-        task_3.setTaskName("Situation 3");
-        assertEquals(ServiceExitCode.OK, result_3.getExitCode());
-        assertEquals(task_3, result_3.getResult());
-
-        //Situation 4: eta is updated
-        Task task_4 = entityManager.find(Task.class, 1L);
-        TaskFieldInfo taskFieldInfo_4 = new TaskFieldInfo(task_4.getTaskName(), 90, null, null);
-        ServiceResult<Task> result_4 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_4);
-        task_4.setEta(90);
-        assertEquals(ServiceExitCode.OK, result_4.getExitCode());
-        assertEquals(task_4, result_4.getResult());
-
-        //Situation 5: deadline and start is updated in a valid way
-        Task task_5 = entityManager.find(Task.class, 1L);
-        TaskFieldInfo taskFieldInfo_5 = new TaskFieldInfo(task_5.getTaskName(), task_5.getEta(), LocalDate.of(2023, 4, 9), LocalDate.of(2023,5,9));
-        ServiceResult<Task> result_5 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_5);
-        task_5.setStartDate(LocalDate.of(2023,4,9));
-        task_5.setDeadline(LocalDate.of(2023,5,9));
-        assertEquals(ServiceExitCode.OK, result_5.getExitCode());
-        assertEquals(task_5, result_5.getResult());
-
-        //Situation 6: Deadline and start are updated in a not valid way
-        Task task_6 = entityManager.find(Task.class, 1L);
-        TaskFieldInfo taskFieldInfo_6 = new TaskFieldInfo(task_5.getTaskName(), task_5.getEta(), LocalDate.of(2023, 5, 9), LocalDate.of(2023,4,9));
-        ServiceResult<Task> result_6 = taskService.editTask(entityManager.find(Task.class, 1L), taskFieldInfo_6);
-        task_6.setStartDate(LocalDate.of(2023,5,9));
-        task_6.setDeadline(LocalDate.of(2023,4,9));
-        assertEquals(ServiceExitCode.INVALID_PARAMETER, result_6.getExitCode());
-        assertNotEquals(task_6, result_6.getResult());
-
-        //Situation 10 Startdate = null;
-        Task task_10 = entityManager.find(Task.class, 5L);
-        TaskFieldInfo taskFieldInfo_10 = new TaskFieldInfo(task_10.getTaskName(), task_10.getEta(),null, task_10.getDeadline());
-        ServiceResult<Task> result_10 = taskService.editTask(entityManager.find(Task.class, 5L), taskFieldInfo_10);
-        task_10.setStartDate(null);
-        assertEquals(ServiceExitCode.OK, result_10.getExitCode());
-        assertEquals(task_10, result_10.getResult());
-
-        //Situation 11 Deadline = null
-        Task task_11 = entityManager.find(Task.class, 5L);
-        TaskFieldInfo taskFieldInfo_11 = new TaskFieldInfo(task_11.getTaskName(), task_11.getEta(),task_11.getStartDate(), null);
-        ServiceResult<Task> result_11 = taskService.editTask(entityManager.find(Task.class, 5L), taskFieldInfo_11);
-        task_11.setDeadline(null);
-        assertEquals(ServiceExitCode.OK, result_11.getExitCode());
-        assertEquals(task_11, result_11.getResult());
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void deleteTask() {
-        for(long i=1; i<=15; i++) {
-            taskService.deleteTask(entityManager.find(Task.class, i));
-            assertThat(entityManager.find(Task.class, i)).isNull();
-        }
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void clearTasks() {
-        //Situation 1: Delete from taskgroup with no tasks
-        taskService.clearTasks(entityManager.find(Taskgroup.class, 1L));
-        for(long i=1; i<=15; i++) {
-            assertThat(entityManager.find(Task.class, i)).isNotNull();
-        }
-        //Situation 2: Delete from taskgroup with tasks
-        taskService.clearTasks(entityManager.find(Taskgroup.class, 2L));
-        for(long i=1; i<=15; i++) {
-            assertThat(entityManager.find(Task.class, i)).isNull();
-        }
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void finishTask() {
-        taskService.finishTask(entityManager.find(Task.class, 1L));
-        assertTrue(entityManager.find(Task.class, 1L).isFinished());
-
-        taskService.finishTask(entityManager.find(Task.class, 2L));
-        assertTrue(entityManager.find(Task.class, 1L).isFinished());
-        assertThat(entityManager.find(BasicTaskSchedule.class, 2L)).isNull();
-    }
-
-    @Test
-    @SqlGroup({
-            @Sql("classpath:taskgroupRepositoryTestEntries.sql"),
-            @Sql("classpath:taskRepositoryEntries.sql"),
-            @Sql("classpath:basicScheduleEntries.sql")
-    })
-    void loadAllTasks() {
-        //Situation 1: No tasks existing
-        List<Task> result_1 = taskService.loadAllTasks(username2, TaskScope.UNFINISHED);
-        assertEquals(0, result_1.size());
-
-        //Situation 2: Tasks existing, Unfinished#
-        List<Task> result_2 = taskService.loadAllTasks(username, TaskScope.UNFINISHED);
-        assertEquals(8, result_2.size());
-        assertTrue(result_2.contains(entityManager.find(Task.class, 1L)));
-        assertTrue(result_2.contains(entityManager.find(Task.class, 3L)));
-        assertTrue(result_2.contains(entityManager.find(Task.class, 5L)));
-        assertTrue(result_2.contains(entityManager.find(Task.class, 7L)));
-        assertTrue(result_2.contains(entityManager.find(Task.class, 9L)));
-        assertTrue(result_2.contains(entityManager.find(Task.class, 11L)));
-        assertTrue(result_2.contains(entityManager.find(Task.class, 12L)));
-
-        //Situation 3: Finished tasks
-        List<Task> result_3 = taskService.loadAllTasks(username, TaskScope.FINISHED);
-        assertEquals(7, result_3.size());
-        assertTrue(result_3.contains(entityManager.find(Task.class, 2L)));
-        assertTrue(result_3.contains(entityManager.find(Task.class, 4L)));
-        assertTrue(result_3.contains(entityManager.find(Task.class, 6L)));
-        assertTrue(result_3.contains(entityManager.find(Task.class, 8L)));
-        assertTrue(result_3.contains(entityManager.find(Task.class, 10L)));
-        assertTrue(result_3.contains(entityManager.find(Task.class, 13L)));
-        assertTrue(result_3.contains(entityManager.find(Task.class, 14L)));
-
-        //overdue
-        List<Task> result_4 = taskService.loadAllTasks(username, TaskScope.OVERDUE);
-        assertEquals(2, result_4.size());
-        assertTrue(result_4.contains(entityManager.find(Task.class, 3L)));
-        assertTrue(result_4.contains(entityManager.find(Task.class, 5L)));
-
-        //upcoming
-        List<Task> result_5 = taskService.loadAllTasks(username, TaskScope.UPCOMING);
-        assertEquals(2, result_5.size());
-        assertTrue(result_5.contains(entityManager.find(Task.class, 7L)));
-        assertTrue(result_5.contains(entityManager.find(Task.class, 9L)));
-        //Active
-        List<Task> result_6 = taskService.loadAllTasks(username, TaskScope.ACTIVE);
-        assertEquals(6, result_6.size());
-        assertTrue(result_6.contains(entityManager.find(Task.class, 1L)));
-        assertTrue(result_6.contains(entityManager.find(Task.class, 3L)));
-        assertTrue(result_6.contains(entityManager.find(Task.class, 5L)));
-        assertTrue(result_6.contains(entityManager.find(Task.class, 11L)));
-        assertTrue(result_6.contains(entityManager.find(Task.class, 12L)));
-
-    }
-}

backend/src/test/java/core/users/UserRepositoryTests.java

@@ -1,87 +0,0 @@
-package core.users;
-
-import core.entities.User;
-import core.repositories.UserRepository;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
-import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
-import org.springframework.test.annotation.DirtiesContext;
-import org.springframework.test.context.jdbc.Sql;
-import org.springframework.test.context.junit.jupiter.SpringExtension;
-
-import java.util.Optional;
-
-import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
-
-@DataJpaTest
-@ExtendWith(SpringExtension.class)
-public class UserRepositoryTests {
-
-    @Autowired
-    private UserRepository userRepository;
-
-    @Autowired
-    private TestEntityManager testEntityManager;
-
-    @Test
-    @Sql("classpath:userRepisotoryTestEntries.sql")
-    void test_findByUsername() {
-        //Situation 1: User with name "FawKes100" is present
-        User referenceUser = testEntityManager.find(User.class, 1L);
-        Optional<User> findResult = userRepository.findByUsername(referenceUser.getUsername());
-        assertTrue(findResult.isPresent());
-        assertEquals(referenceUser,findResult.get());
-
-        //Situation 2: No user with the required name is present
-        findResult = userRepository.findByUsername("fawkes1001");
-        assertFalse(findResult.isPresent());
-    }
-
-    @Test
-    @Sql("classpath:userRepisotoryTestEntries.sql")
-    void test_existsByMail() {
-        User referenceUser = testEntityManager.find(User.class, 1L);
-        //Situation 1: invalid email format should not matter
-        assertFalse(userRepository.existsByEmail("FawKes100"));
-
-        //Situation 2: No user exists with such a mail
-        assertFalse(userRepository.existsByEmail("mail@fawkes100.de"));
-
-        //Situation 3: User with this mail exists
-        assertTrue(userRepository.existsByEmail(referenceUser.getEmail()));
-    }
-
-    @Test
-    @Sql("classpath:userRepisotoryTestEntries.sql")
-    void test_existsByUsername() {
-        User referenceUser = testEntityManager.find(User.class, 1L);
-        //Situation 1: No such user
-        assertFalse(userRepository.existsByUsername("FawKes100"));
-
-        //Situation 3: User with this name exists
-        assertTrue(userRepository.existsByUsername(referenceUser.getUsername()));
-    }
-
-    @Test
-    @Sql("classpath:userRepisotoryTestEntries.sql")
-    void test_deleteUserByName() {
-        User referenceUser1 = testEntityManager.find(User.class, 1L);
-        User referenceUser2 = testEntityManager.find(User.class, 2L);
-
-        userRepository.deleteByUsername(referenceUser2.getUsername());
-
-        assertThat(testEntityManager.find(User.class, referenceUser2.getId())).isNull();
-        assertThat(testEntityManager.find(User.class, referenceUser1.getId())).isNotNull();
-    }
-
-
-    @Test
-    @Sql("classpath:userRepisotoryTestEntries.sql")
-    void test_countUsers() {
-        assertEquals(2, userRepository.countUsers());
-    }
-
-}

frontend/src/api/.openapi-generator/FILES

@@ -5,6 +5,7 @@ api/account.service.ts
 api/api.ts
 api/history.service.ts
 api/login.service.ts
+api/ntfy.service.ts
 api/properties.service.ts
 api/schedule.service.ts
 api/task.service.ts
@@ -32,6 +33,7 @@ model/loginRequest.ts
 model/loginResponse.ts
 model/manualScheduleStopInfo.ts
 model/models.ts
+model/ntfyInformation.ts
 model/passwordChangeRequest.ts
 model/propertiesInfo.ts
 model/propertyInfo.ts

frontend/src/api/api.module.ts

@@ -5,6 +5,7 @@ import { HttpClient } from '@angular/common/http';
 import { AccountService } from './api/account.service';
 import { HistoryService } from './api/history.service';
 import { LoginService } from './api/login.service';
+import { NtfyService } from './api/ntfy.service';
 import { PropertiesService } from './api/properties.service';
 import { ScheduleService } from './api/schedule.service';
 import { TaskService } from './api/task.service';

frontend/src/api/api/api.ts

@@ -4,6 +4,8 @@ export * from './history.service';
 import { HistoryService } from './history.service';
 export * from './login.service';
 import { LoginService } from './login.service';
+export * from './ntfy.service';
+import { NtfyService } from './ntfy.service';
 export * from './properties.service';
 import { PropertiesService } from './properties.service';
 export * from './schedule.service';
@@ -14,4 +16,4 @@ export * from './taskgroup.service';
 import { TaskgroupService } from './taskgroup.service';
 export * from './users.service';
 import { UsersService } from './users.service';
-export const APIS = [AccountService, HistoryService, LoginService, PropertiesService, ScheduleService, TaskService, TaskgroupService, UsersService];
+export const APIS = [AccountService, HistoryService, LoginService, NtfyService, PropertiesService, ScheduleService, TaskService, TaskgroupService, UsersService];

frontend/src/api/api/ntfy.service.ts

@@ -0,0 +1,210 @@
+/**
+ * API Title
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext 
+        }       from '@angular/common/http';
+import { CustomHttpParameterCodec }                          from '../encoder';
+import { Observable }                                        from 'rxjs';
+
+import { NtfyInformation } from '../model/models';
+import { SimpleStatusResponse } from '../model/models';
+
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class NtfyService {
+
+    protected basePath = 'http://127.0.0.1:8080/api';
+    public defaultHeaders = new HttpHeaders();
+    public configuration = new Configuration();
+    public encoder: HttpParameterCodec;
+
+    constructor(protected httpClient: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {
+        if (configuration) {
+            this.configuration = configuration;
+        }
+        if (typeof this.configuration.basePath !== 'string') {
+            if (typeof basePath !== 'string') {
+                basePath = this.basePath;
+            }
+            this.configuration.basePath = basePath;
+        }
+        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec();
+    }
+
+
+    private addToHttpParams(httpParams: HttpParams, value: any, key?: string): HttpParams {
+        if (typeof value === "object" && value instanceof Date === false) {
+            httpParams = this.addToHttpParamsRecursive(httpParams, value);
+        } else {
+            httpParams = this.addToHttpParamsRecursive(httpParams, value, key);
+        }
+        return httpParams;
+    }
+
+    private addToHttpParamsRecursive(httpParams: HttpParams, value?: any, key?: string): HttpParams {
+        if (value == null) {
+            return httpParams;
+        }
+
+        if (typeof value === "object") {
+            if (Array.isArray(value)) {
+                (value as any[]).forEach( elem => httpParams = this.addToHttpParamsRecursive(httpParams, elem, key));
+            } else if (value instanceof Date) {
+                if (key != null) {
+                    httpParams = httpParams.append(key,
+                        (value as Date).toISOString().substr(0, 10));
+                } else {
+                   throw Error("key may not be null if value is Date");
+                }
+            } else {
+                Object.keys(value).forEach( k => httpParams = this.addToHttpParamsRecursive(
+                    httpParams, value[k], key != null ? `${key}.${k}` : k));
+            }
+        } else if (key != null) {
+            httpParams = httpParams.append(key, value);
+        } else {
+            throw Error("key may not be null if value is not object or array");
+        }
+        return httpParams;
+    }
+
+    /**
+     * Get ntfy information
+     * Get ntfy information
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public ntfyGet(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<NtfyInformation>;
+    public ntfyGet(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<NtfyInformation>>;
+    public ntfyGet(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<NtfyInformation>>;
+    public ntfyGet(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        let localVarCredential: string | undefined;
+        // authentication (API_TOKEN) required
+        localVarCredential = this.configuration.lookupCredential('API_TOKEN');
+        if (localVarCredential) {
+            localVarHeaders = localVarHeaders.set('Authorization', 'Bearer ' + localVarCredential);
+        }
+
+        let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts: string[] = [
+                'application/json'
+            ];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        let localVarHttpContext: HttpContext | undefined = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+
+
+        let responseType_: 'text' | 'json' = 'json';
+        if(localVarHttpHeaderAcceptSelected && localVarHttpHeaderAcceptSelected.startsWith('text')) {
+            responseType_ = 'text';
+        }
+
+        return this.httpClient.get<NtfyInformation>(`${this.configuration.basePath}/ntfy`,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                withCredentials: this.configuration.withCredentials,
+                headers: localVarHeaders,
+                observe: observe,
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+    /**
+     * Edit ntfy information
+     * Edit ntfy information
+     * @param ntfyInformation 
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    public ntfyPost(ntfyInformation?: NtfyInformation, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<SimpleStatusResponse>;
+    public ntfyPost(ntfyInformation?: NtfyInformation, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<SimpleStatusResponse>>;
+    public ntfyPost(ntfyInformation?: NtfyInformation, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<SimpleStatusResponse>>;
+    public ntfyPost(ntfyInformation?: NtfyInformation, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> {
+
+        let localVarHeaders = this.defaultHeaders;
+
+        let localVarCredential: string | undefined;
+        // authentication (API_TOKEN) required
+        localVarCredential = this.configuration.lookupCredential('API_TOKEN');
+        if (localVarCredential) {
+            localVarHeaders = localVarHeaders.set('Authorization', 'Bearer ' + localVarCredential);
+        }
+
+        let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts: string[] = [
+                'application/json'
+            ];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+        let localVarHttpContext: HttpContext | undefined = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+
+
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            'application/json'
+        ];
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+
+        let responseType_: 'text' | 'json' = 'json';
+        if(localVarHttpHeaderAcceptSelected && localVarHttpHeaderAcceptSelected.startsWith('text')) {
+            responseType_ = 'text';
+        }
+
+        return this.httpClient.post<SimpleStatusResponse>(`${this.configuration.basePath}/ntfy`,
+            ntfyInformation,
+            {
+                context: localVarHttpContext,
+                responseType: <any>responseType_,
+                withCredentials: this.configuration.withCredentials,
+                headers: localVarHeaders,
+                observe: observe,
+                reportProgress: reportProgress
+            }
+        );
+    }
+
+}

frontend/src/api/model/models.ts

@@ -15,6 +15,7 @@ export * from './inlineResponse409';
 export * from './loginRequest';
 export * from './loginResponse';
 export * from './manualScheduleStopInfo';
+export * from './ntfyInformation';
 export * from './passwordChangeRequest';
 export * from './propertiesInfo';
 export * from './propertyInfo';

frontend/src/api/model/ntfyInformation.ts

@@ -0,0 +1,32 @@
+/**
+ * API Title
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export interface NtfyInformation { 
+    /**
+     * host of ntfy service
+     */
+    ntfy_host: string;
+    /**
+     * topic of ntfy service
+     */
+    ntfy_topic: string;
+    /**
+     * username of ntfy account for publishing news
+     */
+    ntfy_user: string;
+    /**
+     * token to ntfy useraccount
+     */
+    ntfy_token?: string;
+}
+

frontend/src/app/app.module.ts

@@ -89,6 +89,8 @@ import { ScheduleHistoryComponent } from './statistics/schedule-history/schedule
 import {MatButtonToggleModule} from "@angular/material/button-toggle";
 import {MatGridListModule} from "@angular/material/grid-list";
 import { StopScheduleManuallyComponent } from './dashboard/active-schedule/stop-schedule-manually/stop-schedule-manually.component';
+import { ConnectionSettingsComponent } from './user-settings/connection-settings/connection-settings.component';
+import { NtfySettingsComponent } from './user-settings/connection-settings/ntfy-settings/ntfy-settings.component';
 @NgModule({
   declarations: [
     AppComponent,
@@ -134,6 +136,8 @@ import { StopScheduleManuallyComponent } from './dashboard/active-schedule/stop-
     HeatmapActivityComponent,
     ScheduleHistoryComponent,
     StopScheduleManuallyComponent,
+    ConnectionSettingsComponent,
+    NtfySettingsComponent,
   ],
   imports: [
     BrowserModule,

frontend/src/app/user-settings/connection-settings/connection-settings.component.html

@@ -0,0 +1 @@
+<app-ntfy-settings></app-ntfy-settings>

frontend/src/app/user-settings/connection-settings/connection-settings.component.spec.ts

@@ -0,0 +1,21 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { ConnectionSettingsComponent } from './connection-settings.component';
+
+describe('ConnectionSettingsComponent', () => {
+  let component: ConnectionSettingsComponent;
+  let fixture: ComponentFixture<ConnectionSettingsComponent>;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      declarations: [ConnectionSettingsComponent]
+    });
+    fixture = TestBed.createComponent(ConnectionSettingsComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

frontend/src/app/user-settings/connection-settings/connection-settings.component.ts

@@ -0,0 +1,10 @@
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-connection-settings',
+  templateUrl: './connection-settings.component.html',
+  styleUrls: ['./connection-settings.component.css']
+})
+export class ConnectionSettingsComponent {
+
+}

frontend/src/app/user-settings/connection-settings/ntfy-settings/ntfy-settings.component.html

@@ -0,0 +1,24 @@
+<mat-form-field appearance="outline" class="long-form">
+  <mat-label>Hostname</mat-label>
+  <input matInput [formControl]="host_formCtrl" placeholder="https://ntfy.sh">
+</mat-form-field>
+
+<mat-form-field appearance="outline" class="long-form">
+  <mat-label>Topic</mat-label>
+  <input matInput [formControl]="topic_formCtrl" placeholder="Topic">
+</mat-form-field>
+
+<mat-form-field appearance="outline" class="long-form">
+  <mat-label>Username</mat-label>
+  <input matInput [formControl]="user_formCtrl" placeholder="username">
+</mat-form-field>
+
+<mat-form-field appearance="outline" class="long-form">
+  <mat-label>Token</mat-label>
+  <input matInput [formControl]="token_formCtrl" placeholder="Token" type="password">
+</mat-form-field>
+
+<div style="float: right">
+  <button mat-raised-button color="primary" (click)="save()">Save</button>
+</div>
+

frontend/src/app/user-settings/connection-settings/ntfy-settings/ntfy-settings.component.spec.ts

@@ -0,0 +1,21 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { NtfySettingsComponent } from './ntfy-settings.component';
+
+describe('NtfySettingsComponent', () => {
+  let component: NtfySettingsComponent;
+  let fixture: ComponentFixture<NtfySettingsComponent>;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      declarations: [NtfySettingsComponent]
+    });
+    fixture = TestBed.createComponent(NtfySettingsComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

frontend/src/app/user-settings/connection-settings/ntfy-settings/ntfy-settings.component.ts

@@ -0,0 +1,49 @@
+import { Component } from '@angular/core';
+import {NtfyService} from "../../../../api";
+import {Form, FormBuilder, FormControl, FormGroup, Validators} from "@angular/forms";
+import {MatSnackBar} from "@angular/material/snack-bar";
+
+@Component({
+  selector: 'app-ntfy-settings',
+  templateUrl: './ntfy-settings.component.html',
+  styleUrls: ['./ntfy-settings.component.css']
+})
+export class NtfySettingsComponent {
+
+  host_formCtrl = new FormControl('', [Validators.required])
+  topic_formCtrl = new FormControl('', [Validators.required])
+  user_formCtrl = new FormControl('', [Validators.required])
+  token_formCtrl = new FormControl('', [Validators.required])
+
+  constructor(private ntfyService: NtfyService,
+              private snackbar: MatSnackBar) {
+  }
+
+  ngOnInit() {
+    this.ntfyService.ntfyGet().subscribe({
+      next: resp => {
+        this.host_formCtrl.setValue(resp.ntfy_host);
+        this.topic_formCtrl.setValue(resp.ntfy_topic);
+        this.user_formCtrl.setValue(resp.ntfy_user);
+        this.token_formCtrl.setValue(resp.ntfy_token!);
+      }
+    })
+  }
+
+  save() {
+    const token = this.token_formCtrl.value === "****" ? "" : this.token_formCtrl.value!
+    const user = this.user_formCtrl.value === "****" ? "" : this.user_formCtrl.value!
+    this.ntfyService.ntfyPost({
+      ntfy_host: this.host_formCtrl.value!,
+      ntfy_topic: this.topic_formCtrl.value!,
+      ntfy_token: token,
+      ntfy_user: user
+    }).subscribe({
+      next: resp => {
+        this.snackbar.open("Ntfy-Configuration updated", "", {duration: 2000})
+        this.user_formCtrl.setValue("****");
+        this.token_formCtrl.setValue("****");
+      }
+    })
+  }
+}

frontend/src/app/user-settings/user-settings.component.html

@@ -4,4 +4,10 @@
       <app-account-settings></app-account-settings>
     </div>
   </mat-tab>
+
+  <mat-tab label="Connections">
+    <div class="container">
+      <app-connection-settings></app-connection-settings>
+    </div>
+  </mat-tab>
 </mat-tab-group>

openapi.yaml

@@ -2027,6 +2027,52 @@ paths:
                 type: array
                 items:
                   $ref: '#/components/schemas/ScheduleInfo'
+  /ntfy:
+    get:
+      security:
+        - API_TOKEN: []
+      tags:
+        - ntfy
+      description: Get ntfy information
+      summary: Get ntfy information
+      responses:
+        200:
+          description: Operation successfull
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/NtfyInformation'
+        404:
+          description: Not found
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SimpleStatusResponse'
+    post:
+      security:
+        - API_TOKEN: []
+      tags:
+        - ntfy
+      description: Edit ntfy information
+      summary: Edit ntfy information
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/NtfyInformation'
+      responses:
+        200:
+          description: Operation successfull
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SimpleStatusResponse'
+        404:
+          description: Operation successfull
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SimpleStatusResponse'
 
       
 components:
@@ -2713,3 +2759,24 @@ components:
           type: number
           description: duration in minutes
           example: 10
+    NtfyInformation:
+      required:
+        - ntfy_host
+        - ntfy_topic
+      additionalProperties: false
+      properties:
+        ntfy_host:
+          type: string
+          description: host of ntfy service
+          example: https://ntfy.fawkes100.de
+        ntfy_topic:
+          type: string
+          description: topic of ntfy service
+          example: Topicname
+        ntfy_user:
+          type: string
+          description: username of ntfy account for publishing news
+          example: password
+        ntfy_token:
+          type: string
+          description: token to ntfy useraccount