Feat: Fügt eine 1:n Beziehung zwischen RecurringTransaction und Transaction hinzu

lib/Entities/account.g.dart

@@ -17,7 +17,11 @@ const AccountSchema = CollectionSchema(
   name: r'Account',
   id: -6646797162501847804,
   properties: {
-    r'name': PropertySchema(id: 0, name: r'name', type: IsarType.string),
+    r'name': PropertySchema(
+      id: 0,
+      name: r'name',
+      type: IsarType.string,
+    )
   },
   estimateSize: _accountEstimateSize,
   serialize: _accountSerialize,
@@ -101,7 +105,10 @@ extension AccountQueryWhereSort on QueryBuilder<Account, Account, QWhere> {
 extension AccountQueryWhere on QueryBuilder<Account, Account, QWhereClause> {
   QueryBuilder<Account, Account, QAfterWhereClause> idEqualTo(Id id) {
     return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(IdWhereClause.between(lower: id, upper: id));
+      return query.addWhereClause(IdWhereClause.between(
+        lower: id,
+        upper: id,
+      ));
     });
   }
 
@@ -127,10 +134,8 @@ extension AccountQueryWhere on QueryBuilder<Account, Account, QWhereClause> {
     });
   }
 
-  QueryBuilder<Account, Account, QAfterWhereClause> idGreaterThan(
+  QueryBuilder<Account, Account, QAfterWhereClause> idGreaterThan(Id id,
-    Id id, {
+      {bool include = false}) {
-    bool include = false,
-  }) {
     return QueryBuilder.apply(this, (query) {
       return query.addWhereClause(
         IdWhereClause.greaterThan(lower: id, includeLower: include),
@@ -138,10 +143,8 @@ extension AccountQueryWhere on QueryBuilder<Account, Account, QWhereClause> {
     });
   }
 
-  QueryBuilder<Account, Account, QAfterWhereClause> idLessThan(
+  QueryBuilder<Account, Account, QAfterWhereClause> idLessThan(Id id,
-    Id id, {
+      {bool include = false}) {
-    bool include = false,
-  }) {
     return QueryBuilder.apply(this, (query) {
       return query.addWhereClause(
         IdWhereClause.lessThan(upper: id, includeUpper: include),
@@ -156,14 +159,12 @@ extension AccountQueryWhere on QueryBuilder<Account, Account, QWhereClause> {
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(
+      return query.addWhereClause(IdWhereClause.between(
-        IdWhereClause.between(
+        lower: lowerId,
-          lower: lowerId,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upperId,
-          upper: upperId,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+      ));
-        ),
-      );
     });
   }
 }
@@ -172,9 +173,10 @@ extension AccountQueryFilter
     on QueryBuilder<Account, Account, QFilterCondition> {
   QueryBuilder<Account, Account, QAfterFilterCondition> idEqualTo(Id value) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(property: r'id', value: value),
+        property: r'id',
-      );
+        value: value,
+      ));
     });
   }
 
@@ -183,13 +185,11 @@ extension AccountQueryFilter
     bool include = false,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(
+        include: include,
-          include: include,
+        property: r'id',
-          property: r'id',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
@@ -198,13 +198,11 @@ extension AccountQueryFilter
     bool include = false,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.lessThan(
-        FilterCondition.lessThan(
+        include: include,
-          include: include,
+        property: r'id',
-          property: r'id',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
@@ -215,15 +213,13 @@ extension AccountQueryFilter
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.between(
-        FilterCondition.between(
+        property: r'id',
-          property: r'id',
+        lower: lower,
-          lower: lower,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upper,
-          upper: upper,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+      ));
-        ),
-      );
     });
   }
 
@@ -232,13 +228,11 @@ extension AccountQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
@@ -248,14 +242,12 @@ extension AccountQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(
+        include: include,
-          include: include,
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
@@ -265,14 +257,12 @@ extension AccountQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.lessThan(
-        FilterCondition.lessThan(
+        include: include,
-          include: include,
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
@@ -284,16 +274,14 @@ extension AccountQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.between(
-        FilterCondition.between(
+        property: r'name',
-          property: r'name',
+        lower: lower,
-          lower: lower,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upper,
-          upper: upper,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
@@ -302,13 +290,11 @@ extension AccountQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.startsWith(
-        FilterCondition.startsWith(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
@@ -317,59 +303,53 @@ extension AccountQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.endsWith(
-        FilterCondition.endsWith(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
   QueryBuilder<Account, Account, QAfterFilterCondition> nameContains(
-    String value, {
+      String value,
-    bool caseSensitive = true,
+      {bool caseSensitive = true}) {
-  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.contains(
-        FilterCondition.contains(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
   QueryBuilder<Account, Account, QAfterFilterCondition> nameMatches(
-    String pattern, {
+      String pattern,
-    bool caseSensitive = true,
+      {bool caseSensitive = true}) {
-  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.matches(
-        FilterCondition.matches(
+        property: r'name',
-          property: r'name',
+        wildcard: pattern,
-          wildcard: pattern,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
   QueryBuilder<Account, Account, QAfterFilterCondition> nameIsEmpty() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(property: r'name', value: ''),
+        property: r'name',
-      );
+        value: '',
+      ));
     });
   }
 
   QueryBuilder<Account, Account, QAfterFilterCondition> nameIsNotEmpty() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(property: r'name', value: ''),
+        property: r'name',
-      );
+        value: '',
+      ));
     });
   }
 }
@@ -423,9 +403,8 @@ extension AccountQuerySortThenBy
 
 extension AccountQueryWhereDistinct
     on QueryBuilder<Account, Account, QDistinct> {
-  QueryBuilder<Account, Account, QDistinct> distinctByName({
+  QueryBuilder<Account, Account, QDistinct> distinctByName(
-    bool caseSensitive = true,
+      {bool caseSensitive = true}) {
-  }) {
     return QueryBuilder.apply(this, (query) {
       return query.addDistinctBy(r'name', caseSensitive: caseSensitive);
     });

lib/Entities/recurring_transaction.dart

@@ -1,6 +1,7 @@
 import 'package:isar/isar.dart';
 
 import 'time_frame_enum.dart';
+import 'transaction.dart';
 
 part 'recurring_transaction.g.dart';
 
@@ -22,4 +23,9 @@ class RecurringTransaction {
 
   /// Die Höhe der wiederkehrenden Transaktion
   double amount = 0;
+
+  /// Stellt die Transaktionen dar,
+  /// die mit dieser wiederkehrenden verknüpft sind.
+  @Backlink(to: 'recurringTransaction')
+  final IsarLinks<Transaction> transactions = IsarLinks<Transaction>();
 }

lib/Entities/recurring_transaction.g.dart

@@ -18,8 +18,16 @@ const RecurringTransactionSchema = CollectionSchema(
   name: r'RecurringTransaction',
   id: 969840479390105118,
   properties: {
-    r'amount': PropertySchema(id: 0, name: r'amount', type: IsarType.double),
+    r'amount': PropertySchema(
-    r'name': PropertySchema(id: 1, name: r'name', type: IsarType.string),
+      id: 0,
+      name: r'amount',
+      type: IsarType.double,
+    ),
+    r'name': PropertySchema(
+      id: 1,
+      name: r'name',
+      type: IsarType.string,
+    ),
     r'startDate': PropertySchema(
       id: 2,
       name: r'startDate',
@@ -30,7 +38,7 @@ const RecurringTransactionSchema = CollectionSchema(
       name: r'timeFrame',
       type: IsarType.byte,
       enumMap: _RecurringTransactiontimeFrameEnumValueMap,
-    ),
+    )
   },
   estimateSize: _recurringTransactionEstimateSize,
   serialize: _recurringTransactionSerialize,
@@ -38,7 +46,15 @@ const RecurringTransactionSchema = CollectionSchema(
   deserializeProp: _recurringTransactionDeserializeProp,
   idName: r'id',
   indexes: {},
-  links: {},
+  links: {
+    r'transactions': LinkSchema(
+      id: 459560147514286496,
+      name: r'transactions',
+      target: r'Transaction',
+      single: false,
+      linkName: r'recurringTransaction',
+    )
+  },
   embeddedSchemas: {},
   getId: _recurringTransactionGetId,
   getLinks: _recurringTransactionGetLinks,
@@ -79,10 +95,8 @@ RecurringTransaction _recurringTransactionDeserialize(
   object.id = id;
   object.name = reader.readString(offsets[1]);
   object.startDate = reader.readDateTimeOrNull(offsets[2]);
-  object.timeFrame =
+  object.timeFrame = _RecurringTransactiontimeFrameValueEnumMap[
-      _RecurringTransactiontimeFrameValueEnumMap[reader.readByteOrNull(
+  reader.readByteOrNull(offsets[3])] ??
-        offsets[3],
-      )] ??
       TimeFrameEnum.daily;
   return object;
 }
@@ -101,11 +115,9 @@ P _recurringTransactionDeserializeProp<P>(
     case 2:
       return (reader.readDateTimeOrNull(offset)) as P;
     case 3:
-      return (_RecurringTransactiontimeFrameValueEnumMap[reader.readByteOrNull(
+      return (_RecurringTransactiontimeFrameValueEnumMap[
-                offset,
+      reader.readByteOrNull(offset)] ??
-              )] ??
+          TimeFrameEnum.daily) as P;
-              TimeFrameEnum.daily)
-          as P;
     default:
       throw IsarError('Unknown property with id $propertyId');
   }
@@ -129,17 +141,15 @@ Id _recurringTransactionGetId(RecurringTransaction object) {
 }
 
 List<IsarLinkBase<dynamic>> _recurringTransactionGetLinks(
-  RecurringTransaction object,
+    RecurringTransaction object) {
-) {
+  return [object.transactions];
-  return [];
 }
 
-void _recurringTransactionAttach(
+void _recurringTransactionAttach(IsarCollection<dynamic> col, Id id,
-  IsarCollection<dynamic> col,
+    RecurringTransaction object) {
-  Id id,
-  RecurringTransaction object,
-) {
   object.id = id;
+  object.transactions
+      .attach(col, col.isar.collection<Transaction>(), r'transactions', id);
 }
 
 extension RecurringTransactionQueryWhereSort
@@ -157,7 +167,10 @@ extension RecurringTransactionQueryWhere
   QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterWhereClause>
   idEqualTo(Id id) {
     return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(IdWhereClause.between(lower: id, upper: id));
+      return query.addWhereClause(IdWhereClause.between(
+        lower: id,
+        upper: id,
+      ));
     });
   }
 
@@ -210,92 +223,70 @@ extension RecurringTransactionQueryWhere
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(
+      return query.addWhereClause(IdWhereClause.between(
-        IdWhereClause.between(
+        lower: lowerId,
-          lower: lowerId,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upperId,
-          upper: upperId,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+      ));
-        ),
-      );
     });
   }
 }
 
-extension RecurringTransactionQueryFilter
+extension RecurringTransactionQueryFilter on QueryBuilder<RecurringTransaction,
-    on
-        QueryBuilder<
-          RecurringTransaction,
-          RecurringTransaction,
-          QFilterCondition
-        > {
-  QueryBuilder<
     RecurringTransaction,
-    RecurringTransaction,
+    QFilterCondition> {
-    QAfterFilterCondition
+  QueryBuilder<RecurringTransaction,
-  >
+      RecurringTransaction,
-  amountEqualTo(double value, {double epsilon = Query.epsilon}) {
+      QAfterFilterCondition> amountEqualTo(double value, {
+    double epsilon = Query.epsilon,
+  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(
+        property: r'amount',
-          property: r'amount',
+        value: value,
-          value: value,
+        epsilon: epsilon,
-          epsilon: epsilon,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> amountGreaterThan(
-    QAfterFilterCondition
-  >
-  amountGreaterThan(
     double value, {
     bool include = false,
     double epsilon = Query.epsilon,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(
+        include: include,
-          include: include,
+        property: r'amount',
-          property: r'amount',
+        value: value,
-          value: value,
+        epsilon: epsilon,
-          epsilon: epsilon,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> amountLessThan(
-    QAfterFilterCondition
-  >
-  amountLessThan(
     double value, {
     bool include = false,
     double epsilon = Query.epsilon,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.lessThan(
-        FilterCondition.lessThan(
+        include: include,
-          include: include,
+        property: r'amount',
-          property: r'amount',
+        value: value,
-          value: value,
+        epsilon: epsilon,
-          epsilon: epsilon,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> amountBetween(
-    QAfterFilterCondition
-  >
-  amountBetween(
     double lower,
     double upper, {
     bool includeLower = true,
@@ -303,157 +294,126 @@ extension RecurringTransactionQueryFilter
     double epsilon = Query.epsilon,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.between(
-        FilterCondition.between(
+        property: r'amount',
-          property: r'amount',
+        lower: lower,
-          lower: lower,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upper,
-          upper: upper,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+        epsilon: epsilon,
-          epsilon: epsilon,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> idEqualTo(Id value) {
-    QAfterFilterCondition
-  >
-  idEqualTo(Id value) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(property: r'id', value: value),
+        property: r'id',
-      );
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> idGreaterThan(Id value, {
-    QAfterFilterCondition
+    bool include = false,
-  >
+  }) {
-  idGreaterThan(Id value, {bool include = false}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(
+        include: include,
-          include: include,
+        property: r'id',
-          property: r'id',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> idLessThan(Id value, {
-    QAfterFilterCondition
+    bool include = false,
-  >
+  }) {
-  idLessThan(Id value, {bool include = false}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.lessThan(
-        FilterCondition.lessThan(
+        include: include,
-          include: include,
+        property: r'id',
-          property: r'id',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> idBetween(
-    QAfterFilterCondition
-  >
-  idBetween(
     Id lower,
     Id upper, {
     bool includeLower = true,
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.between(
-        FilterCondition.between(
+        property: r'id',
-          property: r'id',
+        lower: lower,
-          lower: lower,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upper,
-          upper: upper,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> nameEqualTo(String value, {
-    QAfterFilterCondition
+    bool caseSensitive = true,
-  >
+  }) {
-  nameEqualTo(String value, {bool caseSensitive = true}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> nameGreaterThan(
-    QAfterFilterCondition
-  >
-  nameGreaterThan(
     String value, {
     bool include = false,
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(
+        include: include,
-          include: include,
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> nameLessThan(
-    QAfterFilterCondition
-  >
-  nameLessThan(
     String value, {
     bool include = false,
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.lessThan(
-        FilterCondition.lessThan(
+        include: include,
-          include: include,
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> nameBetween(
-    QAfterFilterCondition
-  >
-  nameBetween(
     String lower,
     String upper, {
     bool includeLower = true,
@@ -461,297 +421,302 @@ extension RecurringTransactionQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.between(
-        FilterCondition.between(
+        property: r'name',
-          property: r'name',
+        lower: lower,
-          lower: lower,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upper,
-          upper: upper,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> nameStartsWith(String value, {
-    QAfterFilterCondition
+    bool caseSensitive = true,
-  >
+  }) {
-  nameStartsWith(String value, {bool caseSensitive = true}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.startsWith(
-        FilterCondition.startsWith(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> nameEndsWith(String value, {
-    QAfterFilterCondition
+    bool caseSensitive = true,
-  >
+  }) {
-  nameEndsWith(String value, {bool caseSensitive = true}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.endsWith(
-        FilterCondition.endsWith(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition>
-    QAfterFilterCondition
-  >
   nameContains(String value, {bool caseSensitive = true}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.contains(
-        FilterCondition.contains(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition>
-    QAfterFilterCondition
-  >
   nameMatches(String pattern, {bool caseSensitive = true}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.matches(
-        FilterCondition.matches(
+        property: r'name',
-          property: r'name',
+        wildcard: pattern,
-          wildcard: pattern,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> nameIsEmpty() {
-    QAfterFilterCondition
-  >
-  nameIsEmpty() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(property: r'name', value: ''),
+        property: r'name',
-      );
+        value: '',
+      ));
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> nameIsNotEmpty() {
-    QAfterFilterCondition
-  >
-  nameIsNotEmpty() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(property: r'name', value: ''),
+        property: r'name',
-      );
+        value: '',
+      ));
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> startDateIsNull() {
-    QAfterFilterCondition
-  >
-  startDateIsNull() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(const FilterCondition.isNull(
-        const FilterCondition.isNull(property: r'startDate'),
+        property: r'startDate',
-      );
+      ));
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> startDateIsNotNull() {
-    QAfterFilterCondition
-  >
-  startDateIsNotNull() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(const FilterCondition.isNotNull(
-        const FilterCondition.isNotNull(property: r'startDate'),
+        property: r'startDate',
-      );
+      ));
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> startDateEqualTo(DateTime? value) {
-    QAfterFilterCondition
-  >
-  startDateEqualTo(DateTime? value) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(property: r'startDate', value: value),
+        property: r'startDate',
-      );
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> startDateGreaterThan(DateTime? value, {
-    QAfterFilterCondition
+    bool include = false,
-  >
+  }) {
-  startDateGreaterThan(DateTime? value, {bool include = false}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(
+        include: include,
-          include: include,
+        property: r'startDate',
-          property: r'startDate',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> startDateLessThan(DateTime? value, {
-    QAfterFilterCondition
+    bool include = false,
-  >
+  }) {
-  startDateLessThan(DateTime? value, {bool include = false}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.lessThan(
-        FilterCondition.lessThan(
+        include: include,
-          include: include,
+        property: r'startDate',
-          property: r'startDate',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> startDateBetween(
-    QAfterFilterCondition
-  >
-  startDateBetween(
     DateTime? lower,
     DateTime? upper, {
     bool includeLower = true,
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.between(
-        FilterCondition.between(
+        property: r'startDate',
-          property: r'startDate',
+        lower: lower,
-          lower: lower,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upper,
-          upper: upper,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> timeFrameEqualTo(TimeFrameEnum value) {
-    QAfterFilterCondition
-  >
-  timeFrameEqualTo(TimeFrameEnum value) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(property: r'timeFrame', value: value),
+        property: r'timeFrame',
-      );
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> timeFrameGreaterThan(TimeFrameEnum value, {
-    QAfterFilterCondition
+    bool include = false,
-  >
+  }) {
-  timeFrameGreaterThan(TimeFrameEnum value, {bool include = false}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(
+        include: include,
-          include: include,
+        property: r'timeFrame',
-          property: r'timeFrame',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> timeFrameLessThan(TimeFrameEnum value, {
-    QAfterFilterCondition
+    bool include = false,
-  >
+  }) {
-  timeFrameLessThan(TimeFrameEnum value, {bool include = false}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.lessThan(
-        FilterCondition.lessThan(
+        include: include,
-          include: include,
+        property: r'timeFrame',
-          property: r'timeFrame',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
-  QueryBuilder<
+  QueryBuilder<RecurringTransaction,
-    RecurringTransaction,
+      RecurringTransaction,
-    RecurringTransaction,
+      QAfterFilterCondition> timeFrameBetween(
-    QAfterFilterCondition
-  >
-  timeFrameBetween(
     TimeFrameEnum lower,
     TimeFrameEnum upper, {
     bool includeLower = true,
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.between(
-        FilterCondition.between(
+        property: r'timeFrame',
-          property: r'timeFrame',
+        lower: lower,
-          lower: lower,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upper,
-          upper: upper,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+      ));
-        ),
-      );
     });
   }
 }
 
-extension RecurringTransactionQueryObject
+extension RecurringTransactionQueryObject on QueryBuilder<RecurringTransaction,
-    on
+    RecurringTransaction,
-        QueryBuilder<
+    QFilterCondition> {}
-          RecurringTransaction,
-          RecurringTransaction,
-          QFilterCondition
-        > {}
 
-extension RecurringTransactionQueryLinks
+extension RecurringTransactionQueryLinks on QueryBuilder<RecurringTransaction,
-    on
+    RecurringTransaction,
-        QueryBuilder<
+    QFilterCondition> {
-          RecurringTransaction,
+  QueryBuilder<RecurringTransaction,
-          RecurringTransaction,
+      RecurringTransaction,
-          QFilterCondition
+      QAfterFilterCondition> transactions(FilterQuery<Transaction> q) {
-        > {}
+    return QueryBuilder.apply(this, (query) {
+      return query.link(q, r'transactions');
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactionsLengthEqualTo(int length) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', length, true, length, true);
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactionsIsEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', 0, true, 0, true);
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactionsIsNotEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', 0, false, 999999, true);
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactionsLengthLessThan(int length, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', 0, true, length, include);
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactionsLengthGreaterThan(int length, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', length, include, 999999, true);
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      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);
+    });
+  }
+}
 
 extension RecurringTransactionQuerySortBy
     on QueryBuilder<RecurringTransaction, RecurringTransaction, QSortBy> {
@@ -916,13 +881,10 @@ extension RecurringTransactionQueryWhereDistinct
   }
 }
 
-extension RecurringTransactionQueryProperty
+extension RecurringTransactionQueryProperty on QueryBuilder<
-    on
+    RecurringTransaction,
-        QueryBuilder<
+    RecurringTransaction,
-          RecurringTransaction,
+    QQueryProperty> {
-          RecurringTransaction,
-          QQueryProperty
-        > {
   QueryBuilder<RecurringTransaction, int, QQueryOperations> idProperty() {
     return QueryBuilder.apply(this, (query) {
       return query.addPropertyName(r'id');

lib/Entities/transaction.dart

@@ -1,5 +1,7 @@
 import 'package:isar/isar.dart';
 
+import 'recurring_transaction.dart';
+
 part 'transaction.g.dart';
 
 /// Die Klasse stellt eine Transaktion dar.
@@ -16,4 +18,9 @@ class Transaction {
 
   /// Die Höhe der Transaktion
   double amount = 0;
+
+  /// Stellt die wiederkehrende Transaktion dar,
+  /// zu welcher diese Transaktion gehört.
+  final IsarLink<RecurringTransaction> recurringTransaction =
+      IsarLink<RecurringTransaction>();
 }

lib/Entities/transaction.g.dart

@@ -17,9 +17,21 @@ const TransactionSchema = CollectionSchema(
   name: r'Transaction',
   id: 5320225499417954855,
   properties: {
-    r'amount': PropertySchema(id: 0, name: r'amount', type: IsarType.double),
+    r'amount': PropertySchema(
-    r'date': PropertySchema(id: 1, name: r'date', type: IsarType.dateTime),
+      id: 0,
-    r'name': PropertySchema(id: 2, name: r'name', type: IsarType.string),
+      name: r'amount',
+      type: IsarType.double,
+    ),
+    r'date': PropertySchema(
+      id: 1,
+      name: r'date',
+      type: IsarType.dateTime,
+    ),
+    r'name': PropertySchema(
+      id: 2,
+      name: r'name',
+      type: IsarType.string,
+    )
   },
   estimateSize: _transactionEstimateSize,
   serialize: _transactionSerialize,
@@ -27,7 +39,14 @@ const TransactionSchema = CollectionSchema(
   deserializeProp: _transactionDeserializeProp,
   idName: r'id',
   indexes: {},
-  links: {},
+  links: {
+    r'recurringTransaction': LinkSchema(
+      id: 8918082780894736839,
+      name: r'recurringTransaction',
+      target: r'RecurringTransaction',
+      single: true,
+    )
+  },
   embeddedSchemas: {},
   getId: _transactionGetId,
   getLinks: _transactionGetLinks,
@@ -93,15 +112,14 @@ Id _transactionGetId(Transaction object) {
 }
 
 List<IsarLinkBase<dynamic>> _transactionGetLinks(Transaction object) {
-  return [];
+  return [object.recurringTransaction];
 }
 
-void _transactionAttach(
+void _transactionAttach(IsarCollection<dynamic> col, Id id,
-  IsarCollection<dynamic> col,
+    Transaction object) {
-  Id id,
-  Transaction object,
-) {
   object.id = id;
+  object.recurringTransaction.attach(col,
+      col.isar.collection<RecurringTransaction>(), r'recurringTransaction', id);
 }
 
 extension TransactionQueryWhereSort
@@ -117,13 +135,15 @@ extension TransactionQueryWhere
     on QueryBuilder<Transaction, Transaction, QWhereClause> {
   QueryBuilder<Transaction, Transaction, QAfterWhereClause> idEqualTo(Id id) {
     return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(IdWhereClause.between(lower: id, upper: id));
+      return query.addWhereClause(IdWhereClause.between(
+        lower: id,
+        upper: id,
+      ));
     });
   }
 
   QueryBuilder<Transaction, Transaction, QAfterWhereClause> idNotEqualTo(
-    Id id,
+      Id id) {
-  ) {
     return QueryBuilder.apply(this, (query) {
       if (query.whereSort == Sort.asc) {
         return query
@@ -145,10 +165,8 @@ extension TransactionQueryWhere
     });
   }
 
-  QueryBuilder<Transaction, Transaction, QAfterWhereClause> idGreaterThan(
+  QueryBuilder<Transaction, Transaction, QAfterWhereClause> idGreaterThan(Id id,
-    Id id, {
+      {bool include = false}) {
-    bool include = false,
-  }) {
     return QueryBuilder.apply(this, (query) {
       return query.addWhereClause(
         IdWhereClause.greaterThan(lower: id, includeLower: include),
@@ -156,10 +174,8 @@ extension TransactionQueryWhere
     });
   }
 
-  QueryBuilder<Transaction, Transaction, QAfterWhereClause> idLessThan(
+  QueryBuilder<Transaction, Transaction, QAfterWhereClause> idLessThan(Id id,
-    Id id, {
+      {bool include = false}) {
-    bool include = false,
-  }) {
     return QueryBuilder.apply(this, (query) {
       return query.addWhereClause(
         IdWhereClause.lessThan(upper: id, includeUpper: include),
@@ -174,14 +190,12 @@ extension TransactionQueryWhere
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(
+      return query.addWhereClause(IdWhereClause.between(
-        IdWhereClause.between(
+        lower: lowerId,
-          lower: lowerId,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upperId,
-          upper: upperId,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+      ));
-        ),
-      );
     });
   }
 }
@@ -193,13 +207,11 @@ extension TransactionQueryFilter
     double epsilon = Query.epsilon,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(
+        property: r'amount',
-          property: r'amount',
+        value: value,
-          value: value,
+        epsilon: epsilon,
-          epsilon: epsilon,
+      ));
-        ),
-      );
     });
   }
 
@@ -210,14 +222,12 @@ extension TransactionQueryFilter
     double epsilon = Query.epsilon,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(
+        include: include,
-          include: include,
+        property: r'amount',
-          property: r'amount',
+        value: value,
-          value: value,
+        epsilon: epsilon,
-          epsilon: epsilon,
+      ));
-        ),
-      );
     });
   }
 
@@ -227,14 +237,12 @@ extension TransactionQueryFilter
     double epsilon = Query.epsilon,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.lessThan(
-        FilterCondition.lessThan(
+        include: include,
-          include: include,
+        property: r'amount',
-          property: r'amount',
+        value: value,
-          value: value,
+        epsilon: epsilon,
-          epsilon: epsilon,
+      ));
-        ),
-      );
     });
   }
 
@@ -246,43 +254,41 @@ extension TransactionQueryFilter
     double epsilon = Query.epsilon,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.between(
-        FilterCondition.between(
+        property: r'amount',
-          property: r'amount',
+        lower: lower,
-          lower: lower,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upper,
-          upper: upper,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+        epsilon: epsilon,
-          epsilon: epsilon,
+      ));
-        ),
-      );
     });
   }
 
   QueryBuilder<Transaction, Transaction, QAfterFilterCondition> dateIsNull() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(const FilterCondition.isNull(
-        const FilterCondition.isNull(property: r'date'),
+        property: r'date',
-      );
+      ));
     });
   }
 
   QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
   dateIsNotNull() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(const FilterCondition.isNotNull(
-        const FilterCondition.isNotNull(property: r'date'),
+        property: r'date',
-      );
+      ));
     });
   }
 
   QueryBuilder<Transaction, Transaction, QAfterFilterCondition> dateEqualTo(
-    DateTime? value,
+      DateTime? value) {
-  ) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(property: r'date', value: value),
+        property: r'date',
-      );
+        value: value,
+      ));
     });
   }
 
@@ -291,13 +297,11 @@ extension TransactionQueryFilter
     bool include = false,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(
+        include: include,
-          include: include,
+        property: r'date',
-          property: r'date',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
@@ -306,13 +310,11 @@ extension TransactionQueryFilter
     bool include = false,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.lessThan(
-        FilterCondition.lessThan(
+        include: include,
-          include: include,
+        property: r'date',
-          property: r'date',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
@@ -323,25 +325,23 @@ extension TransactionQueryFilter
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.between(
-        FilterCondition.between(
+        property: r'date',
-          property: r'date',
+        lower: lower,
-          lower: lower,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upper,
-          upper: upper,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+      ));
-        ),
-      );
     });
   }
 
   QueryBuilder<Transaction, Transaction, QAfterFilterCondition> idEqualTo(
-    Id value,
+      Id value) {
-  ) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(property: r'id', value: value),
+        property: r'id',
-      );
+        value: value,
+      ));
     });
   }
 
@@ -350,13 +350,11 @@ extension TransactionQueryFilter
     bool include = false,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(
+        include: include,
-          include: include,
+        property: r'id',
-          property: r'id',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
@@ -365,13 +363,11 @@ extension TransactionQueryFilter
     bool include = false,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.lessThan(
-        FilterCondition.lessThan(
+        include: include,
-          include: include,
+        property: r'id',
-          property: r'id',
+        value: value,
-          value: value,
+      ));
-        ),
-      );
     });
   }
 
@@ -382,15 +378,13 @@ extension TransactionQueryFilter
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.between(
-        FilterCondition.between(
+        property: r'id',
-          property: r'id',
+        lower: lower,
-          lower: lower,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upper,
-          upper: upper,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+      ));
-        ),
-      );
     });
   }
 
@@ -399,13 +393,11 @@ extension TransactionQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
@@ -415,14 +407,12 @@ extension TransactionQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(
+        include: include,
-          include: include,
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
@@ -432,14 +422,12 @@ extension TransactionQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.lessThan(
-        FilterCondition.lessThan(
+        include: include,
-          include: include,
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
@@ -451,16 +439,14 @@ extension TransactionQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.between(
-        FilterCondition.between(
+        property: r'name',
-          property: r'name',
+        lower: lower,
-          lower: lower,
+        includeLower: includeLower,
-          includeLower: includeLower,
+        upper: upper,
-          upper: upper,
+        includeUpper: includeUpper,
-          includeUpper: includeUpper,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
@@ -469,13 +455,11 @@ extension TransactionQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.startsWith(
-        FilterCondition.startsWith(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
@@ -484,60 +468,54 @@ extension TransactionQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.endsWith(
-        FilterCondition.endsWith(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
   QueryBuilder<Transaction, Transaction, QAfterFilterCondition> nameContains(
-    String value, {
+      String value,
-    bool caseSensitive = true,
+      {bool caseSensitive = true}) {
-  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.contains(
-        FilterCondition.contains(
+        property: r'name',
-          property: r'name',
+        value: value,
-          value: value,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
   QueryBuilder<Transaction, Transaction, QAfterFilterCondition> nameMatches(
-    String pattern, {
+      String pattern,
-    bool caseSensitive = true,
+      {bool caseSensitive = true}) {
-  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.matches(
-        FilterCondition.matches(
+        property: r'name',
-          property: r'name',
+        wildcard: pattern,
-          wildcard: pattern,
+        caseSensitive: caseSensitive,
-          caseSensitive: caseSensitive,
+      ));
-        ),
-      );
     });
   }
 
   QueryBuilder<Transaction, Transaction, QAfterFilterCondition> nameIsEmpty() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.equalTo(
-        FilterCondition.equalTo(property: r'name', value: ''),
+        property: r'name',
-      );
+        value: '',
+      ));
     });
   }
 
   QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
   nameIsNotEmpty() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
+      return query.addFilterCondition(FilterCondition.greaterThan(
-        FilterCondition.greaterThan(property: r'name', value: ''),
+        property: r'name',
-      );
+        value: '',
+      ));
     });
   }
 }
@@ -546,7 +524,21 @@ extension TransactionQueryObject
     on QueryBuilder<Transaction, Transaction, QFilterCondition> {}
 
 extension TransactionQueryLinks
-    on QueryBuilder<Transaction, Transaction, QFilterCondition> {}
+on QueryBuilder<Transaction, Transaction, QFilterCondition> {
+  QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
+  recurringTransaction(FilterQuery<RecurringTransaction> q) {
+    return QueryBuilder.apply(this, (query) {
+      return query.link(q, r'recurringTransaction');
+    });
+  }
+
+  QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
+  recurringTransactionIsNull() {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'recurringTransaction', 0, true, 0, true);
+    });
+  }
+}
 
 extension TransactionQuerySortBy
     on QueryBuilder<Transaction, Transaction, QSortBy> {
@@ -652,9 +644,8 @@ extension TransactionQueryWhereDistinct
     });
   }
 
-  QueryBuilder<Transaction, Transaction, QDistinct> distinctByName({
+  QueryBuilder<Transaction, Transaction, QDistinct> distinctByName(
-    bool caseSensitive = true,
+      {bool caseSensitive = true}) {
-  }) {
     return QueryBuilder.apply(this, (query) {
       return query.addDistinctBy(r'name', caseSensitive: caseSensitive);
     });