944 lines
26 KiB
Dart
944 lines
26 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'recurring_transaction.dart';
|
|
|
|
// **************************************************************************
|
|
// IsarCollectionGenerator
|
|
// **************************************************************************
|
|
|
|
// coverage:ignore-file
|
|
// ignore_for_file: duplicate_ignore, non_constant_identifier_names, constant_identifier_names, invalid_use_of_protected_member, unnecessary_cast, prefer_const_constructors, lines_longer_than_80_chars, require_trailing_commas, inference_failure_on_function_invocation, unnecessary_parenthesis, unnecessary_raw_strings, unnecessary_null_checks, join_return_with_assignment, prefer_final_locals, avoid_js_rounded_ints, avoid_positional_boolean_parameters, always_specify_types
|
|
|
|
extension GetRecurringTransactionCollection on Isar {
|
|
IsarCollection<RecurringTransaction> get recurringTransactions =>
|
|
this.collection();
|
|
}
|
|
|
|
const RecurringTransactionSchema = CollectionSchema(
|
|
name: r'RecurringTransaction',
|
|
id: 969840479390105118,
|
|
properties: {
|
|
r'amount': PropertySchema(
|
|
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',
|
|
type: IsarType.dateTime,
|
|
),
|
|
r'timeFrame': PropertySchema(
|
|
id: 3,
|
|
name: r'timeFrame',
|
|
type: IsarType.byte,
|
|
enumMap: _RecurringTransactiontimeFrameEnumValueMap,
|
|
)
|
|
},
|
|
estimateSize: _recurringTransactionEstimateSize,
|
|
serialize: _recurringTransactionSerialize,
|
|
deserialize: _recurringTransactionDeserialize,
|
|
deserializeProp: _recurringTransactionDeserializeProp,
|
|
idName: r'id',
|
|
indexes: {},
|
|
links: {
|
|
r'transactions': LinkSchema(
|
|
id: 459560147514286496,
|
|
name: r'transactions',
|
|
target: r'Transaction',
|
|
single: false,
|
|
linkName: r'recurringTransaction',
|
|
),
|
|
r'account': LinkSchema(
|
|
id: -6028551496614242115,
|
|
name: r'account',
|
|
target: r'Account',
|
|
single: true,
|
|
)
|
|
},
|
|
embeddedSchemas: {},
|
|
getId: _recurringTransactionGetId,
|
|
getLinks: _recurringTransactionGetLinks,
|
|
attach: _recurringTransactionAttach,
|
|
version: '3.1.0+1',
|
|
);
|
|
|
|
int _recurringTransactionEstimateSize(
|
|
RecurringTransaction object,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
var bytesCount = offsets.last;
|
|
bytesCount += 3 + object.name.length * 3;
|
|
return bytesCount;
|
|
}
|
|
|
|
void _recurringTransactionSerialize(
|
|
RecurringTransaction object,
|
|
IsarWriter writer,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
writer.writeDouble(offsets[0], object.amount);
|
|
writer.writeString(offsets[1], object.name);
|
|
writer.writeDateTime(offsets[2], object.startDate);
|
|
writer.writeByte(offsets[3], object.timeFrame.index);
|
|
}
|
|
|
|
RecurringTransaction _recurringTransactionDeserialize(
|
|
Id id,
|
|
IsarReader reader,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
final object = RecurringTransaction();
|
|
object.amount = reader.readDouble(offsets[0]);
|
|
object.id = id;
|
|
object.name = reader.readString(offsets[1]);
|
|
object.startDate = reader.readDateTimeOrNull(offsets[2]);
|
|
object.timeFrame = _RecurringTransactiontimeFrameValueEnumMap[
|
|
reader.readByteOrNull(offsets[3])] ??
|
|
TimeFrameEnum.daily;
|
|
return object;
|
|
}
|
|
|
|
P _recurringTransactionDeserializeProp<P>(
|
|
IsarReader reader,
|
|
int propertyId,
|
|
int offset,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
switch (propertyId) {
|
|
case 0:
|
|
return (reader.readDouble(offset)) as P;
|
|
case 1:
|
|
return (reader.readString(offset)) as P;
|
|
case 2:
|
|
return (reader.readDateTimeOrNull(offset)) as P;
|
|
case 3:
|
|
return (_RecurringTransactiontimeFrameValueEnumMap[
|
|
reader.readByteOrNull(offset)] ??
|
|
TimeFrameEnum.daily) as P;
|
|
default:
|
|
throw IsarError('Unknown property with id $propertyId');
|
|
}
|
|
}
|
|
|
|
const _RecurringTransactiontimeFrameEnumValueMap = {
|
|
'daily': 0,
|
|
'weekly': 1,
|
|
'monthly': 2,
|
|
'yearly': 3,
|
|
};
|
|
const _RecurringTransactiontimeFrameValueEnumMap = {
|
|
0: TimeFrameEnum.daily,
|
|
1: TimeFrameEnum.weekly,
|
|
2: TimeFrameEnum.monthly,
|
|
3: TimeFrameEnum.yearly,
|
|
};
|
|
|
|
Id _recurringTransactionGetId(RecurringTransaction object) {
|
|
return object.id;
|
|
}
|
|
|
|
List<IsarLinkBase<dynamic>> _recurringTransactionGetLinks(
|
|
RecurringTransaction object) {
|
|
return [object.transactions, object.account];
|
|
}
|
|
|
|
void _recurringTransactionAttach(IsarCollection<dynamic> col, Id id,
|
|
RecurringTransaction object) {
|
|
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
|
|
on QueryBuilder<RecurringTransaction, RecurringTransaction, QWhere> {
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterWhere>
|
|
anyId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(const IdWhereClause.any());
|
|
});
|
|
}
|
|
}
|
|
|
|
extension RecurringTransactionQueryWhere
|
|
on QueryBuilder<RecurringTransaction, RecurringTransaction, QWhereClause> {
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterWhereClause>
|
|
idEqualTo(Id id) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IdWhereClause.between(
|
|
lower: id,
|
|
upper: id,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterWhereClause>
|
|
idNotEqualTo(Id id) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
if (query.whereSort == Sort.asc) {
|
|
return query
|
|
.addWhereClause(
|
|
IdWhereClause.lessThan(upper: id, includeUpper: false),
|
|
)
|
|
.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: id, includeLower: false),
|
|
);
|
|
} else {
|
|
return query
|
|
.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: id, includeLower: false),
|
|
)
|
|
.addWhereClause(
|
|
IdWhereClause.lessThan(upper: id, includeUpper: false),
|
|
);
|
|
}
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterWhereClause>
|
|
idGreaterThan(Id id, {bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: id, includeLower: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterWhereClause>
|
|
idLessThan(Id id, {bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.lessThan(upper: id, includeUpper: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterWhereClause>
|
|
idBetween(
|
|
Id lowerId,
|
|
Id upperId, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IdWhereClause.between(
|
|
lower: lowerId,
|
|
includeLower: includeLower,
|
|
upper: upperId,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
extension RecurringTransactionQueryFilter on QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QFilterCondition> {
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> amountEqualTo(double value, {
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'amount',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> amountGreaterThan(
|
|
double value, {
|
|
bool include = false,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'amount',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> amountLessThan(
|
|
double value, {
|
|
bool include = false,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'amount',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> amountBetween(
|
|
double lower,
|
|
double upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'amount',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> idEqualTo(Id value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'id',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> idGreaterThan(Id value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'id',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> idLessThan(Id value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'id',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> idBetween(
|
|
Id lower,
|
|
Id upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'id',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> nameEqualTo(String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> nameGreaterThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> nameLessThan(
|
|
String value, {
|
|
bool include = false,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> nameBetween(
|
|
String lower,
|
|
String upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'name',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> nameStartsWith(String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.startsWith(
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> nameEndsWith(String value, {
|
|
bool caseSensitive = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.endsWith(
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition>
|
|
nameContains(String value, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.contains(
|
|
property: r'name',
|
|
value: value,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition>
|
|
nameMatches(String pattern, {bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.matches(
|
|
property: r'name',
|
|
wildcard: pattern,
|
|
caseSensitive: caseSensitive,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> nameIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'name',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> nameIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'name',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> startDateIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNull(
|
|
property: r'startDate',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> startDateIsNotNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(const FilterCondition.isNotNull(
|
|
property: r'startDate',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> startDateEqualTo(DateTime? value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'startDate',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> startDateGreaterThan(DateTime? value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'startDate',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> startDateLessThan(DateTime? value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'startDate',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> startDateBetween(
|
|
DateTime? lower,
|
|
DateTime? upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'startDate',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> timeFrameEqualTo(TimeFrameEnum value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'timeFrame',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> timeFrameGreaterThan(TimeFrameEnum value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'timeFrame',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> timeFrameLessThan(TimeFrameEnum value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'timeFrame',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QAfterFilterCondition> timeFrameBetween(
|
|
TimeFrameEnum lower,
|
|
TimeFrameEnum upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'timeFrame',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
extension RecurringTransactionQueryObject on QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QFilterCondition> {}
|
|
|
|
extension RecurringTransactionQueryLinks on QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
QFilterCondition> {
|
|
QueryBuilder<RecurringTransaction,
|
|
RecurringTransaction,
|
|
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);
|
|
});
|
|
}
|
|
|
|
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
|
|
on QueryBuilder<RecurringTransaction, RecurringTransaction, QSortBy> {
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
sortByAmount() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'amount', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
sortByAmountDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'amount', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
sortByName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
sortByNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
sortByStartDate() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'startDate', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
sortByStartDateDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'startDate', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
sortByTimeFrame() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'timeFrame', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
sortByTimeFrameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'timeFrame', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension RecurringTransactionQuerySortThenBy
|
|
on QueryBuilder<RecurringTransaction, RecurringTransaction, QSortThenBy> {
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
thenByAmount() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'amount', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
thenByAmountDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'amount', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
thenById() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
thenByIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
thenByName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
thenByNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
thenByStartDate() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'startDate', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
thenByStartDateDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'startDate', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
thenByTimeFrame() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'timeFrame', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterSortBy>
|
|
thenByTimeFrameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'timeFrame', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension RecurringTransactionQueryWhereDistinct
|
|
on QueryBuilder<RecurringTransaction, RecurringTransaction, QDistinct> {
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QDistinct>
|
|
distinctByAmount() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'amount');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QDistinct>
|
|
distinctByName({bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'name', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QDistinct>
|
|
distinctByStartDate() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'startDate');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, RecurringTransaction, QDistinct>
|
|
distinctByTimeFrame() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'timeFrame');
|
|
});
|
|
}
|
|
}
|
|
|
|
extension RecurringTransactionQueryProperty on QueryBuilder<
|
|
RecurringTransaction,
|
|
RecurringTransaction,
|
|
QQueryProperty> {
|
|
QueryBuilder<RecurringTransaction, int, QQueryOperations> idProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'id');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, double, QQueryOperations>
|
|
amountProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'amount');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, String, QQueryOperations> nameProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'name');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, DateTime?, QQueryOperations>
|
|
startDateProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'startDate');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<RecurringTransaction, TimeFrameEnum, QQueryOperations>
|
|
timeFrameProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'timeFrame');
|
|
});
|
|
}
|
|
}
|