diff --git a/lib/data/dao/game_dao.dart b/lib/data/dao/game_dao.dart new file mode 100644 index 0000000..e59fae4 --- /dev/null +++ b/lib/data/dao/game_dao.dart @@ -0,0 +1,25 @@ +import 'package:drift/drift.dart'; +import 'package:game_tracker/data/db/database.dart'; +import 'package:game_tracker/data/db/tables/game_table.dart'; +import 'package:game_tracker/data/dto/game.dart'; + +part 'game_dao.g.dart'; + +@DriftAccessor(tables: [GameTable]) +class GameDao extends DatabaseAccessor with _$GameDaoMixin { + GameDao(super.db); + + /// Retrieves all games from the database. + Future> getAllGames() async { + final query = select(gameTable); + final result = await query.get(); + return result.map((row) => Game(id: row.id, name: row.name)).toList(); + } + + /// Retrieves a [Game] by its [id]. + Future getGameById(String id) async { + final query = select(gameTable)..where((g) => g.id.equals(id)); + final result = await query.getSingle(); + return Game(id: result.id, name: result.name); + } +} diff --git a/lib/data/dao/game_dao.g.dart b/lib/data/dao/game_dao.g.dart new file mode 100644 index 0000000..b5a29fe --- /dev/null +++ b/lib/data/dao/game_dao.g.dart @@ -0,0 +1,8 @@ +// GENERATED CODE - DO NOT MODIFY BY HAND + +part of 'game_dao.dart'; + +// ignore_for_file: type=lint +mixin _$GameDaoMixin on DatabaseAccessor { + $GameTableTable get gameTable => attachedDatabase.gameTable; +} diff --git a/lib/data/dao/group_dao.dart b/lib/data/dao/group_dao.dart index d2f529c..c1932d3 100644 --- a/lib/data/dao/group_dao.dart +++ b/lib/data/dao/group_dao.dart @@ -2,6 +2,7 @@ import 'package:drift/drift.dart'; import 'package:game_tracker/data/db/database.dart'; import 'package:game_tracker/data/db/tables/group_table.dart'; import 'package:game_tracker/data/dto/group.dart'; +import 'package:game_tracker/data/dto/player.dart'; part 'group_dao.g.dart'; @@ -9,6 +10,7 @@ part 'group_dao.g.dart'; class GroupDao extends DatabaseAccessor with _$GroupDaoMixin { GroupDao(super.db); + /// Retrieves all groups from the database. Future> getAllGroups() async { final query = select(groupTable); final result = await query.get(); @@ -17,26 +19,41 @@ class GroupDao extends DatabaseAccessor with _$GroupDaoMixin { .toList(); } + /// Retrieves a [Group] by its [id], including its members. Future getGroupById(String id) async { final query = select(groupTable)..where((g) => g.id.equals(id)); final result = await query.getSingle(); - // todo: Get group members + List members = []; - return Group(id: result.id, name: result.name, members: []); + members = await db.playerGroupDao.getPlayersOfGroupById(id); + + return Group(id: result.id, name: result.name, members: members); } + /// Adds a new group with the given [id] and [name] to the database. + /// Returns `true` if more than 0 rows were affected, otherwise `false`. Future addGroup(String id, String name) async { - await into(group).insert(GroupCompanion.insert(id: id, name: name)); + await into( + groupTable, + ).insert(GroupTableCompanion.insert(id: id, name: name)); } - Future deleteGroup(String id) async { - await (delete(group)..where((g) => g.id.equals(id))).go(); + /// Deletes the group with the given [id] from the database. + /// Returns `true` if more than 0 rows were affected, otherwise `false`. + Future deleteGroup(String id) async { + final query = (delete(groupTable)..where((g) => g.id.equals(id))); + final rowsAffected = await query.go(); + return rowsAffected > 0; } - Future updateGroupname(String id, String newName) async { - await (update(group)..where((g) => g.id.equals(id))).write( - GroupCompanion(name: Value(newName)), - ); + /// Updates the name of the group with the given [id] to [newName]. + /// Returns `true` if more than 0 rows were affected, otherwise `false`. + Future updateGroupname(String id, String newName) async { + final rowsAffected = + await (update(groupTable)..where((g) => g.id.equals(id))).write( + GroupTableCompanion(name: Value(newName)), + ); + return rowsAffected > 0; } } diff --git a/lib/data/dao/player_dao.dart b/lib/data/dao/player_dao.dart index d7a7596..2d3c0ab 100644 --- a/lib/data/dao/player_dao.dart +++ b/lib/data/dao/player_dao.dart @@ -9,25 +9,47 @@ part 'player_dao.g.dart'; class PlayerDao extends DatabaseAccessor with _$PlayerDaoMixin { PlayerDao(super.db); - Future> getAllUsers() async { - return await select(UserTable).get(); + /// Retrieves all players from the database. + Future> getAllPlayers() async { + final query = select(playerTable); + final result = await query.get(); + return result.map((row) => Player(id: row.id, name: row.name)).toList(); } - Future getUserById(String id) async { - return await (select(user)..where((u) => u.id.equals(id))).getSingle(); + /// Retrieves a [Player] by their [id]. + Future getPlayerById(String id) async { + final query = select(playerTable)..where((p) => p.id.equals(id)); + final result = await query.getSingle(); + return Player(id: result.id, name: result.name); } - Future addUser(String id, String name) async { - await into(user).insert(UserCompanion.insert(id: id, name: name)); + /// Adds a new [player] to the database. + Future addPlayer(Player player) async { + await into( + playerTable, + ).insert(PlayerTableCompanion.insert(id: player.id, name: player.name)); } - Future deleteUser(String id) async { - await (delete(user)..where((u) => u.id.equals(id))).go(); + /// Deletes the player with the given [id] from the database. + /// Returns `true` if the player was deleted, `false` if the player did not exist. + Future deletePlayer(String id) async { + final query = delete(playerTable)..where((p) => p.id.equals(id)); + final rowsAffected = await query.go(); + return rowsAffected > 0; } - Future updateUsername(String id, String newName) async { - await (update(user)..where((u) => u.id.equals(id))).write( - UserCompanion(name: Value(newName)), + /// Checks if a player with the given [id] exists in the database. + /// Returns `true` if the player exists, `false` otherwise. + Future playerExists(String id) async { + final query = select(playerTable)..where((p) => p.id.equals(id)); + final result = await query.getSingleOrNull(); + return result != null; + } + + /// Updates the name of the player with the given [id] to [newName]. + Future updatePlayername(String id, String newName) async { + await (update(playerTable)..where((p) => p.id.equals(id))).write( + PlayerTableCompanion(name: Value(newName)), ); } } diff --git a/lib/data/dao/player_group_dao.dart b/lib/data/dao/player_group_dao.dart index c4daf21..b68ed09 100644 --- a/lib/data/dao/player_group_dao.dart +++ b/lib/data/dao/player_group_dao.dart @@ -1,6 +1,7 @@ import 'package:drift/drift.dart'; import 'package:game_tracker/data/db/database.dart'; import 'package:game_tracker/data/db/tables/player_group_table.dart'; +import 'package:game_tracker/data/dto/player.dart'; part 'player_group_dao.g.dart'; @@ -9,32 +10,35 @@ class PlayerGroupDao extends DatabaseAccessor with _$PlayerGroupDaoMixin { PlayerGroupDao(super.db); - Future> getAllUsersAndGroups() async { - return await select(userGroup).get(); + /// Retrieves all players belonging to a specific group by [groupId]. + Future> getPlayersOfGroupById(String groupId) async { + final query = select(playerGroupTable) + ..where((pG) => pG.groupId.equals(groupId)); + final result = await query.get(); + + List groupMembers = []; + + for (var entry in result) { + final player = await db.playerDao.getPlayerById(entry.userId); + groupMembers.add(player); + } + + return groupMembers; } - Future> getUsersGroups(String userId) async { - return await (select( - userGroup, - )..where((uG) => uG.userId.equals(userId))).get(); + /// Removes a player from a group based on [userId] and [groupId]. + /// Returns `true` if more than 0 rows were affected, otherwise `false`. + Future removePlayerFromGroup(String userId, String groupId) async { + final query = delete(playerGroupTable) + ..where((p) => p.userId.equals(userId) & p.groupId.equals(groupId)); + final rowsAffected = await query.go(); + return rowsAffected > 0; } - Future> getGroupsUsers(String groupId) async { - return await (select( - userGroup, - )..where((uG) => uG.groupId.equals(groupId))).get(); - } - - Future addUserToGroup(String userId, String groupId) async { - await into( - userGroup, - ).insert(UserGroupCompanion.insert(userId: userId, groupId: groupId)); - } - - Future removeUserFromGroup(String userId, String groupId) async { - await (delete( - userGroup, - )..where((uG) => uG.userId.equals(userId) & uG.groupId.equals(groupId))) - .go(); + /// Adds a player to a group with the given [userId] and [groupId]. + Future addPlayerToGroup(String userId, String groupId) async { + await into(playerGroupTable).insert( + PlayerGroupTableCompanion.insert(userId: userId, groupId: groupId), + ); } } diff --git a/lib/data/dao/player_group_dao.g.dart b/lib/data/dao/player_group_dao.g.dart index d512bb4..d54f979 100644 --- a/lib/data/dao/player_group_dao.g.dart +++ b/lib/data/dao/player_group_dao.g.dart @@ -4,6 +4,8 @@ part of 'player_group_dao.dart'; // ignore_for_file: type=lint mixin _$PlayerGroupDaoMixin on DatabaseAccessor { + $PlayerTableTable get playerTable => attachedDatabase.playerTable; + $GroupTableTable get groupTable => attachedDatabase.groupTable; $PlayerGroupTableTable get playerGroupTable => attachedDatabase.playerGroupTable; } diff --git a/lib/data/db/database.dart b/lib/data/db/database.dart index 6d4dedc..e35513e 100644 --- a/lib/data/db/database.dart +++ b/lib/data/db/database.dart @@ -1,8 +1,10 @@ import 'package:drift/drift.dart'; import 'package:drift_flutter/drift_flutter.dart'; +import 'package:game_tracker/data/dao/game_dao.dart'; import 'package:game_tracker/data/dao/group_dao.dart'; import 'package:game_tracker/data/dao/player_dao.dart'; import 'package:game_tracker/data/dao/player_group_dao.dart'; +import 'package:game_tracker/data/db/tables/game_table.dart'; import 'package:game_tracker/data/db/tables/group_table.dart'; import 'package:game_tracker/data/db/tables/player_group_table.dart'; import 'package:game_tracker/data/db/tables/player_table.dart'; @@ -11,8 +13,8 @@ import 'package:path_provider/path_provider.dart'; part 'database.g.dart'; @DriftDatabase( - tables: [PlayerTable, GroupTable, PlayerGroupTable], - daos: [GroupDao, PlayerDao, PlayerGroupDao], + tables: [PlayerTable, GroupTable, PlayerGroupTable, GameTable], + daos: [GroupDao, PlayerDao, PlayerGroupDao, GameDao], ) class AppDatabase extends _$AppDatabase { AppDatabase([QueryExecutor? executor]) : super(executor ?? _openConnection()); diff --git a/lib/data/db/database.g.dart b/lib/data/db/database.g.dart index 150b8a3..4075912 100644 --- a/lib/data/db/database.g.dart +++ b/lib/data/db/database.g.dart @@ -427,6 +427,9 @@ class $PlayerGroupTableTable extends PlayerGroupTable false, type: DriftSqlType.string, requiredDuringInsert: true, + defaultConstraints: GeneratedColumn.constraintIsAlways( + 'REFERENCES player_table (id)', + ), ); static const VerificationMeta _groupIdMeta = const VerificationMeta( 'groupId', @@ -438,6 +441,9 @@ class $PlayerGroupTableTable extends PlayerGroupTable false, type: DriftSqlType.string, requiredDuringInsert: true, + defaultConstraints: GeneratedColumn.constraintIsAlways( + 'REFERENCES group_table (id)', + ), ); @override List get $columns => [userId, groupId]; @@ -630,6 +636,211 @@ class PlayerGroupTableCompanion extends UpdateCompanion { } } +class $GameTableTable extends GameTable + with TableInfo<$GameTableTable, GameTableData> { + @override + final GeneratedDatabase attachedDatabase; + final String? _alias; + $GameTableTable(this.attachedDatabase, [this._alias]); + static const VerificationMeta _idMeta = const VerificationMeta('id'); + @override + late final GeneratedColumn id = GeneratedColumn( + 'id', + aliasedName, + false, + type: DriftSqlType.string, + requiredDuringInsert: true, + ); + static const VerificationMeta _nameMeta = const VerificationMeta('name'); + @override + late final GeneratedColumn name = GeneratedColumn( + 'name', + aliasedName, + false, + type: DriftSqlType.string, + requiredDuringInsert: true, + ); + @override + List get $columns => [id, name]; + @override + String get aliasedName => _alias ?? actualTableName; + @override + String get actualTableName => $name; + static const String $name = 'game_table'; + @override + VerificationContext validateIntegrity( + Insertable instance, { + bool isInserting = false, + }) { + final context = VerificationContext(); + final data = instance.toColumns(true); + if (data.containsKey('id')) { + context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta)); + } else if (isInserting) { + context.missing(_idMeta); + } + if (data.containsKey('name')) { + context.handle( + _nameMeta, + name.isAcceptableOrUnknown(data['name']!, _nameMeta), + ); + } else if (isInserting) { + context.missing(_nameMeta); + } + return context; + } + + @override + Set get $primaryKey => {id}; + @override + GameTableData map(Map data, {String? tablePrefix}) { + final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : ''; + return GameTableData( + id: attachedDatabase.typeMapping.read( + DriftSqlType.string, + data['${effectivePrefix}id'], + )!, + name: attachedDatabase.typeMapping.read( + DriftSqlType.string, + data['${effectivePrefix}name'], + )!, + ); + } + + @override + $GameTableTable createAlias(String alias) { + return $GameTableTable(attachedDatabase, alias); + } +} + +class GameTableData extends DataClass implements Insertable { + final String id; + final String name; + const GameTableData({required this.id, required this.name}); + @override + Map toColumns(bool nullToAbsent) { + final map = {}; + map['id'] = Variable(id); + map['name'] = Variable(name); + return map; + } + + GameTableCompanion toCompanion(bool nullToAbsent) { + return GameTableCompanion(id: Value(id), name: Value(name)); + } + + factory GameTableData.fromJson( + Map json, { + ValueSerializer? serializer, + }) { + serializer ??= driftRuntimeOptions.defaultSerializer; + return GameTableData( + id: serializer.fromJson(json['id']), + name: serializer.fromJson(json['name']), + ); + } + @override + Map toJson({ValueSerializer? serializer}) { + serializer ??= driftRuntimeOptions.defaultSerializer; + return { + 'id': serializer.toJson(id), + 'name': serializer.toJson(name), + }; + } + + GameTableData copyWith({String? id, String? name}) => + GameTableData(id: id ?? this.id, name: name ?? this.name); + GameTableData copyWithCompanion(GameTableCompanion data) { + return GameTableData( + id: data.id.present ? data.id.value : this.id, + name: data.name.present ? data.name.value : this.name, + ); + } + + @override + String toString() { + return (StringBuffer('GameTableData(') + ..write('id: $id, ') + ..write('name: $name') + ..write(')')) + .toString(); + } + + @override + int get hashCode => Object.hash(id, name); + @override + bool operator ==(Object other) => + identical(this, other) || + (other is GameTableData && + other.id == this.id && + other.name == this.name); +} + +class GameTableCompanion extends UpdateCompanion { + final Value id; + final Value name; + final Value rowid; + const GameTableCompanion({ + this.id = const Value.absent(), + this.name = const Value.absent(), + this.rowid = const Value.absent(), + }); + GameTableCompanion.insert({ + required String id, + required String name, + this.rowid = const Value.absent(), + }) : id = Value(id), + name = Value(name); + static Insertable custom({ + Expression? id, + Expression? name, + Expression? rowid, + }) { + return RawValuesInsertable({ + if (id != null) 'id': id, + if (name != null) 'name': name, + if (rowid != null) 'rowid': rowid, + }); + } + + GameTableCompanion copyWith({ + Value? id, + Value? name, + Value? rowid, + }) { + return GameTableCompanion( + id: id ?? this.id, + name: name ?? this.name, + rowid: rowid ?? this.rowid, + ); + } + + @override + Map toColumns(bool nullToAbsent) { + final map = {}; + if (id.present) { + map['id'] = Variable(id.value); + } + if (name.present) { + map['name'] = Variable(name.value); + } + if (rowid.present) { + map['rowid'] = Variable(rowid.value); + } + return map; + } + + @override + String toString() { + return (StringBuffer('GameTableCompanion(') + ..write('id: $id, ') + ..write('name: $name, ') + ..write('rowid: $rowid') + ..write(')')) + .toString(); + } +} + abstract class _$AppDatabase extends GeneratedDatabase { _$AppDatabase(QueryExecutor e) : super(e); $AppDatabaseManager get managers => $AppDatabaseManager(this); @@ -638,11 +849,13 @@ abstract class _$AppDatabase extends GeneratedDatabase { late final $PlayerGroupTableTable playerGroupTable = $PlayerGroupTableTable( this, ); + late final $GameTableTable gameTable = $GameTableTable(this); late final GroupDao groupDao = GroupDao(this as AppDatabase); late final PlayerDao playerDao = PlayerDao(this as AppDatabase); late final PlayerGroupDao playerGroupDao = PlayerGroupDao( this as AppDatabase, ); + late final GameDao gameDao = GameDao(this as AppDatabase); @override Iterable> get allTables => allSchemaEntities.whereType>(); @@ -651,6 +864,7 @@ abstract class _$AppDatabase extends GeneratedDatabase { playerTable, groupTable, playerGroupTable, + gameTable, ]; } @@ -667,6 +881,34 @@ typedef $$PlayerTableTableUpdateCompanionBuilder = Value rowid, }); +final class $$PlayerTableTableReferences + extends BaseReferences<_$AppDatabase, $PlayerTableTable, PlayerTableData> { + $$PlayerTableTableReferences(super.$_db, super.$_table, super.$_typedResult); + + static MultiTypedResultKey<$PlayerGroupTableTable, List> + _playerGroupTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable( + db.playerGroupTable, + aliasName: $_aliasNameGenerator( + db.playerTable.id, + db.playerGroupTable.userId, + ), + ); + + $$PlayerGroupTableTableProcessedTableManager get playerGroupTableRefs { + final manager = $$PlayerGroupTableTableTableManager( + $_db, + $_db.playerGroupTable, + ).filter((f) => f.userId.id.sqlEquals($_itemColumn('id')!)); + + final cache = $_typedResult.readTableOrNull( + _playerGroupTableRefsTable($_db), + ); + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: cache), + ); + } +} + class $$PlayerTableTableFilterComposer extends Composer<_$AppDatabase, $PlayerTableTable> { $$PlayerTableTableFilterComposer({ @@ -685,6 +927,31 @@ class $$PlayerTableTableFilterComposer column: $table.name, builder: (column) => ColumnFilters(column), ); + + Expression playerGroupTableRefs( + Expression Function($$PlayerGroupTableTableFilterComposer f) f, + ) { + final $$PlayerGroupTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.playerGroupTable, + getReferencedColumn: (t) => t.userId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$PlayerGroupTableTableFilterComposer( + $db: $db, + $table: $db.playerGroupTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } } class $$PlayerTableTableOrderingComposer @@ -721,6 +988,31 @@ class $$PlayerTableTableAnnotationComposer GeneratedColumn get name => $composableBuilder(column: $table.name, builder: (column) => column); + + Expression playerGroupTableRefs( + Expression Function($$PlayerGroupTableTableAnnotationComposer a) f, + ) { + final $$PlayerGroupTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.playerGroupTable, + getReferencedColumn: (t) => t.userId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$PlayerGroupTableTableAnnotationComposer( + $db: $db, + $table: $db.playerGroupTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } } class $$PlayerTableTableTableManager @@ -734,12 +1026,9 @@ class $$PlayerTableTableTableManager $$PlayerTableTableAnnotationComposer, $$PlayerTableTableCreateCompanionBuilder, $$PlayerTableTableUpdateCompanionBuilder, - ( - PlayerTableData, - BaseReferences<_$AppDatabase, $PlayerTableTable, PlayerTableData>, - ), + (PlayerTableData, $$PlayerTableTableReferences), PlayerTableData, - PrefetchHooks Function() + PrefetchHooks Function({bool playerGroupTableRefs}) > { $$PlayerTableTableTableManager(_$AppDatabase db, $PlayerTableTable table) : super( @@ -766,9 +1055,45 @@ class $$PlayerTableTableTableManager }) => PlayerTableCompanion.insert(id: id, name: name, rowid: rowid), withReferenceMapper: (p0) => p0 - .map((e) => (e.readTable(table), BaseReferences(db, table, e))) + .map( + (e) => ( + e.readTable(table), + $$PlayerTableTableReferences(db, table, e), + ), + ) .toList(), - prefetchHooksCallback: null, + prefetchHooksCallback: ({playerGroupTableRefs = false}) { + return PrefetchHooks( + db: db, + explicitlyWatchedTables: [ + if (playerGroupTableRefs) db.playerGroupTable, + ], + addJoins: null, + getPrefetchedDataCallback: (items) async { + return [ + if (playerGroupTableRefs) + await $_getPrefetchedData< + PlayerTableData, + $PlayerTableTable, + PlayerGroupTableData + >( + currentTable: table, + referencedTable: $$PlayerTableTableReferences + ._playerGroupTableRefsTable(db), + managerFromTypedResult: (p0) => + $$PlayerTableTableReferences( + db, + table, + p0, + ).playerGroupTableRefs, + referencedItemsForCurrentItem: (item, referencedItems) => + referencedItems.where((e) => e.userId == item.id), + typedResults: items, + ), + ]; + }, + ); + }, ), ); } @@ -783,12 +1108,9 @@ typedef $$PlayerTableTableProcessedTableManager = $$PlayerTableTableAnnotationComposer, $$PlayerTableTableCreateCompanionBuilder, $$PlayerTableTableUpdateCompanionBuilder, - ( - PlayerTableData, - BaseReferences<_$AppDatabase, $PlayerTableTable, PlayerTableData>, - ), + (PlayerTableData, $$PlayerTableTableReferences), PlayerTableData, - PrefetchHooks Function() + PrefetchHooks Function({bool playerGroupTableRefs}) >; typedef $$GroupTableTableCreateCompanionBuilder = GroupTableCompanion Function({ @@ -803,6 +1125,34 @@ typedef $$GroupTableTableUpdateCompanionBuilder = Value rowid, }); +final class $$GroupTableTableReferences + extends BaseReferences<_$AppDatabase, $GroupTableTable, GroupTableData> { + $$GroupTableTableReferences(super.$_db, super.$_table, super.$_typedResult); + + static MultiTypedResultKey<$PlayerGroupTableTable, List> + _playerGroupTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable( + db.playerGroupTable, + aliasName: $_aliasNameGenerator( + db.groupTable.id, + db.playerGroupTable.groupId, + ), + ); + + $$PlayerGroupTableTableProcessedTableManager get playerGroupTableRefs { + final manager = $$PlayerGroupTableTableTableManager( + $_db, + $_db.playerGroupTable, + ).filter((f) => f.groupId.id.sqlEquals($_itemColumn('id')!)); + + final cache = $_typedResult.readTableOrNull( + _playerGroupTableRefsTable($_db), + ); + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: cache), + ); + } +} + class $$GroupTableTableFilterComposer extends Composer<_$AppDatabase, $GroupTableTable> { $$GroupTableTableFilterComposer({ @@ -821,6 +1171,31 @@ class $$GroupTableTableFilterComposer column: $table.name, builder: (column) => ColumnFilters(column), ); + + Expression playerGroupTableRefs( + Expression Function($$PlayerGroupTableTableFilterComposer f) f, + ) { + final $$PlayerGroupTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.playerGroupTable, + getReferencedColumn: (t) => t.groupId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$PlayerGroupTableTableFilterComposer( + $db: $db, + $table: $db.playerGroupTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } } class $$GroupTableTableOrderingComposer @@ -857,6 +1232,31 @@ class $$GroupTableTableAnnotationComposer GeneratedColumn get name => $composableBuilder(column: $table.name, builder: (column) => column); + + Expression playerGroupTableRefs( + Expression Function($$PlayerGroupTableTableAnnotationComposer a) f, + ) { + final $$PlayerGroupTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.playerGroupTable, + getReferencedColumn: (t) => t.groupId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$PlayerGroupTableTableAnnotationComposer( + $db: $db, + $table: $db.playerGroupTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } } class $$GroupTableTableTableManager @@ -870,12 +1270,9 @@ class $$GroupTableTableTableManager $$GroupTableTableAnnotationComposer, $$GroupTableTableCreateCompanionBuilder, $$GroupTableTableUpdateCompanionBuilder, - ( - GroupTableData, - BaseReferences<_$AppDatabase, $GroupTableTable, GroupTableData>, - ), + (GroupTableData, $$GroupTableTableReferences), GroupTableData, - PrefetchHooks Function() + PrefetchHooks Function({bool playerGroupTableRefs}) > { $$GroupTableTableTableManager(_$AppDatabase db, $GroupTableTable table) : super( @@ -902,9 +1299,45 @@ class $$GroupTableTableTableManager }) => GroupTableCompanion.insert(id: id, name: name, rowid: rowid), withReferenceMapper: (p0) => p0 - .map((e) => (e.readTable(table), BaseReferences(db, table, e))) + .map( + (e) => ( + e.readTable(table), + $$GroupTableTableReferences(db, table, e), + ), + ) .toList(), - prefetchHooksCallback: null, + prefetchHooksCallback: ({playerGroupTableRefs = false}) { + return PrefetchHooks( + db: db, + explicitlyWatchedTables: [ + if (playerGroupTableRefs) db.playerGroupTable, + ], + addJoins: null, + getPrefetchedDataCallback: (items) async { + return [ + if (playerGroupTableRefs) + await $_getPrefetchedData< + GroupTableData, + $GroupTableTable, + PlayerGroupTableData + >( + currentTable: table, + referencedTable: $$GroupTableTableReferences + ._playerGroupTableRefsTable(db), + managerFromTypedResult: (p0) => + $$GroupTableTableReferences( + db, + table, + p0, + ).playerGroupTableRefs, + referencedItemsForCurrentItem: (item, referencedItems) => + referencedItems.where((e) => e.groupId == item.id), + typedResults: items, + ), + ]; + }, + ); + }, ), ); } @@ -919,12 +1352,9 @@ typedef $$GroupTableTableProcessedTableManager = $$GroupTableTableAnnotationComposer, $$GroupTableTableCreateCompanionBuilder, $$GroupTableTableUpdateCompanionBuilder, - ( - GroupTableData, - BaseReferences<_$AppDatabase, $GroupTableTable, GroupTableData>, - ), + (GroupTableData, $$GroupTableTableReferences), GroupTableData, - PrefetchHooks Function() + PrefetchHooks Function({bool playerGroupTableRefs}) >; typedef $$PlayerGroupTableTableCreateCompanionBuilder = PlayerGroupTableCompanion Function({ @@ -939,6 +1369,58 @@ typedef $$PlayerGroupTableTableUpdateCompanionBuilder = Value rowid, }); +final class $$PlayerGroupTableTableReferences + extends + BaseReferences< + _$AppDatabase, + $PlayerGroupTableTable, + PlayerGroupTableData + > { + $$PlayerGroupTableTableReferences( + super.$_db, + super.$_table, + super.$_typedResult, + ); + + static $PlayerTableTable _userIdTable(_$AppDatabase db) => + db.playerTable.createAlias( + $_aliasNameGenerator(db.playerGroupTable.userId, db.playerTable.id), + ); + + $$PlayerTableTableProcessedTableManager get userId { + final $_column = $_itemColumn('user_id')!; + + final manager = $$PlayerTableTableTableManager( + $_db, + $_db.playerTable, + ).filter((f) => f.id.sqlEquals($_column)); + final item = $_typedResult.readTableOrNull(_userIdTable($_db)); + if (item == null) return manager; + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: [item]), + ); + } + + static $GroupTableTable _groupIdTable(_$AppDatabase db) => + db.groupTable.createAlias( + $_aliasNameGenerator(db.playerGroupTable.groupId, db.groupTable.id), + ); + + $$GroupTableTableProcessedTableManager get groupId { + final $_column = $_itemColumn('group_id')!; + + final manager = $$GroupTableTableTableManager( + $_db, + $_db.groupTable, + ).filter((f) => f.id.sqlEquals($_column)); + final item = $_typedResult.readTableOrNull(_groupIdTable($_db)); + if (item == null) return manager; + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: [item]), + ); + } +} + class $$PlayerGroupTableTableFilterComposer extends Composer<_$AppDatabase, $PlayerGroupTableTable> { $$PlayerGroupTableTableFilterComposer({ @@ -948,15 +1430,51 @@ class $$PlayerGroupTableTableFilterComposer super.$addJoinBuilderToRootComposer, super.$removeJoinBuilderFromRootComposer, }); - ColumnFilters get userId => $composableBuilder( - column: $table.userId, - builder: (column) => ColumnFilters(column), - ); + $$PlayerTableTableFilterComposer get userId { + final $$PlayerTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.userId, + referencedTable: $db.playerTable, + getReferencedColumn: (t) => t.id, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$PlayerTableTableFilterComposer( + $db: $db, + $table: $db.playerTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return composer; + } - ColumnFilters get groupId => $composableBuilder( - column: $table.groupId, - builder: (column) => ColumnFilters(column), - ); + $$GroupTableTableFilterComposer get groupId { + final $$GroupTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.groupId, + referencedTable: $db.groupTable, + getReferencedColumn: (t) => t.id, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$GroupTableTableFilterComposer( + $db: $db, + $table: $db.groupTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return composer; + } } class $$PlayerGroupTableTableOrderingComposer @@ -968,15 +1486,51 @@ class $$PlayerGroupTableTableOrderingComposer super.$addJoinBuilderToRootComposer, super.$removeJoinBuilderFromRootComposer, }); - ColumnOrderings get userId => $composableBuilder( - column: $table.userId, - builder: (column) => ColumnOrderings(column), - ); + $$PlayerTableTableOrderingComposer get userId { + final $$PlayerTableTableOrderingComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.userId, + referencedTable: $db.playerTable, + getReferencedColumn: (t) => t.id, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$PlayerTableTableOrderingComposer( + $db: $db, + $table: $db.playerTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return composer; + } - ColumnOrderings get groupId => $composableBuilder( - column: $table.groupId, - builder: (column) => ColumnOrderings(column), - ); + $$GroupTableTableOrderingComposer get groupId { + final $$GroupTableTableOrderingComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.groupId, + referencedTable: $db.groupTable, + getReferencedColumn: (t) => t.id, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$GroupTableTableOrderingComposer( + $db: $db, + $table: $db.groupTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return composer; + } } class $$PlayerGroupTableTableAnnotationComposer @@ -988,11 +1542,51 @@ class $$PlayerGroupTableTableAnnotationComposer super.$addJoinBuilderToRootComposer, super.$removeJoinBuilderFromRootComposer, }); - GeneratedColumn get userId => - $composableBuilder(column: $table.userId, builder: (column) => column); + $$PlayerTableTableAnnotationComposer get userId { + final $$PlayerTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.userId, + referencedTable: $db.playerTable, + getReferencedColumn: (t) => t.id, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$PlayerTableTableAnnotationComposer( + $db: $db, + $table: $db.playerTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return composer; + } - GeneratedColumn get groupId => - $composableBuilder(column: $table.groupId, builder: (column) => column); + $$GroupTableTableAnnotationComposer get groupId { + final $$GroupTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.groupId, + referencedTable: $db.groupTable, + getReferencedColumn: (t) => t.id, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$GroupTableTableAnnotationComposer( + $db: $db, + $table: $db.groupTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return composer; + } } class $$PlayerGroupTableTableTableManager @@ -1006,16 +1600,9 @@ class $$PlayerGroupTableTableTableManager $$PlayerGroupTableTableAnnotationComposer, $$PlayerGroupTableTableCreateCompanionBuilder, $$PlayerGroupTableTableUpdateCompanionBuilder, - ( - PlayerGroupTableData, - BaseReferences< - _$AppDatabase, - $PlayerGroupTableTable, - PlayerGroupTableData - >, - ), + (PlayerGroupTableData, $$PlayerGroupTableTableReferences), PlayerGroupTableData, - PrefetchHooks Function() + PrefetchHooks Function({bool userId, bool groupId}) > { $$PlayerGroupTableTableTableManager( _$AppDatabase db, @@ -1051,9 +1638,71 @@ class $$PlayerGroupTableTableTableManager rowid: rowid, ), withReferenceMapper: (p0) => p0 - .map((e) => (e.readTable(table), BaseReferences(db, table, e))) + .map( + (e) => ( + e.readTable(table), + $$PlayerGroupTableTableReferences(db, table, e), + ), + ) .toList(), - prefetchHooksCallback: null, + prefetchHooksCallback: ({userId = false, groupId = false}) { + return PrefetchHooks( + db: db, + explicitlyWatchedTables: [], + addJoins: + < + T extends TableManagerState< + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic + > + >(state) { + if (userId) { + state = + state.withJoin( + currentTable: table, + currentColumn: table.userId, + referencedTable: + $$PlayerGroupTableTableReferences + ._userIdTable(db), + referencedColumn: + $$PlayerGroupTableTableReferences + ._userIdTable(db) + .id, + ) + as T; + } + if (groupId) { + state = + state.withJoin( + currentTable: table, + currentColumn: table.groupId, + referencedTable: + $$PlayerGroupTableTableReferences + ._groupIdTable(db), + referencedColumn: + $$PlayerGroupTableTableReferences + ._groupIdTable(db) + .id, + ) + as T; + } + + return state; + }, + getPrefetchedDataCallback: (items) async { + return []; + }, + ); + }, ), ); } @@ -1068,15 +1717,143 @@ typedef $$PlayerGroupTableTableProcessedTableManager = $$PlayerGroupTableTableAnnotationComposer, $$PlayerGroupTableTableCreateCompanionBuilder, $$PlayerGroupTableTableUpdateCompanionBuilder, - ( - PlayerGroupTableData, - BaseReferences< - _$AppDatabase, - $PlayerGroupTableTable, - PlayerGroupTableData - >, - ), + (PlayerGroupTableData, $$PlayerGroupTableTableReferences), PlayerGroupTableData, + PrefetchHooks Function({bool userId, bool groupId}) + >; +typedef $$GameTableTableCreateCompanionBuilder = + GameTableCompanion Function({ + required String id, + required String name, + Value rowid, + }); +typedef $$GameTableTableUpdateCompanionBuilder = + GameTableCompanion Function({ + Value id, + Value name, + Value rowid, + }); + +class $$GameTableTableFilterComposer + extends Composer<_$AppDatabase, $GameTableTable> { + $$GameTableTableFilterComposer({ + required super.$db, + required super.$table, + super.joinBuilder, + super.$addJoinBuilderToRootComposer, + super.$removeJoinBuilderFromRootComposer, + }); + ColumnFilters get id => $composableBuilder( + column: $table.id, + builder: (column) => ColumnFilters(column), + ); + + ColumnFilters get name => $composableBuilder( + column: $table.name, + builder: (column) => ColumnFilters(column), + ); +} + +class $$GameTableTableOrderingComposer + extends Composer<_$AppDatabase, $GameTableTable> { + $$GameTableTableOrderingComposer({ + required super.$db, + required super.$table, + super.joinBuilder, + super.$addJoinBuilderToRootComposer, + super.$removeJoinBuilderFromRootComposer, + }); + ColumnOrderings get id => $composableBuilder( + column: $table.id, + builder: (column) => ColumnOrderings(column), + ); + + ColumnOrderings get name => $composableBuilder( + column: $table.name, + builder: (column) => ColumnOrderings(column), + ); +} + +class $$GameTableTableAnnotationComposer + extends Composer<_$AppDatabase, $GameTableTable> { + $$GameTableTableAnnotationComposer({ + required super.$db, + required super.$table, + super.joinBuilder, + super.$addJoinBuilderToRootComposer, + super.$removeJoinBuilderFromRootComposer, + }); + GeneratedColumn get id => + $composableBuilder(column: $table.id, builder: (column) => column); + + GeneratedColumn get name => + $composableBuilder(column: $table.name, builder: (column) => column); +} + +class $$GameTableTableTableManager + extends + RootTableManager< + _$AppDatabase, + $GameTableTable, + GameTableData, + $$GameTableTableFilterComposer, + $$GameTableTableOrderingComposer, + $$GameTableTableAnnotationComposer, + $$GameTableTableCreateCompanionBuilder, + $$GameTableTableUpdateCompanionBuilder, + ( + GameTableData, + BaseReferences<_$AppDatabase, $GameTableTable, GameTableData>, + ), + GameTableData, + PrefetchHooks Function() + > { + $$GameTableTableTableManager(_$AppDatabase db, $GameTableTable table) + : super( + TableManagerState( + db: db, + table: table, + createFilteringComposer: () => + $$GameTableTableFilterComposer($db: db, $table: table), + createOrderingComposer: () => + $$GameTableTableOrderingComposer($db: db, $table: table), + createComputedFieldComposer: () => + $$GameTableTableAnnotationComposer($db: db, $table: table), + updateCompanionCallback: + ({ + Value id = const Value.absent(), + Value name = const Value.absent(), + Value rowid = const Value.absent(), + }) => GameTableCompanion(id: id, name: name, rowid: rowid), + createCompanionCallback: + ({ + required String id, + required String name, + Value rowid = const Value.absent(), + }) => GameTableCompanion.insert(id: id, name: name, rowid: rowid), + withReferenceMapper: (p0) => p0 + .map((e) => (e.readTable(table), BaseReferences(db, table, e))) + .toList(), + prefetchHooksCallback: null, + ), + ); +} + +typedef $$GameTableTableProcessedTableManager = + ProcessedTableManager< + _$AppDatabase, + $GameTableTable, + GameTableData, + $$GameTableTableFilterComposer, + $$GameTableTableOrderingComposer, + $$GameTableTableAnnotationComposer, + $$GameTableTableCreateCompanionBuilder, + $$GameTableTableUpdateCompanionBuilder, + ( + GameTableData, + BaseReferences<_$AppDatabase, $GameTableTable, GameTableData>, + ), + GameTableData, PrefetchHooks Function() >; @@ -1089,4 +1866,6 @@ class $AppDatabaseManager { $$GroupTableTableTableManager(_db, _db.groupTable); $$PlayerGroupTableTableTableManager get playerGroupTable => $$PlayerGroupTableTableTableManager(_db, _db.playerGroupTable); + $$GameTableTableTableManager get gameTable => + $$GameTableTableTableManager(_db, _db.gameTable); } diff --git a/lib/data/db/tables/game_table.dart b/lib/data/db/tables/game_table.dart new file mode 100644 index 0000000..45bfb20 --- /dev/null +++ b/lib/data/db/tables/game_table.dart @@ -0,0 +1,9 @@ +import 'package:drift/drift.dart'; + +class GameTable extends Table { + TextColumn get id => text()(); + TextColumn get name => text()(); + + @override + Set> get primaryKey => {id}; +} diff --git a/lib/data/db/tables/player_group_table.dart b/lib/data/db/tables/player_group_table.dart index a045789..096a981 100644 --- a/lib/data/db/tables/player_group_table.dart +++ b/lib/data/db/tables/player_group_table.dart @@ -1,9 +1,9 @@ import 'package:drift/drift.dart'; -import 'package:game_tracker/data/methods/db/tables/group_table.dart'; -import 'package:game_tracker/data/methods/db/tables/user_table.dart'; +import 'package:game_tracker/data/db/tables/group_table.dart'; +import 'package:game_tracker/data/db/tables/player_table.dart'; class PlayerGroupTable extends Table { - TextColumn get userId => text().references(UserTable, #id)(); + TextColumn get userId => text().references(PlayerTable, #id)(); TextColumn get groupId => text().references(GroupTable, #id)(); @override diff --git a/lib/data/dto/group.dart b/lib/data/dto/group.dart index 316b712..6f12fe9 100644 --- a/lib/data/dto/group.dart +++ b/lib/data/dto/group.dart @@ -1,4 +1,4 @@ -import 'package:game_tracker/data/methods/dto/player.dart'; +import 'package:game_tracker/data/dto/player.dart'; class Group { final String id; diff --git a/lib/data/dto/player.dart b/lib/data/dto/player.dart index 331645a..d5e84e8 100644 --- a/lib/data/dto/player.dart +++ b/lib/data/dto/player.dart @@ -1,6 +1,6 @@ class Player { final String id; - final String username; + final String name; - Player({required this.id, required this.username}); + Player({required this.id, required this.name}); } diff --git a/lib/main.dart b/lib/main.dart index dd19f34..22f94c7 100644 --- a/lib/main.dart +++ b/lib/main.dart @@ -1,7 +1,7 @@ import 'package:flutter/material.dart'; import 'package:game_tracker/core/custom_theme.dart'; -import 'package:game_tracker/data/database.dart'; -import 'package:game_tracker/presentation/views/main_menu/custom_navigation_bardb/database.dart'; +import 'package:game_tracker/data/db/database.dart'; +import 'package:game_tracker/presentation/views/main_menu/custom_navigation_bar.dart'; import 'package:provider/provider.dart'; void main() {