Compare commits
8 Commits
enhancemen
...
8ca3a047a9
| Author | SHA1 | Date | |
|---|---|---|---|
| 8ca3a047a9 | |||
| 61c6364e62 | |||
| 0c4c54dd04 | |||
| a6f6f18fcd | |||
| 27508b5e29 | |||
| acb8e5681f | |||
| 956b6ce6f0 | |||
| 869654a740 |
@@ -85,6 +85,7 @@ jobs:
|
||||
strategy: 'patch'
|
||||
path: './pubspec.yaml'
|
||||
|
||||
|
||||
- name: Commit version update
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.BOT_TOKEN }}
|
||||
@@ -103,10 +104,6 @@ jobs:
|
||||
steps:
|
||||
- name: Checkout code
|
||||
uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
token: ${{ secrets.BOT_TOKEN }}
|
||||
ref: ${{ gitea.ref_name }}
|
||||
|
||||
# Required for Flutter action
|
||||
- name: Install jq
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
# Contributing
|
||||
|
||||
## Code of Conduct
|
||||
|
||||
`<insert link to code of conduct here>`
|
||||
|
||||
## Code Style
|
||||
|
||||
`<insert styling guidelines here>`
|
||||
|
||||
## Repository structure
|
||||
|
||||
`<insert folder structure and explanation here>`
|
||||
165
LICENSE
165
LICENSE
@@ -1,165 +0,0 @@
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
Version 3, 29 June 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
|
||||
This version of the GNU Lesser General Public License incorporates
|
||||
the terms and conditions of version 3 of the GNU General Public
|
||||
License, supplemented by the additional permissions listed below.
|
||||
|
||||
0. Additional Definitions.
|
||||
|
||||
As used herein, "this License" refers to version 3 of the GNU Lesser
|
||||
General Public License, and the "GNU GPL" refers to version 3 of the GNU
|
||||
General Public License.
|
||||
|
||||
"The Library" refers to a covered work governed by this License,
|
||||
other than an Application or a Combined Work as defined below.
|
||||
|
||||
An "Application" is any work that makes use of an interface provided
|
||||
by the Library, but which is not otherwise based on the Library.
|
||||
Defining a subclass of a class defined by the Library is deemed a mode
|
||||
of using an interface provided by the Library.
|
||||
|
||||
A "Combined Work" is a work produced by combining or linking an
|
||||
Application with the Library. The particular version of the Library
|
||||
with which the Combined Work was made is also called the "Linked
|
||||
Version".
|
||||
|
||||
The "Minimal Corresponding Source" for a Combined Work means the
|
||||
Corresponding Source for the Combined Work, excluding any source code
|
||||
for portions of the Combined Work that, considered in isolation, are
|
||||
based on the Application, and not on the Linked Version.
|
||||
|
||||
The "Corresponding Application Code" for a Combined Work means the
|
||||
object code and/or source code for the Application, including any data
|
||||
and utility programs needed for reproducing the Combined Work from the
|
||||
Application, but excluding the System Libraries of the Combined Work.
|
||||
|
||||
1. Exception to Section 3 of the GNU GPL.
|
||||
|
||||
You may convey a covered work under sections 3 and 4 of this License
|
||||
without being bound by section 3 of the GNU GPL.
|
||||
|
||||
2. Conveying Modified Versions.
|
||||
|
||||
If you modify a copy of the Library, and, in your modifications, a
|
||||
facility refers to a function or data to be supplied by an Application
|
||||
that uses the facility (other than as an argument passed when the
|
||||
facility is invoked), then you may convey a copy of the modified
|
||||
version:
|
||||
|
||||
a) under this License, provided that you make a good faith effort to
|
||||
ensure that, in the event an Application does not supply the
|
||||
function or data, the facility still operates, and performs
|
||||
whatever part of its purpose remains meaningful, or
|
||||
|
||||
b) under the GNU GPL, with none of the additional permissions of
|
||||
this License applicable to that copy.
|
||||
|
||||
3. Object Code Incorporating Material from Library Header Files.
|
||||
|
||||
The object code form of an Application may incorporate material from
|
||||
a header file that is part of the Library. You may convey such object
|
||||
code under terms of your choice, provided that, if the incorporated
|
||||
material is not limited to numerical parameters, data structure
|
||||
layouts and accessors, or small macros, inline functions and templates
|
||||
(ten or fewer lines in length), you do both of the following:
|
||||
|
||||
a) Give prominent notice with each copy of the object code that the
|
||||
Library is used in it and that the Library and its use are
|
||||
covered by this License.
|
||||
|
||||
b) Accompany the object code with a copy of the GNU GPL and this license
|
||||
document.
|
||||
|
||||
4. Combined Works.
|
||||
|
||||
You may convey a Combined Work under terms of your choice that,
|
||||
taken together, effectively do not restrict modification of the
|
||||
portions of the Library contained in the Combined Work and reverse
|
||||
engineering for debugging such modifications, if you also do each of
|
||||
the following:
|
||||
|
||||
a) Give prominent notice with each copy of the Combined Work that
|
||||
the Library is used in it and that the Library and its use are
|
||||
covered by this License.
|
||||
|
||||
b) Accompany the Combined Work with a copy of the GNU GPL and this license
|
||||
document.
|
||||
|
||||
c) For a Combined Work that displays copyright notices during
|
||||
execution, include the copyright notice for the Library among
|
||||
these notices, as well as a reference directing the user to the
|
||||
copies of the GNU GPL and this license document.
|
||||
|
||||
d) Do one of the following:
|
||||
|
||||
0) Convey the Minimal Corresponding Source under the terms of this
|
||||
License, and the Corresponding Application Code in a form
|
||||
suitable for, and under terms that permit, the user to
|
||||
recombine or relink the Application with a modified version of
|
||||
the Linked Version to produce a modified Combined Work, in the
|
||||
manner specified by section 6 of the GNU GPL for conveying
|
||||
Corresponding Source.
|
||||
|
||||
1) Use a suitable shared library mechanism for linking with the
|
||||
Library. A suitable mechanism is one that (a) uses at run time
|
||||
a copy of the Library already present on the user's computer
|
||||
system, and (b) will operate properly with a modified version
|
||||
of the Library that is interface-compatible with the Linked
|
||||
Version.
|
||||
|
||||
e) Provide Installation Information, but only if you would otherwise
|
||||
be required to provide such information under section 6 of the
|
||||
GNU GPL, and only to the extent that such information is
|
||||
necessary to install and execute a modified version of the
|
||||
Combined Work produced by recombining or relinking the
|
||||
Application with a modified version of the Linked Version. (If
|
||||
you use option 4d0, the Installation Information must accompany
|
||||
the Minimal Corresponding Source and Corresponding Application
|
||||
Code. If you use option 4d1, you must provide the Installation
|
||||
Information in the manner specified by section 6 of the GNU GPL
|
||||
for conveying Corresponding Source.)
|
||||
|
||||
5. Combined Libraries.
|
||||
|
||||
You may place library facilities that are a work based on the
|
||||
Library side by side in a single library together with other library
|
||||
facilities that are not Applications and are not covered by this
|
||||
License, and convey such a combined library under terms of your
|
||||
choice, if you do both of the following:
|
||||
|
||||
a) Accompany the combined library with a copy of the same work based
|
||||
on the Library, uncombined with any other library facilities,
|
||||
conveyed under the terms of this License.
|
||||
|
||||
b) Give prominent notice with the combined library that part of it
|
||||
is a work based on the Library, and explaining where to find the
|
||||
accompanying uncombined form of the same work.
|
||||
|
||||
6. Revised Versions of the GNU Lesser General Public License.
|
||||
|
||||
The Free Software Foundation may publish revised and/or new versions
|
||||
of the GNU Lesser General Public License from time to time. Such new
|
||||
versions will be similar in spirit to the present version, but may
|
||||
differ in detail to address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the
|
||||
Library as you received it specifies that a certain numbered version
|
||||
of the GNU Lesser General Public License "or any later version"
|
||||
applies to it, you have the option of following the terms and
|
||||
conditions either of that published version or of any later version
|
||||
published by the Free Software Foundation. If the Library as you
|
||||
received it does not specify a version number of the GNU Lesser
|
||||
General Public License, you may choose any version of the GNU Lesser
|
||||
General Public License ever published by the Free Software Foundation.
|
||||
|
||||
If the Library as you received it specifies that a proxy can decide
|
||||
whether future versions of the GNU Lesser General Public License shall
|
||||
apply, that proxy's public statement of acceptance of any version is
|
||||
permanent authorization for you to choose that version for the
|
||||
Library.
|
||||
66
README.md
66
README.md
@@ -1,63 +1,7 @@
|
||||
<p align="center">
|
||||
<img alt="Tallee Logo" src="/artefacts/app-logo.png" width="200"/>
|
||||
<h2 align="center">Tallee</h2>
|
||||
</p>
|
||||
<p align="center">
|
||||
An open-source app to track card- and board games, manage players & groups and get statistics about your played games.
|
||||
</p>
|
||||
<p align="center">
|
||||
<a href="https://apps.apple.com/">
|
||||
<img src="https://tools.applemediaservices.com/api/badges/download-on-the-app-store/black/en-US"
|
||||
alt="Download on the App Store"
|
||||
height="48"
|
||||
/>
|
||||
</a>
|
||||
<a href="https://play.google.com/">
|
||||
<img alt="Get it on Google Play"
|
||||
title="Google Play"
|
||||
src="https://raw.githubusercontent.com/pd4d10/git-touch/main/assets/google-play-badge.png"
|
||||
height="48"
|
||||
/>
|
||||
</a>
|
||||
</p>
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
## Screenshots
|
||||
|
||||
<table align="center" cellspacing="8">
|
||||
<tr>
|
||||
<td><img src="/artefacts/screenshot-1.png" alt="Screenshot 1" width="240" /></td>
|
||||
<td><img src="/artefacts/screenshot-2.png" alt="Screenshot 2" width="240" /></td>
|
||||
<td><img src="/artefacts/screenshot-3.png" alt="Screenshot 3" width="240" /></td>
|
||||
<td><img src="/artefacts/screenshot-4.png" alt="Screenshot 4" width="240" /></td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
## Contributing
|
||||
|
||||
Contributions are welcome! If you find a bug or have a feature request, please open an issue on GitHub. If you'd like to
|
||||
contribute code, feel free to fork the repository and submit a pull request. For contribution guidelines, please refer
|
||||
to [CONTRIBUTING.md](CONTRIBUTING.md).
|
||||
|
||||
## License
|
||||
|
||||
This project is licensed under the GNU LGPLv3 License. See the [LICENSE](LICENSE) file for details.
|
||||
|
||||
## Contributors
|
||||
|
||||
<a href="https://github.com/liquiddevelopmentde/game-tracker/graphs/contributors">
|
||||
<img src="https://contrib.rocks/image?repo=liquiddevelopmentde/game-tracker" />
|
||||
</a>
|
||||
|
||||
|
||||
## Credits
|
||||
|
||||
Tallee is developed and maintained by [Liquid Development](https://liquid-dev.de). For more information or support regarding Tallee, contact us through our website or [hello@liquid-dev.de](mailto:hello@liquid-dev.de).
|
||||
|
||||
|
||||
# Game Tracker
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
A all-in-one app to track card- and board games, manage players and groups and get statistics about your played games.
|
||||
|
||||
@@ -12,7 +12,3 @@ linter:
|
||||
unnecessary_const: true
|
||||
lines_longer_than_80_chars: false
|
||||
constant_identifier_names: false
|
||||
|
||||
analyzer:
|
||||
exclude:
|
||||
- lib/presentation/views/main_menu/settings_view/licenses/oss_licenses.dart
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 47 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 291 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 279 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 354 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 294 KiB |
@@ -15,56 +15,12 @@
|
||||
},
|
||||
"name": {
|
||||
"type": "string"
|
||||
},
|
||||
"description": {
|
||||
"type": "string"
|
||||
}
|
||||
},
|
||||
"additionalProperties": false,
|
||||
"required": [
|
||||
"id",
|
||||
"createdAt",
|
||||
"name",
|
||||
"description"
|
||||
]
|
||||
}
|
||||
},
|
||||
"games": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"id": {
|
||||
"type": "string"
|
||||
},
|
||||
"createdAt": {
|
||||
"type": "string"
|
||||
},
|
||||
"name": {
|
||||
"type": "string"
|
||||
},
|
||||
"ruleset": {
|
||||
"type": "string"
|
||||
},
|
||||
"description": {
|
||||
"type": "string"
|
||||
},
|
||||
"color": {
|
||||
"type": "string"
|
||||
},
|
||||
"icon": {
|
||||
"type": "string"
|
||||
}
|
||||
},
|
||||
"additionalProperties": false,
|
||||
"required": [
|
||||
"id",
|
||||
"createdAt",
|
||||
"name",
|
||||
"ruleset",
|
||||
"description",
|
||||
"color",
|
||||
"icon"
|
||||
"name"
|
||||
]
|
||||
}
|
||||
},
|
||||
@@ -82,9 +38,6 @@
|
||||
"createdAt": {
|
||||
"type": "string"
|
||||
},
|
||||
"description": {
|
||||
"type": "string"
|
||||
},
|
||||
"memberIds": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
@@ -92,38 +45,6 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"additionalProperties": false,
|
||||
"required": [
|
||||
"id",
|
||||
"name",
|
||||
"createdAt",
|
||||
"description",
|
||||
"memberIds"
|
||||
]
|
||||
}
|
||||
},
|
||||
"teams": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"id": {
|
||||
"type": "string"
|
||||
},
|
||||
"name": {
|
||||
"type": "string"
|
||||
},
|
||||
"createdAt": {
|
||||
"type": "string"
|
||||
},
|
||||
"memberIds": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "string"
|
||||
}
|
||||
}
|
||||
},
|
||||
"additionalProperties": false,
|
||||
"required": [
|
||||
"id",
|
||||
"name",
|
||||
@@ -146,14 +67,11 @@
|
||||
"createdAt": {
|
||||
"type": "string"
|
||||
},
|
||||
"endedAt": {
|
||||
"type": ["string", "null"]
|
||||
},
|
||||
"gameId": {
|
||||
"type": "string"
|
||||
},
|
||||
"groupId": {
|
||||
"type": ["string", "null"]
|
||||
"anyOf": [
|
||||
{"type": "string"},
|
||||
{"type": "null"}
|
||||
]
|
||||
},
|
||||
"playerIds": {
|
||||
"type": "array",
|
||||
@@ -161,48 +79,26 @@
|
||||
"type": "string"
|
||||
}
|
||||
},
|
||||
"scores": {
|
||||
"type": "object",
|
||||
"items": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "string",
|
||||
"properties": {
|
||||
"roundNumber": {
|
||||
"type": "number"
|
||||
},
|
||||
"score": {
|
||||
"type": "number"
|
||||
},
|
||||
"change": {
|
||||
"type": "number"
|
||||
}
|
||||
}
|
||||
}
|
||||
"winnerId": {
|
||||
"anyOf": [
|
||||
{"type": "string"},
|
||||
{"type": "null"}
|
||||
]
|
||||
}
|
||||
},
|
||||
"notes": {
|
||||
"type": "string"
|
||||
}
|
||||
},
|
||||
"additionalProperties": false,
|
||||
"required": [
|
||||
"id",
|
||||
"name",
|
||||
"createdAt",
|
||||
"gameId",
|
||||
"playerIds",
|
||||
"notes"
|
||||
"groupId",
|
||||
"playerIds"
|
||||
]
|
||||
}
|
||||
}
|
||||
},
|
||||
"additionalProperties": false,
|
||||
"required": [
|
||||
"players",
|
||||
"games",
|
||||
"groups",
|
||||
"teams",
|
||||
"matches"
|
||||
]
|
||||
}
|
||||
@@ -20,5 +20,7 @@
|
||||
<string>????</string>
|
||||
<key>CFBundleVersion</key>
|
||||
<string>1.0</string>
|
||||
<key>MinimumOSVersion</key>
|
||||
<string>13.0</string>
|
||||
</dict>
|
||||
</plist>
|
||||
|
||||
@@ -2,15 +2,12 @@ import Flutter
|
||||
import UIKit
|
||||
|
||||
@main
|
||||
@objc class AppDelegate: FlutterAppDelegate, FlutterImplicitEngineDelegate {
|
||||
@objc class AppDelegate: FlutterAppDelegate {
|
||||
override func application(
|
||||
_ application: UIApplication,
|
||||
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
|
||||
) -> Bool {
|
||||
GeneratedPluginRegistrant.register(with: self)
|
||||
return super.application(application, didFinishLaunchingWithOptions: launchOptions)
|
||||
}
|
||||
|
||||
func didInitializeImplicitFlutterEngine(_ engineBridge: FlutterImplicitEngineBridge) {
|
||||
GeneratedPluginRegistrant.register(with: engineBridge.pluginRegistry)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -31,27 +31,6 @@
|
||||
</array>
|
||||
<key>LSRequiresIPhoneOS</key>
|
||||
<true/>
|
||||
<key>UIApplicationSceneManifest</key>
|
||||
<dict>
|
||||
<key>UIApplicationSupportsMultipleScenes</key>
|
||||
<false/>
|
||||
<key>UISceneConfigurations</key>
|
||||
<dict>
|
||||
<key>UIWindowSceneSessionRoleApplication</key>
|
||||
<array>
|
||||
<dict>
|
||||
<key>UISceneClassName</key>
|
||||
<string>UIWindowScene</string>
|
||||
<key>UISceneConfigurationName</key>
|
||||
<string>flutter</string>
|
||||
<key>UISceneDelegateClassName</key>
|
||||
<string>FlutterSceneDelegate</string>
|
||||
<key>UISceneStoryboardFile</key>
|
||||
<string>Main</string>
|
||||
</dict>
|
||||
</array>
|
||||
</dict>
|
||||
</dict>
|
||||
<key>UIApplicationSupportsIndirectInputEvents</key>
|
||||
<true/>
|
||||
<key>UILaunchStoryboardName</key>
|
||||
|
||||
@@ -1,45 +0,0 @@
|
||||
import 'package:flutter/cupertino.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
|
||||
/// Translates a [Ruleset] enum value to its corresponding localized string.
|
||||
String translateRulesetToString(Ruleset ruleset, BuildContext context) {
|
||||
final loc = AppLocalizations.of(context);
|
||||
switch (ruleset) {
|
||||
case Ruleset.highestScore:
|
||||
return loc.highest_score;
|
||||
case Ruleset.lowestScore:
|
||||
return loc.lowest_score;
|
||||
case Ruleset.singleWinner:
|
||||
return loc.single_winner;
|
||||
case Ruleset.singleLoser:
|
||||
return loc.single_loser;
|
||||
case Ruleset.multipleWinners:
|
||||
return loc.multiple_winners;
|
||||
}
|
||||
}
|
||||
|
||||
/// Counts how many players in the match are not part of the group
|
||||
/// Returns the count as a string, or an empty string if there is no group
|
||||
String getExtraPlayerCount(Match match) {
|
||||
int count = 0;
|
||||
|
||||
if (match.group == null) {
|
||||
return '';
|
||||
}
|
||||
|
||||
final groupMembers = match.group!.members;
|
||||
final players = match.players;
|
||||
|
||||
for (var player in players) {
|
||||
if (!groupMembers.any((member) => member.id == player.id)) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
if (count == 0) {
|
||||
return '';
|
||||
}
|
||||
return ' + ${count.toString()}';
|
||||
}
|
||||
@@ -13,13 +13,13 @@ class CustomTheme {
|
||||
static const Color secondaryColor = Color(0xFFf2a981);
|
||||
|
||||
/// Background color of the app theme
|
||||
static const Color backgroundColor = Color(0xFF0B0B0B);
|
||||
static const backgroundColor = Color(0xFF0B0B0B);
|
||||
|
||||
/// Default color for boxes and containers
|
||||
static const Color boxColor = Color(0xFF101010);
|
||||
|
||||
/// Default border color for boxes and containers
|
||||
static const Color boxBorderColor = Color(0xFF272727);
|
||||
static const Color boxBorder = Color(0xFF272727);
|
||||
|
||||
/// Color for boxes and containers displayed on boxes
|
||||
static const Color onBoxColor = Color(0xFF181818);
|
||||
@@ -27,12 +27,6 @@ class CustomTheme {
|
||||
/// Text color used throughout the app
|
||||
static const Color textColor = Color(0xFFFFFFFF);
|
||||
|
||||
/// Text color used throughout the app
|
||||
static const Color hintColor = Color(0xFF888888);
|
||||
|
||||
/// Background color for the navigation bar
|
||||
static const Color navBarBackgroundColor = Color(0xFF131313);
|
||||
|
||||
/// Selected color for the [NavbarItem]
|
||||
static Color navBarItemSelectedColor = primaryColor.withGreen(100);
|
||||
|
||||
@@ -57,7 +51,7 @@ class CustomTheme {
|
||||
// ==================== Decorations ====================
|
||||
static BoxDecoration standardBoxDecoration = BoxDecoration(
|
||||
color: boxColor,
|
||||
border: Border.all(color: boxBorderColor),
|
||||
border: Border.all(color: boxBorder),
|
||||
borderRadius: standardBorderRadiusAll,
|
||||
);
|
||||
|
||||
@@ -68,7 +62,7 @@ class CustomTheme {
|
||||
boxShadow: [BoxShadow(color: primaryColor.withAlpha(120), blurRadius: 12)],
|
||||
);
|
||||
|
||||
// ==================== Component Themes ====================
|
||||
// ==================== App Bar Theme ====================
|
||||
static const AppBarTheme appBarTheme = AppBarTheme(
|
||||
backgroundColor: backgroundColor,
|
||||
foregroundColor: textColor,
|
||||
@@ -83,23 +77,4 @@ class CustomTheme {
|
||||
),
|
||||
iconTheme: IconThemeData(color: textColor),
|
||||
);
|
||||
|
||||
static const SearchBarThemeData searchBarTheme = SearchBarThemeData(
|
||||
textStyle: WidgetStatePropertyAll(TextStyle(color: CustomTheme.textColor)),
|
||||
hintStyle: WidgetStatePropertyAll(TextStyle(color: CustomTheme.hintColor)),
|
||||
);
|
||||
|
||||
static final RadioThemeData radioTheme = RadioThemeData(
|
||||
fillColor: WidgetStateProperty.resolveWith<Color>((states) {
|
||||
if (states.contains(WidgetState.selected)) {
|
||||
return CustomTheme.primaryColor;
|
||||
}
|
||||
return CustomTheme.textColor;
|
||||
}),
|
||||
);
|
||||
|
||||
static const InputDecorationTheme inputDecorationTheme = InputDecorationTheme(
|
||||
labelStyle: TextStyle(color: CustomTheme.textColor),
|
||||
hintStyle: TextStyle(color: CustomTheme.hintColor),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,3 +1,6 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
|
||||
/// Button types used for styling the [CustomWidthButton]
|
||||
/// - [ButtonType.primary]: Primary button style.
|
||||
/// - [ButtonType.secondary]: Secondary button style.
|
||||
@@ -26,27 +29,24 @@ enum ImportResult {
|
||||
/// - [ExportResult.unknownException]: An exception occurred during export.
|
||||
enum ExportResult { success, canceled, unknownException }
|
||||
|
||||
/// Different rulesets available for games
|
||||
/// - [Ruleset.highestScore]: The player with the highest score wins.
|
||||
/// - [Ruleset.lowestScore]: The player with the lowest score wins.
|
||||
/// - [Ruleset.singleWinner]: The match is won by a single player.
|
||||
/// - [Ruleset.singleLoser]: The match has a single loser.
|
||||
/// - [Ruleset.multipleWinners]: Multiple players can be winners.
|
||||
enum Ruleset {
|
||||
highestScore,
|
||||
lowestScore,
|
||||
singleWinner,
|
||||
singleLoser,
|
||||
multipleWinners,
|
||||
}
|
||||
/// Different rulesets available for matches
|
||||
/// - [Ruleset.singleWinner]: The match is won by a single player
|
||||
/// - [Ruleset.singleLoser]: The match is lost by a single player
|
||||
/// - [Ruleset.mostPoints]: The player with the most points wins.
|
||||
/// - [Ruleset.leastPoints]: The player with the fewest points wins.
|
||||
enum Ruleset { singleWinner, singleLoser, mostPoints, leastPoints }
|
||||
|
||||
/// Different colors available for games
|
||||
/// - [GameColor.red]: Red color
|
||||
/// - [GameColor.blue]: Blue color
|
||||
/// - [GameColor.green]: Green color
|
||||
/// - [GameColor.yellow]: Yellow color
|
||||
/// - [GameColor.purple]: Purple color
|
||||
/// - [GameColor.orange]: Orange color
|
||||
/// - [GameColor.pink]: Pink color
|
||||
/// - [GameColor.teal]: Teal color
|
||||
enum GameColor { red, blue, green, yellow, purple, orange, pink, teal }
|
||||
/// Translates a [Ruleset] enum value to its corresponding localized string.
|
||||
String translateRulesetToString(Ruleset ruleset, BuildContext context) {
|
||||
final loc = AppLocalizations.of(context);
|
||||
switch (ruleset) {
|
||||
case Ruleset.singleWinner:
|
||||
return loc.single_winner;
|
||||
case Ruleset.singleLoser:
|
||||
return loc.single_loser;
|
||||
case Ruleset.mostPoints:
|
||||
return loc.most_points;
|
||||
case Ruleset.leastPoints:
|
||||
return loc.least_points;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,179 +0,0 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/db/tables/game_table.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
|
||||
part 'game_dao.g.dart';
|
||||
|
||||
@DriftAccessor(tables: [GameTable])
|
||||
class GameDao extends DatabaseAccessor<AppDatabase> with _$GameDaoMixin {
|
||||
GameDao(super.db);
|
||||
|
||||
/// Retrieves all games from the database.
|
||||
Future<List<Game>> getAllGames() async {
|
||||
final query = select(gameTable);
|
||||
final result = await query.get();
|
||||
return result
|
||||
.map(
|
||||
(row) => Game(
|
||||
id: row.id,
|
||||
name: row.name,
|
||||
ruleset: Ruleset.values.firstWhere((e) => e.name == row.ruleset),
|
||||
description: row.description,
|
||||
color: GameColor.values.firstWhere((e) => e.name == row.color),
|
||||
icon: row.icon,
|
||||
createdAt: row.createdAt,
|
||||
),
|
||||
)
|
||||
.toList();
|
||||
}
|
||||
|
||||
/// Retrieves a [Game] by its [gameId].
|
||||
Future<Game> getGameById({required 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,
|
||||
ruleset: Ruleset.values.firstWhere((e) => e.name == result.ruleset),
|
||||
description: result.description,
|
||||
color: GameColor.values.firstWhere((e) => e.name == result.color),
|
||||
icon: result.icon,
|
||||
createdAt: result.createdAt,
|
||||
);
|
||||
}
|
||||
|
||||
/// Adds a new [game] to the database.
|
||||
/// If a game with the same ID already exists, no action is taken.
|
||||
/// Returns `true` if the game was added, `false` otherwise.
|
||||
Future<bool> addGame({required Game game}) async {
|
||||
if (!await gameExists(gameId: game.id)) {
|
||||
await into(gameTable).insert(
|
||||
GameTableCompanion.insert(
|
||||
id: game.id,
|
||||
name: game.name,
|
||||
ruleset: game.ruleset.name,
|
||||
description: game.description,
|
||||
color: game.color.name,
|
||||
icon: game.icon,
|
||||
createdAt: game.createdAt,
|
||||
),
|
||||
mode: InsertMode.insertOrReplace,
|
||||
);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/// Adds multiple [games] to the database in a batch operation.
|
||||
/// Uses insertOrIgnore to avoid overwriting existing games.
|
||||
Future<bool> addGamesAsList({required List<Game> games}) async {
|
||||
if (games.isEmpty) return false;
|
||||
|
||||
await db.batch(
|
||||
(b) => b.insertAll(
|
||||
gameTable,
|
||||
games
|
||||
.map(
|
||||
(game) => GameTableCompanion.insert(
|
||||
id: game.id,
|
||||
name: game.name,
|
||||
ruleset: game.ruleset.name,
|
||||
description: game.description,
|
||||
color: game.color.name,
|
||||
icon: game.icon,
|
||||
createdAt: game.createdAt,
|
||||
),
|
||||
)
|
||||
.toList(),
|
||||
mode: InsertMode.insertOrIgnore,
|
||||
),
|
||||
);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/// Deletes the game with the given [gameId] from the database.
|
||||
/// Returns `true` if the game was deleted, `false` if the game did not exist.
|
||||
Future<bool> deleteGame({required String gameId}) async {
|
||||
final query = delete(gameTable)..where((g) => g.id.equals(gameId));
|
||||
final rowsAffected = await query.go();
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Checks if a game with the given [gameId] exists in the database.
|
||||
/// Returns `true` if the game exists, `false` otherwise.
|
||||
Future<bool> gameExists({required String gameId}) async {
|
||||
final query = select(gameTable)..where((g) => g.id.equals(gameId));
|
||||
final result = await query.getSingleOrNull();
|
||||
return result != null;
|
||||
}
|
||||
|
||||
/// Updates the name of the game with the given [gameId] to [newName].
|
||||
Future<void> updateGameName({
|
||||
required String gameId,
|
||||
required String newName,
|
||||
}) async {
|
||||
await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
|
||||
GameTableCompanion(name: Value(newName)),
|
||||
);
|
||||
}
|
||||
|
||||
/// Updates the ruleset of the game with the given [gameId].
|
||||
Future<void> updateGameRuleset({
|
||||
required String gameId,
|
||||
required Ruleset newRuleset,
|
||||
}) async {
|
||||
await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
|
||||
GameTableCompanion(ruleset: Value(newRuleset.name)),
|
||||
);
|
||||
}
|
||||
|
||||
/// Updates the description of the game with the given [gameId].
|
||||
Future<void> updateGameDescription({
|
||||
required String gameId,
|
||||
required String newDescription,
|
||||
}) async {
|
||||
await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
|
||||
GameTableCompanion(description: Value(newDescription)),
|
||||
);
|
||||
}
|
||||
|
||||
/// Updates the color of the game with the given [gameId].
|
||||
Future<void> updateGameColor({
|
||||
required String gameId,
|
||||
required GameColor newColor,
|
||||
}) async {
|
||||
await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
|
||||
GameTableCompanion(color: Value(newColor.name)),
|
||||
);
|
||||
}
|
||||
|
||||
/// Updates the icon of the game with the given [gameId].
|
||||
Future<void> updateGameIcon({
|
||||
required String gameId,
|
||||
required String newIcon,
|
||||
}) async {
|
||||
await (update(gameTable)..where((g) => g.id.equals(gameId))).write(
|
||||
GameTableCompanion(icon: Value(newIcon)),
|
||||
);
|
||||
}
|
||||
|
||||
/// Retrieves the total count of games in the database.
|
||||
Future<int> getGameCount() async {
|
||||
final count =
|
||||
await (selectOnly(gameTable)..addColumns([gameTable.id.count()]))
|
||||
.map((row) => row.read(gameTable.id.count()))
|
||||
.getSingle();
|
||||
return count ?? 0;
|
||||
}
|
||||
|
||||
/// Deletes all games from the database.
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> deleteAllGames() async {
|
||||
final query = delete(gameTable);
|
||||
final rowsAffected = await query.go();
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
// GENERATED CODE - DO NOT MODIFY BY HAND
|
||||
|
||||
part of 'game_dao.dart';
|
||||
|
||||
// ignore_for_file: type=lint
|
||||
mixin _$GameDaoMixin on DatabaseAccessor<AppDatabase> {
|
||||
$GameTableTable get gameTable => attachedDatabase.gameTable;
|
||||
GameDaoManager get managers => GameDaoManager(this);
|
||||
}
|
||||
|
||||
class GameDaoManager {
|
||||
final _$GameDaoMixin _db;
|
||||
GameDaoManager(this._db);
|
||||
$$GameTableTableTableManager get gameTable =>
|
||||
$$GameTableTableTableManager(_db.attachedDatabase, _db.gameTable);
|
||||
}
|
||||
@@ -1,14 +1,13 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/db/tables/group_table.dart';
|
||||
import 'package:tallee/data/db/tables/match_table.dart';
|
||||
import 'package:tallee/data/db/tables/player_group_table.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
part 'group_dao.g.dart';
|
||||
|
||||
@DriftAccessor(tables: [GroupTable, PlayerGroupTable, MatchTable])
|
||||
@DriftAccessor(tables: [GroupTable, PlayerGroupTable])
|
||||
class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
|
||||
GroupDao(super.db);
|
||||
|
||||
@@ -24,7 +23,6 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
|
||||
return Group(
|
||||
id: groupData.id,
|
||||
name: groupData.name,
|
||||
description: groupData.description,
|
||||
members: members,
|
||||
createdAt: groupData.createdAt,
|
||||
);
|
||||
@@ -44,7 +42,6 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
|
||||
return Group(
|
||||
id: result.id,
|
||||
name: result.name,
|
||||
description: result.description,
|
||||
members: members,
|
||||
createdAt: result.createdAt,
|
||||
);
|
||||
@@ -59,7 +56,6 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
|
||||
GroupTableCompanion.insert(
|
||||
id: group.id,
|
||||
name: group.name,
|
||||
description: group.description,
|
||||
createdAt: group.createdAt,
|
||||
),
|
||||
mode: InsertMode.insertOrReplace,
|
||||
@@ -109,7 +105,6 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
|
||||
(group) => GroupTableCompanion.insert(
|
||||
id: group.id,
|
||||
name: group.name,
|
||||
description: group.description,
|
||||
createdAt: group.createdAt,
|
||||
),
|
||||
)
|
||||
@@ -137,7 +132,6 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
|
||||
(p) => PlayerTableCompanion.insert(
|
||||
id: p.id,
|
||||
name: p.name,
|
||||
description: p.description,
|
||||
createdAt: p.createdAt,
|
||||
),
|
||||
)
|
||||
@@ -182,7 +176,7 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
|
||||
|
||||
/// Updates the name of the group with the given [id] to [newName].
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> updateGroupName({
|
||||
Future<bool> updateGroupname({
|
||||
required String groupId,
|
||||
required String newName,
|
||||
}) async {
|
||||
@@ -193,19 +187,6 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Updates the description of the group with the given [groupId] to [newDescription].
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> updateGroupDescription({
|
||||
required String groupId,
|
||||
required String newDescription,
|
||||
}) async {
|
||||
final rowsAffected =
|
||||
await (update(groupTable)..where((g) => g.id.equals(groupId))).write(
|
||||
GroupTableCompanion(description: Value(newDescription)),
|
||||
);
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Retrieves the number of groups in the database.
|
||||
Future<int> getGroupCount() async {
|
||||
final count =
|
||||
@@ -230,48 +211,4 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
|
||||
final rowsAffected = await query.go();
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Replaces all players in a group with the provided list of players.
|
||||
/// Removes all existing players from the group and adds the new players.
|
||||
/// Also adds any new players to the player table if they don't exist.
|
||||
/// Returns `true` if the group exists and players were replaced, `false` otherwise.
|
||||
Future<bool> replaceGroupPlayers({
|
||||
required String groupId,
|
||||
required List<Player> newPlayers,
|
||||
}) async {
|
||||
if (!await groupExists(groupId: groupId)) return false;
|
||||
|
||||
await db.transaction(() async {
|
||||
// Remove all existing players from the group
|
||||
final deleteQuery = delete(db.playerGroupTable)
|
||||
..where((p) => p.groupId.equals(groupId));
|
||||
await deleteQuery.go();
|
||||
|
||||
// Add new players to the player table if they don't exist
|
||||
await Future.wait(
|
||||
newPlayers.map((player) async {
|
||||
if (!await db.playerDao.playerExists(playerId: player.id)) {
|
||||
await db.playerDao.addPlayer(player: player);
|
||||
}
|
||||
}),
|
||||
);
|
||||
|
||||
// Add the new players to the group
|
||||
await db.batch(
|
||||
(b) => b.insertAll(
|
||||
db.playerGroupTable,
|
||||
newPlayers
|
||||
.map(
|
||||
(player) => PlayerGroupTableCompanion.insert(
|
||||
playerId: player.id,
|
||||
groupId: groupId,
|
||||
),
|
||||
)
|
||||
.toList(),
|
||||
mode: InsertMode.insertOrReplace,
|
||||
),
|
||||
);
|
||||
});
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,25 +8,4 @@ mixin _$GroupDaoMixin on DatabaseAccessor<AppDatabase> {
|
||||
$PlayerTableTable get playerTable => attachedDatabase.playerTable;
|
||||
$PlayerGroupTableTable get playerGroupTable =>
|
||||
attachedDatabase.playerGroupTable;
|
||||
$GameTableTable get gameTable => attachedDatabase.gameTable;
|
||||
$MatchTableTable get matchTable => attachedDatabase.matchTable;
|
||||
GroupDaoManager get managers => GroupDaoManager(this);
|
||||
}
|
||||
|
||||
class GroupDaoManager {
|
||||
final _$GroupDaoMixin _db;
|
||||
GroupDaoManager(this._db);
|
||||
$$GroupTableTableTableManager get groupTable =>
|
||||
$$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
|
||||
$$PlayerTableTableTableManager get playerTable =>
|
||||
$$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
|
||||
$$PlayerGroupTableTableTableManager get playerGroupTable =>
|
||||
$$PlayerGroupTableTableTableManager(
|
||||
_db.attachedDatabase,
|
||||
_db.playerGroupTable,
|
||||
);
|
||||
$$GameTableTableTableManager get gameTable =>
|
||||
$$GameTableTableTableManager(_db.attachedDatabase, _db.gameTable);
|
||||
$$MatchTableTableTableManager get matchTable =>
|
||||
$$MatchTableTableTableManager(_db.attachedDatabase, _db.matchTable);
|
||||
}
|
||||
|
||||
98
lib/data/dao/group_match_dao.dart
Normal file
98
lib/data/dao/group_match_dao.dart
Normal file
@@ -0,0 +1,98 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/db/tables/group_match_table.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
|
||||
part 'group_match_dao.g.dart';
|
||||
|
||||
@DriftAccessor(tables: [GroupMatchTable])
|
||||
class GroupMatchDao extends DatabaseAccessor<AppDatabase>
|
||||
with _$GroupMatchDaoMixin {
|
||||
GroupMatchDao(super.db);
|
||||
|
||||
/// Associates a group with a match by inserting a record into the
|
||||
/// [GroupMatchTable].
|
||||
Future<void> addGroupToMatch({
|
||||
required String matchId,
|
||||
required String groupId,
|
||||
}) async {
|
||||
if (await matchHasGroup(matchId: matchId)) {
|
||||
throw Exception('Match already has a group');
|
||||
}
|
||||
await into(groupMatchTable).insert(
|
||||
GroupMatchTableCompanion.insert(groupId: groupId, matchId: matchId),
|
||||
mode: InsertMode.insertOrIgnore,
|
||||
);
|
||||
}
|
||||
|
||||
/// Retrieves the [Group] associated with the given [matchId].
|
||||
/// Returns `null` if no group is found.
|
||||
Future<Group?> getGroupOfMatch({required String matchId}) async {
|
||||
final result = await (select(
|
||||
groupMatchTable,
|
||||
)..where((g) => g.matchId.equals(matchId))).getSingleOrNull();
|
||||
|
||||
if (result == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
final group = await db.groupDao.getGroupById(groupId: result.groupId);
|
||||
return group;
|
||||
}
|
||||
|
||||
/// Checks if there is a group associated with the given [matchId].
|
||||
/// Returns `true` if there is a group, otherwise `false`.
|
||||
Future<bool> matchHasGroup({required String matchId}) async {
|
||||
final count =
|
||||
await (selectOnly(groupMatchTable)
|
||||
..where(groupMatchTable.matchId.equals(matchId))
|
||||
..addColumns([groupMatchTable.groupId.count()]))
|
||||
.map((row) => row.read(groupMatchTable.groupId.count()))
|
||||
.getSingle();
|
||||
return (count ?? 0) > 0;
|
||||
}
|
||||
|
||||
/// Checks if a specific group is associated with a specific match.
|
||||
/// Returns `true` if the group is in the match, otherwise `false`.
|
||||
Future<bool> isGroupInMatch({
|
||||
required String matchId,
|
||||
required String groupId,
|
||||
}) async {
|
||||
final count =
|
||||
await (selectOnly(groupMatchTable)
|
||||
..where(
|
||||
groupMatchTable.matchId.equals(matchId) &
|
||||
groupMatchTable.groupId.equals(groupId),
|
||||
)
|
||||
..addColumns([groupMatchTable.groupId.count()]))
|
||||
.map((row) => row.read(groupMatchTable.groupId.count()))
|
||||
.getSingle();
|
||||
return (count ?? 0) > 0;
|
||||
}
|
||||
|
||||
/// Removes the association of a group from a match based on [groupId] and
|
||||
/// [matchId].
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> removeGroupFromMatch({
|
||||
required String matchId,
|
||||
required String groupId,
|
||||
}) async {
|
||||
final query = delete(groupMatchTable)
|
||||
..where((g) => g.matchId.equals(matchId) & g.groupId.equals(groupId));
|
||||
final rowsAffected = await query.go();
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Updates the group associated with a match to [newGroupId] based on
|
||||
/// [matchId].
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> updateGroupOfMatch({
|
||||
required String matchId,
|
||||
required String newGroupId,
|
||||
}) async {
|
||||
final updatedRows =
|
||||
await (update(groupMatchTable)..where((g) => g.matchId.equals(matchId)))
|
||||
.write(GroupMatchTableCompanion(groupId: Value(newGroupId)));
|
||||
return updatedRows > 0;
|
||||
}
|
||||
}
|
||||
10
lib/data/dao/group_match_dao.g.dart
Normal file
10
lib/data/dao/group_match_dao.g.dart
Normal file
@@ -0,0 +1,10 @@
|
||||
// GENERATED CODE - DO NOT MODIFY BY HAND
|
||||
|
||||
part of 'group_match_dao.dart';
|
||||
|
||||
// ignore_for_file: type=lint
|
||||
mixin _$GroupMatchDaoMixin on DatabaseAccessor<AppDatabase> {
|
||||
$GroupTableTable get groupTable => attachedDatabase.groupTable;
|
||||
$MatchTableTable get matchTable => attachedDatabase.matchTable;
|
||||
$GroupMatchTableTable get groupMatchTable => attachedDatabase.groupMatchTable;
|
||||
}
|
||||
@@ -1,17 +1,13 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/db/tables/game_table.dart';
|
||||
import 'package:tallee/data/db/tables/group_table.dart';
|
||||
import 'package:tallee/data/db/tables/match_table.dart';
|
||||
import 'package:tallee/data/db/tables/player_match_table.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
part 'match_dao.g.dart';
|
||||
|
||||
@DriftAccessor(tables: [MatchTable, GameTable, GroupTable, PlayerMatchTable])
|
||||
@DriftAccessor(tables: [MatchTable])
|
||||
class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
MatchDao(super.db);
|
||||
|
||||
@@ -22,29 +18,19 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
|
||||
return Future.wait(
|
||||
result.map((row) async {
|
||||
final game = await db.gameDao.getGameById(gameId: row.gameId);
|
||||
Group? group;
|
||||
if (row.groupId != null) {
|
||||
group = await db.groupDao.getGroupById(groupId: row.groupId!);
|
||||
}
|
||||
final players =
|
||||
await db.playerMatchDao.getPlayersOfMatch(matchId: row.id) ?? [];
|
||||
|
||||
final scores = await db.scoreEntryDao.getAllMatchScores(
|
||||
final group = await db.groupMatchDao.getGroupOfMatch(matchId: row.id);
|
||||
final players = await db.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: row.id,
|
||||
);
|
||||
|
||||
final winner = await db.scoreEntryDao.getWinner(matchId: row.id);
|
||||
final winner = row.winnerId != null
|
||||
? await db.playerDao.getPlayerById(playerId: row.winnerId!)
|
||||
: null;
|
||||
return Match(
|
||||
id: row.id,
|
||||
name: row.name,
|
||||
game: game,
|
||||
group: group,
|
||||
players: players,
|
||||
notes: row.notes ?? '',
|
||||
createdAt: row.createdAt,
|
||||
endedAt: row.endedAt,
|
||||
scores: scores,
|
||||
winner: winner,
|
||||
);
|
||||
}),
|
||||
@@ -56,131 +42,69 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
final query = select(matchTable)..where((g) => g.id.equals(matchId));
|
||||
final result = await query.getSingle();
|
||||
|
||||
final game = await db.gameDao.getGameById(gameId: result.gameId);
|
||||
|
||||
Group? group;
|
||||
if (result.groupId != null) {
|
||||
group = await db.groupDao.getGroupById(groupId: result.groupId!);
|
||||
List<Player>? players;
|
||||
if (await db.playerMatchDao.matchHasPlayers(matchId: matchId)) {
|
||||
players = await db.playerMatchDao.getPlayersOfMatch(matchId: matchId);
|
||||
}
|
||||
Group? group;
|
||||
if (await db.groupMatchDao.matchHasGroup(matchId: matchId)) {
|
||||
group = await db.groupMatchDao.getGroupOfMatch(matchId: matchId);
|
||||
}
|
||||
Player? winner;
|
||||
if (result.winnerId != null) {
|
||||
winner = await db.playerDao.getPlayerById(playerId: result.winnerId!);
|
||||
}
|
||||
|
||||
final players =
|
||||
await db.playerMatchDao.getPlayersOfMatch(matchId: matchId) ?? [];
|
||||
|
||||
final scores = await db.scoreEntryDao.getAllMatchScores(matchId: matchId);
|
||||
|
||||
final winner = await db.scoreEntryDao.getWinner(matchId: matchId);
|
||||
|
||||
return Match(
|
||||
id: result.id,
|
||||
name: result.name,
|
||||
game: game,
|
||||
group: group,
|
||||
players: players,
|
||||
notes: result.notes ?? '',
|
||||
createdAt: result.createdAt,
|
||||
endedAt: result.endedAt,
|
||||
scores: scores,
|
||||
group: group,
|
||||
winner: winner,
|
||||
createdAt: result.createdAt,
|
||||
);
|
||||
}
|
||||
|
||||
/// Adds a new [Match] to the database. Also adds players associations.
|
||||
/// This method assumes that the game and group (if any) are already present
|
||||
/// in the database.
|
||||
/// Adds a new [Match] to the database. Also adds players and group
|
||||
/// associations. This method assumes that the players and groups added to
|
||||
/// this match are already present in the database.
|
||||
Future<void> addMatch({required Match match}) async {
|
||||
await db.transaction(() async {
|
||||
await into(matchTable).insert(
|
||||
MatchTableCompanion.insert(
|
||||
id: match.id,
|
||||
gameId: match.game.id,
|
||||
groupId: Value(match.group?.id),
|
||||
name: match.name,
|
||||
notes: Value(match.notes),
|
||||
winnerId: Value(match.winner?.id),
|
||||
createdAt: match.createdAt,
|
||||
endedAt: Value(match.endedAt),
|
||||
),
|
||||
mode: InsertMode.insertOrReplace,
|
||||
);
|
||||
|
||||
for (final p in match.players) {
|
||||
if (match.players != null) {
|
||||
for (final p in match.players ?? []) {
|
||||
await db.playerMatchDao.addPlayerToMatch(
|
||||
matchId: match.id,
|
||||
playerId: p.id,
|
||||
);
|
||||
}
|
||||
|
||||
for (final pid in match.scores.keys) {
|
||||
final playerScores = match.scores[pid]!;
|
||||
await db.scoreEntryDao.addScoresAsList(
|
||||
entrys: playerScores,
|
||||
playerId: pid,
|
||||
matchId: match.id,
|
||||
);
|
||||
}
|
||||
|
||||
if (match.winner != null) {
|
||||
await db.scoreEntryDao.setWinner(
|
||||
if (match.group != null) {
|
||||
await db.groupMatchDao.addGroupToMatch(
|
||||
matchId: match.id,
|
||||
playerId: match.winner!.id,
|
||||
groupId: match.group!.id,
|
||||
);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Adds multiple [Match]es to the database in a batch operation.
|
||||
/// Adds multiple [Match]s to the database in a batch operation.
|
||||
/// Also adds associated players and groups if they exist.
|
||||
/// If the [matches] list is empty, the method returns immediately.
|
||||
/// This method should only be used to import matches from a different device.
|
||||
/// This Method should only be used to import matches from a different device.
|
||||
Future<void> addMatchAsList({required List<Match> matches}) async {
|
||||
if (matches.isEmpty) return;
|
||||
await db.transaction(() async {
|
||||
// Add all games first (deduplicated)
|
||||
final uniqueGames = <String, Game>{};
|
||||
for (final match in matches) {
|
||||
uniqueGames[match.game.id] = match.game;
|
||||
}
|
||||
|
||||
if (uniqueGames.isNotEmpty) {
|
||||
await db.batch(
|
||||
(b) => b.insertAll(
|
||||
db.gameTable,
|
||||
uniqueGames.values
|
||||
.map(
|
||||
(game) => GameTableCompanion.insert(
|
||||
id: game.id,
|
||||
name: game.name,
|
||||
ruleset: game.ruleset.name,
|
||||
description: game.description,
|
||||
color: game.color.name,
|
||||
icon: game.icon,
|
||||
createdAt: game.createdAt,
|
||||
),
|
||||
)
|
||||
.toList(),
|
||||
mode: InsertMode.insertOrIgnore,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
// Add all groups of the matches in batch
|
||||
await db.batch(
|
||||
(b) => b.insertAll(
|
||||
db.groupTable,
|
||||
matches
|
||||
.where((match) => match.group != null)
|
||||
.map(
|
||||
(match) => GroupTableCompanion.insert(
|
||||
id: match.group!.id,
|
||||
name: match.group!.name,
|
||||
description: match.group!.description,
|
||||
createdAt: match.group!.createdAt,
|
||||
),
|
||||
)
|
||||
.toList(),
|
||||
mode: InsertMode.insertOrIgnore,
|
||||
),
|
||||
);
|
||||
|
||||
// Add all matches in batch
|
||||
await db.batch(
|
||||
(b) => b.insertAll(
|
||||
@@ -189,12 +113,9 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
.map(
|
||||
(match) => MatchTableCompanion.insert(
|
||||
id: match.id,
|
||||
gameId: match.game.id,
|
||||
groupId: Value(match.group?.id),
|
||||
name: match.name,
|
||||
notes: Value(match.notes),
|
||||
createdAt: match.createdAt,
|
||||
endedAt: Value(match.endedAt),
|
||||
winnerId: Value(match.winner?.id),
|
||||
),
|
||||
)
|
||||
.toList(),
|
||||
@@ -202,12 +123,34 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
),
|
||||
);
|
||||
|
||||
// Add all groups of the matches in batch
|
||||
// Using insertOrIgnore to avoid overwriting existing groups (which would
|
||||
// trigger cascade deletes on player_group associations)
|
||||
await db.batch(
|
||||
(b) => b.insertAll(
|
||||
db.groupTable,
|
||||
matches
|
||||
.where((match) => match.group != null)
|
||||
.map(
|
||||
(matches) => GroupTableCompanion.insert(
|
||||
id: matches.group!.id,
|
||||
name: matches.group!.name,
|
||||
createdAt: matches.group!.createdAt,
|
||||
),
|
||||
)
|
||||
.toList(),
|
||||
mode: InsertMode.insertOrIgnore,
|
||||
),
|
||||
);
|
||||
|
||||
// Add all players of the matches in batch (unique)
|
||||
final uniquePlayers = <String, Player>{};
|
||||
for (final match in matches) {
|
||||
for (final p in match.players) {
|
||||
if (match.players != null) {
|
||||
for (final p in match.players!) {
|
||||
uniquePlayers[p.id] = p;
|
||||
}
|
||||
}
|
||||
// Also include members of groups
|
||||
if (match.group != null) {
|
||||
for (final m in match.group!.members) {
|
||||
@@ -217,6 +160,8 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
}
|
||||
|
||||
if (uniquePlayers.isNotEmpty) {
|
||||
// Using insertOrIgnore to avoid triggering cascade deletes on
|
||||
// player_group/player_match associations when players already exist
|
||||
await db.batch(
|
||||
(b) => b.insertAll(
|
||||
db.playerTable,
|
||||
@@ -225,7 +170,6 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
(p) => PlayerTableCompanion.insert(
|
||||
id: p.id,
|
||||
name: p.name,
|
||||
description: p.description,
|
||||
createdAt: p.createdAt,
|
||||
),
|
||||
)
|
||||
@@ -238,7 +182,8 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
// Add all player-match associations in batch
|
||||
await db.batch((b) {
|
||||
for (final match in matches) {
|
||||
for (final p in match.players) {
|
||||
if (match.players != null) {
|
||||
for (final p in match.players ?? []) {
|
||||
b.insert(
|
||||
db.playerMatchTable,
|
||||
PlayerMatchTableCompanion.insert(
|
||||
@@ -249,6 +194,7 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Add all player-group associations in batch
|
||||
@@ -268,6 +214,22 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Add all group-match associations in batch
|
||||
await db.batch((b) {
|
||||
for (final match in matches) {
|
||||
if (match.group != null) {
|
||||
b.insert(
|
||||
db.groupMatchTable,
|
||||
GroupMatchTableCompanion.insert(
|
||||
matchId: match.id,
|
||||
groupId: match.group!.id,
|
||||
),
|
||||
mode: InsertMode.insertOrIgnore,
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
@@ -288,34 +250,6 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
return count ?? 0;
|
||||
}
|
||||
|
||||
/// Retrieves all matches associated with the given [groupId].
|
||||
/// Queries the database directly, filtering by [groupId].
|
||||
Future<List<Match>> getGroupMatches({required String groupId}) async {
|
||||
final query = select(matchTable)..where((m) => m.groupId.equals(groupId));
|
||||
final rows = await query.get();
|
||||
|
||||
return Future.wait(
|
||||
rows.map((row) async {
|
||||
final game = await db.gameDao.getGameById(gameId: row.gameId);
|
||||
final group = await db.groupDao.getGroupById(groupId: groupId);
|
||||
final players =
|
||||
await db.playerMatchDao.getPlayersOfMatch(matchId: row.id) ?? [];
|
||||
final winner = await db.scoreEntryDao.getWinner(matchId: row.id);
|
||||
return Match(
|
||||
id: row.id,
|
||||
name: row.name,
|
||||
game: game,
|
||||
group: group,
|
||||
players: players,
|
||||
notes: row.notes ?? '',
|
||||
createdAt: row.createdAt,
|
||||
endedAt: row.endedAt,
|
||||
winner: winner,
|
||||
);
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
/// Checks if a match with the given [matchId] exists in the database.
|
||||
/// Returns `true` if the match exists, otherwise `false`.
|
||||
Future<bool> matchExists({required String matchId}) async {
|
||||
@@ -332,20 +266,52 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Updates the notes of the match with the given [matchId].
|
||||
/// Sets the winner of the match with the given [matchId] to the player with
|
||||
/// the given [winnerId].
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> updateMatchNotes({
|
||||
Future<bool> setWinner({
|
||||
required String matchId,
|
||||
required String? notes,
|
||||
required String winnerId,
|
||||
}) async {
|
||||
final query = update(matchTable)..where((g) => g.id.equals(matchId));
|
||||
final rowsAffected = await query.write(
|
||||
MatchTableCompanion(notes: Value(notes)),
|
||||
MatchTableCompanion(winnerId: Value(winnerId)),
|
||||
);
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Changes the name of the match with the given [matchId] to [newName].
|
||||
/// Retrieves the winner of the match with the given [matchId].
|
||||
/// Returns the [Player] who won the match, or `null` if no winner is set.
|
||||
Future<Player?> getWinner({required String matchId}) async {
|
||||
final query = select(matchTable)..where((g) => g.id.equals(matchId));
|
||||
final result = await query.getSingleOrNull();
|
||||
if (result == null || result.winnerId == null) {
|
||||
return null;
|
||||
}
|
||||
final winner = await db.playerDao.getPlayerById(playerId: result.winnerId!);
|
||||
return winner;
|
||||
}
|
||||
|
||||
/// Removes the winner of the match with the given [matchId].
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> removeWinner({required String matchId}) async {
|
||||
final query = update(matchTable)..where((g) => g.id.equals(matchId));
|
||||
final rowsAffected = await query.write(
|
||||
const MatchTableCompanion(winnerId: Value(null)),
|
||||
);
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Checks if the match with the given [matchId] has a winner set.
|
||||
/// Returns `true` if a winner is set, otherwise `false`.
|
||||
Future<bool> hasWinner({required String matchId}) async {
|
||||
final query = select(matchTable)
|
||||
..where((g) => g.id.equals(matchId) & g.winnerId.isNotNull());
|
||||
final result = await query.getSingleOrNull();
|
||||
return result != null;
|
||||
}
|
||||
|
||||
/// Changes the title of the match with the given [matchId] to [newName].
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> updateMatchName({
|
||||
required String matchId,
|
||||
@@ -357,104 +323,4 @@ class MatchDao extends DatabaseAccessor<AppDatabase> with _$MatchDaoMixin {
|
||||
);
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Updates the game of the match with the given [matchId].
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> updateMatchGame({
|
||||
required String matchId,
|
||||
required String gameId,
|
||||
}) async {
|
||||
final query = update(matchTable)..where((g) => g.id.equals(matchId));
|
||||
final rowsAffected = await query.write(
|
||||
MatchTableCompanion(gameId: Value(gameId)),
|
||||
);
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Updates the group of the match with the given [matchId].
|
||||
/// Replaces the existing group association with the new group specified by [newGroupId].
|
||||
/// Pass null to remove the group association.
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> updateMatchGroup({
|
||||
required String matchId,
|
||||
required String? newGroupId,
|
||||
}) async {
|
||||
final query = update(matchTable)..where((g) => g.id.equals(matchId));
|
||||
final rowsAffected = await query.write(
|
||||
MatchTableCompanion(groupId: Value(newGroupId)),
|
||||
);
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Removes the group association of the match with the given [matchId].
|
||||
/// Sets the groupId to null.
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> removeMatchGroup({required String matchId}) async {
|
||||
final query = update(matchTable)..where((g) => g.id.equals(matchId));
|
||||
final rowsAffected = await query.write(
|
||||
const MatchTableCompanion(groupId: Value(null)),
|
||||
);
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Updates the createdAt timestamp of the match with the given [matchId].
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> updateMatchCreatedAt({
|
||||
required String matchId,
|
||||
required DateTime createdAt,
|
||||
}) async {
|
||||
final query = update(matchTable)..where((g) => g.id.equals(matchId));
|
||||
final rowsAffected = await query.write(
|
||||
MatchTableCompanion(createdAt: Value(createdAt)),
|
||||
);
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Updates the endedAt timestamp of the match with the given [matchId].
|
||||
/// Pass null to remove the ended time (mark match as ongoing).
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> updateMatchEndedAt({
|
||||
required String matchId,
|
||||
required DateTime? endedAt,
|
||||
}) async {
|
||||
final query = update(matchTable)..where((g) => g.id.equals(matchId));
|
||||
final rowsAffected = await query.write(
|
||||
MatchTableCompanion(endedAt: Value(endedAt)),
|
||||
);
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Replaces all players in a match with the provided list of players.
|
||||
/// Removes all existing players from the match and adds the new players.
|
||||
/// Also adds any new players to the player table if they don't exist.
|
||||
Future<void> replaceMatchPlayers({
|
||||
required String matchId,
|
||||
required List<Player> newPlayers,
|
||||
}) async {
|
||||
await db.transaction(() async {
|
||||
// Remove all existing players from the match
|
||||
final deleteQuery = delete(db.playerMatchTable)
|
||||
..where((p) => p.matchId.equals(matchId));
|
||||
await deleteQuery.go();
|
||||
|
||||
// Add new players to the player table if they don't exist
|
||||
await Future.wait(
|
||||
newPlayers.map((player) async {
|
||||
if (!await db.playerDao.playerExists(playerId: player.id)) {
|
||||
await db.playerDao.addPlayer(player: player);
|
||||
}
|
||||
}),
|
||||
);
|
||||
|
||||
// Add the new players to the match
|
||||
await Future.wait(
|
||||
newPlayers.map(
|
||||
(player) => db.playerMatchDao.addPlayerToMatch(
|
||||
matchId: matchId,
|
||||
playerId: player.id,
|
||||
),
|
||||
),
|
||||
);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,32 +4,5 @@ part of 'match_dao.dart';
|
||||
|
||||
// ignore_for_file: type=lint
|
||||
mixin _$MatchDaoMixin on DatabaseAccessor<AppDatabase> {
|
||||
$GameTableTable get gameTable => attachedDatabase.gameTable;
|
||||
$GroupTableTable get groupTable => attachedDatabase.groupTable;
|
||||
$MatchTableTable get matchTable => attachedDatabase.matchTable;
|
||||
$PlayerTableTable get playerTable => attachedDatabase.playerTable;
|
||||
$TeamTableTable get teamTable => attachedDatabase.teamTable;
|
||||
$PlayerMatchTableTable get playerMatchTable =>
|
||||
attachedDatabase.playerMatchTable;
|
||||
MatchDaoManager get managers => MatchDaoManager(this);
|
||||
}
|
||||
|
||||
class MatchDaoManager {
|
||||
final _$MatchDaoMixin _db;
|
||||
MatchDaoManager(this._db);
|
||||
$$GameTableTableTableManager get gameTable =>
|
||||
$$GameTableTableTableManager(_db.attachedDatabase, _db.gameTable);
|
||||
$$GroupTableTableTableManager get groupTable =>
|
||||
$$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
|
||||
$$MatchTableTableTableManager get matchTable =>
|
||||
$$MatchTableTableTableManager(_db.attachedDatabase, _db.matchTable);
|
||||
$$PlayerTableTableTableManager get playerTable =>
|
||||
$$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
|
||||
$$TeamTableTableTableManager get teamTable =>
|
||||
$$TeamTableTableTableManager(_db.attachedDatabase, _db.teamTable);
|
||||
$$PlayerMatchTableTableTableManager get playerMatchTable =>
|
||||
$$PlayerMatchTableTableTableManager(
|
||||
_db.attachedDatabase,
|
||||
_db.playerMatchTable,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/db/tables/player_table.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
part 'player_dao.g.dart';
|
||||
|
||||
@@ -15,12 +15,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
|
||||
final result = await query.get();
|
||||
return result
|
||||
.map(
|
||||
(row) => Player(
|
||||
id: row.id,
|
||||
name: row.name,
|
||||
description: row.description,
|
||||
createdAt: row.createdAt,
|
||||
),
|
||||
(row) => Player(id: row.id, name: row.name, createdAt: row.createdAt),
|
||||
)
|
||||
.toList();
|
||||
}
|
||||
@@ -32,7 +27,6 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
|
||||
return Player(
|
||||
id: result.id,
|
||||
name: result.name,
|
||||
description: result.description,
|
||||
createdAt: result.createdAt,
|
||||
);
|
||||
}
|
||||
@@ -46,7 +40,6 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
|
||||
PlayerTableCompanion.insert(
|
||||
id: player.id,
|
||||
name: player.name,
|
||||
description: player.description,
|
||||
createdAt: player.createdAt,
|
||||
),
|
||||
mode: InsertMode.insertOrReplace,
|
||||
@@ -70,7 +63,6 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
|
||||
(player) => PlayerTableCompanion.insert(
|
||||
id: player.id,
|
||||
name: player.name,
|
||||
description: player.description,
|
||||
createdAt: player.createdAt,
|
||||
),
|
||||
)
|
||||
@@ -99,7 +91,7 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
|
||||
}
|
||||
|
||||
/// Updates the name of the player with the given [playerId] to [newName].
|
||||
Future<void> updatePlayerName({
|
||||
Future<void> updatePlayername({
|
||||
required String playerId,
|
||||
required String newName,
|
||||
}) async {
|
||||
|
||||
@@ -5,12 +5,4 @@ part of 'player_dao.dart';
|
||||
// ignore_for_file: type=lint
|
||||
mixin _$PlayerDaoMixin on DatabaseAccessor<AppDatabase> {
|
||||
$PlayerTableTable get playerTable => attachedDatabase.playerTable;
|
||||
PlayerDaoManager get managers => PlayerDaoManager(this);
|
||||
}
|
||||
|
||||
class PlayerDaoManager {
|
||||
final _$PlayerDaoMixin _db;
|
||||
PlayerDaoManager(this._db);
|
||||
$$PlayerTableTableTableManager get playerTable =>
|
||||
$$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@ import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/db/tables/player_group_table.dart';
|
||||
import 'package:tallee/data/db/tables/player_table.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
part 'player_group_dao.g.dart';
|
||||
|
||||
@@ -27,7 +27,7 @@ class PlayerGroupDao extends DatabaseAccessor<AppDatabase>
|
||||
}
|
||||
|
||||
if (!await db.playerDao.playerExists(playerId: player.id)) {
|
||||
await db.playerDao.addPlayer(player: player);
|
||||
db.playerDao.addPlayer(player: player);
|
||||
}
|
||||
|
||||
await into(playerGroupTable).insert(
|
||||
|
||||
@@ -8,19 +8,4 @@ mixin _$PlayerGroupDaoMixin on DatabaseAccessor<AppDatabase> {
|
||||
$GroupTableTable get groupTable => attachedDatabase.groupTable;
|
||||
$PlayerGroupTableTable get playerGroupTable =>
|
||||
attachedDatabase.playerGroupTable;
|
||||
PlayerGroupDaoManager get managers => PlayerGroupDaoManager(this);
|
||||
}
|
||||
|
||||
class PlayerGroupDaoManager {
|
||||
final _$PlayerGroupDaoMixin _db;
|
||||
PlayerGroupDaoManager(this._db);
|
||||
$$PlayerTableTableTableManager get playerTable =>
|
||||
$$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
|
||||
$$GroupTableTableTableManager get groupTable =>
|
||||
$$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
|
||||
$$PlayerGroupTableTableTableManager get playerGroupTable =>
|
||||
$$PlayerGroupTableTableTableManager(
|
||||
_db.attachedDatabase,
|
||||
_db.playerGroupTable,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,29 +1,23 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/db/tables/player_match_table.dart';
|
||||
import 'package:tallee/data/db/tables/team_table.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
part 'player_match_dao.g.dart';
|
||||
|
||||
@DriftAccessor(tables: [PlayerMatchTable, TeamTable])
|
||||
@DriftAccessor(tables: [PlayerMatchTable])
|
||||
class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
|
||||
with _$PlayerMatchDaoMixin {
|
||||
PlayerMatchDao(super.db);
|
||||
|
||||
/// Associates a player with a match by inserting a record into the
|
||||
/// [PlayerMatchTable]. Optionally associates with a team and sets initial score.
|
||||
/// [PlayerMatchTable].
|
||||
Future<void> addPlayerToMatch({
|
||||
required String matchId,
|
||||
required String playerId,
|
||||
String? teamId,
|
||||
}) async {
|
||||
await into(playerMatchTable).insert(
|
||||
PlayerMatchTableCompanion.insert(
|
||||
playerId: playerId,
|
||||
matchId: matchId,
|
||||
teamId: Value(teamId),
|
||||
),
|
||||
PlayerMatchTableCompanion.insert(playerId: playerId, matchId: matchId),
|
||||
mode: InsertMode.insertOrIgnore,
|
||||
);
|
||||
}
|
||||
@@ -44,21 +38,6 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
|
||||
return players;
|
||||
}
|
||||
|
||||
/// Updates the team for a player in a match.
|
||||
/// Returns `true` if the update was successful, otherwise `false`.
|
||||
Future<bool> updatePlayerTeam({
|
||||
required String matchId,
|
||||
required String playerId,
|
||||
required String? teamId,
|
||||
}) async {
|
||||
final rowsAffected =
|
||||
await (update(playerMatchTable)..where(
|
||||
(p) => p.matchId.equals(matchId) & p.playerId.equals(playerId),
|
||||
))
|
||||
.write(PlayerMatchTableCompanion(teamId: Value(teamId)));
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Checks if there are any players associated with the given [matchId].
|
||||
/// Returns `true` if there are players, otherwise `false`.
|
||||
Future<bool> matchHasPlayers({required String matchId}) async {
|
||||
@@ -117,7 +96,7 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
|
||||
final playersToAdd = newPlayerIdsSet.difference(currentPlayerIds);
|
||||
final playersToRemove = currentPlayerIds.difference(newPlayerIdsSet);
|
||||
|
||||
await db.transaction(() async {
|
||||
db.transaction(() async {
|
||||
// Remove old players
|
||||
if (playersToRemove.isNotEmpty) {
|
||||
await (delete(playerMatchTable)..where(
|
||||
@@ -148,21 +127,4 @@ class PlayerMatchDao extends DatabaseAccessor<AppDatabase>
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Retrieves all players in a specific team for a match.
|
||||
Future<List<Player>> getPlayersInTeam({
|
||||
required String matchId,
|
||||
required String teamId,
|
||||
}) async {
|
||||
final result = await (select(
|
||||
playerMatchTable,
|
||||
)..where((p) => p.matchId.equals(matchId) & p.teamId.equals(teamId))).get();
|
||||
|
||||
if (result.isEmpty) return [];
|
||||
|
||||
final futures = result.map(
|
||||
(row) => db.playerDao.getPlayerById(playerId: row.playerId),
|
||||
);
|
||||
return Future.wait(futures);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,31 +5,7 @@ part of 'player_match_dao.dart';
|
||||
// ignore_for_file: type=lint
|
||||
mixin _$PlayerMatchDaoMixin on DatabaseAccessor<AppDatabase> {
|
||||
$PlayerTableTable get playerTable => attachedDatabase.playerTable;
|
||||
$GameTableTable get gameTable => attachedDatabase.gameTable;
|
||||
$GroupTableTable get groupTable => attachedDatabase.groupTable;
|
||||
$MatchTableTable get matchTable => attachedDatabase.matchTable;
|
||||
$TeamTableTable get teamTable => attachedDatabase.teamTable;
|
||||
$PlayerMatchTableTable get playerMatchTable =>
|
||||
attachedDatabase.playerMatchTable;
|
||||
PlayerMatchDaoManager get managers => PlayerMatchDaoManager(this);
|
||||
}
|
||||
|
||||
class PlayerMatchDaoManager {
|
||||
final _$PlayerMatchDaoMixin _db;
|
||||
PlayerMatchDaoManager(this._db);
|
||||
$$PlayerTableTableTableManager get playerTable =>
|
||||
$$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
|
||||
$$GameTableTableTableManager get gameTable =>
|
||||
$$GameTableTableTableManager(_db.attachedDatabase, _db.gameTable);
|
||||
$$GroupTableTableTableManager get groupTable =>
|
||||
$$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
|
||||
$$MatchTableTableTableManager get matchTable =>
|
||||
$$MatchTableTableTableManager(_db.attachedDatabase, _db.matchTable);
|
||||
$$TeamTableTableTableManager get teamTable =>
|
||||
$$TeamTableTableTableManager(_db.attachedDatabase, _db.teamTable);
|
||||
$$PlayerMatchTableTableTableManager get playerMatchTable =>
|
||||
$$PlayerMatchTableTableTableManager(
|
||||
_db.attachedDatabase,
|
||||
_db.playerMatchTable,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,328 +0,0 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/db/tables/score_entry_table.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/models/score_entry.dart';
|
||||
|
||||
part 'score_entry_dao.g.dart';
|
||||
|
||||
@DriftAccessor(tables: [ScoreEntryTable])
|
||||
class ScoreEntryDao extends DatabaseAccessor<AppDatabase>
|
||||
with _$ScoreEntryDaoMixin {
|
||||
ScoreEntryDao(super.db);
|
||||
|
||||
/// Adds a score entry to the database.
|
||||
Future<void> addScore({
|
||||
required String playerId,
|
||||
required String matchId,
|
||||
required ScoreEntry entry,
|
||||
}) async {
|
||||
await into(scoreEntryTable).insert(
|
||||
ScoreEntryTableCompanion.insert(
|
||||
playerId: playerId,
|
||||
matchId: matchId,
|
||||
roundNumber: entry.roundNumber,
|
||||
score: entry.score,
|
||||
change: entry.change,
|
||||
),
|
||||
mode: InsertMode.insertOrReplace,
|
||||
);
|
||||
}
|
||||
|
||||
Future<void> addScoresAsList({
|
||||
required List<ScoreEntry> entrys,
|
||||
required String playerId,
|
||||
required String matchId,
|
||||
}) async {
|
||||
if (entrys.isEmpty) return;
|
||||
final entries = entrys
|
||||
.map(
|
||||
(score) => ScoreEntryTableCompanion.insert(
|
||||
playerId: playerId,
|
||||
matchId: matchId,
|
||||
roundNumber: score.roundNumber,
|
||||
score: score.score,
|
||||
change: score.change,
|
||||
),
|
||||
)
|
||||
.toList();
|
||||
|
||||
await batch((batch) {
|
||||
batch.insertAll(
|
||||
scoreEntryTable,
|
||||
entries,
|
||||
mode: InsertMode.insertOrReplace,
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
/// Retrieves the score for a specific round.
|
||||
Future<ScoreEntry?> getScore({
|
||||
required String playerId,
|
||||
required String matchId,
|
||||
int roundNumber = 0,
|
||||
}) async {
|
||||
final query = select(scoreEntryTable)
|
||||
..where(
|
||||
(s) =>
|
||||
s.playerId.equals(playerId) &
|
||||
s.matchId.equals(matchId) &
|
||||
s.roundNumber.equals(roundNumber),
|
||||
);
|
||||
|
||||
final result = await query.getSingleOrNull();
|
||||
if (result == null) return null;
|
||||
|
||||
return ScoreEntry(
|
||||
roundNumber: result.roundNumber,
|
||||
score: result.score,
|
||||
change: result.change,
|
||||
);
|
||||
}
|
||||
|
||||
/// Retrieves all scores for a specific match.
|
||||
Future<Map<String, List<ScoreEntry>>> getAllMatchScores({
|
||||
required String matchId,
|
||||
}) async {
|
||||
final query = select(scoreEntryTable)
|
||||
..where((s) => s.matchId.equals(matchId));
|
||||
final result = await query.get();
|
||||
|
||||
final Map<String, List<ScoreEntry>> scoresByPlayer = {};
|
||||
for (final row in result) {
|
||||
final score = ScoreEntry(
|
||||
roundNumber: row.roundNumber,
|
||||
score: row.score,
|
||||
change: row.change,
|
||||
);
|
||||
scoresByPlayer.putIfAbsent(row.playerId, () => []).add(score);
|
||||
}
|
||||
|
||||
return scoresByPlayer;
|
||||
}
|
||||
|
||||
/// Retrieves all scores for a specific player in a match.
|
||||
Future<List<ScoreEntry>> getAllPlayerScoresInMatch({
|
||||
required String playerId,
|
||||
required String matchId,
|
||||
}) async {
|
||||
final query = select(scoreEntryTable)
|
||||
..where((s) => s.playerId.equals(playerId) & s.matchId.equals(matchId))
|
||||
..orderBy([(s) => OrderingTerm.asc(s.roundNumber)]);
|
||||
final result = await query.get();
|
||||
return result
|
||||
.map(
|
||||
(row) => ScoreEntry(
|
||||
roundNumber: row.roundNumber,
|
||||
score: row.score,
|
||||
change: row.change,
|
||||
),
|
||||
)
|
||||
.toList()
|
||||
..sort(
|
||||
(scoreA, scoreB) => scoreA.roundNumber.compareTo(scoreB.roundNumber),
|
||||
);
|
||||
}
|
||||
|
||||
/// Updates a score entry.
|
||||
Future<bool> updateScore({
|
||||
required String playerId,
|
||||
required String matchId,
|
||||
required ScoreEntry newEntry,
|
||||
}) async {
|
||||
final rowsAffected =
|
||||
await (update(scoreEntryTable)..where(
|
||||
(s) =>
|
||||
s.playerId.equals(playerId) &
|
||||
s.matchId.equals(matchId) &
|
||||
s.roundNumber.equals(newEntry.roundNumber),
|
||||
))
|
||||
.write(
|
||||
ScoreEntryTableCompanion(
|
||||
score: Value(newEntry.score),
|
||||
change: Value(newEntry.change),
|
||||
),
|
||||
);
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Deletes a score entry.
|
||||
Future<bool> deleteScore({
|
||||
required String playerId,
|
||||
required String matchId,
|
||||
int roundNumber = 0,
|
||||
}) async {
|
||||
final query = delete(scoreEntryTable)
|
||||
..where(
|
||||
(s) =>
|
||||
s.playerId.equals(playerId) &
|
||||
s.matchId.equals(matchId) &
|
||||
s.roundNumber.equals(roundNumber),
|
||||
);
|
||||
final rowsAffected = await query.go();
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
Future<bool> deleteAllScoresForMatch({required String matchId}) async {
|
||||
final query = delete(scoreEntryTable)
|
||||
..where((s) => s.matchId.equals(matchId));
|
||||
final rowsAffected = await query.go();
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
Future<bool> deleteAllScoresForPlayerInMatch({
|
||||
required String matchId,
|
||||
required String playerId,
|
||||
}) async {
|
||||
final query = delete(scoreEntryTable)
|
||||
..where((s) => s.playerId.equals(playerId) & s.matchId.equals(matchId));
|
||||
final rowsAffected = await query.go();
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Gets the highest (latest) round number for a match.
|
||||
/// Returns `null` if there are no scores for the match.
|
||||
Future<int?> getLatestRoundNumber({required String matchId}) async {
|
||||
final query = selectOnly(scoreEntryTable)
|
||||
..where(scoreEntryTable.matchId.equals(matchId))
|
||||
..addColumns([scoreEntryTable.roundNumber.max()]);
|
||||
final result = await query.getSingle();
|
||||
return result.read(scoreEntryTable.roundNumber.max());
|
||||
}
|
||||
|
||||
/// Aggregates the total score for a player in a match by summing all their
|
||||
/// score entry changes. Returns `0` if there are no scores for the player
|
||||
/// in the match.
|
||||
Future<int> getTotalScoreForPlayer({
|
||||
required String playerId,
|
||||
required String matchId,
|
||||
}) async {
|
||||
final scores = await getAllPlayerScoresInMatch(
|
||||
playerId: playerId,
|
||||
matchId: matchId,
|
||||
);
|
||||
if (scores.isEmpty) return 0;
|
||||
// Return the sum of all score changes
|
||||
return scores.fold<int>(0, (sum, element) => sum + element.change);
|
||||
}
|
||||
|
||||
Future<bool> hasWinner({required String matchId}) async {
|
||||
return await getWinner(matchId: matchId) != null;
|
||||
}
|
||||
|
||||
// Setting the winner for a game and clearing previous winner if exists.
|
||||
Future<bool> setWinner({
|
||||
required String matchId,
|
||||
required String playerId,
|
||||
}) async {
|
||||
// Clear previous winner if exists
|
||||
deleteAllScoresForMatch(matchId: matchId);
|
||||
|
||||
// Set the winner's score to 1
|
||||
final rowsAffected = await into(scoreEntryTable).insert(
|
||||
ScoreEntryTableCompanion.insert(
|
||||
playerId: playerId,
|
||||
matchId: matchId,
|
||||
roundNumber: 0,
|
||||
score: 1,
|
||||
change: 0,
|
||||
),
|
||||
mode: InsertMode.insertOrReplace,
|
||||
);
|
||||
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
// Retrieves the winner of a match based on the highest score.
|
||||
Future<Player?> getWinner({required String matchId}) async {
|
||||
final query = select(scoreEntryTable)
|
||||
..where((s) => s.matchId.equals(matchId))
|
||||
..orderBy([(s) => OrderingTerm.desc(s.score)])
|
||||
..limit(1);
|
||||
final result = await query.getSingleOrNull();
|
||||
|
||||
if (result == null) return null;
|
||||
|
||||
final player = await db.playerDao.getPlayerById(playerId: result.playerId);
|
||||
return Player(
|
||||
id: player.id,
|
||||
name: player.name,
|
||||
createdAt: player.createdAt,
|
||||
description: player.description,
|
||||
);
|
||||
}
|
||||
|
||||
/// Removes the winner of a match.
|
||||
///
|
||||
/// Returns `true` if the winner was removed, `false` if there are multiple
|
||||
/// scores or if the winner cannot be removed.
|
||||
Future<bool> removeWinner({required String matchId}) async {
|
||||
final scores = await getAllMatchScores(matchId: matchId);
|
||||
|
||||
if (scores.length > 1) {
|
||||
return false;
|
||||
} else {
|
||||
return await deleteAllScoresForMatch(matchId: matchId);
|
||||
}
|
||||
}
|
||||
|
||||
Future<bool> hasLooser({required String matchId}) async {
|
||||
return await getLooser(matchId: matchId) != null;
|
||||
}
|
||||
|
||||
// Setting the looser for a game and clearing previous looser if exists.
|
||||
Future<bool> setLooser({
|
||||
required String matchId,
|
||||
required String playerId,
|
||||
}) async {
|
||||
// Clear previous loosers if exists
|
||||
deleteAllScoresForMatch(matchId: matchId);
|
||||
|
||||
// Set the loosers score to 0
|
||||
final rowsAffected = await into(scoreEntryTable).insert(
|
||||
ScoreEntryTableCompanion.insert(
|
||||
playerId: playerId,
|
||||
matchId: matchId,
|
||||
roundNumber: 0,
|
||||
score: 0,
|
||||
change: 0,
|
||||
),
|
||||
mode: InsertMode.insertOrReplace,
|
||||
);
|
||||
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Retrieves the looser of a match based on the score 0.
|
||||
Future<Player?> getLooser({required String matchId}) async {
|
||||
final query = select(scoreEntryTable)
|
||||
..where((s) => s.matchId.equals(matchId) & s.score.equals(0));
|
||||
final result = await query.getSingleOrNull();
|
||||
|
||||
if (result == null) return null;
|
||||
|
||||
final player = await db.playerDao.getPlayerById(playerId: result.playerId);
|
||||
return Player(
|
||||
id: player.id,
|
||||
name: player.name,
|
||||
createdAt: player.createdAt,
|
||||
description: player.description,
|
||||
);
|
||||
}
|
||||
|
||||
/// Removes the looser of a match.
|
||||
///
|
||||
/// Returns `true` if the looser was removed, `false` if there are multiple
|
||||
/// scores or if the looser cannot be removed.
|
||||
Future<bool> removeLooser({required String matchId}) async {
|
||||
final scores = await getAllMatchScores(matchId: matchId);
|
||||
|
||||
if (scores.length > 1) {
|
||||
return false;
|
||||
} else {
|
||||
return await deleteAllScoresForMatch(matchId: matchId);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
// GENERATED CODE - DO NOT MODIFY BY HAND
|
||||
|
||||
part of 'score_entry_dao.dart';
|
||||
|
||||
// ignore_for_file: type=lint
|
||||
mixin _$ScoreEntryDaoMixin on DatabaseAccessor<AppDatabase> {
|
||||
$PlayerTableTable get playerTable => attachedDatabase.playerTable;
|
||||
$GameTableTable get gameTable => attachedDatabase.gameTable;
|
||||
$GroupTableTable get groupTable => attachedDatabase.groupTable;
|
||||
$MatchTableTable get matchTable => attachedDatabase.matchTable;
|
||||
$ScoreEntryTableTable get scoreEntryTable => attachedDatabase.scoreEntryTable;
|
||||
ScoreEntryDaoManager get managers => ScoreEntryDaoManager(this);
|
||||
}
|
||||
|
||||
class ScoreEntryDaoManager {
|
||||
final _$ScoreEntryDaoMixin _db;
|
||||
ScoreEntryDaoManager(this._db);
|
||||
$$PlayerTableTableTableManager get playerTable =>
|
||||
$$PlayerTableTableTableManager(_db.attachedDatabase, _db.playerTable);
|
||||
$$GameTableTableTableManager get gameTable =>
|
||||
$$GameTableTableTableManager(_db.attachedDatabase, _db.gameTable);
|
||||
$$GroupTableTableTableManager get groupTable =>
|
||||
$$GroupTableTableTableManager(_db.attachedDatabase, _db.groupTable);
|
||||
$$MatchTableTableTableManager get matchTable =>
|
||||
$$MatchTableTableTableManager(_db.attachedDatabase, _db.matchTable);
|
||||
$$ScoreEntryTableTableTableManager get scoreEntryTable =>
|
||||
$$ScoreEntryTableTableTableManager(
|
||||
_db.attachedDatabase,
|
||||
_db.scoreEntryTable,
|
||||
);
|
||||
}
|
||||
@@ -1,146 +0,0 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/db/tables/team_table.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/models/team.dart';
|
||||
|
||||
part 'team_dao.g.dart';
|
||||
|
||||
@DriftAccessor(tables: [TeamTable])
|
||||
class TeamDao extends DatabaseAccessor<AppDatabase> with _$TeamDaoMixin {
|
||||
TeamDao(super.db);
|
||||
|
||||
/// Retrieves all teams from the database.
|
||||
/// Note: This returns teams without their members. Use getTeamById for full team data.
|
||||
Future<List<Team>> getAllTeams() async {
|
||||
final query = select(teamTable);
|
||||
final result = await query.get();
|
||||
return Future.wait(
|
||||
result.map((row) async {
|
||||
final members = await _getTeamMembers(teamId: row.id);
|
||||
return Team(
|
||||
id: row.id,
|
||||
name: row.name,
|
||||
createdAt: row.createdAt,
|
||||
members: members,
|
||||
);
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
/// Retrieves a [Team] by its [teamId], including its members.
|
||||
Future<Team> getTeamById({required String teamId}) async {
|
||||
final query = select(teamTable)..where((t) => t.id.equals(teamId));
|
||||
final result = await query.getSingle();
|
||||
final members = await _getTeamMembers(teamId: teamId);
|
||||
return Team(
|
||||
id: result.id,
|
||||
name: result.name,
|
||||
createdAt: result.createdAt,
|
||||
members: members,
|
||||
);
|
||||
}
|
||||
|
||||
/// Helper method to get team members from player_match_table.
|
||||
/// This assumes team members are tracked via the player_match_table.
|
||||
Future<List<Player>> _getTeamMembers({required String teamId}) async {
|
||||
// Get all player_match entries with this teamId
|
||||
final playerMatchQuery = select(db.playerMatchTable)
|
||||
..where((pm) => pm.teamId.equals(teamId));
|
||||
final playerMatches = await playerMatchQuery.get();
|
||||
|
||||
if (playerMatches.isEmpty) return [];
|
||||
|
||||
// Get unique player IDs
|
||||
final playerIds = playerMatches.map((pm) => pm.playerId).toSet();
|
||||
|
||||
// Fetch all players
|
||||
final players = await Future.wait(
|
||||
playerIds.map((id) => db.playerDao.getPlayerById(playerId: id)),
|
||||
);
|
||||
return players;
|
||||
}
|
||||
|
||||
/// Adds a new [team] to the database.
|
||||
/// Returns `true` if the team was added, `false` otherwise.
|
||||
Future<bool> addTeam({required Team team}) async {
|
||||
if (!await teamExists(teamId: team.id)) {
|
||||
await into(teamTable).insert(
|
||||
TeamTableCompanion.insert(
|
||||
id: team.id,
|
||||
name: team.name,
|
||||
createdAt: team.createdAt,
|
||||
),
|
||||
mode: InsertMode.insertOrReplace,
|
||||
);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/// Adds multiple [teams] to the database in a batch operation.
|
||||
Future<bool> addTeamsAsList({required List<Team> teams}) async {
|
||||
if (teams.isEmpty) return false;
|
||||
|
||||
await db.batch(
|
||||
(b) => b.insertAll(
|
||||
teamTable,
|
||||
teams
|
||||
.map(
|
||||
(team) => TeamTableCompanion.insert(
|
||||
id: team.id,
|
||||
name: team.name,
|
||||
createdAt: team.createdAt,
|
||||
),
|
||||
)
|
||||
.toList(),
|
||||
mode: InsertMode.insertOrIgnore,
|
||||
),
|
||||
);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/// Deletes the team with the given [teamId] from the database.
|
||||
/// Returns `true` if the team was deleted, `false` otherwise.
|
||||
Future<bool> deleteTeam({required String teamId}) async {
|
||||
final query = delete(teamTable)..where((t) => t.id.equals(teamId));
|
||||
final rowsAffected = await query.go();
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
|
||||
/// Checks if a team with the given [teamId] exists in the database.
|
||||
/// Returns `true` if the team exists, `false` otherwise.
|
||||
Future<bool> teamExists({required String teamId}) async {
|
||||
final query = select(teamTable)..where((t) => t.id.equals(teamId));
|
||||
final result = await query.getSingleOrNull();
|
||||
return result != null;
|
||||
}
|
||||
|
||||
/// Updates the name of the team with the given [teamId].
|
||||
Future<void> updateTeamName({
|
||||
required String teamId,
|
||||
required String newName,
|
||||
}) async {
|
||||
await (update(teamTable)..where((t) => t.id.equals(teamId))).write(
|
||||
TeamTableCompanion(name: Value(newName)),
|
||||
);
|
||||
}
|
||||
|
||||
/// Retrieves the total count of teams in the database.
|
||||
Future<int> getTeamCount() async {
|
||||
final count =
|
||||
await (selectOnly(teamTable)..addColumns([teamTable.id.count()]))
|
||||
.map((row) => row.read(teamTable.id.count()))
|
||||
.getSingle();
|
||||
return count ?? 0;
|
||||
}
|
||||
|
||||
/// Deletes all teams from the database.
|
||||
/// Returns `true` if more than 0 rows were affected, otherwise `false`.
|
||||
Future<bool> deleteAllTeams() async {
|
||||
final query = delete(teamTable);
|
||||
final rowsAffected = await query.go();
|
||||
return rowsAffected > 0;
|
||||
}
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
// GENERATED CODE - DO NOT MODIFY BY HAND
|
||||
|
||||
part of 'team_dao.dart';
|
||||
|
||||
// ignore_for_file: type=lint
|
||||
mixin _$TeamDaoMixin on DatabaseAccessor<AppDatabase> {
|
||||
$TeamTableTable get teamTable => attachedDatabase.teamTable;
|
||||
TeamDaoManager get managers => TeamDaoManager(this);
|
||||
}
|
||||
|
||||
class TeamDaoManager {
|
||||
final _$TeamDaoMixin _db;
|
||||
TeamDaoManager(this._db);
|
||||
$$TeamTableTableTableManager get teamTable =>
|
||||
$$TeamTableTableTableManager(_db.attachedDatabase, _db.teamTable);
|
||||
}
|
||||
@@ -1,22 +1,18 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:drift_flutter/drift_flutter.dart';
|
||||
import 'package:path_provider/path_provider.dart';
|
||||
import 'package:tallee/data/dao/game_dao.dart';
|
||||
import 'package:tallee/data/dao/group_dao.dart';
|
||||
import 'package:tallee/data/dao/group_match_dao.dart';
|
||||
import 'package:tallee/data/dao/match_dao.dart';
|
||||
import 'package:tallee/data/dao/player_dao.dart';
|
||||
import 'package:tallee/data/dao/player_group_dao.dart';
|
||||
import 'package:tallee/data/dao/player_match_dao.dart';
|
||||
import 'package:tallee/data/dao/score_entry_dao.dart';
|
||||
import 'package:tallee/data/dao/team_dao.dart';
|
||||
import 'package:tallee/data/db/tables/game_table.dart';
|
||||
import 'package:tallee/data/db/tables/group_match_table.dart';
|
||||
import 'package:tallee/data/db/tables/group_table.dart';
|
||||
import 'package:tallee/data/db/tables/match_table.dart';
|
||||
import 'package:tallee/data/db/tables/player_group_table.dart';
|
||||
import 'package:tallee/data/db/tables/player_match_table.dart';
|
||||
import 'package:tallee/data/db/tables/player_table.dart';
|
||||
import 'package:tallee/data/db/tables/score_entry_table.dart';
|
||||
import 'package:tallee/data/db/tables/team_table.dart';
|
||||
|
||||
part 'database.g.dart';
|
||||
|
||||
@@ -27,9 +23,7 @@ part 'database.g.dart';
|
||||
MatchTable,
|
||||
PlayerGroupTable,
|
||||
PlayerMatchTable,
|
||||
GameTable,
|
||||
TeamTable,
|
||||
ScoreEntryTable,
|
||||
GroupMatchTable,
|
||||
],
|
||||
daos: [
|
||||
PlayerDao,
|
||||
@@ -37,9 +31,7 @@ part 'database.g.dart';
|
||||
MatchDao,
|
||||
PlayerGroupDao,
|
||||
PlayerMatchDao,
|
||||
GameDao,
|
||||
ScoreEntryDao,
|
||||
TeamDao,
|
||||
GroupMatchDao,
|
||||
],
|
||||
)
|
||||
class AppDatabase extends _$AppDatabase {
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,14 +0,0 @@
|
||||
import 'package:drift/drift.dart';
|
||||
|
||||
class GameTable extends Table {
|
||||
TextColumn get id => text()();
|
||||
TextColumn get name => text()();
|
||||
TextColumn get ruleset => text()();
|
||||
TextColumn get description => text()();
|
||||
TextColumn get color => text()();
|
||||
TextColumn get icon => text()();
|
||||
DateTimeColumn get createdAt => dateTime()();
|
||||
|
||||
@override
|
||||
Set<Column<Object>> get primaryKey => {id};
|
||||
}
|
||||
13
lib/data/db/tables/group_match_table.dart
Normal file
13
lib/data/db/tables/group_match_table.dart
Normal file
@@ -0,0 +1,13 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/tables/group_table.dart';
|
||||
import 'package:tallee/data/db/tables/match_table.dart';
|
||||
|
||||
class GroupMatchTable extends Table {
|
||||
TextColumn get groupId =>
|
||||
text().references(GroupTable, #id, onDelete: KeyAction.cascade)();
|
||||
TextColumn get matchId =>
|
||||
text().references(MatchTable, #id, onDelete: KeyAction.cascade)();
|
||||
|
||||
@override
|
||||
Set<Column<Object>> get primaryKey => {groupId, matchId};
|
||||
}
|
||||
@@ -3,7 +3,6 @@ import 'package:drift/drift.dart';
|
||||
class GroupTable extends Table {
|
||||
TextColumn get id => text()();
|
||||
TextColumn get name => text()();
|
||||
TextColumn get description => text()();
|
||||
DateTimeColumn get createdAt => dateTime()();
|
||||
|
||||
@override
|
||||
|
||||
@@ -1,20 +1,10 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/tables/game_table.dart';
|
||||
import 'package:tallee/data/db/tables/group_table.dart';
|
||||
|
||||
class MatchTable extends Table {
|
||||
TextColumn get id => text()();
|
||||
TextColumn get gameId =>
|
||||
text().references(GameTable, #id, onDelete: KeyAction.cascade)();
|
||||
// Nullable if there is no group associated with the match
|
||||
// onDelete: If a group gets deleted, groupId in the match gets set to null
|
||||
TextColumn get groupId => text()
|
||||
.references(GroupTable, #id, onDelete: KeyAction.setNull)
|
||||
.nullable()();
|
||||
TextColumn get name => text()();
|
||||
TextColumn get notes => text().nullable()();
|
||||
late final winnerId = text().nullable()();
|
||||
DateTimeColumn get createdAt => dateTime()();
|
||||
DateTimeColumn get endedAt => dateTime().nullable()();
|
||||
|
||||
@override
|
||||
Set<Column<Object>> get primaryKey => {id};
|
||||
|
||||
@@ -1,14 +1,12 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/tables/match_table.dart';
|
||||
import 'package:tallee/data/db/tables/player_table.dart';
|
||||
import 'package:tallee/data/db/tables/team_table.dart';
|
||||
|
||||
class PlayerMatchTable extends Table {
|
||||
TextColumn get playerId =>
|
||||
text().references(PlayerTable, #id, onDelete: KeyAction.cascade)();
|
||||
TextColumn get matchId =>
|
||||
text().references(MatchTable, #id, onDelete: KeyAction.cascade)();
|
||||
TextColumn get teamId => text().references(TeamTable, #id).nullable()();
|
||||
|
||||
@override
|
||||
Set<Column<Object>> get primaryKey => {playerId, matchId};
|
||||
|
||||
@@ -3,7 +3,6 @@ import 'package:drift/drift.dart';
|
||||
class PlayerTable extends Table {
|
||||
TextColumn get id => text()();
|
||||
TextColumn get name => text()();
|
||||
TextColumn get description => text()();
|
||||
DateTimeColumn get createdAt => dateTime()();
|
||||
|
||||
@override
|
||||
|
||||
@@ -1,16 +0,0 @@
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:tallee/data/db/tables/match_table.dart';
|
||||
import 'package:tallee/data/db/tables/player_table.dart';
|
||||
|
||||
class ScoreEntryTable extends Table {
|
||||
TextColumn get playerId =>
|
||||
text().references(PlayerTable, #id, onDelete: KeyAction.cascade)();
|
||||
TextColumn get matchId =>
|
||||
text().references(MatchTable, #id, onDelete: KeyAction.cascade)();
|
||||
IntColumn get roundNumber => integer()();
|
||||
IntColumn get score => integer()();
|
||||
IntColumn get change => integer()();
|
||||
|
||||
@override
|
||||
Set<Column<Object>> get primaryKey => {playerId, matchId, roundNumber};
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
import 'package:drift/drift.dart';
|
||||
|
||||
class TeamTable extends Table {
|
||||
TextColumn get id => text()();
|
||||
TextColumn get name => text()();
|
||||
DateTimeColumn get createdAt => dateTime()();
|
||||
|
||||
@override
|
||||
Set<Column<Object>> get primaryKey => {id};
|
||||
}
|
||||
@@ -1,40 +1,40 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:uuid/uuid.dart';
|
||||
|
||||
class Team {
|
||||
class Group {
|
||||
final String id;
|
||||
final String name;
|
||||
final DateTime createdAt;
|
||||
final String name;
|
||||
final List<Player> members;
|
||||
|
||||
Team({
|
||||
Group({
|
||||
String? id,
|
||||
required this.name,
|
||||
DateTime? createdAt,
|
||||
required this.name,
|
||||
required this.members,
|
||||
}) : id = id ?? const Uuid().v4(),
|
||||
createdAt = createdAt ?? clock.now();
|
||||
|
||||
@override
|
||||
String toString() {
|
||||
return 'Team{id: $id, name: $name, members: $members}';
|
||||
return 'Group{id: $id, name: $name,members: $members}';
|
||||
}
|
||||
|
||||
/// Creates a Team instance from a JSON object (memberIds format).
|
||||
/// Player objects are reconstructed from memberIds by the DataTransferService.
|
||||
Team.fromJson(Map<String, dynamic> json)
|
||||
/// Creates a Group instance from a JSON object.
|
||||
Group.fromJson(Map<String, dynamic> json)
|
||||
: id = json['id'],
|
||||
name = json['name'],
|
||||
createdAt = DateTime.parse(json['createdAt']),
|
||||
members = []; // Populated during import via DataTransferService
|
||||
name = json['name'],
|
||||
members = (json['members'] as List)
|
||||
.map((memberJson) => Player.fromJson(memberJson))
|
||||
.toList();
|
||||
|
||||
/// Converts the Team instance to a JSON object. Related objects are
|
||||
/// represented by their IDs.
|
||||
/// Converts the Group instance to a JSON object.
|
||||
Map<String, dynamic> toJson() => {
|
||||
'id': id,
|
||||
'name': name,
|
||||
'createdAt': createdAt.toIso8601String(),
|
||||
'memberIds': members.map((member) => member.id).toList(),
|
||||
'name': name,
|
||||
'members': members.map((member) => member.toJson()).toList(),
|
||||
};
|
||||
}
|
||||
51
lib/data/dto/match.dart
Normal file
51
lib/data/dto/match.dart
Normal file
@@ -0,0 +1,51 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:uuid/uuid.dart';
|
||||
|
||||
class Match {
|
||||
final String id;
|
||||
final DateTime createdAt;
|
||||
final String name;
|
||||
final List<Player>? players;
|
||||
final Group? group;
|
||||
Player? winner;
|
||||
|
||||
Match({
|
||||
String? id,
|
||||
DateTime? createdAt,
|
||||
required this.name,
|
||||
this.players,
|
||||
this.group,
|
||||
this.winner,
|
||||
}) : id = id ?? const Uuid().v4(),
|
||||
createdAt = createdAt ?? clock.now();
|
||||
|
||||
@override
|
||||
String toString() {
|
||||
return 'Match{\n\tid: $id,\n\tname: $name,\n\tplayers: $players,\n\tgroup: $group,\n\twinner: $winner\n}';
|
||||
}
|
||||
|
||||
/// Creates a Match instance from a JSON object.
|
||||
Match.fromJson(Map<String, dynamic> json)
|
||||
: id = json['id'],
|
||||
name = json['name'],
|
||||
createdAt = DateTime.parse(json['createdAt']),
|
||||
players = json['players'] != null
|
||||
? (json['players'] as List)
|
||||
.map((playerJson) => Player.fromJson(playerJson))
|
||||
.toList()
|
||||
: null,
|
||||
group = json['group'] != null ? Group.fromJson(json['group']) : null,
|
||||
winner = json['winner'] != null ? Player.fromJson(json['winner']) : null;
|
||||
|
||||
/// Converts the Match instance to a JSON object.
|
||||
Map<String, dynamic> toJson() => {
|
||||
'id': id,
|
||||
'createdAt': createdAt.toIso8601String(),
|
||||
'name': name,
|
||||
'players': players?.map((player) => player.toJson()).toList(),
|
||||
'group': group?.toJson(),
|
||||
'winner': winner?.toJson(),
|
||||
};
|
||||
}
|
||||
@@ -5,34 +5,26 @@ class Player {
|
||||
final String id;
|
||||
final DateTime createdAt;
|
||||
final String name;
|
||||
final String description;
|
||||
|
||||
Player({
|
||||
String? id,
|
||||
DateTime? createdAt,
|
||||
required this.name,
|
||||
String? description,
|
||||
}) : id = id ?? const Uuid().v4(),
|
||||
createdAt = createdAt ?? clock.now(),
|
||||
description = description ?? '';
|
||||
Player({String? id, DateTime? createdAt, required this.name})
|
||||
: id = id ?? const Uuid().v4(),
|
||||
createdAt = createdAt ?? clock.now();
|
||||
|
||||
@override
|
||||
String toString() {
|
||||
return 'Player{id: $id, name: $name, description: $description}';
|
||||
return 'Player{id: $id,name: $name}';
|
||||
}
|
||||
|
||||
/// Creates a Player instance from a JSON object.
|
||||
Player.fromJson(Map<String, dynamic> json)
|
||||
: id = json['id'],
|
||||
createdAt = DateTime.parse(json['createdAt']),
|
||||
name = json['name'],
|
||||
description = json['description'];
|
||||
name = json['name'];
|
||||
|
||||
/// Converts the Player instance to a JSON object.
|
||||
Map<String, dynamic> toJson() => {
|
||||
'id': id,
|
||||
'createdAt': createdAt.toIso8601String(),
|
||||
'name': name,
|
||||
'description': description,
|
||||
};
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:uuid/uuid.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
|
||||
class Game {
|
||||
final String id;
|
||||
final DateTime createdAt;
|
||||
final String name;
|
||||
final Ruleset ruleset;
|
||||
final String description;
|
||||
final GameColor color;
|
||||
final String icon;
|
||||
|
||||
Game({
|
||||
String? id,
|
||||
DateTime? createdAt,
|
||||
required this.name,
|
||||
required this.ruleset,
|
||||
String? description,
|
||||
required this.color,
|
||||
required this.icon,
|
||||
}) : id = id ?? const Uuid().v4(),
|
||||
createdAt = createdAt ?? clock.now(),
|
||||
description = description ?? '';
|
||||
|
||||
@override
|
||||
String toString() {
|
||||
return 'Game{id: $id, name: $name, ruleset: $ruleset, description: $description, color: $color, icon: $icon}';
|
||||
}
|
||||
|
||||
/// Creates a Game instance from a JSON object.
|
||||
Game.fromJson(Map<String, dynamic> json)
|
||||
: id = json['id'],
|
||||
createdAt = DateTime.parse(json['createdAt']),
|
||||
name = json['name'],
|
||||
ruleset = Ruleset.values.firstWhere((e) => e.name == json['ruleset']),
|
||||
description = json['description'],
|
||||
color = GameColor.values.firstWhere((e) => e.name == json['color']),
|
||||
icon = json['icon'];
|
||||
|
||||
/// Converts the Game instance to a JSON object.
|
||||
Map<String, dynamic> toJson() => {
|
||||
'id': id,
|
||||
'createdAt': createdAt.toIso8601String(),
|
||||
'name': name,
|
||||
'ruleset': ruleset.name,
|
||||
'description': description,
|
||||
'color': color.name,
|
||||
'icon': icon,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,45 +0,0 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:uuid/uuid.dart';
|
||||
|
||||
class Group {
|
||||
final String id;
|
||||
final String name;
|
||||
final String description;
|
||||
final DateTime createdAt;
|
||||
final List<Player> members;
|
||||
|
||||
Group({
|
||||
String? id,
|
||||
DateTime? createdAt,
|
||||
required this.name,
|
||||
String? description,
|
||||
required this.members,
|
||||
}) : id = id ?? const Uuid().v4(),
|
||||
createdAt = createdAt ?? clock.now(),
|
||||
description = description ?? '';
|
||||
|
||||
@override
|
||||
String toString() {
|
||||
return 'Group{id: $id, name: $name, description: $description, members: $members}';
|
||||
}
|
||||
|
||||
/// Creates a Group instance from a JSON object where the related [Player]
|
||||
/// objects are represented by their IDs.
|
||||
Group.fromJson(Map<String, dynamic> json)
|
||||
: id = json['id'],
|
||||
createdAt = DateTime.parse(json['createdAt']),
|
||||
name = json['name'],
|
||||
description = json['description'],
|
||||
members = [];
|
||||
|
||||
/// Converts the Group instance to a JSON object. Related [Player] objects are
|
||||
/// represented by their IDs.
|
||||
Map<String, dynamic> toJson() => {
|
||||
'id': id,
|
||||
'createdAt': createdAt.toIso8601String(),
|
||||
'name': name,
|
||||
'description': description,
|
||||
'memberIds': members.map((member) => member.id).toList(),
|
||||
};
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/models/score_entry.dart';
|
||||
import 'package:uuid/uuid.dart';
|
||||
|
||||
class Match {
|
||||
final String id;
|
||||
final DateTime createdAt;
|
||||
final DateTime? endedAt;
|
||||
final String name;
|
||||
final Game game;
|
||||
final Group? group;
|
||||
final List<Player> players;
|
||||
final String notes;
|
||||
Map<String, List<ScoreEntry>> scores;
|
||||
Player? winner;
|
||||
|
||||
Match({
|
||||
String? id,
|
||||
DateTime? createdAt,
|
||||
this.endedAt,
|
||||
required this.name,
|
||||
required this.game,
|
||||
this.group,
|
||||
this.players = const [],
|
||||
this.notes = '',
|
||||
Map<String, List<ScoreEntry>>? scores,
|
||||
this.winner,
|
||||
}) : id = id ?? const Uuid().v4(),
|
||||
createdAt = createdAt ?? clock.now(),
|
||||
scores = scores ?? {for (var player in players) player.id: []};
|
||||
|
||||
@override
|
||||
String toString() {
|
||||
return 'Match{id: $id, createdAt: $createdAt, endedAt: $endedAt, name: $name, game: $game, group: $group, players: $players, notes: $notes, scores: $scores, winner: $winner}';
|
||||
}
|
||||
|
||||
/// Creates a Match instance from a JSON object where related objects are
|
||||
/// represented by their IDs. Therefore, the game, group, and players are not
|
||||
/// fully constructed here.
|
||||
Match.fromJson(Map<String, dynamic> json)
|
||||
: id = json['id'],
|
||||
createdAt = DateTime.parse(json['createdAt']),
|
||||
endedAt = json['endedAt'] != null
|
||||
? DateTime.parse(json['endedAt'])
|
||||
: null,
|
||||
name = json['name'],
|
||||
game = Game(
|
||||
name: '',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
description: '',
|
||||
color: GameColor.blue,
|
||||
icon: '',
|
||||
),
|
||||
group = null,
|
||||
players = [],
|
||||
scores = json['scores'],
|
||||
notes = json['notes'] ?? '';
|
||||
|
||||
/// Converts the Match instance to a JSON object. Related objects are
|
||||
/// represented by their IDs, so the game, group, and players are not fully
|
||||
/// serialized here.
|
||||
Map<String, dynamic> toJson() => {
|
||||
'id': id,
|
||||
'createdAt': createdAt.toIso8601String(),
|
||||
'endedAt': endedAt?.toIso8601String(),
|
||||
'name': name,
|
||||
'gameId': game.id,
|
||||
'groupId': group?.id,
|
||||
'playerIds': players.map((player) => player.id).toList(),
|
||||
'scores': scores.map(
|
||||
(playerId, scoreList) =>
|
||||
MapEntry(playerId, scoreList.map((score) => score.toJson()).toList()),
|
||||
),
|
||||
'notes': notes,
|
||||
};
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
class ScoreEntry {
|
||||
int roundNumber = 0;
|
||||
final int score;
|
||||
final int change;
|
||||
|
||||
ScoreEntry({
|
||||
required this.roundNumber,
|
||||
required this.score,
|
||||
required this.change,
|
||||
});
|
||||
|
||||
ScoreEntry.fromJson(Map<String, dynamic> json)
|
||||
: roundNumber = json['roundNumber'],
|
||||
score = json['score'],
|
||||
change = json['change'];
|
||||
|
||||
Map<String, dynamic> toJson() => {
|
||||
'roundNumber': roundNumber,
|
||||
'score': score,
|
||||
'change': change,
|
||||
};
|
||||
}
|
||||
@@ -22,14 +22,9 @@
|
||||
"days_ago": "vor {count} Tagen",
|
||||
"delete": "Löschen",
|
||||
"delete_all_data": "Alle Daten löschen",
|
||||
"delete_group": "Diese Gruppe löschen",
|
||||
"delete_match": "Spiel löschen",
|
||||
"delete_group": "Gruppe löschen",
|
||||
"edit_group": "Gruppe bearbeiten",
|
||||
"edit_match": "Gruppe bearbeiten",
|
||||
"enter_results": "Ergebnisse eintragen",
|
||||
"error_creating_group": "Fehler beim Erstellen der Gruppe, bitte erneut versuchen",
|
||||
"error_deleting_group": "Fehler beim Löschen der Gruppe, bitte erneut versuchen",
|
||||
"error_editing_group": "Fehler beim Bearbeiten der Gruppe, bitte erneut versuchen",
|
||||
"error_reading_file": "Fehler beim Lesen der Datei",
|
||||
"export_canceled": "Export abgebrochen",
|
||||
"export_data": "Daten exportieren",
|
||||
@@ -51,7 +46,6 @@
|
||||
"licenses": "Lizenzen",
|
||||
"match_in_progress": "Spiel läuft...",
|
||||
"match_name": "Spieltitel",
|
||||
"match_profile": "Spielprofil",
|
||||
"matches": "Spiele",
|
||||
"members": "Mitglieder",
|
||||
"most_points": "Höchste Punkte",
|
||||
@@ -64,7 +58,6 @@
|
||||
"no_players_found_with_that_name": "Keine Spieler:in mit diesem Namen gefunden",
|
||||
"no_players_selected": "Keine Spieler:innen ausgewählt",
|
||||
"no_recent_matches_available": "Keine letzten Spiele verfügbar",
|
||||
"no_results_entered_yet": "Noch keine Ergebnisse eingetragen",
|
||||
"no_second_match_available": "Kein zweites Spiel verfügbar",
|
||||
"no_statistics_available": "Keine Statistiken verfügbar",
|
||||
"none": "Kein",
|
||||
@@ -77,14 +70,11 @@
|
||||
"privacy_policy": "Datenschutzerklärung",
|
||||
"quick_create": "Schnellzugriff",
|
||||
"recent_matches": "Letzte Spiele",
|
||||
"result": "Ergebnis",
|
||||
"results": "Ergebnisse",
|
||||
"ruleset": "Regelwerk",
|
||||
"ruleset_least_points": "Umgekehrte Wertung: Der/die Spieler:in mit den wenigsten Punkten gewinnt.",
|
||||
"ruleset_most_points": "Traditionelles Regelwerk: Der/die Spieler:in mit den meisten Punkten gewinnt.",
|
||||
"ruleset_single_loser": "Genau ein:e Verlierer:in wird bestimmt; der letzte Platz erhält die Strafe oder Konsequenz.",
|
||||
"ruleset_single_winner": "Genau ein:e Gewinner:in wird gewählt; Unentschieden werden durch einen vordefinierten Tie-Breaker aufgelöst.",
|
||||
"save_changes": "Änderungen speichern",
|
||||
"search_for_groups": "Nach Gruppen suchen",
|
||||
"search_for_players": "Nach Spieler:innen suchen",
|
||||
"select_winner": "Gewinner:in wählen:",
|
||||
@@ -92,9 +82,6 @@
|
||||
"settings": "Einstellungen",
|
||||
"single_loser": "Ein:e Verlierer:in",
|
||||
"single_winner": "Ein:e Gewinner:in",
|
||||
"highest_score": "Höchste Punkte",
|
||||
"lowest_score": "Niedrigste Punkte",
|
||||
"multiple_winners": "Mehrere Gewinner:innen",
|
||||
"statistics": "Statistiken",
|
||||
"stats": "Statistiken",
|
||||
"successfully_added_player": "Spieler:in {playerName} erfolgreich hinzugefügt",
|
||||
|
||||
@@ -37,10 +37,10 @@
|
||||
"description": "Button text to create a match"
|
||||
},
|
||||
"@create_new_group": {
|
||||
"description": "Appbar text to create a new group"
|
||||
"description": "Button text to create a new group"
|
||||
},
|
||||
"@create_new_match": {
|
||||
"description": "Appbar text to create a new match"
|
||||
"description": "Button text to create a new match"
|
||||
},
|
||||
"@created_on": {
|
||||
"description": "Label for creation date"
|
||||
@@ -72,29 +72,14 @@
|
||||
"description": "Confirmation dialog for deleting all data"
|
||||
},
|
||||
"@delete_group": {
|
||||
"description": "Confirmation dialog for deleting a group"
|
||||
},
|
||||
"@delete_match": {
|
||||
"description": "Button text to delete a match"
|
||||
"description": "Button text to delete a group"
|
||||
},
|
||||
"@edit_group": {
|
||||
"description": "Button & Appbar label for editing a group"
|
||||
},
|
||||
"@edit_match": {
|
||||
"description": "Button & Appbar label for editing a match"
|
||||
},
|
||||
"@enter_results": {
|
||||
"description": "Button text to enter match results"
|
||||
"description": "Button text to edit a group"
|
||||
},
|
||||
"@error_creating_group": {
|
||||
"description": "Error message when group creation fails"
|
||||
},
|
||||
"@error_deleting_group": {
|
||||
"description": "Error message when group deletion fails"
|
||||
},
|
||||
"@error_editing_group": {
|
||||
"description": "Error message when group editing fails"
|
||||
},
|
||||
"@error_reading_file": {
|
||||
"description": "Error message when file cannot be read"
|
||||
},
|
||||
@@ -158,9 +143,6 @@
|
||||
"@match_name": {
|
||||
"description": "Placeholder for match name input"
|
||||
},
|
||||
"@match_profile": {
|
||||
"description": "Title for match profile view"
|
||||
},
|
||||
"@matches": {
|
||||
"description": "Label for matches"
|
||||
},
|
||||
@@ -197,9 +179,6 @@
|
||||
"@no_recent_matches_available": {
|
||||
"description": "Message when no recent matches exist"
|
||||
},
|
||||
"@no_results_entered_yet": {
|
||||
"description": "Message when no results have been entered yet"
|
||||
},
|
||||
"@no_second_match_available": {
|
||||
"description": "Message when no second match exists"
|
||||
},
|
||||
@@ -241,9 +220,6 @@
|
||||
"@recent_matches": {
|
||||
"description": "Title for recent matches section"
|
||||
},
|
||||
"@results": {
|
||||
"description": "Label for match results"
|
||||
},
|
||||
"@ruleset": {
|
||||
"description": "Ruleset label"
|
||||
},
|
||||
@@ -259,9 +235,6 @@
|
||||
"@ruleset_single_winner": {
|
||||
"description": "Description for single winner ruleset"
|
||||
},
|
||||
"@save_changes": {
|
||||
"description": "Save changes button text"
|
||||
},
|
||||
"@search_for_groups": {
|
||||
"description": "Hint text for group search input field"
|
||||
},
|
||||
@@ -348,13 +321,8 @@
|
||||
"delete": "Delete",
|
||||
"delete_all_data": "Delete all data",
|
||||
"delete_group": "Delete Group",
|
||||
"delete_match": "Delete Match",
|
||||
"edit_group": "Edit Group",
|
||||
"edit_match": "Edit Match",
|
||||
"enter_results": "Enter Results",
|
||||
"error_creating_group": "Error while creating group, please try again",
|
||||
"error_deleting_group": "Error while deleting group, please try again",
|
||||
"error_editing_group": "Error while editing group, please try again",
|
||||
"error_reading_file": "Error reading file",
|
||||
"export_canceled": "Export canceled",
|
||||
"export_data": "Export data",
|
||||
@@ -376,7 +344,6 @@
|
||||
"licenses": "Licenses",
|
||||
"match_in_progress": "Match in progress...",
|
||||
"match_name": "Match name",
|
||||
"match_profile": "Match Profile",
|
||||
"matches": "Matches",
|
||||
"members": "Members",
|
||||
"most_points": "Most Points",
|
||||
@@ -389,7 +356,6 @@
|
||||
"no_players_found_with_that_name": "No players found with that name",
|
||||
"no_players_selected": "No players selected",
|
||||
"no_recent_matches_available": "No recent matches available",
|
||||
"no_results_entered_yet": "No results entered yet",
|
||||
"no_second_match_available": "No second match available",
|
||||
"no_statistics_available": "No statistics available",
|
||||
"none": "None",
|
||||
@@ -402,13 +368,11 @@
|
||||
"privacy_policy": "Privacy Policy",
|
||||
"quick_create": "Quick Create",
|
||||
"recent_matches": "Recent Matches",
|
||||
"results": "Results",
|
||||
"ruleset": "Ruleset",
|
||||
"ruleset_least_points": "Inverse scoring: the player with the fewest points wins.",
|
||||
"ruleset_most_points": "Traditional ruleset: the player with the most points wins.",
|
||||
"ruleset_single_loser": "Exactly one loser is determined; last place receives the penalty or consequence.",
|
||||
"ruleset_single_winner": "Exactly one winner is chosen; ties are resolved by a predefined tiebreaker.",
|
||||
"save_changes": "Save Changes",
|
||||
"search_for_groups": "Search for groups",
|
||||
"search_for_players": "Search for players",
|
||||
"select_winner": "Select Winner:",
|
||||
@@ -416,9 +380,6 @@
|
||||
"settings": "Settings",
|
||||
"single_loser": "Single Loser",
|
||||
"single_winner": "Single Winner",
|
||||
"highest_score": "Highest Score",
|
||||
"lowest_score": "Lowest Score",
|
||||
"multiple_winners": "Multiple Winners",
|
||||
"statistics": "Statistics",
|
||||
"stats": "Stats",
|
||||
"successfully_added_player": "Successfully added player {playerName}",
|
||||
|
||||
@@ -170,7 +170,7 @@ abstract class AppLocalizations {
|
||||
/// **'Create match'**
|
||||
String get create_match;
|
||||
|
||||
/// Appbar text to create a new group
|
||||
/// Button text to create a new group
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Create new group'**
|
||||
@@ -182,7 +182,7 @@ abstract class AppLocalizations {
|
||||
/// **'Created on'**
|
||||
String get created_on;
|
||||
|
||||
/// Appbar text to create a new match
|
||||
/// Button text to create a new match
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Create new match'**
|
||||
@@ -230,54 +230,24 @@ abstract class AppLocalizations {
|
||||
/// **'Delete all data'**
|
||||
String get delete_all_data;
|
||||
|
||||
/// Confirmation dialog for deleting a group
|
||||
/// Button text to delete a group
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Delete Group'**
|
||||
String get delete_group;
|
||||
|
||||
/// Button text to delete a match
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Delete Match'**
|
||||
String get delete_match;
|
||||
|
||||
/// Button & Appbar label for editing a group
|
||||
/// Button text to edit a group
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Edit Group'**
|
||||
String get edit_group;
|
||||
|
||||
/// Button & Appbar label for editing a match
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Edit Match'**
|
||||
String get edit_match;
|
||||
|
||||
/// Button text to enter match results
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Enter Results'**
|
||||
String get enter_results;
|
||||
|
||||
/// Error message when group creation fails
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Error while creating group, please try again'**
|
||||
String get error_creating_group;
|
||||
|
||||
/// Error message when group deletion fails
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Error while deleting group, please try again'**
|
||||
String get error_deleting_group;
|
||||
|
||||
/// Error message when group editing fails
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Error while editing group, please try again'**
|
||||
String get error_editing_group;
|
||||
|
||||
/// Error message when file cannot be read
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
@@ -404,12 +374,6 @@ abstract class AppLocalizations {
|
||||
/// **'Match name'**
|
||||
String get match_name;
|
||||
|
||||
/// Title for match profile view
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Match Profile'**
|
||||
String get match_profile;
|
||||
|
||||
/// Label for matches
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
@@ -482,12 +446,6 @@ abstract class AppLocalizations {
|
||||
/// **'No recent matches available'**
|
||||
String get no_recent_matches_available;
|
||||
|
||||
/// Message when no results have been entered yet
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'No results entered yet'**
|
||||
String get no_results_entered_yet;
|
||||
|
||||
/// Message when no second match exists
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
@@ -560,12 +518,6 @@ abstract class AppLocalizations {
|
||||
/// **'Recent Matches'**
|
||||
String get recent_matches;
|
||||
|
||||
/// Label for match results
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Results'**
|
||||
String get results;
|
||||
|
||||
/// Ruleset label
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
@@ -596,12 +548,6 @@ abstract class AppLocalizations {
|
||||
/// **'Exactly one winner is chosen; ties are resolved by a predefined tiebreaker.'**
|
||||
String get ruleset_single_winner;
|
||||
|
||||
/// Save changes button text
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Save Changes'**
|
||||
String get save_changes;
|
||||
|
||||
/// Hint text for group search input field
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
@@ -644,24 +590,6 @@ abstract class AppLocalizations {
|
||||
/// **'Single Winner'**
|
||||
String get single_winner;
|
||||
|
||||
/// No description provided for @highest_score.
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Highest Score'**
|
||||
String get highest_score;
|
||||
|
||||
/// No description provided for @lowest_score.
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Lowest Score'**
|
||||
String get lowest_score;
|
||||
|
||||
/// No description provided for @multiple_winners.
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
/// **'Multiple Winners'**
|
||||
String get multiple_winners;
|
||||
|
||||
/// Statistics tab label
|
||||
///
|
||||
/// In en, this message translates to:
|
||||
|
||||
@@ -79,32 +79,15 @@ class AppLocalizationsDe extends AppLocalizations {
|
||||
String get delete_all_data => 'Alle Daten löschen';
|
||||
|
||||
@override
|
||||
String get delete_group => 'Diese Gruppe löschen';
|
||||
|
||||
@override
|
||||
String get delete_match => 'Spiel löschen';
|
||||
String get delete_group => 'Gruppe löschen';
|
||||
|
||||
@override
|
||||
String get edit_group => 'Gruppe bearbeiten';
|
||||
|
||||
@override
|
||||
String get edit_match => 'Gruppe bearbeiten';
|
||||
|
||||
@override
|
||||
String get enter_results => 'Ergebnisse eintragen';
|
||||
|
||||
@override
|
||||
String get error_creating_group =>
|
||||
'Fehler beim Erstellen der Gruppe, bitte erneut versuchen';
|
||||
|
||||
@override
|
||||
String get error_deleting_group =>
|
||||
'Fehler beim Löschen der Gruppe, bitte erneut versuchen';
|
||||
|
||||
@override
|
||||
String get error_editing_group =>
|
||||
'Fehler beim Bearbeiten der Gruppe, bitte erneut versuchen';
|
||||
|
||||
@override
|
||||
String get error_reading_file => 'Fehler beim Lesen der Datei';
|
||||
|
||||
@@ -168,9 +151,6 @@ class AppLocalizationsDe extends AppLocalizations {
|
||||
@override
|
||||
String get match_name => 'Spieltitel';
|
||||
|
||||
@override
|
||||
String get match_profile => 'Spielprofil';
|
||||
|
||||
@override
|
||||
String get matches => 'Spiele';
|
||||
|
||||
@@ -208,9 +188,6 @@ class AppLocalizationsDe extends AppLocalizations {
|
||||
@override
|
||||
String get no_recent_matches_available => 'Keine letzten Spiele verfügbar';
|
||||
|
||||
@override
|
||||
String get no_results_entered_yet => 'Noch keine Ergebnisse eingetragen';
|
||||
|
||||
@override
|
||||
String get no_second_match_available => 'Kein zweites Spiel verfügbar';
|
||||
|
||||
@@ -249,9 +226,6 @@ class AppLocalizationsDe extends AppLocalizations {
|
||||
@override
|
||||
String get recent_matches => 'Letzte Spiele';
|
||||
|
||||
@override
|
||||
String get results => 'Ergebnisse';
|
||||
|
||||
@override
|
||||
String get ruleset => 'Regelwerk';
|
||||
|
||||
@@ -271,9 +245,6 @@ class AppLocalizationsDe extends AppLocalizations {
|
||||
String get ruleset_single_winner =>
|
||||
'Genau ein:e Gewinner:in wird gewählt; Unentschieden werden durch einen vordefinierten Tie-Breaker aufgelöst.';
|
||||
|
||||
@override
|
||||
String get save_changes => 'Änderungen speichern';
|
||||
|
||||
@override
|
||||
String get search_for_groups => 'Nach Gruppen suchen';
|
||||
|
||||
@@ -295,15 +266,6 @@ class AppLocalizationsDe extends AppLocalizations {
|
||||
@override
|
||||
String get single_winner => 'Ein:e Gewinner:in';
|
||||
|
||||
@override
|
||||
String get highest_score => 'Höchste Punkte';
|
||||
|
||||
@override
|
||||
String get lowest_score => 'Niedrigste Punkte';
|
||||
|
||||
@override
|
||||
String get multiple_winners => 'Mehrere Gewinner:innen';
|
||||
|
||||
@override
|
||||
String get statistics => 'Statistiken';
|
||||
|
||||
|
||||
@@ -81,30 +81,13 @@ class AppLocalizationsEn extends AppLocalizations {
|
||||
@override
|
||||
String get delete_group => 'Delete Group';
|
||||
|
||||
@override
|
||||
String get delete_match => 'Delete Match';
|
||||
|
||||
@override
|
||||
String get edit_group => 'Edit Group';
|
||||
|
||||
@override
|
||||
String get edit_match => 'Edit Match';
|
||||
|
||||
@override
|
||||
String get enter_results => 'Enter Results';
|
||||
|
||||
@override
|
||||
String get error_creating_group =>
|
||||
'Error while creating group, please try again';
|
||||
|
||||
@override
|
||||
String get error_deleting_group =>
|
||||
'Error while deleting group, please try again';
|
||||
|
||||
@override
|
||||
String get error_editing_group =>
|
||||
'Error while editing group, please try again';
|
||||
|
||||
@override
|
||||
String get error_reading_file => 'Error reading file';
|
||||
|
||||
@@ -168,9 +151,6 @@ class AppLocalizationsEn extends AppLocalizations {
|
||||
@override
|
||||
String get match_name => 'Match name';
|
||||
|
||||
@override
|
||||
String get match_profile => 'Match Profile';
|
||||
|
||||
@override
|
||||
String get matches => 'Matches';
|
||||
|
||||
@@ -208,9 +188,6 @@ class AppLocalizationsEn extends AppLocalizations {
|
||||
@override
|
||||
String get no_recent_matches_available => 'No recent matches available';
|
||||
|
||||
@override
|
||||
String get no_results_entered_yet => 'No results entered yet';
|
||||
|
||||
@override
|
||||
String get no_second_match_available => 'No second match available';
|
||||
|
||||
@@ -249,9 +226,6 @@ class AppLocalizationsEn extends AppLocalizations {
|
||||
@override
|
||||
String get recent_matches => 'Recent Matches';
|
||||
|
||||
@override
|
||||
String get results => 'Results';
|
||||
|
||||
@override
|
||||
String get ruleset => 'Ruleset';
|
||||
|
||||
@@ -271,9 +245,6 @@ class AppLocalizationsEn extends AppLocalizations {
|
||||
String get ruleset_single_winner =>
|
||||
'Exactly one winner is chosen; ties are resolved by a predefined tiebreaker.';
|
||||
|
||||
@override
|
||||
String get save_changes => 'Save Changes';
|
||||
|
||||
@override
|
||||
String get search_for_groups => 'Search for groups';
|
||||
|
||||
@@ -295,15 +266,6 @@ class AppLocalizationsEn extends AppLocalizations {
|
||||
@override
|
||||
String get single_winner => 'Single Winner';
|
||||
|
||||
@override
|
||||
String get highest_score => 'Highest Score';
|
||||
|
||||
@override
|
||||
String get lowest_score => 'Lowest Score';
|
||||
|
||||
@override
|
||||
String get multiple_winners => 'Multiple Winners';
|
||||
|
||||
@override
|
||||
String get statistics => 'Statistics';
|
||||
|
||||
|
||||
@@ -35,25 +35,15 @@ class GameTracker extends StatelessWidget {
|
||||
},
|
||||
debugShowCheckedModeBanner: false,
|
||||
onGenerateTitle: (context) => AppLocalizations.of(context).app_name,
|
||||
themeMode: ThemeMode.dark,
|
||||
themeMode: ThemeMode.dark, // forces dark mode
|
||||
theme: ThemeData(
|
||||
// main colors
|
||||
primaryColor: CustomTheme.primaryColor,
|
||||
scaffoldBackgroundColor: CustomTheme.backgroundColor,
|
||||
// themes
|
||||
appBarTheme: CustomTheme.appBarTheme,
|
||||
inputDecorationTheme: CustomTheme.inputDecorationTheme,
|
||||
searchBarTheme: CustomTheme.searchBarTheme,
|
||||
radioTheme: CustomTheme.radioTheme,
|
||||
// color scheme
|
||||
colorScheme: ColorScheme.fromSeed(
|
||||
seedColor: CustomTheme.textColor,
|
||||
seedColor: CustomTheme.primaryColor,
|
||||
brightness: Brightness.dark,
|
||||
primary: CustomTheme.primaryColor,
|
||||
onPrimary: CustomTheme.textColor,
|
||||
surface: CustomTheme.backgroundColor,
|
||||
onSurface: CustomTheme.textColor,
|
||||
),
|
||||
).copyWith(surface: CustomTheme.backgroundColor),
|
||||
pageTransitionsTheme: const PageTransitionsTheme(
|
||||
builders: {
|
||||
TargetPlatform.iOS: CupertinoPageTransitionsBuilder(),
|
||||
|
||||
@@ -1,8 +1,10 @@
|
||||
import 'dart:ui';
|
||||
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:tallee/core/adaptive_page_route.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/group_view/group_view.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/group_view/groups_view.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/home_view.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/match_view/match_view.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/settings_view/settings_view.dart';
|
||||
@@ -38,7 +40,7 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
|
||||
),
|
||||
KeyedSubtree(
|
||||
key: ValueKey('groups_$tabKeyCount'),
|
||||
child: const GroupView(),
|
||||
child: const GroupsView(),
|
||||
),
|
||||
KeyedSubtree(
|
||||
key: ValueKey('stats_$tabKeyCount'),
|
||||
@@ -73,28 +75,66 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
|
||||
backgroundColor: CustomTheme.backgroundColor,
|
||||
body: tabs[currentIndex],
|
||||
extendBody: true,
|
||||
bottomNavigationBar: Container(
|
||||
height: 115,
|
||||
bottomNavigationBar: SizedBox(
|
||||
height: 70 + MediaQuery.of(context).padding.bottom,
|
||||
child: Stack(
|
||||
children: [
|
||||
// Dynamically generated blur layers for ultra-smooth transition
|
||||
...List.generate(34, (index) {
|
||||
// Use cubic curve for an even more natural, smoother transition
|
||||
final progress = index / 34.0; // 0.0 to 1.0
|
||||
final cubic = progress * progress * progress; // cubic curve
|
||||
final blurStrength =
|
||||
0.5 + (cubic * 50.0); // Very smooth from 0.5 to 50.5
|
||||
|
||||
// Height goes completely from 100% to 0% (all the way down)
|
||||
// With extra density at the bottom for softer transition
|
||||
final heightFactor = index < 25
|
||||
// First 25 layers: 100% to 30%
|
||||
? 1.0 - (progress * 0.7)
|
||||
// Last 10 layers: 30% to 0% (denser)
|
||||
: 0.3 - ((index - 25) / 34.0);
|
||||
|
||||
return Positioned(
|
||||
left: 0,
|
||||
right: 0,
|
||||
bottom: 0,
|
||||
height:
|
||||
(70 + MediaQuery.of(context).padding.bottom) *
|
||||
heightFactor.clamp(0.05, 1.0),
|
||||
child: ClipRect(
|
||||
child: BackdropFilter(
|
||||
filter: ImageFilter.blur(
|
||||
sigmaX: blurStrength,
|
||||
sigmaY: blurStrength,
|
||||
),
|
||||
child: Container(color: Colors.transparent),
|
||||
),
|
||||
),
|
||||
);
|
||||
}),
|
||||
// Gradient overlay
|
||||
Positioned.fill(
|
||||
child: Container(
|
||||
decoration: BoxDecoration(
|
||||
color: CustomTheme.navBarBackgroundColor,
|
||||
border: Border.all(
|
||||
strokeAlign: BorderSide.strokeAlignOutside,
|
||||
color: CustomTheme.boxBorderColor,
|
||||
width: 2,
|
||||
),
|
||||
borderRadius: const BorderRadius.only(
|
||||
topLeft: Radius.circular(30),
|
||||
topRight: Radius.circular(30),
|
||||
),
|
||||
boxShadow: [
|
||||
BoxShadow(
|
||||
color: Colors.black.withValues(alpha: 0.1),
|
||||
blurRadius: 20,
|
||||
offset: const Offset(0, -5),
|
||||
),
|
||||
gradient: LinearGradient(
|
||||
begin: Alignment.bottomCenter,
|
||||
end: Alignment.topCenter,
|
||||
colors: [
|
||||
CustomTheme.boxColor.withValues(alpha: 1),
|
||||
CustomTheme.boxColor.withValues(alpha: 0.5),
|
||||
CustomTheme.boxColor.withValues(alpha: 0.2),
|
||||
CustomTheme.boxColor.withValues(alpha: 0.0),
|
||||
],
|
||||
stops: const [0.0, 0.4, 0.8, 1],
|
||||
),
|
||||
child: SafeArea(
|
||||
),
|
||||
),
|
||||
),
|
||||
// Navbar content
|
||||
SafeArea(
|
||||
child: SizedBox(
|
||||
height: 70,
|
||||
child: Row(
|
||||
mainAxisAlignment: MainAxisAlignment.spaceAround,
|
||||
children: <Widget>[
|
||||
@@ -130,6 +170,9 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
|
||||
),
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -141,7 +184,7 @@ class _CustomNavigationBarState extends State<CustomNavigationBar>
|
||||
}
|
||||
|
||||
/// Returns the title of the current tab based on [currentIndex].
|
||||
String _currentTabTitle(BuildContext context) {
|
||||
String _currentTabTitle(context) {
|
||||
final loc = AppLocalizations.of(context);
|
||||
switch (currentIndex) {
|
||||
case 0:
|
||||
|
||||
@@ -4,20 +4,16 @@ import 'package:tallee/core/constants.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/widgets/buttons/custom_width_button.dart';
|
||||
import 'package:tallee/presentation/widgets/player_selection.dart';
|
||||
import 'package:tallee/presentation/widgets/text_input/text_input_field.dart';
|
||||
|
||||
class CreateGroupView extends StatefulWidget {
|
||||
const CreateGroupView({super.key, this.groupToEdit, this.onMembersChanged});
|
||||
|
||||
/// The group to edit, if any
|
||||
final Group? groupToEdit;
|
||||
|
||||
final VoidCallback? onMembersChanged;
|
||||
/// A view that allows the user to create a new group
|
||||
const CreateGroupView({super.key});
|
||||
|
||||
@override
|
||||
State<CreateGroupView> createState() => _CreateGroupViewState();
|
||||
@@ -26,29 +22,16 @@ class CreateGroupView extends StatefulWidget {
|
||||
class _CreateGroupViewState extends State<CreateGroupView> {
|
||||
late final AppDatabase db;
|
||||
|
||||
/// GlobalKey for ScaffoldMessenger to show snackbars
|
||||
final _scaffoldMessengerKey = GlobalKey<ScaffoldMessengerState>();
|
||||
|
||||
/// Controller for the group name input field
|
||||
final _groupNameController = TextEditingController();
|
||||
|
||||
/// List of currently selected players
|
||||
List<Player> selectedPlayers = [];
|
||||
|
||||
/// List of initially selected players (when editing a group)
|
||||
List<Player> initialSelectedPlayers = [];
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
db = Provider.of<AppDatabase>(context, listen: false);
|
||||
if (widget.groupToEdit != null) {
|
||||
_groupNameController.text = widget.groupToEdit!.name;
|
||||
setState(() {
|
||||
initialSelectedPlayers = widget.groupToEdit!.members;
|
||||
selectedPlayers = widget.groupToEdit!.members;
|
||||
});
|
||||
}
|
||||
_groupNameController.addListener(() {
|
||||
setState(() {});
|
||||
});
|
||||
@@ -64,15 +47,10 @@ class _CreateGroupViewState extends State<CreateGroupView> {
|
||||
Widget build(BuildContext context) {
|
||||
final loc = AppLocalizations.of(context);
|
||||
return ScaffoldMessenger(
|
||||
key: _scaffoldMessengerKey,
|
||||
child: Scaffold(
|
||||
resizeToAvoidBottomInset: false,
|
||||
backgroundColor: CustomTheme.backgroundColor,
|
||||
appBar: AppBar(
|
||||
title: Text(
|
||||
widget.groupToEdit == null ? loc.create_new_group : loc.edit_group,
|
||||
),
|
||||
),
|
||||
appBar: AppBar(title: Text(loc.create_new_group)),
|
||||
body: SafeArea(
|
||||
child: Column(
|
||||
mainAxisAlignment: MainAxisAlignment.start,
|
||||
@@ -87,7 +65,6 @@ class _CreateGroupViewState extends State<CreateGroupView> {
|
||||
),
|
||||
Expanded(
|
||||
child: PlayerSelection(
|
||||
initialSelectedPlayers: initialSelectedPlayers,
|
||||
onChanged: (value) {
|
||||
setState(() {
|
||||
selectedPlayers = [...value];
|
||||
@@ -96,16 +73,39 @@ class _CreateGroupViewState extends State<CreateGroupView> {
|
||||
),
|
||||
),
|
||||
CustomWidthButton(
|
||||
text: widget.groupToEdit == null
|
||||
? loc.create_group
|
||||
: loc.edit_group,
|
||||
text: loc.create_group,
|
||||
sizeRelativeToWidth: 0.95,
|
||||
buttonType: ButtonType.primary,
|
||||
onPressed:
|
||||
(_groupNameController.text.isEmpty ||
|
||||
(selectedPlayers.length < 2))
|
||||
? null
|
||||
: _saveGroup,
|
||||
: () async {
|
||||
bool success = await db.groupDao.addGroup(
|
||||
group: Group(
|
||||
name: _groupNameController.text.trim(),
|
||||
members: selectedPlayers,
|
||||
),
|
||||
);
|
||||
if (!context.mounted) return;
|
||||
if (success) {
|
||||
Navigator.pop(context);
|
||||
} else {
|
||||
ScaffoldMessenger.of(context).showSnackBar(
|
||||
SnackBar(
|
||||
backgroundColor: CustomTheme.boxColor,
|
||||
content: Center(
|
||||
child: Text(
|
||||
AppLocalizations.of(
|
||||
context,
|
||||
).error_creating_group,
|
||||
style: const TextStyle(color: Colors.white),
|
||||
),
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
},
|
||||
),
|
||||
const SizedBox(height: 20),
|
||||
],
|
||||
@@ -114,118 +114,4 @@ class _CreateGroupViewState extends State<CreateGroupView> {
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
/// Saves the group by creating a new one or updating the existing one,
|
||||
/// depending on whether the widget is in edit mode.
|
||||
Future<void> _saveGroup() async {
|
||||
final loc = AppLocalizations.of(context);
|
||||
late bool success;
|
||||
Group? updatedGroup;
|
||||
|
||||
if (widget.groupToEdit == null) {
|
||||
success = await _createGroup();
|
||||
} else {
|
||||
final result = await _editGroup();
|
||||
success = result.$1;
|
||||
updatedGroup = result.$2;
|
||||
}
|
||||
|
||||
if (!mounted) return;
|
||||
|
||||
if (success) {
|
||||
Navigator.pop(context, updatedGroup);
|
||||
} else {
|
||||
showSnackbar(
|
||||
message: widget.groupToEdit == null
|
||||
? loc.error_creating_group
|
||||
: loc.error_editing_group,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Handles creating a new group and returns whether the operation was successful.
|
||||
Future<bool> _createGroup() async {
|
||||
final groupName = _groupNameController.text.trim();
|
||||
|
||||
final success = await db.groupDao.addGroup(
|
||||
group: Group(name: groupName, description: '', members: selectedPlayers),
|
||||
);
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
/// Handles editing an existing group and returns a tuple of
|
||||
/// (success, updatedGroup).
|
||||
Future<(bool, Group?)> _editGroup() async {
|
||||
final groupName = _groupNameController.text.trim();
|
||||
|
||||
Group? updatedGroup = Group(
|
||||
id: widget.groupToEdit!.id,
|
||||
name: groupName,
|
||||
description: '',
|
||||
members: selectedPlayers,
|
||||
);
|
||||
|
||||
bool successfullNameChange = true;
|
||||
bool successfullMemberChange = true;
|
||||
|
||||
if (widget.groupToEdit!.name != groupName) {
|
||||
successfullNameChange = await db.groupDao.updateGroupName(
|
||||
groupId: widget.groupToEdit!.id,
|
||||
newName: groupName,
|
||||
);
|
||||
}
|
||||
|
||||
if (widget.groupToEdit!.members != selectedPlayers) {
|
||||
successfullMemberChange = await db.groupDao.replaceGroupPlayers(
|
||||
groupId: widget.groupToEdit!.id,
|
||||
newPlayers: selectedPlayers,
|
||||
);
|
||||
await deleteObsoleteMatchGroupRelations();
|
||||
widget.onMembersChanged?.call();
|
||||
}
|
||||
|
||||
final success = successfullNameChange && successfullMemberChange;
|
||||
|
||||
return (success, updatedGroup);
|
||||
}
|
||||
|
||||
/// Removes the group association from matches that no longer belong to the edited group.
|
||||
///
|
||||
/// After updating the group's members, matches that were previously linked to
|
||||
/// this group but don't have any of the newly selected players are considered
|
||||
/// obsolete. For each such match, the group association is removed by setting
|
||||
/// its [groupId] to null.
|
||||
Future<void> deleteObsoleteMatchGroupRelations() async {
|
||||
final groupMatches = await db.matchDao.getGroupMatches(
|
||||
groupId: widget.groupToEdit!.id,
|
||||
);
|
||||
|
||||
final selectedPlayerIds = selectedPlayers.map((p) => p.id).toSet();
|
||||
final relationshipsToDelete = groupMatches.where((match) {
|
||||
return !match.players.any(
|
||||
(player) => selectedPlayerIds.contains(player.id),
|
||||
);
|
||||
}).toList();
|
||||
|
||||
for (var match in relationshipsToDelete) {
|
||||
await db.matchDao.removeMatchGroup(matchId: match.id);
|
||||
}
|
||||
}
|
||||
|
||||
/// Displays a snackbar with the given message and optional action.
|
||||
///
|
||||
/// [message] The message to display in the snackbar.
|
||||
void showSnackbar({required String message}) {
|
||||
final messenger = _scaffoldMessengerKey.currentState;
|
||||
if (messenger != null) {
|
||||
messenger.hideCurrentSnackBar();
|
||||
messenger.showSnackBar(
|
||||
SnackBar(
|
||||
content: Text(message, style: const TextStyle(color: Colors.white)),
|
||||
backgroundColor: CustomTheme.boxColor,
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,27 +1,24 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:intl/intl.dart';
|
||||
import 'package:provider/provider.dart';
|
||||
import 'package:tallee/core/adaptive_page_route.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/group_view/create_group_view.dart';
|
||||
import 'package:tallee/presentation/widgets/app_skeleton.dart';
|
||||
import 'package:tallee/presentation/widgets/buttons/animated_dialog_button.dart';
|
||||
import 'package:tallee/presentation/widgets/buttons/main_menu_button.dart';
|
||||
import 'package:tallee/presentation/widgets/colored_icon_container.dart';
|
||||
import 'package:tallee/presentation/widgets/dialog/custom_alert_dialog.dart';
|
||||
import 'package:tallee/presentation/widgets/dialog/custom_dialog_action.dart';
|
||||
import 'package:tallee/presentation/widgets/custom_alert_dialog.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/info_tile.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/text_icon_tile.dart';
|
||||
|
||||
class GroupDetailView extends StatefulWidget {
|
||||
class GroupProfileView extends StatefulWidget {
|
||||
/// A view that displays the profile of a group
|
||||
/// - [group]: The group to display
|
||||
const GroupDetailView({
|
||||
const GroupProfileView({
|
||||
super.key,
|
||||
required this.group,
|
||||
required this.callback,
|
||||
@@ -33,24 +30,21 @@ class GroupDetailView extends StatefulWidget {
|
||||
final VoidCallback callback;
|
||||
|
||||
@override
|
||||
State<GroupDetailView> createState() => _GroupDetailViewState();
|
||||
State<GroupProfileView> createState() => _GroupProfileViewState();
|
||||
}
|
||||
|
||||
class _GroupDetailViewState extends State<GroupDetailView> {
|
||||
class _GroupProfileViewState extends State<GroupProfileView> {
|
||||
late final AppDatabase db;
|
||||
bool isLoading = true;
|
||||
late Group _group;
|
||||
|
||||
/// Total matches played in this group
|
||||
int totalMatches = 0;
|
||||
|
||||
/// The best player in this group
|
||||
String bestPlayer = '';
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
_group = widget.group;
|
||||
db = Provider.of<AppDatabase>(context, listen: false);
|
||||
_loadStatistics();
|
||||
}
|
||||
@@ -71,22 +65,29 @@ class _GroupDetailViewState extends State<GroupDetailView> {
|
||||
context: context,
|
||||
builder: (context) => CustomAlertDialog(
|
||||
title: '${loc.delete_group}?',
|
||||
content: Text(loc.this_cannot_be_undone),
|
||||
content: loc.this_cannot_be_undone,
|
||||
actions: [
|
||||
CustomDialogAction(
|
||||
onPressed: () => Navigator.of(context).pop(true),
|
||||
text: loc.delete,
|
||||
),
|
||||
CustomDialogAction(
|
||||
AnimatedDialogButton(
|
||||
onPressed: () => Navigator.of(context).pop(false),
|
||||
buttonType: ButtonType.secondary,
|
||||
text: loc.cancel,
|
||||
child: Text(
|
||||
loc.cancel,
|
||||
style: const TextStyle(color: CustomTheme.textColor),
|
||||
),
|
||||
),
|
||||
AnimatedDialogButton(
|
||||
onPressed: () => Navigator.of(context).pop(true),
|
||||
child: Text(
|
||||
loc.delete,
|
||||
style: const TextStyle(
|
||||
color: CustomTheme.secondaryColor,
|
||||
),
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
).then((confirmed) async {
|
||||
if (confirmed! && context.mounted) {
|
||||
await db.groupDao.deleteGroup(groupId: _group.id);
|
||||
await db.groupDao.deleteGroup(groupId: widget.group.id);
|
||||
if (!context.mounted) return;
|
||||
Navigator.pop(context);
|
||||
widget.callback.call();
|
||||
@@ -117,7 +118,7 @@ class _GroupDetailViewState extends State<GroupDetailView> {
|
||||
),
|
||||
const SizedBox(height: 10),
|
||||
Text(
|
||||
_group.name,
|
||||
widget.group.name,
|
||||
style: const TextStyle(
|
||||
fontSize: 28,
|
||||
fontWeight: FontWeight.bold,
|
||||
@@ -127,7 +128,7 @@ class _GroupDetailViewState extends State<GroupDetailView> {
|
||||
),
|
||||
const SizedBox(height: 5),
|
||||
Text(
|
||||
'${loc.created_on} ${DateFormat.yMMMd(Localizations.localeOf(context).toString()).format(_group.createdAt)}',
|
||||
'${loc.created_on} ${DateFormat.yMMMd(Localizations.localeOf(context).toString()).format(widget.group.createdAt)}',
|
||||
style: const TextStyle(
|
||||
fontSize: 12,
|
||||
color: CustomTheme.textColor,
|
||||
@@ -144,7 +145,7 @@ class _GroupDetailViewState extends State<GroupDetailView> {
|
||||
crossAxisAlignment: WrapCrossAlignment.start,
|
||||
spacing: 12,
|
||||
runSpacing: 8,
|
||||
children: _group.members.map((member) {
|
||||
children: widget.group.members.map((member) {
|
||||
return TextIconTile(
|
||||
text: member.name,
|
||||
iconEnabled: false,
|
||||
@@ -162,7 +163,7 @@ class _GroupDetailViewState extends State<GroupDetailView> {
|
||||
children: [
|
||||
_buildStatRow(
|
||||
loc.members,
|
||||
_group.members.length.toString(),
|
||||
widget.group.members.length.toString(),
|
||||
),
|
||||
_buildStatRow(
|
||||
loc.played_matches,
|
||||
@@ -180,27 +181,19 @@ class _GroupDetailViewState extends State<GroupDetailView> {
|
||||
child: MainMenuButton(
|
||||
text: loc.edit_group,
|
||||
icon: Icons.edit,
|
||||
onPressed: () async {
|
||||
final updatedGroup = await Navigator.push<Group?>(
|
||||
onPressed: () {
|
||||
// TODO: Uncomment when GroupDetailView is implemented
|
||||
/*
|
||||
await Navigator.push(
|
||||
context,
|
||||
adaptivePageRoute(
|
||||
builder: (context) {
|
||||
return CreateGroupView(
|
||||
groupToEdit: _group,
|
||||
onMembersChanged: () {
|
||||
_loadStatistics();
|
||||
},
|
||||
);
|
||||
|
||||
return const GroupDetailView();
|
||||
},
|
||||
),
|
||||
);
|
||||
if (updatedGroup != null && mounted) {
|
||||
setState(() {
|
||||
_group = updatedGroup;
|
||||
});
|
||||
_loadStatistics();
|
||||
widget.callback();
|
||||
}
|
||||
);*/
|
||||
print('Edit Group pressed');
|
||||
},
|
||||
),
|
||||
),
|
||||
@@ -241,8 +234,10 @@ class _GroupDetailViewState extends State<GroupDetailView> {
|
||||
|
||||
/// Loads statistics for this group
|
||||
Future<void> _loadStatistics() async {
|
||||
isLoading = true;
|
||||
final groupMatches = await db.matchDao.getGroupMatches(groupId: _group.id);
|
||||
final matches = await db.matchDao.getAllMatches();
|
||||
final groupMatches = matches
|
||||
.where((match) => match.group?.id == widget.group.id)
|
||||
.toList();
|
||||
|
||||
setState(() {
|
||||
totalMatches = groupMatches.length;
|
||||
@@ -257,9 +252,7 @@ class _GroupDetailViewState extends State<GroupDetailView> {
|
||||
|
||||
// Count wins for each player
|
||||
for (var match in matches) {
|
||||
if (match.winner != null &&
|
||||
_group.members.any((m) => m.id == match.winner?.id)) {
|
||||
print(match.winner);
|
||||
if (match.winner != null) {
|
||||
bestPlayerCounts.update(
|
||||
match.winner!,
|
||||
(value) => value + 1,
|
||||
@@ -4,25 +4,25 @@ import 'package:tallee/core/adaptive_page_route.dart';
|
||||
import 'package:tallee/core/constants.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/group_view/create_group_view.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/group_view/group_detail_view.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/group_view/group_profile_view.dart';
|
||||
import 'package:tallee/presentation/widgets/app_skeleton.dart';
|
||||
import 'package:tallee/presentation/widgets/buttons/main_menu_button.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/group_tile.dart';
|
||||
import 'package:tallee/presentation/widgets/top_centered_message.dart';
|
||||
|
||||
class GroupView extends StatefulWidget {
|
||||
class GroupsView extends StatefulWidget {
|
||||
/// A view that displays a list of groups
|
||||
const GroupView({super.key});
|
||||
const GroupsView({super.key});
|
||||
|
||||
@override
|
||||
State<GroupView> createState() => _GroupViewState();
|
||||
State<GroupsView> createState() => _GroupsViewState();
|
||||
}
|
||||
|
||||
class _GroupViewState extends State<GroupView> {
|
||||
class _GroupsViewState extends State<GroupsView> {
|
||||
late final AppDatabase db;
|
||||
|
||||
/// Loaded groups from the database
|
||||
@@ -35,8 +35,7 @@ class _GroupViewState extends State<GroupView> {
|
||||
7,
|
||||
Group(
|
||||
name: 'Skeleton Group',
|
||||
description: '',
|
||||
members: List.filled(6, Player(name: 'Skeleton Player', description: '')),
|
||||
members: List.filled(6, Player(name: 'Skeleton Player')),
|
||||
),
|
||||
);
|
||||
|
||||
@@ -83,7 +82,7 @@ class _GroupViewState extends State<GroupView> {
|
||||
context,
|
||||
adaptivePageRoute(
|
||||
builder: (context) {
|
||||
return GroupDetailView(
|
||||
return GroupProfileView(
|
||||
group: groups[index],
|
||||
callback: loadGroups,
|
||||
);
|
||||
@@ -2,12 +2,10 @@ import 'package:flutter/material.dart';
|
||||
import 'package:provider/provider.dart';
|
||||
import 'package:tallee/core/adaptive_page_route.dart';
|
||||
import 'package:tallee/core/constants.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/match_view/match_result_view.dart';
|
||||
import 'package:tallee/presentation/widgets/app_skeleton.dart';
|
||||
@@ -42,22 +40,13 @@ class _HomeViewState extends State<HomeView> {
|
||||
2,
|
||||
Match(
|
||||
name: 'Skeleton Match',
|
||||
game: Game(
|
||||
name: '',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
description: '',
|
||||
color: GameColor.blue,
|
||||
icon: '',
|
||||
),
|
||||
group: Group(
|
||||
name: 'Skeleton Group',
|
||||
description: '',
|
||||
members: [
|
||||
Player(name: 'Skeleton Player 1', description: ''),
|
||||
Player(name: 'Skeleton Player 2', description: ''),
|
||||
Player(name: 'Skeleton Player 1'),
|
||||
Player(name: 'Skeleton Player 2'),
|
||||
],
|
||||
),
|
||||
notes: '',
|
||||
),
|
||||
);
|
||||
|
||||
@@ -125,7 +114,7 @@ class _HomeViewState extends State<HomeView> {
|
||||
MatchResultView(match: match),
|
||||
),
|
||||
);
|
||||
await updatedWinnerInRecentMatches(match.id);
|
||||
await updatedWinnerinRecentMatches(match.id);
|
||||
},
|
||||
),
|
||||
)
|
||||
@@ -225,9 +214,9 @@ class _HomeViewState extends State<HomeView> {
|
||||
}
|
||||
|
||||
/// Updates the winner information for a specific match in the recent matches list.
|
||||
Future<void> updatedWinnerInRecentMatches(String matchId) async {
|
||||
Future<void> updatedWinnerinRecentMatches(String matchId) async {
|
||||
final db = Provider.of<AppDatabase>(context, listen: false);
|
||||
final winner = await db.scoreEntryDao.getWinner(matchId: matchId);
|
||||
final winner = await db.matchDao.getWinner(matchId: matchId);
|
||||
final matchIndex = recentMatches.indexWhere((match) => match.id == matchId);
|
||||
if (matchIndex != -1) {
|
||||
setState(() {
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:tallee/core/common.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/widgets/text_input/custom_search_bar.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/group_tile.dart';
|
||||
|
||||
@@ -5,10 +5,9 @@ import 'package:tallee/core/constants.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/match_view/create_match/choose_game_view.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/match_view/create_match/choose_group_view.dart';
|
||||
@@ -21,22 +20,11 @@ import 'package:tallee/presentation/widgets/tiles/choose_tile.dart';
|
||||
class CreateMatchView extends StatefulWidget {
|
||||
/// A view that allows creating a new match
|
||||
/// [onWinnerChanged]: Optional callback invoked when the winner is changed
|
||||
const CreateMatchView({
|
||||
super.key,
|
||||
this.onWinnerChanged,
|
||||
this.matchToEdit,
|
||||
this.onMatchUpdated,
|
||||
});
|
||||
const CreateMatchView({super.key, this.onWinnerChanged});
|
||||
|
||||
/// Optional callback invoked when the winner is changed
|
||||
final VoidCallback? onWinnerChanged;
|
||||
|
||||
/// Optional callback invoked when the match is updated
|
||||
final void Function(Match)? onMatchUpdated;
|
||||
|
||||
/// An optional match to prefill the fields
|
||||
final Match? matchToEdit;
|
||||
|
||||
@override
|
||||
State<CreateMatchView> createState() => _CreateMatchViewState();
|
||||
}
|
||||
@@ -56,18 +44,25 @@ class _CreateMatchViewState extends State<CreateMatchView> {
|
||||
/// List of all players from the database
|
||||
List<Player> playerList = [];
|
||||
|
||||
/// List of players filtered based on the selected group
|
||||
/// If a group is selected, this list contains all players from [playerList]
|
||||
/// who are not members of the selected group. If no group is selected,
|
||||
/// this list is identical to [playerList].
|
||||
List<Player> filteredPlayerList = [];
|
||||
|
||||
/// The currently selected group
|
||||
Group? selectedGroup;
|
||||
|
||||
/// The index of the currently selected group in [groupsList] to mark it in
|
||||
/// the [ChooseGroupView]
|
||||
String selectedGroupId = '';
|
||||
|
||||
/// The index of the currently selected game in [games] to mark it in
|
||||
/// the [ChooseGameView]
|
||||
int selectedGameIndex = -1;
|
||||
|
||||
/// The currently selected players
|
||||
List<Player> selectedPlayers = [];
|
||||
|
||||
/// GlobalKey for ScaffoldMessenger to show snackbars
|
||||
final _scaffoldMessengerKey = GlobalKey<ScaffoldMessengerState>();
|
||||
List<Player>? selectedPlayers;
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
@@ -84,11 +79,9 @@ class _CreateMatchViewState extends State<CreateMatchView> {
|
||||
]).then((result) async {
|
||||
groupsList = result[0] as List<Group>;
|
||||
playerList = result[1] as List<Player>;
|
||||
|
||||
// If a match is provided, prefill the fields
|
||||
if (widget.matchToEdit != null) {
|
||||
prefillMatchDetails();
|
||||
}
|
||||
setState(() {
|
||||
filteredPlayerList = List.from(playerList);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
@@ -106,26 +99,18 @@ class _CreateMatchViewState extends State<CreateMatchView> {
|
||||
}
|
||||
|
||||
List<(String, String, Ruleset)> games = [
|
||||
('Example Game 1', 'This is a description', Ruleset.lowestScore),
|
||||
('Example Game 1', 'This is a description', Ruleset.leastPoints),
|
||||
('Example Game 2', '', Ruleset.singleWinner),
|
||||
];
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final loc = AppLocalizations.of(context);
|
||||
final buttonText = widget.matchToEdit != null
|
||||
? loc.save_changes
|
||||
: loc.create_match;
|
||||
final viewTitle = widget.matchToEdit != null
|
||||
? loc.edit_match
|
||||
: loc.create_new_match;
|
||||
|
||||
return ScaffoldMessenger(
|
||||
key: _scaffoldMessengerKey,
|
||||
child: Scaffold(
|
||||
resizeToAvoidBottomInset: false,
|
||||
backgroundColor: CustomTheme.backgroundColor,
|
||||
appBar: AppBar(title: Text(viewTitle)),
|
||||
appBar: AppBar(title: Text(loc.create_new_match)),
|
||||
body: SafeArea(
|
||||
child: Column(
|
||||
mainAxisAlignment: MainAxisAlignment.start,
|
||||
@@ -167,54 +152,67 @@ class _CreateMatchViewState extends State<CreateMatchView> {
|
||||
? loc.none_group
|
||||
: selectedGroup!.name,
|
||||
onPressed: () async {
|
||||
// Remove all players from the previously selected group from
|
||||
// the selected players list, in case the user deselects the
|
||||
// group or selects a different group.
|
||||
selectedPlayers.removeWhere(
|
||||
(player) =>
|
||||
selectedGroup?.members.any(
|
||||
(member) => member.id == player.id,
|
||||
) ??
|
||||
false,
|
||||
);
|
||||
|
||||
selectedGroup = await Navigator.of(context).push(
|
||||
adaptivePageRoute(
|
||||
builder: (context) => ChooseGroupView(
|
||||
groups: groupsList,
|
||||
initialGroupId: selectedGroup?.id ?? '',
|
||||
initialGroupId: selectedGroupId,
|
||||
),
|
||||
),
|
||||
);
|
||||
|
||||
setState(() {
|
||||
selectedGroupId = selectedGroup?.id ?? '';
|
||||
if (selectedGroup != null) {
|
||||
setState(() {
|
||||
selectedPlayers += [...selectedGroup!.members];
|
||||
});
|
||||
filteredPlayerList = playerList
|
||||
.where(
|
||||
(p) =>
|
||||
!selectedGroup!.members.any((m) => m.id == p.id),
|
||||
)
|
||||
.toList();
|
||||
} else {
|
||||
filteredPlayerList = List.from(playerList);
|
||||
}
|
||||
});
|
||||
setState(() {});
|
||||
},
|
||||
),
|
||||
Expanded(
|
||||
child: PlayerSelection(
|
||||
key: ValueKey(selectedGroup?.id ?? 'no_group'),
|
||||
initialSelectedPlayers: selectedPlayers,
|
||||
initialSelectedPlayers: selectedPlayers ?? [],
|
||||
availablePlayers: filteredPlayerList,
|
||||
onChanged: (value) {
|
||||
setState(() {
|
||||
selectedPlayers = value;
|
||||
removeGroupWhenNoMemberLeft();
|
||||
});
|
||||
},
|
||||
),
|
||||
),
|
||||
CustomWidthButton(
|
||||
text: buttonText,
|
||||
text: loc.create_match,
|
||||
sizeRelativeToWidth: 0.95,
|
||||
buttonType: ButtonType.primary,
|
||||
onPressed: _enableCreateGameButton()
|
||||
? () {
|
||||
buttonNavigation(context);
|
||||
? () async {
|
||||
Match match = Match(
|
||||
name: _matchNameController.text.isEmpty
|
||||
? (hintText ?? '')
|
||||
: _matchNameController.text.trim(),
|
||||
createdAt: DateTime.now(),
|
||||
group: selectedGroup,
|
||||
players: selectedPlayers,
|
||||
);
|
||||
await db.matchDao.addMatch(match: match);
|
||||
if (context.mounted) {
|
||||
Navigator.pushReplacement(
|
||||
context,
|
||||
adaptivePageRoute(
|
||||
fullscreenDialog: true,
|
||||
builder: (context) => MatchResultView(
|
||||
match: match,
|
||||
onWinnerChanged: widget.onWinnerChanged,
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
: null,
|
||||
),
|
||||
@@ -232,156 +230,6 @@ class _CreateMatchViewState extends State<CreateMatchView> {
|
||||
/// - Either a group is selected OR at least 2 players are selected
|
||||
bool _enableCreateGameButton() {
|
||||
return (selectedGroup != null ||
|
||||
(selectedPlayers.length > 1) && selectedGameIndex != -1);
|
||||
}
|
||||
|
||||
// If a match was provided to the view, it updates the match in the database
|
||||
// and navigates back to the previous screen.
|
||||
// If no match was provided, it creates a new match in the database and
|
||||
// navigates to the MatchResultView for the newly created match.
|
||||
void buttonNavigation(BuildContext context) async {
|
||||
if (widget.matchToEdit != null) {
|
||||
await updateMatch();
|
||||
if (context.mounted) {
|
||||
Navigator.pop(context);
|
||||
}
|
||||
} else {
|
||||
final match = await createMatch();
|
||||
|
||||
if (context.mounted) {
|
||||
Navigator.pushReplacement(
|
||||
context,
|
||||
adaptivePageRoute(
|
||||
fullscreenDialog: true,
|
||||
builder: (context) => MatchResultView(
|
||||
match: match,
|
||||
onWinnerChanged: widget.onWinnerChanged,
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Updates attributes of the existing match in the database based on the
|
||||
/// changes made in the edit view.
|
||||
Future<void> updateMatch() async {
|
||||
//TODO: Remove when Games implemented
|
||||
final tempGame = await getTemporaryGame();
|
||||
|
||||
final updatedMatch = Match(
|
||||
id: widget.matchToEdit!.id,
|
||||
name: _matchNameController.text.isEmpty
|
||||
? (hintText ?? '')
|
||||
: _matchNameController.text.trim(),
|
||||
group: selectedGroup,
|
||||
players: selectedPlayers,
|
||||
game: tempGame,
|
||||
winner: widget.matchToEdit!.winner,
|
||||
createdAt: widget.matchToEdit!.createdAt,
|
||||
endedAt: widget.matchToEdit!.endedAt,
|
||||
notes: widget.matchToEdit!.notes,
|
||||
);
|
||||
|
||||
if (widget.matchToEdit!.name != updatedMatch.name) {
|
||||
await db.matchDao.updateMatchName(
|
||||
matchId: widget.matchToEdit!.id,
|
||||
newName: updatedMatch.name,
|
||||
);
|
||||
}
|
||||
|
||||
if (widget.matchToEdit!.group?.id != updatedMatch.group?.id) {
|
||||
await db.matchDao.updateMatchGroup(
|
||||
matchId: widget.matchToEdit!.id,
|
||||
newGroupId: updatedMatch.group?.id,
|
||||
);
|
||||
}
|
||||
|
||||
// Add players who are in updatedMatch but not in the original match
|
||||
for (var player in updatedMatch.players) {
|
||||
if (!widget.matchToEdit!.players.any((p) => p.id == player.id)) {
|
||||
await db.playerMatchDao.addPlayerToMatch(
|
||||
matchId: widget.matchToEdit!.id,
|
||||
playerId: player.id,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Remove players who are in the original match but not in updatedMatch
|
||||
for (var player in widget.matchToEdit!.players) {
|
||||
if (!updatedMatch.players.any((p) => p.id == player.id)) {
|
||||
await db.playerMatchDao.removePlayerFromMatch(
|
||||
matchId: widget.matchToEdit!.id,
|
||||
playerId: player.id,
|
||||
);
|
||||
if (widget.matchToEdit!.winner?.id == player.id) {
|
||||
updatedMatch.winner = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
widget.onMatchUpdated?.call(updatedMatch);
|
||||
}
|
||||
|
||||
// Creates a new match and adds it to the database.
|
||||
// Returns the created match.
|
||||
Future<Match> createMatch() async {
|
||||
final tempGame = await getTemporaryGame();
|
||||
|
||||
Match match = Match(
|
||||
name: _matchNameController.text.isEmpty
|
||||
? (hintText ?? '')
|
||||
: _matchNameController.text.trim(),
|
||||
createdAt: DateTime.now(),
|
||||
group: selectedGroup,
|
||||
players: selectedPlayers,
|
||||
game: tempGame,
|
||||
);
|
||||
await db.matchDao.addMatch(match: match);
|
||||
return match;
|
||||
}
|
||||
|
||||
// TODO: Remove when games fully implemented
|
||||
Future<Game> getTemporaryGame() async {
|
||||
Game? game;
|
||||
|
||||
final selectedGame = games[selectedGameIndex];
|
||||
game = Game(
|
||||
name: selectedGame.$1,
|
||||
description: selectedGame.$2,
|
||||
ruleset: selectedGame.$3,
|
||||
color: GameColor.blue,
|
||||
icon: '',
|
||||
);
|
||||
|
||||
await db.gameDao.addGame(game: game);
|
||||
return game;
|
||||
}
|
||||
|
||||
// If a match was provided to the view, this method prefills the input fields
|
||||
void prefillMatchDetails() {
|
||||
final match = widget.matchToEdit!;
|
||||
_matchNameController.text = match.name;
|
||||
selectedPlayers = match.players;
|
||||
selectedGameIndex = 0;
|
||||
|
||||
if (match.group != null) {
|
||||
selectedGroup = match.group;
|
||||
}
|
||||
}
|
||||
|
||||
// If none of the selected players are from the currently selected group,
|
||||
// the group is also deselected.
|
||||
Future<void> removeGroupWhenNoMemberLeft() async {
|
||||
if (selectedGroup == null) return;
|
||||
|
||||
if (!selectedPlayers.any(
|
||||
(player) =>
|
||||
selectedGroup!.members.any((member) => member.id == player.id),
|
||||
)) {
|
||||
setState(() {
|
||||
selectedGroup = null;
|
||||
});
|
||||
}
|
||||
(selectedPlayers != null && selectedPlayers!.length > 1));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,261 +0,0 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:intl/intl.dart';
|
||||
import 'package:provider/provider.dart';
|
||||
import 'package:tallee/core/adaptive_page_route.dart';
|
||||
import 'package:tallee/core/common.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/match_view/create_match/create_match_view.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/match_view/match_result_view.dart';
|
||||
import 'package:tallee/presentation/widgets/buttons/main_menu_button.dart';
|
||||
import 'package:tallee/presentation/widgets/colored_icon_container.dart';
|
||||
import 'package:tallee/presentation/widgets/dialog/custom_alert_dialog.dart';
|
||||
import 'package:tallee/presentation/widgets/dialog/custom_dialog_action.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/info_tile.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/text_icon_tile.dart';
|
||||
|
||||
class MatchDetailView extends StatefulWidget {
|
||||
/// A view that displays the profile of a match
|
||||
/// - [match]: The match to display
|
||||
/// - [onMatchUpdate]: Callback to refresh the match list
|
||||
const MatchDetailView({
|
||||
super.key,
|
||||
required this.match,
|
||||
required this.onMatchUpdate,
|
||||
});
|
||||
|
||||
/// The match to display
|
||||
final Match match;
|
||||
|
||||
/// Callback to refresh the match list
|
||||
final VoidCallback onMatchUpdate;
|
||||
|
||||
@override
|
||||
State<MatchDetailView> createState() => _MatchDetailViewState();
|
||||
}
|
||||
|
||||
class _MatchDetailViewState extends State<MatchDetailView> {
|
||||
late final AppDatabase db;
|
||||
|
||||
late Match match;
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
db = Provider.of<AppDatabase>(context, listen: false);
|
||||
match = widget.match;
|
||||
}
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final loc = AppLocalizations.of(context);
|
||||
|
||||
return Scaffold(
|
||||
backgroundColor: CustomTheme.backgroundColor,
|
||||
appBar: AppBar(
|
||||
title: Text(loc.match_profile),
|
||||
actions: [
|
||||
IconButton(
|
||||
icon: const Icon(Icons.delete),
|
||||
onPressed: () async {
|
||||
showDialog<bool>(
|
||||
context: context,
|
||||
builder: (context) => CustomAlertDialog(
|
||||
title: '${loc.delete_match}?',
|
||||
content: Text(loc.this_cannot_be_undone),
|
||||
actions: [
|
||||
CustomDialogAction(
|
||||
onPressed: () => Navigator.of(context).pop(true),
|
||||
text: loc.delete,
|
||||
),
|
||||
CustomDialogAction(
|
||||
onPressed: () => Navigator.of(context).pop(false),
|
||||
buttonType: ButtonType.secondary,
|
||||
text: loc.cancel,
|
||||
),
|
||||
],
|
||||
),
|
||||
).then((confirmed) async {
|
||||
if (confirmed! && context.mounted) {
|
||||
await db.matchDao.deleteMatch(matchId: match.id);
|
||||
if (!context.mounted) return;
|
||||
Navigator.pop(context);
|
||||
widget.onMatchUpdate.call();
|
||||
}
|
||||
});
|
||||
},
|
||||
),
|
||||
],
|
||||
),
|
||||
body: SafeArea(
|
||||
child: Stack(
|
||||
alignment: Alignment.center,
|
||||
children: [
|
||||
ListView(
|
||||
padding: const EdgeInsets.only(
|
||||
left: 12,
|
||||
right: 12,
|
||||
top: 20,
|
||||
bottom: 100,
|
||||
),
|
||||
children: [
|
||||
const Center(
|
||||
child: ColoredIconContainer(
|
||||
icon: Icons.sports_esports,
|
||||
containerSize: 55,
|
||||
iconSize: 38,
|
||||
),
|
||||
),
|
||||
const SizedBox(height: 10),
|
||||
Text(
|
||||
match.name,
|
||||
style: const TextStyle(
|
||||
fontSize: 28,
|
||||
fontWeight: FontWeight.bold,
|
||||
color: CustomTheme.textColor,
|
||||
),
|
||||
textAlign: TextAlign.center,
|
||||
),
|
||||
const SizedBox(height: 5),
|
||||
Text(
|
||||
'${loc.created_on} ${DateFormat.yMMMd(Localizations.localeOf(context).toString()).format(match.createdAt)}',
|
||||
style: const TextStyle(
|
||||
fontSize: 12,
|
||||
color: CustomTheme.textColor,
|
||||
),
|
||||
textAlign: TextAlign.center,
|
||||
),
|
||||
const SizedBox(height: 10),
|
||||
if (match.group != null) ...[
|
||||
Row(
|
||||
mainAxisAlignment: MainAxisAlignment.center,
|
||||
children: [
|
||||
const Icon(Icons.group),
|
||||
const SizedBox(width: 8),
|
||||
Text(
|
||||
'${match.group!.name}${getExtraPlayerCount(match)}',
|
||||
style: const TextStyle(fontWeight: FontWeight.bold),
|
||||
),
|
||||
],
|
||||
),
|
||||
const SizedBox(height: 20),
|
||||
],
|
||||
InfoTile(
|
||||
title: loc.players,
|
||||
icon: Icons.people,
|
||||
horizontalAlignment: CrossAxisAlignment.start,
|
||||
content: Wrap(
|
||||
alignment: WrapAlignment.start,
|
||||
crossAxisAlignment: WrapCrossAlignment.start,
|
||||
spacing: 12,
|
||||
runSpacing: 8,
|
||||
children: match.players.map((player) {
|
||||
return TextIconTile(
|
||||
text: player.name,
|
||||
iconEnabled: false,
|
||||
);
|
||||
}).toList(),
|
||||
),
|
||||
),
|
||||
const SizedBox(height: 15),
|
||||
InfoTile(
|
||||
title: loc.results,
|
||||
icon: Icons.emoji_events,
|
||||
content: Padding(
|
||||
padding: const EdgeInsets.symmetric(
|
||||
vertical: 4,
|
||||
horizontal: 8,
|
||||
),
|
||||
child: Row(
|
||||
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
||||
children: [
|
||||
/// TODO: Implement different ruleset results display
|
||||
if (match.winner != null) ...[
|
||||
Text(
|
||||
loc.winner,
|
||||
style: const TextStyle(
|
||||
fontSize: 16,
|
||||
color: CustomTheme.textColor,
|
||||
),
|
||||
),
|
||||
Text(
|
||||
match.winner!.name,
|
||||
style: const TextStyle(
|
||||
fontSize: 16,
|
||||
fontWeight: FontWeight.bold,
|
||||
color: CustomTheme.primaryColor,
|
||||
),
|
||||
),
|
||||
] else ...[
|
||||
Text(
|
||||
loc.no_results_entered_yet,
|
||||
style: const TextStyle(
|
||||
fontSize: 14,
|
||||
color: CustomTheme.textColor,
|
||||
),
|
||||
),
|
||||
],
|
||||
],
|
||||
),
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
Positioned(
|
||||
bottom: MediaQuery.paddingOf(context).bottom,
|
||||
child: Row(
|
||||
children: [
|
||||
MainMenuButton(
|
||||
icon: Icons.edit,
|
||||
onPressed: () => Navigator.push(
|
||||
context,
|
||||
adaptivePageRoute(
|
||||
fullscreenDialog: true,
|
||||
builder: (context) => CreateMatchView(
|
||||
matchToEdit: match,
|
||||
onMatchUpdated: onMatchUpdated,
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
const SizedBox(width: 15),
|
||||
MainMenuButton(
|
||||
text: loc.enter_results,
|
||||
icon: Icons.emoji_events,
|
||||
onPressed: () async {
|
||||
match.winner = await Navigator.push(
|
||||
context,
|
||||
adaptivePageRoute(
|
||||
fullscreenDialog: true,
|
||||
builder: (context) => MatchResultView(
|
||||
match: match,
|
||||
onWinnerChanged: () {
|
||||
widget.onMatchUpdate.call();
|
||||
setState(() {});
|
||||
},
|
||||
),
|
||||
),
|
||||
);
|
||||
},
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
/// Callback for when the match is updated in the edit view,
|
||||
/// updates the match in this view
|
||||
void onMatchUpdated(Match editedMatch) {
|
||||
setState(() {
|
||||
match = editedMatch;
|
||||
});
|
||||
widget.onMatchUpdate.call();
|
||||
}
|
||||
}
|
||||
@@ -2,8 +2,8 @@ import 'package:flutter/material.dart';
|
||||
import 'package:provider/provider.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/custom_radio_list_tile.dart';
|
||||
|
||||
@@ -35,10 +35,7 @@ class _MatchResultViewState extends State<MatchResultView> {
|
||||
@override
|
||||
void initState() {
|
||||
db = Provider.of<AppDatabase>(context, listen: false);
|
||||
|
||||
allPlayers = widget.match.players;
|
||||
allPlayers.sort((a, b) => a.name.compareTo(b.name));
|
||||
|
||||
allPlayers = getAllPlayers(widget.match);
|
||||
if (widget.match.winner != null) {
|
||||
_selectedPlayer = allPlayers.firstWhere(
|
||||
(p) => p.id == widget.match.winner!.id,
|
||||
@@ -57,7 +54,7 @@ class _MatchResultViewState extends State<MatchResultView> {
|
||||
icon: const Icon(Icons.close),
|
||||
onPressed: () {
|
||||
widget.onWinnerChanged?.call();
|
||||
Navigator.of(context).pop(_selectedPlayer);
|
||||
Navigator.of(context).pop();
|
||||
},
|
||||
),
|
||||
title: Text(widget.match.name),
|
||||
@@ -77,7 +74,7 @@ class _MatchResultViewState extends State<MatchResultView> {
|
||||
),
|
||||
decoration: BoxDecoration(
|
||||
color: CustomTheme.boxColor,
|
||||
border: Border.all(color: CustomTheme.boxBorderColor),
|
||||
border: Border.all(color: CustomTheme.boxBorder),
|
||||
borderRadius: BorderRadius.circular(12),
|
||||
),
|
||||
child: Column(
|
||||
@@ -139,13 +136,32 @@ class _MatchResultViewState extends State<MatchResultView> {
|
||||
/// based on the current selection.
|
||||
Future<void> _handleWinnerSaving() async {
|
||||
if (_selectedPlayer == null) {
|
||||
await db.scoreEntryDao.removeWinner(matchId: widget.match.id);
|
||||
await db.matchDao.removeWinner(matchId: widget.match.id);
|
||||
} else {
|
||||
await db.scoreEntryDao.setWinner(
|
||||
await db.matchDao.setWinner(
|
||||
matchId: widget.match.id,
|
||||
playerId: _selectedPlayer!.id,
|
||||
winnerId: _selectedPlayer!.id,
|
||||
);
|
||||
}
|
||||
widget.onWinnerChanged?.call();
|
||||
}
|
||||
|
||||
/// Retrieves all players associated with the given [match].
|
||||
/// This includes players directly assigned to the match
|
||||
/// as well as members of the group (if any).
|
||||
/// The returned list is sorted alphabetically by player name.
|
||||
List<Player> getAllPlayers(Match match) {
|
||||
List<Player> players = [];
|
||||
|
||||
if (match.group == null && match.players != null) {
|
||||
players = [...match.players!];
|
||||
} else if (match.group != null && match.players != null) {
|
||||
players = [...match.players!, ...match.group!.members];
|
||||
} else {
|
||||
players = [...match.group!.members];
|
||||
}
|
||||
|
||||
players.sort((a, b) => a.name.compareTo(b.name));
|
||||
return players;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,18 +1,18 @@
|
||||
import 'dart:core' hide Match;
|
||||
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:fluttericon/rpg_awesome_icons.dart';
|
||||
import 'package:provider/provider.dart';
|
||||
import 'package:tallee/core/adaptive_page_route.dart';
|
||||
import 'package:tallee/core/constants.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/match_view/create_match/create_match_view.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/match_view/match_detail_view.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/match_view/match_result_view.dart';
|
||||
import 'package:tallee/presentation/widgets/app_skeleton.dart';
|
||||
import 'package:tallee/presentation/widgets/buttons/main_menu_button.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/match_tile.dart';
|
||||
@@ -36,21 +36,12 @@ class _MatchViewState extends State<MatchView> {
|
||||
4,
|
||||
Match(
|
||||
name: 'Skeleton match name',
|
||||
game: Game(
|
||||
name: '',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
description: '',
|
||||
color: GameColor.blue,
|
||||
icon: '',
|
||||
),
|
||||
group: Group(
|
||||
name: 'Group name',
|
||||
description: '',
|
||||
members: List.filled(5, Player(name: 'Player', description: '')),
|
||||
members: List.filled(5, Player(name: 'Player')),
|
||||
),
|
||||
winner: Player(name: 'Player', description: ''),
|
||||
players: [Player(name: 'Player', description: '')],
|
||||
notes: '',
|
||||
winner: Player(name: 'Player'),
|
||||
players: [Player(name: 'Player')],
|
||||
),
|
||||
);
|
||||
|
||||
@@ -58,7 +49,7 @@ class _MatchViewState extends State<MatchView> {
|
||||
void initState() {
|
||||
super.initState();
|
||||
db = Provider.of<AppDatabase>(context, listen: false);
|
||||
loadMatches();
|
||||
loadGames();
|
||||
}
|
||||
|
||||
@override
|
||||
@@ -98,9 +89,10 @@ class _MatchViewState extends State<MatchView> {
|
||||
Navigator.push(
|
||||
context,
|
||||
adaptivePageRoute(
|
||||
builder: (context) => MatchDetailView(
|
||||
fullscreenDialog: true,
|
||||
builder: (context) => MatchResultView(
|
||||
match: matches[index],
|
||||
onMatchUpdate: loadMatches,
|
||||
onWinnerChanged: loadGames,
|
||||
),
|
||||
),
|
||||
);
|
||||
@@ -123,7 +115,7 @@ class _MatchViewState extends State<MatchView> {
|
||||
context,
|
||||
adaptivePageRoute(
|
||||
builder: (context) =>
|
||||
CreateMatchView(onWinnerChanged: loadMatches),
|
||||
CreateMatchView(onWinnerChanged: loadGames),
|
||||
),
|
||||
);
|
||||
},
|
||||
@@ -134,9 +126,8 @@ class _MatchViewState extends State<MatchView> {
|
||||
);
|
||||
}
|
||||
|
||||
/// Loads the matches from the database and sorts them by creation date.
|
||||
void loadMatches() {
|
||||
isLoading = true;
|
||||
/// Loads the games from the database and sorts them by creation date.
|
||||
void loadGames() {
|
||||
Future.wait([
|
||||
db.matchDao.getAllMatches(),
|
||||
Future.delayed(Constants.MINIMUM_SKELETON_DURATION),
|
||||
@@ -144,7 +135,7 @@ class _MatchViewState extends State<MatchView> {
|
||||
if (mounted) {
|
||||
setState(() {
|
||||
final loadedMatches = results[0] as List<Match>;
|
||||
matches = [...loadedMatches]
|
||||
matches = loadedMatches
|
||||
..sort((a, b) => b.createdAt.compareTo(a.createdAt));
|
||||
isLoading = false;
|
||||
});
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -9,8 +9,8 @@ import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/views/main_menu/settings_view/licenses_view.dart';
|
||||
import 'package:tallee/presentation/widgets/dialog/custom_alert_dialog.dart';
|
||||
import 'package:tallee/presentation/widgets/dialog/custom_dialog_action.dart';
|
||||
import 'package:tallee/presentation/widgets/buttons/animated_dialog_button.dart';
|
||||
import 'package:tallee/presentation/widgets/custom_alert_dialog.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/settings_list_tile.dart';
|
||||
import 'package:tallee/services/data_transfer_service.dart';
|
||||
import 'package:url_launcher/url_launcher.dart';
|
||||
@@ -31,7 +31,6 @@ class _SettingsViewState extends State<SettingsView> {
|
||||
version: 'n.A.',
|
||||
buildNumber: 'n.A.',
|
||||
);
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
@@ -122,16 +121,25 @@ class _SettingsViewState extends State<SettingsView> {
|
||||
context: context,
|
||||
builder: (context) => CustomAlertDialog(
|
||||
title: '${loc.delete_all_data}?',
|
||||
content: Text(loc.this_cannot_be_undone),
|
||||
content: loc.this_cannot_be_undone,
|
||||
actions: [
|
||||
CustomDialogAction(
|
||||
onPressed: () => Navigator.of(context).pop(true),
|
||||
text: loc.delete,
|
||||
),
|
||||
CustomDialogAction(
|
||||
AnimatedDialogButton(
|
||||
onPressed: () => Navigator.of(context).pop(false),
|
||||
buttonType: ButtonType.secondary,
|
||||
text: loc.cancel,
|
||||
child: Text(
|
||||
loc.cancel,
|
||||
style: const TextStyle(
|
||||
color: CustomTheme.textColor,
|
||||
),
|
||||
),
|
||||
),
|
||||
AnimatedDialogButton(
|
||||
onPressed: () => Navigator.of(context).pop(true),
|
||||
child: Text(
|
||||
loc.delete,
|
||||
style: const TextStyle(
|
||||
color: CustomTheme.secondaryColor,
|
||||
),
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
|
||||
@@ -2,8 +2,8 @@ import 'package:flutter/material.dart';
|
||||
import 'package:provider/provider.dart';
|
||||
import 'package:tallee/core/constants.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/widgets/app_skeleton.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/statistics_tile.dart';
|
||||
@@ -167,8 +167,7 @@ class _StatisticsViewState extends State<StatisticsView> {
|
||||
final playerId = winCounts[i].$1;
|
||||
final player = players.firstWhere(
|
||||
(p) => p.id == playerId,
|
||||
orElse: () =>
|
||||
Player(id: playerId, name: loc.not_available, description: ''),
|
||||
orElse: () => Player(id: playerId, name: loc.not_available),
|
||||
);
|
||||
winCounts[i] = (player.name, winCounts[i].$2);
|
||||
}
|
||||
@@ -203,7 +202,8 @@ class _StatisticsViewState extends State<StatisticsView> {
|
||||
}
|
||||
}
|
||||
}
|
||||
final members = match.players.map((p) => p.id).toList();
|
||||
if (match.players != null) {
|
||||
final members = match.players!.map((p) => p.id).toList();
|
||||
for (var playerId in members) {
|
||||
final index = matchCounts.indexWhere((entry) => entry.$1 == playerId);
|
||||
// -1 means player not found in matchCounts
|
||||
@@ -215,6 +215,7 @@ class _StatisticsViewState extends State<StatisticsView> {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Adding all players with zero matches
|
||||
for (var player in players) {
|
||||
@@ -230,8 +231,7 @@ class _StatisticsViewState extends State<StatisticsView> {
|
||||
final playerId = matchCounts[i].$1;
|
||||
final player = players.firstWhere(
|
||||
(p) => p.id == playerId,
|
||||
orElse: () =>
|
||||
Player(id: playerId, name: loc.not_available, description: ''),
|
||||
orElse: () => Player(id: playerId, name: loc.not_available),
|
||||
);
|
||||
matchCounts[i] = (player.name, matchCounts[i].$2);
|
||||
}
|
||||
|
||||
@@ -47,7 +47,10 @@ class _AppSkeletonState extends State<AppSkeleton> {
|
||||
: (Widget? currentChild, List<Widget> previousChildren) {
|
||||
return Stack(
|
||||
alignment: Alignment.topCenter,
|
||||
children: [...previousChildren, ?currentChild],
|
||||
children: [
|
||||
...previousChildren,
|
||||
if (currentChild != null) currentChild,
|
||||
],
|
||||
);
|
||||
},
|
||||
),
|
||||
|
||||
@@ -1,28 +1,22 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
|
||||
class AnimatedDialogButton extends StatefulWidget {
|
||||
/// A custom animated button widget that provides a scaling and opacity effect
|
||||
/// when pressed.
|
||||
/// - [onPressed]: Callback function that is triggered when the button is pressed.
|
||||
/// - [buttonText]: The text to be displayed on the button.
|
||||
/// - [buttonType]: The type of the button, which determines its styling.
|
||||
/// - [buttonConstraints]: Optional constraints to control the button's size.
|
||||
/// - [child]: The child widget to be displayed inside the button, typically a text or icon.
|
||||
const AnimatedDialogButton({
|
||||
super.key,
|
||||
required this.buttonText,
|
||||
required this.onPressed,
|
||||
this.buttonConstraints,
|
||||
this.buttonType = ButtonType.primary,
|
||||
required this.child,
|
||||
});
|
||||
|
||||
final String buttonText;
|
||||
|
||||
/// Callback function that is triggered when the button is pressed.
|
||||
final VoidCallback onPressed;
|
||||
|
||||
final BoxConstraints? buttonConstraints;
|
||||
|
||||
final ButtonType buttonType;
|
||||
/// The child widget to be displayed inside the button, typically a text or icon.
|
||||
final Widget child;
|
||||
|
||||
@override
|
||||
State<AnimatedDialogButton> createState() => _AnimatedDialogButtonState();
|
||||
@@ -33,29 +27,6 @@ class _AnimatedDialogButtonState extends State<AnimatedDialogButton> {
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final textStyling = TextStyle(
|
||||
color: widget.buttonType == ButtonType.primary
|
||||
? Colors.black
|
||||
: Colors.white,
|
||||
fontSize: 16,
|
||||
fontWeight: FontWeight.bold,
|
||||
);
|
||||
|
||||
final buttonDecoration = widget.buttonType == ButtonType.primary
|
||||
// Primary
|
||||
? BoxDecoration(
|
||||
color: Colors.white,
|
||||
borderRadius: BorderRadius.circular(12),
|
||||
)
|
||||
: widget.buttonType == ButtonType.secondary
|
||||
// Secondary
|
||||
? BoxDecoration(
|
||||
border: BoxBorder.all(color: Colors.white, width: 2),
|
||||
borderRadius: BorderRadius.circular(12),
|
||||
)
|
||||
// Tertiary
|
||||
: const BoxDecoration();
|
||||
|
||||
return GestureDetector(
|
||||
onTapDown: (_) => setState(() => _isPressed = true),
|
||||
onTapUp: (_) => setState(() => _isPressed = false),
|
||||
@@ -67,18 +38,10 @@ class _AnimatedDialogButtonState extends State<AnimatedDialogButton> {
|
||||
child: AnimatedOpacity(
|
||||
opacity: _isPressed ? 0.6 : 1.0,
|
||||
duration: const Duration(milliseconds: 100),
|
||||
child: Center(
|
||||
child: Container(
|
||||
constraints: widget.buttonConstraints,
|
||||
decoration: buttonDecoration,
|
||||
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
|
||||
margin: const EdgeInsets.symmetric(vertical: 8),
|
||||
child: Text(
|
||||
widget.buttonText,
|
||||
style: textStyling,
|
||||
textAlign: TextAlign.center,
|
||||
),
|
||||
),
|
||||
decoration: CustomTheme.standardBoxDecoration,
|
||||
padding: const EdgeInsets.symmetric(horizontal: 26, vertical: 6),
|
||||
child: widget.child,
|
||||
),
|
||||
),
|
||||
),
|
||||
|
||||
@@ -2,25 +2,25 @@ import 'package:flutter/material.dart';
|
||||
|
||||
class MainMenuButton extends StatefulWidget {
|
||||
/// A button for the main menu with an optional icon and a press animation.
|
||||
/// - [onPressed]: The callback to be invoked when the button is pressed.
|
||||
/// - [icon]: The icon of the button.
|
||||
/// - [text]: The text of the button.
|
||||
/// - [icon]: The icon of the button.
|
||||
/// - [onPressed]: The callback to be invoked when the button is pressed.
|
||||
const MainMenuButton({
|
||||
super.key,
|
||||
required this.text,
|
||||
this.icon,
|
||||
required this.onPressed,
|
||||
required this.icon,
|
||||
this.text,
|
||||
});
|
||||
|
||||
/// The text of the button.
|
||||
final String text;
|
||||
|
||||
/// The icon of the button.
|
||||
final IconData? icon;
|
||||
|
||||
/// The callback to be invoked when the button is pressed.
|
||||
final void Function() onPressed;
|
||||
|
||||
/// The icon of the button.
|
||||
final IconData icon;
|
||||
|
||||
/// The text of the button.
|
||||
final String? text;
|
||||
|
||||
@override
|
||||
State<MainMenuButton> createState() => _MainMenuButtonState();
|
||||
}
|
||||
@@ -71,11 +71,12 @@ class _MainMenuButtonState extends State<MainMenuButton>
|
||||
mainAxisSize: MainAxisSize.min,
|
||||
mainAxisAlignment: MainAxisAlignment.center,
|
||||
children: [
|
||||
if (widget.icon != null) ...[
|
||||
Icon(widget.icon, size: 26, color: Colors.black),
|
||||
if (widget.text != null) ...[
|
||||
const SizedBox(width: 7),
|
||||
],
|
||||
Text(
|
||||
widget.text!,
|
||||
widget.text,
|
||||
style: const TextStyle(
|
||||
fontSize: 18,
|
||||
fontWeight: FontWeight.bold,
|
||||
@@ -83,7 +84,6 @@ class _MainMenuButtonState extends State<MainMenuButton>
|
||||
),
|
||||
),
|
||||
],
|
||||
],
|
||||
),
|
||||
),
|
||||
),
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/presentation/widgets/dialog/custom_dialog_action.dart';
|
||||
|
||||
class CustomAlertDialog extends StatelessWidget {
|
||||
/// A custom alert dialog widget that provides a os unspecific AlertDialog,
|
||||
@@ -17,26 +16,23 @@ class CustomAlertDialog extends StatelessWidget {
|
||||
});
|
||||
|
||||
final String title;
|
||||
final Widget content;
|
||||
final List<CustomDialogAction> actions;
|
||||
final String content;
|
||||
final List<Widget> actions;
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
return AlertDialog(
|
||||
title: Text(
|
||||
title,
|
||||
style: const TextStyle(
|
||||
fontWeight: FontWeight.bold,
|
||||
color: CustomTheme.textColor,
|
||||
title: Text(title, style: const TextStyle(color: CustomTheme.textColor)),
|
||||
content: Text(
|
||||
content,
|
||||
style: const TextStyle(color: CustomTheme.textColor),
|
||||
),
|
||||
),
|
||||
content: content,
|
||||
actions: actions,
|
||||
backgroundColor: CustomTheme.boxColor,
|
||||
actionsAlignment: MainAxisAlignment.center,
|
||||
actionsAlignment: MainAxisAlignment.spaceAround,
|
||||
shape: RoundedRectangleBorder(
|
||||
borderRadius: CustomTheme.standardBorderRadiusAll,
|
||||
side: const BorderSide(color: CustomTheme.boxBorderColor),
|
||||
side: const BorderSide(color: CustomTheme.boxBorder),
|
||||
),
|
||||
);
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
import 'package:flutter/cupertino.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/presentation/widgets/buttons/animated_dialog_button.dart';
|
||||
|
||||
class CustomDialogAction extends StatelessWidget {
|
||||
/// A custom dialog action widget that represents a button in a dialog.
|
||||
/// - [text]: The text to be displayed on the button.
|
||||
/// - [buttonType]: The type of the button, which determines its styling.
|
||||
/// - [onPressed]: Callback function that is triggered when the button is pressed.
|
||||
const CustomDialogAction({
|
||||
super.key,
|
||||
required this.onPressed,
|
||||
required this.text,
|
||||
this.buttonType = ButtonType.primary,
|
||||
});
|
||||
|
||||
final String text;
|
||||
|
||||
final ButtonType buttonType;
|
||||
|
||||
final VoidCallback onPressed;
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
return AnimatedDialogButton(
|
||||
onPressed: onPressed,
|
||||
buttonText: text,
|
||||
buttonType: buttonType,
|
||||
buttonConstraints: const BoxConstraints(minWidth: 300),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -87,17 +87,7 @@ class _NavbarItemState extends State<NavbarItem>
|
||||
mainAxisSize: MainAxisSize.min,
|
||||
mainAxisAlignment: MainAxisAlignment.center,
|
||||
children: [
|
||||
AnimatedContainer(
|
||||
width: 50,
|
||||
height: 50,
|
||||
decoration: BoxDecoration(
|
||||
color: widget.isSelected
|
||||
? CustomTheme.primaryColor.withAlpha(50)
|
||||
: Colors.transparent,
|
||||
borderRadius: const BorderRadius.all(Radius.circular(15)),
|
||||
),
|
||||
duration: const Duration(milliseconds: 200),
|
||||
child: ScaleTransition(
|
||||
ScaleTransition(
|
||||
scale: widget.isSelected
|
||||
? _scaleAnimation
|
||||
: const AlwaysStoppedAnimation(1.0),
|
||||
@@ -109,7 +99,7 @@ class _NavbarItemState extends State<NavbarItem>
|
||||
size: 32,
|
||||
),
|
||||
),
|
||||
),
|
||||
const SizedBox(height: 4),
|
||||
Text(
|
||||
widget.label,
|
||||
style: TextStyle(
|
||||
|
||||
@@ -3,7 +3,7 @@ import 'package:provider/provider.dart';
|
||||
import 'package:tallee/core/constants.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/widgets/app_skeleton.dart';
|
||||
import 'package:tallee/presentation/widgets/text_input/custom_search_bar.dart';
|
||||
@@ -62,7 +62,7 @@ class _PlayerSelectionState extends State<PlayerSelection> {
|
||||
/// Skeleton data used while loading players.
|
||||
late final List<Player> skeletonData = List.filled(
|
||||
7,
|
||||
Player(name: 'Player 0', description: ''),
|
||||
Player(name: 'Player 0'),
|
||||
);
|
||||
|
||||
@override
|
||||
@@ -70,7 +70,6 @@ class _PlayerSelectionState extends State<PlayerSelection> {
|
||||
super.initState();
|
||||
db = Provider.of<AppDatabase>(context, listen: false);
|
||||
suggestedPlayers = skeletonData;
|
||||
selectedPlayers = widget.initialSelectedPlayers ?? [];
|
||||
loadPlayerList();
|
||||
}
|
||||
|
||||
@@ -101,7 +100,7 @@ class _PlayerSelectionState extends State<PlayerSelection> {
|
||||
if (value.isEmpty) {
|
||||
// If the search is empty, it shows all unselected players.
|
||||
suggestedPlayers = allPlayers.where((player) {
|
||||
return !selectedPlayers.any((p) => p.id == player.id);
|
||||
return !selectedPlayers.contains(player);
|
||||
}).toList();
|
||||
} else {
|
||||
// If there is input, it filters by name match (case-insensitive) and ensures
|
||||
@@ -110,8 +109,8 @@ class _PlayerSelectionState extends State<PlayerSelection> {
|
||||
final bool nameMatches = player.name.toLowerCase().contains(
|
||||
value.toLowerCase(),
|
||||
);
|
||||
final bool isNotSelected = !selectedPlayers.any(
|
||||
(p) => p.id == player.id,
|
||||
final bool isNotSelected = !selectedPlayers.contains(
|
||||
player,
|
||||
);
|
||||
return nameMatches && isNotSelected;
|
||||
}).toList();
|
||||
@@ -127,8 +126,6 @@ class _PlayerSelectionState extends State<PlayerSelection> {
|
||||
const SizedBox(height: 10),
|
||||
SizedBox(
|
||||
height: 50,
|
||||
child: AppSkeleton(
|
||||
enabled: isLoading,
|
||||
child: selectedPlayers.isEmpty
|
||||
? Center(child: Text(loc.no_players_selected))
|
||||
: SingleChildScrollView(
|
||||
@@ -170,7 +167,6 @@ class _PlayerSelectionState extends State<PlayerSelection> {
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
const SizedBox(height: 10),
|
||||
Text(
|
||||
loc.all_players,
|
||||
@@ -226,9 +222,8 @@ class _PlayerSelectionState extends State<PlayerSelection> {
|
||||
db.playerDao.getAllPlayers(),
|
||||
Future.delayed(Constants.MINIMUM_SKELETON_DURATION),
|
||||
]).then((results) => results[0] as List<Player>);
|
||||
|
||||
if (mounted) {
|
||||
_allPlayersFuture.then((loadedPlayers) {
|
||||
if (!mounted) return;
|
||||
setState(() {
|
||||
// If a list of available players is provided (even if empty), use that list.
|
||||
if (widget.availablePlayers != null) {
|
||||
@@ -250,30 +245,13 @@ class _PlayerSelectionState extends State<PlayerSelection> {
|
||||
// Otherwise, use the loaded players from the database.
|
||||
loadedPlayers.sort((a, b) => a.name.compareTo(b.name));
|
||||
allPlayers = [...loadedPlayers];
|
||||
if (widget.initialSelectedPlayers != null) {
|
||||
// Excludes already selected players from the suggested players list.
|
||||
suggestedPlayers = loadedPlayers
|
||||
.where(
|
||||
(p) => !widget.initialSelectedPlayers!.any(
|
||||
(ip) => ip.id == p.id,
|
||||
),
|
||||
)
|
||||
.toList();
|
||||
// Ensures that only players available for selection are pre-selected.
|
||||
selectedPlayers = widget.initialSelectedPlayers!
|
||||
.where(
|
||||
(p) => allPlayers.any((available) => available.id == p.id),
|
||||
)
|
||||
.toList();
|
||||
} else {
|
||||
// If no initial selection, all loaded players are suggested.
|
||||
suggestedPlayers = [...loadedPlayers];
|
||||
}
|
||||
}
|
||||
isLoading = false;
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/// Adds a new player to the database from the search bar input.
|
||||
/// Shows a snackbar indicating success or failure.
|
||||
@@ -282,7 +260,7 @@ class _PlayerSelectionState extends State<PlayerSelection> {
|
||||
final loc = AppLocalizations.of(context);
|
||||
final playerName = _searchBarController.text.trim();
|
||||
|
||||
final createdPlayer = Player(name: playerName, description: '');
|
||||
final createdPlayer = Player(name: playerName);
|
||||
final success = await db.playerDao.addPlayer(player: createdPlayer);
|
||||
|
||||
if (!context.mounted) return;
|
||||
|
||||
@@ -69,6 +69,7 @@ class CustomSearchBar extends StatelessWidget {
|
||||
constraints ?? const BoxConstraints(maxHeight: 45, minHeight: 45),
|
||||
hintText: hintText,
|
||||
onChanged: onChanged,
|
||||
hintStyle: WidgetStateProperty.all(const TextStyle(fontSize: 16)),
|
||||
leading: const Icon(Icons.search),
|
||||
trailing: [
|
||||
Visibility(
|
||||
@@ -87,7 +88,7 @@ class CustomSearchBar extends StatelessWidget {
|
||||
],
|
||||
backgroundColor: WidgetStateProperty.all(CustomTheme.boxColor),
|
||||
side: WidgetStateProperty.all(
|
||||
const BorderSide(color: CustomTheme.boxBorderColor),
|
||||
const BorderSide(color: CustomTheme.boxBorder),
|
||||
),
|
||||
shape: WidgetStateProperty.all(
|
||||
RoundedRectangleBorder(borderRadius: BorderRadius.circular(12)),
|
||||
|
||||
@@ -44,11 +44,11 @@ class TextInputField extends StatelessWidget {
|
||||
counterText: '',
|
||||
enabledBorder: const OutlineInputBorder(
|
||||
borderRadius: BorderRadius.all(Radius.circular(12)),
|
||||
borderSide: BorderSide(color: CustomTheme.boxBorderColor),
|
||||
borderSide: BorderSide(color: CustomTheme.boxBorder),
|
||||
),
|
||||
focusedBorder: const OutlineInputBorder(
|
||||
borderRadius: BorderRadius.all(Radius.circular(12)),
|
||||
borderSide: BorderSide(color: CustomTheme.boxBorderColor),
|
||||
borderSide: BorderSide(color: CustomTheme.boxBorder),
|
||||
),
|
||||
floatingLabelBehavior: FloatingLabelBehavior.never,
|
||||
),
|
||||
|
||||
@@ -31,12 +31,16 @@ class CustomRadioListTile<T> extends StatelessWidget {
|
||||
padding: const EdgeInsets.symmetric(horizontal: 2),
|
||||
decoration: BoxDecoration(
|
||||
color: CustomTheme.boxColor,
|
||||
border: Border.all(color: CustomTheme.boxBorderColor),
|
||||
border: Border.all(color: CustomTheme.boxBorder),
|
||||
borderRadius: CustomTheme.standardBorderRadiusAll,
|
||||
),
|
||||
child: Row(
|
||||
children: [
|
||||
Radio<T>(value: value, toggleable: true),
|
||||
Radio<T>(
|
||||
value: value,
|
||||
activeColor: CustomTheme.primaryColor,
|
||||
toggleable: true,
|
||||
),
|
||||
Expanded(
|
||||
child: Text(
|
||||
text,
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/text_icon_tile.dart';
|
||||
|
||||
class GroupTile extends StatefulWidget {
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
import 'dart:core' hide Match;
|
||||
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:intl/intl.dart';
|
||||
import 'package:tallee/core/common.dart';
|
||||
import 'package:tallee/core/custom_theme.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
import 'package:tallee/l10n/generated/app_localizations.dart';
|
||||
import 'package:tallee/presentation/widgets/tiles/text_icon_tile.dart';
|
||||
|
||||
@@ -40,13 +38,18 @@ class MatchTile extends StatefulWidget {
|
||||
}
|
||||
|
||||
class _MatchTileState extends State<MatchTile> {
|
||||
late final List<Player> _allPlayers;
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
_allPlayers = _getCombinedPlayers();
|
||||
}
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final match = widget.match;
|
||||
final group = match.group;
|
||||
final winner = match.winner;
|
||||
final players = [...match.players]
|
||||
..sort((a, b) => a.name.compareTo(b.name));
|
||||
final group = widget.match.group;
|
||||
final winner = widget.match.winner;
|
||||
final loc = AppLocalizations.of(context);
|
||||
|
||||
return GestureDetector(
|
||||
@@ -64,7 +67,7 @@ class _MatchTileState extends State<MatchTile> {
|
||||
children: [
|
||||
Expanded(
|
||||
child: Text(
|
||||
match.name,
|
||||
widget.match.name,
|
||||
style: const TextStyle(
|
||||
fontSize: 18,
|
||||
fontWeight: FontWeight.bold,
|
||||
@@ -73,7 +76,7 @@ class _MatchTileState extends State<MatchTile> {
|
||||
),
|
||||
),
|
||||
Text(
|
||||
_formatDate(match.createdAt, context),
|
||||
_formatDate(widget.match.createdAt, context),
|
||||
style: const TextStyle(fontSize: 12, color: Colors.grey),
|
||||
),
|
||||
],
|
||||
@@ -88,7 +91,7 @@ class _MatchTileState extends State<MatchTile> {
|
||||
const SizedBox(width: 6),
|
||||
Expanded(
|
||||
child: Text(
|
||||
'${match.group!.name}${getExtraPlayerCount(match)}',
|
||||
'${group.name}${widget.match.players != null ? ' + ${widget.match.players?.length}' : ''}',
|
||||
style: const TextStyle(fontSize: 14, color: Colors.grey),
|
||||
overflow: TextOverflow.ellipsis,
|
||||
),
|
||||
@@ -103,7 +106,7 @@ class _MatchTileState extends State<MatchTile> {
|
||||
const SizedBox(width: 6),
|
||||
Expanded(
|
||||
child: Text(
|
||||
'${match.players.length} ${loc.players}',
|
||||
'${widget.match.players!.length} ${loc.players}',
|
||||
style: const TextStyle(fontSize: 14, color: Colors.grey),
|
||||
overflow: TextOverflow.ellipsis,
|
||||
),
|
||||
@@ -189,7 +192,7 @@ class _MatchTileState extends State<MatchTile> {
|
||||
const SizedBox(height: 12),
|
||||
],
|
||||
|
||||
if (players.isNotEmpty && widget.compact == false) ...[
|
||||
if (_allPlayers.isNotEmpty && widget.compact == false) ...[
|
||||
Text(
|
||||
loc.players,
|
||||
style: const TextStyle(
|
||||
@@ -202,7 +205,7 @@ class _MatchTileState extends State<MatchTile> {
|
||||
Wrap(
|
||||
spacing: 6,
|
||||
runSpacing: 6,
|
||||
children: players.map((player) {
|
||||
children: _allPlayers.map((player) {
|
||||
return TextIconTile(text: player.name, iconEnabled: false);
|
||||
}).toList(),
|
||||
),
|
||||
@@ -230,4 +233,34 @@ class _MatchTileState extends State<MatchTile> {
|
||||
return '${loc.created_on} ${DateFormat.yMMMd(Localizations.localeOf(context).toString()).format(dateTime)}';
|
||||
}
|
||||
}
|
||||
|
||||
/// Retrieves all unique players associated with the match,
|
||||
/// combining players from both the match and its group.
|
||||
List<Player> _getCombinedPlayers() {
|
||||
final allPlayers = <Player>[];
|
||||
final playerIds = <String>{};
|
||||
|
||||
// Add players from game.players
|
||||
if (widget.match.players != null) {
|
||||
for (var player in widget.match.players!) {
|
||||
if (!playerIds.contains(player.id)) {
|
||||
allPlayers.add(player);
|
||||
playerIds.add(player.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Add players from game.group.players
|
||||
if (widget.match.group?.members != null) {
|
||||
for (var player in widget.match.group!.members) {
|
||||
if (!playerIds.contains(player.id)) {
|
||||
allPlayers.add(player);
|
||||
playerIds.add(player.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
allPlayers.sort((a, b) => a.name.compareTo(b.name));
|
||||
return allPlayers;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,84 +8,51 @@ import 'package:json_schema/json_schema.dart';
|
||||
import 'package:provider/provider.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/models/team.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
class DataTransferService {
|
||||
/// Deletes all data from the database.
|
||||
static Future<void> deleteAllData(BuildContext context) async {
|
||||
final db = Provider.of<AppDatabase>(context, listen: false);
|
||||
|
||||
await db.matchDao.deleteAllMatches();
|
||||
await db.teamDao.deleteAllTeams();
|
||||
await db.groupDao.deleteAllGroups();
|
||||
await db.gameDao.deleteAllGames();
|
||||
await db.playerDao.deleteAllPlayers();
|
||||
}
|
||||
|
||||
/// Retrieves all application data and converts it to a JSON string.
|
||||
/// Returns the JSON string representation of the data in normalized format.
|
||||
/// Returns the JSON string representation of the data.
|
||||
static Future<String> getAppDataAsJson(BuildContext context) async {
|
||||
final db = Provider.of<AppDatabase>(context, listen: false);
|
||||
final matches = await db.matchDao.getAllMatches();
|
||||
final groups = await db.groupDao.getAllGroups();
|
||||
final players = await db.playerDao.getAllPlayers();
|
||||
final games = await db.gameDao.getAllGames();
|
||||
final teams = await db.teamDao.getAllTeams();
|
||||
|
||||
// Construct a JSON representation of the data in normalized format
|
||||
// Construct a JSON representation of the data
|
||||
final Map<String, dynamic> jsonMap = {
|
||||
'players': players.map((p) => p.toJson()).toList(),
|
||||
'games': games.map((g) => g.toJson()).toList(),
|
||||
|
||||
'groups': groups
|
||||
.map(
|
||||
(g) => {
|
||||
'id': g.id,
|
||||
'name': g.name,
|
||||
'description': g.description,
|
||||
'createdAt': g.createdAt.toIso8601String(),
|
||||
'memberIds': (g.members).map((m) => m.id).toList(),
|
||||
},
|
||||
)
|
||||
.toList(),
|
||||
'teams': teams
|
||||
.map(
|
||||
(t) => {
|
||||
'id': t.id,
|
||||
'name': t.name,
|
||||
'createdAt': t.createdAt.toIso8601String(),
|
||||
'memberIds': (t.members).map((m) => m.id).toList(),
|
||||
},
|
||||
)
|
||||
.toList(),
|
||||
|
||||
'matches': matches
|
||||
.map(
|
||||
(m) => {
|
||||
'id': m.id,
|
||||
'name': m.name,
|
||||
'createdAt': m.createdAt.toIso8601String(),
|
||||
'endedAt': m.endedAt?.toIso8601String(),
|
||||
'gameId': m.game.id,
|
||||
'groupId': m.group?.id,
|
||||
'playerIds': m.players.map((p) => p.id).toList(),
|
||||
'scores': m.scores.map(
|
||||
(playerId, scores) => MapEntry(
|
||||
playerId,
|
||||
scores
|
||||
.map(
|
||||
(s) => {
|
||||
'roundNumber': s.roundNumber,
|
||||
'score': s.score,
|
||||
'change': s.change,
|
||||
},
|
||||
)
|
||||
.toList(),
|
||||
),
|
||||
),
|
||||
'notes': m.notes,
|
||||
'playerIds': (m.players ?? []).map((p) => p.id).toList(),
|
||||
'winnerId': m.winner?.id,
|
||||
},
|
||||
)
|
||||
.toList(),
|
||||
@@ -97,8 +64,8 @@ class DataTransferService {
|
||||
/// Exports the given JSON string to a file with the specified name.
|
||||
/// Returns an [ExportResult] indicating the outcome.
|
||||
///
|
||||
/// - [jsonString]: The JSON string to be exported.
|
||||
/// - [fileName]: The desired name for the exported file (without extension).
|
||||
/// [jsonString] The JSON string to be exported.
|
||||
/// [fileName] The desired name for the exported file (without extension).
|
||||
static Future<ExportResult> exportData(
|
||||
String jsonString,
|
||||
String fileName,
|
||||
@@ -139,12 +106,80 @@ class DataTransferService {
|
||||
final jsonString = await _readFileContent(path.files.single);
|
||||
if (jsonString == null) return ImportResult.fileReadError;
|
||||
|
||||
final isValid = await validateJsonSchema(jsonString);
|
||||
final isValid = await _validateJsonSchema(jsonString);
|
||||
if (!isValid) return ImportResult.invalidSchema;
|
||||
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final Map<String, dynamic> decoded =
|
||||
json.decode(jsonString) as Map<String, dynamic>;
|
||||
|
||||
await importDataToDatabase(db, decoded);
|
||||
final List<dynamic> playersJson =
|
||||
(decoded['players'] as List<dynamic>?) ?? [];
|
||||
final List<dynamic> groupsJson =
|
||||
(decoded['groups'] as List<dynamic>?) ?? [];
|
||||
final List<dynamic> matchesJson =
|
||||
(decoded['matches'] as List<dynamic>?) ?? [];
|
||||
|
||||
// Players
|
||||
final List<Player> importedPlayers = playersJson
|
||||
.map((p) => Player.fromJson(p as Map<String, dynamic>))
|
||||
.toList();
|
||||
|
||||
final Map<String, Player> playerById = {
|
||||
for (final p in importedPlayers) p.id: p,
|
||||
};
|
||||
|
||||
// Groups
|
||||
final List<Group> importedGroups = groupsJson.map((g) {
|
||||
final map = g as Map<String, dynamic>;
|
||||
final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
|
||||
.cast<String>();
|
||||
|
||||
final members = memberIds
|
||||
.map((id) => playerById[id])
|
||||
.whereType<Player>()
|
||||
.toList();
|
||||
|
||||
return Group(
|
||||
id: map['id'] as String,
|
||||
name: map['name'] as String,
|
||||
members: members,
|
||||
createdAt: DateTime.parse(map['createdAt'] as String),
|
||||
);
|
||||
}).toList();
|
||||
|
||||
final Map<String, Group> groupById = {
|
||||
for (final g in importedGroups) g.id: g,
|
||||
};
|
||||
|
||||
// Matches
|
||||
final List<Match> importedMatches = matchesJson.map((m) {
|
||||
final map = m as Map<String, dynamic>;
|
||||
|
||||
final String? groupId = map['groupId'] as String?;
|
||||
final List<String> playerIds =
|
||||
(map['playerIds'] as List<dynamic>? ?? []).cast<String>();
|
||||
final String? winnerId = map['winnerId'] as String?;
|
||||
|
||||
final group = (groupId == null) ? null : groupById[groupId];
|
||||
final players = playerIds
|
||||
.map((id) => playerById[id])
|
||||
.whereType<Player>()
|
||||
.toList();
|
||||
final winner = (winnerId == null) ? null : playerById[winnerId];
|
||||
|
||||
return Match(
|
||||
id: map['id'] as String,
|
||||
name: map['name'] as String,
|
||||
group: group,
|
||||
players: players,
|
||||
createdAt: DateTime.parse(map['createdAt'] as String),
|
||||
winner: winner,
|
||||
);
|
||||
}).toList();
|
||||
|
||||
await db.playerDao.addPlayersAsList(players: importedPlayers);
|
||||
await db.groupDao.addGroupsAsList(groups: importedGroups);
|
||||
await db.matchDao.addMatchAsList(matches: importedMatches);
|
||||
|
||||
return ImportResult.success;
|
||||
} on FormatException catch (e, stack) {
|
||||
@@ -160,167 +195,6 @@ class DataTransferService {
|
||||
}
|
||||
}
|
||||
|
||||
/// Imports parsed JSON data into the database.
|
||||
@visibleForTesting
|
||||
static Future<void> importDataToDatabase(
|
||||
AppDatabase db,
|
||||
Map<String, dynamic> decodedJson,
|
||||
) async {
|
||||
// Fetch all entities first to create lookup maps for relationships
|
||||
final importedPlayers = parsePlayersFromJson(decodedJson);
|
||||
final playerById = {for (final p in importedPlayers) p.id: p};
|
||||
|
||||
final importedGames = parseGamesFromJson(decodedJson);
|
||||
final gameById = {for (final g in importedGames) g.id: g};
|
||||
|
||||
final importedGroups = parseGroupsFromJson(decodedJson, playerById);
|
||||
final groupById = {for (final g in importedGroups) g.id: g};
|
||||
|
||||
final importedTeams = parseTeamsFromJson(decodedJson, playerById);
|
||||
|
||||
final importedMatches = parseMatchesFromJson(
|
||||
decodedJson,
|
||||
gameById,
|
||||
groupById,
|
||||
playerById,
|
||||
);
|
||||
|
||||
await db.playerDao.addPlayersAsList(players: importedPlayers);
|
||||
await db.gameDao.addGamesAsList(games: importedGames);
|
||||
await db.groupDao.addGroupsAsList(groups: importedGroups);
|
||||
await db.teamDao.addTeamsAsList(teams: importedTeams);
|
||||
await db.matchDao.addMatchAsList(matches: importedMatches);
|
||||
}
|
||||
|
||||
/* Parsing Methods */
|
||||
|
||||
@visibleForTesting
|
||||
static List<Player> parsePlayersFromJson(Map<String, dynamic> decodedJson) {
|
||||
final playersJson = (decodedJson['players'] as List<dynamic>?) ?? [];
|
||||
return playersJson
|
||||
.map((p) => Player.fromJson(p as Map<String, dynamic>))
|
||||
.toList();
|
||||
}
|
||||
|
||||
@visibleForTesting
|
||||
static List<Game> parseGamesFromJson(Map<String, dynamic> decodedJson) {
|
||||
final gamesJson = (decodedJson['games'] as List<dynamic>?) ?? [];
|
||||
return gamesJson
|
||||
.map((g) => Game.fromJson(g as Map<String, dynamic>))
|
||||
.toList();
|
||||
}
|
||||
|
||||
@visibleForTesting
|
||||
static List<Group> parseGroupsFromJson(
|
||||
Map<String, dynamic> decodedJson,
|
||||
Map<String, Player> playerById,
|
||||
) {
|
||||
final groupsJson = (decodedJson['groups'] as List<dynamic>?) ?? [];
|
||||
return groupsJson.map((g) {
|
||||
final map = g as Map<String, dynamic>;
|
||||
final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
|
||||
.cast<String>();
|
||||
|
||||
final members = memberIds
|
||||
.map((id) => playerById[id])
|
||||
.whereType<Player>()
|
||||
.toList();
|
||||
|
||||
return Group(
|
||||
id: map['id'] as String,
|
||||
name: map['name'] as String,
|
||||
description: map['description'] as String,
|
||||
members: members,
|
||||
createdAt: DateTime.parse(map['createdAt'] as String),
|
||||
);
|
||||
}).toList();
|
||||
}
|
||||
|
||||
/// Parses teams from JSON data.
|
||||
@visibleForTesting
|
||||
static List<Team> parseTeamsFromJson(
|
||||
Map<String, dynamic> decodedJson,
|
||||
Map<String, Player> playerById,
|
||||
) {
|
||||
final teamsJson = (decodedJson['teams'] as List<dynamic>?) ?? [];
|
||||
return teamsJson.map((t) {
|
||||
final map = t as Map<String, dynamic>;
|
||||
final memberIds = (map['memberIds'] as List<dynamic>? ?? [])
|
||||
.cast<String>();
|
||||
|
||||
final members = memberIds
|
||||
.map((id) => playerById[id])
|
||||
.whereType<Player>()
|
||||
.toList();
|
||||
|
||||
return Team(
|
||||
id: map['id'] as String,
|
||||
name: map['name'] as String,
|
||||
members: members,
|
||||
createdAt: DateTime.parse(map['createdAt'] as String),
|
||||
);
|
||||
}).toList();
|
||||
}
|
||||
|
||||
/// Parses matches from JSON data.
|
||||
@visibleForTesting
|
||||
static List<Match> parseMatchesFromJson(
|
||||
Map<String, dynamic> decodedJson,
|
||||
Map<String, Game> gamesMap,
|
||||
Map<String, Group> groupsMap,
|
||||
Map<String, Player> playersMap,
|
||||
) {
|
||||
final matchesJson = (decodedJson['matches'] as List<dynamic>?) ?? [];
|
||||
return matchesJson.map((m) {
|
||||
final map = m as Map<String, dynamic>;
|
||||
|
||||
// Extract attributes from json
|
||||
final id = map['id'] as String;
|
||||
final name = map['name'] as String;
|
||||
final gameId = map['gameId'] as String;
|
||||
final groupId = map['groupId'] as String?;
|
||||
final createdAt = DateTime.parse(map['createdAt'] as String);
|
||||
final endedAt = map['endedAt'] != null
|
||||
? DateTime.parse(map['endedAt'] as String)
|
||||
: null;
|
||||
final notes = map['notes'] as String? ?? '';
|
||||
|
||||
// Link attributes to objects
|
||||
final game = gamesMap[gameId] ?? getFallbackGame();
|
||||
final group = groupId != null ? groupsMap[groupId] : null;
|
||||
|
||||
final playerIds = (map['playerIds'] as List<dynamic>? ?? [])
|
||||
.cast<String>();
|
||||
final players = playerIds
|
||||
.map((id) => playersMap[id])
|
||||
.whereType<Player>()
|
||||
.toList();
|
||||
|
||||
return Match(
|
||||
id: id,
|
||||
name: name,
|
||||
game: game,
|
||||
group: group,
|
||||
players: players,
|
||||
createdAt: createdAt,
|
||||
endedAt: endedAt,
|
||||
notes: notes,
|
||||
);
|
||||
}).toList();
|
||||
}
|
||||
|
||||
/// Creates a fallback game when the referenced game is not found.
|
||||
@visibleForTesting
|
||||
static Game getFallbackGame() {
|
||||
return Game(
|
||||
name: 'Unknown',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
description: '',
|
||||
color: GameColor.blue,
|
||||
icon: '',
|
||||
);
|
||||
}
|
||||
|
||||
/// Helper method to read file content from either bytes or path
|
||||
static Future<String?> _readFileContent(PlatformFile file) async {
|
||||
if (file.bytes != null) return utf8.decode(file.bytes!);
|
||||
@@ -328,10 +202,8 @@ class DataTransferService {
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Validates the given JSON string against the schema
|
||||
/// in `assets/schema.json`.
|
||||
@visibleForTesting
|
||||
static Future<bool> validateJsonSchema(String jsonString) async {
|
||||
/// Validates the given JSON string against the predefined schema.
|
||||
static Future<bool> _validateJsonSchema(String jsonString) async {
|
||||
final String schemaString;
|
||||
|
||||
schemaString = await rootBundle.loadString('assets/schema.json');
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
name: tallee
|
||||
description: "Tracking App for Card Games"
|
||||
publish_to: 'none'
|
||||
version: 0.0.20+254
|
||||
version: 0.0.11+243
|
||||
|
||||
environment:
|
||||
sdk: ^3.8.1
|
||||
@@ -31,10 +31,10 @@ dependencies:
|
||||
dev_dependencies:
|
||||
flutter_test:
|
||||
sdk: flutter
|
||||
build_runner: ^2.7.0
|
||||
build_runner: ^2.5.4
|
||||
dart_pubspec_licenses: ^3.0.14
|
||||
drift_dev: ^2.29.0
|
||||
flutter_lints: ^6.0.0
|
||||
drift_dev: ^2.27.0
|
||||
flutter_lints: ^5.0.0
|
||||
|
||||
flutter:
|
||||
uses-material-design: true
|
||||
|
||||
@@ -1,373 +0,0 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart' hide isNull;
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Player testPlayer4;
|
||||
late Group testGroup1;
|
||||
late Group testGroup2;
|
||||
late Group testGroup3;
|
||||
late Group testGroup4;
|
||||
final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
// Recommended for widget tests to avoid test errors.
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Alice', description: '');
|
||||
testPlayer2 = Player(name: 'Bob', description: '');
|
||||
testPlayer3 = Player(name: 'Charlie', description: '');
|
||||
testPlayer4 = Player(name: 'Diana', description: '');
|
||||
testGroup1 = Group(
|
||||
name: 'Test Group',
|
||||
description: '',
|
||||
members: [testPlayer1, testPlayer2, testPlayer3],
|
||||
);
|
||||
testGroup2 = Group(
|
||||
id: 'gr2',
|
||||
name: 'Second Group',
|
||||
description: '',
|
||||
members: [testPlayer2, testPlayer3, testPlayer4],
|
||||
);
|
||||
testGroup3 = Group(
|
||||
id: 'gr2',
|
||||
name: 'Second Group',
|
||||
description: '',
|
||||
members: [testPlayer2, testPlayer4],
|
||||
);
|
||||
testGroup4 = Group(
|
||||
id: 'gr2',
|
||||
name: 'Second Group',
|
||||
description: '',
|
||||
members: [testPlayer1, testPlayer2, testPlayer3, testPlayer4],
|
||||
);
|
||||
});
|
||||
});
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
group('Group Tests', () {
|
||||
// Verifies that a single group can be added and retrieved with all fields and members intact.
|
||||
test('Adding and fetching a single group works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
final fetchedGroup = await database.groupDao.getGroupById(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
|
||||
expect(fetchedGroup.id, testGroup1.id);
|
||||
expect(fetchedGroup.name, testGroup1.name);
|
||||
expect(fetchedGroup.createdAt, testGroup1.createdAt);
|
||||
|
||||
expect(fetchedGroup.members.length, testGroup1.members.length);
|
||||
for (int i = 0; i < testGroup1.members.length; i++) {
|
||||
expect(fetchedGroup.members[i].id, testGroup1.members[i].id);
|
||||
expect(fetchedGroup.members[i].name, testGroup1.members[i].name);
|
||||
expect(
|
||||
fetchedGroup.members[i].createdAt,
|
||||
testGroup1.members[i].createdAt,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
// Verifies that multiple groups can be added and retrieved with correct members.
|
||||
test('Adding and fetching multiple groups works correctly', () async {
|
||||
await database.groupDao.addGroupsAsList(
|
||||
groups: [testGroup1, testGroup2, testGroup3, testGroup4],
|
||||
);
|
||||
|
||||
final allGroups = await database.groupDao.getAllGroups();
|
||||
expect(allGroups.length, 2);
|
||||
|
||||
final testGroups = {testGroup1.id: testGroup1, testGroup2.id: testGroup2};
|
||||
|
||||
for (final group in allGroups) {
|
||||
final testGroup = testGroups[group.id]!;
|
||||
|
||||
expect(group.id, testGroup.id);
|
||||
expect(group.name, testGroup.name);
|
||||
expect(group.createdAt, testGroup.createdAt);
|
||||
|
||||
expect(group.members.length, testGroup.members.length);
|
||||
for (int i = 0; i < testGroup.members.length; i++) {
|
||||
expect(group.members[i].id, testGroup.members[i].id);
|
||||
expect(group.members[i].name, testGroup.members[i].name);
|
||||
expect(group.members[i].createdAt, testGroup.members[i].createdAt);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Verifies that adding the same group twice does not create duplicates.
|
||||
test('Adding the same group twice does not create duplicates', () async {
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
final allGroups = await database.groupDao.getAllGroups();
|
||||
expect(allGroups.length, 1);
|
||||
});
|
||||
|
||||
// Verifies that groupExists returns correct boolean based on group presence.
|
||||
test('Group existence check works correctly', () async {
|
||||
var groupExists = await database.groupDao.groupExists(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(groupExists, false);
|
||||
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
groupExists = await database.groupDao.groupExists(groupId: testGroup1.id);
|
||||
expect(groupExists, true);
|
||||
});
|
||||
|
||||
// Verifies that deleteGroup removes the group and returns true.
|
||||
test('Deleting a group works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
final groupDeleted = await database.groupDao.deleteGroup(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(groupDeleted, true);
|
||||
|
||||
final groupExists = await database.groupDao.groupExists(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(groupExists, false);
|
||||
});
|
||||
|
||||
// Verifies that updateGroupName correctly updates only the name field.
|
||||
test('Updating a group name works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
const newGroupName = 'new group name';
|
||||
|
||||
await database.groupDao.updateGroupName(
|
||||
groupId: testGroup1.id,
|
||||
newName: newGroupName,
|
||||
);
|
||||
|
||||
final result = await database.groupDao.getGroupById(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(result.name, newGroupName);
|
||||
});
|
||||
|
||||
// Verifies that getGroupCount returns correct count through add/delete operations.
|
||||
test('Getting the group count works correctly', () async {
|
||||
final initialCount = await database.groupDao.getGroupCount();
|
||||
expect(initialCount, 0);
|
||||
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
final groupAdded = await database.groupDao.getGroupCount();
|
||||
expect(groupAdded, 1);
|
||||
|
||||
final groupRemoved = await database.groupDao.deleteGroup(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(groupRemoved, true);
|
||||
|
||||
final finalCount = await database.groupDao.getGroupCount();
|
||||
expect(finalCount, 0);
|
||||
});
|
||||
|
||||
// Verifies that getAllGroups returns an empty list when no groups exist.
|
||||
test('getAllGroups returns empty list when no groups exist', () async {
|
||||
final allGroups = await database.groupDao.getAllGroups();
|
||||
expect(allGroups, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that getGroupById throws StateError for non-existent group ID.
|
||||
test('getGroupById throws exception for non-existent group', () async {
|
||||
expect(
|
||||
() => database.groupDao.getGroupById(groupId: 'non-existent-id'),
|
||||
throwsA(isA<StateError>()),
|
||||
);
|
||||
});
|
||||
|
||||
// Verifies that addGroup returns false when trying to add a duplicate group.
|
||||
test('addGroup returns false when group already exists', () async {
|
||||
final firstAdd = await database.groupDao.addGroup(group: testGroup1);
|
||||
expect(firstAdd, true);
|
||||
|
||||
final secondAdd = await database.groupDao.addGroup(group: testGroup1);
|
||||
expect(secondAdd, false);
|
||||
|
||||
final allGroups = await database.groupDao.getAllGroups();
|
||||
expect(allGroups.length, 1);
|
||||
});
|
||||
|
||||
// Verifies that addGroupsAsList handles an empty list without errors.
|
||||
test('addGroupsAsList handles empty list correctly', () async {
|
||||
await database.groupDao.addGroupsAsList(groups: []);
|
||||
|
||||
final allGroups = await database.groupDao.getAllGroups();
|
||||
expect(allGroups.length, 0);
|
||||
});
|
||||
|
||||
// Verifies that deleteGroup returns false for a non-existent group ID.
|
||||
test('deleteGroup returns false for non-existent group', () async {
|
||||
final deleted = await database.groupDao.deleteGroup(
|
||||
groupId: 'non-existent-id',
|
||||
);
|
||||
expect(deleted, false);
|
||||
});
|
||||
|
||||
// Verifies that updateGroupName returns false for a non-existent group ID.
|
||||
test('updateGroupName returns false for non-existent group', () async {
|
||||
final updated = await database.groupDao.updateGroupName(
|
||||
groupId: 'non-existent-id',
|
||||
newName: 'New Name',
|
||||
);
|
||||
expect(updated, false);
|
||||
});
|
||||
|
||||
// Verifies that updateGroupDescription correctly updates the description field.
|
||||
test('Updating a group description works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
const newDescription = 'This is a new description';
|
||||
|
||||
final updated = await database.groupDao.updateGroupDescription(
|
||||
groupId: testGroup1.id,
|
||||
newDescription: newDescription,
|
||||
);
|
||||
expect(updated, true);
|
||||
|
||||
final result = await database.groupDao.getGroupById(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(result.description, newDescription);
|
||||
});
|
||||
|
||||
// Verifies that updateGroupDescription can set the description to null.
|
||||
test('updateGroupDescription can set description to null', () async {
|
||||
final groupWithDescription = Group(
|
||||
name: 'Group with description',
|
||||
description: 'Initial description',
|
||||
members: [testPlayer1],
|
||||
);
|
||||
await database.groupDao.addGroup(group: groupWithDescription);
|
||||
|
||||
final updated = await database.groupDao.updateGroupDescription(
|
||||
groupId: groupWithDescription.id,
|
||||
newDescription: 'Updated description',
|
||||
);
|
||||
expect(updated, true);
|
||||
|
||||
final result = await database.groupDao.getGroupById(
|
||||
groupId: groupWithDescription.id,
|
||||
);
|
||||
expect(result.description, 'Updated description');
|
||||
});
|
||||
|
||||
// Verifies that updateGroupDescription returns false for a non-existent group.
|
||||
test(
|
||||
'updateGroupDescription returns false for non-existent group',
|
||||
() async {
|
||||
final updated = await database.groupDao.updateGroupDescription(
|
||||
groupId: 'non-existent-id',
|
||||
newDescription: 'New Description',
|
||||
);
|
||||
expect(updated, false);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that deleteAllGroups removes all groups from the database.
|
||||
test('deleteAllGroups removes all groups', () async {
|
||||
await database.groupDao.addGroupsAsList(groups: [testGroup1, testGroup2]);
|
||||
|
||||
final countBefore = await database.groupDao.getGroupCount();
|
||||
expect(countBefore, 2);
|
||||
|
||||
final deleted = await database.groupDao.deleteAllGroups();
|
||||
expect(deleted, true);
|
||||
|
||||
final countAfter = await database.groupDao.getGroupCount();
|
||||
expect(countAfter, 0);
|
||||
});
|
||||
|
||||
// Verifies that deleteAllGroups returns false when no groups exist.
|
||||
test('deleteAllGroups returns false when no groups exist', () async {
|
||||
final deleted = await database.groupDao.deleteAllGroups();
|
||||
expect(deleted, false);
|
||||
});
|
||||
|
||||
// Verifies that groups with special characters (quotes, emojis) are stored correctly.
|
||||
test('Group with special characters in name is stored correctly', () async {
|
||||
final specialGroup = Group(
|
||||
name: 'Group\'s & "Special" <Name>',
|
||||
description: 'Description with émojis 🎮🎲',
|
||||
members: [testPlayer1],
|
||||
);
|
||||
await database.groupDao.addGroup(group: specialGroup);
|
||||
|
||||
final fetchedGroup = await database.groupDao.getGroupById(
|
||||
groupId: specialGroup.id,
|
||||
);
|
||||
expect(fetchedGroup.name, 'Group\'s & "Special" <Name>');
|
||||
expect(fetchedGroup.description, 'Description with émojis 🎮🎲');
|
||||
});
|
||||
|
||||
// Verifies that a group with an empty members list can be stored and retrieved.
|
||||
test('Group with empty members list is stored correctly', () async {
|
||||
final emptyGroup = Group(
|
||||
name: 'Empty Group',
|
||||
description: '',
|
||||
members: [],
|
||||
);
|
||||
await database.groupDao.addGroup(group: emptyGroup);
|
||||
|
||||
final fetchedGroup = await database.groupDao.getGroupById(
|
||||
groupId: emptyGroup.id,
|
||||
);
|
||||
expect(fetchedGroup.name, 'Empty Group');
|
||||
expect(fetchedGroup.members, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that multiple sequential updates to the same group work correctly.
|
||||
test('Multiple updates to the same group work correctly', () async {
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
await database.groupDao.updateGroupName(
|
||||
groupId: testGroup1.id,
|
||||
newName: 'Updated Name',
|
||||
);
|
||||
await database.groupDao.updateGroupDescription(
|
||||
groupId: testGroup1.id,
|
||||
newDescription: 'Updated Description',
|
||||
);
|
||||
|
||||
final updatedGroup = await database.groupDao.getGroupById(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(updatedGroup.name, 'Updated Name');
|
||||
expect(updatedGroup.description, 'Updated Description');
|
||||
expect(updatedGroup.members.length, testGroup1.members.length);
|
||||
});
|
||||
|
||||
// Verifies that addGroupsAsList with duplicate groups only adds unique ones.
|
||||
test('addGroupsAsList with duplicate groups only adds once', () async {
|
||||
await database.groupDao.addGroupsAsList(
|
||||
groups: [testGroup1, testGroup1, testGroup1],
|
||||
);
|
||||
|
||||
final allGroups = await database.groupDao.getAllGroups();
|
||||
expect(allGroups.length, 1);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -1,519 +0,0 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/models/team.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Player testPlayer4;
|
||||
late Team testTeam1;
|
||||
late Team testTeam2;
|
||||
late Team testTeam3;
|
||||
late Game testGame1;
|
||||
late Game testGame2;
|
||||
final fixedDate = DateTime(2025, 11, 19, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() async {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
// Recommended for widget tests to avoid test errors.
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Alice', description: '');
|
||||
testPlayer2 = Player(name: 'Bob', description: '');
|
||||
testPlayer3 = Player(name: 'Charlie', description: '');
|
||||
testPlayer4 = Player(name: 'Diana', description: '');
|
||||
testTeam1 = Team(name: 'Team Alpha', members: [testPlayer1, testPlayer2]);
|
||||
testTeam2 = Team(name: 'Team Beta', members: [testPlayer3, testPlayer4]);
|
||||
testTeam3 = Team(name: 'Team Gamma', members: [testPlayer1, testPlayer3]);
|
||||
testGame1 = Game(
|
||||
name: 'Game 1',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
description: 'Test game 1',
|
||||
color: GameColor.blue,
|
||||
icon: '',
|
||||
);
|
||||
testGame2 = Game(
|
||||
name: 'Game 2',
|
||||
ruleset: Ruleset.highestScore,
|
||||
description: 'Test game 2',
|
||||
color: GameColor.red,
|
||||
icon: '',
|
||||
);
|
||||
});
|
||||
|
||||
await database.playerDao.addPlayersAsList(
|
||||
players: [testPlayer1, testPlayer2, testPlayer3, testPlayer4],
|
||||
);
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
await database.gameDao.addGame(game: testGame2);
|
||||
});
|
||||
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
|
||||
group('Team Tests', () {
|
||||
// Verifies that a single team can be added and retrieved with all fields intact.
|
||||
test('Adding and fetching a single team works correctly', () async {
|
||||
final added = await database.teamDao.addTeam(team: testTeam1);
|
||||
expect(added, true);
|
||||
|
||||
final fetchedTeam = await database.teamDao.getTeamById(
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(fetchedTeam.id, testTeam1.id);
|
||||
expect(fetchedTeam.name, testTeam1.name);
|
||||
expect(fetchedTeam.createdAt, testTeam1.createdAt);
|
||||
});
|
||||
|
||||
// Verifies that multiple teams can be added at once and retrieved correctly.
|
||||
test('Adding and fetching multiple teams works correctly', () async {
|
||||
await database.teamDao.addTeamsAsList(
|
||||
teams: [testTeam1, testTeam2, testTeam3],
|
||||
);
|
||||
|
||||
final allTeams = await database.teamDao.getAllTeams();
|
||||
expect(allTeams.length, 3);
|
||||
|
||||
final testTeams = {
|
||||
testTeam1.id: testTeam1,
|
||||
testTeam2.id: testTeam2,
|
||||
testTeam3.id: testTeam3,
|
||||
};
|
||||
|
||||
for (final team in allTeams) {
|
||||
final testTeam = testTeams[team.id]!;
|
||||
|
||||
expect(team.id, testTeam.id);
|
||||
expect(team.name, testTeam.name);
|
||||
expect(team.createdAt, testTeam.createdAt);
|
||||
}
|
||||
});
|
||||
|
||||
// Verifies that adding the same team twice does not create duplicates and returns false.
|
||||
test('Adding the same team twice does not create duplicates', () async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
final addedAgain = await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
expect(addedAgain, false);
|
||||
|
||||
final teamCount = await database.teamDao.getTeamCount();
|
||||
expect(teamCount, 1);
|
||||
});
|
||||
|
||||
// Verifies that teamExists returns correct boolean based on team presence.
|
||||
test('Team existence check works correctly', () async {
|
||||
var teamExists = await database.teamDao.teamExists(teamId: testTeam1.id);
|
||||
expect(teamExists, false);
|
||||
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
teamExists = await database.teamDao.teamExists(teamId: testTeam1.id);
|
||||
expect(teamExists, true);
|
||||
});
|
||||
|
||||
// Verifies that deleteTeam removes the team and returns true.
|
||||
test('Deleting a team works correctly', () async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
final teamDeleted = await database.teamDao.deleteTeam(
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
expect(teamDeleted, true);
|
||||
|
||||
final teamExists = await database.teamDao.teamExists(
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
expect(teamExists, false);
|
||||
});
|
||||
|
||||
// Verifies that deleteTeam returns false for a non-existent team ID.
|
||||
test('Deleting a non-existent team returns false', () async {
|
||||
final teamDeleted = await database.teamDao.deleteTeam(
|
||||
teamId: 'non-existent-id',
|
||||
);
|
||||
expect(teamDeleted, false);
|
||||
});
|
||||
|
||||
// Verifies that getTeamCount returns correct count through add/delete operations.
|
||||
test('Getting the team count works correctly', () async {
|
||||
var teamCount = await database.teamDao.getTeamCount();
|
||||
expect(teamCount, 0);
|
||||
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
teamCount = await database.teamDao.getTeamCount();
|
||||
expect(teamCount, 1);
|
||||
|
||||
await database.teamDao.addTeam(team: testTeam2);
|
||||
|
||||
teamCount = await database.teamDao.getTeamCount();
|
||||
expect(teamCount, 2);
|
||||
|
||||
await database.teamDao.deleteTeam(teamId: testTeam1.id);
|
||||
|
||||
teamCount = await database.teamDao.getTeamCount();
|
||||
expect(teamCount, 1);
|
||||
|
||||
await database.teamDao.deleteTeam(teamId: testTeam2.id);
|
||||
|
||||
teamCount = await database.teamDao.getTeamCount();
|
||||
expect(teamCount, 0);
|
||||
});
|
||||
|
||||
// Verifies that updateTeamName correctly updates only the name field.
|
||||
test('Updating team name works correctly', () async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
var fetchedTeam = await database.teamDao.getTeamById(
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
expect(fetchedTeam.name, testTeam1.name);
|
||||
|
||||
const newName = 'Updated Team Name';
|
||||
await database.teamDao.updateTeamName(
|
||||
teamId: testTeam1.id,
|
||||
newName: newName,
|
||||
);
|
||||
|
||||
fetchedTeam = await database.teamDao.getTeamById(teamId: testTeam1.id);
|
||||
expect(fetchedTeam.name, newName);
|
||||
});
|
||||
|
||||
// Verifies that deleteAllTeams removes all teams from the database.
|
||||
test('Deleting all teams works correctly', () async {
|
||||
await database.teamDao.addTeamsAsList(
|
||||
teams: [testTeam1, testTeam2, testTeam3],
|
||||
);
|
||||
|
||||
var teamCount = await database.teamDao.getTeamCount();
|
||||
expect(teamCount, 3);
|
||||
|
||||
final deleted = await database.teamDao.deleteAllTeams();
|
||||
expect(deleted, true);
|
||||
|
||||
teamCount = await database.teamDao.getTeamCount();
|
||||
expect(teamCount, 0);
|
||||
});
|
||||
|
||||
// Verifies that deleteAllTeams returns false when no teams exist.
|
||||
test('Deleting all teams when empty returns false', () async {
|
||||
final deleted = await database.teamDao.deleteAllTeams();
|
||||
expect(deleted, false);
|
||||
});
|
||||
|
||||
// Verifies that addTeamsAsList returns false when given an empty list.
|
||||
test('Adding teams as list with empty list returns false', () async {
|
||||
final added = await database.teamDao.addTeamsAsList(teams: []);
|
||||
expect(added, false);
|
||||
});
|
||||
|
||||
// Verifies that addTeamsAsList with duplicate IDs ignores duplicates and keeps the first.
|
||||
test('Adding teams with duplicate IDs ignores duplicates', () async {
|
||||
final duplicateTeam = Team(
|
||||
id: testTeam1.id,
|
||||
name: 'Duplicate Team',
|
||||
members: [testPlayer4],
|
||||
);
|
||||
|
||||
await database.teamDao.addTeamsAsList(
|
||||
teams: [testTeam1, duplicateTeam, testTeam2],
|
||||
);
|
||||
|
||||
final teamCount = await database.teamDao.getTeamCount();
|
||||
expect(teamCount, 2);
|
||||
|
||||
// The first one should be kept (insertOrIgnore)
|
||||
final fetchedTeam = await database.teamDao.getTeamById(
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
expect(fetchedTeam.name, testTeam1.name);
|
||||
});
|
||||
|
||||
// Verifies that getAllTeams returns empty list when no teams exist.
|
||||
test('Getting all teams when empty returns empty list', () async {
|
||||
final allTeams = await database.teamDao.getAllTeams();
|
||||
expect(allTeams.isEmpty, true);
|
||||
});
|
||||
|
||||
// Verifies that getTeamById throws exception for non-existent team.
|
||||
test('Getting non-existent team throws exception', () async {
|
||||
expect(
|
||||
() => database.teamDao.getTeamById(teamId: 'non-existent-id'),
|
||||
throwsA(isA<StateError>()),
|
||||
);
|
||||
});
|
||||
|
||||
// Verifies that updating team name preserves other fields.
|
||||
test('Updating team name preserves other team fields', () async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
final originalTeam = await database.teamDao.getTeamById(
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
final originalCreatedAt = originalTeam.createdAt;
|
||||
|
||||
const newName = 'Brand New Team Name';
|
||||
await database.teamDao.updateTeamName(
|
||||
teamId: testTeam1.id,
|
||||
newName: newName,
|
||||
);
|
||||
|
||||
final updatedTeam = await database.teamDao.getTeamById(
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(updatedTeam.name, newName);
|
||||
expect(updatedTeam.id, testTeam1.id);
|
||||
expect(updatedTeam.createdAt, originalCreatedAt);
|
||||
});
|
||||
|
||||
// Verifies that team name can be updated to an empty string.
|
||||
test('Updating team name to empty string works', () async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
await database.teamDao.updateTeamName(teamId: testTeam1.id, newName: '');
|
||||
|
||||
final updatedTeam = await database.teamDao.getTeamById(
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(updatedTeam.name, '');
|
||||
});
|
||||
|
||||
// Verifies that team name can be updated to a very long string.
|
||||
test('Updating team name to long string works', () async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
final longName = 'A' * 500; // 500 character name
|
||||
|
||||
await database.teamDao.updateTeamName(
|
||||
teamId: testTeam1.id,
|
||||
newName: longName,
|
||||
);
|
||||
|
||||
final updatedTeam = await database.teamDao.getTeamById(
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(updatedTeam.name, longName);
|
||||
expect(updatedTeam.name.length, 500);
|
||||
});
|
||||
|
||||
// Verifies that updating non-existent team name doesn't throw error.
|
||||
test('Updating non-existent team name completes without error', () async {
|
||||
expect(
|
||||
() => database.teamDao.updateTeamName(
|
||||
teamId: 'non-existent-id',
|
||||
newName: 'New Name',
|
||||
),
|
||||
returnsNormally,
|
||||
);
|
||||
});
|
||||
|
||||
// Verifies that deleteTeam only affects the specified team.
|
||||
test('Deleting one team does not affect other teams', () async {
|
||||
await database.teamDao.addTeamsAsList(
|
||||
teams: [testTeam1, testTeam2, testTeam3],
|
||||
);
|
||||
|
||||
await database.teamDao.deleteTeam(teamId: testTeam2.id);
|
||||
|
||||
final allTeams = await database.teamDao.getAllTeams();
|
||||
expect(allTeams.length, 2);
|
||||
expect(allTeams.any((t) => t.id == testTeam1.id), true);
|
||||
expect(allTeams.any((t) => t.id == testTeam2.id), false);
|
||||
expect(allTeams.any((t) => t.id == testTeam3.id), true);
|
||||
});
|
||||
|
||||
// Verifies that teams with overlapping members are independent.
|
||||
test('Teams with overlapping members are independent', () async {
|
||||
// Create two matches since player_match has primary key {playerId, matchId}
|
||||
final match1 = Match(name: 'Match 1', game: testGame1, notes: '');
|
||||
final match2 = Match(name: 'Match 2', game: testGame2, notes: '');
|
||||
await database.matchDao.addMatch(match: match1);
|
||||
await database.matchDao.addMatch(match: match2);
|
||||
|
||||
// Add teams to database
|
||||
await database.teamDao.addTeamsAsList(teams: [testTeam1, testTeam3]);
|
||||
|
||||
// Associate players with teams through match1
|
||||
// testTeam1: player1, player2
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: match1.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
playerId: testPlayer2.id,
|
||||
matchId: match1.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
// Associate players with teams through match2
|
||||
// testTeam3: player1, player3 (overlapping player1)
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: match2.id,
|
||||
teamId: testTeam3.id,
|
||||
);
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
playerId: testPlayer3.id,
|
||||
matchId: match2.id,
|
||||
teamId: testTeam3.id,
|
||||
);
|
||||
|
||||
final team1 = await database.teamDao.getTeamById(teamId: testTeam1.id);
|
||||
final team3 = await database.teamDao.getTeamById(teamId: testTeam3.id);
|
||||
|
||||
expect(team1.members.length, 2);
|
||||
expect(team3.members.length, 2);
|
||||
expect(team1.members.any((p) => p.id == testPlayer1.id), true);
|
||||
expect(team3.members.any((p) => p.id == testPlayer1.id), true);
|
||||
});
|
||||
|
||||
// Verifies that adding teams sequentially works correctly.
|
||||
test('Adding teams sequentially maintains correct count', () async {
|
||||
var count = await database.teamDao.getTeamCount();
|
||||
expect(count, 0);
|
||||
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
count = await database.teamDao.getTeamCount();
|
||||
expect(count, 1);
|
||||
|
||||
await database.teamDao.addTeam(team: testTeam2);
|
||||
count = await database.teamDao.getTeamCount();
|
||||
expect(count, 2);
|
||||
|
||||
await database.teamDao.addTeam(team: testTeam3);
|
||||
count = await database.teamDao.getTeamCount();
|
||||
expect(count, 3);
|
||||
});
|
||||
|
||||
// Verifies that getAllTeams returns all teams with correct data.
|
||||
test('Getting all teams returns all teams with correct data', () async {
|
||||
await database.teamDao.addTeamsAsList(
|
||||
teams: [testTeam1, testTeam2, testTeam3],
|
||||
);
|
||||
|
||||
final allTeams = await database.teamDao.getAllTeams();
|
||||
|
||||
expect(allTeams.length, 3);
|
||||
expect(allTeams.map((t) => t.id).toSet(), {
|
||||
testTeam1.id,
|
||||
testTeam2.id,
|
||||
testTeam3.id,
|
||||
});
|
||||
});
|
||||
|
||||
// Verifies that teamExists returns false for deleted teams.
|
||||
test('Team existence returns false after deletion', () async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
expect(await database.teamDao.teamExists(teamId: testTeam1.id), true);
|
||||
|
||||
await database.teamDao.deleteTeam(teamId: testTeam1.id);
|
||||
expect(await database.teamDao.teamExists(teamId: testTeam1.id), false);
|
||||
});
|
||||
|
||||
// Verifies that adding multiple teams in batch then deleting returns correct count.
|
||||
test('Batch add then partial delete maintains correct count', () async {
|
||||
await database.teamDao.addTeamsAsList(
|
||||
teams: [testTeam1, testTeam2, testTeam3],
|
||||
);
|
||||
|
||||
expect(await database.teamDao.getTeamCount(), 3);
|
||||
|
||||
await database.teamDao.deleteTeam(teamId: testTeam1.id);
|
||||
expect(await database.teamDao.getTeamCount(), 2);
|
||||
|
||||
await database.teamDao.deleteTeam(teamId: testTeam3.id);
|
||||
expect(await database.teamDao.getTeamCount(), 1);
|
||||
});
|
||||
|
||||
// Verifies that deleteAllTeams with single team works.
|
||||
test('Deleting all teams with single team returns true', () async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
expect(await database.teamDao.getTeamCount(), 1);
|
||||
|
||||
final deleted = await database.teamDao.deleteAllTeams();
|
||||
expect(deleted, true);
|
||||
expect(await database.teamDao.getTeamCount(), 0);
|
||||
});
|
||||
|
||||
// Verifies that addTeam after deleteAllTeams works correctly.
|
||||
test('Adding team after deleteAllTeams works correctly', () async {
|
||||
await database.teamDao.addTeamsAsList(teams: [testTeam1, testTeam2]);
|
||||
expect(await database.teamDao.getTeamCount(), 2);
|
||||
|
||||
await database.teamDao.deleteAllTeams();
|
||||
expect(await database.teamDao.getTeamCount(), 0);
|
||||
|
||||
final added = await database.teamDao.addTeam(team: testTeam3);
|
||||
expect(added, true);
|
||||
expect(await database.teamDao.getTeamCount(), 1);
|
||||
|
||||
final fetchedTeam = await database.teamDao.getTeamById(
|
||||
teamId: testTeam3.id,
|
||||
);
|
||||
expect(fetchedTeam.name, testTeam3.name);
|
||||
});
|
||||
|
||||
// Verifies that addTeamsAsList with partial duplicates ignores duplicates.
|
||||
test('Adding teams with some duplicates ignores only duplicates', () async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
final duplicateTeam1 = Team(
|
||||
id: testTeam1.id,
|
||||
name: 'Different Name',
|
||||
members: [testPlayer3],
|
||||
);
|
||||
|
||||
await database.teamDao.addTeamsAsList(
|
||||
teams: [duplicateTeam1, testTeam2, testTeam3],
|
||||
);
|
||||
|
||||
final allTeams = await database.teamDao.getAllTeams();
|
||||
expect(allTeams.length, 3);
|
||||
|
||||
// Verify testTeam1 retained original name (was inserted first)
|
||||
final team1 = await database.teamDao.getTeamById(teamId: testTeam1.id);
|
||||
expect(team1.name, testTeam1.name);
|
||||
});
|
||||
|
||||
// Verifies that team IDs are preserved correctly.
|
||||
test('Team IDs are preserved through add and retrieve', () async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
final fetchedTeam = await database.teamDao.getTeamById(
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(fetchedTeam.id, testTeam1.id);
|
||||
});
|
||||
|
||||
// Verifies that createdAt timestamps are preserved.
|
||||
test('Team createdAt timestamps are preserved', () async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
final fetchedTeam = await database.teamDao.getTeamById(
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(fetchedTeam.createdAt, testTeam1.createdAt);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -1,545 +0,0 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart' hide isNull;
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Game testGame1;
|
||||
late Game testGame2;
|
||||
late Game testGame3;
|
||||
final fixedDate = DateTime(2025, 11, 19, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testGame1 = Game(
|
||||
name: 'Chess',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
description: 'A classic strategy game',
|
||||
color: GameColor.blue,
|
||||
icon: 'chess_icon',
|
||||
);
|
||||
testGame2 = Game(
|
||||
id: 'game2',
|
||||
name: 'Poker',
|
||||
ruleset: Ruleset.multipleWinners,
|
||||
description: 'Card game with multiple winners',
|
||||
color: GameColor.red,
|
||||
icon: 'poker_icon',
|
||||
);
|
||||
testGame3 = Game(
|
||||
id: 'game3',
|
||||
name: 'Monopoly',
|
||||
ruleset: Ruleset.highestScore,
|
||||
description: 'A board game about real estate',
|
||||
color: GameColor.orange,
|
||||
icon: '',
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
|
||||
group('Game Tests', () {
|
||||
// Verifies that getAllGames returns an empty list when the database has no games.
|
||||
test('getAllGames returns empty list when no games exist', () async {
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that a single game can be added and retrieved with all fields intact.
|
||||
test('Adding and fetching a single game works correctly', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames.length, 1);
|
||||
expect(allGames.first.id, testGame1.id);
|
||||
expect(allGames.first.name, testGame1.name);
|
||||
expect(allGames.first.ruleset, testGame1.ruleset);
|
||||
expect(allGames.first.description, testGame1.description);
|
||||
expect(allGames.first.color, testGame1.color);
|
||||
expect(allGames.first.icon, testGame1.icon);
|
||||
expect(allGames.first.createdAt, testGame1.createdAt);
|
||||
});
|
||||
|
||||
// Verifies that multiple games can be added and retrieved correctly.
|
||||
test('Adding and fetching multiple games works correctly', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
await database.gameDao.addGame(game: testGame2);
|
||||
await database.gameDao.addGame(game: testGame3);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames.length, 3);
|
||||
|
||||
final names = allGames.map((g) => g.name).toList();
|
||||
expect(names, containsAll(['Chess', 'Poker', 'Monopoly']));
|
||||
});
|
||||
|
||||
// Verifies that getGameById returns the correct game with all properties.
|
||||
test('getGameById returns correct game', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
await database.gameDao.addGame(game: testGame2);
|
||||
|
||||
final game = await database.gameDao.getGameById(gameId: testGame2.id);
|
||||
expect(game.id, testGame2.id);
|
||||
expect(game.name, testGame2.name);
|
||||
expect(game.ruleset, testGame2.ruleset);
|
||||
expect(game.description, testGame2.description);
|
||||
expect(game.color, testGame2.color);
|
||||
expect(game.icon, testGame2.icon);
|
||||
});
|
||||
|
||||
// Verifies that getGameById throws a StateError when the game doesn't exist.
|
||||
test('getGameById throws exception for non-existent game', () async {
|
||||
expect(
|
||||
() => database.gameDao.getGameById(gameId: 'non-existent-id'),
|
||||
throwsA(isA<StateError>()),
|
||||
);
|
||||
});
|
||||
|
||||
// Verifies that addGame returns true when a game is successfully added.
|
||||
test('addGame returns true when game is added successfully', () async {
|
||||
final result = await database.gameDao.addGame(game: testGame1);
|
||||
expect(result, true);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames.length, 1);
|
||||
});
|
||||
|
||||
// Verifies that addGame returns false when trying to add a duplicate game.
|
||||
test('addGame returns false when game already exists', () async {
|
||||
final firstAdd = await database.gameDao.addGame(game: testGame1);
|
||||
expect(firstAdd, true);
|
||||
|
||||
final secondAdd = await database.gameDao.addGame(game: testGame1);
|
||||
expect(secondAdd, false);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames.length, 1);
|
||||
});
|
||||
|
||||
// Verifies that a game with empty optional fields can be added and retrieved.
|
||||
test('addGame handles game with null optional fields', () async {
|
||||
final gameWithNulls = Game(
|
||||
name: 'Simple Game',
|
||||
ruleset: Ruleset.lowestScore,
|
||||
description: 'A simple game',
|
||||
color: GameColor.green,
|
||||
icon: '',
|
||||
);
|
||||
final result = await database.gameDao.addGame(game: gameWithNulls);
|
||||
expect(result, true);
|
||||
|
||||
final fetchedGame = await database.gameDao.getGameById(
|
||||
gameId: gameWithNulls.id,
|
||||
);
|
||||
expect(fetchedGame.name, 'Simple Game');
|
||||
expect(fetchedGame.description, 'A simple game');
|
||||
expect(fetchedGame.color, GameColor.green);
|
||||
expect(fetchedGame.icon, '');
|
||||
});
|
||||
|
||||
// Verifies that multiple games can be added at once using addGamesAsList.
|
||||
test('addGamesAsList adds multiple games correctly', () async {
|
||||
final result = await database.gameDao.addGamesAsList(
|
||||
games: [testGame1, testGame2, testGame3],
|
||||
);
|
||||
expect(result, true);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames.length, 3);
|
||||
});
|
||||
|
||||
// Verifies that addGamesAsList returns false when given an empty list.
|
||||
test('addGamesAsList returns false for empty list', () async {
|
||||
final result = await database.gameDao.addGamesAsList(games: []);
|
||||
expect(result, false);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames.length, 0);
|
||||
});
|
||||
|
||||
// Verifies that addGamesAsList ignores duplicate games when adding.
|
||||
test('addGamesAsList ignores duplicate games', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
final result = await database.gameDao.addGamesAsList(
|
||||
games: [testGame1, testGame2],
|
||||
);
|
||||
expect(result, true);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames.length, 2);
|
||||
});
|
||||
|
||||
// Verifies that deleteGame returns true and removes the game from database.
|
||||
test('deleteGame returns true when game is deleted', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
final result = await database.gameDao.deleteGame(gameId: testGame1.id);
|
||||
expect(result, true);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that deleteGame returns false for a non-existent game ID.
|
||||
test('deleteGame returns false for non-existent game', () async {
|
||||
final result = await database.gameDao.deleteGame(
|
||||
gameId: 'non-existent-id',
|
||||
);
|
||||
expect(result, false);
|
||||
});
|
||||
|
||||
// Verifies that deleteGame only removes the specified game, leaving others intact.
|
||||
test('deleteGame only deletes the specified game', () async {
|
||||
await database.gameDao.addGamesAsList(
|
||||
games: [testGame1, testGame2, testGame3],
|
||||
);
|
||||
|
||||
await database.gameDao.deleteGame(gameId: testGame2.id);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames.length, 2);
|
||||
expect(allGames.any((g) => g.id == testGame2.id), false);
|
||||
expect(allGames.any((g) => g.id == testGame1.id), true);
|
||||
expect(allGames.any((g) => g.id == testGame3.id), true);
|
||||
});
|
||||
|
||||
// Verifies that gameExists returns true when the game exists in database.
|
||||
test('gameExists returns true for existing game', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
final exists = await database.gameDao.gameExists(gameId: testGame1.id);
|
||||
expect(exists, true);
|
||||
});
|
||||
|
||||
// Verifies that gameExists returns false for a non-existent game ID.
|
||||
test('gameExists returns false for non-existent game', () async {
|
||||
final exists = await database.gameDao.gameExists(
|
||||
gameId: 'non-existent-id',
|
||||
);
|
||||
expect(exists, false);
|
||||
});
|
||||
|
||||
// Verifies that gameExists returns false after a game has been deleted.
|
||||
test('gameExists returns false after game is deleted', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
await database.gameDao.deleteGame(gameId: testGame1.id);
|
||||
|
||||
final exists = await database.gameDao.gameExists(gameId: testGame1.id);
|
||||
expect(exists, false);
|
||||
});
|
||||
|
||||
// Verifies that updateGameName correctly updates only the name field.
|
||||
test('updateGameName updates the name correctly', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
await database.gameDao.updateGameName(
|
||||
gameId: testGame1.id,
|
||||
newName: 'Updated Chess',
|
||||
);
|
||||
|
||||
final updatedGame = await database.gameDao.getGameById(
|
||||
gameId: testGame1.id,
|
||||
);
|
||||
expect(updatedGame.name, 'Updated Chess');
|
||||
expect(updatedGame.ruleset, testGame1.ruleset);
|
||||
});
|
||||
|
||||
// Verifies that updateGameName does nothing when game doesn't exist.
|
||||
test('updateGameName does nothing for non-existent game', () async {
|
||||
await database.gameDao.updateGameName(
|
||||
gameId: 'non-existent-id',
|
||||
newName: 'New Name',
|
||||
);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that updateGameRuleset correctly updates only the ruleset field.
|
||||
test('updateGameRuleset updates the ruleset correctly', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
await database.gameDao.updateGameRuleset(
|
||||
gameId: testGame1.id,
|
||||
newRuleset: Ruleset.highestScore,
|
||||
);
|
||||
|
||||
final updatedGame = await database.gameDao.getGameById(
|
||||
gameId: testGame1.id,
|
||||
);
|
||||
expect(updatedGame.ruleset, Ruleset.highestScore);
|
||||
expect(updatedGame.name, testGame1.name);
|
||||
});
|
||||
|
||||
// Verifies that updateGameRuleset does nothing when game doesn't exist.
|
||||
test('updateGameRuleset does nothing for non-existent game', () async {
|
||||
await database.gameDao.updateGameRuleset(
|
||||
gameId: 'non-existent-id',
|
||||
newRuleset: Ruleset.lowestScore,
|
||||
);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that updateGameDescription correctly updates the description.
|
||||
test('updateGameDescription updates the description correctly', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
await database.gameDao.updateGameDescription(
|
||||
gameId: testGame1.id,
|
||||
newDescription: 'An updated description',
|
||||
);
|
||||
|
||||
final updatedGame = await database.gameDao.getGameById(
|
||||
gameId: testGame1.id,
|
||||
);
|
||||
expect(updatedGame.description, 'An updated description');
|
||||
});
|
||||
|
||||
// Verifies that updateGameDescription can set the description to an empty string.
|
||||
test('updateGameDescription can set description to empty string', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
await database.gameDao.updateGameDescription(
|
||||
gameId: testGame1.id,
|
||||
newDescription: '',
|
||||
);
|
||||
|
||||
final updatedGame = await database.gameDao.getGameById(
|
||||
gameId: testGame1.id,
|
||||
);
|
||||
expect(updatedGame.description, '');
|
||||
});
|
||||
|
||||
// Verifies that updateGameDescription does nothing when game doesn't exist.
|
||||
test('updateGameDescription does nothing for non-existent game', () async {
|
||||
await database.gameDao.updateGameDescription(
|
||||
gameId: 'non-existent-id',
|
||||
newDescription: 'New Description',
|
||||
);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that updateGameColor correctly updates the color value.
|
||||
test('updateGameColor updates the color correctly', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
await database.gameDao.updateGameColor(
|
||||
gameId: testGame1.id,
|
||||
newColor: GameColor.green,
|
||||
);
|
||||
|
||||
final updatedGame = await database.gameDao.getGameById(
|
||||
gameId: testGame1.id,
|
||||
);
|
||||
expect(updatedGame.color, GameColor.green);
|
||||
});
|
||||
|
||||
// Verifies that updateGameColor does nothing when game doesn't exist.
|
||||
test('updateGameColor does nothing for non-existent game', () async {
|
||||
await database.gameDao.updateGameColor(
|
||||
gameId: 'non-existent-id',
|
||||
newColor: GameColor.green,
|
||||
);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that updateGameIcon correctly updates the icon value.
|
||||
test('updateGameIcon updates the icon correctly', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
await database.gameDao.updateGameIcon(
|
||||
gameId: testGame1.id,
|
||||
newIcon: 'new_chess_icon',
|
||||
);
|
||||
|
||||
final updatedGame = await database.gameDao.getGameById(
|
||||
gameId: testGame1.id,
|
||||
);
|
||||
expect(updatedGame.icon, 'new_chess_icon');
|
||||
});
|
||||
|
||||
// Verifies that updateGameIcon can update the icon.
|
||||
test('updateGameIcon updates icon correctly', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
await database.gameDao.updateGameIcon(
|
||||
gameId: testGame1.id,
|
||||
newIcon: 'new_icon',
|
||||
);
|
||||
|
||||
final updatedGame = await database.gameDao.getGameById(
|
||||
gameId: testGame1.id,
|
||||
);
|
||||
expect(updatedGame.icon, 'new_icon');
|
||||
});
|
||||
|
||||
// Verifies that updateGameIcon does nothing when game doesn't exist.
|
||||
test('updateGameIcon does nothing for non-existent game', () async {
|
||||
await database.gameDao.updateGameIcon(
|
||||
gameId: 'non-existent-id',
|
||||
newIcon: 'some_icon',
|
||||
);
|
||||
|
||||
final allGames = await database.gameDao.getAllGames();
|
||||
expect(allGames, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that getGameCount returns 0 when no games exist.
|
||||
test('getGameCount returns 0 when no games exist', () async {
|
||||
final count = await database.gameDao.getGameCount();
|
||||
expect(count, 0);
|
||||
});
|
||||
|
||||
// Verifies that getGameCount returns the correct count after adding games.
|
||||
test('getGameCount returns correct count after adding games', () async {
|
||||
await database.gameDao.addGamesAsList(
|
||||
games: [testGame1, testGame2, testGame3],
|
||||
);
|
||||
|
||||
final count = await database.gameDao.getGameCount();
|
||||
expect(count, 3);
|
||||
});
|
||||
|
||||
// Verifies that getGameCount updates correctly after deleting a game.
|
||||
test('getGameCount updates correctly after deletion', () async {
|
||||
await database.gameDao.addGamesAsList(games: [testGame1, testGame2]);
|
||||
|
||||
final countBefore = await database.gameDao.getGameCount();
|
||||
expect(countBefore, 2);
|
||||
|
||||
await database.gameDao.deleteGame(gameId: testGame1.id);
|
||||
|
||||
final countAfter = await database.gameDao.getGameCount();
|
||||
expect(countAfter, 1);
|
||||
});
|
||||
|
||||
// Verifies that deleteAllGames removes all games from the database.
|
||||
test('deleteAllGames removes all games', () async {
|
||||
await database.gameDao.addGamesAsList(
|
||||
games: [testGame1, testGame2, testGame3],
|
||||
);
|
||||
|
||||
final countBefore = await database.gameDao.getGameCount();
|
||||
expect(countBefore, 3);
|
||||
|
||||
final result = await database.gameDao.deleteAllGames();
|
||||
expect(result, true);
|
||||
|
||||
final countAfter = await database.gameDao.getGameCount();
|
||||
expect(countAfter, 0);
|
||||
});
|
||||
|
||||
// Verifies that deleteAllGames returns false when no games exist.
|
||||
test('deleteAllGames returns false when no games exist', () async {
|
||||
final result = await database.gameDao.deleteAllGames();
|
||||
expect(result, false);
|
||||
});
|
||||
|
||||
// Verifies that games with special characters (quotes, emojis) are stored correctly.
|
||||
test('Game with special characters in name is stored correctly', () async {
|
||||
final specialGame = Game(
|
||||
name: 'Game\'s & "Special" <Name>',
|
||||
ruleset: Ruleset.multipleWinners,
|
||||
description: 'Description with émojis 🎮🎲',
|
||||
color: GameColor.purple,
|
||||
icon: '',
|
||||
);
|
||||
await database.gameDao.addGame(game: specialGame);
|
||||
|
||||
final fetchedGame = await database.gameDao.getGameById(
|
||||
gameId: specialGame.id,
|
||||
);
|
||||
expect(fetchedGame.name, 'Game\'s & "Special" <Name>');
|
||||
expect(fetchedGame.description, 'Description with émojis 🎮🎲');
|
||||
});
|
||||
|
||||
// Verifies that games with empty string fields are stored and retrieved correctly.
|
||||
test('Game with empty string fields is stored correctly', () async {
|
||||
final emptyGame = Game(
|
||||
name: '',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
description: '',
|
||||
icon: '',
|
||||
color: GameColor.red,
|
||||
);
|
||||
await database.gameDao.addGame(game: emptyGame);
|
||||
|
||||
final fetchedGame = await database.gameDao.getGameById(
|
||||
gameId: emptyGame.id,
|
||||
);
|
||||
expect(fetchedGame.name, '');
|
||||
expect(fetchedGame.ruleset, Ruleset.singleWinner);
|
||||
expect(fetchedGame.description, '');
|
||||
expect(fetchedGame.icon, '');
|
||||
});
|
||||
|
||||
// Verifies that games with very long strings (10000 chars) are handled correctly.
|
||||
test('Game with very long strings is stored correctly', () async {
|
||||
final longString = 'A' * 10000;
|
||||
final longGame = Game(
|
||||
name: longString,
|
||||
description: longString,
|
||||
ruleset: Ruleset.multipleWinners,
|
||||
color: GameColor.yellow,
|
||||
icon: '',
|
||||
);
|
||||
await database.gameDao.addGame(game: longGame);
|
||||
|
||||
final fetchedGame = await database.gameDao.getGameById(
|
||||
gameId: longGame.id,
|
||||
);
|
||||
expect(fetchedGame.name.length, 10000);
|
||||
expect(fetchedGame.description.length, 10000);
|
||||
expect(fetchedGame.ruleset, Ruleset.multipleWinners);
|
||||
});
|
||||
|
||||
// Verifies that multiple sequential updates to the same game work correctly.
|
||||
test('Multiple updates to the same game work correctly', () async {
|
||||
await database.gameDao.addGame(game: testGame1);
|
||||
|
||||
await database.gameDao.updateGameName(
|
||||
gameId: testGame1.id,
|
||||
newName: 'Updated Name',
|
||||
);
|
||||
await database.gameDao.updateGameColor(
|
||||
gameId: testGame1.id,
|
||||
newColor: GameColor.teal,
|
||||
);
|
||||
await database.gameDao.updateGameDescription(
|
||||
gameId: testGame1.id,
|
||||
newDescription: 'Updated Description',
|
||||
);
|
||||
|
||||
final updatedGame = await database.gameDao.getGameById(
|
||||
gameId: testGame1.id,
|
||||
);
|
||||
expect(updatedGame.name, 'Updated Name');
|
||||
expect(updatedGame.color, GameColor.teal);
|
||||
expect(updatedGame.description, 'Updated Description');
|
||||
expect(updatedGame.ruleset, testGame1.ruleset);
|
||||
expect(updatedGame.icon, testGame1.icon);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -1,385 +0,0 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart' hide isNull;
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Player testPlayer4;
|
||||
final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
// Recommended for widget tests to avoid test errors.
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Test Player', description: '');
|
||||
testPlayer2 = Player(name: 'Second Player', description: '');
|
||||
testPlayer3 = Player(name: 'Charlie', description: '');
|
||||
testPlayer4 = Player(name: 'Diana', description: '');
|
||||
});
|
||||
});
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
|
||||
group('Player Tests', () {
|
||||
// Verifies that players can be added and retrieved with all fields intact.
|
||||
test('Adding and fetching single player works correctly', () async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.playerDao.addPlayer(player: testPlayer2);
|
||||
|
||||
final allPlayers = await database.playerDao.getAllPlayers();
|
||||
expect(allPlayers.length, 2);
|
||||
|
||||
final fetchedPlayer1 = allPlayers.firstWhere(
|
||||
(g) => g.id == testPlayer1.id,
|
||||
);
|
||||
expect(fetchedPlayer1.name, testPlayer1.name);
|
||||
expect(fetchedPlayer1.createdAt, testPlayer1.createdAt);
|
||||
|
||||
final fetchedPlayer2 = allPlayers.firstWhere(
|
||||
(g) => g.id == testPlayer2.id,
|
||||
);
|
||||
expect(fetchedPlayer2.name, testPlayer2.name);
|
||||
expect(fetchedPlayer2.createdAt, testPlayer2.createdAt);
|
||||
});
|
||||
|
||||
// Verifies that multiple players can be added at once and retrieved correctly.
|
||||
test('Adding and fetching multiple players works correctly', () async {
|
||||
await database.playerDao.addPlayersAsList(
|
||||
players: [testPlayer1, testPlayer2, testPlayer3, testPlayer4],
|
||||
);
|
||||
|
||||
final allPlayers = await database.playerDao.getAllPlayers();
|
||||
expect(allPlayers.length, 4);
|
||||
|
||||
// Map for connecting fetched players with expected players
|
||||
final testPlayers = {
|
||||
testPlayer1.id: testPlayer1,
|
||||
testPlayer2.id: testPlayer2,
|
||||
testPlayer3.id: testPlayer3,
|
||||
testPlayer4.id: testPlayer4,
|
||||
};
|
||||
|
||||
for (final player in allPlayers) {
|
||||
final testPlayer = testPlayers[player.id]!;
|
||||
|
||||
expect(player.id, testPlayer.id);
|
||||
expect(player.name, testPlayer.name);
|
||||
expect(player.createdAt, testPlayer.createdAt);
|
||||
}
|
||||
});
|
||||
|
||||
// Verifies that adding the same player twice does not create duplicates.
|
||||
test('Adding the same player twice does not create duplicates', () async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
final allPlayers = await database.playerDao.getAllPlayers();
|
||||
expect(allPlayers.length, 1);
|
||||
});
|
||||
|
||||
// Verifies that playerExists returns correct boolean based on player presence.
|
||||
test('Player existence check works correctly', () async {
|
||||
var playerExists = await database.playerDao.playerExists(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(playerExists, false);
|
||||
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
playerExists = await database.playerDao.playerExists(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(playerExists, true);
|
||||
});
|
||||
|
||||
// Verifies that deletePlayer removes the player and returns true.
|
||||
test('Deleting a player works correctly', () async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
final playerDeleted = await database.playerDao.deletePlayer(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(playerDeleted, true);
|
||||
|
||||
final playerExists = await database.playerDao.playerExists(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(playerExists, false);
|
||||
});
|
||||
|
||||
// Verifies that updatePlayerName correctly updates only the name field.
|
||||
test('Updating a player name works correctly', () async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
const newPlayerName = 'new player name';
|
||||
|
||||
await database.playerDao.updatePlayerName(
|
||||
playerId: testPlayer1.id,
|
||||
newName: newPlayerName,
|
||||
);
|
||||
|
||||
final result = await database.playerDao.getPlayerById(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(result.name, newPlayerName);
|
||||
});
|
||||
|
||||
// Verifies that getPlayerCount returns correct count through add/delete operations.
|
||||
test('Getting the player count works correctly', () async {
|
||||
var playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 0);
|
||||
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 1);
|
||||
|
||||
await database.playerDao.addPlayer(player: testPlayer2);
|
||||
|
||||
playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 2);
|
||||
|
||||
await database.playerDao.deletePlayer(playerId: testPlayer1.id);
|
||||
|
||||
playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 1);
|
||||
|
||||
await database.playerDao.deletePlayer(playerId: testPlayer2.id);
|
||||
|
||||
playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 0);
|
||||
});
|
||||
|
||||
// Verifies that getAllPlayers returns an empty list when no players exist.
|
||||
test('getAllPlayers returns empty list when no players exist', () async {
|
||||
final allPlayers = await database.playerDao.getAllPlayers();
|
||||
expect(allPlayers, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that getPlayerById returns the correct player.
|
||||
test('getPlayerById returns correct player', () async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.playerDao.addPlayer(player: testPlayer2);
|
||||
|
||||
final fetchedPlayer = await database.playerDao.getPlayerById(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
|
||||
expect(fetchedPlayer.id, testPlayer1.id);
|
||||
expect(fetchedPlayer.name, testPlayer1.name);
|
||||
expect(fetchedPlayer.createdAt, testPlayer1.createdAt);
|
||||
expect(fetchedPlayer.description, testPlayer1.description);
|
||||
});
|
||||
|
||||
// Verifies that getPlayerById throws StateError for non-existent player ID.
|
||||
test('getPlayerById throws exception for non-existent player', () async {
|
||||
expect(
|
||||
() => database.playerDao.getPlayerById(playerId: 'non-existent-id'),
|
||||
throwsA(isA<StateError>()),
|
||||
);
|
||||
});
|
||||
|
||||
// Verifies that addPlayer returns false when trying to add a duplicate player.
|
||||
test('addPlayer returns false when player already exists', () async {
|
||||
final firstAdd = await database.playerDao.addPlayer(player: testPlayer1);
|
||||
expect(firstAdd, true);
|
||||
|
||||
final secondAdd = await database.playerDao.addPlayer(player: testPlayer1);
|
||||
expect(secondAdd, false);
|
||||
});
|
||||
|
||||
// Verifies that addPlayersAsList handles empty list correctly.
|
||||
test('addPlayersAsList handles empty list correctly', () async {
|
||||
final result = await database.playerDao.addPlayersAsList(players: []);
|
||||
expect(result, false);
|
||||
|
||||
final allPlayers = await database.playerDao.getAllPlayers();
|
||||
expect(allPlayers, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that addPlayersAsList ignores duplicate player IDs.
|
||||
test('addPlayersAsList with duplicate IDs ignores duplicates', () async {
|
||||
await database.playerDao.addPlayersAsList(
|
||||
players: [testPlayer1, testPlayer1, testPlayer2],
|
||||
);
|
||||
|
||||
final allPlayers = await database.playerDao.getAllPlayers();
|
||||
expect(allPlayers.length, 2);
|
||||
});
|
||||
|
||||
// Verifies that deletePlayer returns false for non-existent player.
|
||||
test('deletePlayer returns false for non-existent player', () async {
|
||||
final result = await database.playerDao.deletePlayer(
|
||||
playerId: 'non-existent-id',
|
||||
);
|
||||
expect(result, false);
|
||||
});
|
||||
|
||||
// Verifies that updatePlayerName does nothing for non-existent player (no exception).
|
||||
test('updatePlayerName does nothing for non-existent player', () async {
|
||||
// Should not throw, just do nothing
|
||||
await database.playerDao.updatePlayerName(
|
||||
playerId: 'non-existent-id',
|
||||
newName: 'New Name',
|
||||
);
|
||||
|
||||
final allPlayers = await database.playerDao.getAllPlayers();
|
||||
expect(allPlayers, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that deleteAllPlayers removes all players.
|
||||
test('deleteAllPlayers removes all players', () async {
|
||||
await database.playerDao.addPlayersAsList(
|
||||
players: [testPlayer1, testPlayer2, testPlayer3],
|
||||
);
|
||||
|
||||
var playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 3);
|
||||
|
||||
final result = await database.playerDao.deleteAllPlayers();
|
||||
expect(result, true);
|
||||
|
||||
playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 0);
|
||||
});
|
||||
|
||||
// Verifies that deleteAllPlayers returns false when no players exist.
|
||||
test('deleteAllPlayers returns false when no players exist', () async {
|
||||
final result = await database.playerDao.deleteAllPlayers();
|
||||
expect(result, false);
|
||||
});
|
||||
|
||||
// Verifies that a player with special characters in name is stored correctly.
|
||||
test(
|
||||
'Player with special characters in name is stored correctly',
|
||||
() async {
|
||||
final specialPlayer = Player(
|
||||
name: 'Test!@#\$%^&*()_+-=[]{}|;\':",.<>?/`~',
|
||||
description: '',
|
||||
);
|
||||
|
||||
await database.playerDao.addPlayer(player: specialPlayer);
|
||||
|
||||
final fetchedPlayer = await database.playerDao.getPlayerById(
|
||||
playerId: specialPlayer.id,
|
||||
);
|
||||
expect(fetchedPlayer.name, specialPlayer.name);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that a player with description is stored correctly.
|
||||
test('Player with description is stored correctly', () async {
|
||||
final playerWithDescription = Player(
|
||||
name: 'Described Player',
|
||||
description: 'This is a test description',
|
||||
);
|
||||
|
||||
await database.playerDao.addPlayer(player: playerWithDescription);
|
||||
|
||||
final fetchedPlayer = await database.playerDao.getPlayerById(
|
||||
playerId: playerWithDescription.id,
|
||||
);
|
||||
expect(fetchedPlayer.name, playerWithDescription.name);
|
||||
expect(fetchedPlayer.description, playerWithDescription.description);
|
||||
});
|
||||
|
||||
// Verifies that a player with null description is stored correctly.
|
||||
test('Player with null description is stored correctly', () async {
|
||||
final playerWithoutDescription = Player(
|
||||
name: 'No Description Player',
|
||||
description: '',
|
||||
);
|
||||
|
||||
await database.playerDao.addPlayer(player: playerWithoutDescription);
|
||||
|
||||
final fetchedPlayer = await database.playerDao.getPlayerById(
|
||||
playerId: playerWithoutDescription.id,
|
||||
);
|
||||
expect(fetchedPlayer.description, '');
|
||||
});
|
||||
|
||||
// Verifies that multiple updates to the same player work correctly.
|
||||
test('Multiple updates to the same player work correctly', () async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
await database.playerDao.updatePlayerName(
|
||||
playerId: testPlayer1.id,
|
||||
newName: 'First Update',
|
||||
);
|
||||
|
||||
var fetchedPlayer = await database.playerDao.getPlayerById(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(fetchedPlayer.name, 'First Update');
|
||||
|
||||
await database.playerDao.updatePlayerName(
|
||||
playerId: testPlayer1.id,
|
||||
newName: 'Second Update',
|
||||
);
|
||||
|
||||
fetchedPlayer = await database.playerDao.getPlayerById(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(fetchedPlayer.name, 'Second Update');
|
||||
|
||||
await database.playerDao.updatePlayerName(
|
||||
playerId: testPlayer1.id,
|
||||
newName: 'Third Update',
|
||||
);
|
||||
|
||||
fetchedPlayer = await database.playerDao.getPlayerById(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(fetchedPlayer.name, 'Third Update');
|
||||
});
|
||||
|
||||
// Verifies that a player with empty string name is stored correctly.
|
||||
test('Player with empty string name is stored correctly', () async {
|
||||
final emptyNamePlayer = Player(name: '', description: '');
|
||||
|
||||
await database.playerDao.addPlayer(player: emptyNamePlayer);
|
||||
|
||||
final fetchedPlayer = await database.playerDao.getPlayerById(
|
||||
playerId: emptyNamePlayer.id,
|
||||
);
|
||||
expect(fetchedPlayer.name, '');
|
||||
});
|
||||
|
||||
// Verifies that a player with very long name is stored correctly.
|
||||
test('Player with very long name is stored correctly', () async {
|
||||
final longName = 'A' * 1000;
|
||||
final longNamePlayer = Player(name: longName, description: '');
|
||||
|
||||
await database.playerDao.addPlayer(player: longNamePlayer);
|
||||
|
||||
final fetchedPlayer = await database.playerDao.getPlayerById(
|
||||
playerId: longNamePlayer.id,
|
||||
);
|
||||
expect(fetchedPlayer.name, longName);
|
||||
});
|
||||
|
||||
// Verifies that addPlayer returns true on first add.
|
||||
test('addPlayer returns true when player is added successfully', () async {
|
||||
final result = await database.playerDao.addPlayer(player: testPlayer1);
|
||||
expect(result, true);
|
||||
|
||||
final playerExists = await database.playerDao.playerExists(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(playerExists, true);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -1,13 +1,11 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart' hide isNotNull;
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
@@ -18,7 +16,6 @@ void main() {
|
||||
late Player testPlayer5;
|
||||
late Group testGroup1;
|
||||
late Group testGroup2;
|
||||
late Game testGame;
|
||||
late Match testMatch1;
|
||||
late Match testMatch2;
|
||||
late Match testMatchOnlyPlayers;
|
||||
@@ -36,56 +33,39 @@ void main() {
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Alice', description: '');
|
||||
testPlayer2 = Player(name: 'Bob', description: '');
|
||||
testPlayer3 = Player(name: 'Charlie', description: '');
|
||||
testPlayer4 = Player(name: 'Diana', description: '');
|
||||
testPlayer5 = Player(name: 'Eve', description: '');
|
||||
testPlayer1 = Player(name: 'Alice');
|
||||
testPlayer2 = Player(name: 'Bob');
|
||||
testPlayer3 = Player(name: 'Charlie');
|
||||
testPlayer4 = Player(name: 'Diana');
|
||||
testPlayer5 = Player(name: 'Eve');
|
||||
testGroup1 = Group(
|
||||
name: 'Test Group 1',
|
||||
description: '',
|
||||
name: 'Test Group 2',
|
||||
members: [testPlayer1, testPlayer2, testPlayer3],
|
||||
);
|
||||
testGroup2 = Group(
|
||||
name: 'Test Group 2',
|
||||
description: '',
|
||||
members: [testPlayer4, testPlayer5],
|
||||
);
|
||||
testGame = Game(
|
||||
name: 'Test Game',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
description: 'A test game',
|
||||
color: GameColor.blue,
|
||||
icon: '',
|
||||
);
|
||||
testMatch1 = Match(
|
||||
name: 'First Test Match',
|
||||
game: testGame,
|
||||
group: testGroup1,
|
||||
players: [testPlayer4, testPlayer5],
|
||||
winner: testPlayer4,
|
||||
notes: '',
|
||||
);
|
||||
testMatch2 = Match(
|
||||
name: 'Second Test Match',
|
||||
game: testGame,
|
||||
group: testGroup2,
|
||||
players: [testPlayer1, testPlayer2, testPlayer3],
|
||||
winner: testPlayer2,
|
||||
notes: '',
|
||||
);
|
||||
testMatchOnlyPlayers = Match(
|
||||
name: 'Test Match with Players',
|
||||
game: testGame,
|
||||
players: [testPlayer1, testPlayer2, testPlayer3],
|
||||
winner: testPlayer3,
|
||||
notes: '',
|
||||
);
|
||||
testMatchOnlyGroup = Match(
|
||||
name: 'Test Match with Group',
|
||||
game: testGame,
|
||||
group: testGroup2,
|
||||
notes: '',
|
||||
);
|
||||
});
|
||||
await database.playerDao.addPlayersAsList(
|
||||
@@ -98,14 +78,12 @@ void main() {
|
||||
],
|
||||
);
|
||||
await database.groupDao.addGroupsAsList(groups: [testGroup1, testGroup2]);
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
});
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
|
||||
group('Match Tests', () {
|
||||
// Verifies that a single match can be added and retrieved with all fields, group, and players intact.
|
||||
test('Adding and fetching single match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
|
||||
@@ -117,6 +95,14 @@ void main() {
|
||||
expect(result.name, testMatch1.name);
|
||||
expect(result.createdAt, testMatch1.createdAt);
|
||||
|
||||
if (result.winner != null && testMatch1.winner != null) {
|
||||
expect(result.winner!.id, testMatch1.winner!.id);
|
||||
expect(result.winner!.name, testMatch1.winner!.name);
|
||||
expect(result.winner!.createdAt, testMatch1.winner!.createdAt);
|
||||
} else {
|
||||
expect(result.winner, testMatch1.winner);
|
||||
}
|
||||
|
||||
if (result.group != null) {
|
||||
expect(result.group!.members.length, testGroup1.members.length);
|
||||
|
||||
@@ -127,16 +113,22 @@ void main() {
|
||||
} else {
|
||||
fail('Group is null');
|
||||
}
|
||||
expect(result.players.length, testMatch1.players.length);
|
||||
if (result.players != null) {
|
||||
expect(result.players!.length, testMatch1.players!.length);
|
||||
|
||||
for (int i = 0; i < testMatch1.players.length; i++) {
|
||||
expect(result.players[i].id, testMatch1.players[i].id);
|
||||
expect(result.players[i].name, testMatch1.players[i].name);
|
||||
expect(result.players[i].createdAt, testMatch1.players[i].createdAt);
|
||||
for (int i = 0; i < testMatch1.players!.length; i++) {
|
||||
expect(result.players![i].id, testMatch1.players![i].id);
|
||||
expect(result.players![i].name, testMatch1.players![i].name);
|
||||
expect(
|
||||
result.players![i].createdAt,
|
||||
testMatch1.players![i].createdAt,
|
||||
);
|
||||
}
|
||||
} else {
|
||||
fail('Players is null');
|
||||
}
|
||||
});
|
||||
|
||||
// Verifies that multiple matches can be added and retrieved with correct groups and players.
|
||||
test('Adding and fetching multiple matches works correctly', () async {
|
||||
await database.matchDao.addMatchAsList(
|
||||
matches: [
|
||||
@@ -164,6 +156,13 @@ void main() {
|
||||
expect(match.id, testMatch.id);
|
||||
expect(match.name, testMatch.name);
|
||||
expect(match.createdAt, testMatch.createdAt);
|
||||
if (match.winner != null && testMatch.winner != null) {
|
||||
expect(match.winner!.id, testMatch.winner!.id);
|
||||
expect(match.winner!.name, testMatch.winner!.name);
|
||||
expect(match.winner!.createdAt, testMatch.winner!.createdAt);
|
||||
} else {
|
||||
expect(match.winner, testMatch.winner);
|
||||
}
|
||||
|
||||
// Group-Checks
|
||||
if (testMatch.group != null) {
|
||||
@@ -189,16 +188,22 @@ void main() {
|
||||
}
|
||||
|
||||
// Players-Checks
|
||||
expect(match.players.length, testMatch.players.length);
|
||||
for (int i = 0; i < testMatch.players.length; i++) {
|
||||
expect(match.players[i].id, testMatch.players[i].id);
|
||||
expect(match.players[i].name, testMatch.players[i].name);
|
||||
expect(match.players[i].createdAt, testMatch.players[i].createdAt);
|
||||
if (testMatch.players != null) {
|
||||
expect(match.players!.length, testMatch.players!.length);
|
||||
for (int i = 0; i < testMatch.players!.length; i++) {
|
||||
expect(match.players![i].id, testMatch.players![i].id);
|
||||
expect(match.players![i].name, testMatch.players![i].name);
|
||||
expect(
|
||||
match.players![i].createdAt,
|
||||
testMatch.players![i].createdAt,
|
||||
);
|
||||
}
|
||||
} else {
|
||||
expect(match.players, null);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Verifies that adding the same match twice does not create duplicates.
|
||||
test('Adding the same match twice does not create duplicates', () async {
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
@@ -207,7 +212,6 @@ void main() {
|
||||
expect(matchCount, 1);
|
||||
});
|
||||
|
||||
// Verifies that matchExists returns correct boolean based on match presence.
|
||||
test('Match existence check works correctly', () async {
|
||||
var matchExists = await database.matchDao.matchExists(
|
||||
matchId: testMatch1.id,
|
||||
@@ -220,7 +224,6 @@ void main() {
|
||||
expect(matchExists, true);
|
||||
});
|
||||
|
||||
// Verifies that deleteMatch removes the match and returns true.
|
||||
test('Deleting a match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
|
||||
@@ -235,7 +238,6 @@ void main() {
|
||||
expect(matchExists, false);
|
||||
});
|
||||
|
||||
// Verifies that getMatchCount returns correct count through add/delete operations.
|
||||
test('Getting the match count works correctly', () async {
|
||||
var matchCount = await database.matchDao.getMatchCount();
|
||||
expect(matchCount, 0);
|
||||
@@ -261,7 +263,82 @@ void main() {
|
||||
expect(matchCount, 0);
|
||||
});
|
||||
|
||||
// Verifies that updateMatchName correctly updates only the name field.
|
||||
test('Checking if match has winner works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
|
||||
var hasWinner = await database.matchDao.hasWinner(matchId: testMatch1.id);
|
||||
expect(hasWinner, true);
|
||||
|
||||
hasWinner = await database.matchDao.hasWinner(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
);
|
||||
expect(hasWinner, false);
|
||||
});
|
||||
|
||||
test('Fetching the winner of a match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
|
||||
final winner = await database.matchDao.getWinner(matchId: testMatch1.id);
|
||||
if (winner == null) {
|
||||
fail('Winner is null');
|
||||
} else {
|
||||
expect(winner.id, testMatch1.winner!.id);
|
||||
expect(winner.name, testMatch1.winner!.name);
|
||||
expect(winner.createdAt, testMatch1.winner!.createdAt);
|
||||
}
|
||||
});
|
||||
|
||||
test('Updating the winner of a match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
|
||||
final winner = await database.matchDao.getWinner(matchId: testMatch1.id);
|
||||
if (winner == null) {
|
||||
fail('Winner is null');
|
||||
} else {
|
||||
expect(winner.id, testMatch1.winner!.id);
|
||||
expect(winner.name, testMatch1.winner!.name);
|
||||
expect(winner.createdAt, testMatch1.winner!.createdAt);
|
||||
expect(winner.id, testPlayer4.id);
|
||||
expect(winner.id != testPlayer5.id, true);
|
||||
}
|
||||
|
||||
await database.matchDao.setWinner(
|
||||
matchId: testMatch1.id,
|
||||
winnerId: testPlayer5.id,
|
||||
);
|
||||
|
||||
final newWinner = await database.matchDao.getWinner(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
if (newWinner == null) {
|
||||
fail('New winner is null');
|
||||
} else {
|
||||
expect(newWinner.id, testPlayer5.id);
|
||||
expect(newWinner.name, testPlayer5.name);
|
||||
expect(newWinner.createdAt, testPlayer5.createdAt);
|
||||
}
|
||||
});
|
||||
|
||||
test('Removing a winner works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatch2);
|
||||
|
||||
var hasWinner = await database.matchDao.hasWinner(matchId: testMatch2.id);
|
||||
expect(hasWinner, true);
|
||||
|
||||
await database.matchDao.removeWinner(matchId: testMatch2.id);
|
||||
|
||||
hasWinner = await database.matchDao.hasWinner(matchId: testMatch2.id);
|
||||
expect(hasWinner, false);
|
||||
|
||||
final removedWinner = await database.matchDao.getWinner(
|
||||
matchId: testMatch2.id,
|
||||
);
|
||||
|
||||
expect(removedWinner, null);
|
||||
});
|
||||
|
||||
test('Renaming a match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
|
||||
@@ -281,94 +358,5 @@ void main() {
|
||||
);
|
||||
expect(fetchedMatch.name, newName);
|
||||
});
|
||||
|
||||
test('Fetching a winner works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
|
||||
var fetchedMatch = await database.matchDao.getMatchById(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
expect(fetchedMatch.winner, isNotNull);
|
||||
expect(fetchedMatch.winner!.id, testPlayer4.id);
|
||||
});
|
||||
|
||||
test('Setting a winner works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
|
||||
await database.scoreEntryDao.setWinner(
|
||||
matchId: testMatch1.id,
|
||||
playerId: testPlayer5.id,
|
||||
);
|
||||
|
||||
final fetchedMatch = await database.matchDao.getMatchById(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(fetchedMatch.winner, isNotNull);
|
||||
expect(fetchedMatch.winner!.id, testPlayer5.id);
|
||||
});
|
||||
|
||||
test(
|
||||
'removeMatchGroup removes group from match with existing group',
|
||||
() async {
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
|
||||
final removed = await database.matchDao.removeMatchGroup(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(removed, isTrue);
|
||||
|
||||
final updatedMatch = await database.matchDao.getMatchById(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(updatedMatch.group, null);
|
||||
expect(updatedMatch.game.id, testMatch1.game.id);
|
||||
expect(updatedMatch.name, testMatch1.name);
|
||||
expect(updatedMatch.notes, testMatch1.notes);
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'removeMatchGroup on match that already has no group still succeeds',
|
||||
() async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
|
||||
final removed = await database.matchDao.removeMatchGroup(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
expect(removed, isTrue);
|
||||
|
||||
final updatedMatch = await database.matchDao.getMatchById(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
expect(updatedMatch.group, null);
|
||||
},
|
||||
);
|
||||
|
||||
test('removeMatchGroup on non-existing match returns false', () async {
|
||||
final removed = await database.matchDao.removeMatchGroup(
|
||||
matchId: 'non-existing-id',
|
||||
);
|
||||
expect(removed, isFalse);
|
||||
});
|
||||
|
||||
test('Fetching all matches related to a group', () async {
|
||||
var matches = await database.matchDao.getGroupMatches(
|
||||
groupId: 'non-existing-id',
|
||||
);
|
||||
|
||||
expect(matches, isEmpty);
|
||||
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
|
||||
matches = await database.matchDao.getGroupMatches(groupId: testGroup1.id);
|
||||
|
||||
expect(matches, isNotEmpty);
|
||||
|
||||
final match = matches.first;
|
||||
expect(match.id, testMatch1.id);
|
||||
expect(match.group, isNotNull);
|
||||
expect(match.group!.id, testGroup1.id);
|
||||
});
|
||||
});
|
||||
}
|
||||
221
test/db_tests/group_match_test.dart
Normal file
221
test/db_tests/group_match_test.dart
Normal file
@@ -0,0 +1,221 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart' hide isNotNull;
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Player testPlayer4;
|
||||
late Player testPlayer5;
|
||||
late Group testGroup1;
|
||||
late Group testGroup2;
|
||||
late Match testMatchWithGroup;
|
||||
late Match testMatchWithPlayers;
|
||||
final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() async {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
// Recommended for widget tests to avoid test errors.
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Alice');
|
||||
testPlayer2 = Player(name: 'Bob');
|
||||
testPlayer3 = Player(name: 'Charlie');
|
||||
testPlayer4 = Player(name: 'Diana');
|
||||
testPlayer5 = Player(name: 'Eve');
|
||||
testGroup1 = Group(
|
||||
name: 'Test Group',
|
||||
members: [testPlayer1, testPlayer2, testPlayer3],
|
||||
);
|
||||
testGroup2 = Group(
|
||||
name: 'Test Group',
|
||||
members: [testPlayer3, testPlayer2],
|
||||
);
|
||||
testMatchWithPlayers = Match(
|
||||
name: 'Test Match with Players',
|
||||
players: [testPlayer4, testPlayer5],
|
||||
);
|
||||
testMatchWithGroup = Match(
|
||||
name: 'Test Match with Group',
|
||||
group: testGroup1,
|
||||
);
|
||||
});
|
||||
await database.playerDao.addPlayersAsList(
|
||||
players: [
|
||||
testPlayer1,
|
||||
testPlayer2,
|
||||
testPlayer3,
|
||||
testPlayer4,
|
||||
testPlayer5,
|
||||
],
|
||||
);
|
||||
await database.groupDao.addGroupsAsList(groups: [testGroup1, testGroup2]);
|
||||
});
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
group('Group-Match Tests', () {
|
||||
test('matchHasGroup() has group works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchWithPlayers);
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
var matchHasGroup = await database.groupMatchDao.matchHasGroup(
|
||||
matchId: testMatchWithPlayers.id,
|
||||
);
|
||||
|
||||
expect(matchHasGroup, false);
|
||||
|
||||
await database.groupMatchDao.addGroupToMatch(
|
||||
matchId: testMatchWithPlayers.id,
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
|
||||
matchHasGroup = await database.groupMatchDao.matchHasGroup(
|
||||
matchId: testMatchWithPlayers.id,
|
||||
);
|
||||
|
||||
expect(matchHasGroup, true);
|
||||
});
|
||||
|
||||
test('Adding a group to a match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchWithPlayers);
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
await database.groupMatchDao.addGroupToMatch(
|
||||
matchId: testMatchWithPlayers.id,
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
|
||||
var groupAdded = await database.groupMatchDao.isGroupInMatch(
|
||||
matchId: testMatchWithPlayers.id,
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(groupAdded, true);
|
||||
|
||||
groupAdded = await database.groupMatchDao.isGroupInMatch(
|
||||
matchId: testMatchWithPlayers.id,
|
||||
groupId: '',
|
||||
);
|
||||
expect(groupAdded, false);
|
||||
});
|
||||
|
||||
test('Removing group from match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchWithGroup);
|
||||
|
||||
final groupToRemove = testMatchWithGroup.group!;
|
||||
|
||||
final removed = await database.groupMatchDao.removeGroupFromMatch(
|
||||
groupId: groupToRemove.id,
|
||||
matchId: testMatchWithGroup.id,
|
||||
);
|
||||
expect(removed, true);
|
||||
|
||||
final result = await database.matchDao.getMatchById(
|
||||
matchId: testMatchWithGroup.id,
|
||||
);
|
||||
expect(result.group, null);
|
||||
});
|
||||
|
||||
test('Retrieving group of a match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchWithGroup);
|
||||
final group = await database.groupMatchDao.getGroupOfMatch(
|
||||
matchId: testMatchWithGroup.id,
|
||||
);
|
||||
|
||||
if (group == null) {
|
||||
fail('Group should not be null');
|
||||
}
|
||||
|
||||
expect(group.id, testGroup1.id);
|
||||
expect(group.name, testGroup1.name);
|
||||
expect(group.createdAt, testGroup1.createdAt);
|
||||
expect(group.members.length, testGroup1.members.length);
|
||||
for (int i = 0; i < group.members.length; i++) {
|
||||
expect(group.members[i].id, testGroup1.members[i].id);
|
||||
expect(group.members[i].name, testGroup1.members[i].name);
|
||||
expect(group.members[i].createdAt, testGroup1.members[i].createdAt);
|
||||
}
|
||||
});
|
||||
|
||||
test('Updating the group of a match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchWithGroup);
|
||||
|
||||
var group = await database.groupMatchDao.getGroupOfMatch(
|
||||
matchId: testMatchWithGroup.id,
|
||||
);
|
||||
|
||||
if (group == null) {
|
||||
fail('Initial group should not be null');
|
||||
} else {
|
||||
expect(group.id, testGroup1.id);
|
||||
expect(group.name, testGroup1.name);
|
||||
expect(group.createdAt, testGroup1.createdAt);
|
||||
expect(group.members.length, testGroup1.members.length);
|
||||
}
|
||||
|
||||
await database.groupDao.addGroup(group: testGroup2);
|
||||
await database.groupMatchDao.updateGroupOfMatch(
|
||||
matchId: testMatchWithGroup.id,
|
||||
newGroupId: testGroup2.id,
|
||||
);
|
||||
|
||||
group = await database.groupMatchDao.getGroupOfMatch(
|
||||
matchId: testMatchWithGroup.id,
|
||||
);
|
||||
|
||||
if (group == null) {
|
||||
fail('Updated group should not be null');
|
||||
} else {
|
||||
expect(group.id, testGroup2.id);
|
||||
expect(group.name, testGroup2.name);
|
||||
expect(group.createdAt, testGroup2.createdAt);
|
||||
expect(group.members.length, testGroup2.members.length);
|
||||
for (int i = 0; i < group.members.length; i++) {
|
||||
expect(group.members[i].id, testGroup2.members[i].id);
|
||||
expect(group.members[i].name, testGroup2.members[i].name);
|
||||
expect(group.members[i].createdAt, testGroup2.members[i].createdAt);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('Adding the same group to seperate matches works correctly', () async {
|
||||
final match1 = Match(name: 'Match 1', group: testGroup1);
|
||||
final match2 = Match(name: 'Match 2', group: testGroup1);
|
||||
|
||||
await Future.wait([
|
||||
database.matchDao.addMatch(match: match1),
|
||||
database.matchDao.addMatch(match: match2),
|
||||
]);
|
||||
|
||||
final group1 = await database.groupMatchDao.getGroupOfMatch(
|
||||
matchId: match1.id,
|
||||
);
|
||||
final group2 = await database.groupMatchDao.getGroupOfMatch(
|
||||
matchId: match2.id,
|
||||
);
|
||||
|
||||
expect(group1, isNotNull);
|
||||
expect(group2, isNotNull);
|
||||
|
||||
final groups = [group1!, group2!];
|
||||
for (final group in groups) {
|
||||
expect(group.members.length, testGroup1.members.length);
|
||||
expect(group.id, testGroup1.id);
|
||||
expect(group.name, testGroup1.name);
|
||||
expect(group.createdAt, testGroup1.createdAt);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
177
test/db_tests/group_test.dart
Normal file
177
test/db_tests/group_test.dart
Normal file
@@ -0,0 +1,177 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Player testPlayer4;
|
||||
late Group testGroup1;
|
||||
late Group testGroup2;
|
||||
late Group testGroup3;
|
||||
late Group testGroup4;
|
||||
final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
// Recommended for widget tests to avoid test errors.
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Alice');
|
||||
testPlayer2 = Player(name: 'Bob');
|
||||
testPlayer3 = Player(name: 'Charlie');
|
||||
testPlayer4 = Player(name: 'Diana');
|
||||
testGroup1 = Group(
|
||||
name: 'Test Group',
|
||||
members: [testPlayer1, testPlayer2, testPlayer3],
|
||||
);
|
||||
testGroup2 = Group(
|
||||
id: 'gr2',
|
||||
name: 'Second Group',
|
||||
members: [testPlayer2, testPlayer3, testPlayer4],
|
||||
);
|
||||
testGroup3 = Group(
|
||||
id: 'gr2',
|
||||
name: 'Second Group',
|
||||
members: [testPlayer2, testPlayer4],
|
||||
);
|
||||
testGroup4 = Group(
|
||||
id: 'gr2',
|
||||
name: 'Second Group',
|
||||
members: [testPlayer1, testPlayer2, testPlayer3, testPlayer4],
|
||||
);
|
||||
});
|
||||
});
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
group('Group Tests', () {
|
||||
test('Adding and fetching a single group works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
final fetchedGroup = await database.groupDao.getGroupById(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
|
||||
expect(fetchedGroup.id, testGroup1.id);
|
||||
expect(fetchedGroup.name, testGroup1.name);
|
||||
expect(fetchedGroup.createdAt, testGroup1.createdAt);
|
||||
|
||||
expect(fetchedGroup.members.length, testGroup1.members.length);
|
||||
for (int i = 0; i < testGroup1.members.length; i++) {
|
||||
expect(fetchedGroup.members[i].id, testGroup1.members[i].id);
|
||||
expect(fetchedGroup.members[i].name, testGroup1.members[i].name);
|
||||
expect(
|
||||
fetchedGroup.members[i].createdAt,
|
||||
testGroup1.members[i].createdAt,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
test('Adding and fetching multiple groups works correctly', () async {
|
||||
await database.groupDao.addGroupsAsList(
|
||||
groups: [testGroup1, testGroup2, testGroup3, testGroup4],
|
||||
);
|
||||
|
||||
final allGroups = await database.groupDao.getAllGroups();
|
||||
expect(allGroups.length, 2);
|
||||
|
||||
final testGroups = {testGroup1.id: testGroup1, testGroup2.id: testGroup2};
|
||||
|
||||
for (final group in allGroups) {
|
||||
final testGroup = testGroups[group.id]!;
|
||||
|
||||
expect(group.id, testGroup.id);
|
||||
expect(group.name, testGroup.name);
|
||||
expect(group.createdAt, testGroup.createdAt);
|
||||
|
||||
expect(group.members.length, testGroup.members.length);
|
||||
for (int i = 0; i < testGroup.members.length; i++) {
|
||||
expect(group.members[i].id, testGroup.members[i].id);
|
||||
expect(group.members[i].name, testGroup.members[i].name);
|
||||
expect(group.members[i].createdAt, testGroup.members[i].createdAt);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('Adding the same group twice does not create duplicates', () async {
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
final allGroups = await database.groupDao.getAllGroups();
|
||||
expect(allGroups.length, 1);
|
||||
});
|
||||
|
||||
test('Group existence check works correctly', () async {
|
||||
var groupExists = await database.groupDao.groupExists(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(groupExists, false);
|
||||
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
groupExists = await database.groupDao.groupExists(groupId: testGroup1.id);
|
||||
expect(groupExists, true);
|
||||
});
|
||||
|
||||
test('Deleting a group works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
final groupDeleted = await database.groupDao.deleteGroup(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(groupDeleted, true);
|
||||
|
||||
final groupExists = await database.groupDao.groupExists(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(groupExists, false);
|
||||
});
|
||||
|
||||
test('Updating a group name works correcly', () async {
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
const newGroupName = 'new group name';
|
||||
|
||||
await database.groupDao.updateGroupname(
|
||||
groupId: testGroup1.id,
|
||||
newName: newGroupName,
|
||||
);
|
||||
|
||||
final result = await database.groupDao.getGroupById(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(result.name, newGroupName);
|
||||
});
|
||||
|
||||
test('Getting the group count works correctly', () async {
|
||||
final initialCount = await database.groupDao.getGroupCount();
|
||||
expect(initialCount, 0);
|
||||
|
||||
await database.groupDao.addGroup(group: testGroup1);
|
||||
|
||||
final groupAdded = await database.groupDao.getGroupCount();
|
||||
expect(groupAdded, 1);
|
||||
|
||||
final groupRemoved = await database.groupDao.deleteGroup(
|
||||
groupId: testGroup1.id,
|
||||
);
|
||||
expect(groupRemoved, true);
|
||||
|
||||
final finalCount = await database.groupDao.getGroupCount();
|
||||
expect(finalCount, 0);
|
||||
});
|
||||
});
|
||||
}
|
||||
103
test/db_tests/player_group_test.dart
Normal file
103
test/db_tests/player_group_test.dart
Normal file
@@ -0,0 +1,103 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Player testPlayer4;
|
||||
late Group testgroup;
|
||||
final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
// Recommended for widget tests to avoid test errors.
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Alice');
|
||||
testPlayer2 = Player(name: 'Bob');
|
||||
testPlayer3 = Player(name: 'Charlie');
|
||||
testPlayer4 = Player(name: 'Diana');
|
||||
testgroup = Group(
|
||||
name: 'Test Group',
|
||||
members: [testPlayer1, testPlayer2, testPlayer3],
|
||||
);
|
||||
});
|
||||
});
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
|
||||
group('Player-Group Tests', () {
|
||||
/// No need to test if group has players since the members attribute is
|
||||
/// not nullable
|
||||
|
||||
test('Adding a player to a group works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testgroup);
|
||||
await database.playerDao.addPlayer(player: testPlayer4);
|
||||
await database.playerGroupDao.addPlayerToGroup(
|
||||
groupId: testgroup.id,
|
||||
player: testPlayer4,
|
||||
);
|
||||
|
||||
var playerAdded = await database.playerGroupDao.isPlayerInGroup(
|
||||
groupId: testgroup.id,
|
||||
playerId: testPlayer4.id,
|
||||
);
|
||||
|
||||
expect(playerAdded, true);
|
||||
|
||||
playerAdded = await database.playerGroupDao.isPlayerInGroup(
|
||||
groupId: testgroup.id,
|
||||
playerId: '',
|
||||
);
|
||||
|
||||
expect(playerAdded, false);
|
||||
});
|
||||
|
||||
test('Removing player from group works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testgroup);
|
||||
|
||||
final playerToRemove = testgroup.members[0];
|
||||
|
||||
final removed = await database.playerGroupDao.removePlayerFromGroup(
|
||||
playerId: playerToRemove.id,
|
||||
groupId: testgroup.id,
|
||||
);
|
||||
expect(removed, true);
|
||||
|
||||
final result = await database.groupDao.getGroupById(
|
||||
groupId: testgroup.id,
|
||||
);
|
||||
expect(result.members.length, testgroup.members.length - 1);
|
||||
|
||||
final playerExists = result.members.any((p) => p.id == playerToRemove.id);
|
||||
expect(playerExists, false);
|
||||
});
|
||||
|
||||
test('Retrieving players of a group works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testgroup);
|
||||
final players = await database.playerGroupDao.getPlayersOfGroup(
|
||||
groupId: testgroup.id,
|
||||
);
|
||||
|
||||
for (int i = 0; i < players.length; i++) {
|
||||
expect(players[i].id, testgroup.members[i].id);
|
||||
expect(players[i].name, testgroup.members[i].name);
|
||||
expect(players[i].createdAt, testgroup.members[i].createdAt);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
237
test/db_tests/player_match_test.dart
Normal file
237
test/db_tests/player_match_test.dart
Normal file
@@ -0,0 +1,237 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart' hide isNotNull;
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/dto/group.dart';
|
||||
import 'package:tallee/data/dto/match.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Player testPlayer4;
|
||||
late Player testPlayer5;
|
||||
late Player testPlayer6;
|
||||
late Group testgroup;
|
||||
late Match testMatchOnlyGroup;
|
||||
late Match testMatchOnlyPlayers;
|
||||
final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() async {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
// Recommended for widget tests to avoid test errors.
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Alice');
|
||||
testPlayer2 = Player(name: 'Bob');
|
||||
testPlayer3 = Player(name: 'Charlie');
|
||||
testPlayer4 = Player(name: 'Diana');
|
||||
testPlayer5 = Player(name: 'Eve');
|
||||
testPlayer6 = Player(name: 'Frank');
|
||||
testgroup = Group(
|
||||
name: 'Test Group',
|
||||
members: [testPlayer1, testPlayer2, testPlayer3],
|
||||
);
|
||||
testMatchOnlyGroup = Match(
|
||||
name: 'Test Match with Group',
|
||||
group: testgroup,
|
||||
);
|
||||
testMatchOnlyPlayers = Match(
|
||||
name: 'Test Match with Players',
|
||||
players: [testPlayer4, testPlayer5, testPlayer6],
|
||||
);
|
||||
});
|
||||
await database.playerDao.addPlayersAsList(
|
||||
players: [
|
||||
testPlayer1,
|
||||
testPlayer2,
|
||||
testPlayer3,
|
||||
testPlayer4,
|
||||
testPlayer5,
|
||||
testPlayer6,
|
||||
],
|
||||
);
|
||||
await database.groupDao.addGroup(group: testgroup);
|
||||
});
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
|
||||
group('Player-Match Tests', () {
|
||||
test('Match has player works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
var matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
);
|
||||
|
||||
expect(matchHasPlayers, false);
|
||||
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
|
||||
matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
);
|
||||
|
||||
expect(matchHasPlayers, true);
|
||||
});
|
||||
|
||||
test('Adding a player to a match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
await database.playerDao.addPlayer(player: testPlayer5);
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer5.id,
|
||||
);
|
||||
|
||||
var playerAdded = await database.playerMatchDao.isPlayerInMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer5.id,
|
||||
);
|
||||
|
||||
expect(playerAdded, true);
|
||||
|
||||
playerAdded = await database.playerMatchDao.isPlayerInMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: '',
|
||||
);
|
||||
|
||||
expect(playerAdded, false);
|
||||
});
|
||||
|
||||
test('Removing player from match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
|
||||
final playerToRemove = testMatchOnlyPlayers.players![0];
|
||||
|
||||
final removed = await database.playerMatchDao.removePlayerFromMatch(
|
||||
playerId: playerToRemove.id,
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
expect(removed, true);
|
||||
|
||||
final result = await database.matchDao.getMatchById(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
expect(result.players!.length, testMatchOnlyPlayers.players!.length - 1);
|
||||
|
||||
final playerExists = result.players!.any(
|
||||
(p) => p.id == playerToRemove.id,
|
||||
);
|
||||
expect(playerExists, false);
|
||||
});
|
||||
|
||||
test('Retrieving players of a match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
final players = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
|
||||
if (players == null) {
|
||||
fail('Players should not be null');
|
||||
}
|
||||
|
||||
for (int i = 0; i < players.length; i++) {
|
||||
expect(players[i].id, testMatchOnlyPlayers.players![i].id);
|
||||
expect(players[i].name, testMatchOnlyPlayers.players![i].name);
|
||||
expect(
|
||||
players[i].createdAt,
|
||||
testMatchOnlyPlayers.players![i].createdAt,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
test('Updating the match players works coreclty', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
|
||||
final newPlayers = [testPlayer1, testPlayer2, testPlayer4];
|
||||
await database.playerDao.addPlayersAsList(players: newPlayers);
|
||||
|
||||
// First, remove all existing players
|
||||
final existingPlayers = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
|
||||
if (existingPlayers == null || existingPlayers.isEmpty) {
|
||||
fail('Existing players should not be null or empty');
|
||||
}
|
||||
|
||||
await database.playerMatchDao.updatePlayersFromMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
newPlayer: newPlayers,
|
||||
);
|
||||
|
||||
final updatedPlayers = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
|
||||
if (updatedPlayers == null) {
|
||||
fail('Updated players should not be null');
|
||||
}
|
||||
|
||||
expect(updatedPlayers.length, newPlayers.length);
|
||||
|
||||
/// Create a map of new players for easy lookup
|
||||
final testPlayers = {for (var p in newPlayers) p.id: p};
|
||||
|
||||
/// Verify each updated player matches the new players
|
||||
for (final player in updatedPlayers) {
|
||||
final testPlayer = testPlayers[player.id]!;
|
||||
|
||||
expect(player.id, testPlayer.id);
|
||||
expect(player.name, testPlayer.name);
|
||||
expect(player.createdAt, testPlayer.createdAt);
|
||||
}
|
||||
});
|
||||
|
||||
test(
|
||||
'Adding the same player to seperate matches works correctly',
|
||||
() async {
|
||||
final playersList = [testPlayer1, testPlayer2, testPlayer3];
|
||||
final match1 = Match(name: 'Match 1', players: playersList);
|
||||
final match2 = Match(name: 'Match 2', players: playersList);
|
||||
|
||||
await Future.wait([
|
||||
database.matchDao.addMatch(match: match1),
|
||||
database.matchDao.addMatch(match: match2),
|
||||
]);
|
||||
|
||||
final players1 = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: match1.id,
|
||||
);
|
||||
final players2 = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: match2.id,
|
||||
);
|
||||
|
||||
expect(players1, isNotNull);
|
||||
expect(players2, isNotNull);
|
||||
|
||||
expect(
|
||||
players1!.map((p) => p.id).toList(),
|
||||
equals(players2!.map((p) => p.id).toList()),
|
||||
);
|
||||
expect(
|
||||
players1.map((p) => p.name).toList(),
|
||||
equals(players2.map((p) => p.name).toList()),
|
||||
);
|
||||
expect(
|
||||
players1.map((p) => p.createdAt).toList(),
|
||||
equals(players2.map((p) => p.createdAt).toList()),
|
||||
);
|
||||
},
|
||||
);
|
||||
});
|
||||
}
|
||||
159
test/db_tests/player_test.dart
Normal file
159
test/db_tests/player_test.dart
Normal file
@@ -0,0 +1,159 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/dto/player.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Player testPlayer4;
|
||||
final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
// Recommended for widget tests to avoid test errors.
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Test Player');
|
||||
testPlayer2 = Player(name: 'Second Player');
|
||||
testPlayer3 = Player(name: 'Charlie');
|
||||
testPlayer4 = Player(name: 'Diana');
|
||||
});
|
||||
});
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
|
||||
group('Player Tests', () {
|
||||
test('Adding and fetching single player works correctly', () async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.playerDao.addPlayer(player: testPlayer2);
|
||||
|
||||
final allPlayers = await database.playerDao.getAllPlayers();
|
||||
expect(allPlayers.length, 2);
|
||||
|
||||
final fetchedPlayer1 = allPlayers.firstWhere(
|
||||
(g) => g.id == testPlayer1.id,
|
||||
);
|
||||
expect(fetchedPlayer1.name, testPlayer1.name);
|
||||
expect(fetchedPlayer1.createdAt, testPlayer1.createdAt);
|
||||
|
||||
final fetchedPlayer2 = allPlayers.firstWhere(
|
||||
(g) => g.id == testPlayer2.id,
|
||||
);
|
||||
expect(fetchedPlayer2.name, testPlayer2.name);
|
||||
expect(fetchedPlayer2.createdAt, testPlayer2.createdAt);
|
||||
});
|
||||
|
||||
test('Adding and fetching multiple players works correctly', () async {
|
||||
await database.playerDao.addPlayersAsList(
|
||||
players: [testPlayer1, testPlayer2, testPlayer3, testPlayer4],
|
||||
);
|
||||
|
||||
final allPlayers = await database.playerDao.getAllPlayers();
|
||||
expect(allPlayers.length, 4);
|
||||
|
||||
// Map for connencting fetched players with expected players
|
||||
final testPlayers = {
|
||||
testPlayer1.id: testPlayer1,
|
||||
testPlayer2.id: testPlayer2,
|
||||
testPlayer3.id: testPlayer3,
|
||||
testPlayer4.id: testPlayer4,
|
||||
};
|
||||
|
||||
for (final player in allPlayers) {
|
||||
final testPlayer = testPlayers[player.id]!;
|
||||
|
||||
expect(player.id, testPlayer.id);
|
||||
expect(player.name, testPlayer.name);
|
||||
expect(player.createdAt, testPlayer.createdAt);
|
||||
}
|
||||
});
|
||||
|
||||
test('Adding the same player twice does not create duplicates', () async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
final allPlayers = await database.playerDao.getAllPlayers();
|
||||
expect(allPlayers.length, 1);
|
||||
});
|
||||
|
||||
test('Player existence check works correctly', () async {
|
||||
var playerExists = await database.playerDao.playerExists(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(playerExists, false);
|
||||
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
playerExists = await database.playerDao.playerExists(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(playerExists, true);
|
||||
});
|
||||
|
||||
test('Deleting a player works correctly', () async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
final playerDeleted = await database.playerDao.deletePlayer(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(playerDeleted, true);
|
||||
|
||||
final playerExists = await database.playerDao.playerExists(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(playerExists, false);
|
||||
});
|
||||
|
||||
test('Updating a player name works correcly', () async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
const newPlayerName = 'new player name';
|
||||
|
||||
await database.playerDao.updatePlayername(
|
||||
playerId: testPlayer1.id,
|
||||
newName: newPlayerName,
|
||||
);
|
||||
|
||||
final result = await database.playerDao.getPlayerById(
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(result.name, newPlayerName);
|
||||
});
|
||||
|
||||
test('Getting the player count works correctly', () async {
|
||||
var playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 0);
|
||||
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 1);
|
||||
|
||||
await database.playerDao.addPlayer(player: testPlayer2);
|
||||
|
||||
playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 2);
|
||||
|
||||
await database.playerDao.deletePlayer(playerId: testPlayer1.id);
|
||||
|
||||
playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 1);
|
||||
|
||||
await database.playerDao.deletePlayer(playerId: testPlayer2.id);
|
||||
|
||||
playerCount = await database.playerDao.getPlayerCount();
|
||||
expect(playerCount, 0);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -1,376 +0,0 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Player testPlayer4;
|
||||
late Group testGroup;
|
||||
final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
// Recommended for widget tests to avoid test errors.
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Alice', description: '');
|
||||
testPlayer2 = Player(name: 'Bob', description: '');
|
||||
testPlayer3 = Player(name: 'Charlie', description: '');
|
||||
testPlayer4 = Player(name: 'Diana', description: '');
|
||||
testGroup = Group(
|
||||
name: 'Test Group',
|
||||
description: '',
|
||||
members: [testPlayer1, testPlayer2, testPlayer3],
|
||||
);
|
||||
});
|
||||
});
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
|
||||
group('Player-Group Tests', () {
|
||||
// Verifies that a player can be added to an existing group and isPlayerInGroup returns true.
|
||||
test('Adding a player to a group works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
await database.playerDao.addPlayer(player: testPlayer4);
|
||||
await database.playerGroupDao.addPlayerToGroup(
|
||||
groupId: testGroup.id,
|
||||
player: testPlayer4,
|
||||
);
|
||||
|
||||
var playerAdded = await database.playerGroupDao.isPlayerInGroup(
|
||||
groupId: testGroup.id,
|
||||
playerId: testPlayer4.id,
|
||||
);
|
||||
|
||||
expect(playerAdded, true);
|
||||
|
||||
playerAdded = await database.playerGroupDao.isPlayerInGroup(
|
||||
groupId: testGroup.id,
|
||||
playerId: '',
|
||||
);
|
||||
|
||||
expect(playerAdded, false);
|
||||
});
|
||||
|
||||
// Verifies that a player can be removed from a group and the group's member count decreases.
|
||||
test('Removing player from group works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
|
||||
final playerToRemove = testGroup.members[0];
|
||||
|
||||
final removed = await database.playerGroupDao.removePlayerFromGroup(
|
||||
playerId: playerToRemove.id,
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
expect(removed, true);
|
||||
|
||||
final result = await database.groupDao.getGroupById(
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
expect(result.members.length, testGroup.members.length - 1);
|
||||
|
||||
final playerExists = result.members.any((p) => p.id == playerToRemove.id);
|
||||
expect(playerExists, false);
|
||||
});
|
||||
|
||||
// Verifies that getPlayersOfGroup returns all members of a group with correct data.
|
||||
test('Retrieving players of a group works correctly', () async {
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
final players = await database.playerGroupDao.getPlayersOfGroup(
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
|
||||
for (int i = 0; i < players.length; i++) {
|
||||
expect(players[i].id, testGroup.members[i].id);
|
||||
expect(players[i].name, testGroup.members[i].name);
|
||||
expect(players[i].createdAt, testGroup.members[i].createdAt);
|
||||
}
|
||||
});
|
||||
|
||||
// Verifies that isPlayerInGroup returns false for non-existent player.
|
||||
test('isPlayerInGroup returns false for non-existent player', () async {
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
|
||||
final result = await database.playerGroupDao.isPlayerInGroup(
|
||||
playerId: 'non-existent-player-id',
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
|
||||
expect(result, false);
|
||||
});
|
||||
|
||||
// Verifies that isPlayerInGroup returns false for non-existent group.
|
||||
test('isPlayerInGroup returns false for non-existent group', () async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
final result = await database.playerGroupDao.isPlayerInGroup(
|
||||
playerId: testPlayer1.id,
|
||||
groupId: 'non-existent-group-id',
|
||||
);
|
||||
|
||||
expect(result, false);
|
||||
});
|
||||
|
||||
// Verifies that addPlayerToGroup returns false when player already in group.
|
||||
test(
|
||||
'addPlayerToGroup returns false when player already in group',
|
||||
() async {
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
|
||||
// testPlayer1 is already in testGroup via group creation
|
||||
final result = await database.playerGroupDao.addPlayerToGroup(
|
||||
player: testPlayer1,
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
|
||||
expect(result, false);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that addPlayerToGroup adds player to player table if not exists.
|
||||
test(
|
||||
'addPlayerToGroup adds player to player table if not exists',
|
||||
() async {
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
|
||||
// testPlayer4 is not in the database yet
|
||||
var playerExists = await database.playerDao.playerExists(
|
||||
playerId: testPlayer4.id,
|
||||
);
|
||||
expect(playerExists, false);
|
||||
|
||||
await database.playerGroupDao.addPlayerToGroup(
|
||||
player: testPlayer4,
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
|
||||
// Now player should exist in player table
|
||||
playerExists = await database.playerDao.playerExists(
|
||||
playerId: testPlayer4.id,
|
||||
);
|
||||
expect(playerExists, true);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that removePlayerFromGroup returns false for non-existent player.
|
||||
test(
|
||||
'removePlayerFromGroup returns false for non-existent player',
|
||||
() async {
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
|
||||
final result = await database.playerGroupDao.removePlayerFromGroup(
|
||||
playerId: 'non-existent-player-id',
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
|
||||
expect(result, false);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that removePlayerFromGroup returns false for non-existent group.
|
||||
test(
|
||||
'removePlayerFromGroup returns false for non-existent group',
|
||||
() async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
final result = await database.playerGroupDao.removePlayerFromGroup(
|
||||
playerId: testPlayer1.id,
|
||||
groupId: 'non-existent-group-id',
|
||||
);
|
||||
|
||||
expect(result, false);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that getPlayersOfGroup returns empty list for group with no members.
|
||||
test('getPlayersOfGroup returns empty list for empty group', () async {
|
||||
final emptyGroup = Group(
|
||||
name: 'Empty Group',
|
||||
description: '',
|
||||
members: [],
|
||||
);
|
||||
await database.groupDao.addGroup(group: emptyGroup);
|
||||
|
||||
final players = await database.playerGroupDao.getPlayersOfGroup(
|
||||
groupId: emptyGroup.id,
|
||||
);
|
||||
|
||||
expect(players, isEmpty);
|
||||
});
|
||||
|
||||
// Verifies that getPlayersOfGroup returns empty list for non-existent group.
|
||||
test(
|
||||
'getPlayersOfGroup returns empty list for non-existent group',
|
||||
() async {
|
||||
final players = await database.playerGroupDao.getPlayersOfGroup(
|
||||
groupId: 'non-existent-group-id',
|
||||
);
|
||||
|
||||
expect(players, isEmpty);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that removing all players from a group leaves the group empty.
|
||||
test('Removing all players from a group leaves group empty', () async {
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
|
||||
for (final player in testGroup.members) {
|
||||
await database.playerGroupDao.removePlayerFromGroup(
|
||||
playerId: player.id,
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
}
|
||||
|
||||
final players = await database.playerGroupDao.getPlayersOfGroup(
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
expect(players, isEmpty);
|
||||
|
||||
// Group should still exist
|
||||
final groupExists = await database.groupDao.groupExists(
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
expect(groupExists, true);
|
||||
});
|
||||
|
||||
// Verifies that a player can be in multiple groups.
|
||||
test('Player can be in multiple groups', () async {
|
||||
final secondGroup = Group(
|
||||
name: 'Second Group',
|
||||
description: '',
|
||||
members: [],
|
||||
);
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
await database.groupDao.addGroup(group: secondGroup);
|
||||
|
||||
// Add testPlayer1 to second group (already in testGroup)
|
||||
await database.playerGroupDao.addPlayerToGroup(
|
||||
player: testPlayer1,
|
||||
groupId: secondGroup.id,
|
||||
);
|
||||
|
||||
final inFirstGroup = await database.playerGroupDao.isPlayerInGroup(
|
||||
playerId: testPlayer1.id,
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
final inSecondGroup = await database.playerGroupDao.isPlayerInGroup(
|
||||
playerId: testPlayer1.id,
|
||||
groupId: secondGroup.id,
|
||||
);
|
||||
|
||||
expect(inFirstGroup, true);
|
||||
expect(inSecondGroup, true);
|
||||
});
|
||||
|
||||
// Verifies that removing player from one group doesn't affect other groups.
|
||||
test(
|
||||
'Removing player from one group does not affect other groups',
|
||||
() async {
|
||||
final secondGroup = Group(
|
||||
name: 'Second Group',
|
||||
description: '',
|
||||
members: [testPlayer1],
|
||||
);
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
await database.groupDao.addGroup(group: secondGroup);
|
||||
|
||||
// Remove testPlayer1 from testGroup
|
||||
await database.playerGroupDao.removePlayerFromGroup(
|
||||
playerId: testPlayer1.id,
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
|
||||
final inFirstGroup = await database.playerGroupDao.isPlayerInGroup(
|
||||
playerId: testPlayer1.id,
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
final inSecondGroup = await database.playerGroupDao.isPlayerInGroup(
|
||||
playerId: testPlayer1.id,
|
||||
groupId: secondGroup.id,
|
||||
);
|
||||
|
||||
expect(inFirstGroup, false);
|
||||
expect(inSecondGroup, true);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that addPlayerToGroup returns true on successful addition.
|
||||
test('addPlayerToGroup returns true on successful addition', () async {
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
await database.playerDao.addPlayer(player: testPlayer4);
|
||||
|
||||
final result = await database.playerGroupDao.addPlayerToGroup(
|
||||
player: testPlayer4,
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
|
||||
expect(result, true);
|
||||
});
|
||||
|
||||
// Verifies that removing the same player twice returns false on second attempt.
|
||||
test(
|
||||
'Removing same player twice returns false on second attempt',
|
||||
() async {
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
|
||||
final firstRemoval = await database.playerGroupDao
|
||||
.removePlayerFromGroup(
|
||||
playerId: testPlayer1.id,
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
expect(firstRemoval, true);
|
||||
|
||||
final secondRemoval = await database.playerGroupDao
|
||||
.removePlayerFromGroup(
|
||||
playerId: testPlayer1.id,
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
expect(secondRemoval, false);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that replaceGroupPlayers removes all existing players and replaces with new list.
|
||||
test('replaceGroupPlayers replaces all group members correctly', () async {
|
||||
// Create initial group with 3 players
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
|
||||
// Verify initial members
|
||||
var groupMembers = await database.groupDao.getGroupById(
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
expect(groupMembers.members.length, 3);
|
||||
|
||||
// Replace with new list containing 2 different players
|
||||
final newPlayersList = [testPlayer3, testPlayer4];
|
||||
await database.groupDao.replaceGroupPlayers(
|
||||
groupId: testGroup.id,
|
||||
newPlayers: newPlayersList,
|
||||
);
|
||||
|
||||
// Get updated group and verify members
|
||||
groupMembers = await database.groupDao.getGroupById(
|
||||
groupId: testGroup.id,
|
||||
);
|
||||
|
||||
expect(groupMembers.members.length, 2);
|
||||
expect(groupMembers.members.any((p) => p.id == testPlayer3.id), true);
|
||||
expect(groupMembers.members.any((p) => p.id == testPlayer4.id), true);
|
||||
expect(groupMembers.members.any((p) => p.id == testPlayer1.id), false);
|
||||
expect(groupMembers.members.any((p) => p.id == testPlayer2.id), false);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -1,694 +0,0 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart' hide isNotNull, isNull;
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/models/team.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Player testPlayer4;
|
||||
late Player testPlayer5;
|
||||
late Player testPlayer6;
|
||||
late Group testGroup;
|
||||
late Game testGame;
|
||||
late Match testMatchOnlyGroup;
|
||||
late Match testMatchOnlyPlayers;
|
||||
late Team testTeam1;
|
||||
late Team testTeam2;
|
||||
final fixedDate = DateTime(2025, 11, 19, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() async {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
// Recommended for widget tests to avoid test errors.
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Alice', description: '');
|
||||
testPlayer2 = Player(name: 'Bob', description: '');
|
||||
testPlayer3 = Player(name: 'Charlie', description: '');
|
||||
testPlayer4 = Player(name: 'Diana', description: '');
|
||||
testPlayer5 = Player(name: 'Eve', description: '');
|
||||
testPlayer6 = Player(name: 'Frank', description: '');
|
||||
testGroup = Group(
|
||||
name: 'Test Group',
|
||||
description: '',
|
||||
members: [testPlayer1, testPlayer2, testPlayer3],
|
||||
);
|
||||
testGame = Game(
|
||||
name: 'Test Game',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
description: 'A test game',
|
||||
color: GameColor.blue,
|
||||
icon: '',
|
||||
);
|
||||
testMatchOnlyGroup = Match(
|
||||
name: 'Test Match with Group',
|
||||
game: testGame,
|
||||
group: testGroup,
|
||||
notes: '',
|
||||
);
|
||||
testMatchOnlyPlayers = Match(
|
||||
name: 'Test Match with Players',
|
||||
game: testGame,
|
||||
players: [testPlayer4, testPlayer5, testPlayer6],
|
||||
notes: '',
|
||||
);
|
||||
testTeam1 = Team(name: 'Team Alpha', members: [testPlayer1, testPlayer2]);
|
||||
testTeam2 = Team(name: 'Team Beta', members: [testPlayer3, testPlayer4]);
|
||||
});
|
||||
await database.playerDao.addPlayersAsList(
|
||||
players: [
|
||||
testPlayer1,
|
||||
testPlayer2,
|
||||
testPlayer3,
|
||||
testPlayer4,
|
||||
testPlayer5,
|
||||
testPlayer6,
|
||||
],
|
||||
);
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
});
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
|
||||
group('Player-Match Tests', () {
|
||||
test('Match has player works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
var matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
);
|
||||
|
||||
expect(matchHasPlayers, false);
|
||||
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
|
||||
matchHasPlayers = await database.playerMatchDao.matchHasPlayers(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
);
|
||||
|
||||
expect(matchHasPlayers, true);
|
||||
});
|
||||
|
||||
test('Adding a player to a match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
await database.playerDao.addPlayer(player: testPlayer5);
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer5.id,
|
||||
);
|
||||
|
||||
var playerAdded = await database.playerMatchDao.isPlayerInMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer5.id,
|
||||
);
|
||||
|
||||
expect(playerAdded, true);
|
||||
|
||||
playerAdded = await database.playerMatchDao.isPlayerInMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: '',
|
||||
);
|
||||
|
||||
expect(playerAdded, false);
|
||||
});
|
||||
|
||||
test('Removing player from match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
|
||||
final playerToRemove = testMatchOnlyPlayers.players[0];
|
||||
|
||||
final removed = await database.playerMatchDao.removePlayerFromMatch(
|
||||
playerId: playerToRemove.id,
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
expect(removed, true);
|
||||
|
||||
final result = await database.matchDao.getMatchById(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
expect(result.players.length, testMatchOnlyPlayers.players.length - 1);
|
||||
|
||||
final playerExists = result.players.any((p) => p.id == playerToRemove.id);
|
||||
expect(playerExists, false);
|
||||
});
|
||||
|
||||
test('Retrieving players of a match works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
final players =
|
||||
await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
) ??
|
||||
[];
|
||||
|
||||
for (int i = 0; i < players.length; i++) {
|
||||
expect(players[i].id, testMatchOnlyPlayers.players[i].id);
|
||||
expect(players[i].name, testMatchOnlyPlayers.players[i].name);
|
||||
expect(players[i].createdAt, testMatchOnlyPlayers.players[i].createdAt);
|
||||
}
|
||||
});
|
||||
|
||||
test('Updating the match players works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
|
||||
final newPlayers = [testPlayer1, testPlayer2, testPlayer4];
|
||||
await database.playerDao.addPlayersAsList(players: newPlayers);
|
||||
|
||||
// First, remove all existing players
|
||||
final existingPlayers = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
|
||||
if (existingPlayers == null || existingPlayers.isEmpty) {
|
||||
fail('Existing players should not be null or empty');
|
||||
}
|
||||
|
||||
await database.playerMatchDao.updatePlayersFromMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
newPlayer: newPlayers,
|
||||
);
|
||||
|
||||
final updatedPlayers = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
|
||||
if (updatedPlayers == null) {
|
||||
fail('Updated players should not be null');
|
||||
}
|
||||
|
||||
expect(updatedPlayers.length, newPlayers.length);
|
||||
|
||||
/// Create a map of new players for easy lookup
|
||||
final testPlayers = {for (var p in newPlayers) p.id: p};
|
||||
|
||||
/// Verify each updated player matches the new players
|
||||
for (final player in updatedPlayers) {
|
||||
final testPlayer = testPlayers[player.id]!;
|
||||
|
||||
expect(player.id, testPlayer.id);
|
||||
expect(player.name, testPlayer.name);
|
||||
expect(player.createdAt, testPlayer.createdAt);
|
||||
}
|
||||
});
|
||||
|
||||
test(
|
||||
'Adding the same player to separate matches works correctly',
|
||||
() async {
|
||||
final playersList = [testPlayer1, testPlayer2, testPlayer3];
|
||||
final match1 = Match(
|
||||
name: 'Match 1',
|
||||
game: testGame,
|
||||
players: playersList,
|
||||
notes: '',
|
||||
);
|
||||
final match2 = Match(
|
||||
name: 'Match 2',
|
||||
game: testGame,
|
||||
players: playersList,
|
||||
notes: '',
|
||||
);
|
||||
|
||||
await Future.wait([
|
||||
database.matchDao.addMatch(match: match1),
|
||||
database.matchDao.addMatch(match: match2),
|
||||
]);
|
||||
|
||||
final players1 = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: match1.id,
|
||||
);
|
||||
final players2 = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: match2.id,
|
||||
);
|
||||
|
||||
expect(players1, isNotNull);
|
||||
expect(players2, isNotNull);
|
||||
|
||||
expect(
|
||||
players1!.map((p) => p.id).toList(),
|
||||
equals(players2!.map((p) => p.id).toList()),
|
||||
);
|
||||
expect(
|
||||
players1.map((p) => p.name).toList(),
|
||||
equals(players2.map((p) => p.name).toList()),
|
||||
);
|
||||
expect(
|
||||
players1.map((p) => p.createdAt).toList(),
|
||||
equals(players2.map((p) => p.createdAt).toList()),
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that getPlayersOfMatch returns null for a non-existent match.
|
||||
test('getPlayersOfMatch returns null for non-existent match', () async {
|
||||
final players = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: 'non-existent-match-id',
|
||||
);
|
||||
|
||||
expect(players, isNull);
|
||||
});
|
||||
|
||||
test('Adding player with teamId works correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
final playersInTeam = await database.playerMatchDao.getPlayersInTeam(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(playersInTeam.length, 1);
|
||||
expect(playersInTeam[0].id, testPlayer1.id);
|
||||
});
|
||||
|
||||
test('updatePlayerTeam updates team correctly', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
await database.teamDao.addTeam(team: testTeam2);
|
||||
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
// Update player's team
|
||||
final updated = await database.playerMatchDao.updatePlayerTeam(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
teamId: testTeam2.id,
|
||||
);
|
||||
|
||||
expect(updated, true);
|
||||
|
||||
// Verify player is now in testTeam2
|
||||
final playersInTeam2 = await database.playerMatchDao.getPlayersInTeam(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
teamId: testTeam2.id,
|
||||
);
|
||||
|
||||
expect(playersInTeam2.length, 1);
|
||||
expect(playersInTeam2[0].id, testPlayer1.id);
|
||||
|
||||
// Verify player is no longer in testTeam1
|
||||
final playersInTeam1 = await database.playerMatchDao.getPlayersInTeam(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(playersInTeam1.isEmpty, true);
|
||||
});
|
||||
|
||||
test('updatePlayerTeam can remove player from team', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
// Remove player from team by setting teamId to null
|
||||
final updated = await database.playerMatchDao.updatePlayerTeam(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
teamId: null,
|
||||
);
|
||||
|
||||
expect(updated, true);
|
||||
|
||||
final playersInTeam = await database.playerMatchDao.getPlayersInTeam(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(playersInTeam.isEmpty, true);
|
||||
});
|
||||
|
||||
test(
|
||||
'updatePlayerTeam returns false for non-existent player-match',
|
||||
() async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
|
||||
final updated = await database.playerMatchDao.updatePlayerTeam(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: 'non-existent-player-id',
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(updated, false);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that getPlayersInTeam returns empty list for non-existent team.
|
||||
test('getPlayersInTeam returns empty list for non-existent team', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
|
||||
final players = await database.playerMatchDao.getPlayersInTeam(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
teamId: 'non-existent-team-id',
|
||||
);
|
||||
|
||||
expect(players.isEmpty, true);
|
||||
});
|
||||
|
||||
test('getPlayersInTeam returns all players of a team', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer2.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
final playersInTeam = await database.playerMatchDao.getPlayersInTeam(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(playersInTeam.length, 2);
|
||||
final playerIds = playersInTeam.map((p) => p.id).toSet();
|
||||
expect(playerIds.contains(testPlayer1.id), true);
|
||||
expect(playerIds.contains(testPlayer2.id), true);
|
||||
});
|
||||
|
||||
test(
|
||||
'removePlayerFromMatch returns false for non-existent player',
|
||||
() async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
|
||||
final removed = await database.playerMatchDao.removePlayerFromMatch(
|
||||
playerId: 'non-existent-player-id',
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
|
||||
expect(removed, false);
|
||||
},
|
||||
);
|
||||
|
||||
test('Adding same player twice to same match is ignored', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
|
||||
// Try to add the same player again with different score
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
|
||||
// Verify player count is still 1
|
||||
final players = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
);
|
||||
|
||||
expect(players?.length, 1);
|
||||
});
|
||||
|
||||
test(
|
||||
'updatePlayersFromMatch with empty list removes all players',
|
||||
() async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
|
||||
// Verify players exist initially
|
||||
var players = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
expect(players?.length, 3);
|
||||
|
||||
// Update with empty list
|
||||
await database.playerMatchDao.updatePlayersFromMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
newPlayer: [],
|
||||
);
|
||||
|
||||
// Verify all players are removed
|
||||
players = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
expect(players, isNull);
|
||||
},
|
||||
);
|
||||
|
||||
test('updatePlayersFromMatch with same players makes no changes', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
|
||||
final originalPlayers = [testPlayer4, testPlayer5, testPlayer6];
|
||||
|
||||
await database.playerMatchDao.updatePlayersFromMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
newPlayer: originalPlayers,
|
||||
);
|
||||
|
||||
final players = await database.playerMatchDao.getPlayersOfMatch(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
|
||||
expect(players?.length, originalPlayers.length);
|
||||
final playerIds = players!.map((p) => p.id).toSet();
|
||||
for (final originalPlayer in originalPlayers) {
|
||||
expect(playerIds.contains(originalPlayer.id), true);
|
||||
}
|
||||
});
|
||||
|
||||
test('matchHasPlayers returns false for non-existent match', () async {
|
||||
final hasPlayers = await database.playerMatchDao.matchHasPlayers(
|
||||
matchId: 'non-existent-match-id',
|
||||
);
|
||||
|
||||
expect(hasPlayers, false);
|
||||
});
|
||||
|
||||
test('isPlayerInMatch returns false for non-existent match', () async {
|
||||
final isInMatch = await database.playerMatchDao.isPlayerInMatch(
|
||||
matchId: 'non-existent-match-id',
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
|
||||
expect(isInMatch, false);
|
||||
});
|
||||
|
||||
// Verifies that getPlayersInTeam returns empty list for non-existent match.
|
||||
test(
|
||||
'getPlayersInTeam returns empty list for non-existent match',
|
||||
() async {
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
final players = await database.playerMatchDao.getPlayersInTeam(
|
||||
matchId: 'non-existent-match-id',
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(players.isEmpty, true);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that players in different teams within the same match are returned correctly.
|
||||
test('Players in different teams within same match are separate', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
await database.teamDao.addTeam(team: testTeam2);
|
||||
|
||||
// Add players to different teams
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer2.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer3.id,
|
||||
teamId: testTeam2.id,
|
||||
);
|
||||
|
||||
// Verify team 1 players
|
||||
final playersInTeam1 = await database.playerMatchDao.getPlayersInTeam(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
expect(playersInTeam1.length, 2);
|
||||
final team1Ids = playersInTeam1.map((p) => p.id).toSet();
|
||||
expect(team1Ids.contains(testPlayer1.id), true);
|
||||
expect(team1Ids.contains(testPlayer2.id), true);
|
||||
expect(team1Ids.contains(testPlayer3.id), false);
|
||||
|
||||
// Verify team 2 players
|
||||
final playersInTeam2 = await database.playerMatchDao.getPlayersInTeam(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
teamId: testTeam2.id,
|
||||
);
|
||||
expect(playersInTeam2.length, 1);
|
||||
expect(playersInTeam2[0].id, testPlayer3.id);
|
||||
});
|
||||
|
||||
// Verifies that removePlayerFromMatch does not affect other matches.
|
||||
test('removePlayerFromMatch does not affect other matches', () async {
|
||||
final playersList = [testPlayer1, testPlayer2];
|
||||
final match1 = Match(
|
||||
name: 'Match 1',
|
||||
game: testGame,
|
||||
players: playersList,
|
||||
notes: '',
|
||||
);
|
||||
final match2 = Match(
|
||||
name: 'Match 2',
|
||||
game: testGame,
|
||||
players: playersList,
|
||||
notes: '',
|
||||
);
|
||||
|
||||
await Future.wait([
|
||||
database.matchDao.addMatch(match: match1),
|
||||
database.matchDao.addMatch(match: match2),
|
||||
]);
|
||||
|
||||
// Remove player from match1
|
||||
final removed = await database.playerMatchDao.removePlayerFromMatch(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: match1.id,
|
||||
);
|
||||
expect(removed, true);
|
||||
|
||||
// Verify player is removed from match1
|
||||
final isInMatch1 = await database.playerMatchDao.isPlayerInMatch(
|
||||
matchId: match1.id,
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(isInMatch1, false);
|
||||
|
||||
// Verify player still exists in match2
|
||||
final isInMatch2 = await database.playerMatchDao.isPlayerInMatch(
|
||||
matchId: match2.id,
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
expect(isInMatch2, true);
|
||||
});
|
||||
|
||||
// Verifies that updatePlayersFromMatch on non-existent match fails with constraint error.
|
||||
test(
|
||||
'updatePlayersFromMatch on non-existent match fails with foreign key constraint',
|
||||
() async {
|
||||
// Should throw due to foreign key constraint - match doesn't exist
|
||||
await expectLater(
|
||||
database.playerMatchDao.updatePlayersFromMatch(
|
||||
matchId: 'non-existent-match-id',
|
||||
newPlayer: [testPlayer1, testPlayer2],
|
||||
),
|
||||
throwsA(anything),
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
// Verifies that a player can be in a match without being assigned to a team.
|
||||
test('Player can exist in match without team assignment', () async {
|
||||
await database.matchDao.addMatch(match: testMatchOnlyGroup);
|
||||
await database.teamDao.addTeam(team: testTeam1);
|
||||
|
||||
// Add player to match without team
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
|
||||
// Add another player to match with team
|
||||
await database.playerMatchDao.addPlayerToMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer2.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
// Verify both players are in the match
|
||||
final isPlayer1InMatch = await database.playerMatchDao.isPlayerInMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer1.id,
|
||||
);
|
||||
final isPlayer2InMatch = await database.playerMatchDao.isPlayerInMatch(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
playerId: testPlayer2.id,
|
||||
);
|
||||
|
||||
expect(isPlayer1InMatch, true);
|
||||
expect(isPlayer2InMatch, true);
|
||||
|
||||
// Verify only player2 is in the team
|
||||
final playersInTeam = await database.playerMatchDao.getPlayersInTeam(
|
||||
matchId: testMatchOnlyGroup.id,
|
||||
teamId: testTeam1.id,
|
||||
);
|
||||
|
||||
expect(playersInTeam.length, 1);
|
||||
expect(playersInTeam[0].id, testPlayer2.id);
|
||||
});
|
||||
|
||||
// Verifies that replaceMatchPlayers removes all existing players and replaces with new list.
|
||||
test('replaceMatchPlayers replaces all match players correctly', () async {
|
||||
// Create initial match with 3 players
|
||||
await database.matchDao.addMatch(match: testMatchOnlyPlayers);
|
||||
|
||||
// Verify initial players
|
||||
var matchPlayers = await database.matchDao.getMatchById(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
expect(matchPlayers.players.length, 3);
|
||||
|
||||
// Replace with new list containing 2 different players
|
||||
final newPlayersList = [testPlayer1, testPlayer2];
|
||||
await database.matchDao.replaceMatchPlayers(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
newPlayers: newPlayersList,
|
||||
);
|
||||
|
||||
// Get updated match and verify players
|
||||
matchPlayers = await database.matchDao.getMatchById(
|
||||
matchId: testMatchOnlyPlayers.id,
|
||||
);
|
||||
|
||||
expect(matchPlayers.players.length, 2);
|
||||
expect(matchPlayers.players.any((p) => p.id == testPlayer1.id), true);
|
||||
expect(matchPlayers.players.any((p) => p.id == testPlayer2.id), true);
|
||||
expect(matchPlayers.players.any((p) => p.id == testPlayer4.id), false);
|
||||
expect(matchPlayers.players.any((p) => p.id == testPlayer5.id), false);
|
||||
expect(matchPlayers.players.any((p) => p.id == testPlayer6.id), false);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -1,730 +0,0 @@
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart' hide isNull, isNotNull;
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/models/score_entry.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Game testGame;
|
||||
late Match testMatch1;
|
||||
late Match testMatch2;
|
||||
final fixedDate = DateTime(2025, 11, 19, 00, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() async {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
// Recommended for widget tests to avoid test errors.
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Alice', description: '');
|
||||
testPlayer2 = Player(name: 'Bob', description: '');
|
||||
testPlayer3 = Player(name: 'Charlie', description: '');
|
||||
testGame = Game(
|
||||
name: 'Test Game',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
description: 'A test game',
|
||||
color: GameColor.blue,
|
||||
icon: '',
|
||||
);
|
||||
testMatch1 = Match(
|
||||
name: 'Test Match 1',
|
||||
game: testGame,
|
||||
players: [testPlayer1, testPlayer2],
|
||||
notes: '',
|
||||
);
|
||||
testMatch2 = Match(
|
||||
name: 'Test Match 2',
|
||||
game: testGame,
|
||||
players: [testPlayer2, testPlayer3],
|
||||
notes: '',
|
||||
);
|
||||
});
|
||||
|
||||
await database.playerDao.addPlayersAsList(
|
||||
players: [testPlayer1, testPlayer2, testPlayer3],
|
||||
);
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
await database.matchDao.addMatch(match: testMatch1);
|
||||
await database.matchDao.addMatch(match: testMatch2);
|
||||
});
|
||||
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
|
||||
group('Score Tests', () {
|
||||
group('Adding and Fetching scores', () {
|
||||
test('Single Score', () async {
|
||||
ScoreEntry entry = ScoreEntry(roundNumber: 1, score: 10, change: 10);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: entry,
|
||||
);
|
||||
|
||||
final score = await database.scoreEntryDao.getScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
roundNumber: 1,
|
||||
);
|
||||
|
||||
expect(score, isNotNull);
|
||||
expect(score!.roundNumber, 1);
|
||||
expect(score.score, 10);
|
||||
expect(score.change, 10);
|
||||
});
|
||||
|
||||
test('Multiple Scores', () async {
|
||||
final entryList = [
|
||||
ScoreEntry(roundNumber: 1, score: 5, change: 5),
|
||||
ScoreEntry(roundNumber: 2, score: 12, change: 7),
|
||||
ScoreEntry(roundNumber: 3, score: 18, change: 6),
|
||||
];
|
||||
|
||||
await database.scoreEntryDao.addScoresAsList(
|
||||
entrys: entryList,
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
final scores = await database.scoreEntryDao.getAllPlayerScoresInMatch(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
expect(scores, isNotNull);
|
||||
|
||||
// Scores should be returned in order of round number
|
||||
for (int i = 0; i < entryList.length; i++) {
|
||||
expect(scores[i].roundNumber, entryList[i].roundNumber);
|
||||
expect(scores[i].score, entryList[i].score);
|
||||
expect(scores[i].change, entryList[i].change);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
group('Undesirable values', () {
|
||||
test('Score & Round can have negative values', () async {
|
||||
ScoreEntry entry = ScoreEntry(roundNumber: -2, score: -10, change: -10);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: entry,
|
||||
);
|
||||
|
||||
final score = await database.scoreEntryDao.getScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
roundNumber: -2,
|
||||
);
|
||||
|
||||
expect(score, isNotNull);
|
||||
expect(score!.roundNumber, -2);
|
||||
expect(score.score, -10);
|
||||
expect(score.change, -10);
|
||||
});
|
||||
|
||||
test('Score & Round can have zero values', () async {
|
||||
ScoreEntry entry = ScoreEntry(roundNumber: 0, score: 0, change: 0);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: entry,
|
||||
);
|
||||
|
||||
final score = await database.scoreEntryDao.getScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
roundNumber: 0,
|
||||
);
|
||||
|
||||
expect(score, isNotNull);
|
||||
expect(score!.score, 0);
|
||||
expect(score.change, 0);
|
||||
});
|
||||
|
||||
test('Getting score for a non-existent entities returns null', () async {
|
||||
var score = await database.scoreEntryDao.getScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
roundNumber: -1,
|
||||
);
|
||||
|
||||
expect(score, isNull);
|
||||
|
||||
score = await database.scoreEntryDao.getScore(
|
||||
playerId: 'non-existin-player',
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
expect(score, isNull);
|
||||
|
||||
score = await database.scoreEntryDao.getScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: 'non-existing-match',
|
||||
);
|
||||
|
||||
expect(score, isNull);
|
||||
});
|
||||
|
||||
test('Getting score for a non-match player returns null', () async {
|
||||
ScoreEntry entry = ScoreEntry(roundNumber: 1, score: 10, change: 10);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: entry,
|
||||
);
|
||||
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer3.id,
|
||||
matchId: testMatch2.id,
|
||||
entry: entry,
|
||||
);
|
||||
|
||||
var score = await database.scoreEntryDao.getScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch2.id,
|
||||
roundNumber: 1,
|
||||
);
|
||||
|
||||
expect(score, isNull);
|
||||
});
|
||||
});
|
||||
|
||||
group('Scores in matches', () {
|
||||
test('getAllMatchScores()', () async {
|
||||
ScoreEntry entry1 = ScoreEntry(roundNumber: 1, score: 10, change: 10);
|
||||
ScoreEntry entry2 = ScoreEntry(roundNumber: 1, score: 20, change: 20);
|
||||
ScoreEntry entry3 = ScoreEntry(roundNumber: 2, score: 25, change: 15);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: entry1,
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer2.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: entry2,
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: entry3,
|
||||
);
|
||||
|
||||
final scores = await database.scoreEntryDao.getAllMatchScores(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
expect(scores.length, 2);
|
||||
expect(scores[testPlayer1.id]!.length, 2);
|
||||
expect(scores[testPlayer2.id]!.length, 1);
|
||||
});
|
||||
|
||||
test('getAllMatchScores() with no scores saved', () async {
|
||||
final scores = await database.scoreEntryDao.getAllMatchScores(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
expect(scores.isEmpty, true);
|
||||
});
|
||||
|
||||
test('getAllPlayerScoresInMatch()', () async {
|
||||
ScoreEntry entry1 = ScoreEntry(roundNumber: 1, score: 10, change: 10);
|
||||
ScoreEntry entry2 = ScoreEntry(roundNumber: 2, score: 25, change: 15);
|
||||
ScoreEntry entry3 = ScoreEntry(roundNumber: 1, score: 30, change: 30);
|
||||
await database.scoreEntryDao.addScoresAsList(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entrys: [entry1, entry2],
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer2.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: entry3,
|
||||
);
|
||||
|
||||
final playerScores = await database.scoreEntryDao
|
||||
.getAllPlayerScoresInMatch(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
expect(playerScores.length, 2);
|
||||
expect(playerScores[0].roundNumber, 1);
|
||||
expect(playerScores[1].roundNumber, 2);
|
||||
expect(playerScores[0].score, 10);
|
||||
expect(playerScores[1].score, 25);
|
||||
expect(playerScores[0].change, 10);
|
||||
expect(playerScores[1].change, 15);
|
||||
});
|
||||
|
||||
test('getAllPlayerScoresInMatch() with no scores saved', () async {
|
||||
final playerScores = await database.scoreEntryDao
|
||||
.getAllPlayerScoresInMatch(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
expect(playerScores.isEmpty, true);
|
||||
});
|
||||
|
||||
test('Scores are isolated across different matches', () async {
|
||||
ScoreEntry entry1 = ScoreEntry(roundNumber: 1, score: 10, change: 10);
|
||||
ScoreEntry entry2 = ScoreEntry(roundNumber: 1, score: 50, change: 50);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: entry1,
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch2.id,
|
||||
entry: entry2,
|
||||
);
|
||||
|
||||
final match1Scores = await database.scoreEntryDao
|
||||
.getAllPlayerScoresInMatch(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
expect(match1Scores.length, 1);
|
||||
expect(match1Scores[0].score, 10);
|
||||
expect(match1Scores[0].change, 10);
|
||||
|
||||
final match2Scores = await database.scoreEntryDao
|
||||
.getAllPlayerScoresInMatch(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch2.id,
|
||||
);
|
||||
|
||||
expect(match2Scores.length, 1);
|
||||
expect(match2Scores[0].score, 50);
|
||||
expect(match2Scores[0].change, 50);
|
||||
});
|
||||
});
|
||||
|
||||
group('Updating scores', () {
|
||||
test('updateScore()', () async {
|
||||
ScoreEntry entry1 = ScoreEntry(roundNumber: 1, score: 10, change: 10);
|
||||
ScoreEntry entry2 = ScoreEntry(roundNumber: 2, score: 15, change: 5);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: entry1,
|
||||
);
|
||||
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: entry2,
|
||||
);
|
||||
|
||||
final updated = await database.scoreEntryDao.updateScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
newEntry: ScoreEntry(roundNumber: 2, score: 50, change: 40),
|
||||
);
|
||||
|
||||
expect(updated, true);
|
||||
|
||||
final score = await database.scoreEntryDao.getScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
roundNumber: 2,
|
||||
);
|
||||
|
||||
expect(score, isNotNull);
|
||||
expect(score!.score, 50);
|
||||
expect(score.change, 40);
|
||||
});
|
||||
|
||||
test('Updating a non-existent score returns false', () async {
|
||||
final updated = await database.scoreEntryDao.updateScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
newEntry: ScoreEntry(roundNumber: 1, score: 20, change: 20),
|
||||
);
|
||||
|
||||
expect(updated, false);
|
||||
});
|
||||
});
|
||||
|
||||
group('Deleting scores', () {
|
||||
test('deleteScore() ', () async {
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
|
||||
);
|
||||
|
||||
final deleted = await database.scoreEntryDao.deleteScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
roundNumber: 1,
|
||||
);
|
||||
|
||||
expect(deleted, true);
|
||||
|
||||
final score = await database.scoreEntryDao.getScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
roundNumber: 1,
|
||||
);
|
||||
|
||||
expect(score, isNull);
|
||||
});
|
||||
|
||||
test('Deleting a non-existent score returns false', () async {
|
||||
final deleted = await database.scoreEntryDao.deleteScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
roundNumber: 1,
|
||||
);
|
||||
|
||||
expect(deleted, false);
|
||||
});
|
||||
|
||||
test('deleteAllScoresForMatch() works correctly', () async {
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer2.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 20, change: 20),
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch2.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 15, change: 15),
|
||||
);
|
||||
|
||||
final deleted = await database.scoreEntryDao.deleteAllScoresForMatch(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
expect(deleted, true);
|
||||
|
||||
final match1Scores = await database.scoreEntryDao.getAllMatchScores(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(match1Scores.length, 0);
|
||||
|
||||
final match2Scores = await database.scoreEntryDao.getAllMatchScores(
|
||||
matchId: testMatch2.id,
|
||||
);
|
||||
expect(match2Scores.length, 1);
|
||||
});
|
||||
|
||||
test('deleteAllScoresForPlayerInMatch() works correctly', () async {
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
|
||||
);
|
||||
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 2, score: 15, change: 5),
|
||||
);
|
||||
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer2.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 6, change: 6),
|
||||
);
|
||||
|
||||
final deleted = await database.scoreEntryDao
|
||||
.deleteAllScoresForPlayerInMatch(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
expect(deleted, true);
|
||||
|
||||
final player1Scores = await database.scoreEntryDao
|
||||
.getAllPlayerScoresInMatch(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(player1Scores.length, 0);
|
||||
|
||||
final player2Scores = await database.scoreEntryDao
|
||||
.getAllPlayerScoresInMatch(
|
||||
playerId: testPlayer2.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(player2Scores.length, 1);
|
||||
});
|
||||
});
|
||||
|
||||
group('Score Aggregations & Edge Cases', () {
|
||||
test('getLatestRoundNumber()', () async {
|
||||
var latestRound = await database.scoreEntryDao.getLatestRoundNumber(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(latestRound, isNull);
|
||||
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
|
||||
);
|
||||
|
||||
latestRound = await database.scoreEntryDao.getLatestRoundNumber(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(latestRound, 1);
|
||||
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 5, score: 50, change: 40),
|
||||
);
|
||||
|
||||
latestRound = await database.scoreEntryDao.getLatestRoundNumber(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(latestRound, 5);
|
||||
});
|
||||
|
||||
test('getLatestRoundNumber() with non-consecutive rounds', () async {
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 5, score: 50, change: 40),
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 3, score: 30, change: 20),
|
||||
);
|
||||
|
||||
final latestRound = await database.scoreEntryDao.getLatestRoundNumber(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
expect(latestRound, 5);
|
||||
});
|
||||
|
||||
test('getTotalScoreForPlayer()', () async {
|
||||
var totalScore = await database.scoreEntryDao.getTotalScoreForPlayer(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(totalScore, 0);
|
||||
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 2, score: 25, change: 15),
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 3, score: 40, change: 15),
|
||||
);
|
||||
|
||||
totalScore = await database.scoreEntryDao.getTotalScoreForPlayer(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(totalScore, 40);
|
||||
});
|
||||
|
||||
test('getTotalScoreForPlayer() ignores round score', () async {
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 2, score: 25, change: 25),
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 25, change: 10),
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 3, score: 25, change: 25),
|
||||
);
|
||||
|
||||
final totalScore = await database.scoreEntryDao.getTotalScoreForPlayer(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
// Should return the sum of all changes
|
||||
expect(totalScore, 60);
|
||||
});
|
||||
|
||||
test('Adding the same score twice replaces the existing one', () async {
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 10, change: 10),
|
||||
);
|
||||
await database.scoreEntryDao.addScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
entry: ScoreEntry(roundNumber: 1, score: 20, change: 20),
|
||||
);
|
||||
|
||||
final score = await database.scoreEntryDao.getScore(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
roundNumber: 1,
|
||||
);
|
||||
|
||||
expect(score, isNotNull);
|
||||
expect(score!.score, 20);
|
||||
expect(score.change, 20);
|
||||
});
|
||||
});
|
||||
|
||||
group('Handling Winner', () {
|
||||
test('hasWinner() works correctly', () async {
|
||||
var hasWinner = await database.scoreEntryDao.hasWinner(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(hasWinner, false);
|
||||
|
||||
await database.scoreEntryDao.setWinner(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
hasWinner = await database.scoreEntryDao.hasWinner(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(hasWinner, true);
|
||||
});
|
||||
|
||||
test('getWinnersForMatch() returns correct winner', () async {
|
||||
var winner = await database.scoreEntryDao.getWinner(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(winner, isNull);
|
||||
|
||||
await database.scoreEntryDao.setWinner(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
winner = await database.scoreEntryDao.getWinner(matchId: testMatch1.id);
|
||||
|
||||
expect(winner, isNotNull);
|
||||
expect(winner!.id, testPlayer1.id);
|
||||
});
|
||||
|
||||
test('removeWinner() works correctly', () async {
|
||||
var removed = await database.scoreEntryDao.removeWinner(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(removed, false);
|
||||
|
||||
await database.scoreEntryDao.setWinner(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
removed = await database.scoreEntryDao.removeWinner(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(removed, true);
|
||||
|
||||
var winner = await database.scoreEntryDao.getWinner(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(winner, isNull);
|
||||
});
|
||||
});
|
||||
|
||||
group('Handling Looser', () {
|
||||
test('hasLooser() works correctly', () async {
|
||||
var hasLooser = await database.scoreEntryDao.hasLooser(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(hasLooser, false);
|
||||
|
||||
await database.scoreEntryDao.setLooser(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
hasLooser = await database.scoreEntryDao.hasLooser(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(hasLooser, true);
|
||||
});
|
||||
|
||||
test('getLooser() returns correct winner', () async {
|
||||
var looser = await database.scoreEntryDao.getLooser(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(looser, isNull);
|
||||
|
||||
await database.scoreEntryDao.setLooser(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
looser = await database.scoreEntryDao.getLooser(matchId: testMatch1.id);
|
||||
|
||||
expect(looser, isNotNull);
|
||||
expect(looser!.id, testPlayer1.id);
|
||||
});
|
||||
|
||||
test('removeLooser() works correctly', () async {
|
||||
var removed = await database.scoreEntryDao.removeLooser(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(removed, false);
|
||||
|
||||
await database.scoreEntryDao.setLooser(
|
||||
playerId: testPlayer1.id,
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
|
||||
removed = await database.scoreEntryDao.removeLooser(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(removed, true);
|
||||
|
||||
var looser = await database.scoreEntryDao.getLooser(
|
||||
matchId: testMatch1.id,
|
||||
);
|
||||
expect(looser, isNull);
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -1,926 +0,0 @@
|
||||
import 'dart:convert';
|
||||
|
||||
import 'package:clock/clock.dart';
|
||||
import 'package:drift/drift.dart' hide isNull, isNotNull;
|
||||
import 'package:drift/native.dart';
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:provider/provider.dart';
|
||||
import 'package:tallee/core/enums.dart';
|
||||
import 'package:tallee/data/db/database.dart';
|
||||
import 'package:tallee/data/models/game.dart';
|
||||
import 'package:tallee/data/models/group.dart';
|
||||
import 'package:tallee/data/models/match.dart';
|
||||
import 'package:tallee/data/models/player.dart';
|
||||
import 'package:tallee/data/models/score_entry.dart';
|
||||
import 'package:tallee/data/models/team.dart';
|
||||
import 'package:tallee/services/data_transfer_service.dart';
|
||||
|
||||
void main() {
|
||||
late AppDatabase database;
|
||||
late Player testPlayer1;
|
||||
late Player testPlayer2;
|
||||
late Player testPlayer3;
|
||||
late Game testGame;
|
||||
late Group testGroup;
|
||||
late Team testTeam;
|
||||
late Match testMatch;
|
||||
final fixedDate = DateTime(2025, 11, 19, 0, 11, 23);
|
||||
final fakeClock = Clock(() => fixedDate);
|
||||
|
||||
setUp(() {
|
||||
database = AppDatabase(
|
||||
DatabaseConnection(
|
||||
NativeDatabase.memory(),
|
||||
closeStreamsSynchronously: true,
|
||||
),
|
||||
);
|
||||
|
||||
withClock(fakeClock, () {
|
||||
testPlayer1 = Player(name: 'Alice', description: 'First test player');
|
||||
testPlayer2 = Player(name: 'Bob', description: 'Second test player');
|
||||
testPlayer3 = Player(name: 'Charlie', description: 'Third player');
|
||||
|
||||
testGame = Game(
|
||||
name: 'Chess',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
description: 'Strategic board game',
|
||||
color: GameColor.blue,
|
||||
icon: 'chess_icon',
|
||||
);
|
||||
|
||||
testGroup = Group(
|
||||
name: 'Test Group',
|
||||
description: 'Group for testing',
|
||||
members: [testPlayer1, testPlayer2],
|
||||
);
|
||||
|
||||
testTeam = Team(name: 'Test Team', members: [testPlayer1, testPlayer2]);
|
||||
|
||||
testMatch = Match(
|
||||
name: 'Test Match',
|
||||
game: testGame,
|
||||
group: testGroup,
|
||||
players: [testPlayer1, testPlayer2],
|
||||
notes: 'Test notes',
|
||||
scores: {
|
||||
testPlayer1.id: [
|
||||
ScoreEntry(roundNumber: 1, score: 10, change: 10),
|
||||
ScoreEntry(roundNumber: 2, score: 20, change: 10),
|
||||
],
|
||||
testPlayer2.id: [
|
||||
ScoreEntry(roundNumber: 1, score: 15, change: 15),
|
||||
ScoreEntry(roundNumber: 2, score: 25, change: 10),
|
||||
],
|
||||
},
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
tearDown(() async {
|
||||
await database.close();
|
||||
});
|
||||
|
||||
// Helper for getting BuildContext
|
||||
Future<BuildContext> getContext(WidgetTester tester) async {
|
||||
// Minimal widget with Provider
|
||||
await tester.pumpWidget(
|
||||
Provider<AppDatabase>.value(
|
||||
value: database,
|
||||
child: MaterialApp(
|
||||
home: Builder(
|
||||
builder: (context) {
|
||||
return Container();
|
||||
},
|
||||
),
|
||||
),
|
||||
),
|
||||
);
|
||||
final BuildContext context = tester.element(find.byType(Container));
|
||||
return context;
|
||||
}
|
||||
|
||||
group('DataTransferService Tests', () {
|
||||
testWidgets('deleteAllData()', (tester) async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
await database.teamDao.addTeam(team: testTeam);
|
||||
await database.matchDao.addMatch(match: testMatch);
|
||||
|
||||
var playerCount = await database.playerDao.getPlayerCount();
|
||||
var gameCount = await database.gameDao.getGameCount();
|
||||
var groupCount = await database.groupDao.getGroupCount();
|
||||
var teamCount = await database.teamDao.getTeamCount();
|
||||
var matchCount = await database.matchDao.getMatchCount();
|
||||
|
||||
expect(playerCount, greaterThan(0));
|
||||
expect(gameCount, greaterThan(0));
|
||||
expect(groupCount, greaterThan(0));
|
||||
expect(teamCount, greaterThan(0));
|
||||
expect(matchCount, greaterThan(0));
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
await DataTransferService.deleteAllData(ctx);
|
||||
|
||||
playerCount = await database.playerDao.getPlayerCount();
|
||||
gameCount = await database.gameDao.getGameCount();
|
||||
groupCount = await database.groupDao.getGroupCount();
|
||||
teamCount = await database.teamDao.getTeamCount();
|
||||
matchCount = await database.matchDao.getMatchCount();
|
||||
|
||||
expect(playerCount, 0);
|
||||
expect(gameCount, 0);
|
||||
expect(groupCount, 0);
|
||||
expect(teamCount, 0);
|
||||
expect(matchCount, 0);
|
||||
});
|
||||
|
||||
group('getAppDataAsJson()', () {
|
||||
group('Whole export', () {
|
||||
testWidgets('Exporting app data works correctly', (tester) async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.playerDao.addPlayer(player: testPlayer2);
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
await database.teamDao.addTeam(team: testTeam);
|
||||
await database.matchDao.addMatch(match: testMatch);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
|
||||
expect(jsonString, isNotEmpty);
|
||||
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
|
||||
expect(decoded.containsKey('players'), true);
|
||||
expect(decoded.containsKey('games'), true);
|
||||
expect(decoded.containsKey('groups'), true);
|
||||
expect(decoded.containsKey('teams'), true);
|
||||
expect(decoded.containsKey('matches'), true);
|
||||
|
||||
final players = decoded['players'] as List<dynamic>;
|
||||
final games = decoded['games'] as List<dynamic>;
|
||||
final groups = decoded['groups'] as List<dynamic>;
|
||||
final teams = decoded['teams'] as List<dynamic>;
|
||||
final matches = decoded['matches'] as List<dynamic>;
|
||||
|
||||
expect(players.length, 2);
|
||||
expect(games.length, 1);
|
||||
expect(groups.length, 1);
|
||||
expect(teams.length, 1);
|
||||
expect(matches.length, 1);
|
||||
});
|
||||
|
||||
testWidgets('Exporting empty data works correctly', (tester) async {
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
|
||||
final players = decoded['players'] as List<dynamic>;
|
||||
final games = decoded['games'] as List<dynamic>;
|
||||
final groups = decoded['groups'] as List<dynamic>;
|
||||
final teams = decoded['teams'] as List<dynamic>;
|
||||
final matches = decoded['matches'] as List<dynamic>;
|
||||
|
||||
expect(players, isEmpty);
|
||||
expect(games, isEmpty);
|
||||
expect(groups, isEmpty);
|
||||
expect(teams, isEmpty);
|
||||
expect(matches, isEmpty);
|
||||
});
|
||||
});
|
||||
|
||||
group('Checking specific data', () {
|
||||
testWidgets('Player data is correct', (tester) async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final players = decoded['players'] as List<dynamic>;
|
||||
final playerData = players[0] as Map<String, dynamic>;
|
||||
|
||||
expect(playerData['id'], testPlayer1.id);
|
||||
expect(playerData['name'], testPlayer1.name);
|
||||
expect(playerData['description'], testPlayer1.description);
|
||||
expect(
|
||||
playerData['createdAt'],
|
||||
testPlayer1.createdAt.toIso8601String(),
|
||||
);
|
||||
});
|
||||
|
||||
testWidgets('Game data is correct', (tester) async {
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final games = decoded['games'] as List<dynamic>;
|
||||
final gameData = games[0] as Map<String, dynamic>;
|
||||
|
||||
expect(gameData['id'], testGame.id);
|
||||
expect(gameData['name'], testGame.name);
|
||||
expect(gameData['ruleset'], testGame.ruleset.name);
|
||||
expect(gameData['description'], testGame.description);
|
||||
expect(gameData['color'], testGame.color.name);
|
||||
expect(gameData['icon'], testGame.icon);
|
||||
});
|
||||
|
||||
testWidgets('Group data is correct', (tester) async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.playerDao.addPlayer(player: testPlayer2);
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final groups = decoded['groups'] as List<dynamic>;
|
||||
final groupData = groups[0] as Map<String, dynamic>;
|
||||
|
||||
expect(groupData['id'], testGroup.id);
|
||||
expect(groupData['name'], testGroup.name);
|
||||
expect(groupData['description'], testGroup.description);
|
||||
expect(groupData['memberIds'], isA<List>());
|
||||
|
||||
final memberIds = groupData['memberIds'] as List<dynamic>;
|
||||
expect(memberIds.length, 2);
|
||||
expect(memberIds, containsAll([testPlayer1.id, testPlayer2.id]));
|
||||
});
|
||||
|
||||
testWidgets('Team data is correct', (tester) async {
|
||||
await database.teamDao.addTeam(team: testTeam);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final teams = decoded['teams'] as List<dynamic>;
|
||||
|
||||
expect(teams.length, 1);
|
||||
|
||||
final teamData = teams[0] as Map<String, dynamic>;
|
||||
|
||||
expect(teamData['id'], testTeam.id);
|
||||
expect(teamData['name'], testTeam.name);
|
||||
expect(teamData['memberIds'], isA<List>());
|
||||
|
||||
// Note: In this system, teams don't have independent members.
|
||||
// Team members are only tracked through matches via PlayerMatchTable.
|
||||
// Therefore, memberIds will be empty for standalone teams.
|
||||
final memberIds = teamData['memberIds'] as List<dynamic>;
|
||||
expect(memberIds, isEmpty);
|
||||
});
|
||||
|
||||
testWidgets('Match data is correct', (tester) async {
|
||||
await database.playerDao.addPlayersAsList(
|
||||
players: [testPlayer1, testPlayer2],
|
||||
);
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
await database.groupDao.addGroup(group: testGroup);
|
||||
await database.matchDao.addMatch(match: testMatch);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final matches = decoded['matches'] as List<dynamic>;
|
||||
final matchData = matches[0] as Map<String, dynamic>;
|
||||
|
||||
expect(matchData['id'], testMatch.id);
|
||||
expect(matchData['name'], testMatch.name);
|
||||
expect(matchData['gameId'], testGame.id);
|
||||
expect(matchData['groupId'], testGroup.id);
|
||||
expect(matchData['playerIds'], isA<List>());
|
||||
expect(matchData['notes'], testMatch.notes);
|
||||
|
||||
// Check player ids
|
||||
final playerIds = matchData['playerIds'] as List<dynamic>;
|
||||
expect(playerIds.length, 2);
|
||||
expect(playerIds, containsAll([testPlayer1.id, testPlayer2.id]));
|
||||
|
||||
// Check scores structure
|
||||
final scoresJson = matchData['scores'] as Map<String, dynamic>;
|
||||
expect(scoresJson, isA<Map<String, dynamic>>());
|
||||
|
||||
final scores = scoresJson.map(
|
||||
(playerId, scoreList) => MapEntry(
|
||||
playerId,
|
||||
(scoreList as List)
|
||||
.map((s) => ScoreEntry.fromJson(s as Map<String, dynamic>))
|
||||
.toList(),
|
||||
),
|
||||
);
|
||||
|
||||
expect(scores, isA<Map<String, List<ScoreEntry>>>());
|
||||
|
||||
/* Player 1 scores */
|
||||
// General structure
|
||||
expect(scores[testPlayer1.id], isNotNull);
|
||||
expect(scores[testPlayer1.id]!.length, 2);
|
||||
|
||||
// Round 1
|
||||
expect(scores[testPlayer1.id]![0].roundNumber, 1);
|
||||
expect(scores[testPlayer1.id]![0].score, 10);
|
||||
expect(scores[testPlayer1.id]![0].change, 10);
|
||||
|
||||
// Round 2
|
||||
expect(scores[testPlayer1.id]![1].roundNumber, 2);
|
||||
expect(scores[testPlayer1.id]![1].score, 20);
|
||||
expect(scores[testPlayer1.id]![1].change, 10);
|
||||
|
||||
/* Player 2 scores */
|
||||
// General structure
|
||||
expect(scores[testPlayer2.id], isNotNull);
|
||||
expect(scores[testPlayer2.id]!.length, 2);
|
||||
|
||||
// Round 1
|
||||
expect(scores[testPlayer2.id]![0].roundNumber, 1);
|
||||
expect(scores[testPlayer2.id]![0].score, 15);
|
||||
expect(scores[testPlayer2.id]![0].change, 15);
|
||||
|
||||
// Round 2
|
||||
expect(scores[testPlayer2.id]![1].roundNumber, 2);
|
||||
expect(scores[testPlayer2.id]![1].score, 25);
|
||||
expect(scores[testPlayer2.id]![1].change, 10);
|
||||
});
|
||||
|
||||
testWidgets('Match without group is handled correctly', (tester) async {
|
||||
final matchWithoutGroup = Match(
|
||||
name: 'No Group Match',
|
||||
game: testGame,
|
||||
group: null,
|
||||
players: [testPlayer1],
|
||||
notes: 'No group',
|
||||
);
|
||||
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
await database.matchDao.addMatch(match: matchWithoutGroup);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final matches = decoded['matches'] as List<dynamic>;
|
||||
final matchData = matches[0] as Map<String, dynamic>;
|
||||
|
||||
expect(matchData['groupId'], isNull);
|
||||
});
|
||||
|
||||
testWidgets('Match with endedAt is handled correctly', (tester) async {
|
||||
final endedDate = DateTime(2025, 12, 1, 10, 0, 0);
|
||||
final endedMatch = Match(
|
||||
name: 'Ended Match',
|
||||
game: testGame,
|
||||
players: [testPlayer1],
|
||||
endedAt: endedDate,
|
||||
notes: 'Finished',
|
||||
);
|
||||
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
await database.matchDao.addMatch(match: endedMatch);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final matches = decoded['matches'] as List<dynamic>;
|
||||
final matchData = matches[0] as Map<String, dynamic>;
|
||||
|
||||
expect(matchData['endedAt'], endedDate.toIso8601String());
|
||||
});
|
||||
|
||||
testWidgets('Structure is consistent', (tester) async {
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString1 = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final jsonString2 = await DataTransferService.getAppDataAsJson(ctx);
|
||||
|
||||
expect(jsonString1, equals(jsonString2));
|
||||
});
|
||||
|
||||
testWidgets('Empty match notes is handled correctly', (tester) async {
|
||||
final matchWithEmptyNotes = Match(
|
||||
name: 'Empty Notes Match',
|
||||
game: testGame,
|
||||
players: [testPlayer1],
|
||||
notes: '',
|
||||
);
|
||||
|
||||
await database.playerDao.addPlayer(player: testPlayer1);
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
await database.matchDao.addMatch(match: matchWithEmptyNotes);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final matches = decoded['matches'] as List<dynamic>;
|
||||
final matchData = matches[0] as Map<String, dynamic>;
|
||||
|
||||
expect(matchData['notes'], '');
|
||||
});
|
||||
|
||||
testWidgets('Multiple players in match is handled correctly', (
|
||||
tester,
|
||||
) async {
|
||||
final multiPlayerMatch = Match(
|
||||
name: 'Multi Player Match',
|
||||
game: testGame,
|
||||
players: [testPlayer1, testPlayer2, testPlayer3],
|
||||
notes: 'Three players',
|
||||
);
|
||||
|
||||
await database.playerDao.addPlayersAsList(
|
||||
players: [testPlayer1, testPlayer2, testPlayer3],
|
||||
);
|
||||
await database.gameDao.addGame(game: testGame);
|
||||
await database.matchDao.addMatch(match: multiPlayerMatch);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final matches = decoded['matches'] as List<dynamic>;
|
||||
final matchData = matches[0] as Map<String, dynamic>;
|
||||
|
||||
final playerIds = matchData['playerIds'] as List<dynamic>;
|
||||
expect(playerIds.length, 3);
|
||||
expect(
|
||||
playerIds,
|
||||
containsAll([testPlayer1.id, testPlayer2.id, testPlayer3.id]),
|
||||
);
|
||||
});
|
||||
|
||||
testWidgets('All game colors are handled correctly', (tester) async {
|
||||
final games = [
|
||||
Game(
|
||||
name: 'Red Game',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
color: GameColor.red,
|
||||
icon: 'icon',
|
||||
),
|
||||
Game(
|
||||
name: 'Blue Game',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
color: GameColor.blue,
|
||||
icon: 'icon',
|
||||
),
|
||||
Game(
|
||||
name: 'Green Game',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
color: GameColor.green,
|
||||
icon: 'icon',
|
||||
),
|
||||
];
|
||||
|
||||
await database.gameDao.addGamesAsList(games: games);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final gamesJson = decoded['games'] as List<dynamic>;
|
||||
|
||||
expect(gamesJson.length, 3);
|
||||
expect(
|
||||
gamesJson.map((g) => g['color']),
|
||||
containsAll(['red', 'blue', 'green']),
|
||||
);
|
||||
});
|
||||
|
||||
testWidgets('All rulesets are handled correctly', (tester) async {
|
||||
final games = [
|
||||
Game(
|
||||
name: 'Highest Score Game',
|
||||
ruleset: Ruleset.highestScore,
|
||||
color: GameColor.blue,
|
||||
icon: 'icon',
|
||||
),
|
||||
Game(
|
||||
name: 'Lowest Score Game',
|
||||
ruleset: Ruleset.lowestScore,
|
||||
color: GameColor.blue,
|
||||
icon: 'icon',
|
||||
),
|
||||
Game(
|
||||
name: 'Single Winner',
|
||||
ruleset: Ruleset.singleWinner,
|
||||
color: GameColor.blue,
|
||||
icon: 'icon',
|
||||
),
|
||||
];
|
||||
|
||||
await database.gameDao.addGamesAsList(games: games);
|
||||
|
||||
final ctx = await getContext(tester);
|
||||
final jsonString = await DataTransferService.getAppDataAsJson(ctx);
|
||||
final decoded = json.decode(jsonString) as Map<String, dynamic>;
|
||||
final gamesJson = decoded['games'] as List<dynamic>;
|
||||
|
||||
expect(gamesJson.length, 3);
|
||||
expect(
|
||||
gamesJson.map((g) => g['ruleset']),
|
||||
containsAll(['highestScore', 'lowestScore', 'singleWinner']),
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
group('Parse Methods', () {
|
||||
test('parsePlayersFromJson()', () {
|
||||
final jsonMap = {
|
||||
'players': [
|
||||
{
|
||||
'id': testPlayer1.id,
|
||||
'name': testPlayer1.name,
|
||||
'description': testPlayer1.description,
|
||||
'createdAt': testPlayer1.createdAt.toIso8601String(),
|
||||
},
|
||||
{
|
||||
'id': testPlayer2.id,
|
||||
'name': testPlayer2.name,
|
||||
'description': testPlayer2.description,
|
||||
'createdAt': testPlayer2.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
final players = DataTransferService.parsePlayersFromJson(jsonMap);
|
||||
|
||||
expect(players.length, 2);
|
||||
expect(players[0].id, testPlayer1.id);
|
||||
expect(players[0].name, testPlayer1.name);
|
||||
expect(players[1].id, testPlayer2.id);
|
||||
expect(players[1].name, testPlayer2.name);
|
||||
});
|
||||
|
||||
test('parsePlayersFromJson() empty list', () {
|
||||
final jsonMap = {'players': []};
|
||||
final players = DataTransferService.parsePlayersFromJson(jsonMap);
|
||||
expect(players, isEmpty);
|
||||
});
|
||||
|
||||
test('parsePlayersFromJson() missing key', () {
|
||||
final jsonMap = <String, dynamic>{};
|
||||
final players = DataTransferService.parsePlayersFromJson(jsonMap);
|
||||
expect(players, isEmpty);
|
||||
});
|
||||
|
||||
test('parseGamesFromJson()', () {
|
||||
final jsonMap = {
|
||||
'games': [
|
||||
{
|
||||
'id': testGame.id,
|
||||
'name': testGame.name,
|
||||
'ruleset': testGame.ruleset.name,
|
||||
'description': testGame.description,
|
||||
'color': testGame.color.name,
|
||||
'icon': testGame.icon,
|
||||
'createdAt': testGame.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
final games = DataTransferService.parseGamesFromJson(jsonMap);
|
||||
|
||||
expect(games.length, 1);
|
||||
expect(games[0].id, testGame.id);
|
||||
expect(games[0].name, testGame.name);
|
||||
expect(games[0].ruleset, testGame.ruleset);
|
||||
});
|
||||
|
||||
test('parseGamesFromJson() empty list', () {
|
||||
final jsonMap = {'games': []};
|
||||
final games = DataTransferService.parseGamesFromJson(jsonMap);
|
||||
expect(games, isEmpty);
|
||||
});
|
||||
|
||||
test('parseGamesFromJson() missing key', () {
|
||||
final jsonMap = <String, dynamic>{};
|
||||
final games = DataTransferService.parseGamesFromJson(jsonMap);
|
||||
expect(games, isEmpty);
|
||||
});
|
||||
|
||||
test('parseGroupsFromJson()', () {
|
||||
final playerById = {
|
||||
testPlayer1.id: testPlayer1,
|
||||
testPlayer2.id: testPlayer2,
|
||||
};
|
||||
|
||||
final jsonMap = {
|
||||
'groups': [
|
||||
{
|
||||
'id': testGroup.id,
|
||||
'name': testGroup.name,
|
||||
'description': testGroup.description,
|
||||
'memberIds': [testPlayer1.id, testPlayer2.id],
|
||||
'createdAt': testGroup.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
final groups = DataTransferService.parseGroupsFromJson(
|
||||
jsonMap,
|
||||
playerById,
|
||||
);
|
||||
|
||||
expect(groups.length, 1);
|
||||
expect(groups[0].id, testGroup.id);
|
||||
expect(groups[0].name, testGroup.name);
|
||||
expect(groups[0].members.length, 2);
|
||||
expect(groups[0].members[0].id, testPlayer1.id);
|
||||
expect(groups[0].members[1].id, testPlayer2.id);
|
||||
});
|
||||
|
||||
test('parseGroupsFromJson() empty list', () {
|
||||
final jsonMap = {'groups': []};
|
||||
final groups = DataTransferService.parseGroupsFromJson(jsonMap, {});
|
||||
expect(groups, isEmpty);
|
||||
});
|
||||
|
||||
test('parseGroupsFromJson() missing key', () {
|
||||
final jsonMap = <String, dynamic>{};
|
||||
final groups = DataTransferService.parseGroupsFromJson(jsonMap, {});
|
||||
expect(groups, isEmpty);
|
||||
});
|
||||
|
||||
test('parseGroupsFromJson() ignores invalid player ids', () {
|
||||
final playerById = {testPlayer1.id: testPlayer1};
|
||||
|
||||
final jsonMap = {
|
||||
'groups': [
|
||||
{
|
||||
'id': testGroup.id,
|
||||
'name': testGroup.name,
|
||||
'description': testGroup.description,
|
||||
'memberIds': [testPlayer1.id, 'invalid-id'],
|
||||
'createdAt': testGroup.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
final groups = DataTransferService.parseGroupsFromJson(
|
||||
jsonMap,
|
||||
playerById,
|
||||
);
|
||||
|
||||
expect(groups.length, 1);
|
||||
expect(groups[0].members.length, 1);
|
||||
expect(groups[0].members[0].id, testPlayer1.id);
|
||||
});
|
||||
|
||||
test('parseTeamsFromJson()', () {
|
||||
final playerById = {testPlayer1.id: testPlayer1};
|
||||
|
||||
final jsonMap = {
|
||||
'teams': [
|
||||
{
|
||||
'id': testTeam.id,
|
||||
'name': testTeam.name,
|
||||
'memberIds': [testPlayer1.id],
|
||||
'createdAt': testTeam.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
final teams = DataTransferService.parseTeamsFromJson(
|
||||
jsonMap,
|
||||
playerById,
|
||||
);
|
||||
|
||||
expect(teams.length, 1);
|
||||
expect(teams[0].id, testTeam.id);
|
||||
expect(teams[0].name, testTeam.name);
|
||||
expect(teams[0].members.length, 1);
|
||||
expect(teams[0].members[0].id, testPlayer1.id);
|
||||
});
|
||||
|
||||
test('parseTeamsFromJson() empty list', () {
|
||||
final jsonMap = {'teams': []};
|
||||
final teams = DataTransferService.parseTeamsFromJson(jsonMap, {});
|
||||
expect(teams, isEmpty);
|
||||
});
|
||||
|
||||
test('parseTeamsFromJson() missing key', () {
|
||||
final jsonMap = <String, dynamic>{};
|
||||
final teams = DataTransferService.parseTeamsFromJson(jsonMap, {});
|
||||
expect(teams, isEmpty);
|
||||
});
|
||||
|
||||
test('parseMatchesFromJson()', () {
|
||||
final playerById = {
|
||||
testPlayer1.id: testPlayer1,
|
||||
testPlayer2.id: testPlayer2,
|
||||
};
|
||||
final gameById = {testGame.id: testGame};
|
||||
final groupById = {testGroup.id: testGroup};
|
||||
|
||||
final jsonMap = {
|
||||
'matches': [
|
||||
{
|
||||
'id': testMatch.id,
|
||||
'name': testMatch.name,
|
||||
'gameId': testGame.id,
|
||||
'groupId': testGroup.id,
|
||||
'playerIds': [testPlayer1.id, testPlayer2.id],
|
||||
'notes': testMatch.notes,
|
||||
'createdAt': testMatch.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
final matches = DataTransferService.parseMatchesFromJson(
|
||||
jsonMap,
|
||||
gameById,
|
||||
groupById,
|
||||
playerById,
|
||||
);
|
||||
|
||||
expect(matches.length, 1);
|
||||
expect(matches[0].id, testMatch.id);
|
||||
expect(matches[0].name, testMatch.name);
|
||||
expect(matches[0].game.id, testGame.id);
|
||||
expect(matches[0].group?.id, testGroup.id);
|
||||
expect(matches[0].players.length, 2);
|
||||
});
|
||||
|
||||
test('parseMatchesFromJson() empty list', () {
|
||||
final jsonMap = {'teams': []};
|
||||
final matches = DataTransferService.parseMatchesFromJson(
|
||||
jsonMap,
|
||||
{},
|
||||
{},
|
||||
{},
|
||||
);
|
||||
expect(matches, isEmpty);
|
||||
});
|
||||
|
||||
test('parseMatchesFromJson() missing key', () {
|
||||
final jsonMap = <String, dynamic>{};
|
||||
final matches = DataTransferService.parseMatchesFromJson(
|
||||
jsonMap,
|
||||
{},
|
||||
{},
|
||||
{},
|
||||
);
|
||||
expect(matches, isEmpty);
|
||||
});
|
||||
|
||||
test('parseMatchesFromJson() creates unknown game for missing game', () {
|
||||
final playerById = {testPlayer1.id: testPlayer1};
|
||||
final gameById = <String, Game>{};
|
||||
final groupById = <String, Group>{};
|
||||
|
||||
final jsonMap = {
|
||||
'matches': [
|
||||
{
|
||||
'id': testMatch.id,
|
||||
'name': testMatch.name,
|
||||
'gameId': 'non-existent-game-id',
|
||||
'playerIds': [testPlayer1.id],
|
||||
'notes': '',
|
||||
'createdAt': testMatch.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
final matches = DataTransferService.parseMatchesFromJson(
|
||||
jsonMap,
|
||||
gameById,
|
||||
groupById,
|
||||
playerById,
|
||||
);
|
||||
|
||||
expect(matches.length, 1);
|
||||
expect(matches[0].game.name, 'Unknown');
|
||||
expect(matches[0].game.ruleset, Ruleset.singleWinner);
|
||||
});
|
||||
|
||||
test('parseMatchesFromJson() handles null group', () {
|
||||
final playerById = {testPlayer1.id: testPlayer1};
|
||||
final gameById = {testGame.id: testGame};
|
||||
final groupById = <String, Group>{};
|
||||
|
||||
final jsonMap = {
|
||||
'matches': [
|
||||
{
|
||||
'id': testMatch.id,
|
||||
'name': testMatch.name,
|
||||
'gameId': testGame.id,
|
||||
'groupId': null,
|
||||
'playerIds': [testPlayer1.id],
|
||||
'notes': '',
|
||||
'createdAt': testMatch.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
final matches = DataTransferService.parseMatchesFromJson(
|
||||
jsonMap,
|
||||
gameById,
|
||||
groupById,
|
||||
playerById,
|
||||
);
|
||||
|
||||
expect(matches.length, 1);
|
||||
expect(matches[0].group, isNull);
|
||||
});
|
||||
|
||||
test('parseMatchesFromJson() handles endedAt', () {
|
||||
final playerById = {testPlayer1.id: testPlayer1};
|
||||
final gameById = {testGame.id: testGame};
|
||||
final groupById = <String, Group>{};
|
||||
final endedDate = DateTime(2025, 12, 1, 10, 0, 0);
|
||||
|
||||
final jsonMap = {
|
||||
'matches': [
|
||||
{
|
||||
'id': testMatch.id,
|
||||
'name': testMatch.name,
|
||||
'gameId': testGame.id,
|
||||
'playerIds': [testPlayer1.id],
|
||||
'notes': '',
|
||||
'createdAt': testMatch.createdAt.toIso8601String(),
|
||||
'endedAt': endedDate.toIso8601String(),
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
final matches = DataTransferService.parseMatchesFromJson(
|
||||
jsonMap,
|
||||
gameById,
|
||||
groupById,
|
||||
playerById,
|
||||
);
|
||||
|
||||
expect(matches.length, 1);
|
||||
expect(matches[0].endedAt, endedDate);
|
||||
});
|
||||
});
|
||||
|
||||
test('validateJsonSchema()', () async {
|
||||
final validJson = json.encode({
|
||||
'players': [
|
||||
{
|
||||
'id': testPlayer1.id,
|
||||
'name': testPlayer1.name,
|
||||
'description': testPlayer1.description,
|
||||
'createdAt': testPlayer1.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
'games': [
|
||||
{
|
||||
'id': testGame.id,
|
||||
'name': testGame.name,
|
||||
'ruleset': testGame.ruleset.name,
|
||||
'description': testGame.description,
|
||||
'color': testGame.color.name,
|
||||
'icon': testGame.icon,
|
||||
'createdAt': testGame.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
'groups': [
|
||||
{
|
||||
'id': testGroup.id,
|
||||
'name': testGroup.name,
|
||||
'description': testGroup.description,
|
||||
'memberIds': [testPlayer1.id, testPlayer2.id],
|
||||
'createdAt': testGroup.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
'teams': [
|
||||
{
|
||||
'id': testTeam.id,
|
||||
'name': testTeam.name,
|
||||
'memberIds': [testPlayer1.id, testPlayer2.id],
|
||||
'createdAt': testTeam.createdAt.toIso8601String(),
|
||||
},
|
||||
],
|
||||
'matches': [
|
||||
{
|
||||
'id': testMatch.id,
|
||||
'name': testMatch.name,
|
||||
'gameId': testGame.id,
|
||||
'groupId': testGroup.id,
|
||||
'playerIds': [testPlayer1.id, testPlayer2.id],
|
||||
'notes': testMatch.notes,
|
||||
'scores': {
|
||||
testPlayer1.id: [
|
||||
{'roundNumber': 1, 'score': 10, 'change': 10},
|
||||
{'roundNumber': 2, 'score': 20, 'change': 10},
|
||||
],
|
||||
testPlayer2.id: [
|
||||
{'roundNumber': 1, 'score': 15, 'change': 15},
|
||||
{'roundNumber': 2, 'score': 25, 'change': 10},
|
||||
],
|
||||
},
|
||||
'createdAt': testMatch.createdAt.toIso8601String(),
|
||||
'endedAt': null,
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
final isValid = await DataTransferService.validateJsonSchema(validJson);
|
||||
expect(isValid, true);
|
||||
});
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user