From 92fec89333a0cba63e04421110ff95ae0965f86a Mon Sep 17 00:00:00 2001 From: DragonSlayer_14 Date: Mon, 22 Dec 2025 03:33:37 +0100 Subject: [PATCH] =?UTF-8?q?Feat:=20F=C3=BCgt=20IsarService=20und=20Reposit?= =?UTF-8?q?ories=20hinzu?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lib/Repositories/account_repository.dart | 65 +++++++++ .../recurring_transacation_repository.dart | 132 ++++++++++++++++++ lib/Repositories/transaction_repository.dart | 127 +++++++++++++++++ lib/Services/isar_service.dart | 40 ++++++ 4 files changed, 364 insertions(+) create mode 100644 lib/Repositories/account_repository.dart create mode 100644 lib/Repositories/recurring_transacation_repository.dart create mode 100644 lib/Repositories/transaction_repository.dart create mode 100644 lib/Services/isar_service.dart diff --git a/lib/Repositories/account_repository.dart b/lib/Repositories/account_repository.dart new file mode 100644 index 0000000..b74357e --- /dev/null +++ b/lib/Repositories/account_repository.dart @@ -0,0 +1,65 @@ +import 'package:isar/isar.dart'; + +import '../Entities/account.dart'; +import '../Services/isar_service.dart'; + +/// Funktionen zum interagieren mit der Datenbank für die Konten +class AccountRepository { + final IsarService _isarService = IsarService(); + + /// Fügt ein neues Konto zur Datenbank hinzu + Future add(final Account account) async { + final Isar isar = await _isarService.getDatabase(); + + final int id = await isar.writeTxn(() => isar.accounts.put(account)); + + return find(id); + } + + /// Entfernt ein Konto aus der Datenbank + Future remove(final Account account) async { + final Isar isar = await _isarService.getDatabase(); + return isar.writeTxn(() => isar.accounts.delete(account.id)); + } + + /// Sucht ein Konto anhand seiner Id aus der Datenbank + Future find(final int id) async { + final Isar isar = await _isarService.getDatabase(); + + return isar.accounts.get(id); + } + + /// Sucht Konten anhand der gegebenen Parameter aus der Datenbank + Future> findBy({ + final int? id, + final String? name, + final String? orderBy, + }) async { + final Isar isar = await _isarService.getDatabase(); + + final QueryBuilder baseQuery = isar + .accounts + .filter() + .optional( + id != null, + (final QueryBuilder q) => + q.idEqualTo(id!), + ) + .optional( + name != null && name.isNotEmpty, + (final QueryBuilder q) => + q.nameMatches('*$name*', caseSensitive: false), + ); + + switch (orderBy) { + case 'nameAsc': + return baseQuery.sortByName().findAll(); + + case 'nameDesc': + return baseQuery.sortByNameDesc().findAll(); + + default: + return baseQuery.findAll(); + } + } +} diff --git a/lib/Repositories/recurring_transacation_repository.dart b/lib/Repositories/recurring_transacation_repository.dart new file mode 100644 index 0000000..7072f90 --- /dev/null +++ b/lib/Repositories/recurring_transacation_repository.dart @@ -0,0 +1,132 @@ +import 'package:isar/isar.dart'; + +import '../Entities/recurring_transaction.dart'; +import '../Entities/time_frame_enum.dart'; +import '../Services/isar_service.dart'; + +/// Funktionen zum interagieren mit der Datenbank für die Transaktionen +class RecurringTransactionRepository { + final IsarService _isarService = IsarService(); + + /// Fügt eine neue wiederkehrende Transaktion zur Datenbank hinzu + Future add( + final RecurringTransaction recurringTransaction, + ) async { + final Isar isar = await _isarService.getDatabase(); + + final int id = await isar.writeTxn( + () => isar.recurringTransactions.put(recurringTransaction), + ); + + return find(id); + } + + /// Entfernt eine wiederkehrende Transaktion aus der Datenbank + Future remove(final RecurringTransaction recurringTransaction) async { + final Isar isar = await _isarService.getDatabase(); + return isar.writeTxn( + () => isar.recurringTransactions.delete(recurringTransaction.id), + ); + } + + /// Sucht eine wiederkehrende Transaktion anhand seiner Id aus der Datenbank + Future find(final int id) async { + final Isar isar = await _isarService.getDatabase(); + + return isar.recurringTransactions.get(id); + } + + /// Sucht wiederkehrende Transaktionen anhand der gegebenen Parameter + /// aus der Datenbank + /// Sucht wiederkehrende Transaktionen anhand der gegebenen Parameter + Future> 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 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(); + } + } +} diff --git a/lib/Repositories/transaction_repository.dart b/lib/Repositories/transaction_repository.dart new file mode 100644 index 0000000..a66afc4 --- /dev/null +++ b/lib/Repositories/transaction_repository.dart @@ -0,0 +1,127 @@ +import 'package:isar/isar.dart'; + +import '../Entities/transaction.dart'; +import '../Services/isar_service.dart'; + +/// Funktionen zum interagieren mit der Datenbank für die Transaktionen +class TransactionRepository { + final IsarService _isarService = IsarService(); + + /// Fügt eine neue Transaktion zur Datenbank hinzu + Future add(final Transaction transaction) async { + final Isar isar = await _isarService.getDatabase(); + + final int id = await isar.writeTxn( + () => isar.transactions.put(transaction), + ); + + return find(id); + } + + /// Entfernt eine Transaktion aus der Datenbank + Future remove(final Transaction transaction) async { + final Isar isar = await _isarService.getDatabase(); + return isar.writeTxn(() => isar.transactions.delete(transaction.id)); + } + + /// Sucht eine Transaktion anhand seiner Id aus der Datenbank + Future find(final int id) async { + final Isar isar = await _isarService.getDatabase(); + + return isar.transactions.get(id); + } + + /// Sucht Transaktionen anhand der gegebenen Parameter aus der Datenbank + Future> findBy({ + final int? id, + final String? name, + final DateTime? date, + final DateTime? dateBefore, + final DateTime? dateAfter, + final double? amount, + final double? amountMin, + final double? amountMax, + final String? orderBy, + }) async { + final Isar isar = await _isarService.getDatabase(); + + final QueryBuilder + baseQuery = isar.transactions + .filter() + .optional( + id != null, + (final QueryBuilder q) => + q.idEqualTo(id!), + ) + .optional( + name != null && name.isNotEmpty, + ( + final QueryBuilder + q, + ) => q.nameMatches('*$name*', caseSensitive: false), + ) + .optional( + date != null, + (final QueryBuilder q) => + q.dateEqualTo(date), + ) + .optional( + dateBefore != null && dateAfter == null, + (final QueryBuilder q) => + q.dateGreaterThan(dateBefore), + ) + .optional( + dateBefore == null && dateAfter != null, + (final QueryBuilder q) => + q.dateLessThan(dateAfter), + ) + .optional( + dateBefore != null && dateAfter != null, + (final QueryBuilder q) => + q.dateBetween(dateBefore, dateAfter), + ) + .optional( + amount != null, + (final QueryBuilder q) => + q.amountEqualTo(amount!), + ) + .optional( + amountMin != null && amountMax == null, + (final QueryBuilder q) => + q.amountGreaterThan(amountMin!), + ) + .optional( + amountMin == null && amountMax != null, + (final QueryBuilder q) => + q.amountLessThan(amountMax!), + ) + .optional( + amountMin != null && amountMax != null, + (final QueryBuilder 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(); + } + } +} diff --git a/lib/Services/isar_service.dart b/lib/Services/isar_service.dart new file mode 100644 index 0000000..ffad81d --- /dev/null +++ b/lib/Services/isar_service.dart @@ -0,0 +1,40 @@ +import 'dart:io'; + +import 'package:isar/isar.dart'; +import 'package:path_provider/path_provider.dart'; + +import '../Entities/account.dart'; +import '../Entities/recurring_transaction.dart'; +import '../Entities/transaction.dart'; + +/// Ein Service um auf die Datenbank zuzugreifen +class IsarService { + /// Gibt eine gültige Instanz der Klasse zurück + factory IsarService() => _instance; + + /// Initialisiert eine neue Instanz dieser Klasse + IsarService._internal(); + + static final _instance = IsarService._internal(); + + Isar? _isar; + + /// Gibt die Datenbank zurück. + Future getDatabase() async { + if (_isar == null) { + await _initializeDatabase(); + } + + return _isar!; + } + + /// Initialisiert die Datenbank + Future _initializeDatabase() async { + final Directory dir = await getApplicationDocumentsDirectory(); + _isar = await Isar.open([ + AccountSchema, + TransactionSchema, + RecurringTransactionSchema, + ], directory: dir.path); + } +}