Feat: Fügt eine Verknüpfung der Transaktionen mit den Konten hinzu

lib/Entities/account.dart

@@ -1,5 +1,8 @@
 import 'package:isar/isar.dart';
 
+import 'recurring_transaction.dart';
+import 'transaction.dart';
+
 part 'account.g.dart';
 
 /// Die Klasse stellt ein Konto dar.
@@ -11,6 +14,17 @@ class Account {
   /// Der Name des Kontos
   String name = '';
 
+  /// Stellt die Transaktionen dar,
+  /// die mit diesem Konto verknüpft sind.
+  @Backlink(to: 'account')
+  final IsarLinks<Transaction> transactions = IsarLinks<Transaction>();
+
+  /// Stellt die wiederkehrenden Transaktionen dar,
+  /// die mit diesem Konto verknüpft sind.
+  @Backlink(to: 'account')
+  final IsarLinks<RecurringTransaction> recurringTransactions =
+      IsarLinks<RecurringTransaction>();
+
   @override
   String toString() => '${super.toString()}($id: $name)';
 }

lib/Entities/account.g.dart

@@ -29,7 +29,22 @@ const AccountSchema = CollectionSchema(
   deserializeProp: _accountDeserializeProp,
   idName: r'id',
   indexes: {},
-  links: {},
+  links: {
+    r'transactions': LinkSchema(
+      id: 320079441438939175,
+      name: r'transactions',
+      target: r'Transaction',
+      single: false,
+      linkName: r'account',
+    ),
+    r'recurringTransactions': LinkSchema(
+      id: 3985469729442003270,
+      name: r'recurringTransactions',
+      target: r'RecurringTransaction',
+      single: false,
+      linkName: r'account',
+    )
+  },
   embeddedSchemas: {},
   getId: _accountGetId,
   getLinks: _accountGetLinks,
@@ -87,11 +102,18 @@ Id _accountGetId(Account object) {
 }
 
 List<IsarLinkBase<dynamic>> _accountGetLinks(Account object) {
-  return [];
+  return [object.transactions, object.recurringTransactions];
 }
 
 void _accountAttach(IsarCollection<dynamic> col, Id id, Account object) {
   object.id = id;
+  object.transactions
+      .attach(col, col.isar.collection<Transaction>(), r'transactions', id);
+  object.recurringTransactions.attach(
+      col,
+      col.isar.collection<RecurringTransaction>(),
+      r'recurringTransactions',
+      id);
 }
 
 extension AccountQueryWhereSort on QueryBuilder<Account, Account, QWhere> {
@@ -358,7 +380,125 @@ extension AccountQueryObject
     on QueryBuilder<Account, Account, QFilterCondition> {}
 
 extension AccountQueryLinks
-    on QueryBuilder<Account, Account, QFilterCondition> {}
+on QueryBuilder<Account, Account, QFilterCondition> {
+  QueryBuilder<Account, Account, QAfterFilterCondition> transactions(
+      FilterQuery<Transaction> q) {
+    return QueryBuilder.apply(this, (query) {
+      return query.link(q, r'transactions');
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition>
+  transactionsLengthEqualTo(int length) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', length, true, length, true);
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition> transactionsIsEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', 0, true, 0, true);
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition>
+  transactionsIsNotEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', 0, false, 999999, true);
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition>
+  transactionsLengthLessThan(int length, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', 0, true, length, include);
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition>
+  transactionsLengthGreaterThan(int length, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', length, include, 999999, true);
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition>
+  transactionsLengthBetween(int lower,
+      int upper, {
+        bool includeLower = true,
+        bool includeUpper = true,
+      }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(
+          r'transactions', lower, includeLower, upper, includeUpper);
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition> recurringTransactions(
+      FilterQuery<RecurringTransaction> q) {
+    return QueryBuilder.apply(this, (query) {
+      return query.link(q, r'recurringTransactions');
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition>
+  recurringTransactionsLengthEqualTo(int length) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(
+          r'recurringTransactions', length, true, length, true);
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition>
+  recurringTransactionsIsEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'recurringTransactions', 0, true, 0, true);
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition>
+  recurringTransactionsIsNotEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'recurringTransactions', 0, false, 999999, true);
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition>
+  recurringTransactionsLengthLessThan(int length, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(
+          r'recurringTransactions', 0, true, length, include);
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition>
+  recurringTransactionsLengthGreaterThan(int length, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(
+          r'recurringTransactions', length, include, 999999, true);
+    });
+  }
+
+  QueryBuilder<Account, Account, QAfterFilterCondition>
+  recurringTransactionsLengthBetween(int lower,
+      int upper, {
+        bool includeLower = true,
+        bool includeUpper = true,
+      }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(
+          r'recurringTransactions', lower, includeLower, upper, includeUpper);
+    });
+  }
+}
 
 extension AccountQuerySortBy on QueryBuilder<Account, Account, QSortBy> {
   QueryBuilder<Account, Account, QAfterSortBy> sortByName() {

lib/Entities/recurring_transaction.dart

@@ -1,5 +1,6 @@
 import 'package:isar/isar.dart';
 
+import 'account.dart';
 import 'time_frame_enum.dart';
 import 'transaction.dart';
 
@@ -28,4 +29,10 @@ class RecurringTransaction {
   /// die mit dieser wiederkehrenden verknüpft sind.
   @Backlink(to: 'recurringTransaction')
   final IsarLinks<Transaction> transactions = IsarLinks<Transaction>();
+
+  /// Stellt das Konto dar, zu welchem diese wiederkehrende Transaktion gehört.
+  final IsarLink<Account> account = IsarLink<Account>();
+
+  @override
+  String toString() => '${super.toString()}($id: $name)';
 }

lib/Entities/recurring_transaction.g.dart

@@ -53,6 +53,12 @@ const RecurringTransactionSchema = CollectionSchema(
       target: r'Transaction',
       single: false,
       linkName: r'recurringTransaction',
+    ),
+    r'account': LinkSchema(
+      id: -6028551496614242115,
+      name: r'account',
+      target: r'Account',
+      single: true,
     )
   },
   embeddedSchemas: {},
@@ -142,7 +148,7 @@ Id _recurringTransactionGetId(RecurringTransaction object) {
 
 List<IsarLinkBase<dynamic>> _recurringTransactionGetLinks(
     RecurringTransaction object) {
-  return [object.transactions];
+  return [object.transactions, object.account];
 }
 
 void _recurringTransactionAttach(IsarCollection<dynamic> col, Id id,
@@ -150,6 +156,7 @@ void _recurringTransactionAttach(IsarCollection<dynamic> col, Id id,
   object.id = id;
   object.transactions
       .attach(col, col.isar.collection<Transaction>(), r'transactions', id);
+  object.account.attach(col, col.isar.collection<Account>(), r'account', id);
 }
 
 extension RecurringTransactionQueryWhereSort
@@ -716,6 +723,22 @@ extension RecurringTransactionQueryLinks on QueryBuilder<RecurringTransaction,
           r'transactions', lower, includeLower, upper, includeUpper);
     });
   }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> account(FilterQuery<Account> q) {
+    return QueryBuilder.apply(this, (query) {
+      return query.link(q, r'account');
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> accountIsNull() {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'account', 0, true, 0, true);
+    });
+  }
 }
 
 extension RecurringTransactionQuerySortBy

lib/Entities/transaction.dart

@@ -1,5 +1,6 @@
 import 'package:isar/isar.dart';
 
+import 'account.dart';
 import 'recurring_transaction.dart';
 
 part 'transaction.g.dart';
@@ -23,4 +24,10 @@ class Transaction {
   /// zu welcher diese Transaktion gehört.
   final IsarLink<RecurringTransaction> recurringTransaction =
       IsarLink<RecurringTransaction>();
+
+  /// Stellt das Konto dar, zu welchem diese Transaktion gehört.
+  final IsarLink<Account> account = IsarLink<Account>();
+
+  @override
+  String toString() => '${super.toString()}($id: $name)';
 }

lib/Entities/transaction.g.dart

@@ -45,6 +45,12 @@ const TransactionSchema = CollectionSchema(
       name: r'recurringTransaction',
       target: r'RecurringTransaction',
       single: true,
+    ),
+    r'account': LinkSchema(
+      id: -8467990729867616553,
+      name: r'account',
+      target: r'Account',
+      single: true,
     )
   },
   embeddedSchemas: {},
@@ -112,7 +118,7 @@ Id _transactionGetId(Transaction object) {
 }
 
 List<IsarLinkBase<dynamic>> _transactionGetLinks(Transaction object) {
-  return [object.recurringTransaction];
+  return [object.recurringTransaction, object.account];
 }
 
 void _transactionAttach(IsarCollection<dynamic> col, Id id,
@@ -120,6 +126,7 @@ void _transactionAttach(IsarCollection<dynamic> col, Id id,
   object.id = id;
   object.recurringTransaction.attach(col,
       col.isar.collection<RecurringTransaction>(), r'recurringTransaction', id);
+  object.account.attach(col, col.isar.collection<Account>(), r'account', id);
 }
 
 extension TransactionQueryWhereSort
@@ -538,6 +545,20 @@ on QueryBuilder<Transaction, Transaction, QFilterCondition> {
       return query.linkLength(r'recurringTransaction', 0, true, 0, true);
     });
   }
+
+  QueryBuilder<Transaction, Transaction, QAfterFilterCondition> account(
+      FilterQuery<Account> q) {
+    return QueryBuilder.apply(this, (query) {
+      return query.link(q, r'account');
+    });
+  }
+
+  QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
+  accountIsNull() {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'account', 0, true, 0, true);
+    });
+  }
 }
 
 extension TransactionQuerySortBy