118 lines
3.2 KiB
Dart
118 lines
3.2 KiB
Dart
import 'package:gamer_updater/db.dart';
|
|
import 'package:gamer_updater/utils.dart';
|
|
import 'package:http/http.dart' as http;
|
|
import 'package:dart_rss/dart_rss.dart';
|
|
|
|
class Game {
|
|
final String name;
|
|
final String versionRegex;
|
|
final RegExp _internalVersionRegex;
|
|
final String lastPlayed;
|
|
String actualVersion;
|
|
String lastUpdated;
|
|
final String rssFeedUrl;
|
|
|
|
Game({
|
|
required this.name,
|
|
required this.versionRegex,
|
|
required this.lastPlayed,
|
|
this.actualVersion = '',
|
|
required this.rssFeedUrl,
|
|
this.lastUpdated = '',
|
|
}) : _internalVersionRegex = RegExp(versionRegex);
|
|
|
|
factory Game.fromMap(Map<String, dynamic> map) {
|
|
return Game(
|
|
name: map['name'],
|
|
versionRegex: map['version_regex'],
|
|
lastPlayed: map['last_played'],
|
|
rssFeedUrl: map['rss_feed_url'],
|
|
actualVersion: map['actual_version'],
|
|
lastUpdated: map['last_updated'],
|
|
);
|
|
}
|
|
|
|
Future<void> updateActualVersion() async {
|
|
final response = await http.get(Uri.parse(rssFeedUrl));
|
|
final document = RssFeed.parse(response.body);
|
|
final pages = document.items;
|
|
pages.sort((a, b) {
|
|
var lhs = parseRfc822Date(a.pubDate!);
|
|
var rhs = parseRfc822Date(b.pubDate!);
|
|
return rhs.compareTo(lhs);
|
|
});
|
|
final versions =
|
|
pages
|
|
.map(
|
|
(e) =>
|
|
_internalVersionRegex.firstMatch(e.title!)?.group(1)?.trim(),
|
|
)
|
|
.toList();
|
|
|
|
for (int i = 0; i < versions.length; i++) {
|
|
final version = versions[i];
|
|
final page = pages[i];
|
|
if (version != null) {
|
|
actualVersion = version;
|
|
lastUpdated = parseRfc822Date(page.pubDate!).toIso8601String();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class GameRepository {
|
|
static Future<Game> upsert(Game game) async {
|
|
final db = DB.db;
|
|
await db.rawInsert(
|
|
'''
|
|
INSERT INTO games
|
|
(name, actual_version, last_played, rss_feed_url, version_regex, last_updated)
|
|
VALUES
|
|
(?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(name) DO UPDATE SET
|
|
actual_version = excluded.actual_version,
|
|
last_played = excluded.last_played,
|
|
rss_feed_url = excluded.rss_feed_url,
|
|
version_regex = excluded.version_regex,
|
|
last_updated = excluded.last_updated
|
|
''',
|
|
[
|
|
game.name,
|
|
game.actualVersion,
|
|
game.lastPlayed,
|
|
game.rssFeedUrl,
|
|
game.versionRegex,
|
|
game.lastUpdated,
|
|
],
|
|
);
|
|
return game;
|
|
}
|
|
|
|
static Future<Map<String, Game>> getAll() async {
|
|
final db = DB.db;
|
|
final games = await db.rawQuery(
|
|
'SELECT name, actual_version, last_played, rss_feed_url, version_regex, last_updated FROM games',
|
|
);
|
|
return games
|
|
.map((e) => Game.fromMap(e))
|
|
.fold<Map<String, Game>>({}, (map, game) => {...map, game.name: game});
|
|
}
|
|
|
|
static Future<void> delete(Game game) async {
|
|
final db = DB.db;
|
|
await db.rawDelete('DELETE FROM games WHERE name = ?', [game.name]);
|
|
}
|
|
}
|
|
|
|
//CREATE TABLE IF NOT EXISTS games (
|
|
// id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
// name TEXT NOT NULL,
|
|
// actual_version TEXT NOT NULL,
|
|
// last_played TEXT NOT NULL,
|
|
// rss_feed_url TEXT NOT NULL,
|
|
// version_regex TEXT NOT NULL,
|
|
// last_updated TEXT NOT NULL
|
|
//);
|
|
//CREATE INDEX IF NOT EXISTS idx_games_name ON games (name);
|