Use Lombok plugin

Add GET /api/export to the Go backend that dumps all users, allowances,
history, and tasks (including completed) as a single JSON snapshot.

Add POST /api/import to the Spring backend that accepts the same JSON,
wipes existing data, inserts all records with original IDs preserved via
native SQL, and resets PostgreSQL sequences to avoid future collisions.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

backend-spring/.gitignore

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

backend-spring/Dockerfile

@@ -0,0 +1,17 @@
+FROM eclipse-temurin:25-jdk-alpine AS build
+
+WORKDIR /app
+COPY gradle ./gradle
+COPY gradlew build.gradle.kts settings.gradle.kts ./
+RUN ./gradlew dependencies --no-daemon
+
+COPY src ./src
+RUN ./gradlew bootJar --no-daemon -x test
+
+FROM eclipse-temurin:25-jre-alpine
+
+WORKDIR /app
+COPY --from=build /app/build/libs/*.jar app.jar
+
+EXPOSE 8080
+CMD ["java", "-jar", "app.jar"]

backend-spring/build.gradle.kts

@@ -0,0 +1,38 @@
+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"
+version = "0.0.1-SNAPSHOT"
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(25)
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation("org.springframework.boot:spring-boot-starter-web")
+    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
+    implementation("org.springframework.boot:spring-boot-starter-thymeleaf")
+    implementation("org.springframework.boot:spring-boot-starter-flyway")
+    implementation("org.flywaydb:flyway-database-postgresql")
+    runtimeOnly("org.postgresql:postgresql")
+
+    testImplementation("org.springframework.boot:spring-boot-starter-test")
+    testImplementation("org.springframework.boot:spring-boot-testcontainers")
+    testImplementation("org.testcontainers:testcontainers-junit-jupiter:2.0.3")
+    testImplementation("org.testcontainers:testcontainers-postgresql:2.0.3")
+    testImplementation("io.rest-assured:rest-assured:6.0.0")
+}
+
+tasks.withType<Test> {
+    useJUnitPlatform()
+}

backend-spring/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

backend-spring/gradlew

@@ -0,0 +1,248 @@
+#!/bin/sh
+
+#
+# Copyright © 2015 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

backend-spring/gradlew.bat

@@ -0,0 +1,93 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

backend-spring/settings.gradle.kts

@@ -0,0 +1 @@
+rootProject.name = "allowance-planner"

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

@@ -0,0 +1,11 @@
+package be.seeseepuff.allowanceplanner;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class AllowancePlannerApplication {
+    static void main(String[] 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/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

@@ -0,0 +1,149 @@
+package be.seeseepuff.allowanceplanner.controller;
+
+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;
+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;
+
+@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";
+    }
+}

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

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

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

@@ -0,0 +1,7 @@
+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) {
+}

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

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

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

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

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

@@ -0,0 +1,8 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+public record CreateTaskRequest(
+        String name,
+        Double reward,
+        Integer assigned,
+        String schedule) {
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,24 @@
+package be.seeseepuff.allowanceplanner.dto;
+
+import java.util.List;
+
+public record MigrationDto(
+        List<MigrationUserDto> users,
+        List<MigrationAllowanceDto> allowances,
+        List<MigrationHistoryDto> history,
+        List<MigrationTaskDto> tasks
+) {
+    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,
+                                        Integer colour) {
+    }
+
+    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,
+                                   Long completed, Long nextRun) {
+    }
+}

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

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

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

@@ -0,0 +1,7 @@
+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) {
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+package be.seeseepuff.allowanceplanner.entity;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+
+@Entity
+@Table(name = "allowances")
+@Getter
+@Setter
+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;
+}

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

@@ -0,0 +1,26 @@
+package be.seeseepuff.allowanceplanner.entity;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+
+@Entity
+@Table(name = "history")
+@Getter
+@Setter
+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;
+}

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

@@ -0,0 +1,30 @@
+package be.seeseepuff.allowanceplanner.entity;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+
+@Entity
+@Table(name = "tasks")
+@Getter
+@Setter
+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;
+}

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

@@ -0,0 +1,24 @@
+package be.seeseepuff.allowanceplanner.entity;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+
+@Entity
+@Table(name = "users")
+@Getter
+@Setter
+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;
+}

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

@@ -0,0 +1,26 @@
+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);
+}

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

@@ -0,0 +1,12 @@
+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);
+}

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

@@ -0,0 +1,15 @@
+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);
+}

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

@@ -0,0 +1,12 @@
+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);
+}

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

@@ -0,0 +1,258 @@
+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()));
+    }
+}

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

@@ -0,0 +1,97 @@
+package be.seeseepuff.allowanceplanner.service;
+
+import be.seeseepuff.allowanceplanner.dto.MigrationDto;
+import be.seeseepuff.allowanceplanner.repository.AllowanceRepository;
+import be.seeseepuff.allowanceplanner.repository.HistoryRepository;
+import be.seeseepuff.allowanceplanner.repository.TaskRepository;
+import be.seeseepuff.allowanceplanner.repository.UserRepository;
+import jakarta.persistence.EntityManager;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class MigrationService {
+    private final UserRepository userRepository;
+    private final AllowanceRepository allowanceRepository;
+    private final HistoryRepository historyRepository;
+    private final TaskRepository taskRepository;
+    private final EntityManager entityManager;
+
+    public MigrationService(UserRepository userRepository,
+                            AllowanceRepository allowanceRepository,
+                            HistoryRepository historyRepository,
+                            TaskRepository taskRepository,
+                            EntityManager entityManager) {
+        this.userRepository = userRepository;
+        this.allowanceRepository = allowanceRepository;
+        this.historyRepository = historyRepository;
+        this.taskRepository = taskRepository;
+        this.entityManager = entityManager;
+    }
+
+    @Transactional
+    public void importData(MigrationDto data) {
+        // Delete in dependency order
+        taskRepository.deleteAll();
+        historyRepository.deleteAll();
+        allowanceRepository.deleteAll();
+        userRepository.deleteAll();
+
+        // Insert users with original IDs using native SQL to bypass auto-increment
+        for (MigrationDto.MigrationUserDto u : data.users()) {
+            entityManager.createNativeQuery(
+                            "INSERT INTO users (id, name, balance, weight) VALUES (:id, :name, :balance, :weight)")
+                    .setParameter("id", u.id())
+                    .setParameter("name", u.name())
+                    .setParameter("balance", u.balance())
+                    .setParameter("weight", u.weight())
+                    .executeUpdate();
+        }
+
+        // Insert allowances with original IDs
+        for (MigrationDto.MigrationAllowanceDto a : data.allowances()) {
+            entityManager.createNativeQuery(
+                            "INSERT INTO allowances (id, user_id, name, target, balance, weight, colour) VALUES (:id, :userId, :name, :target, :balance, :weight, :colour)")
+                    .setParameter("id", a.id())
+                    .setParameter("userId", a.userId())
+                    .setParameter("name", a.name())
+                    .setParameter("target", a.target())
+                    .setParameter("balance", a.balance())
+                    .setParameter("weight", a.weight())
+                    .setParameter("colour", a.colour())
+                    .executeUpdate();
+        }
+
+        // Insert history with original IDs
+        for (MigrationDto.MigrationHistoryDto h : data.history()) {
+            entityManager.createNativeQuery(
+                            "INSERT INTO history (id, user_id, timestamp, amount, description) VALUES (:id, :userId, :timestamp, :amount, :description)")
+                    .setParameter("id", h.id())
+                    .setParameter("userId", h.userId())
+                    .setParameter("timestamp", h.timestamp())
+                    .setParameter("amount", h.amount())
+                    .setParameter("description", h.description())
+                    .executeUpdate();
+        }
+
+        // Insert tasks with original IDs
+        for (MigrationDto.MigrationTaskDto t : data.tasks()) {
+            entityManager.createNativeQuery(
+                            "INSERT INTO tasks (id, name, reward, assigned, schedule, completed, next_run) VALUES (:id, :name, :reward, :assigned, :schedule, :completed, :nextRun)")
+                    .setParameter("id", t.id())
+                    .setParameter("name", t.name())
+                    .setParameter("reward", t.reward())
+                    .setParameter("assigned", t.assigned())
+                    .setParameter("schedule", t.schedule())
+                    .setParameter("completed", t.completed())
+                    .setParameter("nextRun", t.nextRun())
+                    .executeUpdate();
+        }
+
+        // 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('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('tasks_id_seq', COALESCE((SELECT MAX(id) FROM tasks), 0))").getSingleResult();
+    }
+}

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

@@ -0,0 +1,120 @@
+package be.seeseepuff.allowanceplanner.service;
+
+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;
+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());
+    }
+}

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

@@ -0,0 +1,86 @@
+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 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");
+        }
+
+        public enum Status {
+            SUCCESS, BAD_REQUEST, NOT_FOUND
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+package be.seeseepuff.allowanceplanner.service;
+
+import be.seeseepuff.allowanceplanner.dto.UserDto;
+import be.seeseepuff.allowanceplanner.dto.UserWithAllowanceDto;
+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);
+    }
+}

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

@@ -0,0 +1,33 @@
+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);
+    }
+}

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

@@ -0,0 +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/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');

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:href="@{/login(user=${user.id()})}"
+           th:text="${user.name()}" th:unless="${currentUser != null and currentUser == user.id()}"></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 name="name" placeholder="Name" type="text"/></label></td>
+                    <td></td>
+                    <td><label><input name="target" placeholder="Target" type="number"/></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}">
+                    <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 action="/createTask" method="post">
+            <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 name="name" placeholder="Name" type="text"/></label></td>
+                    <td></td>
+                    <td><label><input name="reward" placeholder="Reward" type="number"/></label></td>
+                    <td><label><input name="schedule" placeholder="Schedule" type="text"/></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>

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

@@ -0,0 +1,28 @@
+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"));
+    }
+}

backend/db.go

@@ -779,3 +779,59 @@ func (db *Db) TransferAllowance(fromId int, toId int, amount float64) error {
 
 	return tx.Commit()
 }
+
+func (db *Db) ExportAllData() (*ExportData, error) {
+	var err error
+	data := &ExportData{
+		Users:      make([]ExportUser, 0),
+		Allowances: make([]ExportAllowance, 0),
+		History:    make([]ExportHistory, 0),
+		Tasks:      make([]ExportTask, 0),
+	}
+
+	for row := range db.db.Query("select id, name, balance, weight from users").Range(&err) {
+		u := ExportUser{}
+		if err = row.Scan(&u.ID, &u.Name, &u.Balance, &u.Weight); err != nil {
+			return nil, err
+		}
+		data.Users = append(data.Users, u)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	for row := range db.db.Query("select id, user_id, name, target, balance, weight, colour from allowances").Range(&err) {
+		a := ExportAllowance{}
+		if err = row.Scan(&a.ID, &a.UserID, &a.Name, &a.Target, &a.Balance, &a.Weight, &a.Colour); err != nil {
+			return nil, err
+		}
+		data.Allowances = append(data.Allowances, a)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	for row := range db.db.Query("select id, user_id, timestamp, amount, description from history").Range(&err) {
+		h := ExportHistory{}
+		if err = row.Scan(&h.ID, &h.UserID, &h.Timestamp, &h.Amount, &h.Description); err != nil {
+			return nil, err
+		}
+		data.History = append(data.History, h)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	for row := range db.db.Query("select id, name, reward, assigned, schedule, completed, next_run from tasks").Range(&err) {
+		t := ExportTask{}
+		if err = row.Scan(&t.ID, &t.Name, &t.Reward, &t.Assigned, &t.Schedule, &t.Completed, &t.NextRun); err != nil {
+			return nil, err
+		}
+		data.Tasks = append(data.Tasks, t)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}

backend/dto.go

@@ -86,3 +86,45 @@ type TransferRequest struct {
 	To     int     `json:"to"`
 	Amount float64 `json:"amount"`
 }
+
+type ExportUser struct {
+	ID      int     `json:"id"`
+	Name    string  `json:"name"`
+	Balance int64   `json:"balance"`
+	Weight  float64 `json:"weight"`
+}
+
+type ExportAllowance struct {
+	ID      int      `json:"id"`
+	UserID  int      `json:"userId"`
+	Name    string   `json:"name"`
+	Target  int64    `json:"target"`
+	Balance int64    `json:"balance"`
+	Weight  float64  `json:"weight"`
+	Colour  *int     `json:"colour"`
+}
+
+type ExportHistory struct {
+	ID          int    `json:"id"`
+	UserID      int    `json:"userId"`
+	Timestamp   int64  `json:"timestamp"`
+	Amount      int64  `json:"amount"`
+	Description string `json:"description"`
+}
+
+type ExportTask struct {
+	ID        int     `json:"id"`
+	Name      string  `json:"name"`
+	Reward    int64   `json:"reward"`
+	Assigned  *int    `json:"assigned"`
+	Schedule  *string `json:"schedule"`
+	Completed *int64  `json:"completed"`
+	NextRun   *int64  `json:"nextRun"`
+}
+
+type ExportData struct {
+	Users      []ExportUser      `json:"users"`
+	Allowances []ExportAllowance `json:"allowances"`
+	History    []ExportHistory   `json:"history"`
+	Tasks      []ExportTask      `json:"tasks"`
+}

backend/main.go

@@ -51,6 +51,16 @@ const DefaultDomain = "localhost:8080"
 // The domain that the server is reachable at.
 var domain = DefaultDomain
 
+func exportData(c *gin.Context) {
+	data, err := db.ExportAllData()
+	if err != nil {
+		log.Printf("Error exporting data: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": ErrInternalServerError})
+		return
+	}
+	c.IndentedJSON(http.StatusOK, data)
+}
+
 func getUsers(c *gin.Context) {
 	users, err := db.GetUsers()
 	if err != nil {
@@ -713,6 +723,7 @@ func start(ctx context.Context, config *ServerConfig) {
 	router.DELETE("/api/task/:taskId", deleteTask)
 	router.POST("/api/task/:taskId/complete", completeTask)
 	router.POST("/api/transfer", transfer)
+	router.GET("/api/export", exportData)
 
 	srv := &http.Server{
 		Addr:    config.Addr,