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

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() {