feat: basic database functionality

lib/data/dao/statistic_dao.dart

@@ -0,0 +1,112 @@
+import 'package:collection/collection.dart';
+import 'package:drift/drift.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/db/tables/statistic_table.dart';
+import 'package:tallee/data/models/statistic.dart';
+
+part 'statistic_dao.g.dart';
+
+@DriftAccessor(tables: [StatisticTable])
+class StatisticDao extends DatabaseAccessor<AppDatabase>
+    with _$StatisticDaoMixin {
+  StatisticDao(super.db);
+
+  /* Create */
+
+  Future<bool> addStatistic({required Statistic statistic}) async {
+    await into(statisticTable).insert(
+      StatisticTableCompanion.insert(
+        id: statistic.id,
+        type: statistic.type.name,
+        timeframe: Value(statistic.timeframe?.name),
+      ),
+      mode: InsertMode.insertOrReplace,
+    );
+
+    await db.statisticScopeDao.addStatisticScopes(
+      statisticId: statistic.id,
+      scopes: statistic.scopes,
+    );
+
+    if (statistic.selectedGroups != null) {
+      await db.statisticGroupDao.addStatisticGroups(
+        statisticId: statistic.id,
+        groups: statistic.selectedGroups!,
+      );
+    }
+
+    if (statistic.selectedGames != null) {
+      await db.statisticGameDao.addStatisticGames(
+        statisticId: statistic.id,
+        games: statistic.selectedGames!,
+      );
+    }
+
+    return true;
+  }
+
+  /* Read */
+
+  Future<Statistic?> getStatisticById(String statisticId) async {
+    final query = select(statisticTable);
+    final row = await query.getSingleOrNull();
+    if (row != null) {
+      final groups = await db.statisticGroupDao.getGroupsForStatistic(row.id);
+      final games = await db.statisticGameDao.getGamesForStatistic(row.id);
+      final scopes = await db.statisticScopeDao.getScopeForStatistic(row.id);
+
+      return Statistic(
+        type: StatisticType.values.firstWhere((type) => type.name == row.type),
+        scopes: scopes,
+        id: row.id,
+        timeframe: Timeframe.values.firstWhereOrNull(
+          (t) => t.name == row.timeframe,
+        ),
+        selectedGroups: groups,
+        selectedGames: games,
+      );
+    }
+    return null;
+  }
+
+  /// Retrieves all statistics from the database, including their associated groups and games.
+  Future<List<Statistic>> getAllStatistics() async {
+    final query = select(statisticTable);
+    final rows = await query.get();
+    return Future.wait(
+      rows.map((row) async {
+        final groups = await db.statisticGroupDao.getGroupsForStatistic(row.id);
+        final games = await db.statisticGameDao.getGamesForStatistic(row.id);
+
+        return Statistic(
+          type: StatisticType.values.firstWhere(
+            (type) => type.name == row.type,
+          ),
+          scopes: [],
+          id: row.id,
+          timeframe: Timeframe.values.firstWhereOrNull(
+            (t) => t.name == row.timeframe,
+          ),
+          selectedGroups: groups,
+          selectedGames: games,
+        );
+      }),
+    );
+  }
+
+  /* Delete */
+
+  Future<bool> deleteStatistic(String statisticId) async {
+    final rowsDeleted = await (delete(
+      statisticTable,
+    )..where((tbl) => tbl.id.equals(statisticId))).go();
+
+    return rowsDeleted > 0;
+  }
+
+  Future<bool> deleteAllStatistics() async {
+    final rowsDeleted = await delete(statisticTable).go();
+    return rowsDeleted > 0;
+  }
+}

lib/data/dao/statistic_dao.g.dart

@@ -0,0 +1,19 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'statistic_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$StatisticDaoMixin on DatabaseAccessor<AppDatabase> {
+  $StatisticTableTable get statisticTable => attachedDatabase.statisticTable;
+  StatisticDaoManager get managers => StatisticDaoManager(this);
+}
+
+class StatisticDaoManager {
+  final _$StatisticDaoMixin _db;
+  StatisticDaoManager(this._db);
+  $$StatisticTableTableTableManager get statisticTable =>
+      $$StatisticTableTableTableManager(
+        _db.attachedDatabase,
+        _db.statisticTable,
+      );
+}

lib/data/dao/statistic_game_dao.dart

@@ -0,0 +1,60 @@
+import 'package:drift/drift.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/db/tables/statistic_game_table.dart';
+import 'package:tallee/data/models/game.dart';
+
+part 'statistic_game_dao.g.dart';
+
+@DriftAccessor(tables: [StatisticGameTable])
+class StatisticGameDao extends DatabaseAccessor<AppDatabase>
+    with _$StatisticGameDaoMixin {
+  StatisticGameDao(super.db);
+
+  /// Retrieves a list of games associated with a specific statistic.
+  Future<List<Game>> getGamesForStatistic(String statisticId) async {
+    final query = select(statisticGameTable).join([
+      innerJoin(gameTable, gameTable.id.equalsExp(statisticGameTable.gameId)),
+    ])..where(statisticGameTable.statisticId.equals(statisticId));
+
+    final results = await query.map((row) => row.readTable(gameTable)).get();
+    return results
+        .map(
+          (result) => Game(
+            id: result.id,
+            name: result.name,
+            ruleset: Ruleset.values.firstWhere((e) => e.name == result.ruleset),
+            description: result.description,
+            color: GameColor.values.firstWhere((e) => e.name == result.color),
+            icon: result.icon,
+            createdAt: result.createdAt,
+          ),
+        )
+        .toList();
+  }
+
+  Future<bool> addStatisticGames({
+    required String statisticId,
+    required List<Game> games,
+  }) {
+    final entries = games
+        .map(
+          (game) => StatisticGameTableCompanion.insert(
+            statisticId: statisticId,
+            gameId: game.id,
+          ),
+        )
+        .toList();
+
+    return batch((batch) {
+      batch.insertAll(
+        statisticGameTable,
+        entries,
+        mode: InsertMode.insertOrReplace,
+      );
+    }).then((_) => true).catchError((error) {
+      print('Error adding statistic games: $error');
+      return false;
+    });
+  }
+}

lib/data/dao/statistic_game_dao.g.dart

@@ -0,0 +1,29 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'statistic_game_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$StatisticGameDaoMixin on DatabaseAccessor<AppDatabase> {
+  $StatisticTableTable get statisticTable => attachedDatabase.statisticTable;
+  $GameTableTable get gameTable => attachedDatabase.gameTable;
+  $StatisticGameTableTable get statisticGameTable =>
+      attachedDatabase.statisticGameTable;
+  StatisticGameDaoManager get managers => StatisticGameDaoManager(this);
+}
+
+class StatisticGameDaoManager {
+  final _$StatisticGameDaoMixin _db;
+  StatisticGameDaoManager(this._db);
+  $$StatisticTableTableTableManager get statisticTable =>
+      $$StatisticTableTableTableManager(
+        _db.attachedDatabase,
+        _db.statisticTable,
+      );
+  $$GameTableTableTableManager get gameTable =>
+      $$GameTableTableTableManager(_db.attachedDatabase, _db.gameTable);
+  $$StatisticGameTableTableTableManager get statisticGameTable =>
+      $$StatisticGameTableTableTableManager(
+        _db.attachedDatabase,
+        _db.statisticGameTable,
+      );
+}

lib/data/dao/statistic_group_dao.dart

@@ -0,0 +1,66 @@
+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/statistic_group_table.dart';
+import 'package:tallee/data/models/group.dart';
+
+part 'statistic_group_dao.g.dart';
+
+@DriftAccessor(tables: [StatisticGroupTable, GroupTable])
+class StatisticGroupDao extends DatabaseAccessor<AppDatabase>
+    with _$StatisticGroupDaoMixin {
+  StatisticGroupDao(super.db);
+
+  /// Retrieves a list of groups associated with a specific statistic.
+  Future<List<Group>> getGroupsForStatistic(String statisticId) async {
+    final query = select(statisticGroupTable).join([
+      innerJoin(
+        groupTable,
+        groupTable.id.equalsExp(statisticGroupTable.groupId),
+      ),
+    ])..where(statisticGroupTable.statisticId.equals(statisticId));
+
+    final results = await query.map((row) => row.readTable(groupTable)).get();
+    final groups = await Future.wait(
+      results.map((result) async {
+        final groupMembers = await db.playerGroupDao.getPlayersOfGroup(
+          groupId: result.id,
+        );
+        return Group(
+          id: result.id,
+          createdAt: result.createdAt,
+          name: result.name,
+          description: result.description,
+          members: groupMembers,
+        );
+      }),
+    );
+
+    return groups;
+  }
+
+  Future<bool> addStatisticGroups({
+    required String statisticId,
+    required List<Group> groups,
+  }) async {
+    final entries = groups
+        .map(
+          (group) => StatisticGroupTableCompanion.insert(
+            statisticId: statisticId,
+            groupId: group.id,
+          ),
+        )
+        .toList();
+
+    return batch((batch) {
+      batch.insertAll(
+        statisticGroupTable,
+        entries,
+        mode: InsertMode.insertOrReplace,
+      );
+    }).then((_) => true).catchError((error) {
+      print('Error adding statistic groups: $error');
+      return false;
+    });
+  }
+}

lib/data/dao/statistic_group_dao.g.dart

@@ -0,0 +1,29 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'statistic_group_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$StatisticGroupDaoMixin on DatabaseAccessor<AppDatabase> {
+  $StatisticTableTable get statisticTable => attachedDatabase.statisticTable;
+  $GroupTableTable get groupTable => attachedDatabase.groupTable;
+  $StatisticGroupTableTable get statisticGroupTable =>
+      attachedDatabase.statisticGroupTable;
+  StatisticGroupDaoManager get managers => StatisticGroupDaoManager(this);
+}
+
+class StatisticGroupDaoManager {
+  final _$StatisticGroupDaoMixin _db;
+  StatisticGroupDaoManager(this._db);
+  $$StatisticTableTableTableManager get statisticTable =>
+      $$StatisticTableTableTableManager(
+        _db.attachedDatabase,
+        _db.statisticTable,
+      );
+  $$GroupTableTableTableManager get groupTable =>
+      $$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
+  $$StatisticGroupTableTableTableManager get statisticGroupTable =>
+      $$StatisticGroupTableTableTableManager(
+        _db.attachedDatabase,
+        _db.statisticGroupTable,
+      );
+}

lib/data/dao/statistic_scope_dao.dart

@@ -0,0 +1,55 @@
+import 'package:drift/drift.dart';
+import 'package:tallee/core/enums.dart';
+import 'package:tallee/data/db/database.dart';
+import 'package:tallee/data/db/tables/statistic_scope_table.dart';
+
+part 'statistic_scope_dao.g.dart';
+
+@DriftAccessor(tables: [StatisticScopeTable])
+class StatisticScopeDao extends DatabaseAccessor<AppDatabase>
+    with _$StatisticScopeDaoMixin {
+  StatisticScopeDao(super.db);
+
+  /// Retrieves a list of statistic scopes associated with a specific statistic ID.
+  Future<List<StatisticScope>> getScopeForStatistic(String statisticId) async {
+    final query = select(statisticScopeTable)
+      ..where((tbl) => tbl.statisticId.equals(statisticId));
+
+    final results = await query.get();
+    return results
+        .map(
+          (result) => StatisticScope.values.firstWhere(
+            (e) => e.name == result.scope,
+            orElse: () => throw Exception(
+              'Invalid scope value: ${result.scope} for statistic ID: $statisticId',
+            ),
+          ),
+        )
+        .toList();
+  }
+
+  Future<bool> addStatisticScopes({
+    required String statisticId,
+    required List<StatisticScope> scopes,
+  }) async {
+    final entries = scopes
+        .map(
+          (scope) => StatisticScopeTableCompanion.insert(
+            statisticId: statisticId,
+            scope: scope.name,
+          ),
+        )
+        .toList();
+
+    return batch((batch) {
+      batch.insertAll(
+        statisticScopeTable,
+        entries,
+        mode: InsertMode.insertOrReplace,
+      );
+    }).then((_) => true).catchError((error) {
+      print('Error adding statistic scopes: $error');
+      return false;
+    });
+  }
+}

lib/data/dao/statistic_scope_dao.g.dart

@@ -0,0 +1,26 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'statistic_scope_dao.dart';
+
+// ignore_for_file: type=lint
+mixin _$StatisticScopeDaoMixin on DatabaseAccessor<AppDatabase> {
+  $StatisticTableTable get statisticTable => attachedDatabase.statisticTable;
+  $StatisticScopeTableTable get statisticScopeTable =>
+      attachedDatabase.statisticScopeTable;
+  StatisticScopeDaoManager get managers => StatisticScopeDaoManager(this);
+}
+
+class StatisticScopeDaoManager {
+  final _$StatisticScopeDaoMixin _db;
+  StatisticScopeDaoManager(this._db);
+  $$StatisticTableTableTableManager get statisticTable =>
+      $$StatisticTableTableTableManager(
+        _db.attachedDatabase,
+        _db.statisticTable,
+      );
+  $$StatisticScopeTableTableTableManager get statisticScopeTable =>
+      $$StatisticScopeTableTableTableManager(
+        _db.attachedDatabase,
+        _db.statisticScopeTable,
+      );
+}