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

lib/Repositories/transaction_repository.dart

@@ -1,34 +1,28 @@
-import 'package:isar/isar.dart';
+import 'package:drift/drift.dart';
 
-import '../Entities/transaction.dart';
-import '../Services/isar_service.dart';
+import '../Entities/drift_database.dart';
+import '../Services/database_service.dart';
 
 /// Funktionen zum interagieren mit der Datenbank für die Transaktionen
 class TransactionRepository {
-  final IsarService _isarService = IsarService();
+  final AppDatabase _db = DatabaseService().database;
 
   /// Fügt eine neue Transaktion zur Datenbank hinzu
-  Future<Transaction?> add(final Transaction transaction) async {
-    final Isar isar = await _isarService.getDatabase();
-
-    final int id = await isar.writeTxn(
-      () => isar.transactions.put(transaction),
-    );
-
+  Future<Transaction?> add(final TransactionsCompanion transaction) async {
+    final int id = await _db.into(_db.transactions).insert(transaction);
     return find(id);
   }
 
   /// Entfernt eine Transaktion aus der Datenbank
-  Future<bool> remove(final Transaction transaction) async {
-    final Isar isar = await _isarService.getDatabase();
-    return isar.writeTxn(() => isar.transactions.delete(transaction.id));
+  Future<int> remove(final Transaction transaction) async {
+    return (_db.delete(_db.transactions)
+      ..where((t) => t.id.equals(transaction.id))).go();
   }
 
   /// Sucht eine Transaktion anhand seiner Id aus der Datenbank
   Future<Transaction?> find(final int id) async {
-    final Isar isar = await _isarService.getDatabase();
-
-    return isar.transactions.get(id);
+    return (_db.select(_db.transactions)
+      ..where((t) => t.id.equals(id))).getSingleOrNull();
   }
 
   /// Sucht Transaktionen anhand der gegebenen Parameter aus der Datenbank
@@ -43,85 +37,63 @@ class TransactionRepository {
     final double? amountMax,
     final String? orderBy,
   }) async {
-    final Isar isar = await _isarService.getDatabase();
+    final query = _db.select(_db.transactions);
 
-    final QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
-    baseQuery = isar.transactions
-        .filter()
-        .optional(
-          id != null,
-          (final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
-              q.idEqualTo(id!),
-        )
-        .optional(
-          name != null && name.isNotEmpty,
-          (
-            final QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
-            q,
-          ) => q.nameMatches('*$name*', caseSensitive: false),
-        )
-        .optional(
-          date != null,
-          (final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
-              q.dateEqualTo(date),
-        )
-        .optional(
-          dateBefore != null && dateAfter == null,
-          (final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
-              q.dateGreaterThan(dateBefore),
-        )
-        .optional(
-          dateBefore == null && dateAfter != null,
-          (final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
-              q.dateLessThan(dateAfter),
-        )
-        .optional(
-          dateBefore != null && dateAfter != null,
-          (final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
-              q.dateBetween(dateBefore, dateAfter),
-        )
-        .optional(
-          amount != null,
-          (final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
-              q.amountEqualTo(amount!),
-        )
-        .optional(
-          amountMin != null && amountMax == null,
-          (final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
-              q.amountGreaterThan(amountMin!),
-        )
-        .optional(
-          amountMin == null && amountMax != null,
-          (final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
-              q.amountLessThan(amountMax!),
-        )
-        .optional(
-          amountMin != null && amountMax != null,
-          (final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
-              q.amountBetween(amountMin!, amountMax!),
-        );
-
-    switch (orderBy) {
-      case 'nameAsc':
-        return baseQuery.sortByName().findAll();
-
-      case 'nameDesc':
-        return baseQuery.sortByNameDesc().findAll();
-
-      case 'dateAsc':
-        return baseQuery.sortByDate().findAll();
-
-      case 'dateDesc':
-        return baseQuery.sortByDateDesc().findAll();
-
-      case 'amountAsc':
-        return baseQuery.sortByAmount().findAll();
-
-      case 'amountDesc':
-        return baseQuery.sortByAmountDesc().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 (date != null) {
+      query.where((t) => t.date.equals(date));
+    }
+
+    if (dateBefore != null) {
+      query.where((t) => t.date.isBiggerThanValue(dateBefore));
+    }
+
+    if (dateAfter != null) {
+      query.where((t) => t.date.isSmallerThanValue(dateAfter));
+    }
+
+    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 'dateAsc':
+          query.orderBy([(t) => OrderingTerm.asc(t.date)]);
+          break;
+        case 'dateDesc':
+          query.orderBy([(t) => OrderingTerm.desc(t.date)]);
+          break;
+        case 'amountAsc':
+          query.orderBy([(t) => OrderingTerm.asc(t.amount)]);
+          break;
+        case 'amountDesc':
+          query.orderBy([(t) => OrderingTerm.desc(t.amount)]);
+          break;
+      }
+    }
+
+    return query.get();
   }
 }