Added case for not fetching a player

Reviewed-on: #196
Reviewed-by: gelbeinhalb <spam@yannick-weigert.de>

analysis_options.yaml

@@ -1,9 +1,5 @@
 include: package:flutter_lints/flutter.yaml
 
-analyzer:
-  exclude:
-    - lib/presentation/views/main_menu/settings_view/licenses/oss_licenses.dart
-
 linter:
   rules:
     avoid_print: false
@@ -15,4 +11,8 @@ linter:
     prefer_const_literals_to_create_immutables: true
     unnecessary_const: true
     lines_longer_than_80_chars: false
-    constant_identifier_names: false
+    constant_identifier_names: false
+
+analyzer:
+  exclude:
+    - lib/presentation/views/main_menu/settings_view/licenses/oss_licenses.dart

assets/schema.json

@@ -20,6 +20,7 @@
             "type": "string"
           }
         },
+        "additionalProperties": false,
         "required": [
           "id",
           "createdAt",
@@ -55,6 +56,7 @@
             "type": "string"
           }
         },
+        "additionalProperties": false,
         "required": [
           "id",
           "createdAt",
@@ -90,6 +92,7 @@
             }
           }
         },
+        "additionalProperties": false,
         "required": [
           "id",
           "name",
@@ -120,6 +123,7 @@
             }
           }
         },
+        "additionalProperties": false,
         "required": [
           "id",
           "name",
@@ -157,10 +161,31 @@
               "type": "string"
             }
           },
+          "scores": {
+            "type": "object",
+            "items": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "properties": {
+                  "roundNumber": {
+                    "type": "number"
+                  },
+                  "score": {
+                    "type": "number"
+                  },
+                  "change": {
+                    "type": "number"
+                  }
+                }
+              }
+            }
+          },
           "notes": {
             "type": "string"
           }
         },
+        "additionalProperties": false,
         "required": [
           "id",
           "name",
@@ -172,6 +197,7 @@
       }
     }
   },
+  "additionalProperties": false,
   "required": [
     "players",
     "games",

lib/core/common.dart

@@ -1,6 +1,7 @@
-import 'package:flutter/material.dart';
+import 'package:flutter/cupertino.dart';
 import 'package:tallee/core/enums.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 
 /// Translates a [Ruleset] enum value to its corresponding localized string.
@@ -20,51 +21,6 @@ String translateRulesetToString(Ruleset ruleset, BuildContext context) {
   }
 }
 
-/// Translates a [GameColor] enum value to its corresponding localized string.
-String translateGameColorToString(GameColor color, BuildContext context) {
-  final loc = AppLocalizations.of(context);
-  switch (color) {
-    case GameColor.red:
-      return loc.color_red;
-    case GameColor.blue:
-      return loc.color_blue;
-    case GameColor.green:
-      return loc.color_green;
-    case GameColor.yellow:
-      return loc.color_yellow;
-    case GameColor.purple:
-      return loc.color_purple;
-    case GameColor.orange:
-      return loc.color_orange;
-    case GameColor.pink:
-      return loc.color_pink;
-    case GameColor.teal:
-      return loc.color_teal;
-  }
-}
-
-/// Returns the [Color] object corresponding to a [GameColor] enum value.
-Color getColorFromGameColor(GameColor color) {
-  switch (color) {
-    case GameColor.red:
-      return Colors.red;
-    case GameColor.blue:
-      return Colors.blue;
-    case GameColor.green:
-      return Colors.green;
-    case GameColor.yellow:
-      return Colors.yellow;
-    case GameColor.purple:
-      return Colors.purple;
-    case GameColor.orange:
-      return Colors.orange;
-    case GameColor.pink:
-      return Colors.pink;
-    case GameColor.teal:
-      return Colors.teal;
-  }
-}
-
 /// Counts how many players in the match are not part of the group
 /// Returns the count as a string, or an empty string if there is no group
 String getExtraPlayerCount(Match match) {
@@ -88,3 +44,10 @@ String getExtraPlayerCount(Match match) {
   }
   return ' + ${count.toString()}';
 }
+
+String getNameCountText(Player player) {
+  if (player.nameCount >= 1) {
+    return ' #${player.nameCount}';
+  }
+  return '';
+}

lib/core/constants.dart

@@ -19,7 +19,4 @@ class Constants {
 
   /// Maximum length for team names
   static const int MAX_TEAM_NAME_LENGTH = 32;
-
-  /// Maximum length for game descriptions
-  static const int MAX_GAME_DESCRIPTION_LENGTH = 256;
 }

lib/data/dao/game_dao.dart

@@ -1,8 +1,8 @@
 import 'package:drift/drift.dart';
+import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/db/tables/game_table.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/models/game.dart';
-import 'package:tallee/core/enums.dart';
 
 part 'game_dao.g.dart';
 
@@ -111,14 +111,20 @@ class GameDao extends DatabaseAccessor<AppDatabase> with _$GameDaoMixin {
   }
 
   /// Updates the name of the game with the given [gameId] to [newName].
-  Future<void> updateGameName({required String gameId, required String newName}) async {
+  Future<void> updateGameName({
-    await (update(
+    required String gameId,
-      gameTable,
+    required String newName,
-    )..where((g) => g.id.equals(gameId))).write(GameTableCompanion(name: Value(newName)));
+  }) async {
+    await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
+      GameTableCompanion(name: Value(newName)),
+    );
   }
 
   /// Updates the ruleset of the game with the given [gameId].
-  Future<void> updateGameRuleset({required String gameId, required Ruleset newRuleset}) async {
+  Future<void> updateGameRuleset({
+    required String gameId,
+    required Ruleset newRuleset,
+  }) async {
     await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
       GameTableCompanion(ruleset: Value(newRuleset.name)),
     );
@@ -135,24 +141,31 @@ class GameDao extends DatabaseAccessor<AppDatabase> with _$GameDaoMixin {
   }
 
   /// Updates the color of the game with the given [gameId].
-  Future<void> updateGameColor({required String gameId, required GameColor newColor}) async {
+  Future<void> updateGameColor({
-    await (update(
+    required String gameId,
-      gameTable,
+    required GameColor newColor,
-    )..where((g) => g.id.equals(gameId))).write(GameTableCompanion(color: Value(newColor.name)));
+  }) async {
+    await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
+      GameTableCompanion(color: Value(newColor.name)),
+    );
   }
 
   /// Updates the icon of the game with the given [gameId].
-  Future<void> updateGameIcon({required String gameId, required String newIcon}) async {
+  Future<void> updateGameIcon({
-    await (update(
+    required String gameId,
-      gameTable,
+    required String newIcon,
-    )..where((g) => g.id.equals(gameId))).write(GameTableCompanion(icon: Value(newIcon)));
+  }) async {
+    await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
+      GameTableCompanion(icon: Value(newIcon)),
+    );
   }
 
   /// Retrieves the total count of games in the database.
   Future<int> getGameCount() async {
-    final count = await (selectOnly(
+    final count =
-      gameTable,
+        await (selectOnly(gameTable)..addColumns([gameTable.id.count()]))
-    )..addColumns([gameTable.id.count()])).map((row) => row.read(gameTable.id.count())).getSingle();
+            .map((row) => row.read(gameTable.id.count()))
+            .getSingle();
     return count ?? 0;
   }
 

lib/data/dao/game_dao.g.dart

@@ -5,4 +5,12 @@ part of 'game_dao.dart';
 // ignore_for_file: type=lint
 mixin _$GameDaoMixin on DatabaseAccessor<AppDatabase> {
   $GameTableTable get gameTable => attachedDatabase.gameTable;
+  GameDaoManager get managers => GameDaoManager(this);
+}
+
+class GameDaoManager {
+  final _$GameDaoMixin _db;
+  GameDaoManager(this._db);
+  $$GameTableTableTableManager get gameTable =>
+      $$GameTableTableTableManager(_db.attachedDatabase, _db.gameTable);
 }

lib/data/dao/group_dao.dart

@@ -1,13 +1,14 @@
 import 'package:drift/drift.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/db/tables/group_table.dart';
+import 'package:tallee/data/db/tables/match_table.dart';
 import 'package:tallee/data/db/tables/player_group_table.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 
 part 'group_dao.g.dart';
 
-@DriftAccessor(tables: [GroupTable, PlayerGroupTable])
+@DriftAccessor(tables: [GroupTable, PlayerGroupTable, MatchTable])
 class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
   GroupDao(super.db);
 
@@ -205,8 +206,6 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
     return rowsAffected > 0;
   }
 
-
-
   /// Retrieves the number of groups in the database.
   Future<int> getGroupCount() async {
     final count =
@@ -235,10 +234,13 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
   /// Replaces all players in a group with the provided list of players.
   /// Removes all existing players from the group and adds the new players.
   /// Also adds any new players to the player table if they don't exist.
-  Future<void> replaceGroupPlayers({
+  /// Returns `true` if the group exists and players were replaced, `false` otherwise.
+  Future<bool> replaceGroupPlayers({
     required String groupId,
     required List<Player> newPlayers,
   }) async {
+    if (!await groupExists(groupId: groupId)) return false;
+
     await db.transaction(() async {
       // Remove all existing players from the group
       final deleteQuery = delete(db.playerGroupTable)
@@ -270,5 +272,6 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
         ),
       );
     });
+    return true;
   }
 }

lib/data/dao/group_dao.g.dart

@@ -8,4 +8,25 @@ mixin _$GroupDaoMixin on DatabaseAccessor<AppDatabase> {
   $PlayerTableTable get playerTable => attachedDatabase.playerTable;
   $PlayerGroupTableTable get playerGroupTable =>
       attachedDatabase.playerGroupTable;
+  $GameTableTable get gameTable => attachedDatabase.gameTable;
+  $MatchTableTable get matchTable => attachedDatabase.matchTable;
+  GroupDaoManager get managers => GroupDaoManager(this);
+}
+
+class GroupDaoManager {
+  final _$GroupDaoMixin _db;
+  GroupDaoManager(this._db);
+  $$GroupTableTableTableManager get groupTable =>
+      $$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
+  $$PlayerTableTableTableManager get playerTable =>
+      $$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
+  $$PlayerGroupTableTableTableManager get playerGroupTable =>
+      $$PlayerGroupTableTableTableManager(
+        _db.attachedDatabase,
+        _db.playerGroupTable,
+      );
+  $$GameTableTableTableManager get gameTable =>
+      $$GameTableTableTableManager(_db.attachedDatabase, _db.gameTable);
+  $$MatchTableTableTableManager get matchTable =>
+      $$MatchTableTableTableManager(_db.attachedDatabase, _db.matchTable);
 }

lib/data/dao/match_dao.dart

@@ -4,10 +4,10 @@ import 'package:tallee/data/db/tables/game_table.dart';
 import 'package:tallee/data/db/tables/group_table.dart';
 import 'package:tallee/data/db/tables/match_table.dart';
 import 'package:tallee/data/db/tables/player_match_table.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/models/game.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 
 part 'match_dao.g.dart';
 
@@ -29,16 +29,22 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
         }
         final players =
             await db.playerMatchDao.getPlayersOfMatch(matchId: row.id) ?? [];
-        final winner = await getWinner(matchId: row.id);
+
+        final scores = await db.scoreEntryDao.getAllMatchScores(
+          matchId: row.id,
+        );
+
+        final winner = await db.scoreEntryDao.getWinner(matchId: row.id);
         return Match(
           id: row.id,
-          name: row.name ?? '',
+          name: row.name,
           game: game,
           group: group,
           players: players,
           notes: row.notes ?? '',
           createdAt: row.createdAt,
           endedAt: row.endedAt,
+          scores: scores,
           winner: winner,
         );
       }),
@@ -60,17 +66,20 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
     final players =
         await db.playerMatchDao.getPlayersOfMatch(matchId: matchId) ?? [];
 
-    final winner = await getWinner(matchId: matchId);
+    final scores = await db.scoreEntryDao.getAllMatchScores(matchId: matchId);
+
+    final winner = await db.scoreEntryDao.getWinner(matchId: matchId);
 
     return Match(
       id: result.id,
-      name: result.name ?? '',
+      name: result.name,
       game: game,
       group: group,
       players: players,
       notes: result.notes ?? '',
       createdAt: result.createdAt,
       endedAt: result.endedAt,
+      scores: scores,
       winner: winner,
     );
   }
@@ -85,7 +94,7 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
           id: match.id,
           gameId: match.game.id,
           groupId: Value(match.group?.id),
-          name: Value(match.name),
+          name: match.name,
           notes: Value(match.notes),
           createdAt: match.createdAt,
           endedAt: Value(match.endedAt),
@@ -100,8 +109,20 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
         );
       }
 
+      for (final pid in match.scores.keys) {
+        final playerScores = match.scores[pid]!;
+        await db.scoreEntryDao.addScoresAsList(
+          entrys: playerScores,
+          playerId: pid,
+          matchId: match.id,
+        );
+      }
+
       if (match.winner != null) {
-        await setWinner(matchId: match.id, winnerId: match.winner!.id);
+        await db.scoreEntryDao.setWinner(
+          matchId: match.id,
+          playerId: match.winner!.id,
+        );
       }
     });
   }
@@ -170,7 +191,7 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
                   id: match.id,
                   gameId: match.game.id,
                   groupId: Value(match.group?.id),
-                  name: Value(match.name),
+                  name: match.name,
                   notes: Value(match.notes),
                   createdAt: match.createdAt,
                   endedAt: Value(match.endedAt),
@@ -223,7 +244,6 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
               PlayerMatchTableCompanion.insert(
                 matchId: match.id,
                 playerId: p.id,
-                score: 0,
               ),
               mode: InsertMode.insertOrIgnore,
             );
@@ -268,6 +288,34 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
     return count ?? 0;
   }
 
+  /// Retrieves all matches associated with the given [groupId].
+  /// Queries the database directly, filtering by [groupId].
+  Future<List<Match>> getGroupMatches({required String groupId}) async {
+    final query = select(matchTable)..where((m) => m.groupId.equals(groupId));
+    final rows = await query.get();
+
+    return Future.wait(
+      rows.map((row) async {
+        final game = await db.gameDao.getGameById(gameId: row.gameId);
+        final group = await db.groupDao.getGroupById(groupId: groupId);
+        final players =
+            await db.playerMatchDao.getPlayersOfMatch(matchId: row.id) ?? [];
+        final winner = await db.scoreEntryDao.getWinner(matchId: row.id);
+        return Match(
+          id: row.id,
+          name: row.name,
+          game: game,
+          group: group,
+          players: players,
+          notes: row.notes ?? '',
+          createdAt: row.createdAt,
+          endedAt: row.endedAt,
+          winner: winner,
+        );
+      }),
+    );
+  }
+
   /// Checks if a match with the given [matchId] exists in the database.
   /// Returns `true` if the match exists, otherwise `false`.
   Future<bool> matchExists({required String matchId}) async {
@@ -338,6 +386,17 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
     return rowsAffected > 0;
   }
 
+  /// Removes the group association of the match with the given [matchId].
+  /// Sets the groupId to null.
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> removeMatchGroup({required String matchId}) async {
+    final query = update(matchTable)..where((g) => g.id.equals(matchId));
+    final rowsAffected = await query.write(
+      const MatchTableCompanion(groupId: Value(null)),
+    );
+    return rowsAffected > 0;
+  }
+
   /// Updates the createdAt timestamp of the match with the given [matchId].
   /// Returns `true` if more than 0 rows were affected, otherwise `false`.
   Future<bool> updateMatchCreatedAt({
@@ -398,91 +457,4 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
       );
     });
   }
-
-  // ============================================================
-  // Winner methods - handle winner logic via player scores
-  // ============================================================
-
-  /// Checks if a match has a winner.
-  /// Returns true if any player in the match has their score set to 1.
-  Future<bool> hasWinner({required String matchId}) async {
-    final players =
-        await db.playerMatchDao.getPlayersOfMatch(matchId: matchId) ?? [];
-
-    for (final player in players) {
-      final score = await db.playerMatchDao.getPlayerScore(
-        matchId: matchId,
-        playerId: player.id,
-      );
-      if (score == 1) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /// Gets the winner of a match.
-  /// Returns the player with score 1, or null if no winner is set.
-  Future<Player?> getWinner({required String matchId}) async {
-    final players =
-        await db.playerMatchDao.getPlayersOfMatch(matchId: matchId) ?? [];
-
-    for (final player in players) {
-      final score = await db.playerMatchDao.getPlayerScore(
-        matchId: matchId,
-        playerId: player.id,
-      );
-      if (score == 1) {
-        return player;
-      }
-    }
-    return null;
-  }
-
-  /// Sets the winner of a match.
-  /// Sets all players' scores to 0, then sets the specified player's score to 1.
-  /// Returns `true` if the operation was successful, otherwise `false`.
-  Future<bool> setWinner({
-    required String matchId,
-    required String winnerId,
-  }) async {
-    await db.transaction(() async {
-      final players =
-          await db.playerMatchDao.getPlayersOfMatch(matchId: matchId) ?? [];
-
-      // Set all players' scores to 0
-      for (final player in players) {
-        await db.playerMatchDao.updatePlayerScore(
-          matchId: matchId,
-          playerId: player.id,
-          newScore: 0,
-        );
-      }
-
-      // Set the winner's score to 1
-      await db.playerMatchDao.updatePlayerScore(
-        matchId: matchId,
-        playerId: winnerId,
-        newScore: 1,
-      );
-    });
-    return true;
-  }
-
-  /// Removes the winner of a match.
-  /// Sets the current winner's score to 0 (no winner).
-  /// Returns `true` if a winner was removed, otherwise `false`.
-  Future<bool> removeWinner({required String matchId}) async {
-    final winner = await getWinner(matchId: matchId);
-    if (winner == null) {
-      return false;
-    }
-
-    final success = await db.playerMatchDao.updatePlayerScore(
-      matchId: matchId,
-      playerId: winner.id,
-      newScore: 0,
-    );
-    return success;
-  }
 }

lib/data/dao/match_dao.g.dart

@@ -11,4 +11,25 @@ mixin _$MatchDaoMixin on DatabaseAccessor<AppDatabase> {
   $TeamTableTable get teamTable => attachedDatabase.teamTable;
   $PlayerMatchTableTable get playerMatchTable =>
       attachedDatabase.playerMatchTable;
+  MatchDaoManager get managers => MatchDaoManager(this);
+}
+
+class MatchDaoManager {
+  final _$MatchDaoMixin _db;
+  MatchDaoManager(this._db);
+  $$GameTableTableTableManager get gameTable =>
+      $$GameTableTableTableManager(_db.attachedDatabase, _db.gameTable);
+  $$GroupTableTableTableManager get groupTable =>
+      $$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
+  $$MatchTableTableTableManager get matchTable =>
+      $$MatchTableTableTableManager(_db.attachedDatabase, _db.matchTable);
+  $$PlayerTableTableTableManager get playerTable =>
+      $$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
+  $$TeamTableTableTableManager get teamTable =>
+      $$TeamTableTableTableManager(_db.attachedDatabase, _db.teamTable);
+  $$PlayerMatchTableTableTableManager get playerMatchTable =>
+      $$PlayerMatchTableTableTableManager(
+        _db.attachedDatabase,
+        _db.playerMatchTable,
+      );
 }

lib/data/dao/player_dao.dart

@@ -1,7 +1,8 @@
 import 'package:drift/drift.dart';
+import 'package:flutter/cupertino.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/db/tables/player_table.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 
 part 'player_dao.g.dart';
 
@@ -20,6 +21,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
             name: row.name,
             description: row.description,
             createdAt: row.createdAt,
+            nameCount: row.nameCount,
           ),
         )
         .toList();
@@ -34,6 +36,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
       name: result.name,
       description: result.description,
       createdAt: result.createdAt,
+      nameCount: result.nameCount,
     );
   }
 
@@ -42,12 +45,15 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
   /// the new one.
   Future<bool> addPlayer({required Player player}) async {
     if (!await playerExists(playerId: player.id)) {
+      final int nameCount = await calculateNameCount(name: player.name);
+
       await into(playerTable).insert(
         PlayerTableCompanion.insert(
           id: player.id,
           name: player.name,
           description: player.description,
           createdAt: player.createdAt,
+          nameCount: Value(nameCount),
         ),
         mode: InsertMode.insertOrReplace,
       );
@@ -62,20 +68,67 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
   Future<bool> addPlayersAsList({required List<Player> players}) async {
     if (players.isEmpty) return false;
 
+    // Filter out players that already exist
+    final newPlayers = <Player>[];
+    for (final player in players) {
+      if (!await playerExists(playerId: player.id)) {
+        newPlayers.add(player);
+      }
+    }
+
+    if (newPlayers.isEmpty) return false;
+
+    // Group players by name
+    final nameGroups = <String, List<Player>>{};
+    for (final player in newPlayers) {
+      nameGroups.putIfAbsent(player.name, () => []).add(player);
+    }
+
+    final playersToInsert = <PlayerTableCompanion>[];
+
+    // Process each group of players with the same name
+    for (final entry in nameGroups.entries) {
+      final name = entry.key;
+      final playersWithName = entry.value;
+
+      // Get the current nameCount
+      var nameCount = await calculateNameCount(name: name);
+
+      // One player with the same name
+      if (playersWithName.length == 1) {
+        final player = playersWithName[0];
+        playersToInsert.add(
+          PlayerTableCompanion.insert(
+            id: player.id,
+            name: player.name,
+            description: player.description,
+            createdAt: player.createdAt,
+            nameCount: Value(nameCount),
+          ),
+        );
+      } else {
+        if (nameCount == 0) nameCount++;
+        // Multiple players with the same name
+        for (var i = 0; i < playersWithName.length; i++) {
+          final player = playersWithName[i];
+          playersToInsert.add(
+            PlayerTableCompanion.insert(
+              id: player.id,
+              name: player.name,
+              description: player.description,
+              createdAt: player.createdAt,
+              nameCount: Value(nameCount + i),
+            ),
+          );
+        }
+      }
+    }
+
     await db.batch(
       (b) => b.insertAll(
         playerTable,
-        players
+        playersToInsert,
-            .map(
+        mode: InsertMode.insertOrReplace,
-              (player) => PlayerTableCompanion.insert(
-                id: player.id,
-                name: player.name,
-                description: player.description,
-                createdAt: player.createdAt,
-              ),
-            )
-            .toList(),
-        mode: InsertMode.insertOrIgnore,
       ),
     );
 
@@ -90,7 +143,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
     return rowsAffected > 0;
   }
 
-  /// Checks if a player with the given [id] exists in the database.
+  /// Checks if a player with the given [playerId] exists in the database.
   /// Returns `true` if the player exists, `false` otherwise.
   Future<bool> playerExists({required String playerId}) async {
     final query = select(playerTable)..where((p) => p.id.equals(playerId));
@@ -103,9 +156,38 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
     required String playerId,
     required String newName,
   }) async {
+    // Get previous name and name count for the player before updating
+    final previousPlayerName =
+        await (select(playerTable)..where((p) => p.id.equals(playerId)))
+            .map((row) => row.name)
+            .getSingleOrNull() ??
+        '';
+    final previousNameCount = await getNameCount(name: previousPlayerName);
+
     await (update(playerTable)..where((p) => p.id.equals(playerId))).write(
       PlayerTableCompanion(name: Value(newName)),
     );
+
+    // Update name count for the new name
+    final count = await calculateNameCount(name: newName);
+    if (count > 0) {
+      await (update(playerTable)..where((p) => p.name.equals(newName))).write(
+        PlayerTableCompanion(nameCount: Value(count)),
+      );
+    }
+
+    if (previousNameCount > 0) {
+      // Get the player with that name and the hightest nameCount, and update their nameCount to previousNameCount
+      final player = await getPlayerWithHighestNameCount(
+        name: previousPlayerName,
+      );
+      if (player != null) {
+        await updateNameCount(
+          playerId: player.id,
+          nameCount: previousNameCount,
+        );
+      }
+    }
   }
 
   /// Retrieves the total count of players in the database.
@@ -117,6 +199,76 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
     return count ?? 0;
   }
 
+  /// Retrieves the count of players with the given [name].
+  Future<int> getNameCount({required String name}) async {
+    final query = select(playerTable)..where((p) => p.name.equals(name));
+    final result = await query.get();
+    return result.length;
+  }
+
+  /// Updates the nameCount for the player with the given [playerId] to [nameCount].
+  /// Returns `true` if more than 0 rows were affected, otherwise `false`.
+  Future<bool> updateNameCount({
+    required String playerId,
+    required int nameCount,
+  }) async {
+    final query = update(playerTable)..where((p) => p.id.equals(playerId));
+    final rowsAffected = await query.write(
+      PlayerTableCompanion(nameCount: Value(nameCount)),
+    );
+    return rowsAffected > 0;
+  }
+
+  @visibleForTesting
+  Future<Player?> getPlayerWithHighestNameCount({required String name}) async {
+    final query = select(playerTable)
+      ..where((p) => p.name.equals(name))
+      ..orderBy([(p) => OrderingTerm.desc(p.nameCount)])
+      ..limit(1);
+    final result = await query.getSingleOrNull();
+    if (result != null) {
+      return Player(
+        id: result.id,
+        name: result.name,
+        description: result.description,
+        createdAt: result.createdAt,
+        nameCount: result.nameCount,
+      );
+    }
+    return null;
+  }
+
+  @visibleForTesting
+  Future<int> calculateNameCount({required String name}) async {
+    final count = await getNameCount(name: name);
+    final int nameCount;
+
+    if (count == 1) {
+      // If one other player exists with the same name, initialize the nameCount
+      await initializeNameCount(name: name);
+      // And for the new player, set nameCount to 2
+      nameCount = 2;
+    } else if (count > 1) {
+      // If more than one player exists with the same name, just increment
+      // the nameCount for the new player
+      nameCount = count + 1;
+    } else {
+      // If no other players exist with the same name, set nameCount to 0
+      nameCount = 0;
+    }
+
+    return nameCount;
+  }
+
+  @visibleForTesting
+  Future<bool> initializeNameCount({required String name}) async {
+    final rowsAffected =
+        await (update(playerTable)..where((p) => p.name.equals(name))).write(
+          const PlayerTableCompanion(nameCount: Value(1)),
+        );
+    return rowsAffected > 0;
+  }
+
   /// Deletes all players from the database.
   /// Returns `true` if more than 0 rows were affected, otherwise `false`.
   Future<bool> deleteAllPlayers() async {

lib/data/dao/player_dao.g.dart

@@ -5,4 +5,12 @@ part of 'player_dao.dart';
 // ignore_for_file: type=lint
 mixin _$PlayerDaoMixin on DatabaseAccessor<AppDatabase> {
   $PlayerTableTable get playerTable => attachedDatabase.playerTable;
+  PlayerDaoManager get managers => PlayerDaoManager(this);
+}
+
+class PlayerDaoManager {
+  final _$PlayerDaoMixin _db;
+  PlayerDaoManager(this._db);
+  $$PlayerTableTableTableManager get playerTable =>
+      $$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
 }

lib/data/dao/player_group_dao.dart

@@ -2,7 +2,7 @@ import 'package:drift/drift.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/db/tables/player_group_table.dart';
 import 'package:tallee/data/db/tables/player_table.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 
 part 'player_group_dao.g.dart';
 

lib/data/dao/player_group_dao.g.dart

@@ -8,4 +8,19 @@ mixin _$PlayerGroupDaoMixin on DatabaseAccessor<AppDatabase> {
   $GroupTableTable get groupTable => attachedDatabase.groupTable;
   $PlayerGroupTableTable get playerGroupTable =>
       attachedDatabase.playerGroupTable;
+  PlayerGroupDaoManager get managers => PlayerGroupDaoManager(this);
+}
+
+class PlayerGroupDaoManager {
+  final _$PlayerGroupDaoMixin _db;
+  PlayerGroupDaoManager(this._db);
+  $$PlayerTableTableTableManager get playerTable =>
+      $$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
+  $$GroupTableTableTableManager get groupTable =>
+      $$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
+  $$PlayerGroupTableTableTableManager get playerGroupTable =>
+      $$PlayerGroupTableTableTableManager(
+        _db.attachedDatabase,
+        _db.playerGroupTable,
+      );
 }

lib/data/dao/player_match_dao.dart

@@ -2,7 +2,7 @@ import 'package:drift/drift.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/db/tables/player_match_table.dart';
 import 'package:tallee/data/db/tables/team_table.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 
 part 'player_match_dao.g.dart';
 
@@ -17,14 +17,12 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
     required String matchId,
     required String playerId,
     String? teamId,
-    int score = 0,
   }) async {
     await into(playerMatchTable).insert(
       PlayerMatchTableCompanion.insert(
         playerId: playerId,
         matchId: matchId,
         teamId: Value(teamId),
-        score: score,
       ),
       mode: InsertMode.insertOrIgnore,
     );
@@ -40,41 +38,12 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
     if (result.isEmpty) return null;
 
     final futures = result.map(
-          (row) => db.playerDao.getPlayerById(playerId: row.playerId),
+      (row) => db.playerDao.getPlayerById(playerId: row.playerId),
     );
     final players = await Future.wait(futures);
     return players;
   }
 
-  /// Retrieves a player's score for a specific match.
-  /// Returns null if the player is not in the match.
-  Future<int?> getPlayerScore({
-    required String matchId,
-    required String playerId,
-  }) async {
-    final result = await (select(playerMatchTable)
-      ..where(
-            (p) => p.matchId.equals(matchId) & p.playerId.equals(playerId),
-      ))
-        .getSingleOrNull();
-    return result?.score;
-  }
-
-  /// Updates the score for a player in a match.
-  /// Returns `true` if the update was successful, otherwise `false`.
-  Future<bool> updatePlayerScore({
-    required String matchId,
-    required String playerId,
-    required int newScore,
-  }) async {
-    final rowsAffected = await (update(playerMatchTable)
-      ..where(
-            (p) => p.matchId.equals(matchId) & p.playerId.equals(playerId),
-      ))
-        .write(PlayerMatchTableCompanion(score: Value(newScore)));
-    return rowsAffected > 0;
-  }
-
   /// Updates the team for a player in a match.
   /// Returns `true` if the update was successful, otherwise `false`.
   Future<bool> updatePlayerTeam({
@@ -82,11 +51,11 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
     required String playerId,
     required String? teamId,
   }) async {
-    final rowsAffected = await (update(playerMatchTable)
+    final rowsAffected =
-      ..where(
+        await (update(playerMatchTable)..where(
-            (p) => p.matchId.equals(matchId) & p.playerId.equals(playerId),
+              (p) => p.matchId.equals(matchId) & p.playerId.equals(playerId),
-      ))
+            ))
-        .write(PlayerMatchTableCompanion(teamId: Value(teamId)));
+            .write(PlayerMatchTableCompanion(teamId: Value(teamId)));
     return rowsAffected > 0;
   }
 
@@ -94,11 +63,11 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
   /// Returns `true` if there are players, otherwise `false`.
   Future<bool> matchHasPlayers({required String matchId}) async {
     final count =
-    await (selectOnly(playerMatchTable)
+        await (selectOnly(playerMatchTable)
-      ..where(playerMatchTable.matchId.equals(matchId))
+              ..where(playerMatchTable.matchId.equals(matchId))
-      ..addColumns([playerMatchTable.playerId.count()]))
+              ..addColumns([playerMatchTable.playerId.count()]))
-        .map((row) => row.read(playerMatchTable.playerId.count()))
+            .map((row) => row.read(playerMatchTable.playerId.count()))
-        .getSingle();
+            .getSingle();
     return (count ?? 0) > 0;
   }
 
@@ -109,12 +78,12 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
     required String playerId,
   }) async {
     final count =
-    await (selectOnly(playerMatchTable)
+        await (selectOnly(playerMatchTable)
-      ..where(playerMatchTable.matchId.equals(matchId))
+              ..where(playerMatchTable.matchId.equals(matchId))
-      ..where(playerMatchTable.playerId.equals(playerId))
+              ..where(playerMatchTable.playerId.equals(playerId))
-      ..addColumns([playerMatchTable.playerId.count()]))
+              ..addColumns([playerMatchTable.playerId.count()]))
-        .map((row) => row.read(playerMatchTable.playerId.count()))
+            .map((row) => row.read(playerMatchTable.playerId.count()))
-        .getSingle();
+            .getSingle();
     return (count ?? 0) > 0;
   }
 
@@ -153,9 +122,9 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
       if (playersToRemove.isNotEmpty) {
         await (delete(playerMatchTable)..where(
               (pg) =>
-          pg.matchId.equals(matchId) &
+                  pg.matchId.equals(matchId) &
-          pg.playerId.isIn(playersToRemove.toList()),
+                  pg.playerId.isIn(playersToRemove.toList()),
-        ))
+            ))
             .go();
       }
 
@@ -164,15 +133,14 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
         final inserts = playersToAdd
             .map(
               (id) => PlayerMatchTableCompanion.insert(
-            playerId: id,
+                playerId: id,
-            matchId: matchId,
+                matchId: matchId,
-            score: 0,
+              ),
-          ),
+            )
-        )
             .toList();
         await Future.wait(
           inserts.map(
-                (c) => into(
+            (c) => into(
               playerMatchTable,
             ).insert(c, mode: InsertMode.insertOrIgnore),
           ),
@@ -186,16 +154,14 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
     required String matchId,
     required String teamId,
   }) async {
-    final result = await (select(playerMatchTable)
+    final result = await (select(
-      ..where(
+      playerMatchTable,
-            (p) => p.matchId.equals(matchId) & p.teamId.equals(teamId),
+    )..where((p) => p.matchId.equals(matchId) & p.teamId.equals(teamId))).get();
-      ))
-        .get();
 
     if (result.isEmpty) return [];
 
     final futures = result.map(
-          (row) => db.playerDao.getPlayerById(playerId: row.playerId),
+      (row) => db.playerDao.getPlayerById(playerId: row.playerId),
     );
     return Future.wait(futures);
   }

lib/data/dao/player_match_dao.g.dart

@@ -11,4 +11,25 @@ mixin _$PlayerMatchDaoMixin on DatabaseAccessor<AppDatabase> {
   $TeamTableTable get teamTable => attachedDatabase.teamTable;
   $PlayerMatchTableTable get playerMatchTable =>
       attachedDatabase.playerMatchTable;
+  PlayerMatchDaoManager get managers => PlayerMatchDaoManager(this);
+}
+
+class PlayerMatchDaoManager {
+  final _$PlayerMatchDaoMixin _db;
+  PlayerMatchDaoManager(this._db);
+  $$PlayerTableTableTableManager get playerTable =>
+      $$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
+  $$GameTableTableTableManager get gameTable =>
+      $$GameTableTableTableManager(_db.attachedDatabase, _db.gameTable);
+  $$GroupTableTableTableManager get groupTable =>
+      $$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
+  $$MatchTableTableTableManager get matchTable =>
+      $$MatchTableTableTableManager(_db.attachedDatabase, _db.matchTable);
+  $$TeamTableTableTableManager get teamTable =>
+      $$TeamTableTableTableManager(_db.attachedDatabase, _db.teamTable);
+  $$PlayerMatchTableTableTableManager get playerMatchTable =>
+      $$PlayerMatchTableTableTableManager(
+        _db.attachedDatabase,
+        _db.playerMatchTable,
+      );
 }

lib/data/dao/score_dao.dart

@@ -1,191 +0,0 @@
-import 'package:drift/drift.dart';
-import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/db/tables/score_table.dart';
-
-part 'score_dao.g.dart';
-
-/// A data class representing a score entry.
-class ScoreEntry {
-  final String playerId;
-  final String matchId;
-  final int roundNumber;
-  final int score;
-  final int change;
-
-  ScoreEntry({
-    required this.playerId,
-    required this.matchId,
-    required this.roundNumber,
-    required this.score,
-    required this.change,
-  });
-}
-
-@DriftAccessor(tables: [ScoreTable])
-class ScoreDao extends DatabaseAccessor<AppDatabase> with _$ScoreDaoMixin {
-  ScoreDao(super.db);
-
-  /// Adds a score entry to the database.
-  Future<void> addScore({
-    required String playerId,
-    required String matchId,
-    required int roundNumber,
-    required int score,
-    required int change,
-  }) async {
-    await into(scoreTable).insert(
-      ScoreTableCompanion.insert(
-        playerId: playerId,
-        matchId: matchId,
-        roundNumber: roundNumber,
-        score: score,
-        change: change,
-      ),
-      mode: InsertMode.insertOrReplace,
-    );
-  }
-
-  /// Retrieves all scores for a specific match.
-  Future<List<ScoreEntry>> getScoresForMatch({required String matchId}) async {
-    final query = select(scoreTable)..where((s) => s.matchId.equals(matchId));
-    final result = await query.get();
-    return result
-        .map(
-          (row) => ScoreEntry(
-            playerId: row.playerId,
-            matchId: row.matchId,
-            roundNumber: row.roundNumber,
-            score: row.score,
-            change: row.change,
-          ),
-        )
-        .toList();
-  }
-
-  /// Retrieves all scores for a specific player in a match.
-  Future<List<ScoreEntry>> getPlayerScoresInMatch({
-    required String playerId,
-    required String matchId,
-  }) async {
-    final query = select(scoreTable)
-      ..where(
-        (s) => s.playerId.equals(playerId) & s.matchId.equals(matchId),
-      )
-      ..orderBy([(s) => OrderingTerm.asc(s.roundNumber)]);
-    final result = await query.get();
-    return result
-        .map(
-          (row) => ScoreEntry(
-            playerId: row.playerId,
-            matchId: row.matchId,
-            roundNumber: row.roundNumber,
-            score: row.score,
-            change: row.change,
-          ),
-        )
-        .toList();
-  }
-
-  /// Retrieves the score for a specific round.
-  Future<ScoreEntry?> getScoreForRound({
-    required String playerId,
-    required String matchId,
-    required int roundNumber,
-  }) async {
-    final query = select(scoreTable)
-      ..where(
-        (s) =>
-            s.playerId.equals(playerId) &
-            s.matchId.equals(matchId) &
-            s.roundNumber.equals(roundNumber),
-      );
-    final result = await query.getSingleOrNull();
-    if (result == null) return null;
-    return ScoreEntry(
-      playerId: result.playerId,
-      matchId: result.matchId,
-      roundNumber: result.roundNumber,
-      score: result.score,
-      change: result.change,
-    );
-  }
-
-  /// Updates a score entry.
-  Future<bool> updateScore({
-    required String playerId,
-    required String matchId,
-    required int roundNumber,
-    required int newScore,
-    required int newChange,
-  }) async {
-    final rowsAffected = await (update(scoreTable)
-          ..where(
-            (s) =>
-                s.playerId.equals(playerId) &
-                s.matchId.equals(matchId) &
-                s.roundNumber.equals(roundNumber),
-          ))
-        .write(
-          ScoreTableCompanion(
-            score: Value(newScore),
-            change: Value(newChange),
-          ),
-        );
-    return rowsAffected > 0;
-  }
-
-  /// Deletes a score entry.
-  Future<bool> deleteScore({
-    required String playerId,
-    required String matchId,
-    required int roundNumber,
-  }) async {
-    final query = delete(scoreTable)
-      ..where(
-        (s) =>
-            s.playerId.equals(playerId) &
-            s.matchId.equals(matchId) &
-            s.roundNumber.equals(roundNumber),
-      );
-    final rowsAffected = await query.go();
-    return rowsAffected > 0;
-  }
-
-  /// Deletes all scores for a specific match.
-  Future<bool> deleteScoresForMatch({required String matchId}) async {
-    final query = delete(scoreTable)..where((s) => s.matchId.equals(matchId));
-    final rowsAffected = await query.go();
-    return rowsAffected > 0;
-  }
-
-  /// Deletes all scores for a specific player.
-  Future<bool> deleteScoresForPlayer({required String playerId}) async {
-    final query = delete(scoreTable)..where((s) => s.playerId.equals(playerId));
-    final rowsAffected = await query.go();
-    return rowsAffected > 0;
-  }
-
-  /// Gets the latest round number for a match.
-  Future<int> getLatestRoundNumber({required String matchId}) async {
-    final query = selectOnly(scoreTable)
-      ..where(scoreTable.matchId.equals(matchId))
-      ..addColumns([scoreTable.roundNumber.max()]);
-    final result = await query.getSingle();
-    return result.read(scoreTable.roundNumber.max()) ?? 0;
-  }
-
-  /// Gets the total score for a player in a match (sum of all changes).
-  Future<int> getTotalScoreForPlayer({
-    required String playerId,
-    required String matchId,
-  }) async {
-    final scores = await getPlayerScoresInMatch(
-      playerId: playerId,
-      matchId: matchId,
-    );
-    if (scores.isEmpty) return 0;
-    // Return the score from the latest round
-    return scores.last.score;
-  }
-}
-

lib/data/dao/score_dao.g.dart

@@ -1,12 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'score_dao.dart';
-
-// ignore_for_file: type=lint
-mixin _$ScoreDaoMixin on DatabaseAccessor<AppDatabase> {
-  $PlayerTableTable get playerTable => attachedDatabase.playerTable;
-  $GameTableTable get gameTable => attachedDatabase.gameTable;
-  $GroupTableTable get groupTable => attachedDatabase.groupTable;
-  $MatchTableTable get matchTable => attachedDatabase.matchTable;
-  $ScoreTableTable get scoreTable => attachedDatabase.scoreTable;
-}

lib/data/dao/score_entry_dao.dart

@@ -0,0 +1,328 @@
+import 'dart:async';
+
+import 'package:drift/drift.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/db/tables/score_entry_table.dart';
+import 'package:tallee/data/models/player.dart';
+import 'package:tallee/data/models/score_entry.dart';
+
+part 'score_entry_dao.g.dart';
+
+@DriftAccessor(tables: [ScoreEntryTable])
+class ScoreEntryDao extends DatabaseAccessor<AppDatabase>
+    with _$ScoreEntryDaoMixin {
+  ScoreEntryDao(super.db);
+
+  /// Adds a score entry to the database.
+  Future<void> addScore({
+    required String playerId,
+    required String matchId,
+    required ScoreEntry entry,
+  }) async {
+    await into(scoreEntryTable).insert(
+      ScoreEntryTableCompanion.insert(
+        playerId: playerId,
+        matchId: matchId,
+        roundNumber: entry.roundNumber,
+        score: entry.score,
+        change: entry.change,
+      ),
+      mode: InsertMode.insertOrReplace,
+    );
+  }
+
+  Future<void> addScoresAsList({
+    required List<ScoreEntry> entrys,
+    required String playerId,
+    required String matchId,
+  }) async {
+    if (entrys.isEmpty) return;
+    final entries = entrys
+        .map(
+          (score) => ScoreEntryTableCompanion.insert(
+            playerId: playerId,
+            matchId: matchId,
+            roundNumber: score.roundNumber,
+            score: score.score,
+            change: score.change,
+          ),
+        )
+        .toList();
+
+    await batch((batch) {
+      batch.insertAll(
+        scoreEntryTable,
+        entries,
+        mode: InsertMode.insertOrReplace,
+      );
+    });
+  }
+
+  /// Retrieves the score for a specific round.
+  Future<ScoreEntry?> getScore({
+    required String playerId,
+    required String matchId,
+    int roundNumber = 0,
+  }) async {
+    final query = select(scoreEntryTable)
+      ..where(
+        (s) =>
+            s.playerId.equals(playerId) &
+            s.matchId.equals(matchId) &
+            s.roundNumber.equals(roundNumber),
+      );
+
+    final result = await query.getSingleOrNull();
+    if (result == null) return null;
+
+    return ScoreEntry(
+      roundNumber: result.roundNumber,
+      score: result.score,
+      change: result.change,
+    );
+  }
+
+  /// Retrieves all scores for a specific match.
+  Future<Map<String, List<ScoreEntry>>> getAllMatchScores({
+    required String matchId,
+  }) async {
+    final query = select(scoreEntryTable)
+      ..where((s) => s.matchId.equals(matchId));
+    final result = await query.get();
+
+    final Map<String, List<ScoreEntry>> scoresByPlayer = {};
+    for (final row in result) {
+      final score = ScoreEntry(
+        roundNumber: row.roundNumber,
+        score: row.score,
+        change: row.change,
+      );
+      scoresByPlayer.putIfAbsent(row.playerId, () => []).add(score);
+    }
+
+    return scoresByPlayer;
+  }
+
+  /// Retrieves all scores for a specific player in a match.
+  Future<List<ScoreEntry>> getAllPlayerScoresInMatch({
+    required String playerId,
+    required String matchId,
+  }) async {
+    final query = select(scoreEntryTable)
+      ..where((s) => s.playerId.equals(playerId) & s.matchId.equals(matchId))
+      ..orderBy([(s) => OrderingTerm.asc(s.roundNumber)]);
+    final result = await query.get();
+    return result
+        .map(
+          (row) => ScoreEntry(
+            roundNumber: row.roundNumber,
+            score: row.score,
+            change: row.change,
+          ),
+        )
+        .toList()
+      ..sort(
+        (scoreA, scoreB) => scoreA.roundNumber.compareTo(scoreB.roundNumber),
+      );
+  }
+
+  /// Updates a score entry.
+  Future<bool> updateScore({
+    required String playerId,
+    required String matchId,
+    required ScoreEntry newEntry,
+  }) async {
+    final rowsAffected =
+        await (update(scoreEntryTable)..where(
+              (s) =>
+                  s.playerId.equals(playerId) &
+                  s.matchId.equals(matchId) &
+                  s.roundNumber.equals(newEntry.roundNumber),
+            ))
+            .write(
+              ScoreEntryTableCompanion(
+                score: Value(newEntry.score),
+                change: Value(newEntry.change),
+              ),
+            );
+    return rowsAffected > 0;
+  }
+
+  /// Deletes a score entry.
+  Future<bool> deleteScore({
+    required String playerId,
+    required String matchId,
+    int roundNumber = 0,
+  }) async {
+    final query = delete(scoreEntryTable)
+      ..where(
+        (s) =>
+            s.playerId.equals(playerId) &
+            s.matchId.equals(matchId) &
+            s.roundNumber.equals(roundNumber),
+      );
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  Future<bool> deleteAllScoresForMatch({required String matchId}) async {
+    final query = delete(scoreEntryTable)
+      ..where((s) => s.matchId.equals(matchId));
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  Future<bool> deleteAllScoresForPlayerInMatch({
+    required String matchId,
+    required String playerId,
+  }) async {
+    final query = delete(scoreEntryTable)
+      ..where((s) => s.playerId.equals(playerId) & s.matchId.equals(matchId));
+    final rowsAffected = await query.go();
+    return rowsAffected > 0;
+  }
+
+  /// Gets the highest (latest) round number for a match.
+  /// Returns `null` if there are no scores for the match.
+  Future<int?> getLatestRoundNumber({required String matchId}) async {
+    final query = selectOnly(scoreEntryTable)
+      ..where(scoreEntryTable.matchId.equals(matchId))
+      ..addColumns([scoreEntryTable.roundNumber.max()]);
+    final result = await query.getSingle();
+    return result.read(scoreEntryTable.roundNumber.max());
+  }
+
+  /// Aggregates the total score for a player in a match by summing all their
+  /// score entry changes. Returns `0` if there are no scores for the player
+  /// in the match.
+  Future<int> getTotalScoreForPlayer({
+    required String playerId,
+    required String matchId,
+  }) async {
+    final scores = await getAllPlayerScoresInMatch(
+      playerId: playerId,
+      matchId: matchId,
+    );
+    if (scores.isEmpty) return 0;
+    // Return the sum of all score changes
+    return scores.fold<int>(0, (sum, element) => sum + element.change);
+  }
+
+  Future<bool> hasWinner({required String matchId}) async {
+    return await getWinner(matchId: matchId) != null;
+  }
+
+  // Setting the winner for a game and clearing previous winner if exists.
+  Future<bool> setWinner({
+    required String matchId,
+    required String playerId,
+  }) async {
+    // Clear previous winner if exists
+    deleteAllScoresForMatch(matchId: matchId);
+
+    // Set the winner's score to 1
+    final rowsAffected = await into(scoreEntryTable).insert(
+      ScoreEntryTableCompanion.insert(
+        playerId: playerId,
+        matchId: matchId,
+        roundNumber: 0,
+        score: 1,
+        change: 0,
+      ),
+      mode: InsertMode.insertOrReplace,
+    );
+
+    return rowsAffected > 0;
+  }
+
+  // Retrieves the winner of a match based on the highest score.
+  Future<Player?> getWinner({required String matchId}) async {
+    final query = select(scoreEntryTable)
+      ..where((s) => s.matchId.equals(matchId))
+      ..orderBy([(s) => OrderingTerm.desc(s.score)])
+      ..limit(1);
+    final result = await query.getSingleOrNull();
+
+    if (result == null) return null;
+
+    final player = await db.playerDao.getPlayerById(playerId: result.playerId);
+    return Player(
+      id: player.id,
+      name: player.name,
+      createdAt: player.createdAt,
+      description: player.description,
+    );
+  }
+
+  /// Removes the winner of a match.
+  ///
+  /// Returns `true` if the winner was removed, `false` if there are multiple
+  /// scores or if the winner cannot be removed.
+  Future<bool> removeWinner({required String matchId}) async {
+    final scores = await getAllMatchScores(matchId: matchId);
+
+    if (scores.length > 1) {
+      return false;
+    } else {
+      return await deleteAllScoresForMatch(matchId: matchId);
+    }
+  }
+
+  Future<bool> hasLooser({required String matchId}) async {
+    return await getLooser(matchId: matchId) != null;
+  }
+
+  // Setting the looser for a game and clearing previous looser if exists.
+  Future<bool> setLooser({
+    required String matchId,
+    required String playerId,
+  }) async {
+    // Clear previous loosers if exists
+    deleteAllScoresForMatch(matchId: matchId);
+
+    // Set the loosers score to 0
+    final rowsAffected = await into(scoreEntryTable).insert(
+      ScoreEntryTableCompanion.insert(
+        playerId: playerId,
+        matchId: matchId,
+        roundNumber: 0,
+        score: 0,
+        change: 0,
+      ),
+      mode: InsertMode.insertOrReplace,
+    );
+
+    return rowsAffected > 0;
+  }
+
+  /// Retrieves the looser of a match based on the score 0.
+  Future<Player?> getLooser({required String matchId}) async {
+    final query = select(scoreEntryTable)
+      ..where((s) => s.matchId.equals(matchId) & s.score.equals(0));
+    final result = await query.getSingleOrNull();
+
+    if (result == null) return null;
+
+    final player = await db.playerDao.getPlayerById(playerId: result.playerId);
+    return Player(
+      id: player.id,
+      name: player.name,
+      createdAt: player.createdAt,
+      description: player.description,
+    );
+  }
+
+  /// Removes the looser of a match.
+  ///
+  /// Returns `true` if the looser was removed, `false` if there are multiple
+  /// scores or if the looser cannot be removed.
+  Future<bool> removeLooser({required String matchId}) async {
+    final scores = await getAllMatchScores(matchId: matchId);
+
+    if (scores.length > 1) {
+      return false;
+    } else {
+      return await deleteAllScoresForMatch(matchId: matchId);
+    }
+  }
+}

lib/data/dao/score_entry_dao.g.dart

@@ -0,0 +1,31 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'score_entry_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$ScoreEntryDaoMixin on DatabaseAccessor<AppDatabase> {
+  $PlayerTableTable get playerTable => attachedDatabase.playerTable;
+  $GameTableTable get gameTable => attachedDatabase.gameTable;
+  $GroupTableTable get groupTable => attachedDatabase.groupTable;
+  $MatchTableTable get matchTable => attachedDatabase.matchTable;
+  $ScoreEntryTableTable get scoreEntryTable => attachedDatabase.scoreEntryTable;
+  ScoreEntryDaoManager get managers => ScoreEntryDaoManager(this);
+}
+
+class ScoreEntryDaoManager {
+  final _$ScoreEntryDaoMixin _db;
+  ScoreEntryDaoManager(this._db);
+  $$PlayerTableTableTableManager get playerTable =>
+      $$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
+  $$GameTableTableTableManager get gameTable =>
+      $$GameTableTableTableManager(_db.attachedDatabase, _db.gameTable);
+  $$GroupTableTableTableManager get groupTable =>
+      $$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
+  $$MatchTableTableTableManager get matchTable =>
+      $$MatchTableTableTableManager(_db.attachedDatabase, _db.matchTable);
+  $$ScoreEntryTableTableTableManager get scoreEntryTable =>
+      $$ScoreEntryTableTableTableManager(
+        _db.attachedDatabase,
+        _db.scoreEntryTable,
+      );
+}

lib/data/dao/team_dao.dart

@@ -1,8 +1,8 @@
 import 'package:drift/drift.dart';
 import 'package:tallee/data/db/database.dart';
 import 'package:tallee/data/db/tables/team_table.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
-import 'package:tallee/data/dto/team.dart';
+import 'package:tallee/data/models/team.dart';
 
 part 'team_dao.g.dart';
 
@@ -144,4 +144,3 @@ class TeamDao extends DatabaseAccessor<AppDatabase> with _$TeamDaoMixin {
     return rowsAffected > 0;
   }
 }
-

lib/data/dao/team_dao.g.dart

@@ -5,4 +5,12 @@ part of 'team_dao.dart';
 // ignore_for_file: type=lint
 mixin _$TeamDaoMixin on DatabaseAccessor<AppDatabase> {
   $TeamTableTable get teamTable => attachedDatabase.teamTable;
+  TeamDaoManager get managers => TeamDaoManager(this);
+}
+
+class TeamDaoManager {
+  final _$TeamDaoMixin _db;
+  TeamDaoManager(this._db);
+  $$TeamTableTableTableManager get teamTable =>
+      $$TeamTableTableTableManager(_db.attachedDatabase, _db.teamTable);
 }

lib/data/db/database.dart

@@ -7,7 +7,7 @@ import 'package:tallee/data/dao/match_dao.dart';
 import 'package:tallee/data/dao/player_dao.dart';
 import 'package:tallee/data/dao/player_group_dao.dart';
 import 'package:tallee/data/dao/player_match_dao.dart';
-import 'package:tallee/data/dao/score_dao.dart';
+import 'package:tallee/data/dao/score_entry_dao.dart';
 import 'package:tallee/data/dao/team_dao.dart';
 import 'package:tallee/data/db/tables/game_table.dart';
 import 'package:tallee/data/db/tables/group_table.dart';
@@ -15,7 +15,7 @@ import 'package:tallee/data/db/tables/match_table.dart';
 import 'package:tallee/data/db/tables/player_group_table.dart';
 import 'package:tallee/data/db/tables/player_match_table.dart';
 import 'package:tallee/data/db/tables/player_table.dart';
-import 'package:tallee/data/db/tables/score_table.dart';
+import 'package:tallee/data/db/tables/score_entry_table.dart';
 import 'package:tallee/data/db/tables/team_table.dart';
 
 part 'database.g.dart';
@@ -29,7 +29,7 @@ part 'database.g.dart';
     PlayerMatchTable,
     GameTable,
     TeamTable,
-    ScoreTable,
+    ScoreEntryTable,
   ],
   daos: [
     PlayerDao,
@@ -38,8 +38,8 @@ part 'database.g.dart';
     PlayerGroupDao,
     PlayerMatchDao,
     GameDao,
-    ScoreDao,
+    ScoreEntryDao,
-    TeamDao
+    TeamDao,
   ],
 )
 class AppDatabase extends _$AppDatabase {
@@ -60,7 +60,9 @@ class AppDatabase extends _$AppDatabase {
   static QueryExecutor _openConnection() {
     return driftDatabase(
       name: 'gametracker_db',
-      native: const DriftNativeOptions(databaseDirectory: getApplicationSupportDirectory),
+      native: const DriftNativeOptions(
+        databaseDirectory: getApplicationSupportDirectory,
+      ),
     );
   }
 }

lib/data/db/tables/match_table.dart

@@ -7,13 +7,15 @@ class MatchTable extends Table {
   TextColumn get gameId =>
       text().references(GameTable, #id, onDelete: KeyAction.cascade)();
   // Nullable if there is no group associated with the match
-  TextColumn get groupId =>
+  // onDelete: If a group gets deleted, groupId in the match gets set to null
-      text().references(GroupTable, #id, onDelete: KeyAction.cascade).nullable()();
+  TextColumn get groupId => text()
-  TextColumn get name => text().nullable()();
+      .references(GroupTable, #id, onDelete: KeyAction.setNull)
+      .nullable()();
+  TextColumn get name => text()();
   TextColumn get notes => text().nullable()();
   DateTimeColumn get createdAt => dateTime()();
   DateTimeColumn get endedAt => dateTime().nullable()();
 
   @override
   Set<Column<Object>> get primaryKey => {id};
-}
+}

lib/data/db/tables/player_match_table.dart

@@ -8,9 +8,7 @@ class PlayerMatchTable extends Table {
       text().references(PlayerTable, #id, onDelete: KeyAction.cascade)();
   TextColumn get matchId =>
       text().references(MatchTable, #id, onDelete: KeyAction.cascade)();
-  TextColumn get teamId =>
+  TextColumn get teamId => text().references(TeamTable, #id).nullable()();
-      text().references(TeamTable, #id).nullable()();
-  IntColumn get score => integer()();
 
   @override
   Set<Column<Object>> get primaryKey => {playerId, matchId};

lib/data/db/tables/player_table.dart

@@ -2,9 +2,10 @@ import 'package:drift/drift.dart';
 
 class PlayerTable extends Table {
   TextColumn get id => text()();
-  TextColumn get name => text()();
-  TextColumn get description => text()();
   DateTimeColumn get createdAt => dateTime()();
+  TextColumn get name => text()();
+  IntColumn get nameCount => integer().withDefault(const Constant(0))();
+  TextColumn get description => text()();
 
   @override
   Set<Column<Object>> get primaryKey => {id};

lib/data/db/tables/score_entry_table.dart

@@ -2,7 +2,7 @@ import 'package:drift/drift.dart';
 import 'package:tallee/data/db/tables/match_table.dart';
 import 'package:tallee/data/db/tables/player_table.dart';
 
-class ScoreTable extends Table {
+class ScoreEntryTable extends Table {
   TextColumn get playerId =>
       text().references(PlayerTable, #id, onDelete: KeyAction.cascade)();
   TextColumn get matchId =>
@@ -13,4 +13,4 @@ class ScoreTable extends Table {
 
   @override
   Set<Column<Object>> get primaryKey => {playerId, matchId, roundNumber};
-}
+}

lib/data/models/game.dart

@@ -1,6 +1,6 @@
 import 'package:clock/clock.dart';
-import 'package:tallee/core/enums.dart';
 import 'package:uuid/uuid.dart';
+import 'package:tallee/core/enums.dart';
 
 class Game {
   final String id;
@@ -18,11 +18,10 @@ class Game {
     required this.ruleset,
     String? description,
     required this.color,
-    String? icon,
+    required this.icon,
   }) : id = id ?? const Uuid().v4(),
        createdAt = createdAt ?? clock.now(),
-       description = description ?? '',
+       description = description ?? '';
-       icon = icon ?? '';
 
   @override
   String toString() {
@@ -50,3 +49,4 @@ class Game {
     'icon': icon,
   };
 }
+

lib/data/models/group.dart

@@ -1,5 +1,5 @@
 import 'package:clock/clock.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:uuid/uuid.dart';
 
 class Group {
@@ -24,16 +24,17 @@ class Group {
     return 'Group{id: $id, name: $name, description: $description, members: $members}';
   }
 
-  /// Creates a Group instance from a JSON object (memberIds format).
+  /// Creates a Group instance from a JSON object where the related [Player]
-  /// Player objects are reconstructed from memberIds by the DataTransferService.
+  /// objects are represented by their IDs.
   Group.fromJson(Map<String, dynamic> json)
     : id = json['id'],
       createdAt = DateTime.parse(json['createdAt']),
       name = json['name'],
       description = json['description'],
-      members = []; // Populated during import via DataTransferService
+      members = [];
 
-  /// Converts the Group instance to a JSON object using normalized format (memberIds only).
+  /// Converts the Group instance to a JSON object. Related [Player] objects are
+  /// represented by their IDs.
   Map<String, dynamic> toJson() => {
     'id': id,
     'createdAt': createdAt.toIso8601String(),

lib/data/models/match.dart

@@ -1,8 +1,9 @@
 import 'package:clock/clock.dart';
 import 'package:tallee/core/enums.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/models/game.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
+import 'package:tallee/data/models/score_entry.dart';
 import 'package:uuid/uuid.dart';
 
 class Match {
@@ -14,6 +15,7 @@ class Match {
   final Group? group;
   final List<Player> players;
   final String notes;
+  Map<String, List<ScoreEntry>> scores;
   Player? winner;
 
   Match({
@@ -24,19 +26,21 @@ class Match {
     required this.game,
     this.group,
     this.players = const [],
-    String? notes,
+    this.notes = '',
+    Map<String, List<ScoreEntry>>? scores,
     this.winner,
   }) : id = id ?? const Uuid().v4(),
        createdAt = createdAt ?? clock.now(),
-       notes = notes ?? '';
+       scores = scores ?? {for (var player in players) player.id: []};
 
   @override
   String toString() {
-    return 'Match{id: $id, name: $name, game: $game, group: $group, players: $players, notes: $notes, endedAt: $endedAt}';
+    return 'Match{id: $id, createdAt: $createdAt, endedAt: $endedAt, name: $name, game: $game, group: $group, players: $players, notes: $notes, scores: $scores, winner: $winner}';
   }
 
-  /// Creates a Match instance from a JSON object (ID references format).
+  /// Creates a Match instance from a JSON object where related objects are
-  /// Related objects are reconstructed from IDs by the DataTransferService.
+  /// represented by their IDs. Therefore, the game, group, and players are not
+  /// fully constructed here.
   Match.fromJson(Map<String, dynamic> json)
     : id = json['id'],
       createdAt = DateTime.parse(json['createdAt']),
@@ -49,12 +53,16 @@ class Match {
         ruleset: Ruleset.singleWinner,
         description: '',
         color: GameColor.blue,
-      ), // Populated during import via DataTransferService
+        icon: '',
-      group = null, // Populated during import via DataTransferService
+      ),
-      players = [], // Populated during import via DataTransferService
+      group = null,
+      players = [],
+      scores = json['scores'],
       notes = json['notes'] ?? '';
 
-  /// Converts the Match instance to a JSON object using normalized format (ID references only).
+  /// Converts the Match instance to a JSON object. Related objects are
+  /// represented by their IDs, so the game, group, and players are not fully
+  /// serialized here.
   Map<String, dynamic> toJson() => {
     'id': id,
     'createdAt': createdAt.toIso8601String(),
@@ -63,6 +71,10 @@ class Match {
     'gameId': game.id,
     'groupId': group?.id,
     'playerIds': players.map((player) => player.id).toList(),
+    'scores': scores.map(
+      (playerId, scoreList) =>
+          MapEntry(playerId, scoreList.map((score) => score.toJson()).toList()),
+    ),
     'notes': notes,
   };
 }

lib/data/models/player.dart

@@ -5,12 +5,14 @@ class Player {
   final String id;
   final DateTime createdAt;
   final String name;
+  int nameCount;
   final String description;
 
   Player({
     String? id,
     DateTime? createdAt,
     required this.name,
+    this.nameCount = 0,
     String? description,
   }) : id = id ?? const Uuid().v4(),
        createdAt = createdAt ?? clock.now(),
@@ -18,7 +20,7 @@ class Player {
 
   @override
   String toString() {
-    return 'Player{id: $id, name: $name, description: $description}';
+    return 'Player{id: $id, createdAt: $createdAt, name: $name, nameCount: $nameCount, description: $description}';
   }
 
   /// Creates a Player instance from a JSON object.
@@ -26,6 +28,7 @@ class Player {
     : id = json['id'],
       createdAt = DateTime.parse(json['createdAt']),
       name = json['name'],
+      nameCount = 0,
       description = json['description'];
 
   /// Converts the Player instance to a JSON object.

lib/data/models/score_entry.dart

@@ -0,0 +1,22 @@
+class ScoreEntry {
+  int roundNumber = 0;
+  final int score;
+  final int change;
+
+  ScoreEntry({
+    required this.roundNumber,
+    required this.score,
+    required this.change,
+  });
+
+  ScoreEntry.fromJson(Map<String, dynamic> json)
+    : roundNumber = json['roundNumber'],
+      score = json['score'],
+      change = json['change'];
+
+  Map<String, dynamic> toJson() => {
+    'roundNumber': roundNumber,
+    'score': score,
+    'change': change,
+  };
+}

lib/data/models/team.dart

@@ -1,5 +1,5 @@
 import 'package:clock/clock.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:uuid/uuid.dart';
 
 class Team {
@@ -29,7 +29,8 @@ class Team {
       createdAt = DateTime.parse(json['createdAt']),
       members = []; // Populated during import via DataTransferService
 
-  /// Converts the Team instance to a JSON object using normalized format (memberIds only).
+  /// Converts the Team instance to a JSON object. Related objects are
+  /// represented by their IDs.
   Map<String, dynamic> toJson() => {
     'id': id,
     'name': name,
@@ -37,4 +38,3 @@ class Team {
     'memberIds': members.map((member) => member.id).toList(),
   };
 }
-

lib/l10n/arb/app_de.arb

@@ -9,9 +9,7 @@
   "choose_game": "Spielvorlage wählen",
   "choose_group": "Gruppe wählen",
   "choose_ruleset": "Regelwerk wählen",
-  "choose_color": "Farbe wählen",
   "could_not_add_player": "Spieler:in {playerName} konnte nicht hinzugefügt werden",
-  "create_game": "Spielvorlage erstellen",
   "create_group": "Gruppe erstellen",
   "create_match": "Spiel erstellen",
   "create_new_group": "Neue Gruppe erstellen",
@@ -26,15 +24,10 @@
   "delete_all_data": "Alle Daten löschen",
   "delete_group": "Diese Gruppe löschen",
   "delete_match": "Spiel löschen",
-  "delete_game": "Spielvorlage löschen",
-  "delete_group": "Gruppe löschen",
-  "description": "Beschreibung",
-  "edit_game": "Spielvorlage bearbeiten",
   "edit_group": "Gruppe bearbeiten",
   "edit_match": "Gruppe bearbeiten",
   "enter_results": "Ergebnisse eintragen",
   "error_creating_group": "Fehler beim Erstellen der Gruppe, bitte erneut versuchen",
-  "error_deleting_game": "Fehler beim Löschen der Spielvorlage, bitte erneut versuchen",
   "error_deleting_group": "Fehler beim Löschen der Gruppe, bitte erneut versuchen",
   "error_editing_group": "Fehler beim Bearbeiten der Gruppe, bitte erneut versuchen",
   "error_reading_file": "Fehler beim Lesen der Datei",
@@ -113,14 +106,5 @@
   "winner": "Gewinner:in",
   "winrate": "Siegquote",
   "wins": "Siege",
-  "yesterday_at": "Gestern um",
+  "yesterday_at": "Gestern um"
-  "color_red": "Rot",
-  "color_blue": "Blau",
-  "color_green": "Grün",
-  "color_yellow": "Gelb",
-  "color_purple": "Lila",
-  "color_orange": "Orange",
-  "color_pink": "Rosa",
-  "color_teal": "Türkis",
-  "color": "Farbe"
 }

lib/l10n/arb/app_en.arb

@@ -27,15 +27,9 @@
   "@choose_ruleset": {
     "description": "Label for choosing a ruleset"
   },
-  "@choose_color": {
-    "description": "Label for choosing a color"
-  },
   "@could_not_add_player": {
     "description": "Error message when adding a player fails"
   },
-  "@create_game": {
-    "description": "Button text to create a game"
-  },
   "@create_group": {
     "description": "Button text to create a group"
   },
@@ -77,21 +71,12 @@
   "@delete_all_data": {
     "description": "Confirmation dialog for deleting all data"
   },
-  "@delete_game": {
-    "description": "Button text to delete a game"
-  },
   "@delete_group": {
     "description": "Confirmation dialog for deleting a group"
   },
   "@delete_match": {
     "description": "Button text to delete a match"
   },
-  "description": {
-    "description": "Description label"
-  },
-  "edit_game": {
-    "description": "Button text to edit a game"
-   },
   "@edit_group": {
       "description": "Button & Appbar label for editing a group"
   },
@@ -104,9 +89,6 @@
   "@error_creating_group": {
     "description": "Error message when group creation fails"
   },
-  "@error_deleting_game": {
-    "description": "Error message when game deletion fails"
-  },
   "@error_deleting_group": {
       "description": "Error message when group deletion fails"
   },
@@ -343,9 +325,6 @@
   "@yesterday_at": {
     "description": "Date format for yesterday"
   },
-  "@color": {
-    "description": "Color label"
-  },
   "all_players": "All players",
   "all_players_selected": "All players selected",
   "amount_of_matches": "Amount of Matches",
@@ -355,9 +334,7 @@
   "choose_game": "Choose Game",
   "choose_group": "Choose Group",
   "choose_ruleset": "Choose Ruleset",
-  "choose_color": "Choose Color",
   "could_not_add_player": "Could not add player",
-  "create_game": "Create Game",
   "create_group": "Create Group",
   "create_match": "Create match",
   "create_new_group": "Create new group",
@@ -370,16 +347,12 @@
   "days_ago": "{count} days ago",
   "delete": "Delete",
   "delete_all_data": "Delete all data",
-  "delete_game": "Delete Game",
   "delete_group": "Delete Group",
   "delete_match": "Delete Match",
-  "description": "Description",
-  "edit_game": "Edit Game",
   "edit_group": "Edit Group",
   "edit_match": "Edit Match",
   "enter_results": "Enter Results",
   "error_creating_group": "Error while creating group, please try again",
-  "error_deleting_game": "Error while deleting game, please try again",
   "error_deleting_group": "Error while deleting group, please try again",
   "error_editing_group": "Error while editing group, please try again",
   "error_reading_file": "Error reading file",
@@ -457,14 +430,5 @@
   "winner": "Winner",
   "winrate": "Winrate",
   "wins": "Wins",
-  "yesterday_at": "Yesterday at",
+  "yesterday_at": "Yesterday at"
-  "color_red": "Red",
-  "color_blue": "Blue",
-  "color_green": "Green",
-  "color_yellow": "Yellow",
-  "color_purple": "Purple",
-  "color_orange": "Orange",
-  "color_pink": "Pink",
-  "color_teal": "Teal",
-  "color": "Color"
 }

lib/l10n/generated/app_localizations.dart

@@ -98,18 +98,6 @@ abstract class AppLocalizations {
     Locale('en'),
   ];
 
-  /// No description provided for @description.
-  ///
-  /// In en, this message translates to:
-  /// **'Description'**
-  String get description;
-
-  /// No description provided for @edit_game.
-  ///
-  /// In en, this message translates to:
-  /// **'Edit Game'**
-  String get edit_game;
-
   /// Label for all players list
   ///
   /// In en, this message translates to:
@@ -164,24 +152,12 @@ abstract class AppLocalizations {
   /// **'Choose Ruleset'**
   String get choose_ruleset;
 
-  /// Label for choosing a color
-  ///
-  /// In en, this message translates to:
-  /// **'Choose Color'**
-  String get choose_color;
-
   /// Error message when adding a player fails
   ///
   /// In en, this message translates to:
   /// **'Could not add player'**
   String could_not_add_player(Object playerName);
 
-  /// Button text to create a game
-  ///
-  /// In en, this message translates to:
-  /// **'Create Game'**
-  String get create_game;
-
   /// Button text to create a group
   ///
   /// In en, this message translates to:
@@ -254,12 +230,6 @@ abstract class AppLocalizations {
   /// **'Delete all data'**
   String get delete_all_data;
 
-  /// Button text to delete a game
-  ///
-  /// In en, this message translates to:
-  /// **'Delete Game'**
-  String get delete_game;
-
   /// Confirmation dialog for deleting a group
   ///
   /// In en, this message translates to:
@@ -296,12 +266,6 @@ abstract class AppLocalizations {
   /// **'Error while creating group, please try again'**
   String get error_creating_group;
 
-  /// Error message when game deletion fails
-  ///
-  /// In en, this message translates to:
-  /// **'Error while deleting game, please try again'**
-  String get error_deleting_game;
-
   /// Error message when group deletion fails
   ///
   /// In en, this message translates to:
@@ -769,60 +733,6 @@ abstract class AppLocalizations {
   /// In en, this message translates to:
   /// **'Yesterday at'**
   String get yesterday_at;
-
-  /// No description provided for @color_red.
-  ///
-  /// In en, this message translates to:
-  /// **'Red'**
-  String get color_red;
-
-  /// No description provided for @color_blue.
-  ///
-  /// In en, this message translates to:
-  /// **'Blue'**
-  String get color_blue;
-
-  /// No description provided for @color_green.
-  ///
-  /// In en, this message translates to:
-  /// **'Green'**
-  String get color_green;
-
-  /// No description provided for @color_yellow.
-  ///
-  /// In en, this message translates to:
-  /// **'Yellow'**
-  String get color_yellow;
-
-  /// No description provided for @color_purple.
-  ///
-  /// In en, this message translates to:
-  /// **'Purple'**
-  String get color_purple;
-
-  /// No description provided for @color_orange.
-  ///
-  /// In en, this message translates to:
-  /// **'Orange'**
-  String get color_orange;
-
-  /// No description provided for @color_pink.
-  ///
-  /// In en, this message translates to:
-  /// **'Pink'**
-  String get color_pink;
-
-  /// No description provided for @color_teal.
-  ///
-  /// In en, this message translates to:
-  /// **'Teal'**
-  String get color_teal;
-
-  /// Color label
-  ///
-  /// In en, this message translates to:
-  /// **'Color'**
-  String get color;
 }
 
 class _AppLocalizationsDelegate

lib/l10n/generated/app_localizations_de.dart

@@ -8,12 +8,6 @@ import 'app_localizations.dart';
 class AppLocalizationsDe extends AppLocalizations {
   AppLocalizationsDe([String locale = 'de']) : super(locale);
 
-  @override
-  String get description => 'Beschreibung';
-
-  @override
-  String get edit_game => 'Spielvorlage bearbeiten';
-
   @override
   String get all_players => 'Alle Spieler:innen';
 
@@ -41,17 +35,11 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get choose_ruleset => 'Regelwerk wählen';
 
-  @override
-  String get choose_color => 'Farbe wählen';
-
   @override
   String could_not_add_player(Object playerName) {
     return 'Spieler:in $playerName konnte nicht hinzugefügt werden';
   }
 
-  @override
-  String get create_game => 'Spielvorlage erstellen';
-
   @override
   String get create_group => 'Gruppe erstellen';
 
@@ -91,10 +79,7 @@ class AppLocalizationsDe extends AppLocalizations {
   String get delete_all_data => 'Alle Daten löschen';
 
   @override
-  String get delete_game => 'Spielvorlage löschen';
+  String get delete_group => 'Diese Gruppe löschen';
-
-  @override
-  String get delete_group => 'Gruppe löschen';
 
   @override
   String get delete_match => 'Spiel löschen';
@@ -112,10 +97,6 @@ class AppLocalizationsDe extends AppLocalizations {
   String get error_creating_group =>
       'Fehler beim Erstellen der Gruppe, bitte erneut versuchen';
 
-  @override
-  String get error_deleting_game =>
-      'Fehler beim Löschen der Spielvorlage, bitte erneut versuchen';
-
   @override
   String get error_deleting_group =>
       'Fehler beim Löschen der Gruppe, bitte erneut versuchen';
@@ -362,31 +343,4 @@ class AppLocalizationsDe extends AppLocalizations {
 
   @override
   String get yesterday_at => 'Gestern um';
-
-  @override
-  String get color_red => 'Rot';
-
-  @override
-  String get color_blue => 'Blau';
-
-  @override
-  String get color_green => 'Grün';
-
-  @override
-  String get color_yellow => 'Gelb';
-
-  @override
-  String get color_purple => 'Lila';
-
-  @override
-  String get color_orange => 'Orange';
-
-  @override
-  String get color_pink => 'Rosa';
-
-  @override
-  String get color_teal => 'Türkis';
-
-  @override
-  String get color => 'Farbe';
 }

lib/l10n/generated/app_localizations_en.dart

@@ -8,12 +8,6 @@ import 'app_localizations.dart';
 class AppLocalizationsEn extends AppLocalizations {
   AppLocalizationsEn([String locale = 'en']) : super(locale);
 
-  @override
-  String get description => 'Description';
-
-  @override
-  String get edit_game => 'Edit Game';
-
   @override
   String get all_players => 'All players';
 
@@ -41,17 +35,11 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get choose_ruleset => 'Choose Ruleset';
 
-  @override
-  String get choose_color => 'Choose Color';
-
   @override
   String could_not_add_player(Object playerName) {
     return 'Could not add player';
   }
 
-  @override
-  String get create_game => 'Create Game';
-
   @override
   String get create_group => 'Create Group';
 
@@ -90,9 +78,6 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get delete_all_data => 'Delete all data';
 
-  @override
-  String get delete_game => 'Delete Game';
-
   @override
   String get delete_group => 'Delete Group';
 
@@ -112,10 +97,6 @@ class AppLocalizationsEn extends AppLocalizations {
   String get error_creating_group =>
       'Error while creating group, please try again';
 
-  @override
-  String get error_deleting_game =>
-      'Error while deleting game, please try again';
-
   @override
   String get error_deleting_group =>
       'Error while deleting group, please try again';
@@ -361,31 +342,4 @@ class AppLocalizationsEn extends AppLocalizations {
 
   @override
   String get yesterday_at => 'Yesterday at';
-
-  @override
-  String get color_red => 'Red';
-
-  @override
-  String get color_blue => 'Blue';
-
-  @override
-  String get color_green => 'Green';
-
-  @override
-  String get color_yellow => 'Yellow';
-
-  @override
-  String get color_purple => 'Purple';
-
-  @override
-  String get color_orange => 'Orange';
-
-  @override
-  String get color_pink => 'Pink';
-
-  @override
-  String get color_teal => 'Teal';
-
-  @override
-  String get color => 'Color';
 }

lib/presentation/views/main_menu/group_view/create_group_view.dart

@@ -1,21 +1,24 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
+import 'package:tallee/core/constants.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/widgets/buttons/custom_width_button.dart';
 import 'package:tallee/presentation/widgets/player_selection.dart';
 import 'package:tallee/presentation/widgets/text_input/text_input_field.dart';
 
 class CreateGroupView extends StatefulWidget {
-  const CreateGroupView({super.key, this.groupToEdit});
+  const CreateGroupView({super.key, this.groupToEdit, this.onMembersChanged});
 
   /// The group to edit, if any
   final Group? groupToEdit;
 
+  final VoidCallback? onMembersChanged;
+
   @override
   State<CreateGroupView> createState() => _CreateGroupViewState();
 }
@@ -69,49 +72,6 @@ class _CreateGroupViewState extends State<CreateGroupView> {
           title: Text(
             widget.groupToEdit == null ? loc.create_new_group : loc.edit_group,
           ),
-          actions: widget.groupToEdit == null
-              ? []
-              : [
-                  IconButton(
-                    icon: const Icon(Icons.delete),
-                    onPressed: () async {
-                      if (widget.groupToEdit != null) {
-                        showDialog<bool>(
-                          context: context,
-                          builder: (context) => AlertDialog(
-                            title: Text(loc.delete_group),
-                            content: Text(loc.this_cannot_be_undone),
-                            actions: [
-                              TextButton(
-                                onPressed: () =>
-                                    Navigator.of(context).pop(false),
-                                child: Text(loc.cancel),
-                              ),
-                              TextButton(
-                                onPressed: () =>
-                                    Navigator.of(context).pop(true),
-                                child: Text(loc.delete),
-                              ),
-                            ],
-                          ),
-                        ).then((confirmed) async {
-                          if (confirmed == true && context.mounted) {
-                            bool success = await db.groupDao.deleteGroup(
-                              groupId: widget.groupToEdit!.id,
-                            );
-                            if (!context.mounted) return;
-                            if (success) {
-                              Navigator.pop(context);
-                            } else {
-                              if (!mounted) return;
-                              showSnackbar(message: loc.error_deleting_group);
-                            }
-                          }
-                        });
-                      }
-                    },
-                  ),
-                ],
         ),
         body: SafeArea(
           child: Column(
@@ -122,6 +82,7 @@ class _CreateGroupViewState extends State<CreateGroupView> {
                 child: TextInputField(
                   controller: _groupNameController,
                   hintText: loc.group_name,
+                  maxLength: Constants.MAX_GROUP_NAME_LENGTH,
                 ),
               ),
               Expanded(
@@ -144,42 +105,7 @@ class _CreateGroupViewState extends State<CreateGroupView> {
                     (_groupNameController.text.isEmpty ||
                         (selectedPlayers.length < 2))
                     ? null
-                    : () async {
+                    : _saveGroup,
-                        late Group? updatedGroup;
-                        late bool success;
-                        if (widget.groupToEdit == null) {
-                          success = await db.groupDao.addGroup(
-                            group: Group(
-                              name: _groupNameController.text.trim(),
-                              members: selectedPlayers,
-                            ),
-                          );
-                        } else {
-                          updatedGroup = Group(
-                            id: widget.groupToEdit!.id,
-                            name: _groupNameController.text.trim(),
-                            description: '',
-                            members: selectedPlayers,
-                          );
-                          //TODO: Implement group editing in database
-                          /*
-                          success = await db.groupDao.updateGroup(
-                            group: updatedGroup,
-                          );
-                          */
-                          success = true;
-                        }
-                        if (!context.mounted) return;
-                        if (success) {
-                          Navigator.pop(context, updatedGroup);
-                        } else {
-                          showSnackbar(
-                            message: widget.groupToEdit == null
-                                ? loc.error_creating_group
-                                : loc.error_editing_group,
-                          );
-                        }
-                      },
               ),
               const SizedBox(height: 20),
             ],
@@ -189,6 +115,104 @@ class _CreateGroupViewState extends State<CreateGroupView> {
     );
   }
 
+  /// Saves the group by creating a new one or updating the existing one,
+  /// depending on whether the widget  is in edit mode.
+  Future<void> _saveGroup() async {
+    final loc = AppLocalizations.of(context);
+    late bool success;
+    Group? updatedGroup;
+
+    if (widget.groupToEdit == null) {
+      success = await _createGroup();
+    } else {
+      final result = await _editGroup();
+      success = result.$1;
+      updatedGroup = result.$2;
+    }
+
+    if (!mounted) return;
+
+    if (success) {
+      Navigator.pop(context, updatedGroup);
+    } else {
+      showSnackbar(
+        message: widget.groupToEdit == null
+            ? loc.error_creating_group
+            : loc.error_editing_group,
+      );
+    }
+  }
+
+  /// Handles creating a new group and returns whether the operation was successful.
+  Future<bool> _createGroup() async {
+    final groupName = _groupNameController.text.trim();
+
+    final success = await db.groupDao.addGroup(
+      group: Group(name: groupName, description: '', members: selectedPlayers),
+    );
+
+    return success;
+  }
+
+  /// Handles editing an existing group and returns a tuple of
+  /// (success, updatedGroup).
+  Future<(bool, Group?)> _editGroup() async {
+    final groupName = _groupNameController.text.trim();
+
+    Group? updatedGroup = Group(
+      id: widget.groupToEdit!.id,
+      name: groupName,
+      description: '',
+      members: selectedPlayers,
+    );
+
+    bool successfullNameChange = true;
+    bool successfullMemberChange = true;
+
+    if (widget.groupToEdit!.name != groupName) {
+      successfullNameChange = await db.groupDao.updateGroupName(
+        groupId: widget.groupToEdit!.id,
+        newName: groupName,
+      );
+    }
+
+    if (widget.groupToEdit!.members != selectedPlayers) {
+      successfullMemberChange = await db.groupDao.replaceGroupPlayers(
+        groupId: widget.groupToEdit!.id,
+        newPlayers: selectedPlayers,
+      );
+      await deleteObsoleteMatchGroupRelations();
+      widget.onMembersChanged?.call();
+    }
+
+    final success = successfullNameChange && successfullMemberChange;
+
+    return (success, updatedGroup);
+  }
+
+  /// Removes the group association from matches that no longer belong to the edited group.
+  ///
+  /// After updating the group's members, matches that were previously linked to
+  /// this group but don't have any of the newly selected players are considered
+  /// obsolete. For each such match, the group association is removed by setting
+  /// its [groupId] to null.
+  Future<void> deleteObsoleteMatchGroupRelations() async {
+    final groupMatches = await db.matchDao.getGroupMatches(
+      groupId: widget.groupToEdit!.id,
+    );
+
+    final selectedPlayerIds = selectedPlayers.map((p) => p.id).toSet();
+    final relationshipsToDelete = groupMatches.where((match) {
+      return !match.players.any(
+        (player) => selectedPlayerIds.contains(player.id),
+      );
+    }).toList();
+
+    for (var match in relationshipsToDelete) {
+      await db.matchDao.removeMatchGroup(matchId: match.id);
+    }
+  }
+
   /// Displays a snackbar with the given message and optional action.
   ///
   /// [message] The message to display in the snackbar.

lib/presentation/views/main_menu/group_view/group_detail_view.dart

@@ -2,11 +2,12 @@ import 'package:flutter/material.dart';
 import 'package:intl/intl.dart';
 import 'package:provider/provider.dart';
 import 'package:tallee/core/adaptive_page_route.dart';
+import 'package:tallee/core/common.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/views/main_menu/group_view/create_group_view.dart';
 import 'package:tallee/presentation/widgets/app_skeleton.dart';
@@ -153,6 +154,7 @@ class _GroupDetailViewState extends State<GroupDetailView> {
                     children: _group.members.map((member) {
                       return TextIconTile(
                         text: member.name,
+                        suffixText: getNameCountText(member),
                         iconEnabled: false,
                       );
                     }).toList(),
@@ -191,7 +193,12 @@ class _GroupDetailViewState extends State<GroupDetailView> {
                     context,
                     adaptivePageRoute(
                       builder: (context) {
-                        return CreateGroupView(groupToEdit: _group);
+                        return CreateGroupView(
+                          groupToEdit: _group,
+                          onMembersChanged: () {
+                            _loadStatistics();
+                          },
+                        );
                       },
                     ),
                   );
@@ -242,10 +249,8 @@ class _GroupDetailViewState extends State<GroupDetailView> {
 
   /// Loads statistics for this group
   Future<void> _loadStatistics() async {
-    final matches = await db.matchDao.getAllMatches();
+    isLoading = true;
-    final groupMatches = matches
+    final groupMatches = await db.matchDao.getGroupMatches(groupId: _group.id);
-        .where((match) => match.group?.id == _group.id)
-        .toList();
 
     setState(() {
       totalMatches = groupMatches.length;
@@ -260,7 +265,9 @@ class _GroupDetailViewState extends State<GroupDetailView> {
 
     // Count wins for each player
     for (var match in matches) {
-      if (match.winner != null) {
+      if (match.winner != null &&
+          _group.members.any((m) => m.id == match.winner?.id)) {
+        print(match.winner);
         bestPlayerCounts.update(
           match.winner!,
           (value) => value + 1,

lib/presentation/views/main_menu/group_view/group_view.dart

@@ -4,8 +4,8 @@ import 'package:tallee/core/adaptive_page_route.dart';
 import 'package:tallee/core/constants.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/views/main_menu/group_view/create_group_view.dart';
 import 'package:tallee/presentation/views/main_menu/group_view/group_detail_view.dart';

lib/presentation/views/main_menu/home_view.dart

@@ -4,10 +4,10 @@ import 'package:tallee/core/adaptive_page_route.dart';
 import 'package:tallee/core/constants.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/models/game.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/views/main_menu/match_view/match_result_view.dart';
 import 'package:tallee/presentation/widgets/app_skeleton.dart';
@@ -47,6 +47,7 @@ class _HomeViewState extends State<HomeView> {
         ruleset: Ruleset.singleWinner,
         description: '',
         color: GameColor.blue,
+        icon: '',
       ),
       group: Group(
         name: 'Skeleton Group',
@@ -226,7 +227,7 @@ class _HomeViewState extends State<HomeView> {
   /// Updates the winner information for a specific match in the recent matches list.
   Future<void> updatedWinnerInRecentMatches(String matchId) async {
     final db = Provider.of<AppDatabase>(context, listen: false);
-    final winner = await db.matchDao.getWinner(matchId: matchId);
+    final winner = await db.scoreEntryDao.getWinner(matchId: matchId);
     final matchIndex = recentMatches.indexWhere((match) => match.id == matchId);
     if (matchIndex != -1) {
       setState(() {

lib/presentation/views/main_menu/match_view/create_match/choose_game_view.dart

@@ -1,33 +1,26 @@
 import 'package:flutter/material.dart';
-import 'package:tallee/core/adaptive_page_route.dart';
 import 'package:tallee/core/common.dart';
 import 'package:tallee/core/custom_theme.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/core/enums.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
-import 'package:tallee/presentation/views/main_menu/match_view/create_match/game_view/create_game_view.dart';
 import 'package:tallee/presentation/widgets/text_input/custom_search_bar.dart';
 import 'package:tallee/presentation/widgets/tiles/title_description_list_tile.dart';
 
 class ChooseGameView extends StatefulWidget {
   /// A view that allows the user to choose a game from a list of available games
-  /// - [games]: The list of available games
+  /// - [games]: A list of tuples containing the game name, description and ruleset
-  /// - [initialSelectedGameId]: The id of the initially selected game
+  /// - [initialGameIndex]: The index of the initially selected game
-  /// - [onGamesUpdated]: Optional callback invoked when the games are updated
   const ChooseGameView({
     super.key,
     required this.games,
-    required this.initialSelectedGameId,
+    required this.initialGameIndex,
-    this.onGamesUpdated,
   });
 
   /// A list of tuples containing the game name, description and ruleset
-  final List<Game> games;
+  final List<(String, String, Ruleset)> games;
 
   /// The index of the initially selected game
-  final String initialSelectedGameId;
+  final int initialGameIndex;
-
-  /// Optional callback invoked when the games are updated
-  final VoidCallback? onGamesUpdated;
 
   @override
   State<ChooseGameView> createState() => _ChooseGameViewState();
@@ -37,18 +30,12 @@ class _ChooseGameViewState extends State<ChooseGameView> {
   /// Controller for the search bar
   final TextEditingController searchBarController = TextEditingController();
 
-  /// Currently selected game id
+  /// Currently selected game index
-  late String selectedGameId;
+  late int selectedGameIndex;
-
-  /// Games filtered according to the current search query
-  late List<Game> filteredGames;
 
   @override
   void initState() {
-    selectedGameId = widget.initialSelectedGameId;
+    selectedGameIndex = widget.initialGameIndex;
-
-    // Start with all games visible
-    filteredGames = List<Game>.from(widget.games);
     super.initState();
   }
 
@@ -62,32 +49,9 @@ class _ChooseGameViewState extends State<ChooseGameView> {
         leading: IconButton(
           icon: const Icon(Icons.arrow_back_ios),
           onPressed: () {
-            Navigator.of(context).pop(selectedGameId);
+            Navigator.of(context).pop(selectedGameIndex);
           },
         ),
-        actions: [
-          IconButton(
-            icon: const Icon(Icons.add),
-            onPressed: () async {
-              final result = await Navigator.push(
-                context,
-                adaptivePageRoute(
-                  builder: (context) => CreateGameView(
-                    onGameChanged: () {
-                      widget.onGamesUpdated?.call();
-                    },
-                  ),
-                ),
-              );
-              if (result != null && result.game != null) {
-                setState(() {
-                  widget.games.insert(0, result.game);
-                });
-                _refreshFromSource();
-              }
-            },
-          ),
-        ],
         title: Text(loc.choose_game),
       ),
       body: PopScope(
@@ -98,7 +62,7 @@ class _ChooseGameViewState extends State<ChooseGameView> {
           if (didPop) {
             return;
           }
-          Navigator.of(context).pop(selectedGameId);
+          Navigator.of(context).pop(selectedGameIndex);
         },
         child: Column(
           children: [
@@ -107,63 +71,30 @@ class _ChooseGameViewState extends State<ChooseGameView> {
               child: CustomSearchBar(
                 controller: searchBarController,
                 hintText: loc.game_name,
-                onChanged: (value) {
-                  _applySearchFilter(value);
-                },
               ),
             ),
             const SizedBox(height: 5),
             Expanded(
               child: ListView.builder(
-                itemCount: filteredGames.length,
+                itemCount: widget.games.length,
                 itemBuilder: (BuildContext context, int index) {
-                  final game = filteredGames[index];
                   return TitleDescriptionListTile(
-                    title: game.name,
+                    title: widget.games[index].$1,
-                    description: game.description,
+                    description: widget.games[index].$2,
-                    badgeText: translateRulesetToString(game.ruleset, context),
+                    badgeText: translateRulesetToString(
-                    isHighlighted: selectedGameId == game.id,
+                      widget.games[index].$3,
-                    onTap: () async {
+                      context,
+                    ),
+                    isHighlighted: selectedGameIndex == index,
+                    onPressed: () async {
                       setState(() {
-                        if (selectedGameId == game.id) {
+                        if (selectedGameIndex == index) {
-                          selectedGameId = '';
+                          selectedGameIndex = -1;
                         } else {
-                          selectedGameId = game.id;
+                          selectedGameIndex = index;
                         }
                       });
                     },
-                    onLongPress: () async {
-                      final result = await Navigator.push(
-                        context,
-                        adaptivePageRoute(
-                          builder: (context) => CreateGameView(
-                            gameToEdit: game,
-                            onGameChanged: () {
-                              widget.onGamesUpdated?.call();
-                            },
-                          ),
-                        ),
-                      );
-                      if (result != null && result.game != null) {
-                        // Find the index in the original list to mutate
-                        final originalIndex = widget.games.indexWhere(
-                          (g) => g.id == game.id,
-                        );
-                        if (originalIndex == -1) {
-                          return;
-                        }
-                        if (result.delete) {
-                          setState(() {
-                            widget.games.removeAt(originalIndex);
-                          });
-                        } else {
-                          setState(() {
-                            widget.games[originalIndex] = result.game;
-                          });
-                        }
-                        _refreshFromSource();
-                      }
-                    },
                   );
                 },
               ),
@@ -173,28 +104,4 @@ class _ChooseGameViewState extends State<ChooseGameView> {
       ),
     );
   }
-
-  /// Applies the search filter to the games list based on [query].
-  void _applySearchFilter(String query) {
-    final q = query.toLowerCase().trim();
-    if (q.isEmpty) {
-      setState(() {
-        filteredGames = List<Game>.from(widget.games);
-      });
-      return;
-    }
-
-    setState(() {
-      filteredGames = widget.games.where((game) {
-        final name = game.name.toLowerCase();
-        final description = game.description.toLowerCase();
-        return name.contains(q) || description.contains(q);
-      }).toList();
-    });
-  }
-
-  /// Re-applies the current filter after the underlying games list changed.
-  void _refreshFromSource() {
-    _applySearchFilter(searchBarController.text);
-  }
 }

lib/presentation/views/main_menu/match_view/create_match/choose_group_view.dart

@@ -1,6 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:tallee/core/custom_theme.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/widgets/text_input/custom_search_bar.dart';
 import 'package:tallee/presentation/widgets/tiles/group_tile.dart';

lib/presentation/views/main_menu/match_view/create_match/create_match_view.dart

@@ -5,10 +5,10 @@ import 'package:tallee/core/constants.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/models/game.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/views/main_menu/match_view/create_match/choose_game_view.dart';
 import 'package:tallee/presentation/views/main_menu/match_view/create_match/choose_group_view.dart';
@@ -18,13 +18,9 @@ import 'package:tallee/presentation/widgets/player_selection.dart';
 import 'package:tallee/presentation/widgets/text_input/text_input_field.dart';
 import 'package:tallee/presentation/widgets/tiles/choose_tile.dart';
 
-/// A stateful widget for creating or editing a match.
 class CreateMatchView extends StatefulWidget {
-  /// Constructor for `CreateMatchView`.
+  /// A view that allows creating a new match
-  ///
+  /// [onWinnerChanged]: Optional callback invoked when the winner is changed
-  /// [onWinnerChanged] is an optional callback invoked when the winner is changed.
-  /// [matchToEdit] is an optional match to prefill the fields.
-  /// [onMatchUpdated] is an optional callback invoked when the match is updated.
   const CreateMatchView({
     super.key,
     this.onWinnerChanged,
@@ -32,49 +28,45 @@ class CreateMatchView extends StatefulWidget {
     this.onMatchUpdated,
   });
 
-  /// Optional callback invoked when the winner is changed.
+  /// Optional callback invoked when the winner is changed
   final VoidCallback? onWinnerChanged;
 
-  /// Optional callback invoked when the match is updated.
+  /// Optional callback invoked when the match is updated
   final void Function(Match)? onMatchUpdated;
 
-  /// An optional match to prefill the fields.
+  /// An optional match to prefill the fields
   final Match? matchToEdit;
 
   @override
   State<CreateMatchView> createState() => _CreateMatchViewState();
 }
 
-/// The state class for `CreateMatchView`, managing the UI and logic for creating or editing a match.
 class _CreateMatchViewState extends State<CreateMatchView> {
-  /// The database instance for accessing match data.
   late final AppDatabase db;
 
-  /// Controller for the match name input field.
+  /// Controller for the match name input field
   final TextEditingController _matchNameController = TextEditingController();
 
-  /// Hint text for the match name input field.
+  /// Hint text for the match name input field
   String? hintText;
 
-  /// List of all games from the database.
+  /// List of all groups from the database
-  List<Game> gamesList = [];
-
-  /// List of all groups from the database.
   List<Group> groupsList = [];
 
-  /// List of all players from the database.
+  /// List of all players from the database
   List<Player> playerList = [];
 
-  /// The currently selected group.
+  /// The currently selected group
   Group? selectedGroup;
 
-  /// The currently selected game.
+  /// The index of the currently selected game in [games] to mark it in
-  Game? selectedGame;
+  /// the [ChooseGameView]
+  int selectedGameIndex = -1;
 
-  /// The currently selected players.
+  /// The currently selected players
   List<Player> selectedPlayers = [];
 
-  /// GlobalKey for ScaffoldMessenger to show snackbars.
+  /// GlobalKey for ScaffoldMessenger to show snackbars
   final _scaffoldMessengerKey = GlobalKey<ScaffoldMessengerState>();
 
   @override
@@ -86,18 +78,14 @@ class _CreateMatchViewState extends State<CreateMatchView> {
 
     db = Provider.of<AppDatabase>(context, listen: false);
 
-    // Load games, groups, and players from the database.
     Future.wait([
-      db.gameDao.getAllGames(),
       db.groupDao.getAllGroups(),
       db.playerDao.getAllPlayers(),
     ]).then((result) async {
-      gamesList = result[0] as List<Game>;
+      groupsList = result[0] as List<Group>;
-      gamesList.sort((a, b) => b.createdAt.compareTo(a.createdAt));
+      playerList = result[1] as List<Player>;
-      groupsList = result[1] as List<Group>;
-      playerList = result[2] as List<Player>;
 
-      // If a match is provided, prefill the fields.
+      // If a match is provided, prefill the fields
       if (widget.matchToEdit != null) {
         prefillMatchDetails();
       }
@@ -117,6 +105,11 @@ class _CreateMatchViewState extends State<CreateMatchView> {
     hintText ??= loc.match_name;
   }
 
+  List<(String, String, Ruleset)> games = [
+    ('Example Game 1', 'This is a description', Ruleset.lowestScore),
+    ('Example Game 2', '', Ruleset.singleWinner),
+  ];
+
   @override
   Widget build(BuildContext context) {
     final loc = AppLocalizations.of(context);
@@ -137,7 +130,6 @@ class _CreateMatchViewState extends State<CreateMatchView> {
           child: Column(
             mainAxisAlignment: MainAxisAlignment.start,
             children: [
-              // Match name input field.
               Container(
                 margin: CustomTheme.tileMargin,
                 child: TextInputField(
@@ -146,48 +138,38 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                   maxLength: Constants.MAX_MATCH_NAME_LENGTH,
                 ),
               ),
-              // Game selection tile.
               ChooseTile(
                 title: loc.game,
-                trailingText: selectedGame == null
+                trailingText: selectedGameIndex == -1
                     ? loc.none
-                    : selectedGame!.name,
+                    : games[selectedGameIndex].$1,
                 onPressed: () async {
-                  final String? selectedGameId = await Navigator.of(context)
+                  selectedGameIndex = await Navigator.of(context).push(
-                      .push(
+                    adaptivePageRoute(
-                        adaptivePageRoute(
+                      builder: (context) => ChooseGameView(
-                          builder: (context) => ChooseGameView(
+                        games: games,
-                            games: gamesList,
+                        initialGameIndex: selectedGameIndex,
-                            initialSelectedGameId: selectedGame?.id ?? '',
+                      ),
-                            onGamesUpdated: loadGames,
+                    ),
-                          ),
+                  );
-                        ),
-                      );
-
-                  try {
-                    selectedGame = gamesList.firstWhere(
-                      (g) => g.id == selectedGameId,
-                    );
-                  } catch (_) {
-                    selectedGame = null;
-                  }
-
                   setState(() {
-                    if (selectedGame != null) {
+                    if (selectedGameIndex != -1) {
-                      hintText = selectedGame!.name;
+                      hintText = games[selectedGameIndex].$1;
                     } else {
                       hintText = loc.match_name;
                     }
                   });
                 },
               ),
-              // Group selection tile.
               ChooseTile(
                 title: loc.group,
                 trailingText: selectedGroup == null
                     ? loc.none_group
                     : selectedGroup!.name,
                 onPressed: () async {
+                  // Remove all players from the previously selected group from
+                  // the selected players list, in case the user deselects the
+                  // group or selects a different group.
                   selectedPlayers.removeWhere(
                     (player) =>
                         selectedGroup?.members.any(
@@ -214,7 +196,6 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                   });
                 },
               ),
-              // Player selection widget.
               Expanded(
                 child: PlayerSelection(
                   key: ValueKey(selectedGroup?.id ?? 'no_group'),
@@ -227,7 +208,6 @@ class _CreateMatchViewState extends State<CreateMatchView> {
                   },
                 ),
               ),
-              // Create or save button.
               CustomWidthButton(
                 text: buttonText,
                 sizeRelativeToWidth: 0.95,
@@ -249,16 +229,16 @@ class _CreateMatchViewState extends State<CreateMatchView> {
   ///
   /// Returns `true` if:
   /// - A ruleset is selected AND
-  /// - Either a group is selected OR at least 2 players are selected.
+  /// - Either a group is selected OR at least 2 players are selected
   bool _enableCreateGameButton() {
     return (selectedGroup != null ||
-        (selectedPlayers.length > 1) && selectedGame != null);
+        (selectedPlayers.length > 1) && selectedGameIndex != -1);
   }
 
-  /// Handles navigation when the create or save button is pressed.
+  // If a match was provided to the view, it updates the match in the database
-  ///
+  // and navigates back to the previous screen.
-  /// If a match is being edited, updates the match in the database.
+  // If no match was provided, it creates a new match in the database and
-  /// Otherwise, creates a new match and navigates to the MatchResultView.
+  // navigates to the MatchResultView for the newly created match.
   void buttonNavigation(BuildContext context) async {
     if (widget.matchToEdit != null) {
       await updateMatch();
@@ -283,8 +263,12 @@ class _CreateMatchViewState extends State<CreateMatchView> {
     }
   }
 
-  /// Updates the existing match in the database.
+  /// Updates attributes of the existing match in the database based on the
+  /// changes made in the edit view.
   Future<void> updateMatch() async {
+    //TODO: Remove when Games implemented
+    final tempGame = await getTemporaryGame();
+
     final updatedMatch = Match(
       id: widget.matchToEdit!.id,
       name: _matchNameController.text.isEmpty
@@ -292,7 +276,7 @@ class _CreateMatchViewState extends State<CreateMatchView> {
           : _matchNameController.text.trim(),
       group: selectedGroup,
       players: selectedPlayers,
-      game: selectedGame!,
+      game: tempGame,
       winner: widget.matchToEdit!.winner,
       createdAt: widget.matchToEdit!.createdAt,
       endedAt: widget.matchToEdit!.endedAt,
@@ -313,13 +297,7 @@ class _CreateMatchViewState extends State<CreateMatchView> {
       );
     }
 
-    if (widget.matchToEdit!.game.id != updatedMatch.game.id) {
+    // Add players who are in updatedMatch but not in the original match
-      await db.matchDao.updateMatchGame(
-        matchId: widget.matchToEdit!.id,
-        gameId: updatedMatch.game.id,
-      );
-    }
-
     for (var player in updatedMatch.players) {
       if (!widget.matchToEdit!.players.any((p) => p.id == player.id)) {
         await db.playerMatchDao.addPlayerToMatch(
@@ -329,6 +307,7 @@ class _CreateMatchViewState extends State<CreateMatchView> {
       }
     }
 
+    // Remove players who are in the original match but not in updatedMatch
     for (var player in widget.matchToEdit!.players) {
       if (!updatedMatch.players.any((p) => p.id == player.id)) {
         await db.playerMatchDao.removePlayerFromMatch(
@@ -344,8 +323,11 @@ class _CreateMatchViewState extends State<CreateMatchView> {
     widget.onMatchUpdated?.call(updatedMatch);
   }
 
-  /// Creates a new match and adds it to the database.
+  // Creates a new match and adds it to the database.
+  // Returns the created match.
   Future<Match> createMatch() async {
+    final tempGame = await getTemporaryGame();
+
     Match match = Match(
       name: _matchNameController.text.isEmpty
           ? (hintText ?? '')
@@ -353,25 +335,43 @@ class _CreateMatchViewState extends State<CreateMatchView> {
       createdAt: DateTime.now(),
       group: selectedGroup,
       players: selectedPlayers,
-      game: selectedGame!,
+      game: tempGame,
     );
     await db.matchDao.addMatch(match: match);
     return match;
   }
 
-  /// Prefills the input fields if a match was provided to the view.
+  // TODO: Remove when games fully implemented
+  Future<Game> getTemporaryGame() async {
+    Game? game;
+
+    final selectedGame = games[selectedGameIndex];
+    game = Game(
+      name: selectedGame.$1,
+      description: selectedGame.$2,
+      ruleset: selectedGame.$3,
+      color: GameColor.blue,
+      icon: '',
+    );
+
+    await db.gameDao.addGame(game: game);
+    return game;
+  }
+
+  // If a match was provided to the view, this method prefills the input fields
   void prefillMatchDetails() {
     final match = widget.matchToEdit!;
     _matchNameController.text = match.name;
     selectedPlayers = match.players;
-    selectedGame = match.game;
+    selectedGameIndex = 0;
 
     if (match.group != null) {
       selectedGroup = match.group;
     }
   }
 
-  /// Removes the group if none of its members are in the selected players list.
+  // If none of the selected players are from the currently selected group,
+  // the group is also deselected.
   Future<void> removeGroupWhenNoMemberLeft() async {
     if (selectedGroup == null) return;
 
@@ -384,13 +384,4 @@ class _CreateMatchViewState extends State<CreateMatchView> {
       });
     }
   }
-
-  /// Loads all games from the database and updates the state.
-  Future<void> loadGames() async {
-    final result = await db.gameDao.getAllGames();
-    result.sort((a, b) => b.createdAt.compareTo(a.createdAt));
-    setState(() {
-      gamesList = result;
-    });
-  }
 }

lib/presentation/views/main_menu/match_view/create_match/game_view/choose_color_view.dart

@@ -1,78 +0,0 @@
-import 'package:flutter/material.dart';
-import 'package:tallee/core/common.dart';
-import 'package:tallee/core/custom_theme.dart';
-import 'package:tallee/core/enums.dart';
-import 'package:tallee/l10n/generated/app_localizations.dart';
-import 'package:tallee/presentation/widgets/tiles/title_description_list_tile.dart';
-
-class ChooseColorView extends StatefulWidget {
-  /// A view that allows the user to choose a color from a list of available game colors
-  /// - [initialColor]: The initially selected color
-  const ChooseColorView({super.key, this.initialColor});
-
-  /// The initially selected color
-  final GameColor? initialColor;
-
-  @override
-  State<ChooseColorView> createState() => _ChooseColorViewState();
-}
-
-class _ChooseColorViewState extends State<ChooseColorView> {
-  /// Currently selected color
-  GameColor? selectedColor;
-
-  @override
-  void initState() {
-    selectedColor = widget.initialColor;
-    super.initState();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    final loc = AppLocalizations.of(context);
-    const colors = GameColor.values;
-
-    return Scaffold(
-      backgroundColor: CustomTheme.backgroundColor,
-      appBar: AppBar(
-        leading: IconButton(
-          icon: const Icon(Icons.arrow_back_ios),
-          onPressed: () {
-            Navigator.of(context).pop(selectedColor);
-          },
-        ),
-        title: Text(loc.choose_color),
-      ),
-      body: PopScope(
-        canPop: false,
-        onPopInvokedWithResult: (bool didPop, Object? result) {
-          if (didPop) return;
-          Navigator.of(context).pop(selectedColor);
-        },
-        child: ListView.builder(
-          padding: const EdgeInsets.only(bottom: 85),
-          itemCount: colors.length,
-          itemBuilder: (BuildContext context, int index) {
-            final color = colors[index];
-            return TitleDescriptionListTile(
-              onTap: () {
-                setState(() {
-                  if (selectedColor == color) {
-                    selectedColor = null;
-                  } else {
-                    selectedColor = color;
-                  }
-                });
-              },
-              title: translateGameColorToString(color, context),
-              description: '',
-              isHighlighted: selectedColor == color,
-              badgeText: '          ', //Breite für Color Badge
-              badgeColor: getColorFromGameColor(color),
-            );
-          },
-        ),
-      ),
-    );
-  }
-}

lib/presentation/views/main_menu/match_view/create_match/game_view/choose_ruleset_view.dart

@@ -1,99 +0,0 @@
-import 'package:flutter/material.dart';
-import 'package:tallee/core/common.dart';
-import 'package:tallee/core/custom_theme.dart';
-import 'package:tallee/core/enums.dart';
-import 'package:tallee/l10n/generated/app_localizations.dart';
-import 'package:tallee/presentation/widgets/tiles/title_description_list_tile.dart';
-
-class ChooseRulesetView extends StatefulWidget {
-  /// A view that allows the user to choose a ruleset from a list of available rulesets
-  /// - [rulesets]: A list of tuples containing the ruleset and its description
-  /// - [initialRulesetIndex]: The index of the initially selected ruleset
-  const ChooseRulesetView({
-    super.key,
-    required this.rulesets,
-    required this.initialRulesetIndex,
-  });
-
-  /// A list of tuples containing the ruleset and its description
-  final List<(Ruleset, String)> rulesets;
-
-  /// The index of the initially selected ruleset
-  final int initialRulesetIndex;
-  @override
-  State<ChooseRulesetView> createState() => _ChooseRulesetViewState();
-}
-
-class _ChooseRulesetViewState extends State<ChooseRulesetView> {
-  /// Currently selected ruleset index
-  late int selectedRulesetIndex;
-
-  @override
-  void initState() {
-    selectedRulesetIndex = widget.initialRulesetIndex;
-    super.initState();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    final loc = AppLocalizations.of(context);
-    return DefaultTabController(
-      length: 2,
-      initialIndex: 0,
-      child: Scaffold(
-        backgroundColor: CustomTheme.backgroundColor,
-        appBar: AppBar(
-          leading: IconButton(
-            icon: const Icon(Icons.arrow_back_ios),
-            onPressed: () {
-              Navigator.of(context).pop(
-                selectedRulesetIndex == -1
-                    ? null
-                    : widget.rulesets[selectedRulesetIndex].$1,
-              );
-            },
-          ),
-          title: Text(loc.choose_ruleset),
-        ),
-        body: PopScope(
-          // This fixes that the Android Back Gesture didn't return the
-          // selectedRulesetIndex and therefore the selected Ruleset wasn't saved
-          canPop: false,
-          onPopInvokedWithResult: (bool didPop, Object? result) {
-            if (didPop) {
-              return;
-            }
-            Navigator.of(context).pop(
-              selectedRulesetIndex == -1
-                  ? null
-                  : widget.rulesets[selectedRulesetIndex].$1,
-            );
-          },
-          child: ListView.builder(
-            padding: const EdgeInsets.only(bottom: 85),
-            itemCount: widget.rulesets.length,
-            itemBuilder: (BuildContext context, int index) {
-              return TitleDescriptionListTile(
-                onTap: () async {
-                  setState(() {
-                    if (selectedRulesetIndex == index) {
-                      selectedRulesetIndex = -1;
-                    } else {
-                      selectedRulesetIndex = index;
-                    }
-                  });
-                },
-                title: translateRulesetToString(
-                  widget.rulesets[index].$1,
-                  context,
-                ),
-                description: widget.rulesets[index].$2,
-                isHighlighted: selectedRulesetIndex == index,
-              );
-            },
-          ),
-        ),
-      ),
-    );
-  }
-}

lib/presentation/views/main_menu/match_view/create_match/game_view/create_game_view.dart

@@ -1,351 +0,0 @@
-import 'package:flutter/material.dart';
-import 'package:provider/provider.dart';
-import 'package:tallee/core/adaptive_page_route.dart';
-import 'package:tallee/core/common.dart';
-import 'package:tallee/core/constants.dart';
-import 'package:tallee/core/custom_theme.dart';
-import 'package:tallee/core/enums.dart';
-import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/game.dart';
-import 'package:tallee/data/dto/group.dart';
-import 'package:tallee/l10n/generated/app_localizations.dart';
-import 'package:tallee/presentation/views/main_menu/match_view/create_match/game_view/choose_color_view.dart';
-import 'package:tallee/presentation/views/main_menu/match_view/create_match/game_view/choose_ruleset_view.dart';
-import 'package:tallee/presentation/widgets/buttons/custom_width_button.dart';
-import 'package:tallee/presentation/widgets/custom_alert_dialog.dart';
-import 'package:tallee/presentation/widgets/text_input/text_input_field.dart';
-import 'package:tallee/presentation/widgets/tiles/choose_tile.dart';
-
-/// A stateful widget for creating or editing a game.
-/// - [gameToEdit] An optional game to prefill the fields
-/// - [onGameChanged] Callback to invoke when the game is created or edited
-class CreateGameView extends StatefulWidget {
-  const CreateGameView({
-    super.key,
-    this.gameToEdit,
-    required this.onGameChanged,
-  });
-
-  /// An optional game to prefill the fields
-  final Game? gameToEdit;
-
-  /// Callback to invoke when the game is created or edited
-  final VoidCallback onGameChanged;
-
-  @override
-  State<CreateGameView> createState() => _CreateGameViewState();
-}
-
-class _CreateGameViewState extends State<CreateGameView> {
-  /// GlobalKey for ScaffoldMessenger to show snackbars
-  final _scaffoldMessengerKey = GlobalKey<ScaffoldMessengerState>();
-
-  /// The database instance for accessing game data.
-  late final AppDatabase db;
-
-  /// The currently selected ruleset for the game.
-  Ruleset? selectedRuleset;
-
-  /// The index of the currently selected ruleset.
-  int selectedRulesetIndex = -1;
-
-  /// A list of available rulesets and their localized names.
-  late List<(Ruleset, String)> _rulesets;
-
-  /// The currently selected color for the game.
-  GameColor? selectedColor;
-
-  /// Controller for the game name input field.
-  final _gameNameController = TextEditingController();
-
-  /// Controller for the game description input field.
-  final _descriptionController = TextEditingController();
-
-  /// The ID of the currently selected group.
-  late String selectedGroupId;
-
-  /// A controller for the search bar input field.
-  final TextEditingController controller = TextEditingController();
-
-  /// A list of groups filtered based on the search query.
-  late final List<Group> filteredGroups;
-
-  @override
-  void initState() {
-    super.initState();
-    db = Provider.of<AppDatabase>(context, listen: false);
-    _gameNameController.addListener(() => setState(() {}));
-  }
-
-  @override
-  void didChangeDependencies() {
-    super.didChangeDependencies();
-    _rulesets = [
-      (
-        Ruleset.singleWinner,
-        translateRulesetToString(Ruleset.singleWinner, context),
-      ),
-      (
-        Ruleset.singleLoser,
-        translateRulesetToString(Ruleset.singleLoser, context),
-      ),
-      (
-        Ruleset.highestScore,
-        translateRulesetToString(Ruleset.highestScore, context),
-      ),
-      (
-        Ruleset.lowestScore,
-        translateRulesetToString(Ruleset.lowestScore, context),
-      ),
-      (
-        Ruleset.multipleWinners,
-        translateRulesetToString(Ruleset.multipleWinners, context),
-      ),
-    ];
-
-    if (widget.gameToEdit != null) {
-      _gameNameController.text = widget.gameToEdit!.name;
-      _descriptionController.text = widget.gameToEdit!.description;
-      selectedRuleset = widget.gameToEdit!.ruleset;
-      selectedColor = widget.gameToEdit!.color;
-
-      selectedRulesetIndex = _rulesets.indexWhere(
-        (r) => r.$1 == selectedRuleset,
-      );
-    }
-  }
-
-  @override
-  void dispose() {
-    _gameNameController.dispose();
-    _descriptionController.dispose();
-    super.dispose();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    var loc = AppLocalizations.of(context);
-    final isEditing = widget.gameToEdit != null;
-
-    return ScaffoldMessenger(
-      child: Scaffold(
-        backgroundColor: CustomTheme.backgroundColor,
-        appBar: AppBar(
-          title: Text(isEditing ? loc.edit_game : loc.create_game),
-          actions: widget.gameToEdit == null
-              ? []
-              : [
-                  IconButton(
-                    icon: const Icon(Icons.delete),
-                    onPressed: () async {
-                      if (widget.gameToEdit != null) {
-                        showDialog<bool>(
-                          context: context,
-                          builder: (context) => CustomAlertDialog(
-                            title: loc.delete_game,
-                            content: loc.this_cannot_be_undone,
-                            actions: [
-                              TextButton(
-                                onPressed: () =>
-                                    Navigator.of(context).pop(false),
-                                child: Text(loc.cancel),
-                              ),
-                              TextButton(
-                                onPressed: () =>
-                                    Navigator.of(context).pop(true),
-                                child: Text(loc.delete),
-                              ),
-                            ],
-                          ),
-                        ).then((confirmed) async {
-                          if (confirmed == true && context.mounted) {
-                            bool success = await db.gameDao.deleteGame(
-                              gameId: widget.gameToEdit!.id,
-                            );
-                            if (!context.mounted) return;
-                            if (success) {
-                              widget.onGameChanged.call();
-                              Navigator.of(
-                                context,
-                              ).pop((game: widget.gameToEdit, delete: true));
-                            } else {
-                              if (!mounted) return;
-                              showSnackbar(message: loc.error_deleting_game);
-                            }
-                          }
-                        });
-                      }
-                    },
-                  ),
-                ],
-        ),
-        body: SafeArea(
-          child: Column(
-            children: [
-              Container(
-                margin: CustomTheme.tileMargin,
-                child: TextInputField(
-                  controller: _gameNameController,
-                  maxLength: Constants.MAX_MATCH_NAME_LENGTH,
-                  hintText: loc.game_name,
-                ),
-              ),
-              ChooseTile(
-                title: loc.ruleset,
-                trailingText: selectedRuleset == null
-                    ? loc.none
-                    : translateRulesetToString(selectedRuleset!, context),
-                onPressed: () async {
-                  final result = await Navigator.of(context).push<Ruleset?>(
-                    adaptivePageRoute(
-                      builder: (context) => ChooseRulesetView(
-                        rulesets: _rulesets,
-                        initialRulesetIndex: selectedRulesetIndex,
-                      ),
-                    ),
-                  );
-                  if (mounted) {
-                    setState(() {
-                      selectedRuleset = result;
-                      selectedRulesetIndex = result == null
-                          ? -1
-                          : _rulesets.indexWhere((r) => r.$1 == result);
-                    });
-                  }
-                },
-              ),
-              ChooseTile(
-                title: loc.color,
-                trailingText: selectedColor == null
-                    ? loc.none
-                    : translateGameColorToString(selectedColor!, context),
-                onPressed: () async {
-                  final result = await Navigator.of(context).push<GameColor?>(
-                    adaptivePageRoute(
-                      builder: (context) =>
-                          ChooseColorView(initialColor: selectedColor),
-                    ),
-                  );
-                  if (mounted) {
-                    setState(() {
-                      selectedColor = result;
-                    });
-                  }
-                },
-              ),
-              Container(
-                margin: CustomTheme.tileMargin,
-                child: TextInputField(
-                  controller: _descriptionController,
-                  hintText: loc.description,
-                  minLines: 6,
-                  maxLines: 6,
-                  maxLength: Constants.MAX_GAME_DESCRIPTION_LENGTH,
-                  showCounterText: true,
-                ),
-              ),
-              const Spacer(),
-              Padding(
-                padding: const EdgeInsets.all(12.0),
-                child: CustomWidthButton(
-                  text: isEditing ? loc.edit_game : loc.create_game,
-                  sizeRelativeToWidth: 1,
-                  buttonType: ButtonType.primary,
-                  onPressed:
-                      _gameNameController.text.trim().isNotEmpty &&
-                          selectedRulesetIndex != -1 &&
-                          selectedColor != null
-                      ? () async {
-                          Game newGame = Game(
-                            name: _gameNameController.text.trim(),
-                            description: _descriptionController.text.trim(),
-                            ruleset: selectedRuleset!,
-                            color: selectedColor!,
-                          );
-                          if (isEditing) {
-                            await handleGameUpdate(newGame);
-                          } else {
-                            await handleGameCreation(newGame);
-                          }
-                          widget.onGameChanged.call();
-                          if (context.mounted) {
-                            Navigator.of(
-                              context,
-                            ).pop((game: newGame, delete: false));
-                          }
-                        }
-                      : null,
-                ),
-              ),
-            ],
-          ),
-        ),
-      ),
-    );
-  }
-
-  /// Handles updating an existing game in the database.
-  ///
-  /// [newGame] The updated game object.
-  Future<void> handleGameUpdate(Game newGame) async {
-    final oldGame = widget.gameToEdit!;
-
-    if (oldGame.name != newGame.name) {
-      await db.gameDao.updateGameName(
-        gameId: oldGame.id,
-        newName: newGame.name,
-      );
-    }
-
-    if (oldGame.description != newGame.description) {
-      await db.gameDao.updateGameDescription(
-        gameId: oldGame.id,
-        newDescription: newGame.description,
-      );
-    }
-
-    if (oldGame.ruleset != newGame.ruleset) {
-      await db.gameDao.updateGameRuleset(
-        gameId: oldGame.id,
-        newRuleset: newGame.ruleset,
-      );
-    }
-
-    if (oldGame.color != newGame.color) {
-      await db.gameDao.updateGameColor(
-        gameId: oldGame.id,
-        newColor: newGame.color,
-      );
-    }
-
-    if (oldGame.icon != newGame.icon) {
-      await db.gameDao.updateGameIcon(
-        gameId: oldGame.id,
-        newIcon: newGame.icon,
-      );
-    }
-  }
-
-  /// Handles creating a new game in the database.
-  ///
-  /// [newGame] The game object to be created.
-  Future<void> handleGameCreation(Game newGame) async {
-    await db.gameDao.addGame(game: newGame);
-  }
-
-  /// Displays a snackbar with the given message and optional action.
-  ///
-  /// [message] The message to display in the snackbar.
-  void showSnackbar({required String message}) {
-    final messenger = _scaffoldMessengerKey.currentState;
-    if (messenger != null) {
-      messenger.hideCurrentSnackBar();
-      messenger.showSnackBar(
-        SnackBar(
-          content: Text(message, style: const TextStyle(color: Colors.white)),
-          backgroundColor: CustomTheme.boxColor,
-        ),
-      );
-    }
-  }
-}

lib/presentation/views/main_menu/match_view/match_detail_view.dart

@@ -5,7 +5,7 @@ import 'package:tallee/core/adaptive_page_route.dart';
 import 'package:tallee/core/common.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/views/main_menu/match_view/create_match/create_match_view.dart';
 import 'package:tallee/presentation/views/main_menu/match_view/match_result_view.dart';
@@ -161,6 +161,7 @@ class _MatchDetailViewState extends State<MatchDetailView> {
                     children: match.players.map((player) {
                       return TextIconTile(
                         text: player.name,
+                        suffixText: getNameCountText(player),
                         iconEnabled: false,
                       );
                     }).toList(),

lib/presentation/views/main_menu/match_view/match_result_view.dart

@@ -2,8 +2,8 @@ import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/widgets/tiles/custom_radio_list_tile.dart';
 
@@ -139,11 +139,11 @@ class _MatchResultViewState extends State<MatchResultView> {
   /// based on the current selection.
   Future<void> _handleWinnerSaving() async {
     if (_selectedPlayer == null) {
-      await db.matchDao.removeWinner(matchId: widget.match.id);
+      await db.scoreEntryDao.removeWinner(matchId: widget.match.id);
     } else {
-      await db.matchDao.setWinner(
+      await db.scoreEntryDao.setWinner(
         matchId: widget.match.id,
-        winnerId: _selectedPlayer!.id,
+        playerId: _selectedPlayer!.id,
       );
     }
     widget.onWinnerChanged?.call();

lib/presentation/views/main_menu/match_view/match_view.dart

@@ -6,10 +6,10 @@ import 'package:tallee/core/constants.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/models/game.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/views/main_menu/match_view/create_match/create_match_view.dart';
 import 'package:tallee/presentation/views/main_menu/match_view/match_detail_view.dart';
@@ -19,7 +19,7 @@ import 'package:tallee/presentation/widgets/tiles/match_tile.dart';
 import 'package:tallee/presentation/widgets/top_centered_message.dart';
 
 class MatchView extends StatefulWidget {
-  /// A view that displays a list of matches.
+  /// A view that displays a list of matches
   const MatchView({super.key});
 
   @override
@@ -27,14 +27,11 @@ class MatchView extends StatefulWidget {
 }
 
 class _MatchViewState extends State<MatchView> {
-  /// Database instance used to access match data.
   late final AppDatabase db;
-
-  /// Indicates whether matches are currently being loaded.
   bool isLoading = true;
 
   /// Loaded matches from the database,
-  /// initially filled with skeleton matches.
+  /// initially filled with skeleton matches
   List<Match> matches = List.filled(
     4,
     Match(
@@ -44,6 +41,7 @@ class _MatchViewState extends State<MatchView> {
         ruleset: Ruleset.singleWinner,
         description: '',
         color: GameColor.blue,
+        icon: '',
       ),
       group: Group(
         name: 'Group name',

lib/presentation/views/main_menu/settings_view/licenses/oss_licenses.dart

@@ -70,6 +70,8 @@ const allDependencies = <Package>[
   _http_parser,
   _intl,
   _io,
+  _jni,
+  _jni_flutter,
   _js,
   _json_annotation,
   _json_schema,
@@ -360,13 +362,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// async 2.13.0
+/// async 2.13.1
 const _async = Package(
     name: 'async',
     description: "Utility functions and classes related to the 'dart:async' library.",
     repository: 'https://github.com/dart-lang/core/tree/main/pkgs/async',
     authors: [],
-    version: '2.13.0',
+    version: '2.13.1',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -442,13 +444,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// build 4.0.4
+/// build 4.0.5
 const _build = Package(
     name: 'build',
     description: 'A package for authoring build_runner compatible code generators.',
     repository: 'https://github.com/dart-lang/build/tree/master/build',
     authors: [],
-    version: '4.0.4',
+    version: '4.0.5',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -565,13 +567,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// build_runner 2.12.2
+/// build_runner 2.13.1
 const _build_runner = Package(
     name: 'build_runner',
     description: 'A build system for Dart code generation and modular compilation.',
     repository: 'https://github.com/dart-lang/build/tree/master/build_runner',
     authors: [],
-    version: '2.12.2',
+    version: '2.13.1',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -649,14 +651,14 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// built_value 8.12.4
+/// built_value 8.12.5
 const _built_value = Package(
     name: 'built_value',
     description: '''Value types with builders, Dart classes as enums, and serialization. This library is the runtime dependency.
 ''',
     repository: 'https://github.com/google/built_value.dart/tree/master/built_value',
     authors: [],
-    version: '8.12.4',
+    version: '8.12.5',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -1436,18 +1438,18 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// cupertino_icons 1.0.8
+/// cupertino_icons 1.0.9
 const _cupertino_icons = Package(
     name: 'cupertino_icons',
     description: 'Default icons asset for Cupertino widgets based on Apple styled icons',
     repository: 'https://github.com/flutter/packages/tree/main/third_party/packages/cupertino_icons',
     authors: [],
-    version: '1.0.8',
+    version: '1.0.9',
     spdxIdentifiers: ['MIT'],
     isMarkdown: false,
     isSdk: false,
     dependencies: [],
-    devDependencies: [PackageRef('flutter'), PackageRef('flutter_test')],
+    devDependencies: [PackageRef('collection'), PackageRef('flutter'), PackageRef('flutter_test'), PackageRef('path')],
     license: '''The MIT License (MIT)
 
 Copyright (c) 2016 Vladimir Kharlampidi
@@ -2627,13 +2629,13 @@ const _flutter_localizations = Package(
     devDependencies: [PackageRef('flutter_test')],
   );
 
-/// flutter_plugin_android_lifecycle 2.0.33
+/// flutter_plugin_android_lifecycle 2.0.34
 const _flutter_plugin_android_lifecycle = Package(
     name: 'flutter_plugin_android_lifecycle',
     description: 'Flutter plugin for accessing an Android Lifecycle within other plugins.',
     repository: 'https://github.com/flutter/packages/tree/main/packages/flutter_plugin_android_lifecycle',
     authors: [],
-    version: '2.0.33',
+    version: '2.0.34',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -3173,6 +3175,88 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
+/// jni 1.0.0
+const _jni = Package(
+    name: 'jni',
+    description: 'A library to access JNI from Dart and Flutter that acts as a support library for package:jnigen.',
+    repository: 'https://github.com/dart-lang/native/tree/main/pkgs/jni',
+    authors: [],
+    version: '1.0.0',
+    spdxIdentifiers: ['BSD-3-Clause'],
+    isMarkdown: false,
+    isSdk: false,
+    dependencies: [PackageRef('args'), PackageRef('collection'), PackageRef('ffi'), PackageRef('meta'), PackageRef('package_config'), PackageRef('path'), PackageRef('plugin_platform_interface')],
+    devDependencies: [PackageRef('dart_style'), PackageRef('logging'), PackageRef('test')],
+    license: '''Copyright 2022, the Dart project authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google LLC nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
+  );
+
+/// jni_flutter 1.0.1
+const _jni_flutter = Package(
+    name: 'jni_flutter',
+    description: 'A library to access Flutter Android specific APIs from Dart.',
+    repository: 'https://github.com/dart-lang/native/tree/main/pkgs/jni_flutter',
+    authors: [],
+    version: '1.0.1',
+    spdxIdentifiers: ['BSD-3-Clause'],
+    isMarkdown: false,
+    isSdk: false,
+    dependencies: [PackageRef('flutter'), PackageRef('jni')],
+    devDependencies: [PackageRef('flutter_test')],
+    license: '''Copyright 2026, the Dart project authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google LLC nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
+  );
+
 /// js 0.7.2
 const _js = Package(
     name: 'js',
@@ -3511,13 +3595,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// markdown 7.3.0
+/// markdown 7.3.1
 const _markdown = Package(
     name: 'markdown',
     description: 'A portable Markdown library written in Dart that can parse Markdown into HTML.',
     repository: 'https://github.com/dart-lang/tools/tree/main/pkgs/markdown',
     authors: [],
-    version: '7.3.0',
+    version: '7.3.1',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -3890,13 +3974,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// native_toolchain_c 0.17.5
+/// native_toolchain_c 0.17.6
 const _native_toolchain_c = Package(
     name: 'native_toolchain_c',
     description: 'A library to invoke the native C compiler installed on the host machine.',
     repository: 'https://github.com/dart-lang/native/tree/main/pkgs/native_toolchain_c',
     authors: [],
-    version: '0.17.5',
+    version: '0.17.6',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -4110,14 +4194,14 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// package_info_plus 9.0.0
+/// package_info_plus 9.0.1
 const _package_info_plus = Package(
     name: 'package_info_plus',
     description: 'Flutter plugin for querying information about the application package, such as CFBundleVersion on iOS or versionCode on Android.',
     homepage: 'https://github.com/fluttercommunity/plus_plugins',
     repository: 'https://github.com/fluttercommunity/plus_plugins/tree/main/packages/package_info_plus/package_info_plus',
     authors: [],
-    version: '9.0.0',
+    version: '9.0.1',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -4194,13 +4278,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// pana 0.23.10
+/// pana 0.23.11
 const _pana = Package(
     name: 'pana',
     description: 'PAckage aNAlyzer - produce a report summarizing the health and quality of a Dart package.',
     repository: 'https://github.com/dart-lang/pana',
     authors: [],
-    version: '0.23.10',
+    version: '0.23.11',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -4315,17 +4399,17 @@ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// path_provider_android 2.2.22
+/// path_provider_android 2.3.1
 const _path_provider_android = Package(
     name: 'path_provider_android',
     description: 'Android implementation of the path_provider plugin.',
     repository: 'https://github.com/flutter/packages/tree/main/packages/path_provider/path_provider_android',
     authors: [],
-    version: '2.2.22',
+    version: '2.3.1',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
-    dependencies: [PackageRef('flutter'), PackageRef('path_provider_platform_interface')],
+    dependencies: [PackageRef('flutter'), PackageRef('jni'), PackageRef('jni_flutter'), PackageRef('path_provider_platform_interface')],
     devDependencies: [PackageRef('flutter_test'), PackageRef('test')],
     license: '''Copyright 2013 The Flutter Authors
 
@@ -36119,13 +36203,13 @@ Copyright (C) 2009-2017, International Business Machines Corporation,
 Google, and others. All Rights Reserved.''',
   );
 
-/// source_gen 4.2.0
+/// source_gen 4.2.2
 const _source_gen = Package(
     name: 'source_gen',
     description: 'Source code generation builders and utilities for the Dart build system',
     repository: 'https://github.com/dart-lang/source_gen/tree/master/source_gen',
     authors: [],
-    version: '4.2.0',
+    version: '4.2.2',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -36318,13 +36402,13 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.''',
   );
 
-/// sqlite3_flutter_libs 0.5.41
+/// sqlite3_flutter_libs 0.5.42
 const _sqlite3_flutter_libs = Package(
     name: 'sqlite3_flutter_libs',
     description: 'Flutter plugin to include native sqlite3 libraries with your app',
     homepage: 'https://github.com/simolus3/sqlite3.dart/tree/v2/sqlite3_flutter_libs',
     authors: [],
-    version: '0.5.41',
+    version: '0.5.42',
     spdxIdentifiers: ['MIT'],
     isMarkdown: false,
     isSdk: false,
@@ -36835,13 +36919,13 @@ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.''',
   );
 
-/// url_launcher_android 6.3.28
+/// url_launcher_android 6.3.29
 const _url_launcher_android = Package(
     name: 'url_launcher_android',
     description: 'Android implementation of the url_launcher plugin.',
     repository: 'https://github.com/flutter/packages/tree/main/packages/url_launcher/url_launcher_android',
     authors: [],
-    version: '6.3.28',
+    version: '6.3.29',
     spdxIdentifiers: ['BSD-3-Clause'],
     isMarkdown: false,
     isSdk: false,
@@ -37796,12 +37880,12 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.''',
   );
 
-/// tallee 0.0.18+252
+/// tallee 0.0.20+254
 const _tallee = Package(
     name: 'tallee',
     description: 'Tracking App for Card Games',
     authors: [],
-    version: '0.0.18+252',
+    version: '0.0.20+254',
     spdxIdentifiers: ['LGPL-3.0'],
     isMarkdown: false,
     isSdk: false,

lib/presentation/views/main_menu/statistics_view.dart

@@ -2,8 +2,8 @@ import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import 'package:tallee/core/constants.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/widgets/app_skeleton.dart';
 import 'package:tallee/presentation/widgets/tiles/statistics_tile.dart';
@@ -167,7 +167,8 @@ class _StatisticsViewState extends State<StatisticsView> {
       final playerId = winCounts[i].$1;
       final player = players.firstWhere(
         (p) => p.id == playerId,
-        orElse: () => Player(id: playerId, name: loc.not_available, description: ''),
+        orElse: () =>
+            Player(id: playerId, name: loc.not_available, description: ''),
       );
       winCounts[i] = (player.name, winCounts[i].$2);
     }
@@ -208,11 +209,11 @@ class _StatisticsViewState extends State<StatisticsView> {
         // -1 means player not found in matchCounts
         if (index != -1) {
           final current = matchCounts[index].$2;
-            matchCounts[index] = (playerId, current + 1);
+          matchCounts[index] = (playerId, current + 1);
-          } else {
+        } else {
-            matchCounts.add((playerId, 1));
+          matchCounts.add((playerId, 1));
-          }
         }
+      }
     }
 
     // Adding all players with zero matches
@@ -229,7 +230,8 @@ class _StatisticsViewState extends State<StatisticsView> {
       final playerId = matchCounts[i].$1;
       final player = players.firstWhere(
         (p) => p.id == playerId,
-        orElse: () => Player(id: playerId, name: loc.not_available, description: ''),
+        orElse: () =>
+            Player(id: playerId, name: loc.not_available, description: ''),
       );
       matchCounts[i] = (player.name, matchCounts[i].$2);
     }

lib/presentation/widgets/player_selection.dart

@@ -1,9 +1,10 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
+import 'package:tallee/core/common.dart';
 import 'package:tallee/core/constants.dart';
 import 'package:tallee/core/custom_theme.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/widgets/app_skeleton.dart';
 import 'package:tallee/presentation/widgets/text_input/custom_search_bar.dart';
@@ -140,6 +141,7 @@ class _PlayerSelectionState extends State<PlayerSelection> {
                               padding: const EdgeInsets.only(right: 8.0),
                               child: TextIconTile(
                                 text: player.name,
+                                suffixText: getNameCountText(player),
                                 onIconTap: () {
                                   setState(() {
                                     // Removes the player from the selection and notifies the parent.
@@ -193,6 +195,7 @@ class _PlayerSelectionState extends State<PlayerSelection> {
                   itemBuilder: (BuildContext context, int index) {
                     return TextIconListTile(
                       text: suggestedPlayers[index].name,
+                      suffixText: getNameCountText(suggestedPlayers[index]),
                       onPressed: () {
                         setState(() {
                           // If the player is not already selected
@@ -282,7 +285,8 @@ class _PlayerSelectionState extends State<PlayerSelection> {
     final loc = AppLocalizations.of(context);
     final playerName = _searchBarController.text.trim();
 
-    final createdPlayer = Player(name: playerName, description: '');
+    int nameCount = _calculateNameCount(playerName);
+    final createdPlayer = Player(name: playerName, nameCount: nameCount);
     final success = await db.playerDao.addPlayer(player: createdPlayer);
 
     if (!context.mounted) return;
@@ -295,6 +299,22 @@ class _PlayerSelectionState extends State<PlayerSelection> {
     }
   }
 
+  int _calculateNameCount(String playerName) {
+    final playersWithSameName =
+        allPlayers.where((player) => player.name == playerName).toList()
+          ..sort((a, b) => a.nameCount.compareTo(b.nameCount));
+
+    if (playersWithSameName.isEmpty) {
+      return 0;
+    } else if (playersWithSameName.length == 1) {
+      // Initialize nameCount
+      playersWithSameName[0].nameCount = 1;
+    }
+
+    // Return following count
+    return playersWithSameName.length + 1;
+  }
+
   /// Updates the state after successfully adding a new player.
   void _handleSuccessfulPlayerCreation(Player player) {
     selectedPlayers.insert(0, player);

lib/presentation/widgets/text_input/text_input_field.dart

@@ -8,18 +8,12 @@ class TextInputField extends StatelessWidget {
   /// - [onChanged]: Optional callback invoked when the text in the field changes.
   /// - [hintText]: The hint text displayed in the text input field when it is empty
   /// - [maxLength]: Optional parameter for maximum length of the input text.
-  /// - [maxLines]: The maximum number of lines for the text input field. Defaults to 1.
-  /// - [minLines]: The minimum number of lines for the text input field. Defaults to 1.
-  /// - [showCounterText]: Whether to show the counter text in the text input field. Defaults to false.
   const TextInputField({
     super.key,
     required this.controller,
     required this.hintText,
     this.onChanged,
     this.maxLength,
-    this.maxLines = 1,
-    this.minLines = 1,
-    this.showCounterText = false,
   });
 
   /// The controller for the text input field.
@@ -34,15 +28,6 @@ class TextInputField extends StatelessWidget {
   /// Optional parameter for maximum length of the input text.
   final int? maxLength;
 
-  /// The maximum number of lines for the text input field.
-  final int? maxLines;
-
-  /// The minimum number of lines for the text input field.
-  final int? minLines;
-
-  /// Whether to show the counter text in the text input field.
-  final bool showCounterText;
-
   @override
   Widget build(BuildContext context) {
     return TextField(
@@ -50,14 +35,13 @@ class TextInputField extends StatelessWidget {
       onChanged: onChanged,
       maxLength: maxLength,
       maxLengthEnforcement: MaxLengthEnforcement.truncateAfterCompositionEnds,
-      maxLines: maxLines,
-      minLines: minLines,
       decoration: InputDecoration(
         filled: true,
         fillColor: CustomTheme.boxColor,
         hintText: hintText,
         hintStyle: const TextStyle(fontSize: 18),
-        counterText: showCounterText ? null : '',
+        // Hides the character counter
+        counterText: '',
         enabledBorder: const OutlineInputBorder(
           borderRadius: BorderRadius.all(Radius.circular(12)),
           borderSide: BorderSide(color: CustomTheme.boxBorderColor),

lib/presentation/widgets/tiles/group_tile.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/material.dart';
+import 'package:tallee/core/common.dart';
 import 'package:tallee/core/custom_theme.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
 import 'package:tallee/presentation/widgets/tiles/text_icon_tile.dart';
 
 class GroupTile extends StatefulWidget {
@@ -81,7 +82,11 @@ class _GroupTileState extends State<GroupTile> {
                 for (var member in [
                   ...widget.group.members,
                 ]..sort((a, b) => a.name.compareTo(b.name)))
-                  TextIconTile(text: member.name, iconEnabled: false),
+                  TextIconTile(
+                    text: member.name,
+                    suffixText: getNameCountText(member),
+                    iconEnabled: false,
+                  ),
               ],
             ),
             const SizedBox(height: 2.5),

lib/presentation/widgets/tiles/match_tile.dart

@@ -4,7 +4,7 @@ import 'package:flutter/material.dart';
 import 'package:intl/intl.dart';
 import 'package:tallee/core/common.dart';
 import 'package:tallee/core/custom_theme.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
 import 'package:tallee/l10n/generated/app_localizations.dart';
 import 'package:tallee/presentation/widgets/tiles/text_icon_tile.dart';
 
@@ -203,7 +203,11 @@ class _MatchTileState extends State<MatchTile> {
                 spacing: 6,
                 runSpacing: 6,
                 children: players.map((player) {
-                  return TextIconTile(text: player.name, iconEnabled: false);
+                  return TextIconTile(
+                    text: player.name,
+                    suffixText: getNameCountText(player),
+                    iconEnabled: false,
+                  );
                 }).toList(),
               ),
             ],

lib/presentation/widgets/tiles/text_icon_list_tile.dart

@@ -9,6 +9,7 @@ class TextIconListTile extends StatelessWidget {
   const TextIconListTile({
     super.key,
     required this.text,
+    this.suffixText = '',
     this.iconEnabled = true,
     this.onPressed,
   });
@@ -16,6 +17,9 @@ class TextIconListTile extends StatelessWidget {
   /// The text to display in the tile.
   final String text;
 
+  /// An optional suffix text to display after the main text.
+  final String suffixText;
+
   /// A boolean to determine if the icon should be displayed.
   final bool iconEnabled;
 
@@ -35,12 +39,27 @@ class TextIconListTile extends StatelessWidget {
           Flexible(
             child: Container(
               padding: const EdgeInsets.symmetric(vertical: 12.5),
-              child: Text(
+              child: RichText(
-                text,
                 overflow: TextOverflow.ellipsis,
-                style: const TextStyle(
+                text: TextSpan(
-                  fontSize: 16,
+                  style: DefaultTextStyle.of(context).style,
-                  fontWeight: FontWeight.w500,
+                  children: [
+                    TextSpan(
+                      text: text,
+                      style: const TextStyle(
+                        fontSize: 16,
+                        fontWeight: FontWeight.w500,
+                      ),
+                    ),
+                    TextSpan(
+                      text: suffixText,
+                      style: TextStyle(
+                        fontSize: 14,
+                        fontWeight: FontWeight.w500,
+                        color: CustomTheme.textColor.withAlpha(100),
+                      ),
+                    ),
+                  ],
                 ),
               ),
             ),

lib/presentation/widgets/tiles/text_icon_tile.dart

@@ -9,6 +9,7 @@ class TextIconTile extends StatelessWidget {
   const TextIconTile({
     super.key,
     required this.text,
+    this.suffixText = '',
     this.iconEnabled = true,
     this.onIconTap,
   });
@@ -16,6 +17,8 @@ class TextIconTile extends StatelessWidget {
   /// The text to display in the tile.
   final String text;
 
+  final String suffixText;
+
   /// A boolean to determine if the icon should be displayed.
   final bool iconEnabled;
 
@@ -36,10 +39,28 @@ class TextIconTile extends StatelessWidget {
         children: [
           if (iconEnabled) const SizedBox(width: 3),
           Flexible(
-            child: Text(
+            child: RichText(
-              text,
               overflow: TextOverflow.ellipsis,
-              style: const TextStyle(fontSize: 14, fontWeight: FontWeight.w500),
+              text: TextSpan(
+                style: DefaultTextStyle.of(context).style,
+                children: [
+                  TextSpan(
+                    text: text,
+                    style: const TextStyle(
+                      fontSize: 14,
+                      fontWeight: FontWeight.w500,
+                    ),
+                  ),
+                  TextSpan(
+                    text: suffixText,
+                    style: TextStyle(
+                      fontSize: 13,
+                      fontWeight: FontWeight.w500,
+                      color: CustomTheme.textColor.withAlpha(120),
+                    ),
+                  ),
+                ],
+              ),
             ),
           ),
           if (iconEnabled) ...<Widget>[

lib/presentation/widgets/tiles/title_description_list_tile.dart

@@ -6,7 +6,6 @@ class TitleDescriptionListTile extends StatelessWidget {
   /// - [title]: The title text displayed on the tile.
   /// - [description]: The description text displayed below the title.
   /// - [onPressed]: The callback invoked when the tile is tapped.
-  /// - [onLongPress]: The callback invoked when the tile is tapped.
   /// - [isHighlighted]: A boolean to determine if the tile should be highlighted.
   /// - [badgeText]: Optional text to display in a badge on the right side of the title.
   /// - [badgeColor]: Optional color for the badge background.
@@ -14,8 +13,7 @@ class TitleDescriptionListTile extends StatelessWidget {
     super.key,
     required this.title,
     required this.description,
-    this.onTap,
+    this.onPressed,
-    this.onLongPress,
     this.isHighlighted = false,
     this.badgeText,
     this.badgeColor,
@@ -28,10 +26,7 @@ class TitleDescriptionListTile extends StatelessWidget {
   final String description;
 
   /// The callback invoked when the tile is tapped.
-  final VoidCallback? onTap;
+  final VoidCallback? onPressed;
-
-  /// The callback invoked when the tile is long-pressed.
-  final VoidCallback? onLongPress;
 
   /// A boolean to determine if the tile should be highlighted.
   final bool isHighlighted;
@@ -45,8 +40,7 @@ class TitleDescriptionListTile extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return GestureDetector(
-      onTap: onTap,
+      onTap: onPressed,
-      onLongPress: onLongPress,
       child: AnimatedContainer(
         margin: const EdgeInsets.symmetric(vertical: 10, horizontal: 10),
         padding: const EdgeInsets.symmetric(vertical: 6, horizontal: 12),

lib/services/data_transfer_service.dart

@@ -8,16 +8,17 @@ import 'package:json_schema/json_schema.dart';
 import 'package:provider/provider.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/models/game.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
-import 'package:tallee/data/dto/team.dart';
+import 'package:tallee/data/models/team.dart';
 
 class DataTransferService {
   /// Deletes all data from the database.
   static Future<void> deleteAllData(BuildContext context) async {
     final db = Provider.of<AppDatabase>(context, listen: false);
+
     await db.matchDao.deleteAllMatches();
     await db.teamDao.deleteAllTeams();
     await db.groupDao.deleteAllGroups();
@@ -70,6 +71,20 @@ class DataTransferService {
               'gameId': m.game.id,
               'groupId': m.group?.id,
               'playerIds': m.players.map((p) => p.id).toList(),
+              'scores': m.scores.map(
+                (playerId, scores) => MapEntry(
+                  playerId,
+                  scores
+                      .map(
+                        (s) => {
+                          'roundNumber': s.roundNumber,
+                          'score': s.score,
+                          'change': s.change,
+                        },
+                      )
+                      .toList(),
+                ),
+              ),
               'notes': m.notes,
             },
           )
@@ -82,8 +97,8 @@ class DataTransferService {
   /// Exports the given JSON string to a file with the specified name.
   /// Returns an [ExportResult] indicating the outcome.
   ///
-  /// [jsonString] The JSON string to be exported.
+  /// - [jsonString]: The JSON string to be exported.
-  /// [fileName] The desired name for the exported file (without extension).
+  /// - [fileName]:  The desired name for the exported file (without extension).
   static Future<ExportResult> exportData(
     String jsonString,
     String fileName,
@@ -124,128 +139,12 @@ class DataTransferService {
       final jsonString = await _readFileContent(path.files.single);
       if (jsonString == null) return ImportResult.fileReadError;
 
-      final isValid = await _validateJsonSchema(jsonString);
+      final isValid = await validateJsonSchema(jsonString);
       if (!isValid) return ImportResult.invalidSchema;
 
-      final Map<String, dynamic> decoded =
+      final decoded = json.decode(jsonString) as Map<String, dynamic>;
-          json.decode(jsonString) as Map<String, dynamic>;
 
-      final List<dynamic> playersJson =
+      await importDataToDatabase(db, decoded);
-          (decoded['players'] as List<dynamic>?) ?? [];
-      final List<dynamic> gamesJson =
-          (decoded['games'] as List<dynamic>?) ?? [];
-      final List<dynamic> groupsJson =
-          (decoded['groups'] as List<dynamic>?) ?? [];
-      final List<dynamic> teamsJson =
-          (decoded['teams'] as List<dynamic>?) ?? [];
-      final List<dynamic> matchesJson =
-          (decoded['matches'] as List<dynamic>?) ?? [];
-
-      // Import Players
-      final List<Player> importedPlayers = playersJson
-          .map((p) => Player.fromJson(p as Map<String, dynamic>))
-          .toList();
-
-      final Map<String, Player> playerById = {
-        for (final p in importedPlayers) p.id: p,
-      };
-
-      // Import Games
-      final List<Game> importedGames = gamesJson
-          .map((g) => Game.fromJson(g as Map<String, dynamic>))
-          .toList();
-
-      final Map<String, Game> gameById = {
-        for (final g in importedGames) g.id: g,
-      };
-
-      // Import Groups
-      final List<Group> importedGroups = groupsJson.map((g) {
-        final map = g as Map<String, dynamic>;
-        final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
-            .cast<String>();
-
-        final members = memberIds
-            .map((id) => playerById[id])
-            .whereType<Player>()
-            .toList();
-
-        return Group(
-          id: map['id'] as String,
-          name: map['name'] as String,
-          description: map['description'] as String,
-          members: members,
-          createdAt: DateTime.parse(map['createdAt'] as String),
-        );
-      }).toList();
-
-      final Map<String, Group> groupById = {
-        for (final g in importedGroups) g.id: g,
-      };
-
-      // Import Teams
-      final List<Team> importedTeams = teamsJson.map((t) {
-        final map = t as Map<String, dynamic>;
-        final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
-            .cast<String>();
-
-        final members = memberIds
-            .map((id) => playerById[id])
-            .whereType<Player>()
-            .toList();
-
-        return Team(
-          id: map['id'] as String,
-          name: map['name'] as String,
-          members: members,
-          createdAt: DateTime.parse(map['createdAt'] as String),
-        );
-      }).toList();
-
-      // Import Matches
-      final List<Match> importedMatches = matchesJson.map((m) {
-        final map = m as Map<String, dynamic>;
-
-        final String gameId = map['gameId'] as String;
-        final String? groupId = map['groupId'] as String?;
-        final List<String> playerIds =
-            (map['playerIds'] as List<dynamic>? ?? []).cast<String>();
-        final DateTime? endedAt = map['endedAt'] != null
-            ? DateTime.parse(map['endedAt'] as String)
-            : null;
-
-        final game = gameById[gameId];
-        final group = (groupId == null) ? null : groupById[groupId];
-        final players = playerIds
-            .map((id) => playerById[id])
-            .whereType<Player>()
-            .toList();
-
-        return Match(
-          id: map['id'] as String,
-          name: map['name'] as String,
-          game:
-              game ??
-              Game(
-                name: 'Unknown',
-                ruleset: Ruleset.singleWinner,
-                description: '',
-                color: GameColor.blue,
-              ),
-          group: group,
-          players: players,
-          createdAt: DateTime.parse(map['createdAt'] as String),
-          endedAt: endedAt,
-          notes: map['notes'] as String? ?? '',
-        );
-      }).toList();
-
-      // Import all data into the database
-      await db.playerDao.addPlayersAsList(players: importedPlayers);
-      await db.gameDao.addGamesAsList(games: importedGames);
-      await db.groupDao.addGroupsAsList(groups: importedGroups);
-      await db.teamDao.addTeamsAsList(teams: importedTeams);
-      await db.matchDao.addMatchAsList(matches: importedMatches);
 
       return ImportResult.success;
     } on FormatException catch (e, stack) {
@@ -261,6 +160,167 @@ class DataTransferService {
     }
   }
 
+  /// Imports parsed JSON data into the database.
+  @visibleForTesting
+  static Future<void> importDataToDatabase(
+    AppDatabase db,
+    Map<String, dynamic> decodedJson,
+  ) async {
+    // Fetch all entities first to create lookup maps for relationships
+    final importedPlayers = parsePlayersFromJson(decodedJson);
+    final playerById = {for (final p in importedPlayers) p.id: p};
+
+    final importedGames = parseGamesFromJson(decodedJson);
+    final gameById = {for (final g in importedGames) g.id: g};
+
+    final importedGroups = parseGroupsFromJson(decodedJson, playerById);
+    final groupById = {for (final g in importedGroups) g.id: g};
+
+    final importedTeams = parseTeamsFromJson(decodedJson, playerById);
+
+    final importedMatches = parseMatchesFromJson(
+      decodedJson,
+      gameById,
+      groupById,
+      playerById,
+    );
+
+    await db.playerDao.addPlayersAsList(players: importedPlayers);
+    await db.gameDao.addGamesAsList(games: importedGames);
+    await db.groupDao.addGroupsAsList(groups: importedGroups);
+    await db.teamDao.addTeamsAsList(teams: importedTeams);
+    await db.matchDao.addMatchAsList(matches: importedMatches);
+  }
+
+  /* Parsing Methods */
+
+  @visibleForTesting
+  static List<Player> parsePlayersFromJson(Map<String, dynamic> decodedJson) {
+    final playersJson = (decodedJson['players'] as List<dynamic>?) ?? [];
+    return playersJson
+        .map((p) => Player.fromJson(p as Map<String, dynamic>))
+        .toList();
+  }
+
+  @visibleForTesting
+  static List<Game> parseGamesFromJson(Map<String, dynamic> decodedJson) {
+    final gamesJson = (decodedJson['games'] as List<dynamic>?) ?? [];
+    return gamesJson
+        .map((g) => Game.fromJson(g as Map<String, dynamic>))
+        .toList();
+  }
+
+  @visibleForTesting
+  static List<Group> parseGroupsFromJson(
+    Map<String, dynamic> decodedJson,
+    Map<String, Player> playerById,
+  ) {
+    final groupsJson = (decodedJson['groups'] as List<dynamic>?) ?? [];
+    return groupsJson.map((g) {
+      final map = g as Map<String, dynamic>;
+      final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
+          .cast<String>();
+
+      final members = memberIds
+          .map((id) => playerById[id])
+          .whereType<Player>()
+          .toList();
+
+      return Group(
+        id: map['id'] as String,
+        name: map['name'] as String,
+        description: map['description'] as String,
+        members: members,
+        createdAt: DateTime.parse(map['createdAt'] as String),
+      );
+    }).toList();
+  }
+
+  /// Parses teams from JSON data.
+  @visibleForTesting
+  static List<Team> parseTeamsFromJson(
+    Map<String, dynamic> decodedJson,
+    Map<String, Player> playerById,
+  ) {
+    final teamsJson = (decodedJson['teams'] as List<dynamic>?) ?? [];
+    return teamsJson.map((t) {
+      final map = t as Map<String, dynamic>;
+      final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
+          .cast<String>();
+
+      final members = memberIds
+          .map((id) => playerById[id])
+          .whereType<Player>()
+          .toList();
+
+      return Team(
+        id: map['id'] as String,
+        name: map['name'] as String,
+        members: members,
+        createdAt: DateTime.parse(map['createdAt'] as String),
+      );
+    }).toList();
+  }
+
+  /// Parses matches from JSON data.
+  @visibleForTesting
+  static List<Match> parseMatchesFromJson(
+    Map<String, dynamic> decodedJson,
+    Map<String, Game> gamesMap,
+    Map<String, Group> groupsMap,
+    Map<String, Player> playersMap,
+  ) {
+    final matchesJson = (decodedJson['matches'] as List<dynamic>?) ?? [];
+    return matchesJson.map((m) {
+      final map = m as Map<String, dynamic>;
+
+      // Extract attributes from json
+      final id = map['id'] as String;
+      final name = map['name'] as String;
+      final gameId = map['gameId'] as String;
+      final groupId = map['groupId'] as String?;
+      final createdAt = DateTime.parse(map['createdAt'] as String);
+      final endedAt = map['endedAt'] != null
+          ? DateTime.parse(map['endedAt'] as String)
+          : null;
+      final notes = map['notes'] as String? ?? '';
+
+      // Link attributes to objects
+      final game = gamesMap[gameId] ?? getFallbackGame();
+      final group = groupId != null ? groupsMap[groupId] : null;
+
+      final playerIds = (map['playerIds'] as List<dynamic>? ?? [])
+          .cast<String>();
+      final players = playerIds
+          .map((id) => playersMap[id])
+          .whereType<Player>()
+          .toList();
+
+      return Match(
+        id: id,
+        name: name,
+        game: game,
+        group: group,
+        players: players,
+        createdAt: createdAt,
+        endedAt: endedAt,
+        notes: notes,
+      );
+    }).toList();
+  }
+
+  /// Creates a fallback game when the referenced game is not found.
+  @visibleForTesting
+  static Game getFallbackGame() {
+    return Game(
+      name: 'Unknown',
+      ruleset: Ruleset.singleWinner,
+      description: '',
+      color: GameColor.blue,
+      icon: '',
+    );
+  }
+
   /// Helper method to read file content from either bytes or path
   static Future<String?> _readFileContent(PlatformFile file) async {
     if (file.bytes != null) return utf8.decode(file.bytes!);
@@ -268,8 +328,10 @@ class DataTransferService {
     return null;
   }
 
-  /// Validates the given JSON string against the predefined schema.
+  /// Validates the given JSON string against the schema
-  static Future<bool> _validateJsonSchema(String jsonString) async {
+  /// in `assets/schema.json`.
+  @visibleForTesting
+  static Future<bool> validateJsonSchema(String jsonString) async {
     final String schemaString;
 
     schemaString = await rootBundle.loadString('assets/schema.json');

pubspec.yaml

@@ -1,7 +1,7 @@
 name: tallee
 description: "Tracking App for Card Games"
 publish_to: 'none'
-version: 0.0.18+252
+version: 0.0.20+254
 
 environment:
   sdk: ^3.8.1
@@ -31,9 +31,9 @@ dependencies:
 dev_dependencies:
   flutter_test:
     sdk: flutter
-  build_runner: ^2.5.4
+  build_runner: ^2.7.0
   dart_pubspec_licenses: ^3.0.14
-  drift_dev: ^2.27.0
+  drift_dev: ^2.29.0
   flutter_lints: ^6.0.0
 
 flutter:

test/db_tests/aggregates/group_test.dart

@@ -3,8 +3,8 @@ import 'package:drift/drift.dart' hide isNull;
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 
 void main() {
   late AppDatabase database;
@@ -62,7 +62,6 @@ void main() {
     await database.close();
   });
   group('Group Tests', () {
-
     // Verifies that a single group can be added and retrieved with all fields and members intact.
     test('Adding and fetching a single group works correctly', () async {
       await database.groupDao.addGroup(group: testGroup1);
@@ -277,20 +276,20 @@ void main() {
     });
 
     // Verifies that updateGroupDescription returns false for a non-existent group.
-    test('updateGroupDescription returns false for non-existent group',
+    test(
-        () async {
+      'updateGroupDescription returns false for non-existent group',
-      final updated = await database.groupDao.updateGroupDescription(
+      () async {
-        groupId: 'non-existent-id',
+        final updated = await database.groupDao.updateGroupDescription(
-        newDescription: 'New Description',
+          groupId: 'non-existent-id',
-      );
+          newDescription: 'New Description',
-      expect(updated, false);
+        );
-    });
+        expect(updated, false);
+      },
+    );
 
     // Verifies that deleteAllGroups removes all groups from the database.
     test('deleteAllGroups removes all groups', () async {
-      await database.groupDao.addGroupsAsList(
+      await database.groupDao.addGroupsAsList(groups: [testGroup1, testGroup2]);
-        groups: [testGroup1, testGroup2],
-      );
 
       final countBefore = await database.groupDao.getGroupCount();
       expect(countBefore, 2);

test/db_tests/aggregates/match_test.dart

@@ -4,10 +4,10 @@ import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/models/game.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 
 void main() {
   late AppDatabase database;
@@ -42,7 +42,7 @@ void main() {
       testPlayer4 = Player(name: 'Diana', description: '');
       testPlayer5 = Player(name: 'Eve', description: '');
       testGroup1 = Group(
-        name: 'Test Group 2',
+        name: 'Test Group 1',
         description: '',
         members: [testPlayer1, testPlayer2, testPlayer3],
       );
@@ -56,6 +56,7 @@ void main() {
         ruleset: Ruleset.singleWinner,
         description: 'A test game',
         color: GameColor.blue,
+        icon: '',
       );
       testMatch1 = Match(
         name: 'First Test Match',
@@ -295,9 +296,9 @@ void main() {
     test('Setting a winner works correctly', () async {
       await database.matchDao.addMatch(match: testMatch1);
 
-      await database.matchDao.setWinner(
+      await database.scoreEntryDao.setWinner(
         matchId: testMatch1.id,
-        winnerId: testPlayer5.id,
+        playerId: testPlayer5.id,
       );
 
       final fetchedMatch = await database.matchDao.getMatchById(
@@ -306,5 +307,68 @@ void main() {
       expect(fetchedMatch.winner, isNotNull);
       expect(fetchedMatch.winner!.id, testPlayer5.id);
     });
+
+    test(
+      'removeMatchGroup removes group from match with existing group',
+      () async {
+        await database.matchDao.addMatch(match: testMatch1);
+
+        final removed = await database.matchDao.removeMatchGroup(
+          matchId: testMatch1.id,
+        );
+        expect(removed, isTrue);
+
+        final updatedMatch = await database.matchDao.getMatchById(
+          matchId: testMatch1.id,
+        );
+        expect(updatedMatch.group, null);
+        expect(updatedMatch.game.id, testMatch1.game.id);
+        expect(updatedMatch.name, testMatch1.name);
+        expect(updatedMatch.notes, testMatch1.notes);
+      },
+    );
+
+    test(
+      'removeMatchGroup on match that already has no group still succeeds',
+      () async {
+        await database.matchDao.addMatch(match: testMatchOnlyPlayers);
+
+        final removed = await database.matchDao.removeMatchGroup(
+          matchId: testMatchOnlyPlayers.id,
+        );
+        expect(removed, isTrue);
+
+        final updatedMatch = await database.matchDao.getMatchById(
+          matchId: testMatchOnlyPlayers.id,
+        );
+        expect(updatedMatch.group, null);
+      },
+    );
+
+    test('removeMatchGroup on non-existing match returns false', () async {
+      final removed = await database.matchDao.removeMatchGroup(
+        matchId: 'non-existing-id',
+      );
+      expect(removed, isFalse);
+    });
+
+    test('Fetching all matches related to a group', () async {
+      var matches = await database.matchDao.getGroupMatches(
+        groupId: 'non-existing-id',
+      );
+
+      expect(matches, isEmpty);
+
+      await database.matchDao.addMatch(match: testMatch1);
+
+      matches = await database.matchDao.getGroupMatches(groupId: testGroup1.id);
+
+      expect(matches, isNotEmpty);
+
+      final match = matches.first;
+      expect(match.id, testMatch1.id);
+      expect(match.group, isNotNull);
+      expect(match.group!.id, testGroup1.id);
+    });
   });
 }

test/db_tests/aggregates/team_test.dart

@@ -4,10 +4,10 @@ import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/models/game.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
-import 'package:tallee/data/dto/team.dart';
+import 'package:tallee/data/models/team.dart';
 
 void main() {
   late AppDatabase database;
@@ -45,12 +45,14 @@ void main() {
         ruleset: Ruleset.singleWinner,
         description: 'Test game 1',
         color: GameColor.blue,
+        icon: '',
       );
       testGame2 = Game(
         name: 'Game 2',
         ruleset: Ruleset.highestScore,
         description: 'Test game 2',
         color: GameColor.red,
+        icon: '',
       );
     });
 
@@ -355,13 +357,11 @@ void main() {
         playerId: testPlayer1.id,
         matchId: match1.id,
         teamId: testTeam1.id,
-        score: 0,
       );
       await database.playerMatchDao.addPlayerToMatch(
         playerId: testPlayer2.id,
         matchId: match1.id,
         teamId: testTeam1.id,
-        score: 0,
       );
 
       // Associate players with teams through match2
@@ -370,13 +370,11 @@ void main() {
         playerId: testPlayer1.id,
         matchId: match2.id,
         teamId: testTeam3.id,
-        score: 0,
       );
       await database.playerMatchDao.addPlayerToMatch(
         playerId: testPlayer3.id,
         matchId: match2.id,
         teamId: testTeam3.id,
-        score: 0,
       );
 
       final team1 = await database.teamDao.getTeamById(teamId: testTeam1.id);

test/db_tests/entities/game_test.dart

@@ -4,7 +4,7 @@ import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/models/game.dart';
 
 void main() {
   late AppDatabase database;
@@ -44,6 +44,7 @@ void main() {
         ruleset: Ruleset.highestScore,
         description: 'A board game about real estate',
         color: GameColor.orange,
+        icon: '',
       );
     });
   });
@@ -137,6 +138,7 @@ void main() {
         ruleset: Ruleset.lowestScore,
         description: 'A simple game',
         color: GameColor.green,
+        icon: '',
       );
       final result = await database.gameDao.addGame(game: gameWithNulls);
       expect(result, true);
@@ -462,6 +464,7 @@ void main() {
         ruleset: Ruleset.multipleWinners,
         description: 'Description with émojis 🎮🎲',
         color: GameColor.purple,
+        icon: '',
       );
       await database.gameDao.addGame(game: specialGame);
 
@@ -478,6 +481,7 @@ void main() {
         name: '',
         ruleset: Ruleset.singleWinner,
         description: '',
+        icon: '',
         color: GameColor.red,
       );
       await database.gameDao.addGame(game: emptyGame);
@@ -499,6 +503,7 @@ void main() {
         description: longString,
         ruleset: Ruleset.multipleWinners,
         color: GameColor.yellow,
+        icon: '',
       );
       await database.gameDao.addGame(game: longGame);
 

test/db_tests/entities/player_test.dart

@@ -1,9 +1,9 @@
 import 'package:clock/clock.dart';
-import 'package:drift/drift.dart' hide isNull;
+import 'package:drift/drift.dart' hide isNull, isNotNull;
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 
 void main() {
   late AppDatabase database;
@@ -35,7 +35,6 @@ void main() {
   });
 
   group('Player Tests', () {
-
     // Verifies that players can be added and retrieved with all fields intact.
     test('Adding and fetching single player works correctly', () async {
       await database.playerDao.addPlayer(player: testPlayer1);
@@ -264,16 +263,22 @@ void main() {
     });
 
     // Verifies that a player with special characters in name is stored correctly.
-    test('Player with special characters in name is stored correctly', () async {
+    test(
-      final specialPlayer = Player(name: 'Test!@#\$%^&*()_+-=[]{}|;\':",.<>?/`~', description: '');
+      'Player with special characters in name is stored correctly',
+      () async {
+        final specialPlayer = Player(
+          name: 'Test!@#\$%^&*()_+-=[]{}|;\':",.<>?/`~',
+          description: '',
+        );
 
-      await database.playerDao.addPlayer(player: specialPlayer);
+        await database.playerDao.addPlayer(player: specialPlayer);
 
-      final fetchedPlayer = await database.playerDao.getPlayerById(
+        final fetchedPlayer = await database.playerDao.getPlayerById(
-        playerId: specialPlayer.id,
+          playerId: specialPlayer.id,
-      );
+        );
-      expect(fetchedPlayer.name, specialPlayer.name);
+        expect(fetchedPlayer.name, specialPlayer.name);
-    });
+      },
+    );
 
     // Verifies that a player with description is stored correctly.
     test('Player with description is stored correctly', () async {
@@ -293,7 +298,10 @@ void main() {
 
     // Verifies that a player with null description is stored correctly.
     test('Player with null description is stored correctly', () async {
-      final playerWithoutDescription = Player(name: 'No Description Player', description: '');
+      final playerWithoutDescription = Player(
+        name: 'No Description Player',
+        description: '',
+      );
 
       await database.playerDao.addPlayer(player: playerWithoutDescription);
 
@@ -373,5 +381,160 @@ void main() {
       );
       expect(playerExists, true);
     });
+
+    group('Name Count Tests', () {
+      test('Single player gets initialized wih name count  0', () async {
+        await database.playerDao.addPlayer(player: testPlayer1);
+
+        final player = await database.playerDao.getPlayerById(
+          playerId: testPlayer1.id,
+        );
+        expect(player.nameCount, 0);
+      });
+
+      test('Multiple players get initialized wih name count  0', () async {
+        await database.playerDao.addPlayersAsList(
+          players: [testPlayer1, testPlayer2],
+        );
+
+        final players = await database.playerDao.getAllPlayers();
+
+        expect(players.length, 2);
+        for (Player p in players) {
+          expect(p.nameCount, 0);
+        }
+      });
+
+      test(
+        'Seperatly added players nameCount gets increased correctly',
+        () async {
+          await database.playerDao.addPlayer(player: testPlayer1);
+
+          final player1 = Player(name: testPlayer1.name, description: '');
+          await database.playerDao.addPlayer(player: player1);
+
+          var players = await database.playerDao.getAllPlayers();
+
+          expect(players.length, 2);
+          players.sort((a, b) => a.nameCount.compareTo(b.nameCount));
+
+          for (int i = 0; i < players.length - 1; i++) {
+            expect(players[i].nameCount, i + 1);
+          }
+        },
+      );
+
+      test(
+        'Together added players nameCount gets increased correctly',
+        () async {
+          final player1 = Player(name: testPlayer1.name, description: '');
+          final player2 = Player(name: testPlayer1.name, description: '');
+          final player3 = Player(name: testPlayer1.name, description: '');
+
+          // addPlayersAsList() with multiple players and with one player
+          await database.playerDao.addPlayersAsList(players: [testPlayer1]);
+          await database.playerDao.addPlayersAsList(
+            players: [player1, player2, player3],
+          );
+
+          var players = await database.playerDao.getAllPlayers();
+
+          expect(players.length, 4);
+          players.sort((a, b) => a.nameCount.compareTo(b.nameCount));
+
+          for (int i = 0; i < players.length - 1; i++) {
+            expect(players[i].nameCount, i + 1);
+          }
+        },
+      );
+
+      test('getNameCount works  correctly', () async {
+        final player2 = Player(name: testPlayer1.name);
+        final player3 = Player(name: testPlayer1.name);
+
+        await database.playerDao.addPlayersAsList(
+          players: [testPlayer1, player2, player3],
+        );
+
+        final nameCount = await database.playerDao.getNameCount(
+          name: testPlayer1.name,
+        );
+
+        expect(nameCount, 3);
+      });
+
+      test('updateNameCount works correctly', () async {
+        await database.playerDao.addPlayer(player: testPlayer1);
+
+        final success = await database.playerDao.updateNameCount(
+          playerId: testPlayer1.id,
+          nameCount: 2,
+        );
+        expect(success, true);
+
+        final player = await database.playerDao.getPlayerById(
+          playerId: testPlayer1.id,
+        );
+        expect(player.nameCount, 2);
+      });
+
+      test('getPlayerWithHighestNameCount works correctly', () async {
+        final player2 = Player(name: testPlayer1.name, description: '');
+        final player3 = Player(name: testPlayer1.name, description: '');
+
+        await database.playerDao.addPlayersAsList(
+          players: [testPlayer1, player2, player3],
+        );
+
+        final player = await database.playerDao.getPlayerWithHighestNameCount(
+          name: testPlayer1.name,
+        );
+
+        expect(player, isNotNull);
+        expect(player!.nameCount, 3);
+      });
+
+      test('getPlayerWithHighestNameCount with non existing player', () async {
+        final player = await database.playerDao.getPlayerWithHighestNameCount(
+          name: 'non-existing-name',
+        );
+        expect(player, isNull);
+      });
+
+      test('calculateNameCount works correctly', () async {
+        // Case 1: No existing players with the name
+        var count = await database.playerDao.calculateNameCount(
+          name: testPlayer1.name,
+        );
+        expect(count, 0);
+
+        // Case 2: One existing player with the name. Should update that
+        // player's nameCount to 1 and return 2 for the new player
+        await database.playerDao.addPlayer(player: testPlayer1);
+
+        count = await database.playerDao.calculateNameCount(
+          name: testPlayer1.name,
+        );
+        expect(count, 2);
+
+        // Case 3: Multiple existing players with the name.
+        final player2 = Player(name: testPlayer1.name, nameCount: count);
+        await database.playerDao.addPlayer(player: player2);
+
+        count = await database.playerDao.calculateNameCount(
+          name: testPlayer1.name,
+        );
+        expect(count, 3);
+      });
+
+      test('getPlayerWithHighestNameCount with non existing player', () async {
+        await database.playerDao.addPlayer(player: testPlayer1);
+        await database.playerDao.initializeNameCount(name: testPlayer1.name);
+        final player = await database.playerDao.getPlayerById(
+          playerId: testPlayer1.id,
+        );
+        expect(player.nameCount, 1);
+      });
+    });
   });
 }

test/db_tests/relationships/player_group_test.dart

@@ -3,8 +3,8 @@ import 'package:drift/drift.dart';
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
 
 void main() {
   late AppDatabase database;
@@ -42,7 +42,6 @@ void main() {
   });
 
   group('Player-Group Tests', () {
-
     // Verifies that a player can be added to an existing group and isPlayerInGroup returns true.
     test('Adding a player to a group works correctly', () async {
       await database.groupDao.addGroup(group: testGroup);
@@ -127,67 +126,83 @@ void main() {
     });
 
     // Verifies that addPlayerToGroup returns false when player already in group.
-    test('addPlayerToGroup returns false when player already in group', () async {
+    test(
-      await database.groupDao.addGroup(group: testGroup);
+      'addPlayerToGroup returns false when player already in group',
+      () async {
+        await database.groupDao.addGroup(group: testGroup);
 
-      // testPlayer1 is already in testGroup via group creation
+        // testPlayer1 is already in testGroup via group creation
-      final result = await database.playerGroupDao.addPlayerToGroup(
+        final result = await database.playerGroupDao.addPlayerToGroup(
-        player: testPlayer1,
+          player: testPlayer1,
-        groupId: testGroup.id,
+          groupId: testGroup.id,
-      );
+        );
 
-      expect(result, false);
+        expect(result, false);
-    });
+      },
+    );
 
     // Verifies that addPlayerToGroup adds player to player table if not exists.
-    test('addPlayerToGroup adds player to player table if not exists', () async {
+    test(
-      await database.groupDao.addGroup(group: testGroup);
+      'addPlayerToGroup adds player to player table if not exists',
+      () async {
+        await database.groupDao.addGroup(group: testGroup);
 
-      // testPlayer4 is not in the database yet
+        // testPlayer4 is not in the database yet
-      var playerExists = await database.playerDao.playerExists(
+        var playerExists = await database.playerDao.playerExists(
-        playerId: testPlayer4.id,
+          playerId: testPlayer4.id,
-      );
+        );
-      expect(playerExists, false);
+        expect(playerExists, false);
 
-      await database.playerGroupDao.addPlayerToGroup(
+        await database.playerGroupDao.addPlayerToGroup(
-        player: testPlayer4,
+          player: testPlayer4,
-        groupId: testGroup.id,
+          groupId: testGroup.id,
-      );
+        );
 
-      // Now player should exist in player table
+        // Now player should exist in player table
-      playerExists = await database.playerDao.playerExists(
+        playerExists = await database.playerDao.playerExists(
-        playerId: testPlayer4.id,
+          playerId: testPlayer4.id,
-      );
+        );
-      expect(playerExists, true);
+        expect(playerExists, true);
-    });
+      },
+    );
 
     // Verifies that removePlayerFromGroup returns false for non-existent player.
-    test('removePlayerFromGroup returns false for non-existent player', () async {
+    test(
-      await database.groupDao.addGroup(group: testGroup);
+      'removePlayerFromGroup returns false for non-existent player',
+      () async {
+        await database.groupDao.addGroup(group: testGroup);
 
-      final result = await database.playerGroupDao.removePlayerFromGroup(
+        final result = await database.playerGroupDao.removePlayerFromGroup(
-        playerId: 'non-existent-player-id',
+          playerId: 'non-existent-player-id',
-        groupId: testGroup.id,
+          groupId: testGroup.id,
-      );
+        );
 
-      expect(result, false);
+        expect(result, false);
-    });
+      },
+    );
 
     // Verifies that removePlayerFromGroup returns false for non-existent group.
-    test('removePlayerFromGroup returns false for non-existent group', () async {
+    test(
-      await database.playerDao.addPlayer(player: testPlayer1);
+      'removePlayerFromGroup returns false for non-existent group',
+      () async {
+        await database.playerDao.addPlayer(player: testPlayer1);
 
-      final result = await database.playerGroupDao.removePlayerFromGroup(
+        final result = await database.playerGroupDao.removePlayerFromGroup(
-        playerId: testPlayer1.id,
+          playerId: testPlayer1.id,
-        groupId: 'non-existent-group-id',
+          groupId: 'non-existent-group-id',
-      );
+        );
 
-      expect(result, false);
+        expect(result, false);
-    });
+      },
+    );
 
     // Verifies that getPlayersOfGroup returns empty list for group with no members.
     test('getPlayersOfGroup returns empty list for empty group', () async {
-      final emptyGroup = Group(name: 'Empty Group', description: '', members: []);
+      final emptyGroup = Group(
+        name: 'Empty Group',
+        description: '',
+        members: [],
+      );
       await database.groupDao.addGroup(group: emptyGroup);
 
       final players = await database.playerGroupDao.getPlayersOfGroup(
@@ -198,13 +213,16 @@ void main() {
     });
 
     // Verifies that getPlayersOfGroup returns empty list for non-existent group.
-    test('getPlayersOfGroup returns empty list for non-existent group', () async {
+    test(
-      final players = await database.playerGroupDao.getPlayersOfGroup(
+      'getPlayersOfGroup returns empty list for non-existent group',
-        groupId: 'non-existent-group-id',
+      () async {
-      );
+        final players = await database.playerGroupDao.getPlayersOfGroup(
+          groupId: 'non-existent-group-id',
+        );
 
-      expect(players, isEmpty);
+        expect(players, isEmpty);
-    });
+      },
+    );
 
     // Verifies that removing all players from a group leaves the group empty.
     test('Removing all players from a group leaves group empty', () async {
@@ -231,7 +249,11 @@ void main() {
 
     // Verifies that a player can be in multiple groups.
     test('Player can be in multiple groups', () async {
-      final secondGroup = Group(name: 'Second Group', description: '', members: []);
+      final secondGroup = Group(
+        name: 'Second Group',
+        description: '',
+        members: [],
+      );
       await database.groupDao.addGroup(group: testGroup);
       await database.groupDao.addGroup(group: secondGroup);
 
@@ -255,29 +277,36 @@ void main() {
     });
 
     // Verifies that removing player from one group doesn't affect other groups.
-    test('Removing player from one group does not affect other groups', () async {
+    test(
-      final secondGroup = Group(name: 'Second Group', description: '', members: [testPlayer1]);
+      'Removing player from one group does not affect other groups',
-      await database.groupDao.addGroup(group: testGroup);
+      () async {
-      await database.groupDao.addGroup(group: secondGroup);
+        final secondGroup = Group(
+          name: 'Second Group',
+          description: '',
+          members: [testPlayer1],
+        );
+        await database.groupDao.addGroup(group: testGroup);
+        await database.groupDao.addGroup(group: secondGroup);
 
-      // Remove testPlayer1 from testGroup
+        // Remove testPlayer1 from testGroup
-      await database.playerGroupDao.removePlayerFromGroup(
+        await database.playerGroupDao.removePlayerFromGroup(
-        playerId: testPlayer1.id,
+          playerId: testPlayer1.id,
-        groupId: testGroup.id,
+          groupId: testGroup.id,
-      );
+        );
 
-      final inFirstGroup = await database.playerGroupDao.isPlayerInGroup(
+        final inFirstGroup = await database.playerGroupDao.isPlayerInGroup(
-        playerId: testPlayer1.id,
+          playerId: testPlayer1.id,
-        groupId: testGroup.id,
+          groupId: testGroup.id,
-      );
+        );
-      final inSecondGroup = await database.playerGroupDao.isPlayerInGroup(
+        final inSecondGroup = await database.playerGroupDao.isPlayerInGroup(
-        playerId: testPlayer1.id,
+          playerId: testPlayer1.id,
-        groupId: secondGroup.id,
+          groupId: secondGroup.id,
-      );
+        );
 
-      expect(inFirstGroup, false);
+        expect(inFirstGroup, false);
-      expect(inSecondGroup, true);
+        expect(inSecondGroup, true);
-    });
+      },
+    );
 
     // Verifies that addPlayerToGroup returns true on successful addition.
     test('addPlayerToGroup returns true on successful addition', () async {
@@ -293,21 +322,26 @@ void main() {
     });
 
     // Verifies that removing the same player twice returns false on second attempt.
-    test('Removing same player twice returns false on second attempt', () async {
+    test(
-      await database.groupDao.addGroup(group: testGroup);
+      'Removing same player twice returns false on second attempt',
+      () async {
+        await database.groupDao.addGroup(group: testGroup);
 
-      final firstRemoval = await database.playerGroupDao.removePlayerFromGroup(
+        final firstRemoval = await database.playerGroupDao
-        playerId: testPlayer1.id,
+            .removePlayerFromGroup(
-        groupId: testGroup.id,
+              playerId: testPlayer1.id,
-      );
+              groupId: testGroup.id,
-      expect(firstRemoval, true);
+            );
+        expect(firstRemoval, true);
 
-      final secondRemoval = await database.playerGroupDao.removePlayerFromGroup(
+        final secondRemoval = await database.playerGroupDao
-        playerId: testPlayer1.id,
+            .removePlayerFromGroup(
-        groupId: testGroup.id,
+              playerId: testPlayer1.id,
-      );
+              groupId: testGroup.id,
-      expect(secondRemoval, false);
+            );
-    });
+        expect(secondRemoval, false);
+      },
+    );
 
     // Verifies that replaceGroupPlayers removes all existing players and replaces with new list.
     test('replaceGroupPlayers replaces all group members correctly', () async {

test/db_tests/relationships/player_match_test.dart

@@ -4,11 +4,11 @@ import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:tallee/core/enums.dart';
 import 'package:tallee/data/db/database.dart';
-import 'package:tallee/data/dto/game.dart';
+import 'package:tallee/data/models/game.dart';
-import 'package:tallee/data/dto/group.dart';
+import 'package:tallee/data/models/group.dart';
-import 'package:tallee/data/dto/match.dart';
+import 'package:tallee/data/models/match.dart';
-import 'package:tallee/data/dto/player.dart';
+import 'package:tallee/data/models/player.dart';
-import 'package:tallee/data/dto/team.dart';
+import 'package:tallee/data/models/team.dart';
 
 void main() {
   late AppDatabase database;
@@ -53,6 +53,7 @@ void main() {
         ruleset: Ruleset.singleWinner,
         description: 'A test game',
         color: GameColor.blue,
+        icon: '',
       );
       testMatchOnlyGroup = Match(
         name: 'Test Match with Group',
@@ -87,7 +88,6 @@ void main() {
   });
 
   group('Player-Match Tests', () {
-    // Verifies that matchHasPlayers returns false initially and true after adding a player.
     test('Match has player works correctly', () async {
       await database.matchDao.addMatch(match: testMatchOnlyGroup);
       await database.playerDao.addPlayer(player: testPlayer1);
@@ -110,7 +110,6 @@ void main() {
       expect(matchHasPlayers, true);
     });
 
-    // Verifies that a player can be added to a match and isPlayerInMatch returns true.
     test('Adding a player to a match works correctly', () async {
       await database.matchDao.addMatch(match: testMatchOnlyGroup);
       await database.playerDao.addPlayer(player: testPlayer5);
@@ -134,7 +133,6 @@ void main() {
       expect(playerAdded, false);
     });
 
-    // Verifies that a player can be removed from a match and the player count decreases.
     test('Removing player from match works correctly', () async {
       await database.matchDao.addMatch(match: testMatchOnlyPlayers);
 
@@ -155,7 +153,6 @@ void main() {
       expect(playerExists, false);
     });
 
-    // Verifies that getPlayersOfMatch returns all players of a match with correct data.
     test('Retrieving players of a match works correctly', () async {
       await database.matchDao.addMatch(match: testMatchOnlyPlayers);
       final players =
@@ -171,7 +168,6 @@ void main() {
       }
     });
 
-    // Verifies that updatePlayersFromMatch replaces all existing players with new ones.
     test('Updating the match players works correctly', () async {
       await database.matchDao.addMatch(match: testMatchOnlyPlayers);
 
@@ -215,7 +211,6 @@ void main() {
       }
     });
 
-    // Verifies that the same player can be added to multiple different matches.
     test(
       'Adding the same player to separate matches works correctly',
       () async {
@@ -272,89 +267,6 @@ void main() {
       expect(players, isNull);
     });
 
-    // Verifies that adding a player with initial score works correctly.
-    test('Adding player with initial score works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyGroup);
-
-      await database.playerMatchDao.addPlayerToMatch(
-        matchId: testMatchOnlyGroup.id,
-        playerId: testPlayer1.id,
-        score: 100,
-      );
-
-      final score = await database.playerMatchDao.getPlayerScore(
-        matchId: testMatchOnlyGroup.id,
-        playerId: testPlayer1.id,
-      );
-
-      expect(score, 100);
-    });
-
-    // Verifies that getPlayerScore returns the correct score.
-    test('getPlayerScore returns correct score', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
-
-      // Default score should be 0 when added through match
-      final score = await database.playerMatchDao.getPlayerScore(
-        matchId: testMatchOnlyPlayers.id,
-        playerId: testPlayer4.id,
-      );
-
-      expect(score, 0);
-    });
-
-    // Verifies that getPlayerScore returns null for non-existent player-match combination.
-    test(
-      'getPlayerScore returns null for non-existent player in match',
-      () async {
-        await database.matchDao.addMatch(match: testMatchOnlyGroup);
-
-        final score = await database.playerMatchDao.getPlayerScore(
-          matchId: testMatchOnlyGroup.id,
-          playerId: 'non-existent-player-id',
-        );
-
-        expect(score, isNull);
-      },
-    );
-
-    // Verifies that updatePlayerScore updates the score correctly.
-    test('updatePlayerScore updates score correctly', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
-
-      final updated = await database.playerMatchDao.updatePlayerScore(
-        matchId: testMatchOnlyPlayers.id,
-        playerId: testPlayer4.id,
-        newScore: 50,
-      );
-
-      expect(updated, true);
-
-      final score = await database.playerMatchDao.getPlayerScore(
-        matchId: testMatchOnlyPlayers.id,
-        playerId: testPlayer4.id,
-      );
-
-      expect(score, 50);
-    });
-
-    // Verifies that updatePlayerScore returns false for non-existent player-match.
-    test(
-      'updatePlayerScore returns false for non-existent player-match',
-      () async {
-        await database.matchDao.addMatch(match: testMatchOnlyGroup);
-
-        final updated = await database.playerMatchDao.updatePlayerScore(
-          matchId: testMatchOnlyGroup.id,
-          playerId: 'non-existent-player-id',
-          newScore: 50,
-        );
-
-        expect(updated, false);
-      },
-    );
-
-    // Verifies that adding a player with teamId works correctly.
     test('Adding player with teamId works correctly', () async {
       await database.matchDao.addMatch(match: testMatchOnlyGroup);
       await database.teamDao.addTeam(team: testTeam1);
@@ -374,7 +286,6 @@ void main() {
       expect(playersInTeam[0].id, testPlayer1.id);
     });
 
-    // Verifies that updatePlayerTeam updates the team correctly.
     test('updatePlayerTeam updates team correctly', () async {
       await database.matchDao.addMatch(match: testMatchOnlyGroup);
       await database.teamDao.addTeam(team: testTeam1);
@@ -413,7 +324,6 @@ void main() {
       expect(playersInTeam1.isEmpty, true);
     });
 
-    // Verifies that updatePlayerTeam can set team to null.
     test('updatePlayerTeam can remove player from team', () async {
       await database.matchDao.addMatch(match: testMatchOnlyGroup);
       await database.teamDao.addTeam(team: testTeam1);
@@ -441,7 +351,6 @@ void main() {
       expect(playersInTeam.isEmpty, true);
     });
 
-    // Verifies that updatePlayerTeam returns false for non-existent player-match.
     test(
       'updatePlayerTeam returns false for non-existent player-match',
       () async {
@@ -469,7 +378,6 @@ void main() {
       expect(players.isEmpty, true);
     });
 
-    // Verifies that getPlayersInTeam returns all players of a team.
     test('getPlayersInTeam returns all players of a team', () async {
       await database.matchDao.addMatch(match: testMatchOnlyGroup);
       await database.teamDao.addTeam(team: testTeam1);
@@ -496,7 +404,6 @@ void main() {
       expect(playerIds.contains(testPlayer2.id), true);
     });
 
-    // Verifies that removePlayerFromMatch returns false for non-existent player.
     test(
       'removePlayerFromMatch returns false for non-existent player',
       () async {
@@ -511,31 +418,20 @@ void main() {
       },
     );
 
-    // Verifies that adding the same player twice to the same match is ignored.
     test('Adding same player twice to same match is ignored', () async {
       await database.matchDao.addMatch(match: testMatchOnlyGroup);
 
       await database.playerMatchDao.addPlayerToMatch(
         matchId: testMatchOnlyGroup.id,
         playerId: testPlayer1.id,
-        score: 10,
       );
 
       // Try to add the same player again with different score
       await database.playerMatchDao.addPlayerToMatch(
         matchId: testMatchOnlyGroup.id,
         playerId: testPlayer1.id,
-        score: 100,
       );
 
-      // Score should still be 10 because insert was ignored
-      final score = await database.playerMatchDao.getPlayerScore(
-        matchId: testMatchOnlyGroup.id,
-        playerId: testPlayer1.id,
-      );
-
-      expect(score, 10);
-
       // Verify player count is still 1
       final players = await database.playerMatchDao.getPlayersOfMatch(
         matchId: testMatchOnlyGroup.id,
@@ -544,7 +440,6 @@ void main() {
       expect(players?.length, 1);
     });
 
-    // Verifies that updatePlayersFromMatch with empty list removes all players.
     test(
       'updatePlayersFromMatch with empty list removes all players',
       () async {
@@ -570,7 +465,6 @@ void main() {
       },
     );
 
-    // Verifies that updatePlayersFromMatch with same players makes no changes.
     test('updatePlayersFromMatch with same players makes no changes', () async {
       await database.matchDao.addMatch(match: testMatchOnlyPlayers);
 
@@ -592,7 +486,6 @@ void main() {
       }
     });
 
-    // Verifies that matchHasPlayers returns false for non-existent match.
     test('matchHasPlayers returns false for non-existent match', () async {
       final hasPlayers = await database.playerMatchDao.matchHasPlayers(
         matchId: 'non-existent-match-id',
@@ -601,7 +494,6 @@ void main() {
       expect(hasPlayers, false);
     });
 
-    // Verifies that isPlayerInMatch returns false for non-existent match.
     test('isPlayerInMatch returns false for non-existent match', () async {
       final isInMatch = await database.playerMatchDao.isPlayerInMatch(
         matchId: 'non-existent-match-id',
@@ -611,116 +503,6 @@ void main() {
       expect(isInMatch, false);
     });
 
-    // Verifies that updatePlayersFromMatch preserves scores for existing players.
-    test('updatePlayersFromMatch only modifies player associations', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
-
-      // Update score for existing player
-      await database.playerMatchDao.updatePlayerScore(
-        matchId: testMatchOnlyPlayers.id,
-        playerId: testPlayer4.id,
-        newScore: 75,
-      );
-
-      // Update players, keeping testPlayer4 and adding testPlayer1
-      await database.playerMatchDao.updatePlayersFromMatch(
-        matchId: testMatchOnlyPlayers.id,
-        newPlayer: [testPlayer4, testPlayer1],
-      );
-
-      // Verify testPlayer4's score is preserved
-      final score = await database.playerMatchDao.getPlayerScore(
-        matchId: testMatchOnlyPlayers.id,
-        playerId: testPlayer4.id,
-      );
-
-      expect(score, 75);
-
-      // Verify testPlayer1 was added with default score
-      final newPlayerScore = await database.playerMatchDao.getPlayerScore(
-        matchId: testMatchOnlyPlayers.id,
-        playerId: testPlayer1.id,
-      );
-
-      expect(newPlayerScore, 0);
-    });
-
-    // Verifies that adding a player with both score and teamId works correctly.
-    test('Adding player with score and teamId works correctly', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyGroup);
-      await database.teamDao.addTeam(team: testTeam1);
-
-      await database.playerMatchDao.addPlayerToMatch(
-        matchId: testMatchOnlyGroup.id,
-        playerId: testPlayer1.id,
-        teamId: testTeam1.id,
-        score: 150,
-      );
-
-      // Verify score
-      final score = await database.playerMatchDao.getPlayerScore(
-        matchId: testMatchOnlyGroup.id,
-        playerId: testPlayer1.id,
-      );
-      expect(score, 150);
-
-      // Verify team assignment
-      final playersInTeam = await database.playerMatchDao.getPlayersInTeam(
-        matchId: testMatchOnlyGroup.id,
-        teamId: testTeam1.id,
-      );
-      expect(playersInTeam.length, 1);
-      expect(playersInTeam[0].id, testPlayer1.id);
-    });
-
-    // Verifies that updating score with negative value works.
-    test('updatePlayerScore with negative score works', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
-
-      final updated = await database.playerMatchDao.updatePlayerScore(
-        matchId: testMatchOnlyPlayers.id,
-        playerId: testPlayer4.id,
-        newScore: -10,
-      );
-
-      expect(updated, true);
-
-      final score = await database.playerMatchDao.getPlayerScore(
-        matchId: testMatchOnlyPlayers.id,
-        playerId: testPlayer4.id,
-      );
-
-      expect(score, -10);
-    });
-
-    // Verifies that updating score with zero value works.
-    test('updatePlayerScore with zero score works', () async {
-      await database.matchDao.addMatch(match: testMatchOnlyPlayers);
-
-      // First set a non-zero score
-      await database.playerMatchDao.updatePlayerScore(
-        matchId: testMatchOnlyPlayers.id,
-        playerId: testPlayer4.id,
-        newScore: 100,
-      );
-
-      // Then update to zero
-      final updated = await database.playerMatchDao.updatePlayerScore(
-        matchId: testMatchOnlyPlayers.id,
-        playerId: testPlayer4.id,
-        newScore: 0,
-      );
-
-      expect(updated, true);
-
-      final score = await database.playerMatchDao.getPlayerScore(
-        matchId: testMatchOnlyPlayers.id,
-        playerId: testPlayer4.id,
-      );
-
-      expect(score, 0);
-    });
-
     // Verifies that getPlayersInTeam returns empty list for non-existent match.
     test(
       'getPlayersInTeam returns empty list for non-existent match',
@@ -822,55 +604,6 @@ void main() {
       expect(isInMatch2, true);
     });
 
-    // Verifies that updating scores for players in different matches are independent.
-    test('Player scores are independent across matches', () async {
-      final playersList = [testPlayer1];
-      final match1 = Match(
-        name: 'Match 1',
-        game: testGame,
-        players: playersList,
-        notes: '',
-      );
-      final match2 = Match(
-        name: 'Match 2',
-        game: testGame,
-        players: playersList,
-        notes: '',
-      );
-
-      await Future.wait([
-        database.matchDao.addMatch(match: match1),
-        database.matchDao.addMatch(match: match2),
-      ]);
-
-      // Update score in match1
-      await database.playerMatchDao.updatePlayerScore(
-        matchId: match1.id,
-        playerId: testPlayer1.id,
-        newScore: 100,
-      );
-
-      // Update score in match2
-      await database.playerMatchDao.updatePlayerScore(
-        matchId: match2.id,
-        playerId: testPlayer1.id,
-        newScore: 50,
-      );
-
-      // Verify scores are independent
-      final scoreInMatch1 = await database.playerMatchDao.getPlayerScore(
-        matchId: match1.id,
-        playerId: testPlayer1.id,
-      );
-      final scoreInMatch2 = await database.playerMatchDao.getPlayerScore(
-        matchId: match2.id,
-        playerId: testPlayer1.id,
-      );
-
-      expect(scoreInMatch1, 100);
-      expect(scoreInMatch2, 50);
-    });
-
     // Verifies that updatePlayersFromMatch on non-existent match fails with constraint error.
     test(
       'updatePlayersFromMatch on non-existent match fails with foreign key constraint',

test/services/data_transfer_service_test.dart

@@ -0,0 +1,926 @@
+import 'dart:convert';
+
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart' hide isNull, isNotNull;
+import 'package:drift/native.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:provider/provider.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/models/game.dart';
+import 'package:tallee/data/models/group.dart';
+import 'package:tallee/data/models/match.dart';
+import 'package:tallee/data/models/player.dart';
+import 'package:tallee/data/models/score_entry.dart';
+import 'package:tallee/data/models/team.dart';
+import 'package:tallee/services/data_transfer_service.dart';
+
+void main() {
+  late AppDatabase database;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Game testGame;
+  late Group testGroup;
+  late Team testTeam;
+  late Match testMatch;
+  final fixedDate = DateTime(2025, 11, 19, 0, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    withClock(fakeClock, () {
+      testPlayer1 = Player(name: 'Alice', description: 'First test player');
+      testPlayer2 = Player(name: 'Bob', description: 'Second test player');
+      testPlayer3 = Player(name: 'Charlie', description: 'Third player');
+
+      testGame = Game(
+        name: 'Chess',
+        ruleset: Ruleset.singleWinner,
+        description: 'Strategic board game',
+        color: GameColor.blue,
+        icon: 'chess_icon',
+      );
+
+      testGroup = Group(
+        name: 'Test Group',
+        description: 'Group for testing',
+        members: [testPlayer1, testPlayer2],
+      );
+
+      testTeam = Team(name: 'Test Team', members: [testPlayer1, testPlayer2]);
+
+      testMatch = Match(
+        name: 'Test Match',
+        game: testGame,
+        group: testGroup,
+        players: [testPlayer1, testPlayer2],
+        notes: 'Test notes',
+        scores: {
+          testPlayer1.id: [
+            ScoreEntry(roundNumber: 1, score: 10, change: 10),
+            ScoreEntry(roundNumber: 2, score: 20, change: 10),
+          ],
+          testPlayer2.id: [
+            ScoreEntry(roundNumber: 1, score: 15, change: 15),
+            ScoreEntry(roundNumber: 2, score: 25, change: 10),
+          ],
+        },
+      );
+    });
+  });
+
+  tearDown(() async {
+    await database.close();
+  });
+
+  // Helper for getting BuildContext
+  Future<BuildContext> getContext(WidgetTester tester) async {
+    // Minimal widget with Provider
+    await tester.pumpWidget(
+      Provider<AppDatabase>.value(
+        value: database,
+        child: MaterialApp(
+          home: Builder(
+            builder: (context) {
+              return Container();
+            },
+          ),
+        ),
+      ),
+    );
+    final BuildContext context = tester.element(find.byType(Container));
+    return context;
+  }
+
+  group('DataTransferService Tests', () {
+    testWidgets('deleteAllData()', (tester) async {
+      await database.playerDao.addPlayer(player: testPlayer1);
+      await database.gameDao.addGame(game: testGame);
+      await database.groupDao.addGroup(group: testGroup);
+      await database.teamDao.addTeam(team: testTeam);
+      await database.matchDao.addMatch(match: testMatch);
+
+      var playerCount = await database.playerDao.getPlayerCount();
+      var gameCount = await database.gameDao.getGameCount();
+      var groupCount = await database.groupDao.getGroupCount();
+      var teamCount = await database.teamDao.getTeamCount();
+      var matchCount = await database.matchDao.getMatchCount();
+
+      expect(playerCount, greaterThan(0));
+      expect(gameCount, greaterThan(0));
+      expect(groupCount, greaterThan(0));
+      expect(teamCount, greaterThan(0));
+      expect(matchCount, greaterThan(0));
+
+      final ctx = await getContext(tester);
+      await DataTransferService.deleteAllData(ctx);
+
+      playerCount = await database.playerDao.getPlayerCount();
+      gameCount = await database.gameDao.getGameCount();
+      groupCount = await database.groupDao.getGroupCount();
+      teamCount = await database.teamDao.getTeamCount();
+      matchCount = await database.matchDao.getMatchCount();
+
+      expect(playerCount, 0);
+      expect(gameCount, 0);
+      expect(groupCount, 0);
+      expect(teamCount, 0);
+      expect(matchCount, 0);
+    });
+
+    group('getAppDataAsJson()', () {
+      group('Whole export', () {
+        testWidgets('Exporting app data works correctly', (tester) async {
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.playerDao.addPlayer(player: testPlayer2);
+          await database.gameDao.addGame(game: testGame);
+          await database.groupDao.addGroup(group: testGroup);
+          await database.teamDao.addTeam(team: testTeam);
+          await database.matchDao.addMatch(match: testMatch);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+
+          expect(jsonString, isNotEmpty);
+
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+
+          expect(decoded.containsKey('players'), true);
+          expect(decoded.containsKey('games'), true);
+          expect(decoded.containsKey('groups'), true);
+          expect(decoded.containsKey('teams'), true);
+          expect(decoded.containsKey('matches'), true);
+
+          final players = decoded['players'] as List<dynamic>;
+          final games = decoded['games'] as List<dynamic>;
+          final groups = decoded['groups'] as List<dynamic>;
+          final teams = decoded['teams'] as List<dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+
+          expect(players.length, 2);
+          expect(games.length, 1);
+          expect(groups.length, 1);
+          expect(teams.length, 1);
+          expect(matches.length, 1);
+        });
+
+        testWidgets('Exporting empty data works correctly', (tester) async {
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+
+          final players = decoded['players'] as List<dynamic>;
+          final games = decoded['games'] as List<dynamic>;
+          final groups = decoded['groups'] as List<dynamic>;
+          final teams = decoded['teams'] as List<dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+
+          expect(players, isEmpty);
+          expect(games, isEmpty);
+          expect(groups, isEmpty);
+          expect(teams, isEmpty);
+          expect(matches, isEmpty);
+        });
+      });
+
+      group('Checking specific data', () {
+        testWidgets('Player data is correct', (tester) async {
+          await database.playerDao.addPlayer(player: testPlayer1);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final players = decoded['players'] as List<dynamic>;
+          final playerData = players[0] as Map<String, dynamic>;
+
+          expect(playerData['id'], testPlayer1.id);
+          expect(playerData['name'], testPlayer1.name);
+          expect(playerData['description'], testPlayer1.description);
+          expect(
+            playerData['createdAt'],
+            testPlayer1.createdAt.toIso8601String(),
+          );
+        });
+
+        testWidgets('Game data is correct', (tester) async {
+          await database.gameDao.addGame(game: testGame);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final games = decoded['games'] as List<dynamic>;
+          final gameData = games[0] as Map<String, dynamic>;
+
+          expect(gameData['id'], testGame.id);
+          expect(gameData['name'], testGame.name);
+          expect(gameData['ruleset'], testGame.ruleset.name);
+          expect(gameData['description'], testGame.description);
+          expect(gameData['color'], testGame.color.name);
+          expect(gameData['icon'], testGame.icon);
+        });
+
+        testWidgets('Group data is correct', (tester) async {
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.playerDao.addPlayer(player: testPlayer2);
+          await database.groupDao.addGroup(group: testGroup);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final groups = decoded['groups'] as List<dynamic>;
+          final groupData = groups[0] as Map<String, dynamic>;
+
+          expect(groupData['id'], testGroup.id);
+          expect(groupData['name'], testGroup.name);
+          expect(groupData['description'], testGroup.description);
+          expect(groupData['memberIds'], isA<List>());
+
+          final memberIds = groupData['memberIds'] as List<dynamic>;
+          expect(memberIds.length, 2);
+          expect(memberIds, containsAll([testPlayer1.id, testPlayer2.id]));
+        });
+
+        testWidgets('Team data is correct', (tester) async {
+          await database.teamDao.addTeam(team: testTeam);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final teams = decoded['teams'] as List<dynamic>;
+
+          expect(teams.length, 1);
+
+          final teamData = teams[0] as Map<String, dynamic>;
+
+          expect(teamData['id'], testTeam.id);
+          expect(teamData['name'], testTeam.name);
+          expect(teamData['memberIds'], isA<List>());
+
+          // Note: In this system, teams don't have independent members.
+          // Team members are only tracked through matches via PlayerMatchTable.
+          // Therefore, memberIds will be empty for standalone teams.
+          final memberIds = teamData['memberIds'] as List<dynamic>;
+          expect(memberIds, isEmpty);
+        });
+
+        testWidgets('Match data is correct', (tester) async {
+          await database.playerDao.addPlayersAsList(
+            players: [testPlayer1, testPlayer2],
+          );
+          await database.gameDao.addGame(game: testGame);
+          await database.groupDao.addGroup(group: testGroup);
+          await database.matchDao.addMatch(match: testMatch);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+          final matchData = matches[0] as Map<String, dynamic>;
+
+          expect(matchData['id'], testMatch.id);
+          expect(matchData['name'], testMatch.name);
+          expect(matchData['gameId'], testGame.id);
+          expect(matchData['groupId'], testGroup.id);
+          expect(matchData['playerIds'], isA<List>());
+          expect(matchData['notes'], testMatch.notes);
+
+          // Check player ids
+          final playerIds = matchData['playerIds'] as List<dynamic>;
+          expect(playerIds.length, 2);
+          expect(playerIds, containsAll([testPlayer1.id, testPlayer2.id]));
+
+          // Check scores structure
+          final scoresJson = matchData['scores'] as Map<String, dynamic>;
+          expect(scoresJson, isA<Map<String, dynamic>>());
+
+          final scores = scoresJson.map(
+            (playerId, scoreList) => MapEntry(
+              playerId,
+              (scoreList as List)
+                  .map((s) => ScoreEntry.fromJson(s as Map<String, dynamic>))
+                  .toList(),
+            ),
+          );
+
+          expect(scores, isA<Map<String, List<ScoreEntry>>>());
+
+          /* Player 1 scores */
+          // General structure
+          expect(scores[testPlayer1.id], isNotNull);
+          expect(scores[testPlayer1.id]!.length, 2);
+
+          // Round 1
+          expect(scores[testPlayer1.id]![0].roundNumber, 1);
+          expect(scores[testPlayer1.id]![0].score, 10);
+          expect(scores[testPlayer1.id]![0].change, 10);
+
+          // Round 2
+          expect(scores[testPlayer1.id]![1].roundNumber, 2);
+          expect(scores[testPlayer1.id]![1].score, 20);
+          expect(scores[testPlayer1.id]![1].change, 10);
+
+          /* Player 2 scores */
+          // General structure
+          expect(scores[testPlayer2.id], isNotNull);
+          expect(scores[testPlayer2.id]!.length, 2);
+
+          // Round 1
+          expect(scores[testPlayer2.id]![0].roundNumber, 1);
+          expect(scores[testPlayer2.id]![0].score, 15);
+          expect(scores[testPlayer2.id]![0].change, 15);
+
+          // Round 2
+          expect(scores[testPlayer2.id]![1].roundNumber, 2);
+          expect(scores[testPlayer2.id]![1].score, 25);
+          expect(scores[testPlayer2.id]![1].change, 10);
+        });
+
+        testWidgets('Match without group is handled correctly', (tester) async {
+          final matchWithoutGroup = Match(
+            name: 'No Group Match',
+            game: testGame,
+            group: null,
+            players: [testPlayer1],
+            notes: 'No group',
+          );
+
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.gameDao.addGame(game: testGame);
+          await database.matchDao.addMatch(match: matchWithoutGroup);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+          final matchData = matches[0] as Map<String, dynamic>;
+
+          expect(matchData['groupId'], isNull);
+        });
+
+        testWidgets('Match with endedAt is handled correctly', (tester) async {
+          final endedDate = DateTime(2025, 12, 1, 10, 0, 0);
+          final endedMatch = Match(
+            name: 'Ended Match',
+            game: testGame,
+            players: [testPlayer1],
+            endedAt: endedDate,
+            notes: 'Finished',
+          );
+
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.gameDao.addGame(game: testGame);
+          await database.matchDao.addMatch(match: endedMatch);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+          final matchData = matches[0] as Map<String, dynamic>;
+
+          expect(matchData['endedAt'], endedDate.toIso8601String());
+        });
+
+        testWidgets('Structure is consistent', (tester) async {
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.gameDao.addGame(game: testGame);
+
+          final ctx = await getContext(tester);
+          final jsonString1 = await DataTransferService.getAppDataAsJson(ctx);
+          final jsonString2 = await DataTransferService.getAppDataAsJson(ctx);
+
+          expect(jsonString1, equals(jsonString2));
+        });
+
+        testWidgets('Empty match notes is handled correctly', (tester) async {
+          final matchWithEmptyNotes = Match(
+            name: 'Empty Notes Match',
+            game: testGame,
+            players: [testPlayer1],
+            notes: '',
+          );
+
+          await database.playerDao.addPlayer(player: testPlayer1);
+          await database.gameDao.addGame(game: testGame);
+          await database.matchDao.addMatch(match: matchWithEmptyNotes);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+          final matchData = matches[0] as Map<String, dynamic>;
+
+          expect(matchData['notes'], '');
+        });
+
+        testWidgets('Multiple players in match is handled correctly', (
+          tester,
+        ) async {
+          final multiPlayerMatch = Match(
+            name: 'Multi Player Match',
+            game: testGame,
+            players: [testPlayer1, testPlayer2, testPlayer3],
+            notes: 'Three players',
+          );
+
+          await database.playerDao.addPlayersAsList(
+            players: [testPlayer1, testPlayer2, testPlayer3],
+          );
+          await database.gameDao.addGame(game: testGame);
+          await database.matchDao.addMatch(match: multiPlayerMatch);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final matches = decoded['matches'] as List<dynamic>;
+          final matchData = matches[0] as Map<String, dynamic>;
+
+          final playerIds = matchData['playerIds'] as List<dynamic>;
+          expect(playerIds.length, 3);
+          expect(
+            playerIds,
+            containsAll([testPlayer1.id, testPlayer2.id, testPlayer3.id]),
+          );
+        });
+
+        testWidgets('All game colors are handled correctly', (tester) async {
+          final games = [
+            Game(
+              name: 'Red Game',
+              ruleset: Ruleset.singleWinner,
+              color: GameColor.red,
+              icon: 'icon',
+            ),
+            Game(
+              name: 'Blue Game',
+              ruleset: Ruleset.singleWinner,
+              color: GameColor.blue,
+              icon: 'icon',
+            ),
+            Game(
+              name: 'Green Game',
+              ruleset: Ruleset.singleWinner,
+              color: GameColor.green,
+              icon: 'icon',
+            ),
+          ];
+
+          await database.gameDao.addGamesAsList(games: games);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final gamesJson = decoded['games'] as List<dynamic>;
+
+          expect(gamesJson.length, 3);
+          expect(
+            gamesJson.map((g) => g['color']),
+            containsAll(['red', 'blue', 'green']),
+          );
+        });
+
+        testWidgets('All rulesets are handled correctly', (tester) async {
+          final games = [
+            Game(
+              name: 'Highest Score Game',
+              ruleset: Ruleset.highestScore,
+              color: GameColor.blue,
+              icon: 'icon',
+            ),
+            Game(
+              name: 'Lowest Score Game',
+              ruleset: Ruleset.lowestScore,
+              color: GameColor.blue,
+              icon: 'icon',
+            ),
+            Game(
+              name: 'Single Winner',
+              ruleset: Ruleset.singleWinner,
+              color: GameColor.blue,
+              icon: 'icon',
+            ),
+          ];
+
+          await database.gameDao.addGamesAsList(games: games);
+
+          final ctx = await getContext(tester);
+          final jsonString = await DataTransferService.getAppDataAsJson(ctx);
+          final decoded = json.decode(jsonString) as Map<String, dynamic>;
+          final gamesJson = decoded['games'] as List<dynamic>;
+
+          expect(gamesJson.length, 3);
+          expect(
+            gamesJson.map((g) => g['ruleset']),
+            containsAll(['highestScore', 'lowestScore', 'singleWinner']),
+          );
+        });
+      });
+    });
+
+    group('Parse Methods', () {
+      test('parsePlayersFromJson()', () {
+        final jsonMap = {
+          'players': [
+            {
+              'id': testPlayer1.id,
+              'name': testPlayer1.name,
+              'description': testPlayer1.description,
+              'createdAt': testPlayer1.createdAt.toIso8601String(),
+            },
+            {
+              'id': testPlayer2.id,
+              'name': testPlayer2.name,
+              'description': testPlayer2.description,
+              'createdAt': testPlayer2.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final players = DataTransferService.parsePlayersFromJson(jsonMap);
+
+        expect(players.length, 2);
+        expect(players[0].id, testPlayer1.id);
+        expect(players[0].name, testPlayer1.name);
+        expect(players[1].id, testPlayer2.id);
+        expect(players[1].name, testPlayer2.name);
+      });
+
+      test('parsePlayersFromJson() empty list', () {
+        final jsonMap = {'players': []};
+        final players = DataTransferService.parsePlayersFromJson(jsonMap);
+        expect(players, isEmpty);
+      });
+
+      test('parsePlayersFromJson() missing key', () {
+        final jsonMap = <String, dynamic>{};
+        final players = DataTransferService.parsePlayersFromJson(jsonMap);
+        expect(players, isEmpty);
+      });
+
+      test('parseGamesFromJson()', () {
+        final jsonMap = {
+          'games': [
+            {
+              'id': testGame.id,
+              'name': testGame.name,
+              'ruleset': testGame.ruleset.name,
+              'description': testGame.description,
+              'color': testGame.color.name,
+              'icon': testGame.icon,
+              'createdAt': testGame.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final games = DataTransferService.parseGamesFromJson(jsonMap);
+
+        expect(games.length, 1);
+        expect(games[0].id, testGame.id);
+        expect(games[0].name, testGame.name);
+        expect(games[0].ruleset, testGame.ruleset);
+      });
+
+      test('parseGamesFromJson() empty list', () {
+        final jsonMap = {'games': []};
+        final games = DataTransferService.parseGamesFromJson(jsonMap);
+        expect(games, isEmpty);
+      });
+
+      test('parseGamesFromJson() missing key', () {
+        final jsonMap = <String, dynamic>{};
+        final games = DataTransferService.parseGamesFromJson(jsonMap);
+        expect(games, isEmpty);
+      });
+
+      test('parseGroupsFromJson()', () {
+        final playerById = {
+          testPlayer1.id: testPlayer1,
+          testPlayer2.id: testPlayer2,
+        };
+
+        final jsonMap = {
+          'groups': [
+            {
+              'id': testGroup.id,
+              'name': testGroup.name,
+              'description': testGroup.description,
+              'memberIds': [testPlayer1.id, testPlayer2.id],
+              'createdAt': testGroup.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final groups = DataTransferService.parseGroupsFromJson(
+          jsonMap,
+          playerById,
+        );
+
+        expect(groups.length, 1);
+        expect(groups[0].id, testGroup.id);
+        expect(groups[0].name, testGroup.name);
+        expect(groups[0].members.length, 2);
+        expect(groups[0].members[0].id, testPlayer1.id);
+        expect(groups[0].members[1].id, testPlayer2.id);
+      });
+
+      test('parseGroupsFromJson() empty list', () {
+        final jsonMap = {'groups': []};
+        final groups = DataTransferService.parseGroupsFromJson(jsonMap, {});
+        expect(groups, isEmpty);
+      });
+
+      test('parseGroupsFromJson() missing key', () {
+        final jsonMap = <String, dynamic>{};
+        final groups = DataTransferService.parseGroupsFromJson(jsonMap, {});
+        expect(groups, isEmpty);
+      });
+
+      test('parseGroupsFromJson() ignores invalid player ids', () {
+        final playerById = {testPlayer1.id: testPlayer1};
+
+        final jsonMap = {
+          'groups': [
+            {
+              'id': testGroup.id,
+              'name': testGroup.name,
+              'description': testGroup.description,
+              'memberIds': [testPlayer1.id, 'invalid-id'],
+              'createdAt': testGroup.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final groups = DataTransferService.parseGroupsFromJson(
+          jsonMap,
+          playerById,
+        );
+
+        expect(groups.length, 1);
+        expect(groups[0].members.length, 1);
+        expect(groups[0].members[0].id, testPlayer1.id);
+      });
+
+      test('parseTeamsFromJson()', () {
+        final playerById = {testPlayer1.id: testPlayer1};
+
+        final jsonMap = {
+          'teams': [
+            {
+              'id': testTeam.id,
+              'name': testTeam.name,
+              'memberIds': [testPlayer1.id],
+              'createdAt': testTeam.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final teams = DataTransferService.parseTeamsFromJson(
+          jsonMap,
+          playerById,
+        );
+
+        expect(teams.length, 1);
+        expect(teams[0].id, testTeam.id);
+        expect(teams[0].name, testTeam.name);
+        expect(teams[0].members.length, 1);
+        expect(teams[0].members[0].id, testPlayer1.id);
+      });
+
+      test('parseTeamsFromJson() empty list', () {
+        final jsonMap = {'teams': []};
+        final teams = DataTransferService.parseTeamsFromJson(jsonMap, {});
+        expect(teams, isEmpty);
+      });
+
+      test('parseTeamsFromJson() missing key', () {
+        final jsonMap = <String, dynamic>{};
+        final teams = DataTransferService.parseTeamsFromJson(jsonMap, {});
+        expect(teams, isEmpty);
+      });
+
+      test('parseMatchesFromJson()', () {
+        final playerById = {
+          testPlayer1.id: testPlayer1,
+          testPlayer2.id: testPlayer2,
+        };
+        final gameById = {testGame.id: testGame};
+        final groupById = {testGroup.id: testGroup};
+
+        final jsonMap = {
+          'matches': [
+            {
+              'id': testMatch.id,
+              'name': testMatch.name,
+              'gameId': testGame.id,
+              'groupId': testGroup.id,
+              'playerIds': [testPlayer1.id, testPlayer2.id],
+              'notes': testMatch.notes,
+              'createdAt': testMatch.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          gameById,
+          groupById,
+          playerById,
+        );
+
+        expect(matches.length, 1);
+        expect(matches[0].id, testMatch.id);
+        expect(matches[0].name, testMatch.name);
+        expect(matches[0].game.id, testGame.id);
+        expect(matches[0].group?.id, testGroup.id);
+        expect(matches[0].players.length, 2);
+      });
+
+      test('parseMatchesFromJson() empty list', () {
+        final jsonMap = {'teams': []};
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          {},
+          {},
+          {},
+        );
+        expect(matches, isEmpty);
+      });
+
+      test('parseMatchesFromJson() missing key', () {
+        final jsonMap = <String, dynamic>{};
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          {},
+          {},
+          {},
+        );
+        expect(matches, isEmpty);
+      });
+
+      test('parseMatchesFromJson() creates unknown game for missing game', () {
+        final playerById = {testPlayer1.id: testPlayer1};
+        final gameById = <String, Game>{};
+        final groupById = <String, Group>{};
+
+        final jsonMap = {
+          'matches': [
+            {
+              'id': testMatch.id,
+              'name': testMatch.name,
+              'gameId': 'non-existent-game-id',
+              'playerIds': [testPlayer1.id],
+              'notes': '',
+              'createdAt': testMatch.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          gameById,
+          groupById,
+          playerById,
+        );
+
+        expect(matches.length, 1);
+        expect(matches[0].game.name, 'Unknown');
+        expect(matches[0].game.ruleset, Ruleset.singleWinner);
+      });
+
+      test('parseMatchesFromJson() handles null group', () {
+        final playerById = {testPlayer1.id: testPlayer1};
+        final gameById = {testGame.id: testGame};
+        final groupById = <String, Group>{};
+
+        final jsonMap = {
+          'matches': [
+            {
+              'id': testMatch.id,
+              'name': testMatch.name,
+              'gameId': testGame.id,
+              'groupId': null,
+              'playerIds': [testPlayer1.id],
+              'notes': '',
+              'createdAt': testMatch.createdAt.toIso8601String(),
+            },
+          ],
+        };
+
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          gameById,
+          groupById,
+          playerById,
+        );
+
+        expect(matches.length, 1);
+        expect(matches[0].group, isNull);
+      });
+
+      test('parseMatchesFromJson() handles endedAt', () {
+        final playerById = {testPlayer1.id: testPlayer1};
+        final gameById = {testGame.id: testGame};
+        final groupById = <String, Group>{};
+        final endedDate = DateTime(2025, 12, 1, 10, 0, 0);
+
+        final jsonMap = {
+          'matches': [
+            {
+              'id': testMatch.id,
+              'name': testMatch.name,
+              'gameId': testGame.id,
+              'playerIds': [testPlayer1.id],
+              'notes': '',
+              'createdAt': testMatch.createdAt.toIso8601String(),
+              'endedAt': endedDate.toIso8601String(),
+            },
+          ],
+        };
+
+        final matches = DataTransferService.parseMatchesFromJson(
+          jsonMap,
+          gameById,
+          groupById,
+          playerById,
+        );
+
+        expect(matches.length, 1);
+        expect(matches[0].endedAt, endedDate);
+      });
+    });
+
+    test('validateJsonSchema()', () async {
+      final validJson = json.encode({
+        'players': [
+          {
+            'id': testPlayer1.id,
+            'name': testPlayer1.name,
+            'description': testPlayer1.description,
+            'createdAt': testPlayer1.createdAt.toIso8601String(),
+          },
+        ],
+        'games': [
+          {
+            'id': testGame.id,
+            'name': testGame.name,
+            'ruleset': testGame.ruleset.name,
+            'description': testGame.description,
+            'color': testGame.color.name,
+            'icon': testGame.icon,
+            'createdAt': testGame.createdAt.toIso8601String(),
+          },
+        ],
+        'groups': [
+          {
+            'id': testGroup.id,
+            'name': testGroup.name,
+            'description': testGroup.description,
+            'memberIds': [testPlayer1.id, testPlayer2.id],
+            'createdAt': testGroup.createdAt.toIso8601String(),
+          },
+        ],
+        'teams': [
+          {
+            'id': testTeam.id,
+            'name': testTeam.name,
+            'memberIds': [testPlayer1.id, testPlayer2.id],
+            'createdAt': testTeam.createdAt.toIso8601String(),
+          },
+        ],
+        'matches': [
+          {
+            'id': testMatch.id,
+            'name': testMatch.name,
+            'gameId': testGame.id,
+            'groupId': testGroup.id,
+            'playerIds': [testPlayer1.id, testPlayer2.id],
+            'notes': testMatch.notes,
+            'scores': {
+              testPlayer1.id: [
+                {'roundNumber': 1, 'score': 10, 'change': 10},
+                {'roundNumber': 2, 'score': 20, 'change': 10},
+              ],
+              testPlayer2.id: [
+                {'roundNumber': 1, 'score': 15, 'change': 15},
+                {'roundNumber': 2, 'score': 25, 'change': 10},
+              ],
+            },
+            'createdAt': testMatch.createdAt.toIso8601String(),
+            'endedAt': null,
+          },
+        ],
+      });
+
+      final isValid = await DataTransferService.validateJsonSchema(validJson);
+      expect(isValid, true);
+    });
+  });
+}