128 lines
3.5 KiB
Dart
128 lines
3.5 KiB
Dart
import 'package:bang_navigator/features/bangs/data/database/database.dart';
|
|
import 'package:bang_navigator/features/bangs/data/models/bang.dart';
|
|
import 'package:bang_navigator/features/bangs/data/providers.dart';
|
|
import 'package:bang_navigator/features/bangs/data/services/source.dart';
|
|
import 'package:drift/isolate.dart';
|
|
import 'package:exceptions/exceptions.dart';
|
|
import 'package:riverpod/riverpod.dart';
|
|
import 'package:riverpod_annotation/riverpod_annotation.dart';
|
|
|
|
part 'sync.g.dart';
|
|
|
|
@Riverpod(keepAlive: true)
|
|
class BangSyncRepository extends _$BangSyncRepository {
|
|
late BangDatabase _db;
|
|
|
|
BangSyncRepository();
|
|
|
|
static Future<Result<void>> _fetchAndSync({
|
|
required BangSourceService sourceService,
|
|
required BangDatabase db,
|
|
required Uri url,
|
|
required BangGroup group,
|
|
required Duration? syncInterval,
|
|
}) async {
|
|
if (syncInterval != null) {
|
|
final lastSync =
|
|
await db.syncDao.lastSyncOfGroup(group).getSingleOrNull();
|
|
|
|
if (lastSync != null &&
|
|
lastSync.difference(DateTime.now()) < syncInterval) {
|
|
return Result.success(null);
|
|
}
|
|
}
|
|
|
|
final result = await sourceService.getBangs(url, group);
|
|
return result.flatMapAsync(
|
|
(remoteBangs) async {
|
|
await db.syncDao.syncBangs(
|
|
group: group,
|
|
remoteBangs: remoteBangs,
|
|
syncTime: DateTime.now(),
|
|
);
|
|
await db.optimizeFtsIndex();
|
|
},
|
|
);
|
|
}
|
|
|
|
Future<Result<void>> _syncBangGroup(
|
|
BangGroup group,
|
|
Uri url,
|
|
Duration? syncInterval,
|
|
) async {
|
|
try {
|
|
return Result.success(
|
|
await _db.computeWithDatabase(
|
|
connect: BangDatabase.new,
|
|
computation: (db) async {
|
|
final ref = ProviderContainer();
|
|
final result = await _fetchAndSync(
|
|
sourceService: ref.read(bangSourceServiceProvider.notifier),
|
|
db: db,
|
|
url: url,
|
|
group: group,
|
|
syncInterval: syncInterval,
|
|
);
|
|
|
|
//Throw if necessary
|
|
return result.value;
|
|
},
|
|
),
|
|
);
|
|
} catch (e) {
|
|
return Result.failure(
|
|
ErrorMessage(
|
|
message: "Failed to sync Bangs (${group.name})",
|
|
source: 'BangSync',
|
|
details: e,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
Stream<DateTime?> watchLastSyncOfGroup(BangGroup group) {
|
|
return _db.syncDao.lastSyncOfGroup(group).watchSingleOrNull();
|
|
}
|
|
|
|
Future<Result<void>> syncGeneralBangs({Duration? syncInterval}) =>
|
|
_syncBangGroup(
|
|
BangGroup.general,
|
|
Uri.parse(BangGroup.general.url),
|
|
syncInterval,
|
|
);
|
|
|
|
Future<Result<void>> syncKagiBangs({Duration? syncInterval}) =>
|
|
_syncBangGroup(
|
|
BangGroup.kagi,
|
|
Uri.parse(BangGroup.kagi.url),
|
|
syncInterval,
|
|
);
|
|
|
|
Future<Result<void>> syncAssistantBangs({Duration? syncInterval}) =>
|
|
_syncBangGroup(
|
|
BangGroup.assistant,
|
|
Uri.parse(BangGroup.assistant.url),
|
|
syncInterval,
|
|
);
|
|
|
|
Future<Map<BangGroup, Result<void>>> syncAllBangGroups({
|
|
Duration? syncInterval,
|
|
}) async {
|
|
//Run isolated operations
|
|
final generalSync = syncGeneralBangs(syncInterval: syncInterval);
|
|
final assistantSync = syncAssistantBangs(syncInterval: syncInterval);
|
|
final kagiSync = syncKagiBangs(syncInterval: syncInterval);
|
|
|
|
return {
|
|
BangGroup.general: await generalSync,
|
|
BangGroup.assistant: await assistantSync,
|
|
BangGroup.kagi: await kagiSync,
|
|
};
|
|
}
|
|
|
|
@override
|
|
void build() {
|
|
_db = ref.watch(bangDatabaseProvider);
|
|
}
|
|
}
|