From a922f24150318995b4bfa4b090cd5e1f6dca977f Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Wed, 12 Nov 2025 11:41:06 +0100 Subject: [PATCH] Added basic structure for game implementation --- lib/data/dao/game_dao.dart | 26 +- lib/data/dao/group_dao.dart | 12 +- lib/data/dao/group_game_dao.dart | 33 + lib/data/dao/group_game_dao.g.dart | 10 + lib/data/dao/player_game_dao.dart | 40 + lib/data/dao/player_game_dao.g.dart | 10 + lib/data/db/database.dart | 22 +- lib/data/db/database.g.dart | 1824 ++++++++++++++++++++- lib/data/db/tables/game_table.dart | 1 + lib/data/db/tables/group_game_table.dart | 11 + lib/data/db/tables/player_game_table.dart | 11 + lib/data/dto/game.dart | 14 +- 12 files changed, 1924 insertions(+), 90 deletions(-) create mode 100644 lib/data/dao/group_game_dao.dart create mode 100644 lib/data/dao/group_game_dao.g.dart create mode 100644 lib/data/dao/player_game_dao.dart create mode 100644 lib/data/dao/player_game_dao.g.dart create mode 100644 lib/data/db/tables/group_game_table.dart create mode 100644 lib/data/db/tables/player_game_table.dart diff --git a/lib/data/dao/game_dao.dart b/lib/data/dao/game_dao.dart index 3b6529a..5894ed5 100644 --- a/lib/data/dao/game_dao.dart +++ b/lib/data/dao/game_dao.dart @@ -2,6 +2,8 @@ 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'; +import 'package:game_tracker/data/dto/group.dart'; +import 'package:game_tracker/data/dto/player.dart'; part 'game_dao.g.dart'; @@ -16,11 +18,27 @@ class GameDao extends DatabaseAccessor with _$GameDaoMixin { 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)); + /// Retrieves a [Game] by its [gameId]. + Future getGameById(String gameId) async { + final query = select(gameTable)..where((g) => g.id.equals(gameId)); final result = await query.getSingle(); - return Game(id: result.id, name: result.name); + + List? players; + if (await db.playerGameDao.hasGamePlayers(gameId)) { + players = await db.playerGameDao.getPlayersByGameId(gameId); + } + Group? group; + if (await db.groupGameDao.hasGameGroup(gameId)) { + group = await db.groupGameDao.getGroupByGameId(gameId); + } + + return Game( + id: result.id, + name: result.name, + players: players, + group: group, + winner: result.winnerId, + ); } /// Retrieves the number of games in the database. diff --git a/lib/data/dao/group_dao.dart b/lib/data/dao/group_dao.dart index 7dc144d..a92247a 100644 --- a/lib/data/dao/group_dao.dart +++ b/lib/data/dao/group_dao.dart @@ -19,14 +19,14 @@ 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)); + /// Retrieves a [Group] by its [groupId], including its members. + Future getGroupById(String groupId) async { + final query = select(groupTable)..where((g) => g.id.equals(groupId)); final result = await query.getSingle(); - List members = []; - - members = await db.playerGroupDao.getPlayersOfGroupById(id); + List members = await db.playerGroupDao.getPlayersOfGroupById( + groupId, + ); return Group(id: result.id, name: result.name, members: members); } diff --git a/lib/data/dao/group_game_dao.dart b/lib/data/dao/group_game_dao.dart new file mode 100644 index 0000000..851e032 --- /dev/null +++ b/lib/data/dao/group_game_dao.dart @@ -0,0 +1,33 @@ +import 'package:drift/drift.dart'; +import 'package:game_tracker/data/db/database.dart'; +import 'package:game_tracker/data/db/tables/group_game_table.dart'; +import 'package:game_tracker/data/dto/group.dart'; + +part 'group_game_dao.g.dart'; + +@DriftAccessor(tables: [GroupGameTable]) +class GroupGameDao extends DatabaseAccessor + with _$GroupGameDaoMixin { + GroupGameDao(super.db); + + /// Checks if there is a group associated with the given [gameId]. + /// Returns `true` if there is a group, otherwise `false`. + Future hasGameGroup(String gameId) async { + final count = + await (selectOnly(groupGameTable) + ..where(groupGameTable.gameId.equals(gameId)) + ..addColumns([groupGameTable.groupId.count()])) + .map((row) => row.read(groupGameTable.groupId.count())) + .getSingle(); + return (count ?? 0) > 0; + } + + Future getGroupByGameId(String gameId) async { + final result = await (select( + groupGameTable, + )..where((g) => g.gameId.equals(gameId))).getSingle(); + + final group = await db.groupDao.getGroupById(result.groupId); + return group; + } +} diff --git a/lib/data/dao/group_game_dao.g.dart b/lib/data/dao/group_game_dao.g.dart new file mode 100644 index 0000000..f1aa46f --- /dev/null +++ b/lib/data/dao/group_game_dao.g.dart @@ -0,0 +1,10 @@ +// GENERATED CODE - DO NOT MODIFY BY HAND + +part of 'group_game_dao.dart'; + +// ignore_for_file: type=lint +mixin _$GroupGameDaoMixin on DatabaseAccessor { + $PlayerTableTable get playerTable => attachedDatabase.playerTable; + $GroupTableTable get groupTable => attachedDatabase.groupTable; + $GroupGameTableTable get groupGameTable => attachedDatabase.groupGameTable; +} diff --git a/lib/data/dao/player_game_dao.dart b/lib/data/dao/player_game_dao.dart new file mode 100644 index 0000000..c05edd1 --- /dev/null +++ b/lib/data/dao/player_game_dao.dart @@ -0,0 +1,40 @@ +import 'package:drift/drift.dart'; +import 'package:game_tracker/data/db/database.dart'; +import 'package:game_tracker/data/db/tables/player_game_table.dart'; +import 'package:game_tracker/data/dto/player.dart'; + +part 'player_game_dao.g.dart'; + +@DriftAccessor(tables: [PlayerGameTable]) +class PlayerGameDao extends DatabaseAccessor + with _$PlayerGameDaoMixin { + PlayerGameDao(super.db); + + /// Checks if there are any players associated with the given [gameId]. + /// Returns `true` if there are players, otherwise `false`. + Future hasGamePlayers(String gameId) async { + final count = + await (selectOnly(playerGameTable) + ..where(playerGameTable.gameId.equals(gameId)) + ..addColumns([playerGameTable.playerId.count()])) + .map((row) => row.read(playerGameTable.playerId.count())) + .getSingle(); + return (count ?? 0) > 0; + } + + /// Retrieves a list of [Player]s associated with the given [gameId]. + /// Returns an empty list if no players are found. + Future> getPlayersByGameId(String gameId) async { + final result = await (select( + playerGameTable, + )..where((p) => p.gameId.equals(gameId))).get(); + + if (result.isEmpty) return []; + + final futures = result.map( + (row) => db.playerDao.getPlayerById(row.playerId), + ); + final players = await Future.wait(futures); + return players.whereType().toList(); + } +} diff --git a/lib/data/dao/player_game_dao.g.dart b/lib/data/dao/player_game_dao.g.dart new file mode 100644 index 0000000..0d5f5e1 --- /dev/null +++ b/lib/data/dao/player_game_dao.g.dart @@ -0,0 +1,10 @@ +// GENERATED CODE - DO NOT MODIFY BY HAND + +part of 'player_game_dao.dart'; + +// ignore_for_file: type=lint +mixin _$PlayerGameDaoMixin on DatabaseAccessor { + $PlayerTableTable get playerTable => attachedDatabase.playerTable; + $GroupTableTable get groupTable => attachedDatabase.groupTable; + $PlayerGameTableTable get playerGameTable => attachedDatabase.playerGameTable; +} diff --git a/lib/data/db/database.dart b/lib/data/db/database.dart index e35513e..b0662aa 100644 --- a/lib/data/db/database.dart +++ b/lib/data/db/database.dart @@ -2,10 +2,14 @@ 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/group_game_dao.dart'; import 'package:game_tracker/data/dao/player_dao.dart'; +import 'package:game_tracker/data/dao/player_game_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_game_table.dart'; import 'package:game_tracker/data/db/tables/group_table.dart'; +import 'package:game_tracker/data/db/tables/player_game_table.dart'; import 'package:game_tracker/data/db/tables/player_group_table.dart'; import 'package:game_tracker/data/db/tables/player_table.dart'; import 'package:path_provider/path_provider.dart'; @@ -13,8 +17,22 @@ import 'package:path_provider/path_provider.dart'; part 'database.g.dart'; @DriftDatabase( - tables: [PlayerTable, GroupTable, PlayerGroupTable, GameTable], - daos: [GroupDao, PlayerDao, PlayerGroupDao, GameDao], + tables: [ + PlayerTable, + GroupTable, + PlayerGroupTable, + PlayerGameTable, + GroupGameTable, + GameTable, + ], + daos: [ + GroupDao, + PlayerDao, + GameDao, + PlayerGroupDao, + PlayerGameDao, + GroupGameDao, + ], ) 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 d4e9e94..74efba1 100644 --- a/lib/data/db/database.g.dart +++ b/lib/data/db/database.g.dart @@ -638,6 +638,452 @@ class PlayerGroupTableCompanion extends UpdateCompanion { } } +class $PlayerGameTableTable extends PlayerGameTable + with TableInfo<$PlayerGameTableTable, PlayerGameTableData> { + @override + final GeneratedDatabase attachedDatabase; + final String? _alias; + $PlayerGameTableTable(this.attachedDatabase, [this._alias]); + static const VerificationMeta _playerIdMeta = const VerificationMeta( + 'playerId', + ); + @override + late final GeneratedColumn playerId = GeneratedColumn( + 'player_id', + aliasedName, + false, + type: DriftSqlType.string, + requiredDuringInsert: true, + defaultConstraints: GeneratedColumn.constraintIsAlways( + 'REFERENCES player_table (id)', + ), + ); + static const VerificationMeta _gameIdMeta = const VerificationMeta('gameId'); + @override + late final GeneratedColumn gameId = GeneratedColumn( + 'game_id', + aliasedName, + false, + type: DriftSqlType.string, + requiredDuringInsert: true, + defaultConstraints: GeneratedColumn.constraintIsAlways( + 'REFERENCES group_table (id)', + ), + ); + @override + List get $columns => [playerId, gameId]; + @override + String get aliasedName => _alias ?? actualTableName; + @override + String get actualTableName => $name; + static const String $name = 'player_game_table'; + @override + VerificationContext validateIntegrity( + Insertable instance, { + bool isInserting = false, + }) { + final context = VerificationContext(); + final data = instance.toColumns(true); + if (data.containsKey('player_id')) { + context.handle( + _playerIdMeta, + playerId.isAcceptableOrUnknown(data['player_id']!, _playerIdMeta), + ); + } else if (isInserting) { + context.missing(_playerIdMeta); + } + if (data.containsKey('game_id')) { + context.handle( + _gameIdMeta, + gameId.isAcceptableOrUnknown(data['game_id']!, _gameIdMeta), + ); + } else if (isInserting) { + context.missing(_gameIdMeta); + } + return context; + } + + @override + Set get $primaryKey => {playerId, gameId}; + @override + PlayerGameTableData map(Map data, {String? tablePrefix}) { + final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : ''; + return PlayerGameTableData( + playerId: attachedDatabase.typeMapping.read( + DriftSqlType.string, + data['${effectivePrefix}player_id'], + )!, + gameId: attachedDatabase.typeMapping.read( + DriftSqlType.string, + data['${effectivePrefix}game_id'], + )!, + ); + } + + @override + $PlayerGameTableTable createAlias(String alias) { + return $PlayerGameTableTable(attachedDatabase, alias); + } +} + +class PlayerGameTableData extends DataClass + implements Insertable { + final String playerId; + final String gameId; + const PlayerGameTableData({required this.playerId, required this.gameId}); + @override + Map toColumns(bool nullToAbsent) { + final map = {}; + map['player_id'] = Variable(playerId); + map['game_id'] = Variable(gameId); + return map; + } + + PlayerGameTableCompanion toCompanion(bool nullToAbsent) { + return PlayerGameTableCompanion( + playerId: Value(playerId), + gameId: Value(gameId), + ); + } + + factory PlayerGameTableData.fromJson( + Map json, { + ValueSerializer? serializer, + }) { + serializer ??= driftRuntimeOptions.defaultSerializer; + return PlayerGameTableData( + playerId: serializer.fromJson(json['playerId']), + gameId: serializer.fromJson(json['gameId']), + ); + } + @override + Map toJson({ValueSerializer? serializer}) { + serializer ??= driftRuntimeOptions.defaultSerializer; + return { + 'playerId': serializer.toJson(playerId), + 'gameId': serializer.toJson(gameId), + }; + } + + PlayerGameTableData copyWith({String? playerId, String? gameId}) => + PlayerGameTableData( + playerId: playerId ?? this.playerId, + gameId: gameId ?? this.gameId, + ); + PlayerGameTableData copyWithCompanion(PlayerGameTableCompanion data) { + return PlayerGameTableData( + playerId: data.playerId.present ? data.playerId.value : this.playerId, + gameId: data.gameId.present ? data.gameId.value : this.gameId, + ); + } + + @override + String toString() { + return (StringBuffer('PlayerGameTableData(') + ..write('playerId: $playerId, ') + ..write('gameId: $gameId') + ..write(')')) + .toString(); + } + + @override + int get hashCode => Object.hash(playerId, gameId); + @override + bool operator ==(Object other) => + identical(this, other) || + (other is PlayerGameTableData && + other.playerId == this.playerId && + other.gameId == this.gameId); +} + +class PlayerGameTableCompanion extends UpdateCompanion { + final Value playerId; + final Value gameId; + final Value rowid; + const PlayerGameTableCompanion({ + this.playerId = const Value.absent(), + this.gameId = const Value.absent(), + this.rowid = const Value.absent(), + }); + PlayerGameTableCompanion.insert({ + required String playerId, + required String gameId, + this.rowid = const Value.absent(), + }) : playerId = Value(playerId), + gameId = Value(gameId); + static Insertable custom({ + Expression? playerId, + Expression? gameId, + Expression? rowid, + }) { + return RawValuesInsertable({ + if (playerId != null) 'player_id': playerId, + if (gameId != null) 'game_id': gameId, + if (rowid != null) 'rowid': rowid, + }); + } + + PlayerGameTableCompanion copyWith({ + Value? playerId, + Value? gameId, + Value? rowid, + }) { + return PlayerGameTableCompanion( + playerId: playerId ?? this.playerId, + gameId: gameId ?? this.gameId, + rowid: rowid ?? this.rowid, + ); + } + + @override + Map toColumns(bool nullToAbsent) { + final map = {}; + if (playerId.present) { + map['player_id'] = Variable(playerId.value); + } + if (gameId.present) { + map['game_id'] = Variable(gameId.value); + } + if (rowid.present) { + map['rowid'] = Variable(rowid.value); + } + return map; + } + + @override + String toString() { + return (StringBuffer('PlayerGameTableCompanion(') + ..write('playerId: $playerId, ') + ..write('gameId: $gameId, ') + ..write('rowid: $rowid') + ..write(')')) + .toString(); + } +} + +class $GroupGameTableTable extends GroupGameTable + with TableInfo<$GroupGameTableTable, GroupGameTableData> { + @override + final GeneratedDatabase attachedDatabase; + final String? _alias; + $GroupGameTableTable(this.attachedDatabase, [this._alias]); + static const VerificationMeta _groupIdMeta = const VerificationMeta( + 'groupId', + ); + @override + late final GeneratedColumn groupId = GeneratedColumn( + 'group_id', + aliasedName, + false, + type: DriftSqlType.string, + requiredDuringInsert: true, + defaultConstraints: GeneratedColumn.constraintIsAlways( + 'REFERENCES player_table (id)', + ), + ); + static const VerificationMeta _gameIdMeta = const VerificationMeta('gameId'); + @override + late final GeneratedColumn gameId = GeneratedColumn( + 'game_id', + aliasedName, + false, + type: DriftSqlType.string, + requiredDuringInsert: true, + defaultConstraints: GeneratedColumn.constraintIsAlways( + 'REFERENCES group_table (id)', + ), + ); + @override + List get $columns => [groupId, gameId]; + @override + String get aliasedName => _alias ?? actualTableName; + @override + String get actualTableName => $name; + static const String $name = 'group_game_table'; + @override + VerificationContext validateIntegrity( + Insertable instance, { + bool isInserting = false, + }) { + final context = VerificationContext(); + final data = instance.toColumns(true); + if (data.containsKey('group_id')) { + context.handle( + _groupIdMeta, + groupId.isAcceptableOrUnknown(data['group_id']!, _groupIdMeta), + ); + } else if (isInserting) { + context.missing(_groupIdMeta); + } + if (data.containsKey('game_id')) { + context.handle( + _gameIdMeta, + gameId.isAcceptableOrUnknown(data['game_id']!, _gameIdMeta), + ); + } else if (isInserting) { + context.missing(_gameIdMeta); + } + return context; + } + + @override + Set get $primaryKey => {groupId, gameId}; + @override + GroupGameTableData map(Map data, {String? tablePrefix}) { + final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : ''; + return GroupGameTableData( + groupId: attachedDatabase.typeMapping.read( + DriftSqlType.string, + data['${effectivePrefix}group_id'], + )!, + gameId: attachedDatabase.typeMapping.read( + DriftSqlType.string, + data['${effectivePrefix}game_id'], + )!, + ); + } + + @override + $GroupGameTableTable createAlias(String alias) { + return $GroupGameTableTable(attachedDatabase, alias); + } +} + +class GroupGameTableData extends DataClass + implements Insertable { + final String groupId; + final String gameId; + const GroupGameTableData({required this.groupId, required this.gameId}); + @override + Map toColumns(bool nullToAbsent) { + final map = {}; + map['group_id'] = Variable(groupId); + map['game_id'] = Variable(gameId); + return map; + } + + GroupGameTableCompanion toCompanion(bool nullToAbsent) { + return GroupGameTableCompanion( + groupId: Value(groupId), + gameId: Value(gameId), + ); + } + + factory GroupGameTableData.fromJson( + Map json, { + ValueSerializer? serializer, + }) { + serializer ??= driftRuntimeOptions.defaultSerializer; + return GroupGameTableData( + groupId: serializer.fromJson(json['groupId']), + gameId: serializer.fromJson(json['gameId']), + ); + } + @override + Map toJson({ValueSerializer? serializer}) { + serializer ??= driftRuntimeOptions.defaultSerializer; + return { + 'groupId': serializer.toJson(groupId), + 'gameId': serializer.toJson(gameId), + }; + } + + GroupGameTableData copyWith({String? groupId, String? gameId}) => + GroupGameTableData( + groupId: groupId ?? this.groupId, + gameId: gameId ?? this.gameId, + ); + GroupGameTableData copyWithCompanion(GroupGameTableCompanion data) { + return GroupGameTableData( + groupId: data.groupId.present ? data.groupId.value : this.groupId, + gameId: data.gameId.present ? data.gameId.value : this.gameId, + ); + } + + @override + String toString() { + return (StringBuffer('GroupGameTableData(') + ..write('groupId: $groupId, ') + ..write('gameId: $gameId') + ..write(')')) + .toString(); + } + + @override + int get hashCode => Object.hash(groupId, gameId); + @override + bool operator ==(Object other) => + identical(this, other) || + (other is GroupGameTableData && + other.groupId == this.groupId && + other.gameId == this.gameId); +} + +class GroupGameTableCompanion extends UpdateCompanion { + final Value groupId; + final Value gameId; + final Value rowid; + const GroupGameTableCompanion({ + this.groupId = const Value.absent(), + this.gameId = const Value.absent(), + this.rowid = const Value.absent(), + }); + GroupGameTableCompanion.insert({ + required String groupId, + required String gameId, + this.rowid = const Value.absent(), + }) : groupId = Value(groupId), + gameId = Value(gameId); + static Insertable custom({ + Expression? groupId, + Expression? gameId, + Expression? rowid, + }) { + return RawValuesInsertable({ + if (groupId != null) 'group_id': groupId, + if (gameId != null) 'game_id': gameId, + if (rowid != null) 'rowid': rowid, + }); + } + + GroupGameTableCompanion copyWith({ + Value? groupId, + Value? gameId, + Value? rowid, + }) { + return GroupGameTableCompanion( + groupId: groupId ?? this.groupId, + gameId: gameId ?? this.gameId, + rowid: rowid ?? this.rowid, + ); + } + + @override + Map toColumns(bool nullToAbsent) { + final map = {}; + if (groupId.present) { + map['group_id'] = Variable(groupId.value); + } + if (gameId.present) { + map['game_id'] = Variable(gameId.value); + } + if (rowid.present) { + map['rowid'] = Variable(rowid.value); + } + return map; + } + + @override + String toString() { + return (StringBuffer('GroupGameTableCompanion(') + ..write('groupId: $groupId, ') + ..write('gameId: $gameId, ') + ..write('rowid: $rowid') + ..write(')')) + .toString(); + } +} + class $GameTableTable extends GameTable with TableInfo<$GameTableTable, GameTableData> { @override @@ -662,8 +1108,19 @@ class $GameTableTable extends GameTable type: DriftSqlType.string, requiredDuringInsert: true, ); + static const VerificationMeta _winnerIdMeta = const VerificationMeta( + 'winnerId', + ); @override - List get $columns => [id, name]; + late final GeneratedColumn winnerId = GeneratedColumn( + 'winner_id', + aliasedName, + true, + type: DriftSqlType.string, + requiredDuringInsert: false, + ); + @override + List get $columns => [id, name, winnerId]; @override String get aliasedName => _alias ?? actualTableName; @override @@ -689,6 +1146,12 @@ class $GameTableTable extends GameTable } else if (isInserting) { context.missing(_nameMeta); } + if (data.containsKey('winner_id')) { + context.handle( + _winnerIdMeta, + winnerId.isAcceptableOrUnknown(data['winner_id']!, _winnerIdMeta), + ); + } return context; } @@ -706,6 +1169,10 @@ class $GameTableTable extends GameTable DriftSqlType.string, data['${effectivePrefix}name'], )!, + winnerId: attachedDatabase.typeMapping.read( + DriftSqlType.string, + data['${effectivePrefix}winner_id'], + ), ); } @@ -718,17 +1185,27 @@ class $GameTableTable extends GameTable class GameTableData extends DataClass implements Insertable { final String id; final String name; - const GameTableData({required this.id, required this.name}); + final String? winnerId; + const GameTableData({required this.id, required this.name, this.winnerId}); @override Map toColumns(bool nullToAbsent) { final map = {}; map['id'] = Variable(id); map['name'] = Variable(name); + if (!nullToAbsent || winnerId != null) { + map['winner_id'] = Variable(winnerId); + } return map; } GameTableCompanion toCompanion(bool nullToAbsent) { - return GameTableCompanion(id: Value(id), name: Value(name)); + return GameTableCompanion( + id: Value(id), + name: Value(name), + winnerId: winnerId == null && nullToAbsent + ? const Value.absent() + : Value(winnerId), + ); } factory GameTableData.fromJson( @@ -739,6 +1216,7 @@ class GameTableData extends DataClass implements Insertable { return GameTableData( id: serializer.fromJson(json['id']), name: serializer.fromJson(json['name']), + winnerId: serializer.fromJson(json['winnerId']), ); } @override @@ -747,15 +1225,24 @@ class GameTableData extends DataClass implements Insertable { return { 'id': serializer.toJson(id), 'name': serializer.toJson(name), + 'winnerId': serializer.toJson(winnerId), }; } - GameTableData copyWith({String? id, String? name}) => - GameTableData(id: id ?? this.id, name: name ?? this.name); + GameTableData copyWith({ + String? id, + String? name, + Value winnerId = const Value.absent(), + }) => GameTableData( + id: id ?? this.id, + name: name ?? this.name, + winnerId: winnerId.present ? winnerId.value : this.winnerId, + ); GameTableData copyWithCompanion(GameTableCompanion data) { return GameTableData( id: data.id.present ? data.id.value : this.id, name: data.name.present ? data.name.value : this.name, + winnerId: data.winnerId.present ? data.winnerId.value : this.winnerId, ); } @@ -763,44 +1250,51 @@ class GameTableData extends DataClass implements Insertable { String toString() { return (StringBuffer('GameTableData(') ..write('id: $id, ') - ..write('name: $name') + ..write('name: $name, ') + ..write('winnerId: $winnerId') ..write(')')) .toString(); } @override - int get hashCode => Object.hash(id, name); + int get hashCode => Object.hash(id, name, winnerId); @override bool operator ==(Object other) => identical(this, other) || (other is GameTableData && other.id == this.id && - other.name == this.name); + other.name == this.name && + other.winnerId == this.winnerId); } class GameTableCompanion extends UpdateCompanion { final Value id; final Value name; + final Value winnerId; final Value rowid; const GameTableCompanion({ this.id = const Value.absent(), this.name = const Value.absent(), + this.winnerId = const Value.absent(), this.rowid = const Value.absent(), }); GameTableCompanion.insert({ required String id, required String name, + this.winnerId = const Value.absent(), this.rowid = const Value.absent(), }) : id = Value(id), name = Value(name); static Insertable custom({ Expression? id, Expression? name, + Expression? winnerId, Expression? rowid, }) { return RawValuesInsertable({ if (id != null) 'id': id, if (name != null) 'name': name, + if (winnerId != null) 'winner_id': winnerId, if (rowid != null) 'rowid': rowid, }); } @@ -808,11 +1302,13 @@ class GameTableCompanion extends UpdateCompanion { GameTableCompanion copyWith({ Value? id, Value? name, + Value? winnerId, Value? rowid, }) { return GameTableCompanion( id: id ?? this.id, name: name ?? this.name, + winnerId: winnerId ?? this.winnerId, rowid: rowid ?? this.rowid, ); } @@ -826,6 +1322,9 @@ class GameTableCompanion extends UpdateCompanion { if (name.present) { map['name'] = Variable(name.value); } + if (winnerId.present) { + map['winner_id'] = Variable(winnerId.value); + } if (rowid.present) { map['rowid'] = Variable(rowid.value); } @@ -837,6 +1336,7 @@ class GameTableCompanion extends UpdateCompanion { return (StringBuffer('GameTableCompanion(') ..write('id: $id, ') ..write('name: $name, ') + ..write('winnerId: $winnerId, ') ..write('rowid: $rowid') ..write(')')) .toString(); @@ -851,13 +1351,19 @@ abstract class _$AppDatabase extends GeneratedDatabase { late final $PlayerGroupTableTable playerGroupTable = $PlayerGroupTableTable( this, ); + late final $PlayerGameTableTable playerGameTable = $PlayerGameTableTable( + this, + ); + late final $GroupGameTableTable groupGameTable = $GroupGameTableTable(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 GameDao gameDao = GameDao(this as AppDatabase); late final PlayerGroupDao playerGroupDao = PlayerGroupDao( this as AppDatabase, ); - late final GameDao gameDao = GameDao(this as AppDatabase); + late final PlayerGameDao playerGameDao = PlayerGameDao(this as AppDatabase); + late final GroupGameDao groupGameDao = GroupGameDao(this as AppDatabase); @override Iterable> get allTables => allSchemaEntities.whereType>(); @@ -866,6 +1372,8 @@ abstract class _$AppDatabase extends GeneratedDatabase { playerTable, groupTable, playerGroupTable, + playerGameTable, + groupGameTable, gameTable, ]; } @@ -909,6 +1417,50 @@ final class $$PlayerTableTableReferences manager.$state.copyWith(prefetchedData: cache), ); } + + static MultiTypedResultKey<$PlayerGameTableTable, List> + _playerGameTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable( + db.playerGameTable, + aliasName: $_aliasNameGenerator( + db.playerTable.id, + db.playerGameTable.playerId, + ), + ); + + $$PlayerGameTableTableProcessedTableManager get playerGameTableRefs { + final manager = $$PlayerGameTableTableTableManager( + $_db, + $_db.playerGameTable, + ).filter((f) => f.playerId.id.sqlEquals($_itemColumn('id')!)); + + final cache = $_typedResult.readTableOrNull( + _playerGameTableRefsTable($_db), + ); + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: cache), + ); + } + + static MultiTypedResultKey<$GroupGameTableTable, List> + _groupGameTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable( + db.groupGameTable, + aliasName: $_aliasNameGenerator( + db.playerTable.id, + db.groupGameTable.groupId, + ), + ); + + $$GroupGameTableTableProcessedTableManager get groupGameTableRefs { + final manager = $$GroupGameTableTableTableManager( + $_db, + $_db.groupGameTable, + ).filter((f) => f.groupId.id.sqlEquals($_itemColumn('id')!)); + + final cache = $_typedResult.readTableOrNull(_groupGameTableRefsTable($_db)); + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: cache), + ); + } } class $$PlayerTableTableFilterComposer @@ -954,6 +1506,56 @@ class $$PlayerTableTableFilterComposer ); return f(composer); } + + Expression playerGameTableRefs( + Expression Function($$PlayerGameTableTableFilterComposer f) f, + ) { + final $$PlayerGameTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.playerGameTable, + getReferencedColumn: (t) => t.playerId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$PlayerGameTableTableFilterComposer( + $db: $db, + $table: $db.playerGameTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } + + Expression groupGameTableRefs( + Expression Function($$GroupGameTableTableFilterComposer f) f, + ) { + final $$GroupGameTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.groupGameTable, + getReferencedColumn: (t) => t.groupId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$GroupGameTableTableFilterComposer( + $db: $db, + $table: $db.groupGameTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } } class $$PlayerTableTableOrderingComposer @@ -1015,6 +1617,56 @@ class $$PlayerTableTableAnnotationComposer ); return f(composer); } + + Expression playerGameTableRefs( + Expression Function($$PlayerGameTableTableAnnotationComposer a) f, + ) { + final $$PlayerGameTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.playerGameTable, + getReferencedColumn: (t) => t.playerId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$PlayerGameTableTableAnnotationComposer( + $db: $db, + $table: $db.playerGameTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } + + Expression groupGameTableRefs( + Expression Function($$GroupGameTableTableAnnotationComposer a) f, + ) { + final $$GroupGameTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.groupGameTable, + getReferencedColumn: (t) => t.groupId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$GroupGameTableTableAnnotationComposer( + $db: $db, + $table: $db.groupGameTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } } class $$PlayerTableTableTableManager @@ -1030,7 +1682,11 @@ class $$PlayerTableTableTableManager $$PlayerTableTableUpdateCompanionBuilder, (PlayerTableData, $$PlayerTableTableReferences), PlayerTableData, - PrefetchHooks Function({bool playerGroupTableRefs}) + PrefetchHooks Function({ + bool playerGroupTableRefs, + bool playerGameTableRefs, + bool groupGameTableRefs, + }) > { $$PlayerTableTableTableManager(_$AppDatabase db, $PlayerTableTable table) : super( @@ -1064,38 +1720,89 @@ class $$PlayerTableTableTableManager ), ) .toList(), - 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.playerId == item.id), - typedResults: items, - ), - ]; + prefetchHooksCallback: + ({ + playerGroupTableRefs = false, + playerGameTableRefs = false, + groupGameTableRefs = false, + }) { + return PrefetchHooks( + db: db, + explicitlyWatchedTables: [ + if (playerGroupTableRefs) db.playerGroupTable, + if (playerGameTableRefs) db.playerGameTable, + if (groupGameTableRefs) db.groupGameTable, + ], + 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.playerId == item.id, + ), + typedResults: items, + ), + if (playerGameTableRefs) + await $_getPrefetchedData< + PlayerTableData, + $PlayerTableTable, + PlayerGameTableData + >( + currentTable: table, + referencedTable: $$PlayerTableTableReferences + ._playerGameTableRefsTable(db), + managerFromTypedResult: (p0) => + $$PlayerTableTableReferences( + db, + table, + p0, + ).playerGameTableRefs, + referencedItemsForCurrentItem: + (item, referencedItems) => referencedItems.where( + (e) => e.playerId == item.id, + ), + typedResults: items, + ), + if (groupGameTableRefs) + await $_getPrefetchedData< + PlayerTableData, + $PlayerTableTable, + GroupGameTableData + >( + currentTable: table, + referencedTable: $$PlayerTableTableReferences + ._groupGameTableRefsTable(db), + managerFromTypedResult: (p0) => + $$PlayerTableTableReferences( + db, + table, + p0, + ).groupGameTableRefs, + referencedItemsForCurrentItem: + (item, referencedItems) => referencedItems.where( + (e) => e.groupId == item.id, + ), + typedResults: items, + ), + ]; + }, + ); }, - ); - }, ), ); } @@ -1112,7 +1819,11 @@ typedef $$PlayerTableTableProcessedTableManager = $$PlayerTableTableUpdateCompanionBuilder, (PlayerTableData, $$PlayerTableTableReferences), PlayerTableData, - PrefetchHooks Function({bool playerGroupTableRefs}) + PrefetchHooks Function({ + bool playerGroupTableRefs, + bool playerGameTableRefs, + bool groupGameTableRefs, + }) >; typedef $$GroupTableTableCreateCompanionBuilder = GroupTableCompanion Function({ @@ -1153,6 +1864,47 @@ final class $$GroupTableTableReferences manager.$state.copyWith(prefetchedData: cache), ); } + + static MultiTypedResultKey<$PlayerGameTableTable, List> + _playerGameTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable( + db.playerGameTable, + aliasName: $_aliasNameGenerator( + db.groupTable.id, + db.playerGameTable.gameId, + ), + ); + + $$PlayerGameTableTableProcessedTableManager get playerGameTableRefs { + final manager = $$PlayerGameTableTableTableManager( + $_db, + $_db.playerGameTable, + ).filter((f) => f.gameId.id.sqlEquals($_itemColumn('id')!)); + + final cache = $_typedResult.readTableOrNull( + _playerGameTableRefsTable($_db), + ); + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: cache), + ); + } + + static MultiTypedResultKey<$GroupGameTableTable, List> + _groupGameTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable( + db.groupGameTable, + aliasName: $_aliasNameGenerator(db.groupTable.id, db.groupGameTable.gameId), + ); + + $$GroupGameTableTableProcessedTableManager get groupGameTableRefs { + final manager = $$GroupGameTableTableTableManager( + $_db, + $_db.groupGameTable, + ).filter((f) => f.gameId.id.sqlEquals($_itemColumn('id')!)); + + final cache = $_typedResult.readTableOrNull(_groupGameTableRefsTable($_db)); + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: cache), + ); + } } class $$GroupTableTableFilterComposer @@ -1198,6 +1950,56 @@ class $$GroupTableTableFilterComposer ); return f(composer); } + + Expression playerGameTableRefs( + Expression Function($$PlayerGameTableTableFilterComposer f) f, + ) { + final $$PlayerGameTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.playerGameTable, + getReferencedColumn: (t) => t.gameId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$PlayerGameTableTableFilterComposer( + $db: $db, + $table: $db.playerGameTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } + + Expression groupGameTableRefs( + Expression Function($$GroupGameTableTableFilterComposer f) f, + ) { + final $$GroupGameTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.groupGameTable, + getReferencedColumn: (t) => t.gameId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$GroupGameTableTableFilterComposer( + $db: $db, + $table: $db.groupGameTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } } class $$GroupTableTableOrderingComposer @@ -1259,6 +2061,56 @@ class $$GroupTableTableAnnotationComposer ); return f(composer); } + + Expression playerGameTableRefs( + Expression Function($$PlayerGameTableTableAnnotationComposer a) f, + ) { + final $$PlayerGameTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.playerGameTable, + getReferencedColumn: (t) => t.gameId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$PlayerGameTableTableAnnotationComposer( + $db: $db, + $table: $db.playerGameTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } + + Expression groupGameTableRefs( + Expression Function($$GroupGameTableTableAnnotationComposer a) f, + ) { + final $$GroupGameTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.id, + referencedTable: $db.groupGameTable, + getReferencedColumn: (t) => t.gameId, + builder: + ( + joinBuilder, { + $addJoinBuilderToRootComposer, + $removeJoinBuilderFromRootComposer, + }) => $$GroupGameTableTableAnnotationComposer( + $db: $db, + $table: $db.groupGameTable, + $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer, + joinBuilder: joinBuilder, + $removeJoinBuilderFromRootComposer: + $removeJoinBuilderFromRootComposer, + ), + ); + return f(composer); + } } class $$GroupTableTableTableManager @@ -1274,7 +2126,11 @@ class $$GroupTableTableTableManager $$GroupTableTableUpdateCompanionBuilder, (GroupTableData, $$GroupTableTableReferences), GroupTableData, - PrefetchHooks Function({bool playerGroupTableRefs}) + PrefetchHooks Function({ + bool playerGroupTableRefs, + bool playerGameTableRefs, + bool groupGameTableRefs, + }) > { $$GroupTableTableTableManager(_$AppDatabase db, $GroupTableTable table) : super( @@ -1308,38 +2164,89 @@ class $$GroupTableTableTableManager ), ) .toList(), - 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, - ), - ]; + prefetchHooksCallback: + ({ + playerGroupTableRefs = false, + playerGameTableRefs = false, + groupGameTableRefs = false, + }) { + return PrefetchHooks( + db: db, + explicitlyWatchedTables: [ + if (playerGroupTableRefs) db.playerGroupTable, + if (playerGameTableRefs) db.playerGameTable, + if (groupGameTableRefs) db.groupGameTable, + ], + 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, + ), + if (playerGameTableRefs) + await $_getPrefetchedData< + GroupTableData, + $GroupTableTable, + PlayerGameTableData + >( + currentTable: table, + referencedTable: $$GroupTableTableReferences + ._playerGameTableRefsTable(db), + managerFromTypedResult: (p0) => + $$GroupTableTableReferences( + db, + table, + p0, + ).playerGameTableRefs, + referencedItemsForCurrentItem: + (item, referencedItems) => referencedItems.where( + (e) => e.gameId == item.id, + ), + typedResults: items, + ), + if (groupGameTableRefs) + await $_getPrefetchedData< + GroupTableData, + $GroupTableTable, + GroupGameTableData + >( + currentTable: table, + referencedTable: $$GroupTableTableReferences + ._groupGameTableRefsTable(db), + managerFromTypedResult: (p0) => + $$GroupTableTableReferences( + db, + table, + p0, + ).groupGameTableRefs, + referencedItemsForCurrentItem: + (item, referencedItems) => referencedItems.where( + (e) => e.gameId == item.id, + ), + typedResults: items, + ), + ]; + }, + ); }, - ); - }, ), ); } @@ -1356,7 +2263,11 @@ typedef $$GroupTableTableProcessedTableManager = $$GroupTableTableUpdateCompanionBuilder, (GroupTableData, $$GroupTableTableReferences), GroupTableData, - PrefetchHooks Function({bool playerGroupTableRefs}) + PrefetchHooks Function({ + bool playerGroupTableRefs, + bool playerGameTableRefs, + bool groupGameTableRefs, + }) >; typedef $$PlayerGroupTableTableCreateCompanionBuilder = PlayerGroupTableCompanion Function({ @@ -1723,16 +2634,746 @@ typedef $$PlayerGroupTableTableProcessedTableManager = PlayerGroupTableData, PrefetchHooks Function({bool playerId, bool groupId}) >; +typedef $$PlayerGameTableTableCreateCompanionBuilder = + PlayerGameTableCompanion Function({ + required String playerId, + required String gameId, + Value rowid, + }); +typedef $$PlayerGameTableTableUpdateCompanionBuilder = + PlayerGameTableCompanion Function({ + Value playerId, + Value gameId, + Value rowid, + }); + +final class $$PlayerGameTableTableReferences + extends + BaseReferences< + _$AppDatabase, + $PlayerGameTableTable, + PlayerGameTableData + > { + $$PlayerGameTableTableReferences( + super.$_db, + super.$_table, + super.$_typedResult, + ); + + static $PlayerTableTable _playerIdTable(_$AppDatabase db) => + db.playerTable.createAlias( + $_aliasNameGenerator(db.playerGameTable.playerId, db.playerTable.id), + ); + + $$PlayerTableTableProcessedTableManager get playerId { + final $_column = $_itemColumn('player_id')!; + + final manager = $$PlayerTableTableTableManager( + $_db, + $_db.playerTable, + ).filter((f) => f.id.sqlEquals($_column)); + final item = $_typedResult.readTableOrNull(_playerIdTable($_db)); + if (item == null) return manager; + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: [item]), + ); + } + + static $GroupTableTable _gameIdTable(_$AppDatabase db) => + db.groupTable.createAlias( + $_aliasNameGenerator(db.playerGameTable.gameId, db.groupTable.id), + ); + + $$GroupTableTableProcessedTableManager get gameId { + final $_column = $_itemColumn('game_id')!; + + final manager = $$GroupTableTableTableManager( + $_db, + $_db.groupTable, + ).filter((f) => f.id.sqlEquals($_column)); + final item = $_typedResult.readTableOrNull(_gameIdTable($_db)); + if (item == null) return manager; + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: [item]), + ); + } +} + +class $$PlayerGameTableTableFilterComposer + extends Composer<_$AppDatabase, $PlayerGameTableTable> { + $$PlayerGameTableTableFilterComposer({ + required super.$db, + required super.$table, + super.joinBuilder, + super.$addJoinBuilderToRootComposer, + super.$removeJoinBuilderFromRootComposer, + }); + $$PlayerTableTableFilterComposer get playerId { + final $$PlayerTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.playerId, + 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; + } + + $$GroupTableTableFilterComposer get gameId { + final $$GroupTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.gameId, + 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 $$PlayerGameTableTableOrderingComposer + extends Composer<_$AppDatabase, $PlayerGameTableTable> { + $$PlayerGameTableTableOrderingComposer({ + required super.$db, + required super.$table, + super.joinBuilder, + super.$addJoinBuilderToRootComposer, + super.$removeJoinBuilderFromRootComposer, + }); + $$PlayerTableTableOrderingComposer get playerId { + final $$PlayerTableTableOrderingComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.playerId, + 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; + } + + $$GroupTableTableOrderingComposer get gameId { + final $$GroupTableTableOrderingComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.gameId, + 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 $$PlayerGameTableTableAnnotationComposer + extends Composer<_$AppDatabase, $PlayerGameTableTable> { + $$PlayerGameTableTableAnnotationComposer({ + required super.$db, + required super.$table, + super.joinBuilder, + super.$addJoinBuilderToRootComposer, + super.$removeJoinBuilderFromRootComposer, + }); + $$PlayerTableTableAnnotationComposer get playerId { + final $$PlayerTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.playerId, + 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; + } + + $$GroupTableTableAnnotationComposer get gameId { + final $$GroupTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.gameId, + 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 $$PlayerGameTableTableTableManager + extends + RootTableManager< + _$AppDatabase, + $PlayerGameTableTable, + PlayerGameTableData, + $$PlayerGameTableTableFilterComposer, + $$PlayerGameTableTableOrderingComposer, + $$PlayerGameTableTableAnnotationComposer, + $$PlayerGameTableTableCreateCompanionBuilder, + $$PlayerGameTableTableUpdateCompanionBuilder, + (PlayerGameTableData, $$PlayerGameTableTableReferences), + PlayerGameTableData, + PrefetchHooks Function({bool playerId, bool gameId}) + > { + $$PlayerGameTableTableTableManager( + _$AppDatabase db, + $PlayerGameTableTable table, + ) : super( + TableManagerState( + db: db, + table: table, + createFilteringComposer: () => + $$PlayerGameTableTableFilterComposer($db: db, $table: table), + createOrderingComposer: () => + $$PlayerGameTableTableOrderingComposer($db: db, $table: table), + createComputedFieldComposer: () => + $$PlayerGameTableTableAnnotationComposer($db: db, $table: table), + updateCompanionCallback: + ({ + Value playerId = const Value.absent(), + Value gameId = const Value.absent(), + Value rowid = const Value.absent(), + }) => PlayerGameTableCompanion( + playerId: playerId, + gameId: gameId, + rowid: rowid, + ), + createCompanionCallback: + ({ + required String playerId, + required String gameId, + Value rowid = const Value.absent(), + }) => PlayerGameTableCompanion.insert( + playerId: playerId, + gameId: gameId, + rowid: rowid, + ), + withReferenceMapper: (p0) => p0 + .map( + (e) => ( + e.readTable(table), + $$PlayerGameTableTableReferences(db, table, e), + ), + ) + .toList(), + prefetchHooksCallback: ({playerId = false, gameId = false}) { + return PrefetchHooks( + db: db, + explicitlyWatchedTables: [], + addJoins: + < + T extends TableManagerState< + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic + > + >(state) { + if (playerId) { + state = + state.withJoin( + currentTable: table, + currentColumn: table.playerId, + referencedTable: + $$PlayerGameTableTableReferences + ._playerIdTable(db), + referencedColumn: + $$PlayerGameTableTableReferences + ._playerIdTable(db) + .id, + ) + as T; + } + if (gameId) { + state = + state.withJoin( + currentTable: table, + currentColumn: table.gameId, + referencedTable: + $$PlayerGameTableTableReferences + ._gameIdTable(db), + referencedColumn: + $$PlayerGameTableTableReferences + ._gameIdTable(db) + .id, + ) + as T; + } + + return state; + }, + getPrefetchedDataCallback: (items) async { + return []; + }, + ); + }, + ), + ); +} + +typedef $$PlayerGameTableTableProcessedTableManager = + ProcessedTableManager< + _$AppDatabase, + $PlayerGameTableTable, + PlayerGameTableData, + $$PlayerGameTableTableFilterComposer, + $$PlayerGameTableTableOrderingComposer, + $$PlayerGameTableTableAnnotationComposer, + $$PlayerGameTableTableCreateCompanionBuilder, + $$PlayerGameTableTableUpdateCompanionBuilder, + (PlayerGameTableData, $$PlayerGameTableTableReferences), + PlayerGameTableData, + PrefetchHooks Function({bool playerId, bool gameId}) + >; +typedef $$GroupGameTableTableCreateCompanionBuilder = + GroupGameTableCompanion Function({ + required String groupId, + required String gameId, + Value rowid, + }); +typedef $$GroupGameTableTableUpdateCompanionBuilder = + GroupGameTableCompanion Function({ + Value groupId, + Value gameId, + Value rowid, + }); + +final class $$GroupGameTableTableReferences + extends + BaseReferences< + _$AppDatabase, + $GroupGameTableTable, + GroupGameTableData + > { + $$GroupGameTableTableReferences( + super.$_db, + super.$_table, + super.$_typedResult, + ); + + static $PlayerTableTable _groupIdTable(_$AppDatabase db) => + db.playerTable.createAlias( + $_aliasNameGenerator(db.groupGameTable.groupId, db.playerTable.id), + ); + + $$PlayerTableTableProcessedTableManager get groupId { + final $_column = $_itemColumn('group_id')!; + + final manager = $$PlayerTableTableTableManager( + $_db, + $_db.playerTable, + ).filter((f) => f.id.sqlEquals($_column)); + final item = $_typedResult.readTableOrNull(_groupIdTable($_db)); + if (item == null) return manager; + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: [item]), + ); + } + + static $GroupTableTable _gameIdTable(_$AppDatabase db) => + db.groupTable.createAlias( + $_aliasNameGenerator(db.groupGameTable.gameId, db.groupTable.id), + ); + + $$GroupTableTableProcessedTableManager get gameId { + final $_column = $_itemColumn('game_id')!; + + final manager = $$GroupTableTableTableManager( + $_db, + $_db.groupTable, + ).filter((f) => f.id.sqlEquals($_column)); + final item = $_typedResult.readTableOrNull(_gameIdTable($_db)); + if (item == null) return manager; + return ProcessedTableManager( + manager.$state.copyWith(prefetchedData: [item]), + ); + } +} + +class $$GroupGameTableTableFilterComposer + extends Composer<_$AppDatabase, $GroupGameTableTable> { + $$GroupGameTableTableFilterComposer({ + required super.$db, + required super.$table, + super.joinBuilder, + super.$addJoinBuilderToRootComposer, + super.$removeJoinBuilderFromRootComposer, + }); + $$PlayerTableTableFilterComposer get groupId { + final $$PlayerTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.groupId, + 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; + } + + $$GroupTableTableFilterComposer get gameId { + final $$GroupTableTableFilterComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.gameId, + 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 $$GroupGameTableTableOrderingComposer + extends Composer<_$AppDatabase, $GroupGameTableTable> { + $$GroupGameTableTableOrderingComposer({ + required super.$db, + required super.$table, + super.joinBuilder, + super.$addJoinBuilderToRootComposer, + super.$removeJoinBuilderFromRootComposer, + }); + $$PlayerTableTableOrderingComposer get groupId { + final $$PlayerTableTableOrderingComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.groupId, + 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; + } + + $$GroupTableTableOrderingComposer get gameId { + final $$GroupTableTableOrderingComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.gameId, + 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 $$GroupGameTableTableAnnotationComposer + extends Composer<_$AppDatabase, $GroupGameTableTable> { + $$GroupGameTableTableAnnotationComposer({ + required super.$db, + required super.$table, + super.joinBuilder, + super.$addJoinBuilderToRootComposer, + super.$removeJoinBuilderFromRootComposer, + }); + $$PlayerTableTableAnnotationComposer get groupId { + final $$PlayerTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.groupId, + 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; + } + + $$GroupTableTableAnnotationComposer get gameId { + final $$GroupTableTableAnnotationComposer composer = $composerBuilder( + composer: this, + getCurrentColumn: (t) => t.gameId, + 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 $$GroupGameTableTableTableManager + extends + RootTableManager< + _$AppDatabase, + $GroupGameTableTable, + GroupGameTableData, + $$GroupGameTableTableFilterComposer, + $$GroupGameTableTableOrderingComposer, + $$GroupGameTableTableAnnotationComposer, + $$GroupGameTableTableCreateCompanionBuilder, + $$GroupGameTableTableUpdateCompanionBuilder, + (GroupGameTableData, $$GroupGameTableTableReferences), + GroupGameTableData, + PrefetchHooks Function({bool groupId, bool gameId}) + > { + $$GroupGameTableTableTableManager( + _$AppDatabase db, + $GroupGameTableTable table, + ) : super( + TableManagerState( + db: db, + table: table, + createFilteringComposer: () => + $$GroupGameTableTableFilterComposer($db: db, $table: table), + createOrderingComposer: () => + $$GroupGameTableTableOrderingComposer($db: db, $table: table), + createComputedFieldComposer: () => + $$GroupGameTableTableAnnotationComposer($db: db, $table: table), + updateCompanionCallback: + ({ + Value groupId = const Value.absent(), + Value gameId = const Value.absent(), + Value rowid = const Value.absent(), + }) => GroupGameTableCompanion( + groupId: groupId, + gameId: gameId, + rowid: rowid, + ), + createCompanionCallback: + ({ + required String groupId, + required String gameId, + Value rowid = const Value.absent(), + }) => GroupGameTableCompanion.insert( + groupId: groupId, + gameId: gameId, + rowid: rowid, + ), + withReferenceMapper: (p0) => p0 + .map( + (e) => ( + e.readTable(table), + $$GroupGameTableTableReferences(db, table, e), + ), + ) + .toList(), + prefetchHooksCallback: ({groupId = false, gameId = false}) { + return PrefetchHooks( + db: db, + explicitlyWatchedTables: [], + addJoins: + < + T extends TableManagerState< + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic, + dynamic + > + >(state) { + if (groupId) { + state = + state.withJoin( + currentTable: table, + currentColumn: table.groupId, + referencedTable: $$GroupGameTableTableReferences + ._groupIdTable(db), + referencedColumn: + $$GroupGameTableTableReferences + ._groupIdTable(db) + .id, + ) + as T; + } + if (gameId) { + state = + state.withJoin( + currentTable: table, + currentColumn: table.gameId, + referencedTable: $$GroupGameTableTableReferences + ._gameIdTable(db), + referencedColumn: + $$GroupGameTableTableReferences + ._gameIdTable(db) + .id, + ) + as T; + } + + return state; + }, + getPrefetchedDataCallback: (items) async { + return []; + }, + ); + }, + ), + ); +} + +typedef $$GroupGameTableTableProcessedTableManager = + ProcessedTableManager< + _$AppDatabase, + $GroupGameTableTable, + GroupGameTableData, + $$GroupGameTableTableFilterComposer, + $$GroupGameTableTableOrderingComposer, + $$GroupGameTableTableAnnotationComposer, + $$GroupGameTableTableCreateCompanionBuilder, + $$GroupGameTableTableUpdateCompanionBuilder, + (GroupGameTableData, $$GroupGameTableTableReferences), + GroupGameTableData, + PrefetchHooks Function({bool groupId, bool gameId}) + >; typedef $$GameTableTableCreateCompanionBuilder = GameTableCompanion Function({ required String id, required String name, + Value winnerId, Value rowid, }); typedef $$GameTableTableUpdateCompanionBuilder = GameTableCompanion Function({ Value id, Value name, + Value winnerId, Value rowid, }); @@ -1754,6 +3395,11 @@ class $$GameTableTableFilterComposer column: $table.name, builder: (column) => ColumnFilters(column), ); + + ColumnFilters get winnerId => $composableBuilder( + column: $table.winnerId, + builder: (column) => ColumnFilters(column), + ); } class $$GameTableTableOrderingComposer @@ -1774,6 +3420,11 @@ class $$GameTableTableOrderingComposer column: $table.name, builder: (column) => ColumnOrderings(column), ); + + ColumnOrderings get winnerId => $composableBuilder( + column: $table.winnerId, + builder: (column) => ColumnOrderings(column), + ); } class $$GameTableTableAnnotationComposer @@ -1790,6 +3441,9 @@ class $$GameTableTableAnnotationComposer GeneratedColumn get name => $composableBuilder(column: $table.name, builder: (column) => column); + + GeneratedColumn get winnerId => + $composableBuilder(column: $table.winnerId, builder: (column) => column); } class $$GameTableTableTableManager @@ -1825,14 +3479,26 @@ class $$GameTableTableTableManager ({ Value id = const Value.absent(), Value name = const Value.absent(), + Value winnerId = const Value.absent(), Value rowid = const Value.absent(), - }) => GameTableCompanion(id: id, name: name, rowid: rowid), + }) => GameTableCompanion( + id: id, + name: name, + winnerId: winnerId, + rowid: rowid, + ), createCompanionCallback: ({ required String id, required String name, + Value winnerId = const Value.absent(), Value rowid = const Value.absent(), - }) => GameTableCompanion.insert(id: id, name: name, rowid: rowid), + }) => GameTableCompanion.insert( + id: id, + name: name, + winnerId: winnerId, + rowid: rowid, + ), withReferenceMapper: (p0) => p0 .map((e) => (e.readTable(table), BaseReferences(db, table, e))) .toList(), @@ -1868,6 +3534,10 @@ class $AppDatabaseManager { $$GroupTableTableTableManager(_db, _db.groupTable); $$PlayerGroupTableTableTableManager get playerGroupTable => $$PlayerGroupTableTableTableManager(_db, _db.playerGroupTable); + $$PlayerGameTableTableTableManager get playerGameTable => + $$PlayerGameTableTableTableManager(_db, _db.playerGameTable); + $$GroupGameTableTableTableManager get groupGameTable => + $$GroupGameTableTableTableManager(_db, _db.groupGameTable); $$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 index 45bfb20..0772647 100644 --- a/lib/data/db/tables/game_table.dart +++ b/lib/data/db/tables/game_table.dart @@ -3,6 +3,7 @@ import 'package:drift/drift.dart'; class GameTable extends Table { TextColumn get id => text()(); TextColumn get name => text()(); + TextColumn get winnerId => text().nullable()(); @override Set> get primaryKey => {id}; diff --git a/lib/data/db/tables/group_game_table.dart b/lib/data/db/tables/group_game_table.dart new file mode 100644 index 0000000..f70206f --- /dev/null +++ b/lib/data/db/tables/group_game_table.dart @@ -0,0 +1,11 @@ +import 'package:drift/drift.dart'; +import 'package:game_tracker/data/db/tables/group_table.dart'; +import 'package:game_tracker/data/db/tables/player_table.dart'; + +class GroupGameTable extends Table { + TextColumn get groupId => text().references(PlayerTable, #id)(); + TextColumn get gameId => text().references(GroupTable, #id)(); + + @override + Set> get primaryKey => {groupId, gameId}; +} diff --git a/lib/data/db/tables/player_game_table.dart b/lib/data/db/tables/player_game_table.dart new file mode 100644 index 0000000..95ef4db --- /dev/null +++ b/lib/data/db/tables/player_game_table.dart @@ -0,0 +1,11 @@ +import 'package:drift/drift.dart'; +import 'package:game_tracker/data/db/tables/group_table.dart'; +import 'package:game_tracker/data/db/tables/player_table.dart'; + +class PlayerGameTable extends Table { + TextColumn get playerId => text().references(PlayerTable, #id)(); + TextColumn get gameId => text().references(GroupTable, #id)(); + + @override + Set> get primaryKey => {playerId, gameId}; +} diff --git a/lib/data/dto/game.dart b/lib/data/dto/game.dart index 7457b54..2c09851 100644 --- a/lib/data/dto/game.dart +++ b/lib/data/dto/game.dart @@ -1,6 +1,18 @@ +import 'package:game_tracker/data/dto/group.dart'; +import 'package:game_tracker/data/dto/player.dart'; + class Game { final String id; final String name; + final List? players; + final Group? group; + final String? winner; - Game({required this.id, required this.name}); + Game({ + this.players, + this.group, + this.winner, + required this.id, + required this.name, + }); }