Use Lombok plugin

backend-spring/.gitignore

@@ -1,2 +1,8 @@
 .gradle/
 build/
+
+# Eclispe Directories
+/.classpath
+/.project
+/bin
+/.settings

backend-spring/build.gradle.kts

@@ -2,6 +2,7 @@ plugins {
     java
     id("org.springframework.boot") version "4.0.3"
     id("io.spring.dependency-management") version "1.1.7"
+    id("io.freefair.lombok") version "9.2.0"
 }
 
 group = "be.seeseepuff"

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/AllowancePlannerApplication.java

@@ -4,10 +4,8 @@ import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication
-public class AllowancePlannerApplication
+public class AllowancePlannerApplication {
-{
+    static void main(String[] args) {
-	public static void main(String[] args)
+        SpringApplication.run(AllowancePlannerApplication.class, args);
-	{
+    }
-		SpringApplication.run(AllowancePlannerApplication.class, args);
-	}
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/AllowanceController.java

@@ -0,0 +1,221 @@
+package be.seeseepuff.allowanceplanner.controller;
+
+import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.service.AllowanceService;
+import be.seeseepuff.allowanceplanner.service.UserService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/api")
+@CrossOrigin(origins = "*")
+public class AllowanceController {
+    private final UserService userService;
+    private final AllowanceService allowanceService;
+
+    public AllowanceController(UserService userService, AllowanceService allowanceService) {
+        this.userService = userService;
+        this.allowanceService = allowanceService;
+    }
+
+    @GetMapping("/user/{userId}/allowance")
+    public ResponseEntity<?> getUserAllowance(@PathVariable String userId) {
+        int id;
+        try {
+            id = Integer.parseInt(userId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
+        }
+
+        if (!userService.userExists(id)) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
+        }
+
+        return ResponseEntity.ok(allowanceService.getUserAllowances(id));
+    }
+
+    @PostMapping("/user/{userId}/allowance")
+    public ResponseEntity<?> createUserAllowance(@PathVariable String userId,
+                                                 @RequestBody CreateAllowanceRequest request) {
+        int id;
+        try {
+            id = Integer.parseInt(userId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
+        }
+
+        if (request.name() == null || request.name().isEmpty()) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Allowance name cannot be empty"));
+        }
+
+        if (!userService.userExists(id)) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
+        }
+
+        int allowanceId = allowanceService.createAllowance(id, request);
+        return ResponseEntity.status(HttpStatus.CREATED).body(new IdResponse(allowanceId));
+    }
+
+    @PutMapping("/user/{userId}/allowance")
+    public ResponseEntity<?> bulkPutUserAllowance(@PathVariable String userId,
+                                                  @RequestBody List<BulkUpdateAllowanceRequest> requests) {
+        int id;
+        try {
+            id = Integer.parseInt(userId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
+        }
+
+        if (!userService.userExists(id)) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
+        }
+
+        allowanceService.bulkUpdateAllowance(id, requests);
+        return ResponseEntity.ok(new MessageResponse("Allowance updated successfully"));
+    }
+
+    @GetMapping("/user/{userId}/allowance/{allowanceId}")
+    public ResponseEntity<?> getUserAllowanceById(@PathVariable String userId, @PathVariable String allowanceId) {
+        int uid;
+        try {
+            uid = Integer.parseInt(userId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
+        }
+
+        int aid;
+        try {
+            aid = Integer.parseInt(allowanceId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid allowance ID"));
+        }
+
+        if (!userService.userExists(uid)) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
+        }
+
+        Optional<AllowanceDto> allowance = allowanceService.getUserAllowanceById(uid, aid);
+        if (allowance.isEmpty()) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Allowance not found"));
+        }
+        return ResponseEntity.ok(allowance.get());
+    }
+
+    @DeleteMapping("/user/{userId}/allowance/{allowanceId}")
+    public ResponseEntity<?> deleteUserAllowance(@PathVariable String userId, @PathVariable String allowanceId) {
+        int uid;
+        try {
+            uid = Integer.parseInt(userId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
+        }
+
+        int aid;
+        try {
+            aid = Integer.parseInt(allowanceId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid allowance ID"));
+        }
+
+        if (aid == 0) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Allowance id zero cannot be deleted"));
+        }
+
+        if (!userService.userExists(uid)) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
+        }
+
+        boolean deleted = allowanceService.deleteAllowance(uid, aid);
+        if (!deleted) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("History not found"));
+        }
+        return ResponseEntity.ok(new MessageResponse("History deleted successfully"));
+    }
+
+    @PutMapping("/user/{userId}/allowance/{allowanceId}")
+    public ResponseEntity<?> putUserAllowance(@PathVariable String userId, @PathVariable String allowanceId,
+                                              @RequestBody UpdateAllowanceRequest request) {
+        int uid;
+        try {
+            uid = Integer.parseInt(userId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
+        }
+
+        int aid;
+        try {
+            aid = Integer.parseInt(allowanceId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid allowance ID"));
+        }
+
+        if (!userService.userExists(uid)) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
+        }
+
+        boolean updated = allowanceService.updateAllowance(uid, aid, request);
+        if (!updated) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Allowance not found"));
+        }
+        return ResponseEntity.ok(new MessageResponse("Allowance updated successfully"));
+    }
+
+    @PostMapping("/user/{userId}/allowance/{allowanceId}/complete")
+    public ResponseEntity<?> completeAllowance(@PathVariable String userId, @PathVariable String allowanceId) {
+        int uid;
+        try {
+            uid = Integer.parseInt(userId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
+        }
+
+        int aid;
+        try {
+            aid = Integer.parseInt(allowanceId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid allowance ID"));
+        }
+
+        if (!userService.userExists(uid)) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
+        }
+
+        boolean completed = allowanceService.completeAllowance(uid, aid);
+        if (!completed) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Allowance not found"));
+        }
+        return ResponseEntity.ok(new MessageResponse("Allowance completed successfully"));
+    }
+
+    @PostMapping("/user/{userId}/allowance/{allowanceId}/add")
+    public ResponseEntity<?> addToAllowance(@PathVariable String userId, @PathVariable String allowanceId,
+                                            @RequestBody AddAllowanceAmountRequest request) {
+        int uid;
+        try {
+            uid = Integer.parseInt(userId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
+        }
+
+        int aid;
+        try {
+            aid = Integer.parseInt(allowanceId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid allowance ID"));
+        }
+
+        if (!userService.userExists(uid)) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
+        }
+
+        boolean result = allowanceService.addAllowanceAmount(uid, aid, request);
+        if (!result) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Allowance not found"));
+        }
+        return ResponseEntity.ok(new MessageResponse("Allowance completed successfully"));
+    }
+}

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/ApiController.java

@@ -1,519 +0,0 @@
-package be.seeseepuff.allowanceplanner.controller;
-
-import be.seeseepuff.allowanceplanner.dto.*;
-import be.seeseepuff.allowanceplanner.service.AllowanceService;
-import be.seeseepuff.allowanceplanner.service.MigrationService;
-import be.seeseepuff.allowanceplanner.service.TaskService;
-import be.seeseepuff.allowanceplanner.service.TransferService;
-import be.seeseepuff.allowanceplanner.service.UserService;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.List;
-import java.util.Optional;
-
-@RestController
-@RequestMapping("/api")
-@CrossOrigin(origins = "*")
-public class ApiController
-{
-	private final UserService userService;
-	private final AllowanceService allowanceService;
-	private final TaskService taskService;
-	private final TransferService transferService;
-	private final MigrationService migrationService;
-
-	public ApiController(UserService userService,
-			AllowanceService allowanceService,
-			TaskService taskService,
-			TransferService transferService,
-			MigrationService migrationService)
-	{
-		this.userService = userService;
-		this.allowanceService = allowanceService;
-		this.taskService = taskService;
-		this.transferService = transferService;
-		this.migrationService = migrationService;
-	}
-
-	// ---- Users ----
-
-	@GetMapping("/users")
-	public List<UserDto> getUsers()
-	{
-		return userService.getUsers();
-	}
-
-	@GetMapping("/user/{userId}")
-	public ResponseEntity<?> getUser(@PathVariable String userId)
-	{
-		int id;
-		try
-		{
-			id = Integer.parseInt(userId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
-		}
-
-		Optional<UserWithAllowanceDto> user = userService.getUser(id);
-		if (user.isEmpty())
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
-		}
-		return ResponseEntity.ok(user.get());
-	}
-
-	// ---- History ----
-
-	@PostMapping("/user/{userId}/history")
-	public ResponseEntity<?> postHistory(@PathVariable String userId, @RequestBody PostHistoryRequest request)
-	{
-		int id;
-		try
-		{
-			id = Integer.parseInt(userId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
-		}
-
-		if (request.description() == null || request.description().isEmpty())
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Description cannot be empty"));
-		}
-
-		if (!userService.userExists(id))
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
-		}
-
-		allowanceService.addHistory(id, request);
-		return ResponseEntity.ok(new MessageResponse("History updated successfully"));
-	}
-
-	@GetMapping("/user/{userId}/history")
-	public ResponseEntity<?> getHistory(@PathVariable String userId)
-	{
-		int id;
-		try
-		{
-			id = Integer.parseInt(userId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
-		}
-
-		List<HistoryDto> history = allowanceService.getHistory(id);
-		return ResponseEntity.ok(history);
-	}
-
-	// ---- Allowances ----
-
-	@GetMapping("/user/{userId}/allowance")
-	public ResponseEntity<?> getUserAllowance(@PathVariable String userId)
-	{
-		int id;
-		try
-		{
-			id = Integer.parseInt(userId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
-		}
-
-		if (!userService.userExists(id))
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
-		}
-
-		return ResponseEntity.ok(allowanceService.getUserAllowances(id));
-	}
-
-	@PostMapping("/user/{userId}/allowance")
-	public ResponseEntity<?> createUserAllowance(@PathVariable String userId,
-			@RequestBody CreateAllowanceRequest request)
-	{
-		int id;
-		try
-		{
-			id = Integer.parseInt(userId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
-		}
-
-		if (request.name() == null || request.name().isEmpty())
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Allowance name cannot be empty"));
-		}
-
-		if (!userService.userExists(id))
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
-		}
-
-		int allowanceId = allowanceService.createAllowance(id, request);
-		return ResponseEntity.status(HttpStatus.CREATED).body(new IdResponse(allowanceId));
-	}
-
-	@PutMapping("/user/{userId}/allowance")
-	public ResponseEntity<?> bulkPutUserAllowance(@PathVariable String userId,
-			@RequestBody List<BulkUpdateAllowanceRequest> requests)
-	{
-		int id;
-		try
-		{
-			id = Integer.parseInt(userId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
-		}
-
-		if (!userService.userExists(id))
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
-		}
-
-		allowanceService.bulkUpdateAllowance(id, requests);
-		return ResponseEntity.ok(new MessageResponse("Allowance updated successfully"));
-	}
-
-	@GetMapping("/user/{userId}/allowance/{allowanceId}")
-	public ResponseEntity<?> getUserAllowanceById(@PathVariable String userId, @PathVariable String allowanceId)
-	{
-		int uid;
-		try
-		{
-			uid = Integer.parseInt(userId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
-		}
-
-		int aid;
-		try
-		{
-			aid = Integer.parseInt(allowanceId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid allowance ID"));
-		}
-
-		if (!userService.userExists(uid))
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
-		}
-
-		Optional<AllowanceDto> allowance = allowanceService.getUserAllowanceById(uid, aid);
-		if (allowance.isEmpty())
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Allowance not found"));
-		}
-		return ResponseEntity.ok(allowance.get());
-	}
-
-	@DeleteMapping("/user/{userId}/allowance/{allowanceId}")
-	public ResponseEntity<?> deleteUserAllowance(@PathVariable String userId, @PathVariable String allowanceId)
-	{
-		int uid;
-		try
-		{
-			uid = Integer.parseInt(userId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
-		}
-
-		int aid;
-		try
-		{
-			aid = Integer.parseInt(allowanceId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid allowance ID"));
-		}
-
-		if (aid == 0)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Allowance id zero cannot be deleted"));
-		}
-
-		if (!userService.userExists(uid))
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
-		}
-
-		boolean deleted = allowanceService.deleteAllowance(uid, aid);
-		if (!deleted)
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("History not found"));
-		}
-		return ResponseEntity.ok(new MessageResponse("History deleted successfully"));
-	}
-
-	@PutMapping("/user/{userId}/allowance/{allowanceId}")
-	public ResponseEntity<?> putUserAllowance(@PathVariable String userId, @PathVariable String allowanceId,
-			@RequestBody UpdateAllowanceRequest request)
-	{
-		int uid;
-		try
-		{
-			uid = Integer.parseInt(userId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
-		}
-
-		int aid;
-		try
-		{
-			aid = Integer.parseInt(allowanceId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid allowance ID"));
-		}
-
-		if (!userService.userExists(uid))
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
-		}
-
-		boolean updated = allowanceService.updateAllowance(uid, aid, request);
-		if (!updated)
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Allowance not found"));
-		}
-		return ResponseEntity.ok(new MessageResponse("Allowance updated successfully"));
-	}
-
-	@PostMapping("/user/{userId}/allowance/{allowanceId}/complete")
-	public ResponseEntity<?> completeAllowance(@PathVariable String userId, @PathVariable String allowanceId)
-	{
-		int uid;
-		try
-		{
-			uid = Integer.parseInt(userId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
-		}
-
-		int aid;
-		try
-		{
-			aid = Integer.parseInt(allowanceId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid allowance ID"));
-		}
-
-		if (!userService.userExists(uid))
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
-		}
-
-		boolean completed = allowanceService.completeAllowance(uid, aid);
-		if (!completed)
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Allowance not found"));
-		}
-		return ResponseEntity.ok(new MessageResponse("Allowance completed successfully"));
-	}
-
-	@PostMapping("/user/{userId}/allowance/{allowanceId}/add")
-	public ResponseEntity<?> addToAllowance(@PathVariable String userId, @PathVariable String allowanceId,
-			@RequestBody AddAllowanceAmountRequest request)
-	{
-		int uid;
-		try
-		{
-			uid = Integer.parseInt(userId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
-		}
-
-		int aid;
-		try
-		{
-			aid = Integer.parseInt(allowanceId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid allowance ID"));
-		}
-
-		if (!userService.userExists(uid))
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
-		}
-
-		boolean result = allowanceService.addAllowanceAmount(uid, aid, request);
-		if (!result)
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Allowance not found"));
-		}
-		return ResponseEntity.ok(new MessageResponse("Allowance completed successfully"));
-	}
-
-	// ---- Tasks ----
-
-	@PostMapping("/tasks")
-	public ResponseEntity<?> createTask(@RequestBody CreateTaskRequest request)
-	{
-		if (request.name() == null || request.name().isEmpty())
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Task name cannot be empty"));
-		}
-
-		if (request.schedule() != null)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Schedules are not yet supported"));
-		}
-
-		if (request.assigned() != null)
-		{
-			if (!userService.userExists(request.assigned()))
-			{
-				return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
-			}
-		}
-
-		int taskId = taskService.createTask(request);
-		return ResponseEntity.status(HttpStatus.CREATED).body(new IdResponse(taskId));
-	}
-
-	@GetMapping("/tasks")
-	public List<TaskDto> getTasks()
-	{
-		return taskService.getTasks();
-	}
-
-	@GetMapping("/task/{taskId}")
-	public ResponseEntity<?> getTask(@PathVariable String taskId)
-	{
-		int id;
-		try
-		{
-			id = Integer.parseInt(taskId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid task ID"));
-		}
-
-		Optional<TaskDto> task = taskService.getTask(id);
-		if (task.isEmpty())
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Task not found"));
-		}
-		return ResponseEntity.ok(task.get());
-	}
-
-	@PutMapping("/task/{taskId}")
-	public ResponseEntity<?> putTask(@PathVariable String taskId, @RequestBody CreateTaskRequest request)
-	{
-		int id;
-		try
-		{
-			id = Integer.parseInt(taskId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid task ID"));
-		}
-
-		Optional<TaskDto> existing = taskService.getTask(id);
-		if (existing.isEmpty())
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Task not found"));
-		}
-
-		taskService.updateTask(id, request);
-		return ResponseEntity.ok(new MessageResponse("Task updated successfully"));
-	}
-
-	@DeleteMapping("/task/{taskId}")
-	public ResponseEntity<?> deleteTask(@PathVariable String taskId)
-	{
-		int id;
-		try
-		{
-			id = Integer.parseInt(taskId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid task ID"));
-		}
-
-		if (!taskService.hasTask(id))
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Task not found"));
-		}
-
-		taskService.deleteTask(id);
-		return ResponseEntity.ok(new MessageResponse("Task deleted successfully"));
-	}
-
-	@PostMapping("/task/{taskId}/complete")
-	public ResponseEntity<?> completeTask(@PathVariable String taskId)
-	{
-		int id;
-		try
-		{
-			id = Integer.parseInt(taskId);
-		}
-		catch (NumberFormatException e)
-		{
-			return ResponseEntity.badRequest().body(new ErrorResponse("Invalid task ID"));
-		}
-
-		boolean completed = taskService.completeTask(id);
-		if (!completed)
-		{
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Task not found"));
-		}
-		return ResponseEntity.ok(new MessageResponse("Task completed successfully"));
-	}
-
-	// ---- Transfer ----
-
-	@PostMapping("/transfer")
-	public ResponseEntity<?> transfer(@RequestBody TransferRequest request)
-	{
-		TransferService.TransferResult result = transferService.transfer(request);
-		return switch (result.status())
-		{
-			case SUCCESS -> ResponseEntity.ok(new MessageResponse(result.message()));
-			case BAD_REQUEST -> ResponseEntity.badRequest().body(new ErrorResponse(result.message()));
-			case NOT_FOUND ->
-					ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse(result.message()));
-		};
-	}
-
-	// ---- Migration ----
-
-	@PostMapping("/import")
-	public ResponseEntity<?> importData(@RequestBody MigrationDto data)
-	{
-		migrationService.importData(data);
-		return ResponseEntity.ok(new MessageResponse("Import successful"));
-	}
-}

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/HistoryController.java

@@ -0,0 +1,57 @@
+package be.seeseepuff.allowanceplanner.controller;
+
+import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.service.AllowanceService;
+import be.seeseepuff.allowanceplanner.service.UserService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api")
+@CrossOrigin(origins = "*")
+public class HistoryController {
+    private final UserService userService;
+    private final AllowanceService allowanceService;
+
+    public HistoryController(UserService userService, AllowanceService allowanceService) {
+        this.userService = userService;
+        this.allowanceService = allowanceService;
+    }
+
+    @PostMapping("/user/{userId}/history")
+    public ResponseEntity<?> postHistory(@PathVariable String userId, @RequestBody PostHistoryRequest request) {
+        int id;
+        try {
+            id = Integer.parseInt(userId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
+        }
+
+        if (request.description() == null || request.description().isEmpty()) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Description cannot be empty"));
+        }
+
+        if (!userService.userExists(id)) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
+        }
+
+        allowanceService.addHistory(id, request);
+        return ResponseEntity.ok(new MessageResponse("History updated successfully"));
+    }
+
+    @GetMapping("/user/{userId}/history")
+    public ResponseEntity<?> getHistory(@PathVariable String userId) {
+        int id;
+        try {
+            id = Integer.parseInt(userId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
+        }
+
+        List<HistoryDto> history = allowanceService.getHistory(id);
+        return ResponseEntity.ok(history);
+    }
+}

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/MigrationController.java

@@ -0,0 +1,23 @@
+package be.seeseepuff.allowanceplanner.controller;
+
+import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.service.MigrationService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api")
+@CrossOrigin(origins = "*")
+public class MigrationController {
+    private final MigrationService migrationService;
+
+    public MigrationController(MigrationService migrationService) {
+        this.migrationService = migrationService;
+    }
+
+    @PostMapping("/import")
+    public ResponseEntity<?> importData(@RequestBody MigrationDto data) {
+        migrationService.importData(data);
+        return ResponseEntity.ok(new MessageResponse("Import successful"));
+    }
+}

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/TaskController.java

@@ -0,0 +1,116 @@
+package be.seeseepuff.allowanceplanner.controller;
+
+import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.service.TaskService;
+import be.seeseepuff.allowanceplanner.service.UserService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/api")
+@CrossOrigin(origins = "*")
+public class TaskController {
+    private final UserService userService;
+    private final TaskService taskService;
+
+    public TaskController(UserService userService, TaskService taskService) {
+        this.userService = userService;
+        this.taskService = taskService;
+    }
+
+    @PostMapping("/tasks")
+    public ResponseEntity<?> createTask(@RequestBody CreateTaskRequest request) {
+        if (request.name() == null || request.name().isEmpty()) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Task name cannot be empty"));
+        }
+
+        if (request.schedule() != null) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Schedules are not yet supported"));
+        }
+
+        if (request.assigned() != null) {
+            if (!userService.userExists(request.assigned())) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
+            }
+        }
+
+        int taskId = taskService.createTask(request);
+        return ResponseEntity.status(HttpStatus.CREATED).body(new IdResponse(taskId));
+    }
+
+    @GetMapping("/tasks")
+    public List<TaskDto> getTasks() {
+        return taskService.getTasks();
+    }
+
+    @GetMapping("/task/{taskId}")
+    public ResponseEntity<?> getTask(@PathVariable String taskId) {
+        int id;
+        try {
+            id = Integer.parseInt(taskId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid task ID"));
+        }
+
+        Optional<TaskDto> task = taskService.getTask(id);
+        if (task.isEmpty()) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Task not found"));
+        }
+        return ResponseEntity.ok(task.get());
+    }
+
+    @PutMapping("/task/{taskId}")
+    public ResponseEntity<?> putTask(@PathVariable String taskId, @RequestBody CreateTaskRequest request) {
+        int id;
+        try {
+            id = Integer.parseInt(taskId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid task ID"));
+        }
+
+        Optional<TaskDto> existing = taskService.getTask(id);
+        if (existing.isEmpty()) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Task not found"));
+        }
+
+        taskService.updateTask(id, request);
+        return ResponseEntity.ok(new MessageResponse("Task updated successfully"));
+    }
+
+    @DeleteMapping("/task/{taskId}")
+    public ResponseEntity<?> deleteTask(@PathVariable String taskId) {
+        int id;
+        try {
+            id = Integer.parseInt(taskId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid task ID"));
+        }
+
+        if (!taskService.hasTask(id)) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Task not found"));
+        }
+
+        taskService.deleteTask(id);
+        return ResponseEntity.ok(new MessageResponse("Task deleted successfully"));
+    }
+
+    @PostMapping("/task/{taskId}/complete")
+    public ResponseEntity<?> completeTask(@PathVariable String taskId) {
+        int id;
+        try {
+            id = Integer.parseInt(taskId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid task ID"));
+        }
+
+        boolean completed = taskService.completeTask(id);
+        if (!completed) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("Task not found"));
+        }
+        return ResponseEntity.ok(new MessageResponse("Task completed successfully"));
+    }
+}

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/TransferController.java

@@ -0,0 +1,28 @@
+package be.seeseepuff.allowanceplanner.controller;
+
+import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.service.TransferService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api")
+@CrossOrigin(origins = "*")
+public class TransferController {
+    private final TransferService transferService;
+
+    public TransferController(TransferService transferService) {
+        this.transferService = transferService;
+    }
+
+    @PostMapping("/transfer")
+    public ResponseEntity<?> transfer(@RequestBody TransferRequest request) {
+        TransferService.TransferResult result = transferService.transfer(request);
+        return switch (result.status()) {
+            case SUCCESS -> ResponseEntity.ok(new MessageResponse(result.message()));
+            case BAD_REQUEST -> ResponseEntity.badRequest().body(new ErrorResponse(result.message()));
+            case NOT_FOUND -> ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse(result.message()));
+        };
+    }
+}

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/UserController.java

@@ -0,0 +1,42 @@
+package be.seeseepuff.allowanceplanner.controller;
+
+import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.service.UserService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/api")
+@CrossOrigin(origins = "*")
+public class UserController {
+    private final UserService userService;
+
+    public UserController(UserService userService) {
+        this.userService = userService;
+    }
+
+    @GetMapping("/users")
+    public List<UserDto> getUsers() {
+        return userService.getUsers();
+    }
+
+    @GetMapping("/user/{userId}")
+    public ResponseEntity<?> getUser(@PathVariable String userId) {
+        int id;
+        try {
+            id = Integer.parseInt(userId);
+        } catch (NumberFormatException e) {
+            return ResponseEntity.badRequest().body(new ErrorResponse("Invalid user ID"));
+        }
+
+        Optional<UserWithAllowanceDto> user = userService.getUser(id);
+        if (user.isEmpty()) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(new ErrorResponse("User not found"));
+        }
+        return ResponseEntity.ok(user.get());
+    }
+}

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/WebController.java

@@ -1,6 +1,7 @@
 package be.seeseepuff.allowanceplanner.controller;
 
-import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.dto.CreateAllowanceRequest;
+import be.seeseepuff.allowanceplanner.dto.CreateTaskRequest;
 import be.seeseepuff.allowanceplanner.service.AllowanceService;
 import be.seeseepuff.allowanceplanner.service.TaskService;
 import be.seeseepuff.allowanceplanner.service.UserService;
@@ -14,160 +15,135 @@ import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 
 import java.util.Arrays;
-import java.util.List;
 
 @Controller
-public class WebController
+public class WebController {
-{
+    private final UserService userService;
-	private final UserService userService;
+    private final AllowanceService allowanceService;
-	private final AllowanceService allowanceService;
+    private final TaskService taskService;
-	private final TaskService taskService;
 
-	public WebController(UserService userService, AllowanceService allowanceService, TaskService taskService)
+    public WebController(UserService userService, AllowanceService allowanceService, TaskService taskService) {
-	{
+        this.userService = userService;
-		this.userService = userService;
+        this.allowanceService = allowanceService;
-		this.allowanceService = allowanceService;
+        this.taskService = taskService;
-		this.taskService = taskService;
+    }
-	}
 
-	@GetMapping("/")
+    @GetMapping("/")
-	public String index(HttpServletRequest request, HttpServletResponse response, Model model)
+    public String index(HttpServletRequest request, HttpServletResponse response, Model model) {
-	{
+        Integer currentUser = getCurrentUser(request, response);
-		Integer currentUser = getCurrentUser(request, response);
+        if (currentUser == null) {
-		if (currentUser == null)
+            model.addAttribute("users", userService.getUsers());
-		{
+            return "index";
-			model.addAttribute("users", userService.getUsers());
+        }
-			return "index";
+        return renderWithUser(model, currentUser);
-		}
+    }
-		return renderWithUser(model, currentUser);
-	}
 
-	@GetMapping("/login")
+    @GetMapping("/login")
-	public String login(@RequestParam(required = false) String user, HttpServletResponse response)
+    public String login(@RequestParam(required = false) String user, HttpServletResponse response) {
-	{
+        if (user != null && !user.isEmpty()) {
-		if (user != null && !user.isEmpty())
+            Cookie cookie = new Cookie("user", user);
-		{
+            cookie.setMaxAge(3600);
-			Cookie cookie = new Cookie("user", user);
+            cookie.setHttpOnly(true);
-			cookie.setMaxAge(3600);
+            response.addCookie(cookie);
-			cookie.setHttpOnly(true);
+        }
-			response.addCookie(cookie);
+        return "redirect:/";
-		}
+    }
-		return "redirect:/";
-	}
 
-	@PostMapping("/createTask")
+    @PostMapping("/createTask")
-	public String createTask(@RequestParam String name, @RequestParam double reward,
+    public String createTask(@RequestParam String name, @RequestParam double reward,
-			@RequestParam(required = false) String schedule,
+                             @RequestParam(required = false) String schedule,
-			HttpServletRequest request, HttpServletResponse response, Model model)
+                             HttpServletRequest request, HttpServletResponse response, Model model) {
-	{
+        Integer currentUser = getCurrentUser(request, response);
-		Integer currentUser = getCurrentUser(request, response);
+        if (currentUser == null) {
-		if (currentUser == null)
+            return "redirect:/";
-		{
+        }
-			return "redirect:/";
-		}
 
-		if (name.isEmpty() || reward <= 0)
+        if (name.isEmpty() || reward <= 0) {
-		{
+            model.addAttribute("error", "Invalid input");
-			model.addAttribute("error", "Invalid input");
+            return "index";
-			return "index";
+        }
-		}
 
-		CreateTaskRequest taskRequest = new CreateTaskRequest(name, reward, null,
+        CreateTaskRequest taskRequest = new CreateTaskRequest(name, reward, null,
-				(schedule != null && !schedule.isEmpty()) ? schedule : null);
+                (schedule != null && !schedule.isEmpty()) ? schedule : null);
-		taskService.createTask(taskRequest);
+        taskService.createTask(taskRequest);
-		return "redirect:/";
+        return "redirect:/";
-	}
+    }
 
-	@GetMapping("/completeTask")
+    @GetMapping("/completeTask")
-	public String completeTask(@RequestParam("task") int taskId)
+    public String completeTask(@RequestParam("task") int taskId) {
-	{
+        taskService.completeTask(taskId);
-		taskService.completeTask(taskId);
+        return "redirect:/";
-		return "redirect:/";
+    }
-	}
 
-	@PostMapping("/createAllowance")
+    @PostMapping("/createAllowance")
-	public String createAllowance(@RequestParam String name, @RequestParam double target,
+    public String createAllowance(@RequestParam String name, @RequestParam double target,
-			@RequestParam double weight,
+                                  @RequestParam double weight,
-			HttpServletRequest request, HttpServletResponse response, Model model)
+                                  HttpServletRequest request, HttpServletResponse response, Model model) {
-	{
+        Integer currentUser = getCurrentUser(request, response);
-		Integer currentUser = getCurrentUser(request, response);
+        if (currentUser == null) {
-		if (currentUser == null)
+            return "redirect:/";
-		{
+        }
-			return "redirect:/";
-		}
 
-		if (name.isEmpty() || target <= 0 || weight <= 0)
+        if (name.isEmpty() || target <= 0 || weight <= 0) {
-		{
+            model.addAttribute("error", "Invalid input");
-			model.addAttribute("error", "Invalid input");
+            return "index";
-			return "index";
+        }
-		}
 
-		allowanceService.createAllowance(currentUser, new CreateAllowanceRequest(name, target, weight, ""));
+        allowanceService.createAllowance(currentUser, new CreateAllowanceRequest(name, target, weight, ""));
-		return "redirect:/";
+        return "redirect:/";
-	}
+    }
 
-	@GetMapping("/completeAllowance")
+    @GetMapping("/completeAllowance")
-	public String completeAllowance(@RequestParam("allowance") int allowanceId,
+    public String completeAllowance(@RequestParam("allowance") int allowanceId,
-			HttpServletRequest request, HttpServletResponse response)
+                                    HttpServletRequest request, HttpServletResponse response) {
-	{
+        Integer currentUser = getCurrentUser(request, response);
-		Integer currentUser = getCurrentUser(request, response);
+        if (currentUser == null) {
-		if (currentUser == null)
+            return "redirect:/";
-		{
+        }
-			return "redirect:/";
+        allowanceService.completeAllowance(currentUser, allowanceId);
-		}
+        return "redirect:/";
-		allowanceService.completeAllowance(currentUser, allowanceId);
+    }
-		return "redirect:/";
-	}
 
-	private Integer getCurrentUser(HttpServletRequest request, HttpServletResponse response)
+    private Integer getCurrentUser(HttpServletRequest request, HttpServletResponse response) {
-	{
+        Cookie[] cookies = request.getCookies();
-		Cookie[] cookies = request.getCookies();
+        if (cookies == null) {
-		if (cookies == null)
+            return null;
-		{
+        }
-			return null;
+        String userStr = Arrays.stream(cookies)
-		}
+                .filter(c -> "user".equals(c.getName()))
-		String userStr = Arrays.stream(cookies)
+                .map(Cookie::getValue)
-				.filter(c -> "user".equals(c.getName()))
+                .findFirst()
-				.map(Cookie::getValue)
+                .orElse(null);
-				.findFirst()
+        if (userStr == null) {
-				.orElse(null);
+            return null;
-		if (userStr == null)
+        }
-		{
+        try {
-			return null;
+            int userId = Integer.parseInt(userStr);
-		}
+            if (!userService.userExists(userId)) {
-		try
+                unsetUserCookie(response);
-		{
+                return null;
-			int userId = Integer.parseInt(userStr);
+            }
-			if (!userService.userExists(userId))
+            return userId;
-			{
+        } catch (NumberFormatException e) {
-				unsetUserCookie(response);
+            unsetUserCookie(response);
-				return null;
+            return null;
-			}
+        }
-			return userId;
+    }
-		}
-		catch (NumberFormatException e)
-		{
-			unsetUserCookie(response);
-			return null;
-		}
-	}
 
-	private void unsetUserCookie(HttpServletResponse response)
+    private void unsetUserCookie(HttpServletResponse response) {
-	{
+        Cookie cookie = new Cookie("user", "");
-		Cookie cookie = new Cookie("user", "");
+        cookie.setMaxAge(0);
-		cookie.setMaxAge(0);
+        cookie.setPath("/");
-		cookie.setPath("/");
+        cookie.setHttpOnly(true);
-		cookie.setHttpOnly(true);
+        response.addCookie(cookie);
-		response.addCookie(cookie);
+    }
-	}
 
-	private String renderWithUser(Model model, int currentUser)
+    private String renderWithUser(Model model, int currentUser) {
-	{
+        model.addAttribute("users", userService.getUsers());
-		model.addAttribute("users", userService.getUsers());
+        model.addAttribute("currentUser", currentUser);
-		model.addAttribute("currentUser", currentUser);
+        model.addAttribute("allowances", allowanceService.getUserAllowances(currentUser));
-		model.addAttribute("allowances", allowanceService.getUserAllowances(currentUser));
+        model.addAttribute("tasks", taskService.getTasks());
-		model.addAttribute("tasks", taskService.getTasks());
+        model.addAttribute("history", allowanceService.getHistory(currentUser));
-		model.addAttribute("history", allowanceService.getHistory(currentUser));
+        return "index";
-		return "index";
+    }
-	}
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/AddAllowanceAmountRequest.java

@@ -1,5 +1,4 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-public record AddAllowanceAmountRequest(double amount, String description)
+public record AddAllowanceAmountRequest(double amount, String description) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/AllowanceDto.java

@@ -3,6 +3,5 @@ package be.seeseepuff.allowanceplanner.dto;
 import com.fasterxml.jackson.annotation.JsonInclude;
 
 @JsonInclude(JsonInclude.Include.ALWAYS)
-public record AllowanceDto(int id, String name, double target, double progress, double weight, String colour)
+public record AllowanceDto(int id, String name, double target, double progress, double weight, String colour) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/BulkUpdateAllowanceRequest.java

@@ -1,5 +1,4 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-public record BulkUpdateAllowanceRequest(int id, double weight)
+public record BulkUpdateAllowanceRequest(int id, double weight) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/CreateAllowanceRequest.java

@@ -1,5 +1,4 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-public record CreateAllowanceRequest(String name, double target, double weight, String colour)
+public record CreateAllowanceRequest(String name, double target, double weight, String colour) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/CreateTaskRequest.java

@@ -1,11 +1,8 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-import com.fasterxml.jackson.annotation.JsonProperty;
-
 public record CreateTaskRequest(
-		String name,
+        String name,
-		Double reward,
+        Double reward,
-		Integer assigned,
+        Integer assigned,
-		String schedule)
+        String schedule) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/ErrorResponse.java

@@ -1,5 +1,4 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-public record ErrorResponse(String error)
+public record ErrorResponse(String error) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/HistoryDto.java

@@ -2,6 +2,5 @@ package be.seeseepuff.allowanceplanner.dto;
 
 import java.time.Instant;
 
-public record HistoryDto(double allowance, Instant timestamp, String description)
+public record HistoryDto(double allowance, Instant timestamp, String description) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/IdResponse.java

@@ -1,5 +1,4 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-public record IdResponse(int id)
+public record IdResponse(int id) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/MessageResponse.java

@@ -1,5 +1,4 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-public record MessageResponse(String message)
+public record MessageResponse(String message) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/MigrationDto.java

@@ -3,19 +3,22 @@ package be.seeseepuff.allowanceplanner.dto;
 import java.util.List;
 
 public record MigrationDto(
-		List<MigrationUserDto> users,
+        List<MigrationUserDto> users,
-		List<MigrationAllowanceDto> allowances,
+        List<MigrationAllowanceDto> allowances,
-		List<MigrationHistoryDto> history,
+        List<MigrationHistoryDto> history,
-		List<MigrationTaskDto> tasks
+        List<MigrationTaskDto> tasks
-)
+) {
-{
+    public record MigrationUserDto(int id, String name, long balance, double weight) {
-	public record MigrationUserDto(int id, String name, long balance, double weight) {}
+    }
 
-	public record MigrationAllowanceDto(int id, int userId, String name, long target, long balance, double weight,
+    public record MigrationAllowanceDto(int id, int userId, String name, long target, long balance, double weight,
-			Integer colour) {}
+                                        Integer colour) {
+    }
 
-	public record MigrationHistoryDto(int id, int userId, long timestamp, long amount, String description) {}
+    public record MigrationHistoryDto(int id, int userId, long timestamp, long amount, String description) {
+    }
 
-	public record MigrationTaskDto(int id, String name, long reward, Integer assigned, String schedule,
+    public record MigrationTaskDto(int id, String name, long reward, Integer assigned, String schedule,
-			Long completed, Long nextRun) {}
+                                   Long completed, Long nextRun) {
+    }
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/PostHistoryRequest.java

@@ -1,5 +1,4 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-public record PostHistoryRequest(double allowance, String description)
+public record PostHistoryRequest(double allowance, String description) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/TaskDto.java

@@ -3,6 +3,5 @@ package be.seeseepuff.allowanceplanner.dto;
 import com.fasterxml.jackson.annotation.JsonInclude;
 
 @JsonInclude(JsonInclude.Include.ALWAYS)
-public record TaskDto(int id, String name, double reward, Integer assigned, String schedule)
+public record TaskDto(int id, String name, double reward, Integer assigned, String schedule) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/TransferRequest.java

@@ -1,5 +1,4 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-public record TransferRequest(int from, int to, double amount)
+public record TransferRequest(int from, int to, double amount) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/UpdateAllowanceRequest.java

@@ -1,5 +1,4 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-public record UpdateAllowanceRequest(String name, double target, double weight, String colour)
+public record UpdateAllowanceRequest(String name, double target, double weight, String colour) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/UserDto.java

@@ -1,5 +1,4 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-public record UserDto(int id, String name)
+public record UserDto(int id, String name) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/UserWithAllowanceDto.java

@@ -1,5 +1,4 @@
 package be.seeseepuff.allowanceplanner.dto;
 
-public record UserWithAllowanceDto(int id, String name, double allowance)
+public record UserWithAllowanceDto(int id, String name, double allowance) {
-{
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/Allowance.java

@@ -1,99 +1,32 @@
 package be.seeseepuff.allowanceplanner.entity;
 
 import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
 
 @Entity
 @Table(name = "allowances")
-public class Allowance
+@Getter
-{
+@Setter
-	@Id
+public class Allowance {
-	@GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Id
-	private int id;
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private int id;
 
-	@Column(name = "user_id", nullable = false)
+    @Column(name = "user_id", nullable = false)
-	private int userId;
+    private int userId;
 
-	@Column(nullable = false)
+    @Column(nullable = false)
-	private String name;
+    private String name;
 
-	@Column(nullable = false)
+    @Column(nullable = false)
-	private long target;
+    private long target;
 
-	@Column(nullable = false)
+    @Column(nullable = false)
-	private long balance = 0;
+    private long balance = 0;
 
-	@Column(nullable = false)
+    @Column(nullable = false)
-	private double weight;
+    private double weight;
 
-	private Integer colour;
+    private Integer colour;
-
-	public int getId()
-	{
-		return id;
-	}
-
-	public void setId(int id)
-	{
-		this.id = id;
-	}
-
-	public int getUserId()
-	{
-		return userId;
-	}
-
-	public void setUserId(int userId)
-	{
-		this.userId = userId;
-	}
-
-	public String getName()
-	{
-		return name;
-	}
-
-	public void setName(String name)
-	{
-		this.name = name;
-	}
-
-	public long getTarget()
-	{
-		return target;
-	}
-
-	public void setTarget(long target)
-	{
-		this.target = target;
-	}
-
-	public long getBalance()
-	{
-		return balance;
-	}
-
-	public void setBalance(long balance)
-	{
-		this.balance = balance;
-	}
-
-	public double getWeight()
-	{
-		return weight;
-	}
-
-	public void setWeight(double weight)
-	{
-		this.weight = weight;
-	}
-
-	public Integer getColour()
-	{
-		return colour;
-	}
-
-	public void setColour(Integer colour)
-	{
-		this.colour = colour;
-	}
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/History.java

@@ -1,73 +1,26 @@
 package be.seeseepuff.allowanceplanner.entity;
 
 import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
 
 @Entity
 @Table(name = "history")
-public class History
+@Getter
-{
+@Setter
-	@Id
+public class History {
-	@GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Id
-	private int id;
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private int id;
 
-	@Column(name = "user_id", nullable = false)
+    @Column(name = "user_id", nullable = false)
-	private int userId;
+    private int userId;
 
-	@Column(nullable = false)
+    @Column(nullable = false)
-	private long timestamp;
+    private long timestamp;
 
-	@Column(nullable = false)
+    @Column(nullable = false)
-	private long amount;
+    private long amount;
 
-	private String description;
+    private String description;
-
-	public int getId()
-	{
-		return id;
-	}
-
-	public void setId(int id)
-	{
-		this.id = id;
-	}
-
-	public int getUserId()
-	{
-		return userId;
-	}
-
-	public void setUserId(int userId)
-	{
-		this.userId = userId;
-	}
-
-	public long getTimestamp()
-	{
-		return timestamp;
-	}
-
-	public void setTimestamp(long timestamp)
-	{
-		this.timestamp = timestamp;
-	}
-
-	public long getAmount()
-	{
-		return amount;
-	}
-
-	public void setAmount(long amount)
-	{
-		this.amount = amount;
-	}
-
-	public String getDescription()
-	{
-		return description;
-	}
-
-	public void setDescription(String description)
-	{
-		this.description = description;
-	}
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/Task.java

@@ -1,97 +1,30 @@
 package be.seeseepuff.allowanceplanner.entity;
 
 import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
 
 @Entity
 @Table(name = "tasks")
-public class Task
+@Getter
-{
+@Setter
-	@Id
+public class Task {
-	@GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Id
-	private int id;
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private int id;
 
-	@Column(nullable = false)
+    @Column(nullable = false)
-	private String name;
+    private String name;
 
-	@Column(nullable = false)
+    @Column(nullable = false)
-	private long reward;
+    private long reward;
 
-	private Integer assigned;
+    private Integer assigned;
 
-	private String schedule;
+    private String schedule;
 
-	private Long completed;
+    private Long completed;
 
-	@Column(name = "next_run")
+    @Column(name = "next_run")
-	private Long nextRun;
+    private Long nextRun;
-
-	public int getId()
-	{
-		return id;
-	}
-
-	public void setId(int id)
-	{
-		this.id = id;
-	}
-
-	public String getName()
-	{
-		return name;
-	}
-
-	public void setName(String name)
-	{
-		this.name = name;
-	}
-
-	public long getReward()
-	{
-		return reward;
-	}
-
-	public void setReward(long reward)
-	{
-		this.reward = reward;
-	}
-
-	public Integer getAssigned()
-	{
-		return assigned;
-	}
-
-	public void setAssigned(Integer assigned)
-	{
-		this.assigned = assigned;
-	}
-
-	public String getSchedule()
-	{
-		return schedule;
-	}
-
-	public void setSchedule(String schedule)
-	{
-		this.schedule = schedule;
-	}
-
-	public Long getCompleted()
-	{
-		return completed;
-	}
-
-	public void setCompleted(Long completed)
-	{
-		this.completed = completed;
-	}
-
-	public Long getNextRun()
-	{
-		return nextRun;
-	}
-
-	public void setNextRun(Long nextRun)
-	{
-		this.nextRun = nextRun;
-	}
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/User.java

@@ -1,61 +1,24 @@
 package be.seeseepuff.allowanceplanner.entity;
 
 import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
 
 @Entity
 @Table(name = "users")
-public class User
+@Getter
-{
+@Setter
-	@Id
+public class User {
-	@GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Id
-	private int id;
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private int id;
 
-	@Column(nullable = false)
+    @Column(nullable = false)
-	private String name;
+    private String name;
 
-	@Column(nullable = false)
+    @Column(nullable = false)
-	private double weight = 10.0;
+    private double weight = 10.0;
 
-	@Column(nullable = false)
+    @Column(nullable = false)
-	private long balance = 0;
+    private long balance = 0;
-
-	public int getId()
-	{
-		return id;
-	}
-
-	public void setId(int id)
-	{
-		this.id = id;
-	}
-
-	public String getName()
-	{
-		return name;
-	}
-
-	public void setName(String name)
-	{
-		this.name = name;
-	}
-
-	public double getWeight()
-	{
-		return weight;
-	}
-
-	public void setWeight(double weight)
-	{
-		this.weight = weight;
-	}
-
-	public long getBalance()
-	{
-		return balance;
-	}
-
-	public void setBalance(long balance)
-	{
-		this.balance = balance;
-	}
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/AllowanceRepository.java

@@ -9,19 +9,18 @@ import java.util.List;
 import java.util.Optional;
 
 @Repository
-public interface AllowanceRepository extends JpaRepository<Allowance, Integer>
+public interface AllowanceRepository extends JpaRepository<Allowance, Integer> {
-{
+    List<Allowance> findByUserIdOrderByIdAsc(int userId);
-	List<Allowance> findByUserIdOrderByIdAsc(int userId);
 
-	Optional<Allowance> findByIdAndUserId(int id, int userId);
+    Optional<Allowance> findByIdAndUserId(int id, int userId);
 
-	int countByIdAndUserId(int id, int userId);
+    int countByIdAndUserId(int id, int userId);
 
-	void deleteByIdAndUserId(int id, int userId);
+    void deleteByIdAndUserId(int id, int userId);
 
-	@Query("SELECT a FROM Allowance a WHERE a.userId = :userId AND a.weight > 0 ORDER BY (a.target - a.balance) ASC")
+    @Query("SELECT a FROM Allowance a WHERE a.userId = :userId AND a.weight > 0 ORDER BY (a.target - a.balance) ASC")
-	List<Allowance> findByUserIdWithPositiveWeightOrderByRemainingAsc(int userId);
+    List<Allowance> findByUserIdWithPositiveWeightOrderByRemainingAsc(int userId);
 
-	@Query("SELECT COALESCE(SUM(a.weight), 0) FROM Allowance a WHERE a.userId = :userId AND a.weight > 0")
+    @Query("SELECT COALESCE(SUM(a.weight), 0) FROM Allowance a WHERE a.userId = :userId AND a.weight > 0")
-	double sumPositiveWeights(int userId);
+    double sumPositiveWeights(int userId);
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/HistoryRepository.java

@@ -7,7 +7,6 @@ import org.springframework.stereotype.Repository;
 import java.util.List;
 
 @Repository
-public interface HistoryRepository extends JpaRepository<History, Integer>
+public interface HistoryRepository extends JpaRepository<History, Integer> {
-{
+    List<History> findByUserIdOrderByIdDesc(int userId);
-	List<History> findByUserIdOrderByIdDesc(int userId);
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/TaskRepository.java

@@ -8,9 +8,8 @@ import java.util.List;
 import java.util.Optional;
 
 @Repository
-public interface TaskRepository extends JpaRepository<Task, Integer>
+public interface TaskRepository extends JpaRepository<Task, Integer> {
-{
+    List<Task> findByCompletedIsNull();
-	List<Task> findByCompletedIsNull();
 
-	Optional<Task> findByIdAndCompletedIsNull(int id);
+    Optional<Task> findByIdAndCompletedIsNull(int id);
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/UserRepository.java

@@ -6,8 +6,7 @@ import org.springframework.data.jpa.repository.Query;
 import org.springframework.stereotype.Repository;
 
 @Repository
-public interface UserRepository extends JpaRepository<User, Integer>
+public interface UserRepository extends JpaRepository<User, Integer> {
-{
+    @Query("SELECT COALESCE(SUM(h.amount), 0) FROM History h WHERE h.userId = :userId")
-	@Query("SELECT COALESCE(SUM(h.amount), 0) FROM History h WHERE h.userId = :userId")
+    long sumHistoryAmount(int userId);
-	long sumHistoryAmount(int userId);
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/AllowanceService.java

@@ -17,282 +17,242 @@ import java.util.List;
 import java.util.Optional;
 
 @Service
-public class AllowanceService
+public class AllowanceService {
-{
+    private final AllowanceRepository allowanceRepository;
-	private final AllowanceRepository allowanceRepository;
+    private final UserRepository userRepository;
-	private final UserRepository userRepository;
+    private final HistoryRepository historyRepository;
-	private final HistoryRepository historyRepository;
 
-	public AllowanceService(AllowanceRepository allowanceRepository,
+    public AllowanceService(AllowanceRepository allowanceRepository,
-			UserRepository userRepository,
+                            UserRepository userRepository,
-			HistoryRepository historyRepository)
+                            HistoryRepository historyRepository) {
-	{
+        this.allowanceRepository = allowanceRepository;
-		this.allowanceRepository = allowanceRepository;
+        this.userRepository = userRepository;
-		this.userRepository = userRepository;
+        this.historyRepository = historyRepository;
-		this.historyRepository = historyRepository;
+    }
-	}
 
-	public List<AllowanceDto> getUserAllowances(int userId)
+    public List<AllowanceDto> getUserAllowances(int userId) {
-	{
+        User user = userRepository.findById(userId).orElseThrow();
-		User user = userRepository.findById(userId).orElseThrow();
+        List<AllowanceDto> result = new ArrayList<>();
-		List<AllowanceDto> result = new ArrayList<>();
 
-		// Add the "rest" allowance (id=0)
+        // Add the "rest" allowance (id=0)
-		result.add(new AllowanceDto(0, "", 0, user.getBalance() / 100.0, user.getWeight(), ""));
+        result.add(new AllowanceDto(0, "", 0, user.getBalance() / 100.0, user.getWeight(), ""));
 
-		// Add named allowances
+        // Add named allowances
-		for (Allowance a : allowanceRepository.findByUserIdOrderByIdAsc(userId))
+        for (Allowance a : allowanceRepository.findByUserIdOrderByIdAsc(userId)) {
-		{
+            result.add(toDto(a));
-			result.add(toDto(a));
+        }
-		}
+        return result;
-		return result;
+    }
-	}
 
-	public Optional<AllowanceDto> getUserAllowanceById(int userId, int allowanceId)
+    public Optional<AllowanceDto> getUserAllowanceById(int userId, int allowanceId) {
-	{
+        if (allowanceId == 0) {
-		if (allowanceId == 0)
+            return userRepository.findById(userId)
-		{
+                    .map(u -> new AllowanceDto(0, "", 0, u.getBalance() / 100.0, u.getWeight(), ""));
-			return userRepository.findById(userId)
+        }
-					.map(u -> new AllowanceDto(0, "", 0, u.getBalance() / 100.0, u.getWeight(), ""));
+        return allowanceRepository.findByIdAndUserId(allowanceId, userId)
-		}
+                .map(this::toDto);
-		return allowanceRepository.findByIdAndUserId(allowanceId, userId)
+    }
-				.map(this::toDto);
-	}
 
-	@Transactional
+    @Transactional
-	public int createAllowance(int userId, CreateAllowanceRequest request)
+    public int createAllowance(int userId, CreateAllowanceRequest request) {
-	{
+        int colour = ColourUtil.convertStringToColour(request.colour());
-		int colour = ColourUtil.convertStringToColour(request.colour());
+        Allowance allowance = new Allowance();
-		Allowance allowance = new Allowance();
+        allowance.setUserId(userId);
-		allowance.setUserId(userId);
+        allowance.setName(request.name());
-		allowance.setName(request.name());
+        allowance.setTarget(Math.round(request.target() * 100.0));
-		allowance.setTarget(Math.round(request.target() * 100.0));
+        allowance.setWeight(request.weight());
-		allowance.setWeight(request.weight());
+        allowance.setColour(colour);
-		allowance.setColour(colour);
+        allowance = allowanceRepository.save(allowance);
-		allowance = allowanceRepository.save(allowance);
+        return allowance.getId();
-		return allowance.getId();
+    }
-	}
 
-	@Transactional
+    @Transactional
-	public boolean deleteAllowance(int userId, int allowanceId)
+    public boolean deleteAllowance(int userId, int allowanceId) {
-	{
+        int count = allowanceRepository.countByIdAndUserId(allowanceId, userId);
-		int count = allowanceRepository.countByIdAndUserId(allowanceId, userId);
+        if (count == 0) {
-		if (count == 0)
+            return false;
-		{
+        }
-			return false;
+        allowanceRepository.deleteByIdAndUserId(allowanceId, userId);
-		}
+        return true;
-		allowanceRepository.deleteByIdAndUserId(allowanceId, userId);
+    }
-		return true;
-	}
 
-	@Transactional
+    @Transactional
-	public boolean updateAllowance(int userId, int allowanceId, UpdateAllowanceRequest request)
+    public boolean updateAllowance(int userId, int allowanceId, UpdateAllowanceRequest request) {
-	{
+        if (allowanceId == 0) {
-		if (allowanceId == 0)
+            User user = userRepository.findById(userId).orElseThrow();
-		{
+            user.setWeight(request.weight());
-			User user = userRepository.findById(userId).orElseThrow();
+            userRepository.save(user);
-			user.setWeight(request.weight());
+            return true;
-			userRepository.save(user);
+        }
-			return true;
-		}
 
-		Optional<Allowance> opt = allowanceRepository.findByIdAndUserId(allowanceId, userId);
+        Optional<Allowance> opt = allowanceRepository.findByIdAndUserId(allowanceId, userId);
-		if (opt.isEmpty())
+        if (opt.isEmpty()) {
-		{
+            return false;
-			return false;
+        }
-		}
 
-		int colour = ColourUtil.convertStringToColour(request.colour());
+        int colour = ColourUtil.convertStringToColour(request.colour());
-		Allowance allowance = opt.get();
+        Allowance allowance = opt.get();
-		allowance.setName(request.name());
+        allowance.setName(request.name());
-		allowance.setTarget(Math.round(request.target() * 100.0));
+        allowance.setTarget(Math.round(request.target() * 100.0));
-		allowance.setWeight(request.weight());
+        allowance.setWeight(request.weight());
-		allowance.setColour(colour);
+        allowance.setColour(colour);
-		allowanceRepository.save(allowance);
+        allowanceRepository.save(allowance);
-		return true;
+        return true;
-	}
+    }
 
-	@Transactional
+    @Transactional
-	public void bulkUpdateAllowance(int userId, List<BulkUpdateAllowanceRequest> requests)
+    public void bulkUpdateAllowance(int userId, List<BulkUpdateAllowanceRequest> requests) {
-	{
+        for (BulkUpdateAllowanceRequest req : requests) {
-		for (BulkUpdateAllowanceRequest req : requests)
+            if (req.id() == 0) {
-		{
+                User user = userRepository.findById(userId).orElseThrow();
-			if (req.id() == 0)
+                user.setWeight(req.weight());
-			{
+                userRepository.save(user);
-				User user = userRepository.findById(userId).orElseThrow();
+            } else {
-				user.setWeight(req.weight());
+                allowanceRepository.findByIdAndUserId(req.id(), userId).ifPresent(a ->
-				userRepository.save(user);
+                {
-			}
+                    a.setWeight(req.weight());
-			else
+                    allowanceRepository.save(a);
-			{
+                });
-				allowanceRepository.findByIdAndUserId(req.id(), userId).ifPresent(a ->
+            }
-				{
+        }
-					a.setWeight(req.weight());
+    }
-					allowanceRepository.save(a);
-				});
-			}
-		}
-	}
 
-	@Transactional
+    @Transactional
-	public boolean completeAllowance(int userId, int allowanceId)
+    public boolean completeAllowance(int userId, int allowanceId) {
-	{
+        Optional<Allowance> opt = allowanceRepository.findByIdAndUserId(allowanceId, userId);
-		Optional<Allowance> opt = allowanceRepository.findByIdAndUserId(allowanceId, userId);
+        if (opt.isEmpty()) {
-		if (opt.isEmpty())
+            return false;
-		{
+        }
-			return false;
-		}
 
-		Allowance allowance = opt.get();
+        Allowance allowance = opt.get();
-		long cost = allowance.getBalance();
+        long cost = allowance.getBalance();
-		String allowanceName = allowance.getName();
+        String allowanceName = allowance.getName();
 
-		// Delete the allowance
+        // Delete the allowance
-		allowanceRepository.delete(allowance);
+        allowanceRepository.delete(allowance);
 
-		// Add a history entry
+        // Add a history entry
-		History history = new History();
+        History history = new History();
-		history.setUserId(userId);
+        history.setUserId(userId);
-		history.setTimestamp(Instant.now().getEpochSecond());
+        history.setTimestamp(Instant.now().getEpochSecond());
-		history.setAmount(-cost);
+        history.setAmount(-cost);
-		history.setDescription("Allowance completed: " + allowanceName);
+        history.setDescription("Allowance completed: " + allowanceName);
-		historyRepository.save(history);
+        historyRepository.save(history);
 
-		return true;
+        return true;
-	}
+    }
 
-	@Transactional
+    @Transactional
-	public boolean addAllowanceAmount(int userId, int allowanceId, AddAllowanceAmountRequest request)
+    public boolean addAllowanceAmount(int userId, int allowanceId, AddAllowanceAmountRequest request) {
-	{
+        long remainingAmount = Math.round(request.amount() * 100);
-		long remainingAmount = Math.round(request.amount() * 100);
 
-		// Insert history entry
+        // Insert history entry
-		History history = new History();
+        History history = new History();
-		history.setUserId(userId);
+        history.setUserId(userId);
-		history.setTimestamp(Instant.now().getEpochSecond());
+        history.setTimestamp(Instant.now().getEpochSecond());
-		history.setAmount(remainingAmount);
+        history.setAmount(remainingAmount);
-		history.setDescription(request.description());
+        history.setDescription(request.description());
-		historyRepository.save(history);
+        historyRepository.save(history);
 
-		if (allowanceId == 0)
+        if (allowanceId == 0) {
-		{
+            if (remainingAmount < 0) {
-			if (remainingAmount < 0)
+                User user = userRepository.findById(userId).orElseThrow();
-			{
+                if (remainingAmount > user.getBalance()) {
-				User user = userRepository.findById(userId).orElseThrow();
+                    throw new IllegalArgumentException("cannot remove more than the current balance: " + user.getBalance());
-				if (remainingAmount > user.getBalance())
+                }
-				{
+            }
-					throw new IllegalArgumentException("cannot remove more than the current balance: " + user.getBalance());
+            User user = userRepository.findById(userId).orElseThrow();
-				}
+            user.setBalance(user.getBalance() + remainingAmount);
-			}
+            userRepository.save(user);
-			User user = userRepository.findById(userId).orElseThrow();
+        } else if (remainingAmount < 0) {
-			user.setBalance(user.getBalance() + remainingAmount);
+            Allowance allowance = allowanceRepository.findByIdAndUserId(allowanceId, userId).orElse(null);
-			userRepository.save(user);
+            if (allowance == null) {
-		}
+                return false;
-		else if (remainingAmount < 0)
+            }
-		{
+            if (remainingAmount > allowance.getBalance()) {
-			Allowance allowance = allowanceRepository.findByIdAndUserId(allowanceId, userId).orElse(null);
+                throw new IllegalArgumentException("cannot remove more than the current allowance balance: " + allowance.getBalance());
-			if (allowance == null)
+            }
-			{
+            allowance.setBalance(allowance.getBalance() + remainingAmount);
-				return false;
+            allowanceRepository.save(allowance);
-			}
+        } else {
-			if (remainingAmount > allowance.getBalance())
+            Allowance allowance = allowanceRepository.findByIdAndUserId(allowanceId, userId).orElse(null);
-			{
+            if (allowance == null) {
-				throw new IllegalArgumentException("cannot remove more than the current allowance balance: " + allowance.getBalance());
+                return false;
-			}
+            }
-			allowance.setBalance(allowance.getBalance() + remainingAmount);
-			allowanceRepository.save(allowance);
-		}
-		else
-		{
-			Allowance allowance = allowanceRepository.findByIdAndUserId(allowanceId, userId).orElse(null);
-			if (allowance == null)
-			{
-				return false;
-			}
 
-			long toAdd = remainingAmount;
+            long toAdd = remainingAmount;
-			if (allowance.getBalance() + toAdd > allowance.getTarget())
+            if (allowance.getBalance() + toAdd > allowance.getTarget()) {
-			{
+                toAdd = allowance.getTarget() - allowance.getBalance();
-				toAdd = allowance.getTarget() - allowance.getBalance();
+            }
-			}
+            remainingAmount -= toAdd;
-			remainingAmount -= toAdd;
 
-			if (toAdd > 0)
+            if (toAdd > 0) {
-			{
+                allowance.setBalance(allowance.getBalance() + toAdd);
-				allowance.setBalance(allowance.getBalance() + toAdd);
+                allowanceRepository.save(allowance);
-				allowanceRepository.save(allowance);
+            }
-			}
 
-			if (remainingAmount > 0)
+            if (remainingAmount > 0) {
-			{
+                addDistributedReward(userId, (int) remainingAmount);
-				addDistributedReward(userId, (int) remainingAmount);
+            }
-			}
+        }
-		}
+        return true;
-		return true;
+    }
-	}
 
-	public void addDistributedReward(int userId, int reward)
+    public void addDistributedReward(int userId, int reward) {
-	{
+        User user = userRepository.findById(userId).orElseThrow();
-		User user = userRepository.findById(userId).orElseThrow();
+        double userWeight = user.getWeight();
-		double userWeight = user.getWeight();
 
-		double sumOfWeights = allowanceRepository.sumPositiveWeights(userId) + userWeight;
+        double sumOfWeights = allowanceRepository.sumPositiveWeights(userId) + userWeight;
 
-		int remainingReward = reward;
+        int remainingReward = reward;
 
-		if (sumOfWeights > 0)
+        if (sumOfWeights > 0) {
-		{
+            List<Allowance> allowances = allowanceRepository.findByUserIdWithPositiveWeightOrderByRemainingAsc(userId);
-			List<Allowance> allowances = allowanceRepository.findByUserIdWithPositiveWeightOrderByRemainingAsc(userId);
+            for (Allowance allowance : allowances) {
-			for (Allowance allowance : allowances)
+                int amount = (int) ((allowance.getWeight() / sumOfWeights) * remainingReward);
-			{
+                if (allowance.getBalance() + amount > allowance.getTarget()) {
-				int amount = (int) ((allowance.getWeight() / sumOfWeights) * remainingReward);
+                    amount = (int) (allowance.getTarget() - allowance.getBalance());
-				if (allowance.getBalance() + amount > allowance.getTarget())
+                }
-				{
+                sumOfWeights -= allowance.getWeight();
-					amount = (int) (allowance.getTarget() - allowance.getBalance());
+                allowance.setBalance(allowance.getBalance() + amount);
-				}
+                allowanceRepository.save(allowance);
-				sumOfWeights -= allowance.getWeight();
+                remainingReward -= amount;
-				allowance.setBalance(allowance.getBalance() + amount);
+            }
-				allowanceRepository.save(allowance);
+        }
-				remainingReward -= amount;
-			}
-		}
 
-		// Add remaining to user's balance
+        // Add remaining to user's balance
-		user = userRepository.findById(userId).orElseThrow();
+        user = userRepository.findById(userId).orElseThrow();
-		user.setBalance(user.getBalance() + remainingReward);
+        user.setBalance(user.getBalance() + remainingReward);
-		userRepository.save(user);
+        userRepository.save(user);
-	}
+    }
 
-	public List<HistoryDto> getHistory(int userId)
+    public List<HistoryDto> getHistory(int userId) {
-	{
+        return historyRepository.findByUserIdOrderByIdDesc(userId).stream()
-		return historyRepository.findByUserIdOrderByIdDesc(userId).stream()
+                .map(h -> new HistoryDto(
-				.map(h -> new HistoryDto(
+                        h.getAmount() / 100.0,
-						h.getAmount() / 100.0,
+                        Instant.ofEpochSecond(h.getTimestamp()),
-						Instant.ofEpochSecond(h.getTimestamp()),
+                        h.getDescription()))
-						h.getDescription()))
+                .toList();
-				.toList();
+    }
-	}
 
-	@Transactional
+    @Transactional
-	public void addHistory(int userId, PostHistoryRequest request)
+    public void addHistory(int userId, PostHistoryRequest request) {
-	{
+        long amount = Math.round(request.allowance() * 100.0);
-		long amount = Math.round(request.allowance() * 100.0);
+        History history = new History();
-		History history = new History();
+        history.setUserId(userId);
-		history.setUserId(userId);
+        history.setTimestamp(Instant.now().getEpochSecond());
-		history.setTimestamp(Instant.now().getEpochSecond());
+        history.setAmount(amount);
-		history.setAmount(amount);
+        history.setDescription(request.description());
-		history.setDescription(request.description());
+        historyRepository.save(history);
-		historyRepository.save(history);
+    }
-	}
 
-	private AllowanceDto toDto(Allowance a)
+    private AllowanceDto toDto(Allowance a) {
-	{
+        return new AllowanceDto(
-		return new AllowanceDto(
+                a.getId(),
-				a.getId(),
+                a.getName(),
-				a.getName(),
+                a.getTarget() / 100.0,
-				a.getTarget() / 100.0,
+                a.getBalance() / 100.0,
-				a.getBalance() / 100.0,
+                a.getWeight(),
-				a.getWeight(),
+                ColourUtil.convertColourToString(a.getColour()));
-				ColourUtil.convertColourToString(a.getColour()));
+    }
-	}
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/MigrationService.java

@@ -10,95 +10,88 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 @Service
-public class MigrationService
+public class MigrationService {
-{
+    private final UserRepository userRepository;
-	private final UserRepository userRepository;
+    private final AllowanceRepository allowanceRepository;
-	private final AllowanceRepository allowanceRepository;
+    private final HistoryRepository historyRepository;
-	private final HistoryRepository historyRepository;
+    private final TaskRepository taskRepository;
-	private final TaskRepository taskRepository;
+    private final EntityManager entityManager;
-	private final EntityManager entityManager;
 
-	public MigrationService(UserRepository userRepository,
+    public MigrationService(UserRepository userRepository,
-			AllowanceRepository allowanceRepository,
+                            AllowanceRepository allowanceRepository,
-			HistoryRepository historyRepository,
+                            HistoryRepository historyRepository,
-			TaskRepository taskRepository,
+                            TaskRepository taskRepository,
-			EntityManager entityManager)
+                            EntityManager entityManager) {
-	{
+        this.userRepository = userRepository;
-		this.userRepository = userRepository;
+        this.allowanceRepository = allowanceRepository;
-		this.allowanceRepository = allowanceRepository;
+        this.historyRepository = historyRepository;
-		this.historyRepository = historyRepository;
+        this.taskRepository = taskRepository;
-		this.taskRepository = taskRepository;
+        this.entityManager = entityManager;
-		this.entityManager = entityManager;
+    }
-	}
 
-	@Transactional
+    @Transactional
-	public void importData(MigrationDto data)
+    public void importData(MigrationDto data) {
-	{
+        // Delete in dependency order
-		// Delete in dependency order
+        taskRepository.deleteAll();
-		taskRepository.deleteAll();
+        historyRepository.deleteAll();
-		historyRepository.deleteAll();
+        allowanceRepository.deleteAll();
-		allowanceRepository.deleteAll();
+        userRepository.deleteAll();
-		userRepository.deleteAll();
 
-		// Insert users with original IDs using native SQL to bypass auto-increment
+        // Insert users with original IDs using native SQL to bypass auto-increment
-		for (MigrationDto.MigrationUserDto u : data.users())
+        for (MigrationDto.MigrationUserDto u : data.users()) {
-		{
+            entityManager.createNativeQuery(
-			entityManager.createNativeQuery(
+                            "INSERT INTO users (id, name, balance, weight) VALUES (:id, :name, :balance, :weight)")
-							"INSERT INTO users (id, name, balance, weight) VALUES (:id, :name, :balance, :weight)")
+                    .setParameter("id", u.id())
-					.setParameter("id", u.id())
+                    .setParameter("name", u.name())
-					.setParameter("name", u.name())
+                    .setParameter("balance", u.balance())
-					.setParameter("balance", u.balance())
+                    .setParameter("weight", u.weight())
-					.setParameter("weight", u.weight())
+                    .executeUpdate();
-					.executeUpdate();
+        }
-		}
 
-		// Insert allowances with original IDs
+        // Insert allowances with original IDs
-		for (MigrationDto.MigrationAllowanceDto a : data.allowances())
+        for (MigrationDto.MigrationAllowanceDto a : data.allowances()) {
-		{
+            entityManager.createNativeQuery(
-			entityManager.createNativeQuery(
+                            "INSERT INTO allowances (id, user_id, name, target, balance, weight, colour) VALUES (:id, :userId, :name, :target, :balance, :weight, :colour)")
-							"INSERT INTO allowances (id, user_id, name, target, balance, weight, colour) VALUES (:id, :userId, :name, :target, :balance, :weight, :colour)")
+                    .setParameter("id", a.id())
-					.setParameter("id", a.id())
+                    .setParameter("userId", a.userId())
-					.setParameter("userId", a.userId())
+                    .setParameter("name", a.name())
-					.setParameter("name", a.name())
+                    .setParameter("target", a.target())
-					.setParameter("target", a.target())
+                    .setParameter("balance", a.balance())
-					.setParameter("balance", a.balance())
+                    .setParameter("weight", a.weight())
-					.setParameter("weight", a.weight())
+                    .setParameter("colour", a.colour())
-					.setParameter("colour", a.colour())
+                    .executeUpdate();
-					.executeUpdate();
+        }
-		}
 
-		// Insert history with original IDs
+        // Insert history with original IDs
-		for (MigrationDto.MigrationHistoryDto h : data.history())
+        for (MigrationDto.MigrationHistoryDto h : data.history()) {
-		{
+            entityManager.createNativeQuery(
-			entityManager.createNativeQuery(
+                            "INSERT INTO history (id, user_id, timestamp, amount, description) VALUES (:id, :userId, :timestamp, :amount, :description)")
-							"INSERT INTO history (id, user_id, timestamp, amount, description) VALUES (:id, :userId, :timestamp, :amount, :description)")
+                    .setParameter("id", h.id())
-					.setParameter("id", h.id())
+                    .setParameter("userId", h.userId())
-					.setParameter("userId", h.userId())
+                    .setParameter("timestamp", h.timestamp())
-					.setParameter("timestamp", h.timestamp())
+                    .setParameter("amount", h.amount())
-					.setParameter("amount", h.amount())
+                    .setParameter("description", h.description())
-					.setParameter("description", h.description())
+                    .executeUpdate();
-					.executeUpdate();
+        }
-		}
 
-		// Insert tasks with original IDs
+        // Insert tasks with original IDs
-		for (MigrationDto.MigrationTaskDto t : data.tasks())
+        for (MigrationDto.MigrationTaskDto t : data.tasks()) {
-		{
+            entityManager.createNativeQuery(
-			entityManager.createNativeQuery(
+                            "INSERT INTO tasks (id, name, reward, assigned, schedule, completed, next_run) VALUES (:id, :name, :reward, :assigned, :schedule, :completed, :nextRun)")
-							"INSERT INTO tasks (id, name, reward, assigned, schedule, completed, next_run) VALUES (:id, :name, :reward, :assigned, :schedule, :completed, :nextRun)")
+                    .setParameter("id", t.id())
-					.setParameter("id", t.id())
+                    .setParameter("name", t.name())
-					.setParameter("name", t.name())
+                    .setParameter("reward", t.reward())
-					.setParameter("reward", t.reward())
+                    .setParameter("assigned", t.assigned())
-					.setParameter("assigned", t.assigned())
+                    .setParameter("schedule", t.schedule())
-					.setParameter("schedule", t.schedule())
+                    .setParameter("completed", t.completed())
-					.setParameter("completed", t.completed())
+                    .setParameter("nextRun", t.nextRun())
-					.setParameter("nextRun", t.nextRun())
+                    .executeUpdate();
-					.executeUpdate();
+        }
-		}
 
-		// Reset sequences so new inserts don't collide with migrated IDs
+        // Reset sequences so new inserts don't collide with migrated IDs
-		entityManager.createNativeQuery("SELECT setval('users_id_seq', COALESCE((SELECT MAX(id) FROM users), 0))").getSingleResult();
+        entityManager.createNativeQuery("SELECT setval('users_id_seq', COALESCE((SELECT MAX(id) FROM users), 0))").getSingleResult();
-		entityManager.createNativeQuery("SELECT setval('allowances_id_seq', COALESCE((SELECT MAX(id) FROM allowances), 0))").getSingleResult();
+        entityManager.createNativeQuery("SELECT setval('allowances_id_seq', COALESCE((SELECT MAX(id) FROM allowances), 0))").getSingleResult();
-		entityManager.createNativeQuery("SELECT setval('history_id_seq', COALESCE((SELECT MAX(id) FROM history), 0))").getSingleResult();
+        entityManager.createNativeQuery("SELECT setval('history_id_seq', COALESCE((SELECT MAX(id) FROM history), 0))").getSingleResult();
-		entityManager.createNativeQuery("SELECT setval('tasks_id_seq', COALESCE((SELECT MAX(id) FROM tasks), 0))").getSingleResult();
+        entityManager.createNativeQuery("SELECT setval('tasks_id_seq', COALESCE((SELECT MAX(id) FROM tasks), 0))").getSingleResult();
-	}
+    }
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/TaskService.java

@@ -1,6 +1,7 @@
 package be.seeseepuff.allowanceplanner.service;
 
-import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.dto.CreateTaskRequest;
+import be.seeseepuff.allowanceplanner.dto.TaskDto;
 import be.seeseepuff.allowanceplanner.entity.History;
 import be.seeseepuff.allowanceplanner.entity.Task;
 import be.seeseepuff.allowanceplanner.entity.User;
@@ -15,118 +16,105 @@ import java.util.List;
 import java.util.Optional;
 
 @Service
-public class TaskService
+public class TaskService {
-{
+    private final TaskRepository taskRepository;
-	private final TaskRepository taskRepository;
+    private final UserRepository userRepository;
-	private final UserRepository userRepository;
+    private final HistoryRepository historyRepository;
-	private final HistoryRepository historyRepository;
+    private final AllowanceService allowanceService;
-	private final AllowanceService allowanceService;
 
-	public TaskService(TaskRepository taskRepository,
+    public TaskService(TaskRepository taskRepository,
-			UserRepository userRepository,
+                       UserRepository userRepository,
-			HistoryRepository historyRepository,
+                       HistoryRepository historyRepository,
-			AllowanceService allowanceService)
+                       AllowanceService allowanceService) {
-	{
+        this.taskRepository = taskRepository;
-		this.taskRepository = taskRepository;
+        this.userRepository = userRepository;
-		this.userRepository = userRepository;
+        this.historyRepository = historyRepository;
-		this.historyRepository = historyRepository;
+        this.allowanceService = allowanceService;
-		this.allowanceService = allowanceService;
+    }
-	}
 
-	@Transactional
+    @Transactional
-	public int createTask(CreateTaskRequest request)
+    public int createTask(CreateTaskRequest request) {
-	{
+        Task task = new Task();
-		Task task = new Task();
+        task.setName(request.name());
-		task.setName(request.name());
+        task.setReward(Math.round((request.reward() != null ? request.reward() : 0.0) * 100.0));
-		task.setReward(Math.round((request.reward() != null ? request.reward() : 0.0) * 100.0));
+        task.setAssigned(request.assigned());
-		task.setAssigned(request.assigned());
+        task = taskRepository.save(task);
-		task = taskRepository.save(task);
+        return task.getId();
-		return task.getId();
+    }
-	}
 
-	public List<TaskDto> getTasks()
+    public List<TaskDto> getTasks() {
-	{
+        return taskRepository.findByCompletedIsNull().stream()
-		return taskRepository.findByCompletedIsNull().stream()
+                .map(this::toDto)
-				.map(this::toDto)
+                .toList();
-				.toList();
+    }
-	}
 
-	public Optional<TaskDto> getTask(int taskId)
+    public Optional<TaskDto> getTask(int taskId) {
-	{
+        return taskRepository.findByIdAndCompletedIsNull(taskId)
-		return taskRepository.findByIdAndCompletedIsNull(taskId)
+                .map(this::toDto);
-				.map(this::toDto);
+    }
-	}
 
-	@Transactional
+    @Transactional
-	public boolean updateTask(int taskId, CreateTaskRequest request)
+    public boolean updateTask(int taskId, CreateTaskRequest request) {
-	{
+        Optional<Task> opt = taskRepository.findByIdAndCompletedIsNull(taskId);
-		Optional<Task> opt = taskRepository.findByIdAndCompletedIsNull(taskId);
+        if (opt.isEmpty()) {
-		if (opt.isEmpty())
+            return false;
-		{
+        }
-			return false;
+        Task task = opt.get();
-		}
+        task.setName(request.name());
-		Task task = opt.get();
+        task.setReward(Math.round((request.reward() != null ? request.reward() : 0.0) * 100.0));
-		task.setName(request.name());
+        task.setAssigned(request.assigned());
-		task.setReward(Math.round((request.reward() != null ? request.reward() : 0.0) * 100.0));
+        taskRepository.save(task);
-		task.setAssigned(request.assigned());
+        return true;
-		taskRepository.save(task);
+    }
-		return true;
-	}
 
-	public boolean hasTask(int taskId)
+    public boolean hasTask(int taskId) {
-	{
+        return taskRepository.existsById(taskId);
-		return taskRepository.existsById(taskId);
+    }
-	}
 
-	@Transactional
+    @Transactional
-	public void deleteTask(int taskId)
+    public void deleteTask(int taskId) {
-	{
+        taskRepository.deleteById(taskId);
-		taskRepository.deleteById(taskId);
+    }
-	}
 
-	@Transactional
+    @Transactional
-	public boolean completeTask(int taskId)
+    public boolean completeTask(int taskId) {
-	{
+        Optional<Task> opt = taskRepository.findById(taskId);
-		Optional<Task> opt = taskRepository.findById(taskId);
+        if (opt.isEmpty()) {
-		if (opt.isEmpty())
+            return false;
-		{
+        }
-			return false;
-		}
 
-		Task task = opt.get();
+        Task task = opt.get();
-		long reward = task.getReward();
+        long reward = task.getReward();
-		String rewardName = task.getName();
+        String rewardName = task.getName();
 
-		// Give reward to all users
+        // Give reward to all users
-		List<User> users = userRepository.findAll();
+        List<User> users = userRepository.findAll();
-		for (User user : users)
+        for (User user : users) {
-		{
+            // Add history entry
-			// Add history entry
+            History history = new History();
-			History history = new History();
+            history.setUserId(user.getId());
-			history.setUserId(user.getId());
+            history.setTimestamp(Instant.now().getEpochSecond());
-			history.setTimestamp(Instant.now().getEpochSecond());
+            history.setAmount(reward);
-			history.setAmount(reward);
+            history.setDescription("Task completed: " + rewardName);
-			history.setDescription("Task completed: " + rewardName);
+            historyRepository.save(history);
-			historyRepository.save(history);
 
-			// Distribute reward
+            // Distribute reward
-			allowanceService.addDistributedReward(user.getId(), (int) reward);
+            allowanceService.addDistributedReward(user.getId(), (int) reward);
-		}
+        }
 
-		// Mark task as completed
+        // Mark task as completed
-		task.setCompleted(Instant.now().getEpochSecond());
+        task.setCompleted(Instant.now().getEpochSecond());
-		taskRepository.save(task);
+        taskRepository.save(task);
 
-		return true;
+        return true;
-	}
+    }
 
-	private TaskDto toDto(Task t)
+    private TaskDto toDto(Task t) {
-	{
+        return new TaskDto(
-		return new TaskDto(
+                t.getId(),
-				t.getId(),
+                t.getName(),
-				t.getName(),
+                t.getReward() / 100.0,
-				t.getReward() / 100.0,
+                t.getAssigned(),
-				t.getAssigned(),
+                t.getSchedule());
-				t.getSchedule());
+    }
-	}
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/TransferService.java

@@ -9,94 +9,78 @@ import org.springframework.transaction.annotation.Transactional;
 import java.util.Optional;
 
 @Service
-public class TransferService
+public class TransferService {
-{
+    private final AllowanceRepository allowanceRepository;
-	private final AllowanceRepository allowanceRepository;
 
-	public TransferService(AllowanceRepository allowanceRepository)
+    public TransferService(AllowanceRepository allowanceRepository) {
-	{
+        this.allowanceRepository = allowanceRepository;
-		this.allowanceRepository = allowanceRepository;
+    }
-	}
 
-	@Transactional
+    @Transactional
-	public TransferResult transfer(TransferRequest request)
+    public TransferResult transfer(TransferRequest request) {
-	{
+        if (request.from() == request.to()) {
-		if (request.from() == request.to())
+            return TransferResult.success();
-		{
+        }
-			return TransferResult.success();
-		}
 
-		int amountCents = (int) Math.round(request.amount() * 100.0);
+        int amountCents = (int) Math.round(request.amount() * 100.0);
-		if (amountCents <= 0)
+        if (amountCents <= 0) {
-		{
+            return TransferResult.badRequest("amount must be positive");
-			return TransferResult.badRequest("amount must be positive");
+        }
-		}
 
-		Optional<Allowance> fromOpt = allowanceRepository.findById(request.from());
+        Optional<Allowance> fromOpt = allowanceRepository.findById(request.from());
-		if (fromOpt.isEmpty())
+        if (fromOpt.isEmpty()) {
-		{
+            return TransferResult.notFound();
-			return TransferResult.notFound();
+        }
-		}
 
-		Optional<Allowance> toOpt = allowanceRepository.findById(request.to());
+        Optional<Allowance> toOpt = allowanceRepository.findById(request.to());
-		if (toOpt.isEmpty())
+        if (toOpt.isEmpty()) {
-		{
+            return TransferResult.notFound();
-			return TransferResult.notFound();
+        }
-		}
 
-		Allowance from = fromOpt.get();
+        Allowance from = fromOpt.get();
-		Allowance to = toOpt.get();
+        Allowance to = toOpt.get();
 
-		if (from.getUserId() != to.getUserId())
+        if (from.getUserId() != to.getUserId()) {
-		{
+            return TransferResult.badRequest("Allowances do not belong to the same user");
-			return TransferResult.badRequest("Allowances do not belong to the same user");
+        }
-		}
 
-		long remainingTo = to.getTarget() - to.getBalance();
+        long remainingTo = to.getTarget() - to.getBalance();
-		if (remainingTo <= 0)
+        if (remainingTo <= 0) {
-		{
+            return TransferResult.badRequest("target already reached");
-			return TransferResult.badRequest("target already reached");
+        }
-		}
 
-		int transfer = amountCents;
+        int transfer = amountCents;
-		if (transfer > remainingTo)
+        if (transfer > remainingTo) {
-		{
+            transfer = (int) remainingTo;
-			transfer = (int) remainingTo;
+        }
-		}
 
-		if (from.getBalance() < transfer)
+        if (from.getBalance() < transfer) {
-		{
+            return TransferResult.badRequest("Insufficient funds in source allowance");
-			return TransferResult.badRequest("Insufficient funds in source allowance");
+        }
-		}
 
-		from.setBalance(from.getBalance() - transfer);
+        from.setBalance(from.getBalance() - transfer);
-		to.setBalance(to.getBalance() + transfer);
+        to.setBalance(to.getBalance() + transfer);
-		allowanceRepository.save(from);
+        allowanceRepository.save(from);
-		allowanceRepository.save(to);
+        allowanceRepository.save(to);
 
-		return TransferResult.success();
+        return TransferResult.success();
-	}
+    }
 
-	public record TransferResult(Status status, String message)
+    public record TransferResult(Status status, String message) {
-	{
+        public static TransferResult success() {
-		public enum Status
+            return new TransferResult(Status.SUCCESS, "Transfer successful");
-		{
+        }
-			SUCCESS, BAD_REQUEST, NOT_FOUND
-		}
 
-		public static TransferResult success()
+        public static TransferResult badRequest(String message) {
-		{
+            return new TransferResult(Status.BAD_REQUEST, message);
-			return new TransferResult(Status.SUCCESS, "Transfer successful");
+        }
-		}
 
-		public static TransferResult badRequest(String message)
+        public static TransferResult notFound() {
-		{
+            return new TransferResult(Status.NOT_FOUND, "Allowance not found");
-			return new TransferResult(Status.BAD_REQUEST, message);
+        }
-		}
 
-		public static TransferResult notFound()
+        public enum Status {
-		{
+            SUCCESS, BAD_REQUEST, NOT_FOUND
-			return new TransferResult(Status.NOT_FOUND, "Allowance not found");
+        }
-		}
+    }
-	}
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/UserService.java

@@ -1,7 +1,7 @@
 package be.seeseepuff.allowanceplanner.service;
 
-import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.dto.UserDto;
-import be.seeseepuff.allowanceplanner.entity.User;
+import be.seeseepuff.allowanceplanner.dto.UserWithAllowanceDto;
 import be.seeseepuff.allowanceplanner.repository.UserRepository;
 import org.springframework.stereotype.Service;
 
@@ -9,34 +9,29 @@ import java.util.List;
 import java.util.Optional;
 
 @Service
-public class UserService
+public class UserService {
-{
+    private final UserRepository userRepository;
-	private final UserRepository userRepository;
 
-	public UserService(UserRepository userRepository)
+    public UserService(UserRepository userRepository) {
-	{
+        this.userRepository = userRepository;
-		this.userRepository = userRepository;
+    }
-	}
 
-	public List<UserDto> getUsers()
+    public List<UserDto> getUsers() {
-	{
+        return userRepository.findAll().stream()
-		return userRepository.findAll().stream()
+                .map(u -> new UserDto(u.getId(), u.getName()))
-				.map(u -> new UserDto(u.getId(), u.getName()))
+                .toList();
-				.toList();
+    }
-	}
 
-	public Optional<UserWithAllowanceDto> getUser(int userId)
+    public Optional<UserWithAllowanceDto> getUser(int userId) {
-	{
+        return userRepository.findById(userId)
-		return userRepository.findById(userId)
+                .map(u ->
-				.map(u ->
+                {
-				{
+                    long totalAmount = userRepository.sumHistoryAmount(userId);
-					long totalAmount = userRepository.sumHistoryAmount(userId);
+                    return new UserWithAllowanceDto(u.getId(), u.getName(), totalAmount / 100.0);
-					return new UserWithAllowanceDto(u.getId(), u.getName(), totalAmount / 100.0);
+                });
-				});
+    }
-	}
 
-	public boolean userExists(int userId)
+    public boolean userExists(int userId) {
-	{
+        return userRepository.existsById(userId);
-		return userRepository.existsById(userId);
+    }
-	}
 }

backend-spring/src/main/java/be/seeseepuff/allowanceplanner/util/ColourUtil.java

@@ -1,42 +1,33 @@
 package be.seeseepuff.allowanceplanner.util;
 
-public class ColourUtil
+public class ColourUtil {
-{
+    private ColourUtil() {
-	private ColourUtil()
+    }
-	{
-	}
 
-	public static int convertStringToColour(String colourStr)
+    public static int convertStringToColour(String colourStr) {
-	{
+        if (colourStr == null || colourStr.isEmpty()) {
-		if (colourStr == null || colourStr.isEmpty())
+            return 0xFF0000; // Default colour
-		{
+        }
-			return 0xFF0000; // Default colour
+        if (colourStr.charAt(0) == '#') {
-		}
+            colourStr = colourStr.substring(1);
-		if (colourStr.charAt(0) == '#')
+        }
-		{
+        if (colourStr.length() != 6 && colourStr.length() != 3) {
-			colourStr = colourStr.substring(1);
+            throw new IllegalArgumentException("colour must be a valid hex string");
-		}
+        }
-		if (colourStr.length() != 6 && colourStr.length() != 3)
+        int colour = Integer.parseInt(colourStr, 16);
-		{
+        if (colourStr.length() == 3) {
-			throw new IllegalArgumentException("colour must be a valid hex string");
+            int r = (colour & 0xF00) >> 8;
-		}
+            int g = (colour & 0x0F0) >> 4;
-		int colour = Integer.parseInt(colourStr, 16);
+            int b = (colour & 0x00F);
-		if (colourStr.length() == 3)
+            colour = (r << 20) | (g << 12) | (b << 4);
-		{
+        }
-			int r = (colour & 0xF00) >> 8;
+        return colour;
-			int g = (colour & 0x0F0) >> 4;
+    }
-			int b = (colour & 0x00F);
-			colour = (r << 20) | (g << 12) | (b << 4);
-		}
-		return colour;
-	}
 
-	public static String convertColourToString(Integer colour)
+    public static String convertColourToString(Integer colour) {
-	{
+        if (colour == null) {
-		if (colour == null)
+            return "";
-		{
+        }
-			return "";
+        return String.format("#%06X", colour);
-		}
+    }
-		return String.format("#%06X", colour);
-	}
 }

backend-spring/src/main/resources/application.properties

@@ -1,12 +1,8 @@
 spring.application.name=allowance-planner
-
 spring.datasource.url=jdbc:postgresql://localhost:5432/allowance_planner
 spring.datasource.username=postgres
 spring.datasource.password=postgres
-
 spring.jpa.hibernate.ddl-auto=validate
 spring.jpa.open-in-view=false
-
 spring.flyway.enabled=true
-
 server.port=8080

backend-spring/src/main/resources/templates/index.html

@@ -20,8 +20,8 @@
     <h2>Users</h2>
     <span th:each="user : ${users}">
         <strong th:if="${currentUser != null and currentUser == user.id()}" th:text="${user.name()}"></strong>
-        <a th:unless="${currentUser != null and currentUser == user.id()}"
+        <a th:href="@{/login(user=${user.id()})}"
-           th:href="@{/login(user=${user.id()})}" th:text="${user.name()}"></a>
+           th:text="${user.name()}" th:unless="${currentUser != null and currentUser == user.id()}"></a>
     </span>
 
     <div th:if="${currentUser != null and currentUser > 0}">
@@ -39,10 +39,10 @@
                 </thead>
                 <tbody>
                 <tr>
-                    <td><label><input type="text" name="name" placeholder="Name"/></label></td>
+                    <td><label><input name="name" placeholder="Name" type="text"/></label></td>
                     <td></td>
-                    <td><label><input type="number" name="target" placeholder="Target"/></label></td>
+                    <td><label><input name="target" placeholder="Target" type="number"/></label></td>
-                    <td><label><input type="number" name="weight" placeholder="Weight"/></label></td>
+                    <td><label><input name="weight" placeholder="Weight" type="number"/></label></td>
                     <td><input type="submit" value="Create"/></td>
                 </tr>
                 <tr th:each="allowance : ${allowances}">
@@ -66,7 +66,7 @@
         </form>
 
         <h2>Tasks</h2>
-        <form method="post" action="/createTask">
+        <form action="/createTask" method="post">
             <table border="1">
                 <thead>
                 <tr>
@@ -91,10 +91,10 @@
                     </td>
                 </tr>
                 <tr>
-                    <td><label><input type="text" name="name" placeholder="Name"/></label></td>
+                    <td><label><input name="name" placeholder="Name" type="text"/></label></td>
                     <td></td>
-                    <td><label><input type="number" name="reward" placeholder="Reward"/></label></td>
+                    <td><label><input name="reward" placeholder="Reward" type="number"/></label></td>
-                    <td><label><input type="text" name="schedule" placeholder="Schedule"/></label></td>
+                    <td><label><input name="schedule" placeholder="Schedule" type="text"/></label></td>
                     <td><input type="submit" value="Create"/></td>
                 </tr>
                 </tbody>

backend-spring/src/test/java/be/seeseepuff/allowanceplanner/ColourUtilTest.java

@@ -5,29 +5,24 @@ import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-class ColourUtilTest
+class ColourUtilTest {
-{
+    @Test
-	@Test
+    void convertStringToColourWithSign() {
-	void convertStringToColourWithSign()
+        assertEquals(0x123456, ColourUtil.convertStringToColour("#123456"));
-	{
+    }
-		assertEquals(0x123456, ColourUtil.convertStringToColour("#123456"));
-	}
 
-	@Test
+    @Test
-	void convertStringToColourWithoutSign()
+    void convertStringToColourWithoutSign() {
-	{
+        assertEquals(0x123456, ColourUtil.convertStringToColour("123456"));
-		assertEquals(0x123456, ColourUtil.convertStringToColour("123456"));
+    }
-	}
 
-	@Test
+    @Test
-	void convertStringToColourWithSignThreeDigits()
+    void convertStringToColourWithSignThreeDigits() {
-	{
+        assertEquals(0xA0B0C0, ColourUtil.convertStringToColour("#ABC"));
-		assertEquals(0xA0B0C0, ColourUtil.convertStringToColour("#ABC"));
+    }
-	}
 
-	@Test
+    @Test
-	void convertStringToColourWithoutSignThreeDigits()
+    void convertStringToColourWithoutSignThreeDigits() {
-	{
+        assertEquals(0xA0B0C0, ColourUtil.convertStringToColour("ABC"));
-		assertEquals(0xA0B0C0, ColourUtil.convertStringToColour("ABC"));
+    }
-	}
 }