Flutterapps/dragon_ledger
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Feat: Ersetzt die Isar-Datenbank durch die drift-Datenbank

Browse Source
This commit is contained in:
DragonSlayer_14
2025-12-24 01:04:38 +01:00
parent 673d7de21c
commit c11515d447
23 changed files with 15995 additions and 2601 deletions
Download Patch File Download Diff File Expand all files Collapse all files

170
lib/Repositories/recurring_transacation_repository.dart
View File

@@ -1,132 +1,116 @@
import 'package:isar/isar.dart';
import 'package:drift/drift.dart';
import '../Entities/recurring_transaction.dart';
import '../Entities/drift_database.dart';
import '../Entities/time_frame_enum.dart';
import '../Services/isar_service.dart';
import '../Services/database_service.dart';
/// Funktionen zum interagieren mit der Datenbank für die Transaktionen
class RecurringTransactionRepository {
final IsarService _isarService = IsarService();
final AppDatabase _db = DatabaseService().database;
/// Fügt eine neue wiederkehrende Transaktion zur Datenbank hinzu
Future<RecurringTransaction?> add(
final RecurringTransaction recurringTransaction,
final RecurringTransactionsCompanion recurringTransaction,
) async {
final Isar isar = await _isarService.getDatabase();
final int id = await isar.writeTxn(
() => isar.recurringTransactions.put(recurringTransaction),
);
final int id = await _db.into(_db.recurringTransactions).insert(
recurringTransaction);
return find(id);
}
/// Entfernt eine wiederkehrende Transaktion aus der Datenbank
Future<bool> remove(final RecurringTransaction recurringTransaction) async {
final Isar isar = await _isarService.getDatabase();
return isar.writeTxn(
() => isar.recurringTransactions.delete(recurringTransaction.id),
);
Future<int> remove(final RecurringTransaction recurringTransaction) async {
return (_db.delete(_db.recurringTransactions)
..where((t) => t.id.equals(recurringTransaction.id))).go();
}
/// Sucht eine wiederkehrende Transaktion anhand seiner Id aus der Datenbank
Future<RecurringTransaction?> find(final int id) async {
final Isar isar = await _isarService.getDatabase();
return isar.recurringTransactions.get(id);
return (_db.select(_db.recurringTransactions)
..where((t) => t.id.equals(id))).getSingleOrNull();
}
/// Sucht wiederkehrende Transaktionen anhand der gegebenen Parameter
/// aus der Datenbank
/// Sucht wiederkehrende Transaktionen anhand der gegebenen Parameter
Future<List<RecurringTransaction>> findBy({
final int? id,
final String? name,
final DateTime? startDate,
final DateTime? startDateBefore,
final DateTime? startDateAfter,
final DateTime? startDateFrom,
final DateTime? startDateTo,
final TimeFrameEnum? timeFrame,
final double? amount,
final double? amountMin,
final double? amountMax,
final String? orderBy,
}) async {
final Isar isar = await _isarService.getDatabase();
final query = _db.select(_db.recurringTransactions);
final QueryBuilder<
RecurringTransaction,
RecurringTransaction,
QAfterFilterCondition
>
baseQuery = isar.recurringTransactions
.filter()
.optional(id != null, (final q) => q.idEqualTo(id!))
.optional(
name != null && name.isNotEmpty,
(final q) => q.nameMatches('*$name*', caseSensitive: false),
)
// --- StartDate Filter ---
.optional(startDate != null, (final q) => q.startDateEqualTo(startDate))
.optional(
startDateAfter != null,
(final q) => q.startDateGreaterThan(startDateAfter),
)
.optional(
startDateBefore != null,
(final q) => q.startDateLessThan(startDateBefore),
)
.optional(
startDateFrom != null && startDateTo != null,
(final q) => q.startDateBetween(startDateFrom, startDateTo),
)
// --- TimeFrame ---
.optional(
timeFrame != null,
(final q) => q.timeFrameEqualTo(timeFrame!),
)
// --- Amount Filter ---
.optional(amount != null, (final q) => q.amountEqualTo(amount!))
.optional(
amountMin != null && amountMax == null,
(final q) => q.amountGreaterThan(amountMin!),
)
.optional(
amountMin == null && amountMax != null,
(final q) => q.amountLessThan(amountMax!),
)
.optional(
amountMin != null && amountMax != null,
(final q) => q.amountBetween(amountMin!, amountMax!),
);
// --- Sortierung ---
switch (orderBy) {
case 'nameAsc':
return baseQuery.sortByName().findAll();
case 'nameDesc':
return baseQuery.sortByNameDesc().findAll();
case 'amountAsc':
return baseQuery.sortByAmount().findAll();
case 'amountDesc':
return baseQuery.sortByAmountDesc().findAll();
case 'startDateAsc':
return baseQuery.sortByStartDate().findAll();
case 'startDateDesc':
return baseQuery.sortByStartDateDesc().findAll();
default:
return baseQuery.findAll();
if (id != null) {
query.where((t) => t.id.equals(id));
}
if (name != null && name.isNotEmpty) {
query.where((t) => t.name.like('%$name%'));
}
if (startDate != null) {
query.where((t) => t.startDate.equals(startDate));
}
if (startDateAfter != null) {
query.where((t) => t.startDate.isBiggerThanValue(startDateAfter));
}
if (startDateBefore != null) {
query.where((t) => t.startDate.isSmallerThanValue(startDateBefore));
}
if (startDateFrom != null && startDateTo != null) {
query.where((t) =>
t.startDate.isBetweenValues(startDateFrom, startDateTo));
}
if (timeFrame != null) {
query.where((t) => t.timeFrame.equals(timeFrame.index));
}
if (amount != null) {
query.where((t) => t.amount.equals(amount));
}
if (amountMin != null) {
query.where((t) => t.amount.isBiggerThanValue(amountMin));
}
if (amountMax != null) {
query.where((t) => t.amount.isSmallerThanValue(amountMax));
}
if (orderBy != null) {
switch (orderBy) {
case 'nameAsc':
query.orderBy([(t) => OrderingTerm.asc(t.name)]);
break;
case 'nameDesc':
query.orderBy([(t) => OrderingTerm.desc(t.name)]);
break;
case 'amountAsc':
query.orderBy([(t) => OrderingTerm.asc(t.amount)]);
break;
case 'amountDesc':
query.orderBy([(t) => OrderingTerm.desc(t.amount)]);
break;
case 'startDateAsc':
query.orderBy([(t) => OrderingTerm.asc(t.startDate)]);
break;
case 'startDateDesc':
query.orderBy([(t) => OrderingTerm.desc(t.startDate)]);
break;
}
}
return query.get();
}
}