implement basic player_detail_view.dart

lib/data/dao/group_dao.dart

@@ -185,6 +185,38 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
     return count ?? 0;
   }
 
+  /// Retrieves all groups a specific player belongs to.
+  /// Returns an empty list if the player is not part of any group.
+  Future<List<Group>> getGroupsByPlayer({required String playerId}) async {
+    final playerGroups = await (select(
+      playerGroupTable,
+    )..where((pg) => pg.playerId.equals(playerId))).get();
+
+    if (playerGroups.isEmpty) return [];
+
+    final groupIds = playerGroups.map((pg) => pg.groupId).toSet().toList();
+    final rows =
+        await (select(groupTable)
+              ..where((g) => g.id.isIn(groupIds))
+              ..orderBy([(g) => OrderingTerm.desc(g.createdAt)]))
+            .get();
+
+    return Future.wait(
+      rows.map((groupData) async {
+        final members = await db.playerGroupDao.getPlayersOfGroup(
+          groupId: groupData.id,
+        );
+        return Group(
+          id: groupData.id,
+          name: groupData.name,
+          description: groupData.description,
+          members: members,
+          createdAt: groupData.createdAt,
+        );
+      }),
+    );
+  }
+
   /// Checks if a group with the given [groupId] exists in the database.
   /// Returns `true` if the group exists, `false` otherwise.
   Future<bool> groupExists({required String groupId}) async {

lib/data/dao/match_dao.dart

@@ -352,6 +352,53 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
     return count ?? 0;
   }
 
+  Future<List<Match>> getMatchesByPlayer({required String playerId}) async {
+    final playerMatches = await (select(
+      playerMatchTable,
+    )..where((pm) => pm.playerId.equals(playerId))).get();
+
+    if (playerMatches.isEmpty) return [];
+
+    final matchIds = playerMatches.map((pm) => pm.matchId).toSet().toList();
+    final rows =
+        await (select(matchTable)
+              ..where((m) => m.id.isIn(matchIds))
+              ..orderBy([(m) => OrderingTerm.desc(m.createdAt)]))
+            .get();
+
+    return Future.wait(
+      rows.map((row) async {
+        final game = await db.gameDao.getGameById(gameId: row.gameId);
+
+        Group? group;
+        if (row.groupId != null) {
+          group = await db.groupDao.getGroupById(groupId: row.groupId!);
+        }
+
+        final players = await db.playerMatchDao.getPlayersOfMatch(
+          matchId: row.id,
+        );
+        final scores = await db.scoreEntryDao.getAllMatchScores(
+          matchId: row.id,
+        );
+        final teams = await _getMatchTeams(matchId: row.id);
+
+        return Match(
+          id: row.id,
+          name: row.name,
+          game: game,
+          group: group,
+          players: players,
+          teams: teams.isEmpty ? null : teams,
+          notes: row.notes,
+          createdAt: row.createdAt,
+          endedAt: row.endedAt,
+          scores: scores,
+        );
+      }),
+    );
+  }
+
   /// Retrieves all matches associated with the given [groupId].
   /// Queries the database directly, filtering by [groupId].
   Future<List<Match>> getMatchesByGroup({required String groupId}) async {