1153 lines
32 KiB
Dart
1153 lines
32 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'budget.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 GetBudgetItemCollection on Isar {
|
|
IsarCollection<BudgetItem> get budgetItems => this.collection();
|
|
}
|
|
|
|
const BudgetItemSchema = CollectionSchema(
|
|
name: r'BudgetItem',
|
|
id: 618999772191843499,
|
|
properties: {
|
|
r'amount': PropertySchema(
|
|
id: 0,
|
|
name: r'amount',
|
|
type: IsarType.double,
|
|
)
|
|
},
|
|
estimateSize: _budgetItemEstimateSize,
|
|
serialize: _budgetItemSerialize,
|
|
deserialize: _budgetItemDeserialize,
|
|
deserializeProp: _budgetItemDeserializeProp,
|
|
idName: r'id',
|
|
indexes: {},
|
|
links: {
|
|
r'expenseCategory': LinkSchema(
|
|
id: -915171920088002159,
|
|
name: r'expenseCategory',
|
|
target: r'ExpenseCategory',
|
|
single: true,
|
|
)
|
|
},
|
|
embeddedSchemas: {},
|
|
getId: _budgetItemGetId,
|
|
getLinks: _budgetItemGetLinks,
|
|
attach: _budgetItemAttach,
|
|
version: '3.1.0+1',
|
|
);
|
|
|
|
int _budgetItemEstimateSize(
|
|
BudgetItem object,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
var bytesCount = offsets.last;
|
|
return bytesCount;
|
|
}
|
|
|
|
void _budgetItemSerialize(
|
|
BudgetItem object,
|
|
IsarWriter writer,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
writer.writeDouble(offsets[0], object.amount);
|
|
}
|
|
|
|
BudgetItem _budgetItemDeserialize(
|
|
Id id,
|
|
IsarReader reader,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
final object = BudgetItem();
|
|
object.amount = reader.readDouble(offsets[0]);
|
|
object.id = id;
|
|
return object;
|
|
}
|
|
|
|
P _budgetItemDeserializeProp<P>(
|
|
IsarReader reader,
|
|
int propertyId,
|
|
int offset,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
switch (propertyId) {
|
|
case 0:
|
|
return (reader.readDouble(offset)) as P;
|
|
default:
|
|
throw IsarError('Unknown property with id $propertyId');
|
|
}
|
|
}
|
|
|
|
Id _budgetItemGetId(BudgetItem object) {
|
|
return object.id;
|
|
}
|
|
|
|
List<IsarLinkBase<dynamic>> _budgetItemGetLinks(BudgetItem object) {
|
|
return [object.expenseCategory];
|
|
}
|
|
|
|
void _budgetItemAttach(IsarCollection<dynamic> col, Id id, BudgetItem object) {
|
|
object.id = id;
|
|
object.expenseCategory.attach(
|
|
col, col.isar.collection<ExpenseCategory>(), r'expenseCategory', id);
|
|
}
|
|
|
|
extension BudgetItemQueryWhereSort
|
|
on QueryBuilder<BudgetItem, BudgetItem, QWhere> {
|
|
QueryBuilder<BudgetItem, BudgetItem, QAfterWhere> anyId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(const IdWhereClause.any());
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetItemQueryWhere
|
|
on QueryBuilder<BudgetItem, BudgetItem, QWhereClause> {
|
|
QueryBuilder<BudgetItem, BudgetItem, QAfterWhereClause> idEqualTo(Id id) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IdWhereClause.between(
|
|
lower: id,
|
|
upper: id,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<BudgetItem, BudgetItem, 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<BudgetItem, BudgetItem, QAfterWhereClause> idGreaterThan(Id id,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: id, includeLower: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<BudgetItem, BudgetItem, QAfterWhereClause> idLessThan(Id id,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.lessThan(upper: id, includeUpper: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<BudgetItem, BudgetItem, 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 BudgetItemQueryFilter
|
|
on QueryBuilder<BudgetItem, BudgetItem, QFilterCondition> {
|
|
QueryBuilder<BudgetItem, BudgetItem, 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<BudgetItem, BudgetItem, 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<BudgetItem, BudgetItem, 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<BudgetItem, BudgetItem, 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<BudgetItem, BudgetItem, QAfterFilterCondition> idEqualTo(
|
|
Id value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'id',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<BudgetItem, BudgetItem, 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<BudgetItem, BudgetItem, 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<BudgetItem, BudgetItem, 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,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetItemQueryObject
|
|
on QueryBuilder<BudgetItem, BudgetItem, QFilterCondition> {}
|
|
|
|
extension BudgetItemQueryLinks
|
|
on QueryBuilder<BudgetItem, BudgetItem, QFilterCondition> {
|
|
QueryBuilder<BudgetItem, BudgetItem, QAfterFilterCondition> expenseCategory(
|
|
FilterQuery<ExpenseCategory> q) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.link(q, r'expenseCategory');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<BudgetItem, BudgetItem, QAfterFilterCondition>
|
|
expenseCategoryIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'expenseCategory', 0, true, 0, true);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetItemQuerySortBy
|
|
on QueryBuilder<BudgetItem, BudgetItem, QSortBy> {
|
|
QueryBuilder<BudgetItem, BudgetItem, QAfterSortBy> sortByAmount() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'amount', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<BudgetItem, BudgetItem, QAfterSortBy> sortByAmountDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'amount', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetItemQuerySortThenBy
|
|
on QueryBuilder<BudgetItem, BudgetItem, QSortThenBy> {
|
|
QueryBuilder<BudgetItem, BudgetItem, QAfterSortBy> thenByAmount() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'amount', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<BudgetItem, BudgetItem, QAfterSortBy> thenByAmountDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'amount', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<BudgetItem, BudgetItem, QAfterSortBy> thenById() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<BudgetItem, BudgetItem, QAfterSortBy> thenByIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetItemQueryWhereDistinct
|
|
on QueryBuilder<BudgetItem, BudgetItem, QDistinct> {
|
|
QueryBuilder<BudgetItem, BudgetItem, QDistinct> distinctByAmount() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'amount');
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetItemQueryProperty
|
|
on QueryBuilder<BudgetItem, BudgetItem, QQueryProperty> {
|
|
QueryBuilder<BudgetItem, int, QQueryOperations> idProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'id');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<BudgetItem, double, QQueryOperations> amountProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'amount');
|
|
});
|
|
}
|
|
}
|
|
|
|
// 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 GetBudgetCollection on Isar {
|
|
IsarCollection<Budget> get budgets => this.collection();
|
|
}
|
|
|
|
const BudgetSchema = CollectionSchema(
|
|
name: r'Budget',
|
|
id: -3383598594604670326,
|
|
properties: {
|
|
r'includeOtherSpendings': PropertySchema(
|
|
id: 0,
|
|
name: r'includeOtherSpendings',
|
|
type: IsarType.bool,
|
|
),
|
|
r'income': PropertySchema(
|
|
id: 1,
|
|
name: r'income',
|
|
type: IsarType.double,
|
|
),
|
|
r'name': PropertySchema(
|
|
id: 2,
|
|
name: r'name',
|
|
type: IsarType.string,
|
|
),
|
|
r'period': PropertySchema(
|
|
id: 3,
|
|
name: r'period',
|
|
type: IsarType.byte,
|
|
enumMap: _BudgetperiodEnumValueMap,
|
|
)
|
|
},
|
|
estimateSize: _budgetEstimateSize,
|
|
serialize: _budgetSerialize,
|
|
deserialize: _budgetDeserialize,
|
|
deserializeProp: _budgetDeserializeProp,
|
|
idName: r'id',
|
|
indexes: {},
|
|
links: {
|
|
r'account': LinkSchema(
|
|
id: -2244135419803748845,
|
|
name: r'account',
|
|
target: r'Account',
|
|
single: true,
|
|
),
|
|
r'items': LinkSchema(
|
|
id: -7217800434111289514,
|
|
name: r'items',
|
|
target: r'BudgetItem',
|
|
single: false,
|
|
)
|
|
},
|
|
embeddedSchemas: {},
|
|
getId: _budgetGetId,
|
|
getLinks: _budgetGetLinks,
|
|
attach: _budgetAttach,
|
|
version: '3.1.0+1',
|
|
);
|
|
|
|
int _budgetEstimateSize(
|
|
Budget object,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
var bytesCount = offsets.last;
|
|
bytesCount += 3 + object.name.length * 3;
|
|
return bytesCount;
|
|
}
|
|
|
|
void _budgetSerialize(
|
|
Budget object,
|
|
IsarWriter writer,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
writer.writeBool(offsets[0], object.includeOtherSpendings);
|
|
writer.writeDouble(offsets[1], object.income);
|
|
writer.writeString(offsets[2], object.name);
|
|
writer.writeByte(offsets[3], object.period.index);
|
|
}
|
|
|
|
Budget _budgetDeserialize(
|
|
Id id,
|
|
IsarReader reader,
|
|
List<int> offsets,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
final object = Budget();
|
|
object.id = id;
|
|
object.includeOtherSpendings = reader.readBool(offsets[0]);
|
|
object.income = reader.readDouble(offsets[1]);
|
|
object.name = reader.readString(offsets[2]);
|
|
object.period =
|
|
_BudgetperiodValueEnumMap[reader.readByteOrNull(offsets[3])] ??
|
|
BudgetPeriod.month;
|
|
return object;
|
|
}
|
|
|
|
P _budgetDeserializeProp<P>(
|
|
IsarReader reader,
|
|
int propertyId,
|
|
int offset,
|
|
Map<Type, List<int>> allOffsets,
|
|
) {
|
|
switch (propertyId) {
|
|
case 0:
|
|
return (reader.readBool(offset)) as P;
|
|
case 1:
|
|
return (reader.readDouble(offset)) as P;
|
|
case 2:
|
|
return (reader.readString(offset)) as P;
|
|
case 3:
|
|
return (_BudgetperiodValueEnumMap[reader.readByteOrNull(offset)] ??
|
|
BudgetPeriod.month) as P;
|
|
default:
|
|
throw IsarError('Unknown property with id $propertyId');
|
|
}
|
|
}
|
|
|
|
const _BudgetperiodEnumValueMap = {
|
|
'month': 0,
|
|
};
|
|
const _BudgetperiodValueEnumMap = {
|
|
0: BudgetPeriod.month,
|
|
};
|
|
|
|
Id _budgetGetId(Budget object) {
|
|
return object.id;
|
|
}
|
|
|
|
List<IsarLinkBase<dynamic>> _budgetGetLinks(Budget object) {
|
|
return [object.account, object.items];
|
|
}
|
|
|
|
void _budgetAttach(IsarCollection<dynamic> col, Id id, Budget object) {
|
|
object.id = id;
|
|
object.account.attach(col, col.isar.collection<Account>(), r'account', id);
|
|
object.items.attach(col, col.isar.collection<BudgetItem>(), r'items', id);
|
|
}
|
|
|
|
extension BudgetQueryWhereSort on QueryBuilder<Budget, Budget, QWhere> {
|
|
QueryBuilder<Budget, Budget, QAfterWhere> anyId() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(const IdWhereClause.any());
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetQueryWhere on QueryBuilder<Budget, Budget, QWhereClause> {
|
|
QueryBuilder<Budget, Budget, QAfterWhereClause> idEqualTo(Id id) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(IdWhereClause.between(
|
|
lower: id,
|
|
upper: id,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, 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<Budget, Budget, QAfterWhereClause> idGreaterThan(Id id,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.greaterThan(lower: id, includeLower: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterWhereClause> idLessThan(Id id,
|
|
{bool include = false}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addWhereClause(
|
|
IdWhereClause.lessThan(upper: id, includeUpper: include),
|
|
);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, 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 BudgetQueryFilter on QueryBuilder<Budget, Budget, QFilterCondition> {
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> idEqualTo(Id value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'id',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, 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<Budget, Budget, 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<Budget, Budget, 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<Budget, Budget, QAfterFilterCondition>
|
|
includeOtherSpendingsEqualTo(bool value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'includeOtherSpendings',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> incomeEqualTo(
|
|
double value, {
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'income',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> incomeGreaterThan(
|
|
double value, {
|
|
bool include = false,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'income',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> incomeLessThan(
|
|
double value, {
|
|
bool include = false,
|
|
double epsilon = Query.epsilon,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'income',
|
|
value: value,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> incomeBetween(
|
|
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'income',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
epsilon: epsilon,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, 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<Budget, Budget, 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<Budget, Budget, 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<Budget, Budget, 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<Budget, Budget, 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<Budget, Budget, 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<Budget, Budget, 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<Budget, Budget, 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<Budget, Budget, QAfterFilterCondition> nameIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'name',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> nameIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
property: r'name',
|
|
value: '',
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> periodEqualTo(
|
|
BudgetPeriod value) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.equalTo(
|
|
property: r'period',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> periodGreaterThan(
|
|
BudgetPeriod value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.greaterThan(
|
|
include: include,
|
|
property: r'period',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> periodLessThan(
|
|
BudgetPeriod value, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.lessThan(
|
|
include: include,
|
|
property: r'period',
|
|
value: value,
|
|
));
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> periodBetween(
|
|
BudgetPeriod lower,
|
|
BudgetPeriod upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addFilterCondition(FilterCondition.between(
|
|
property: r'period',
|
|
lower: lower,
|
|
includeLower: includeLower,
|
|
upper: upper,
|
|
includeUpper: includeUpper,
|
|
));
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetQueryObject on QueryBuilder<Budget, Budget, QFilterCondition> {}
|
|
|
|
extension BudgetQueryLinks on QueryBuilder<Budget, Budget, QFilterCondition> {
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> account(
|
|
FilterQuery<Account> q) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.link(q, r'account');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> accountIsNull() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'account', 0, true, 0, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> items(
|
|
FilterQuery<BudgetItem> q) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.link(q, r'items');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> itemsLengthEqualTo(
|
|
int length) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'items', length, true, length, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> itemsIsEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'items', 0, true, 0, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> itemsIsNotEmpty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'items', 0, false, 999999, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> itemsLengthLessThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'items', 0, true, length, include);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> itemsLengthGreaterThan(
|
|
int length, {
|
|
bool include = false,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(r'items', length, include, 999999, true);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterFilterCondition> itemsLengthBetween(
|
|
int lower,
|
|
int upper, {
|
|
bool includeLower = true,
|
|
bool includeUpper = true,
|
|
}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.linkLength(
|
|
r'items', lower, includeLower, upper, includeUpper);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetQuerySortBy on QueryBuilder<Budget, Budget, QSortBy> {
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> sortByIncludeOtherSpendings() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'includeOtherSpendings', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> sortByIncludeOtherSpendingsDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'includeOtherSpendings', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> sortByIncome() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'income', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> sortByIncomeDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'income', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> sortByName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> sortByNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> sortByPeriod() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'period', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> sortByPeriodDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'period', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetQuerySortThenBy on QueryBuilder<Budget, Budget, QSortThenBy> {
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> thenById() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> thenByIdDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'id', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> thenByIncludeOtherSpendings() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'includeOtherSpendings', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> thenByIncludeOtherSpendingsDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'includeOtherSpendings', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> thenByIncome() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'income', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> thenByIncomeDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'income', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> thenByName() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> thenByNameDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'name', Sort.desc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> thenByPeriod() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'period', Sort.asc);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QAfterSortBy> thenByPeriodDesc() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addSortBy(r'period', Sort.desc);
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetQueryWhereDistinct on QueryBuilder<Budget, Budget, QDistinct> {
|
|
QueryBuilder<Budget, Budget, QDistinct> distinctByIncludeOtherSpendings() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'includeOtherSpendings');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QDistinct> distinctByIncome() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'income');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QDistinct> distinctByName(
|
|
{bool caseSensitive = true}) {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'name', caseSensitive: caseSensitive);
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, Budget, QDistinct> distinctByPeriod() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addDistinctBy(r'period');
|
|
});
|
|
}
|
|
}
|
|
|
|
extension BudgetQueryProperty on QueryBuilder<Budget, Budget, QQueryProperty> {
|
|
QueryBuilder<Budget, int, QQueryOperations> idProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'id');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, bool, QQueryOperations> includeOtherSpendingsProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'includeOtherSpendings');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, double, QQueryOperations> incomeProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'income');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, String, QQueryOperations> nameProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'name');
|
|
});
|
|
}
|
|
|
|
QueryBuilder<Budget, BudgetPeriod, QQueryOperations> periodProperty() {
|
|
return QueryBuilder.apply(this, (query) {
|
|
return query.addPropertyName(r'period');
|
|
});
|
|
}
|
|
}
|