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

lib/Repositories/account_repository.dart

@@ -1,32 +1,28 @@
-import 'package:isar/isar.dart';
+import 'package:drift/drift.dart';
 
-import '../Entities/account.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 Konten
 class AccountRepository {
-  final IsarService _isarService = IsarService();
+  final AppDatabase _db = DatabaseService().database;
 
   /// Fügt ein neues Konto zur Datenbank hinzu
-  Future<Account?> add(final Account account) async {
-    final Isar isar = await _isarService.getDatabase();
-
-    final int id = await isar.writeTxn(() => isar.accounts.put(account));
-
+  Future<Account?> add(final AccountsCompanion account) async {
+    final int id = await _db.into(_db.accounts).insert(account);
     return find(id);
   }
 
   /// Entfernt ein Konto aus der Datenbank
-  Future<bool> remove(final Account account) async {
-    final Isar isar = await _isarService.getDatabase();
-    return isar.writeTxn(() => isar.accounts.delete(account.id));
+  Future<int> remove(final Account account) async {
+    return (_db.delete(_db.accounts)
+      ..where((t) => t.id.equals(account.id))).go();
   }
 
   /// Sucht ein Konto anhand seiner Id aus der Datenbank
   Future<Account?> find(final int id) async {
-    final Isar isar = await _isarService.getDatabase();
-
-    return isar.accounts.get(id);
+    return (_db.select(_db.accounts)
+      ..where((t) => t.id.equals(id))).getSingleOrNull();
   }
 
   /// Sucht Konten anhand der gegebenen Parameter aus der Datenbank
@@ -35,31 +31,27 @@ class AccountRepository {
     final String? name,
     final String? orderBy,
   }) async {
-    final Isar isar = await _isarService.getDatabase();
+    final query = _db.select(_db.accounts);
 
-    final QueryBuilder<Account, Account, QAfterFilterCondition> baseQuery = isar
-        .accounts
-        .filter()
-        .optional(
-          id != null,
-          (final QueryBuilder<Account, Account, QFilterCondition> q) =>
-              q.idEqualTo(id!),
-        )
-        .optional(
-          name != null && name.isNotEmpty,
-          (final QueryBuilder<Account, Account, QAfterFilterCondition> q) =>
-              q.nameMatches('*$name*', caseSensitive: false),
-        );
-
-    switch (orderBy) {
-      case 'nameAsc':
-        return baseQuery.sortByName().findAll();
-
-      case 'nameDesc':
-        return baseQuery.sortByNameDesc().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 (orderBy != null) {
+      switch (orderBy) {
+        case 'nameAsc':
+          query.orderBy([(t) => OrderingTerm.asc(t.name)]);
+          break;
+        case 'nameDesc':
+          query.orderBy([(t) => OrderingTerm.desc(t.name)]);
+          break;
+      }
+    }
+
+    return query.get();
   }
 }

lib/Repositories/recurring_transacation_repository.dart

@@ -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();
   }
 }

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();
   }
 }