Flutterapps/dragon_ledger
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Feat: Ersetzt die Isar-Datenbank durch die drift-Datenbank

Browse Source
This commit is contained in:
DragonSlayer_14
2025-12-24 01:04:38 +01:00
parent 673d7de21c
commit c11515d447
23 changed files with 15995 additions and 2601 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
lib/Entities/account.dart
View File

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

567
lib/Entities/account.g.dart
View File

@@ -1,567 +0,0 @@
// GENERATED CODE - DO NOT MODIFY BY HAND
part of 'account.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 GetAccountCollection on Isar {
IsarCollection<Account> get accounts => this.collection();
}
const AccountSchema = CollectionSchema(
name: r'Account',
id: -6646797162501847804,
properties: {
r'name': PropertySchema(
id: 0,
name: r'name',
type: IsarType.string,
)
},
estimateSize: _accountEstimateSize,
serialize: _accountSerialize,
deserialize: _accountDeserialize,
deserializeProp: _accountDeserializeProp,
idName: r'id',
indexes: {},
links: {
r'transactions': LinkSchema(
id: 320079441438939175,
name: r'transactions',
target: r'Transaction',
single: false,
linkName: r'account',
),
r'recurringTransactions': LinkSchema(
id: 3985469729442003270,
name: r'recurringTransactions',
target: r'RecurringTransaction',
single: false,
linkName: r'account',
)
},
embeddedSchemas: {},
getId: _accountGetId,
getLinks: _accountGetLinks,
attach: _accountAttach,
version: '3.1.0+1',
);
int _accountEstimateSize(
Account object,
List<int> offsets,
Map<Type, List<int>> allOffsets,
) {
var bytesCount = offsets.last;
bytesCount += 3 + object.name.length * 3;
return bytesCount;
}
void _accountSerialize(
Account object,
IsarWriter writer,
List<int> offsets,
Map<Type, List<int>> allOffsets,
) {
writer.writeString(offsets[0], object.name);
}
Account _accountDeserialize(
Id id,
IsarReader reader,
List<int> offsets,
Map<Type, List<int>> allOffsets,
) {
final object = Account();
object.id = id;
object.name = reader.readString(offsets[0]);
return object;
}
P _accountDeserializeProp<P>(
IsarReader reader,
int propertyId,
int offset,
Map<Type, List<int>> allOffsets,
) {
switch (propertyId) {
case 0:
return (reader.readString(offset)) as P;
default:
throw IsarError('Unknown property with id $propertyId');
}
}
Id _accountGetId(Account object) {
return object.id;
}
List<IsarLinkBase<dynamic>> _accountGetLinks(Account object) {
return [object.transactions, object.recurringTransactions];
}
void _accountAttach(IsarCollection<dynamic> col, Id id, Account object) {
object.id = id;
object.transactions
.attach(col, col.isar.collection<Transaction>(), r'transactions', id);
object.recurringTransactions.attach(
col,
col.isar.collection<RecurringTransaction>(),
r'recurringTransactions',
id);
}
extension AccountQueryWhereSort on QueryBuilder<Account, Account, QWhere> {
QueryBuilder<Account, Account, QAfterWhere> anyId() {
return QueryBuilder.apply(this, (query) {
return query.addWhereClause(const IdWhereClause.any());
});
}
}
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,
));
});
}
QueryBuilder<Account, Account, 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<Account, Account, QAfterWhereClause> idGreaterThan(Id id,
{bool include = false}) {
return QueryBuilder.apply(this, (query) {
return query.addWhereClause(
IdWhereClause.greaterThan(lower: id, includeLower: include),
);
});
}
QueryBuilder<Account, Account, QAfterWhereClause> idLessThan(Id id,
{bool include = false}) {
return QueryBuilder.apply(this, (query) {
return query.addWhereClause(
IdWhereClause.lessThan(upper: id, includeUpper: include),
);
});
}
QueryBuilder<Account, Account, 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 AccountQueryFilter
on QueryBuilder<Account, Account, QFilterCondition> {
QueryBuilder<Account, Account, QAfterFilterCondition> idEqualTo(Id value) {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(FilterCondition.equalTo(
property: r'id',
value: value,
));
});
}
QueryBuilder<Account, Account, 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<Account, Account, 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<Account, Account, 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<Account, Account, 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<Account, Account, 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<Account, Account, 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<Account, Account, 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<Account, Account, 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<Account, Account, 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<Account, Account, 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<Account, Account, 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<Account, Account, QAfterFilterCondition> nameIsEmpty() {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(FilterCondition.equalTo(
property: r'name',
value: '',
));
});
}
QueryBuilder<Account, Account, QAfterFilterCondition> nameIsNotEmpty() {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(FilterCondition.greaterThan(
property: r'name',
value: '',
));
});
}
}
extension AccountQueryObject
on QueryBuilder<Account, Account, QFilterCondition> {}
extension AccountQueryLinks
on QueryBuilder<Account, Account, QFilterCondition> {
QueryBuilder<Account, Account, QAfterFilterCondition> transactions(
FilterQuery<Transaction> q) {
return QueryBuilder.apply(this, (query) {
return query.link(q, r'transactions');
});
}
QueryBuilder<Account, Account, QAfterFilterCondition>
transactionsLengthEqualTo(int length) {
return QueryBuilder.apply(this, (query) {
return query.linkLength(r'transactions', length, true, length, true);
});
}
QueryBuilder<Account, Account, QAfterFilterCondition> transactionsIsEmpty() {
return QueryBuilder.apply(this, (query) {
return query.linkLength(r'transactions', 0, true, 0, true);
});
}
QueryBuilder<Account, Account, QAfterFilterCondition>
transactionsIsNotEmpty() {
return QueryBuilder.apply(this, (query) {
return query.linkLength(r'transactions', 0, false, 999999, true);
});
}
QueryBuilder<Account, Account, QAfterFilterCondition>
transactionsLengthLessThan(int length, {
bool include = false,
}) {
return QueryBuilder.apply(this, (query) {
return query.linkLength(r'transactions', 0, true, length, include);
});
}
QueryBuilder<Account, Account, QAfterFilterCondition>
transactionsLengthGreaterThan(int length, {
bool include = false,
}) {
return QueryBuilder.apply(this, (query) {
return query.linkLength(r'transactions', length, include, 999999, true);
});
}
QueryBuilder<Account, Account, QAfterFilterCondition>
transactionsLengthBetween(int lower,
int upper, {
bool includeLower = true,
bool includeUpper = true,
}) {
return QueryBuilder.apply(this, (query) {
return query.linkLength(
r'transactions', lower, includeLower, upper, includeUpper);
});
}
QueryBuilder<Account, Account, QAfterFilterCondition> recurringTransactions(
FilterQuery<RecurringTransaction> q) {
return QueryBuilder.apply(this, (query) {
return query.link(q, r'recurringTransactions');
});
}
QueryBuilder<Account, Account, QAfterFilterCondition>
recurringTransactionsLengthEqualTo(int length) {
return QueryBuilder.apply(this, (query) {
return query.linkLength(
r'recurringTransactions', length, true, length, true);
});
}
QueryBuilder<Account, Account, QAfterFilterCondition>
recurringTransactionsIsEmpty() {
return QueryBuilder.apply(this, (query) {
return query.linkLength(r'recurringTransactions', 0, true, 0, true);
});
}
QueryBuilder<Account, Account, QAfterFilterCondition>
recurringTransactionsIsNotEmpty() {
return QueryBuilder.apply(this, (query) {
return query.linkLength(r'recurringTransactions', 0, false, 999999, true);
});
}
QueryBuilder<Account, Account, QAfterFilterCondition>
recurringTransactionsLengthLessThan(int length, {
bool include = false,
}) {
return QueryBuilder.apply(this, (query) {
return query.linkLength(
r'recurringTransactions', 0, true, length, include);
});
}
QueryBuilder<Account, Account, QAfterFilterCondition>
recurringTransactionsLengthGreaterThan(int length, {
bool include = false,
}) {
return QueryBuilder.apply(this, (query) {
return query.linkLength(
r'recurringTransactions', length, include, 999999, true);
});
}
QueryBuilder<Account, Account, QAfterFilterCondition>
recurringTransactionsLengthBetween(int lower,
int upper, {
bool includeLower = true,
bool includeUpper = true,
}) {
return QueryBuilder.apply(this, (query) {
return query.linkLength(
r'recurringTransactions', lower, includeLower, upper, includeUpper);
});
}
}
extension AccountQuerySortBy on QueryBuilder<Account, Account, QSortBy> {
QueryBuilder<Account, Account, QAfterSortBy> sortByName() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'name', Sort.asc);
});
}
QueryBuilder<Account, Account, QAfterSortBy> sortByNameDesc() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'name', Sort.desc);
});
}
}
extension AccountQuerySortThenBy
on QueryBuilder<Account, Account, QSortThenBy> {
QueryBuilder<Account, Account, QAfterSortBy> thenById() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'id', Sort.asc);
});
}
QueryBuilder<Account, Account, QAfterSortBy> thenByIdDesc() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'id', Sort.desc);
});
}
QueryBuilder<Account, Account, QAfterSortBy> thenByName() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'name', Sort.asc);
});
}
QueryBuilder<Account, Account, QAfterSortBy> thenByNameDesc() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'name', Sort.desc);
});
}
}
extension AccountQueryWhereDistinct
on QueryBuilder<Account, Account, QDistinct> {
QueryBuilder<Account, Account, QDistinct> distinctByName(
{bool caseSensitive = true}) {
return QueryBuilder.apply(this, (query) {
return query.addDistinctBy(r'name', caseSensitive: caseSensitive);
});
}
}
extension AccountQueryProperty
on QueryBuilder<Account, Account, QQueryProperty> {
QueryBuilder<Account, int, QQueryOperations> idProperty() {
return QueryBuilder.apply(this, (query) {
return query.addPropertyName(r'id');
});
}
QueryBuilder<Account, String, QQueryOperations> nameProperty() {
return QueryBuilder.apply(this, (query) {
return query.addPropertyName(r'name');
});
}
}

59
lib/Entities/drift_database.dart Normal file
View File

@@ -0,0 +1,59 @@
import 'package:drift/drift.dart';
import 'package:drift_flutter/drift_flutter.dart';
import 'time_frame_enum.dart';
part 'drift_database.g.dart';
class Accounts extends Table {
IntColumn get id => integer().autoIncrement()();
TextColumn get name => text().withDefault(const Constant(''))();
}
class Transactions extends Table {
IntColumn get id => integer().autoIncrement()();
TextColumn get name => text().withDefault(const Constant(''))();
DateTimeColumn get date => dateTime().nullable()();
RealColumn get amount => real().withDefault(const Constant(0.0))();
IntColumn get accountId => integer().references(Accounts, #id)();
IntColumn get recurringTransactionId =>
integer().nullable().references(RecurringTransactions, #id)();
}
class RecurringTransactions extends Table {
IntColumn get id => integer().autoIncrement()();
TextColumn get name => text().withDefault(const Constant(''))();
DateTimeColumn get startDate => dateTime().nullable()();
IntColumn get timeFrame => intEnum<TimeFrameEnum>()();
RealColumn get amount => real().withDefault(const Constant(0.0))();
IntColumn get accountId => integer().references(Accounts, #id)();
}
@DriftDatabase(tables: [Accounts, Transactions, RecurringTransactions])
class AppDatabase extends _$AppDatabase {
AppDatabase() : super(_openConnection());
@override
int get schemaVersion => 1;
static QueryExecutor _openConnection() {
return driftDatabase(
name: 'dragon_ledger',
web: DriftWebOptions(
sqlite3Wasm: Uri.parse('sqlite3.wasm'),
driftWorker: Uri.parse('drift_worker.js'),
),
);
}
}

2323
lib/Entities/drift_database.g.dart Normal file
View File

File diff suppressed because it is too large Load Diff

38
lib/Entities/recurring_transaction.dart
View File

@@ -1,38 +0,0 @@
import 'package:isar/isar.dart';
import 'account.dart';
import 'time_frame_enum.dart';
import 'transaction.dart';
part 'recurring_transaction.g.dart';
/// Stellt eine wiederkehrende Transaktion dar
@collection
class RecurringTransaction {
/// Die Id der wiederkehrenden Transaktion
Id id = Isar.autoIncrement;
/// Der Name der wiederkehrenden Transaktion
String name = '';
/// Das Startdatum ab wann diese wiederkehrende Transaktion belastet wird
DateTime? startDate;
/// Der Zeitraum der wiederkehrenden Transaktion
@enumerated
TimeFrameEnum timeFrame = TimeFrameEnum.monthly;
/// 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>();
/// Stellt das Konto dar, zu welchem diese wiederkehrende Transaktion gehört.
final IsarLink<Account> account = IsarLink<Account>();
@override
String toString() => '${super.toString()}($id: $name)';
}

943
lib/Entities/recurring_transaction.g.dart
View File

@@ -1,943 +0,0 @@
// 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');
});
}
}

33
lib/Entities/transaction.dart
View File

@@ -1,33 +0,0 @@
import 'package:isar/isar.dart';
import 'account.dart';
import 'recurring_transaction.dart';
part 'transaction.g.dart';
/// Die Klasse stellt eine Transaktion dar.
@collection
class Transaction {
/// Die Id der Transaktion
Id id = Isar.autoIncrement;
/// Der Name der Transaktion
String name = '';
/// Der Tag an der die Transaktion getätigt wurde
DateTime? date;
/// 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>();
/// Stellt das Konto dar, zu welchem diese Transaktion gehört.
final IsarLink<Account> account = IsarLink<Account>();
@override
String toString() => '${super.toString()}($id: $name)';
}

701
lib/Entities/transaction.g.dart
View File

@@ -1,701 +0,0 @@
// GENERATED CODE - DO NOT MODIFY BY HAND
part of '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 GetTransactionCollection on Isar {
IsarCollection<Transaction> get transactions => this.collection();
}
const TransactionSchema = CollectionSchema(
name: r'Transaction',
id: 5320225499417954855,
properties: {
r'amount': PropertySchema(
id: 0,
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,
deserialize: _transactionDeserialize,
deserializeProp: _transactionDeserializeProp,
idName: r'id',
indexes: {},
links: {
r'recurringTransaction': LinkSchema(
id: 8918082780894736839,
name: r'recurringTransaction',
target: r'RecurringTransaction',
single: true,
),
r'account': LinkSchema(
id: -8467990729867616553,
name: r'account',
target: r'Account',
single: true,
)
},
embeddedSchemas: {},
getId: _transactionGetId,
getLinks: _transactionGetLinks,
attach: _transactionAttach,
version: '3.1.0+1',
);
int _transactionEstimateSize(
Transaction object,
List<int> offsets,
Map<Type, List<int>> allOffsets,
) {
var bytesCount = offsets.last;
bytesCount += 3 + object.name.length * 3;
return bytesCount;
}
void _transactionSerialize(
Transaction object,
IsarWriter writer,
List<int> offsets,
Map<Type, List<int>> allOffsets,
) {
writer.writeDouble(offsets[0], object.amount);
writer.writeDateTime(offsets[1], object.date);
writer.writeString(offsets[2], object.name);
}
Transaction _transactionDeserialize(
Id id,
IsarReader reader,
List<int> offsets,
Map<Type, List<int>> allOffsets,
) {
final object = Transaction();
object.amount = reader.readDouble(offsets[0]);
object.date = reader.readDateTimeOrNull(offsets[1]);
object.id = id;
object.name = reader.readString(offsets[2]);
return object;
}
P _transactionDeserializeProp<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.readDateTimeOrNull(offset)) as P;
case 2:
return (reader.readString(offset)) as P;
default:
throw IsarError('Unknown property with id $propertyId');
}
}
Id _transactionGetId(Transaction object) {
return object.id;
}
List<IsarLinkBase<dynamic>> _transactionGetLinks(Transaction object) {
return [object.recurringTransaction, object.account];
}
void _transactionAttach(IsarCollection<dynamic> col, Id id,
Transaction object) {
object.id = id;
object.recurringTransaction.attach(col,
col.isar.collection<RecurringTransaction>(), r'recurringTransaction', id);
object.account.attach(col, col.isar.collection<Account>(), r'account', id);
}
extension TransactionQueryWhereSort
on QueryBuilder<Transaction, Transaction, QWhere> {
QueryBuilder<Transaction, Transaction, QAfterWhere> anyId() {
return QueryBuilder.apply(this, (query) {
return query.addWhereClause(const IdWhereClause.any());
});
}
}
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,
));
});
}
QueryBuilder<Transaction, Transaction, 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<Transaction, Transaction, QAfterWhereClause> idGreaterThan(Id id,
{bool include = false}) {
return QueryBuilder.apply(this, (query) {
return query.addWhereClause(
IdWhereClause.greaterThan(lower: id, includeLower: include),
);
});
}
QueryBuilder<Transaction, Transaction, QAfterWhereClause> idLessThan(Id id,
{bool include = false}) {
return QueryBuilder.apply(this, (query) {
return query.addWhereClause(
IdWhereClause.lessThan(upper: id, includeUpper: include),
);
});
}
QueryBuilder<Transaction, Transaction, 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 TransactionQueryFilter
on QueryBuilder<Transaction, Transaction, QFilterCondition> {
QueryBuilder<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, QAfterFilterCondition> dateIsNull() {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(const FilterCondition.isNull(
property: r'date',
));
});
}
QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
dateIsNotNull() {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(const FilterCondition.isNotNull(
property: r'date',
));
});
}
QueryBuilder<Transaction, Transaction, QAfterFilterCondition> dateEqualTo(
DateTime? value) {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(FilterCondition.equalTo(
property: r'date',
value: value,
));
});
}
QueryBuilder<Transaction, Transaction, QAfterFilterCondition> dateGreaterThan(
DateTime? value, {
bool include = false,
}) {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(FilterCondition.greaterThan(
include: include,
property: r'date',
value: value,
));
});
}
QueryBuilder<Transaction, Transaction, QAfterFilterCondition> dateLessThan(
DateTime? value, {
bool include = false,
}) {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(FilterCondition.lessThan(
include: include,
property: r'date',
value: value,
));
});
}
QueryBuilder<Transaction, Transaction, QAfterFilterCondition> dateBetween(
DateTime? lower,
DateTime? upper, {
bool includeLower = true,
bool includeUpper = true,
}) {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(FilterCondition.between(
property: r'date',
lower: lower,
includeLower: includeLower,
upper: upper,
includeUpper: includeUpper,
));
});
}
QueryBuilder<Transaction, Transaction, QAfterFilterCondition> idEqualTo(
Id value) {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(FilterCondition.equalTo(
property: r'id',
value: value,
));
});
}
QueryBuilder<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, 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<Transaction, Transaction, QAfterFilterCondition> nameIsEmpty() {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(FilterCondition.equalTo(
property: r'name',
value: '',
));
});
}
QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
nameIsNotEmpty() {
return QueryBuilder.apply(this, (query) {
return query.addFilterCondition(FilterCondition.greaterThan(
property: r'name',
value: '',
));
});
}
}
extension TransactionQueryObject
on QueryBuilder<Transaction, Transaction, QFilterCondition> {}
extension TransactionQueryLinks
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);
});
}
QueryBuilder<Transaction, Transaction, QAfterFilterCondition> account(
FilterQuery<Account> q) {
return QueryBuilder.apply(this, (query) {
return query.link(q, r'account');
});
}
QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
accountIsNull() {
return QueryBuilder.apply(this, (query) {
return query.linkLength(r'account', 0, true, 0, true);
});
}
}
extension TransactionQuerySortBy
on QueryBuilder<Transaction, Transaction, QSortBy> {
QueryBuilder<Transaction, Transaction, QAfterSortBy> sortByAmount() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'amount', Sort.asc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> sortByAmountDesc() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'amount', Sort.desc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> sortByDate() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'date', Sort.asc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> sortByDateDesc() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'date', Sort.desc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> sortByName() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'name', Sort.asc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> sortByNameDesc() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'name', Sort.desc);
});
}
}
extension TransactionQuerySortThenBy
on QueryBuilder<Transaction, Transaction, QSortThenBy> {
QueryBuilder<Transaction, Transaction, QAfterSortBy> thenByAmount() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'amount', Sort.asc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> thenByAmountDesc() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'amount', Sort.desc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> thenByDate() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'date', Sort.asc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> thenByDateDesc() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'date', Sort.desc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> thenById() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'id', Sort.asc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> thenByIdDesc() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'id', Sort.desc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> thenByName() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'name', Sort.asc);
});
}
QueryBuilder<Transaction, Transaction, QAfterSortBy> thenByNameDesc() {
return QueryBuilder.apply(this, (query) {
return query.addSortBy(r'name', Sort.desc);
});
}
}
extension TransactionQueryWhereDistinct
on QueryBuilder<Transaction, Transaction, QDistinct> {
QueryBuilder<Transaction, Transaction, QDistinct> distinctByAmount() {
return QueryBuilder.apply(this, (query) {
return query.addDistinctBy(r'amount');
});
}
QueryBuilder<Transaction, Transaction, QDistinct> distinctByDate() {
return QueryBuilder.apply(this, (query) {
return query.addDistinctBy(r'date');
});
}
QueryBuilder<Transaction, Transaction, QDistinct> distinctByName(
{bool caseSensitive = true}) {
return QueryBuilder.apply(this, (query) {
return query.addDistinctBy(r'name', caseSensitive: caseSensitive);
});
}
}
extension TransactionQueryProperty
on QueryBuilder<Transaction, Transaction, QQueryProperty> {
QueryBuilder<Transaction, int, QQueryOperations> idProperty() {
return QueryBuilder.apply(this, (query) {
return query.addPropertyName(r'id');
});
}
QueryBuilder<Transaction, double, QQueryOperations> amountProperty() {
return QueryBuilder.apply(this, (query) {
return query.addPropertyName(r'amount');
});
}
QueryBuilder<Transaction, DateTime?, QQueryOperations> dateProperty() {
return QueryBuilder.apply(this, (query) {
return query.addPropertyName(r'date');
});
}
QueryBuilder<Transaction, String, QQueryOperations> nameProperty() {
return QueryBuilder.apply(this, (query) {
return query.addPropertyName(r'name');
});
}
}