Add spring backend

2026-03-01 13:22:26 +01:00
parent ccc8d5e8e7
commit 29284f6eac
44 changed files with 3652 additions and 0 deletions
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/AllowancePlannerApplication.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/AllowancePlannerApplication.java
@@ -0,0 +1,13 @@
+package be.seeseepuff.allowanceplanner;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class AllowancePlannerApplication
+{
+	public static void main(String[] args)
+	{
+		SpringApplication.run(AllowancePlannerApplication.class, args);
+	}
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/ApiController.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/ApiController.java
@@ -0,0 +1,506 @@
+package be.seeseepuff.allowanceplanner.controller;
+
+import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.service.AllowanceService;
+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;
+
+	public ApiController(UserService userService,
+			AllowanceService allowanceService,
+			TaskService taskService,
+			TransferService transferService)
+	{
+		this.userService = userService;
+		this.allowanceService = allowanceService;
+		this.taskService = taskService;
+		this.transferService = transferService;
+	}
+
+	// ---- 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()));
+		};
+	}
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/WebController.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/controller/WebController.java
@@ -0,0 +1,173 @@
+package be.seeseepuff.allowanceplanner.controller;
+
+import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.service.AllowanceService;
+import be.seeseepuff.allowanceplanner.service.TaskService;
+import be.seeseepuff.allowanceplanner.service.UserService;
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+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
+{
+	private final UserService userService;
+	private final AllowanceService allowanceService;
+	private final TaskService taskService;
+
+	public WebController(UserService userService, AllowanceService allowanceService, TaskService taskService)
+	{
+		this.userService = userService;
+		this.allowanceService = allowanceService;
+		this.taskService = taskService;
+	}
+
+	@GetMapping("/")
+	public String index(HttpServletRequest request, HttpServletResponse response, Model model)
+	{
+		Integer currentUser = getCurrentUser(request, response);
+		if (currentUser == null)
+		{
+			model.addAttribute("users", userService.getUsers());
+			return "index";
+		}
+		return renderWithUser(model, currentUser);
+	}
+
+	@GetMapping("/login")
+	public String login(@RequestParam(required = false) String user, HttpServletResponse response)
+	{
+		if (user != null && !user.isEmpty())
+		{
+			Cookie cookie = new Cookie("user", user);
+			cookie.setMaxAge(3600);
+			cookie.setHttpOnly(true);
+			response.addCookie(cookie);
+		}
+		return "redirect:/";
+	}
+
+	@PostMapping("/createTask")
+	public String createTask(@RequestParam String name, @RequestParam double reward,
+			@RequestParam(required = false) String schedule,
+			HttpServletRequest request, HttpServletResponse response, Model model)
+	{
+		Integer currentUser = getCurrentUser(request, response);
+		if (currentUser == null)
+		{
+			return "redirect:/";
+		}
+
+		if (name.isEmpty() || reward <= 0)
+		{
+			model.addAttribute("error", "Invalid input");
+			return "index";
+		}
+
+		CreateTaskRequest taskRequest = new CreateTaskRequest(name, reward, null,
+				(schedule != null && !schedule.isEmpty()) ? schedule : null);
+		taskService.createTask(taskRequest);
+		return "redirect:/";
+	}
+
+	@GetMapping("/completeTask")
+	public String completeTask(@RequestParam("task") int taskId)
+	{
+		taskService.completeTask(taskId);
+		return "redirect:/";
+	}
+
+	@PostMapping("/createAllowance")
+	public String createAllowance(@RequestParam String name, @RequestParam double target,
+			@RequestParam double weight,
+			HttpServletRequest request, HttpServletResponse response, Model model)
+	{
+		Integer currentUser = getCurrentUser(request, response);
+		if (currentUser == null)
+		{
+			return "redirect:/";
+		}
+
+		if (name.isEmpty() || target <= 0 || weight <= 0)
+		{
+			model.addAttribute("error", "Invalid input");
+			return "index";
+		}
+
+		allowanceService.createAllowance(currentUser, new CreateAllowanceRequest(name, target, weight, ""));
+		return "redirect:/";
+	}
+
+	@GetMapping("/completeAllowance")
+	public String completeAllowance(@RequestParam("allowance") int allowanceId,
+			HttpServletRequest request, HttpServletResponse response)
+	{
+		Integer currentUser = getCurrentUser(request, response);
+		if (currentUser == null)
+		{
+			return "redirect:/";
+		}
+		allowanceService.completeAllowance(currentUser, allowanceId);
+		return "redirect:/";
+	}
+
+	private Integer getCurrentUser(HttpServletRequest request, HttpServletResponse response)
+	{
+		Cookie[] cookies = request.getCookies();
+		if (cookies == null)
+		{
+			return null;
+		}
+		String userStr = Arrays.stream(cookies)
+				.filter(c -> "user".equals(c.getName()))
+				.map(Cookie::getValue)
+				.findFirst()
+				.orElse(null);
+		if (userStr == null)
+		{
+			return null;
+		}
+		try
+		{
+			int userId = Integer.parseInt(userStr);
+			if (!userService.userExists(userId))
+			{
+				unsetUserCookie(response);
+				return null;
+			}
+			return userId;
+		}
+		catch (NumberFormatException e)
+		{
+			unsetUserCookie(response);
+			return null;
+		}
+	}
+
+	private void unsetUserCookie(HttpServletResponse response)
+	{
+		Cookie cookie = new Cookie("user", "");
+		cookie.setMaxAge(0);
+		cookie.setPath("/");
+		cookie.setHttpOnly(true);
+		response.addCookie(cookie);
+	}
+
+	private String renderWithUser(Model model, int currentUser)
+	{
+		model.addAttribute("users", userService.getUsers());
+		model.addAttribute("currentUser", currentUser);
+		model.addAttribute("allowances", allowanceService.getUserAllowances(currentUser));
+		model.addAttribute("tasks", taskService.getTasks());
+		model.addAttribute("history", allowanceService.getHistory(currentUser));
+		return "index";
+	}
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/AddAllowanceAmountRequest.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/AddAllowanceAmountRequest.java
@@ -0,0 +1,5 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record AddAllowanceAmountRequest(double amount, String description)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/AllowanceDto.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/AllowanceDto.java
@@ -0,0 +1,8 @@
+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)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/BulkUpdateAllowanceRequest.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/BulkUpdateAllowanceRequest.java
@@ -0,0 +1,5 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record BulkUpdateAllowanceRequest(int id, double weight)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/CreateAllowanceRequest.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/CreateAllowanceRequest.java
@@ -0,0 +1,5 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record CreateAllowanceRequest(String name, double target, double weight, String colour)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/CreateTaskRequest.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/CreateTaskRequest.java
@@ -0,0 +1,11 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+public record CreateTaskRequest(
+		String name,
+		Double reward,
+		Integer assigned,
+		String schedule)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/ErrorResponse.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/ErrorResponse.java
@@ -0,0 +1,5 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record ErrorResponse(String error)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/HistoryDto.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/HistoryDto.java
@@ -0,0 +1,7 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+import java.time.Instant;
+
+public record HistoryDto(double allowance, Instant timestamp, String description)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/IdResponse.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/IdResponse.java
@@ -0,0 +1,5 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record IdResponse(int id)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/MessageResponse.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/MessageResponse.java
@@ -0,0 +1,5 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record MessageResponse(String message)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/PostHistoryRequest.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/PostHistoryRequest.java
@@ -0,0 +1,5 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record PostHistoryRequest(double allowance, String description)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/TaskDto.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/TaskDto.java
@@ -0,0 +1,8 @@
+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)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/TransferRequest.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/TransferRequest.java
@@ -0,0 +1,5 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record TransferRequest(int from, int to, double amount)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/UpdateAllowanceRequest.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/UpdateAllowanceRequest.java
@@ -0,0 +1,5 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record UpdateAllowanceRequest(String name, double target, double weight, String colour)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/UserDto.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/UserDto.java
@@ -0,0 +1,5 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record UserDto(int id, String name)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/UserWithAllowanceDto.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/dto/UserWithAllowanceDto.java
@@ -0,0 +1,5 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record UserWithAllowanceDto(int id, String name, double allowance)
+{
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/Allowance.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/Allowance.java
@@ -0,0 +1,99 @@
+package be.seeseepuff.allowanceplanner.entity;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "allowances")
+public class Allowance
+{
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private int id;
+
+	@Column(name = "user_id", nullable = false)
+	private int userId;
+
+	@Column(nullable = false)
+	private String name;
+
+	@Column(nullable = false)
+	private long target;
+
+	@Column(nullable = false)
+	private long balance = 0;
+
+	@Column(nullable = false)
+	private double weight;
+
+	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;
+	}
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/History.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/History.java
@@ -0,0 +1,73 @@
+package be.seeseepuff.allowanceplanner.entity;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "history")
+public class History
+{
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private int id;
+
+	@Column(name = "user_id", nullable = false)
+	private int userId;
+
+	@Column(nullable = false)
+	private long timestamp;
+
+	@Column(nullable = false)
+	private long amount;
+
+	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;
+	}
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/Task.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/Task.java
@@ -0,0 +1,97 @@
+package be.seeseepuff.allowanceplanner.entity;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "tasks")
+public class Task
+{
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private int id;
+
+	@Column(nullable = false)
+	private String name;
+
+	@Column(nullable = false)
+	private long reward;
+
+	private Integer assigned;
+
+	private String schedule;
+
+	private Long completed;
+
+	@Column(name = "next_run")
+	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;
+	}
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/User.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/entity/User.java
@@ -0,0 +1,61 @@
+package be.seeseepuff.allowanceplanner.entity;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "users")
+public class User
+{
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private int id;
+
+	@Column(nullable = false)
+	private String name;
+
+	@Column(nullable = false)
+	private double weight = 10.0;
+
+	@Column(nullable = false)
+	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;
+	}
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/AllowanceRepository.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/AllowanceRepository.java
@@ -0,0 +1,27 @@
+package be.seeseepuff.allowanceplanner.repository;
+
+import be.seeseepuff.allowanceplanner.entity.Allowance;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface AllowanceRepository extends JpaRepository<Allowance, Integer>
+{
+	List<Allowance> findByUserIdOrderByIdAsc(int userId);
+
+	Optional<Allowance> findByIdAndUserId(int id, int userId);
+
+	int countByIdAndUserId(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")
+	List<Allowance> findByUserIdWithPositiveWeightOrderByRemainingAsc(int userId);
+
+	@Query("SELECT COALESCE(SUM(a.weight), 0) FROM Allowance a WHERE a.userId = :userId AND a.weight > 0")
+	double sumPositiveWeights(int userId);
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/HistoryRepository.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/HistoryRepository.java
@@ -0,0 +1,13 @@
+package be.seeseepuff.allowanceplanner.repository;
+
+import be.seeseepuff.allowanceplanner.entity.History;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface HistoryRepository extends JpaRepository<History, Integer>
+{
+	List<History> findByUserIdOrderByIdDesc(int userId);
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/TaskRepository.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/TaskRepository.java
@@ -0,0 +1,16 @@
+package be.seeseepuff.allowanceplanner.repository;
+
+import be.seeseepuff.allowanceplanner.entity.Task;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface TaskRepository extends JpaRepository<Task, Integer>
+{
+	List<Task> findByCompletedIsNull();
+
+	Optional<Task> findByIdAndCompletedIsNull(int id);
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/UserRepository.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/repository/UserRepository.java
@@ -0,0 +1,13 @@
+package be.seeseepuff.allowanceplanner.repository;
+
+import be.seeseepuff.allowanceplanner.entity.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, Integer>
+{
+	@Query("SELECT COALESCE(SUM(h.amount), 0) FROM History h WHERE h.userId = :userId")
+	long sumHistoryAmount(int userId);
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/AllowanceService.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/AllowanceService.java
@@ -0,0 +1,298 @@
+package be.seeseepuff.allowanceplanner.service;
+
+import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.entity.Allowance;
+import be.seeseepuff.allowanceplanner.entity.History;
+import be.seeseepuff.allowanceplanner.entity.User;
+import be.seeseepuff.allowanceplanner.repository.AllowanceRepository;
+import be.seeseepuff.allowanceplanner.repository.HistoryRepository;
+import be.seeseepuff.allowanceplanner.repository.UserRepository;
+import be.seeseepuff.allowanceplanner.util.ColourUtil;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class AllowanceService
+{
+	private final AllowanceRepository allowanceRepository;
+	private final UserRepository userRepository;
+	private final HistoryRepository historyRepository;
+
+	public AllowanceService(AllowanceRepository allowanceRepository,
+			UserRepository userRepository,
+			HistoryRepository historyRepository)
+	{
+		this.allowanceRepository = allowanceRepository;
+		this.userRepository = userRepository;
+		this.historyRepository = historyRepository;
+	}
+
+	public List<AllowanceDto> getUserAllowances(int userId)
+	{
+		User user = userRepository.findById(userId).orElseThrow();
+		List<AllowanceDto> result = new ArrayList<>();
+
+		// Add the "rest" allowance (id=0)
+		result.add(new AllowanceDto(0, "", 0, user.getBalance() / 100.0, user.getWeight(), ""));
+
+		// Add named allowances
+		for (Allowance a : allowanceRepository.findByUserIdOrderByIdAsc(userId))
+		{
+			result.add(toDto(a));
+		}
+		return result;
+	}
+
+	public Optional<AllowanceDto> getUserAllowanceById(int userId, int allowanceId)
+	{
+		if (allowanceId == 0)
+		{
+			return userRepository.findById(userId)
+					.map(u -> new AllowanceDto(0, "", 0, u.getBalance() / 100.0, u.getWeight(), ""));
+		}
+		return allowanceRepository.findByIdAndUserId(allowanceId, userId)
+				.map(this::toDto);
+	}
+
+	@Transactional
+	public int createAllowance(int userId, CreateAllowanceRequest request)
+	{
+		int colour = ColourUtil.convertStringToColour(request.colour());
+		Allowance allowance = new Allowance();
+		allowance.setUserId(userId);
+		allowance.setName(request.name());
+		allowance.setTarget(Math.round(request.target() * 100.0));
+		allowance.setWeight(request.weight());
+		allowance.setColour(colour);
+		allowance = allowanceRepository.save(allowance);
+		return allowance.getId();
+	}
+
+	@Transactional
+	public boolean deleteAllowance(int userId, int allowanceId)
+	{
+		int count = allowanceRepository.countByIdAndUserId(allowanceId, userId);
+		if (count == 0)
+		{
+			return false;
+		}
+		allowanceRepository.deleteByIdAndUserId(allowanceId, userId);
+		return true;
+	}
+
+	@Transactional
+	public boolean updateAllowance(int userId, int allowanceId, UpdateAllowanceRequest request)
+	{
+		if (allowanceId == 0)
+		{
+			User user = userRepository.findById(userId).orElseThrow();
+			user.setWeight(request.weight());
+			userRepository.save(user);
+			return true;
+		}
+
+		Optional<Allowance> opt = allowanceRepository.findByIdAndUserId(allowanceId, userId);
+		if (opt.isEmpty())
+		{
+			return false;
+		}
+
+		int colour = ColourUtil.convertStringToColour(request.colour());
+		Allowance allowance = opt.get();
+		allowance.setName(request.name());
+		allowance.setTarget(Math.round(request.target() * 100.0));
+		allowance.setWeight(request.weight());
+		allowance.setColour(colour);
+		allowanceRepository.save(allowance);
+		return true;
+	}
+
+	@Transactional
+	public void bulkUpdateAllowance(int userId, List<BulkUpdateAllowanceRequest> requests)
+	{
+		for (BulkUpdateAllowanceRequest req : requests)
+		{
+			if (req.id() == 0)
+			{
+				User user = userRepository.findById(userId).orElseThrow();
+				user.setWeight(req.weight());
+				userRepository.save(user);
+			}
+			else
+			{
+				allowanceRepository.findByIdAndUserId(req.id(), userId).ifPresent(a ->
+				{
+					a.setWeight(req.weight());
+					allowanceRepository.save(a);
+				});
+			}
+		}
+	}
+
+	@Transactional
+	public boolean completeAllowance(int userId, int allowanceId)
+	{
+		Optional<Allowance> opt = allowanceRepository.findByIdAndUserId(allowanceId, userId);
+		if (opt.isEmpty())
+		{
+			return false;
+		}
+
+		Allowance allowance = opt.get();
+		long cost = allowance.getBalance();
+		String allowanceName = allowance.getName();
+
+		// Delete the allowance
+		allowanceRepository.delete(allowance);
+
+		// Add a history entry
+		History history = new History();
+		history.setUserId(userId);
+		history.setTimestamp(Instant.now().getEpochSecond());
+		history.setAmount(-cost);
+		history.setDescription("Allowance completed: " + allowanceName);
+		historyRepository.save(history);
+
+		return true;
+	}
+
+	@Transactional
+	public boolean addAllowanceAmount(int userId, int allowanceId, AddAllowanceAmountRequest request)
+	{
+		long remainingAmount = Math.round(request.amount() * 100);
+
+		// Insert history entry
+		History history = new History();
+		history.setUserId(userId);
+		history.setTimestamp(Instant.now().getEpochSecond());
+		history.setAmount(remainingAmount);
+		history.setDescription(request.description());
+		historyRepository.save(history);
+
+		if (allowanceId == 0)
+		{
+			if (remainingAmount < 0)
+			{
+				User user = userRepository.findById(userId).orElseThrow();
+				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);
+		}
+		else if (remainingAmount < 0)
+		{
+			Allowance allowance = allowanceRepository.findByIdAndUserId(allowanceId, userId).orElse(null);
+			if (allowance == null)
+			{
+				return false;
+			}
+			if (remainingAmount > allowance.getBalance())
+			{
+				throw new IllegalArgumentException("cannot remove more than the current allowance balance: " + allowance.getBalance());
+			}
+			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;
+			if (allowance.getBalance() + toAdd > allowance.getTarget())
+			{
+				toAdd = allowance.getTarget() - allowance.getBalance();
+			}
+			remainingAmount -= toAdd;
+
+			if (toAdd > 0)
+			{
+				allowance.setBalance(allowance.getBalance() + toAdd);
+				allowanceRepository.save(allowance);
+			}
+
+			if (remainingAmount > 0)
+			{
+				addDistributedReward(userId, (int) remainingAmount);
+			}
+		}
+		return true;
+	}
+
+	public void addDistributedReward(int userId, int reward)
+	{
+		User user = userRepository.findById(userId).orElseThrow();
+		double userWeight = user.getWeight();
+
+		double sumOfWeights = allowanceRepository.sumPositiveWeights(userId) + userWeight;
+
+		int remainingReward = reward;
+
+		if (sumOfWeights > 0)
+		{
+			List<Allowance> allowances = allowanceRepository.findByUserIdWithPositiveWeightOrderByRemainingAsc(userId);
+			for (Allowance allowance : allowances)
+			{
+				int amount = (int) ((allowance.getWeight() / sumOfWeights) * remainingReward);
+				if (allowance.getBalance() + amount > allowance.getTarget())
+				{
+					amount = (int) (allowance.getTarget() - allowance.getBalance());
+				}
+				sumOfWeights -= allowance.getWeight();
+				allowance.setBalance(allowance.getBalance() + amount);
+				allowanceRepository.save(allowance);
+				remainingReward -= amount;
+			}
+		}
+
+		// Add remaining to user's balance
+		user = userRepository.findById(userId).orElseThrow();
+		user.setBalance(user.getBalance() + remainingReward);
+		userRepository.save(user);
+	}
+
+	public List<HistoryDto> getHistory(int userId)
+	{
+		return historyRepository.findByUserIdOrderByIdDesc(userId).stream()
+				.map(h -> new HistoryDto(
+						h.getAmount() / 100.0,
+						Instant.ofEpochSecond(h.getTimestamp()),
+						h.getDescription()))
+				.toList();
+	}
+
+	@Transactional
+	public void addHistory(int userId, PostHistoryRequest request)
+	{
+		long amount = Math.round(request.allowance() * 100.0);
+		History history = new History();
+		history.setUserId(userId);
+		history.setTimestamp(Instant.now().getEpochSecond());
+		history.setAmount(amount);
+		history.setDescription(request.description());
+		historyRepository.save(history);
+	}
+
+	private AllowanceDto toDto(Allowance a)
+	{
+		return new AllowanceDto(
+				a.getId(),
+				a.getName(),
+				a.getTarget() / 100.0,
+				a.getBalance() / 100.0,
+				a.getWeight(),
+				ColourUtil.convertColourToString(a.getColour()));
+	}
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/TaskService.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/TaskService.java
@@ -0,0 +1,132 @@
+package be.seeseepuff.allowanceplanner.service;
+
+import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.entity.History;
+import be.seeseepuff.allowanceplanner.entity.Task;
+import be.seeseepuff.allowanceplanner.entity.User;
+import be.seeseepuff.allowanceplanner.repository.HistoryRepository;
+import be.seeseepuff.allowanceplanner.repository.TaskRepository;
+import be.seeseepuff.allowanceplanner.repository.UserRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class TaskService
+{
+	private final TaskRepository taskRepository;
+	private final UserRepository userRepository;
+	private final HistoryRepository historyRepository;
+	private final AllowanceService allowanceService;
+
+	public TaskService(TaskRepository taskRepository,
+			UserRepository userRepository,
+			HistoryRepository historyRepository,
+			AllowanceService allowanceService)
+	{
+		this.taskRepository = taskRepository;
+		this.userRepository = userRepository;
+		this.historyRepository = historyRepository;
+		this.allowanceService = allowanceService;
+	}
+
+	@Transactional
+	public int createTask(CreateTaskRequest request)
+	{
+		Task task = new Task();
+		task.setName(request.name());
+		task.setReward(Math.round((request.reward() != null ? request.reward() : 0.0) * 100.0));
+		task.setAssigned(request.assigned());
+		task = taskRepository.save(task);
+		return task.getId();
+	}
+
+	public List<TaskDto> getTasks()
+	{
+		return taskRepository.findByCompletedIsNull().stream()
+				.map(this::toDto)
+				.toList();
+	}
+
+	public Optional<TaskDto> getTask(int taskId)
+	{
+		return taskRepository.findByIdAndCompletedIsNull(taskId)
+				.map(this::toDto);
+	}
+
+	@Transactional
+	public boolean updateTask(int taskId, CreateTaskRequest request)
+	{
+		Optional<Task> opt = taskRepository.findByIdAndCompletedIsNull(taskId);
+		if (opt.isEmpty())
+		{
+			return false;
+		}
+		Task task = opt.get();
+		task.setName(request.name());
+		task.setReward(Math.round((request.reward() != null ? request.reward() : 0.0) * 100.0));
+		task.setAssigned(request.assigned());
+		taskRepository.save(task);
+		return true;
+	}
+
+	public boolean hasTask(int taskId)
+	{
+		return taskRepository.existsById(taskId);
+	}
+
+	@Transactional
+	public void deleteTask(int taskId)
+	{
+		taskRepository.deleteById(taskId);
+	}
+
+	@Transactional
+	public boolean completeTask(int taskId)
+	{
+		Optional<Task> opt = taskRepository.findById(taskId);
+		if (opt.isEmpty())
+		{
+			return false;
+		}
+
+		Task task = opt.get();
+		long reward = task.getReward();
+		String rewardName = task.getName();
+
+		// Give reward to all users
+		List<User> users = userRepository.findAll();
+		for (User user : users)
+		{
+			// Add history entry
+			History history = new History();
+			history.setUserId(user.getId());
+			history.setTimestamp(Instant.now().getEpochSecond());
+			history.setAmount(reward);
+			history.setDescription("Task completed: " + rewardName);
+			historyRepository.save(history);
+
+			// Distribute reward
+			allowanceService.addDistributedReward(user.getId(), (int) reward);
+		}
+
+		// Mark task as completed
+		task.setCompleted(Instant.now().getEpochSecond());
+		taskRepository.save(task);
+
+		return true;
+	}
+
+	private TaskDto toDto(Task t)
+	{
+		return new TaskDto(
+				t.getId(),
+				t.getName(),
+				t.getReward() / 100.0,
+				t.getAssigned(),
+				t.getSchedule());
+	}
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/TransferService.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/TransferService.java
@@ -0,0 +1,102 @@
+package be.seeseepuff.allowanceplanner.service;
+
+import be.seeseepuff.allowanceplanner.dto.TransferRequest;
+import be.seeseepuff.allowanceplanner.entity.Allowance;
+import be.seeseepuff.allowanceplanner.repository.AllowanceRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+
+@Service
+public class TransferService
+{
+	private final AllowanceRepository allowanceRepository;
+
+	public TransferService(AllowanceRepository allowanceRepository)
+	{
+		this.allowanceRepository = allowanceRepository;
+	}
+
+	@Transactional
+	public TransferResult transfer(TransferRequest request)
+	{
+		if (request.from() == request.to())
+		{
+			return TransferResult.success();
+		}
+
+		int amountCents = (int) Math.round(request.amount() * 100.0);
+		if (amountCents <= 0)
+		{
+			return TransferResult.badRequest("amount must be positive");
+		}
+
+		Optional<Allowance> fromOpt = allowanceRepository.findById(request.from());
+		if (fromOpt.isEmpty())
+		{
+			return TransferResult.notFound();
+		}
+
+		Optional<Allowance> toOpt = allowanceRepository.findById(request.to());
+		if (toOpt.isEmpty())
+		{
+			return TransferResult.notFound();
+		}
+
+		Allowance from = fromOpt.get();
+		Allowance to = toOpt.get();
+
+		if (from.getUserId() != to.getUserId())
+		{
+			return TransferResult.badRequest("Allowances do not belong to the same user");
+		}
+
+		long remainingTo = to.getTarget() - to.getBalance();
+		if (remainingTo <= 0)
+		{
+			return TransferResult.badRequest("target already reached");
+		}
+
+		int transfer = amountCents;
+		if (transfer > remainingTo)
+		{
+			transfer = (int) remainingTo;
+		}
+
+		if (from.getBalance() < transfer)
+		{
+			return TransferResult.badRequest("Insufficient funds in source allowance");
+		}
+
+		from.setBalance(from.getBalance() - transfer);
+		to.setBalance(to.getBalance() + transfer);
+		allowanceRepository.save(from);
+		allowanceRepository.save(to);
+
+		return TransferResult.success();
+	}
+
+	public record TransferResult(Status status, String message)
+	{
+		public enum Status
+		{
+			SUCCESS, BAD_REQUEST, NOT_FOUND
+		}
+
+		public static TransferResult success()
+		{
+			return new TransferResult(Status.SUCCESS, "Transfer successful");
+		}
+
+		public static TransferResult badRequest(String message)
+		{
+			return new TransferResult(Status.BAD_REQUEST, message);
+		}
+
+		public static TransferResult notFound()
+		{
+			return new TransferResult(Status.NOT_FOUND, "Allowance not found");
+		}
+	}
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/UserService.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/service/UserService.java
@@ -0,0 +1,42 @@
+package be.seeseepuff.allowanceplanner.service;
+
+import be.seeseepuff.allowanceplanner.dto.*;
+import be.seeseepuff.allowanceplanner.entity.User;
+import be.seeseepuff.allowanceplanner.repository.UserRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class UserService
+{
+	private final UserRepository userRepository;
+
+	public UserService(UserRepository userRepository)
+	{
+		this.userRepository = userRepository;
+	}
+
+	public List<UserDto> getUsers()
+	{
+		return userRepository.findAll().stream()
+				.map(u -> new UserDto(u.getId(), u.getName()))
+				.toList();
+	}
+
+	public Optional<UserWithAllowanceDto> getUser(int userId)
+	{
+		return userRepository.findById(userId)
+				.map(u ->
+				{
+					long totalAmount = userRepository.sumHistoryAmount(userId);
+					return new UserWithAllowanceDto(u.getId(), u.getName(), totalAmount / 100.0);
+				});
+	}
+
+	public boolean userExists(int userId)
+	{
+		return userRepository.existsById(userId);
+	}
+}
--- a/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/util/ColourUtil.java
+++ b/backend-spring/src/main/java/be/seeseepuff/allowanceplanner/util/ColourUtil.java
@@ -0,0 +1,42 @@
+package be.seeseepuff.allowanceplanner.util;
+
+public class ColourUtil
+{
+	private ColourUtil()
+	{
+	}
+
+	public static int convertStringToColour(String colourStr)
+	{
+		if (colourStr == null || colourStr.isEmpty())
+		{
+			return 0xFF0000; // Default colour
+		}
+		if (colourStr.charAt(0) == '#')
+		{
+			colourStr = colourStr.substring(1);
+		}
+		if (colourStr.length() != 6 && colourStr.length() != 3)
+		{
+			throw new IllegalArgumentException("colour must be a valid hex string");
+		}
+		int colour = Integer.parseInt(colourStr, 16);
+		if (colourStr.length() == 3)
+		{
+			int r = (colour & 0xF00) >> 8;
+			int g = (colour & 0x0F0) >> 4;
+			int b = (colour & 0x00F);
+			colour = (r << 20) | (g << 12) | (b << 4);
+		}
+		return colour;
+	}
+
+	public static String convertColourToString(Integer colour)
+	{
+		if (colour == null)
+		{
+			return "";
+		}
+		return String.format("#%06X", colour);
+	}
+}
--- a/backend-spring/src/main/resources/application.properties
+++ b/backend-spring/src/main/resources/application.properties
@@ -0,0 +1,12 @@
+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
--- a/backend-spring/src/main/resources/db/migration/V1__initial.sql
+++ b/backend-spring/src/main/resources/db/migration/V1__initial.sql
@@ -0,0 +1,42 @@
+CREATE TABLE users
+(
+    id      SERIAL PRIMARY KEY,
+    name    TEXT             NOT NULL,
+    weight  DOUBLE PRECISION NOT NULL DEFAULT 10.0,
+    balance BIGINT           NOT NULL DEFAULT 0
+);
+
+CREATE TABLE history
+(
+    id          SERIAL PRIMARY KEY,
+    user_id     INTEGER NOT NULL,
+    timestamp   BIGINT  NOT NULL,
+    amount      BIGINT  NOT NULL,
+    description TEXT
+);
+
+CREATE TABLE allowances
+(
+    id      SERIAL PRIMARY KEY,
+    user_id INTEGER          NOT NULL,
+    name    TEXT             NOT NULL,
+    target  BIGINT           NOT NULL,
+    balance BIGINT           NOT NULL DEFAULT 0,
+    weight  DOUBLE PRECISION NOT NULL,
+    colour  INTEGER
+);
+
+CREATE TABLE tasks
+(
+    id        SERIAL PRIMARY KEY,
+    name      TEXT   NOT NULL,
+    reward    BIGINT NOT NULL,
+    assigned  INTEGER,
+    schedule  TEXT,
+    completed BIGINT,
+    next_run  BIGINT
+);
+
+INSERT INTO users (name)
+VALUES ('Seeseemelk'),
+       ('Huffle');
--- a/backend-spring/src/main/resources/templates/index.html
+++ b/backend-spring/src/main/resources/templates/index.html
@@ -0,0 +1,122 @@
+<!DOCTYPE html>
+<html lang="en" xmlns:th="http://www.thymeleaf.org">
+<head>
+    <title>Allowance Planner 2000</title>
+    <style>
+        tr:hover {
+            background-color: #f0f0f0;
+        }
+    </style>
+</head>
+<body>
+<h1>Allowance Planner 2000</h1>
+
+<div th:if="${error != null}">
+    <h2>Error</h2>
+    <p th:text="${error}"></p>
+</div>
+
+<div th:if="${error == null}">
+    <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()}"
+           th:href="@{/login(user=${user.id()})}" th:text="${user.name()}"></a>
+    </span>
+
+    <div th:if="${currentUser != null and currentUser > 0}">
+        <h2>Allowances</h2>
+        <form action="/createAllowance" method="post">
+            <table border="1">
+                <thead>
+                <tr>
+                    <th>Name</th>
+                    <th>Progress</th>
+                    <th>Target</th>
+                    <th>Weight</th>
+                    <th>Actions</th>
+                </tr>
+                </thead>
+                <tbody>
+                <tr>
+                    <td><label><input type="text" name="name" placeholder="Name"/></label></td>
+                    <td></td>
+                    <td><label><input type="number" name="target" placeholder="Target"/></label></td>
+                    <td><label><input type="number" name="weight" placeholder="Weight"/></label></td>
+                    <td><input type="submit" value="Create"/></td>
+                </tr>
+                <tr th:each="allowance : ${allowances}">
+                    <td th:if="${allowance.id() == 0}">Total</td>
+                    <td th:if="${allowance.id() != 0}" th:text="${allowance.name()}"></td>
+                    <td th:if="${allowance.id() == 0}" th:text="${allowance.progress()}"></td>
+                    <td th:if="${allowance.id() != 0}">
+                        <progress th:max="${allowance.target()}" th:value="${allowance.progress()}"></progress>
+                        (<span th:text="${allowance.progress()}"></span>)
+                    </td>
+                    <td th:if="${allowance.id() == 0}"></td>
+                    <td th:if="${allowance.id() != 0}" th:text="${allowance.target()}"></td>
+                    <td th:text="${allowance.weight()}"></td>
+                    <td th:if="${allowance.id() != 0 and allowance.progress() >= allowance.target()}">
+                        <a th:href="@{/completeAllowance(allowance=${allowance.id()})}">Mark as completed</a>
+                    </td>
+                    <td th:if="${allowance.id() == 0 or allowance.progress() < allowance.target()}"></td>
+                </tr>
+                </tbody>
+            </table>
+        </form>
+
+        <h2>Tasks</h2>
+        <form method="post" action="/createTask">
+            <table border="1">
+                <thead>
+                <tr>
+                    <th>Name</th>
+                    <th>Assigned</th>
+                    <th>Reward</th>
+                    <th>Schedule</th>
+                    <th>Actions</th>
+                </tr>
+                </thead>
+                <tbody>
+                <tr th:each="task : ${tasks}">
+                    <td th:text="${task.name()}"></td>
+                    <td>
+                        <span th:if="${task.assigned() == null}">None</span>
+                        <span th:if="${task.assigned() != null}" th:text="${task.assigned()}"></span>
+                    </td>
+                    <td th:text="${task.reward()}"></td>
+                    <td th:text="${task.schedule()}"></td>
+                    <td>
+                        <a th:href="@{/completeTask(task=${task.id()})}">Mark as completed</a>
+                    </td>
+                </tr>
+                <tr>
+                    <td><label><input type="text" name="name" placeholder="Name"/></label></td>
+                    <td></td>
+                    <td><label><input type="number" name="reward" placeholder="Reward"/></label></td>
+                    <td><label><input type="text" name="schedule" placeholder="Schedule"/></label></td>
+                    <td><input type="submit" value="Create"/></td>
+                </tr>
+                </tbody>
+            </table>
+        </form>
+
+        <h2>History</h2>
+        <table border="1">
+            <thead>
+            <tr>
+                <th>Timestamp</th>
+                <th>Allowance</th>
+            </tr>
+            </thead>
+            <tbody>
+            <tr th:each="item : ${history}">
+                <td th:text="${item.timestamp()}"></td>
+                <td th:text="${item.allowance()}"></td>
+            </tr>
+            </tbody>
+        </table>
+    </div>
+</div>
+</body>
+</html>
--- a/backend-spring/src/test/java/be/seeseepuff/allowanceplanner/ApiTest.java
+++ b/backend-spring/src/test/java/be/seeseepuff/allowanceplanner/ApiTest.java
--- a/backend-spring/src/test/java/be/seeseepuff/allowanceplanner/ColourUtilTest.java
+++ b/backend-spring/src/test/java/be/seeseepuff/allowanceplanner/ColourUtilTest.java
@@ -0,0 +1,33 @@
+package be.seeseepuff.allowanceplanner;
+
+import be.seeseepuff.allowanceplanner.util.ColourUtil;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class ColourUtilTest
+{
+	@Test
+	void convertStringToColourWithSign()
+	{
+		assertEquals(0x123456, ColourUtil.convertStringToColour("#123456"));
+	}
+
+	@Test
+	void convertStringToColourWithoutSign()
+	{
+		assertEquals(0x123456, ColourUtil.convertStringToColour("123456"));
+	}
+
+	@Test
+	void convertStringToColourWithSignThreeDigits()
+	{
+		assertEquals(0xA0B0C0, ColourUtil.convertStringToColour("#ABC"));
+	}
+
+	@Test
+	void convertStringToColourWithoutSignThreeDigits()
+	{
+		assertEquals(0xA0B0C0, ColourUtil.convertStringToColour("ABC"));
+	}
+}