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

This commit is contained in:
2025-12-24 01:04:38 +01:00
parent 673d7de21c
commit c11515d447
23 changed files with 15995 additions and 2601 deletions

View File

@@ -1,3 +1,15 @@
# DragonLedger 🐉📒
Eine Flutter-App um den Überblick über wiederkehrende Transaktionen und den damit verbunden Kontostand zu behalten.
# Fürs Debuggen:
`flutter run --web-header=Cross-Origin-Opener-Policy=same-origin --web-header=Cross-Origin-Embedder-Policy=require-corp`
## Release TODO:
Webserver Header:
- `Cross-Origin-Opener-Policy: same-origin`
- `Cross-Origin-Embedder-Policy: require-corp`
- sqlite3.wasm braucht `Content-Type: application/wasm`

View File

@@ -9,6 +9,10 @@
# packages, and plugins designed to encourage good coding practices.
include: package:flutter_lints/flutter.yaml
analyzer:
exclude:
- "**/*.g.dart"
linter:
# The lint rules applied to this project can be customized in the
# section below to disable rules from the `package:flutter_lints/flutter.yaml`

View File

@@ -1,9 +1,10 @@
import 'dart:async';
import 'package:drift/drift.dart';
import 'package:flutter/material.dart';
import '../Entities/account.dart';
import '../Entities/dialog_type_enum.dart';
import '../Entities/drift_database.dart';
import '../Pages/Dialog/dialog_action.dart';
import '../Pages/Dialog/dialog_input_field.dart';
import '../Pages/Dialog/dynamic_dialog.dart';
@@ -65,7 +66,7 @@ class AccountController {
await _errorNameEmptyDialog?.show(_buildContext!);
}
} else {
final account = Account()..name = values['name']!;
final account = AccountsCompanion(name: Value(values['name']!));
await _accountRepository.add(account);
await _accountCreatedDialog?.show(_buildContext!);

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)';
}

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');
});
}
}

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'),
),
);
}
}

File diff suppressed because it is too large Load Diff

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)';
}

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');
});
}
}

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)';
}

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');
});
}
}

View File

@@ -1,32 +1,28 @@
import 'package:isar/isar.dart';
import 'package:drift/drift.dart';
import '../Entities/account.dart';
import '../Services/isar_service.dart';
import '../Entities/drift_database.dart';
import '../Services/database_service.dart';
/// Funktionen zum interagieren mit der Datenbank für die Konten
class AccountRepository {
final IsarService _isarService = IsarService();
final AppDatabase _db = DatabaseService().database;
/// Fügt ein neues Konto zur Datenbank hinzu
Future<Account?> add(final Account account) async {
final Isar isar = await _isarService.getDatabase();
final int id = await isar.writeTxn(() => isar.accounts.put(account));
Future<Account?> add(final AccountsCompanion account) async {
final int id = await _db.into(_db.accounts).insert(account);
return find(id);
}
/// Entfernt ein Konto aus der Datenbank
Future<bool> remove(final Account account) async {
final Isar isar = await _isarService.getDatabase();
return isar.writeTxn(() => isar.accounts.delete(account.id));
Future<int> remove(final Account account) async {
return (_db.delete(_db.accounts)
..where((t) => t.id.equals(account.id))).go();
}
/// Sucht ein Konto anhand seiner Id aus der Datenbank
Future<Account?> find(final int id) async {
final Isar isar = await _isarService.getDatabase();
return isar.accounts.get(id);
return (_db.select(_db.accounts)
..where((t) => t.id.equals(id))).getSingleOrNull();
}
/// Sucht Konten anhand der gegebenen Parameter aus der Datenbank
@@ -35,31 +31,27 @@ class AccountRepository {
final String? name,
final String? orderBy,
}) async {
final Isar isar = await _isarService.getDatabase();
final query = _db.select(_db.accounts);
final QueryBuilder<Account, Account, QAfterFilterCondition> baseQuery = isar
.accounts
.filter()
.optional(
id != null,
(final QueryBuilder<Account, Account, QFilterCondition> q) =>
q.idEqualTo(id!),
)
.optional(
name != null && name.isNotEmpty,
(final QueryBuilder<Account, Account, QAfterFilterCondition> q) =>
q.nameMatches('*$name*', caseSensitive: false),
);
if (id != null) {
query.where((t) => t.id.equals(id));
}
if (name != null && name.isNotEmpty) {
query.where((t) => t.name.like('%$name%'));
}
if (orderBy != null) {
switch (orderBy) {
case 'nameAsc':
return baseQuery.sortByName().findAll();
query.orderBy([(t) => OrderingTerm.asc(t.name)]);
break;
case 'nameDesc':
return baseQuery.sortByNameDesc().findAll();
default:
return baseQuery.findAll();
query.orderBy([(t) => OrderingTerm.desc(t.name)]);
break;
}
}
return query.get();
}
}

View File

@@ -1,132 +1,116 @@
import 'package:isar/isar.dart';
import 'package:drift/drift.dart';
import '../Entities/recurring_transaction.dart';
import '../Entities/drift_database.dart';
import '../Entities/time_frame_enum.dart';
import '../Services/isar_service.dart';
import '../Services/database_service.dart';
/// Funktionen zum interagieren mit der Datenbank für die Transaktionen
class RecurringTransactionRepository {
final IsarService _isarService = IsarService();
final AppDatabase _db = DatabaseService().database;
/// Fügt eine neue wiederkehrende Transaktion zur Datenbank hinzu
Future<RecurringTransaction?> add(
final RecurringTransaction recurringTransaction,
final RecurringTransactionsCompanion recurringTransaction,
) async {
final Isar isar = await _isarService.getDatabase();
final int id = await isar.writeTxn(
() => isar.recurringTransactions.put(recurringTransaction),
);
final int id = await _db.into(_db.recurringTransactions).insert(
recurringTransaction);
return find(id);
}
/// Entfernt eine wiederkehrende Transaktion aus der Datenbank
Future<bool> remove(final RecurringTransaction recurringTransaction) async {
final Isar isar = await _isarService.getDatabase();
return isar.writeTxn(
() => isar.recurringTransactions.delete(recurringTransaction.id),
);
Future<int> remove(final RecurringTransaction recurringTransaction) async {
return (_db.delete(_db.recurringTransactions)
..where((t) => t.id.equals(recurringTransaction.id))).go();
}
/// Sucht eine wiederkehrende Transaktion anhand seiner Id aus der Datenbank
Future<RecurringTransaction?> find(final int id) async {
final Isar isar = await _isarService.getDatabase();
return isar.recurringTransactions.get(id);
return (_db.select(_db.recurringTransactions)
..where((t) => t.id.equals(id))).getSingleOrNull();
}
/// Sucht wiederkehrende Transaktionen anhand der gegebenen Parameter
/// aus der Datenbank
/// Sucht wiederkehrende Transaktionen anhand der gegebenen Parameter
Future<List<RecurringTransaction>> findBy({
final int? id,
final String? name,
final DateTime? startDate,
final DateTime? startDateBefore,
final DateTime? startDateAfter,
final DateTime? startDateFrom,
final DateTime? startDateTo,
final TimeFrameEnum? timeFrame,
final double? amount,
final double? amountMin,
final double? amountMax,
final String? orderBy,
}) async {
final Isar isar = await _isarService.getDatabase();
final query = _db.select(_db.recurringTransactions);
final QueryBuilder<
RecurringTransaction,
RecurringTransaction,
QAfterFilterCondition
>
baseQuery = isar.recurringTransactions
.filter()
.optional(id != null, (final q) => q.idEqualTo(id!))
.optional(
name != null && name.isNotEmpty,
(final q) => q.nameMatches('*$name*', caseSensitive: false),
)
// --- StartDate Filter ---
.optional(startDate != null, (final q) => q.startDateEqualTo(startDate))
.optional(
startDateAfter != null,
(final q) => q.startDateGreaterThan(startDateAfter),
)
.optional(
startDateBefore != null,
(final q) => q.startDateLessThan(startDateBefore),
)
.optional(
startDateFrom != null && startDateTo != null,
(final q) => q.startDateBetween(startDateFrom, startDateTo),
)
// --- TimeFrame ---
.optional(
timeFrame != null,
(final q) => q.timeFrameEqualTo(timeFrame!),
)
// --- Amount Filter ---
.optional(amount != null, (final q) => q.amountEqualTo(amount!))
.optional(
amountMin != null && amountMax == null,
(final q) => q.amountGreaterThan(amountMin!),
)
.optional(
amountMin == null && amountMax != null,
(final q) => q.amountLessThan(amountMax!),
)
.optional(
amountMin != null && amountMax != null,
(final q) => q.amountBetween(amountMin!, amountMax!),
);
if (id != null) {
query.where((t) => t.id.equals(id));
}
// --- Sortierung ---
if (name != null && name.isNotEmpty) {
query.where((t) => t.name.like('%$name%'));
}
if (startDate != null) {
query.where((t) => t.startDate.equals(startDate));
}
if (startDateAfter != null) {
query.where((t) => t.startDate.isBiggerThanValue(startDateAfter));
}
if (startDateBefore != null) {
query.where((t) => t.startDate.isSmallerThanValue(startDateBefore));
}
if (startDateFrom != null && startDateTo != null) {
query.where((t) =>
t.startDate.isBetweenValues(startDateFrom, startDateTo));
}
if (timeFrame != null) {
query.where((t) => t.timeFrame.equals(timeFrame.index));
}
if (amount != null) {
query.where((t) => t.amount.equals(amount));
}
if (amountMin != null) {
query.where((t) => t.amount.isBiggerThanValue(amountMin));
}
if (amountMax != null) {
query.where((t) => t.amount.isSmallerThanValue(amountMax));
}
if (orderBy != null) {
switch (orderBy) {
case 'nameAsc':
return baseQuery.sortByName().findAll();
query.orderBy([(t) => OrderingTerm.asc(t.name)]);
break;
case 'nameDesc':
return baseQuery.sortByNameDesc().findAll();
query.orderBy([(t) => OrderingTerm.desc(t.name)]);
break;
case 'amountAsc':
return baseQuery.sortByAmount().findAll();
query.orderBy([(t) => OrderingTerm.asc(t.amount)]);
break;
case 'amountDesc':
return baseQuery.sortByAmountDesc().findAll();
query.orderBy([(t) => OrderingTerm.desc(t.amount)]);
break;
case 'startDateAsc':
return baseQuery.sortByStartDate().findAll();
query.orderBy([(t) => OrderingTerm.asc(t.startDate)]);
break;
case 'startDateDesc':
return baseQuery.sortByStartDateDesc().findAll();
default:
return baseQuery.findAll();
query.orderBy([(t) => OrderingTerm.desc(t.startDate)]);
break;
}
}
return query.get();
}
}

View File

@@ -1,34 +1,28 @@
import 'package:isar/isar.dart';
import 'package:drift/drift.dart';
import '../Entities/transaction.dart';
import '../Services/isar_service.dart';
import '../Entities/drift_database.dart';
import '../Services/database_service.dart';
/// Funktionen zum interagieren mit der Datenbank für die Transaktionen
class TransactionRepository {
final IsarService _isarService = IsarService();
final AppDatabase _db = DatabaseService().database;
/// Fügt eine neue Transaktion zur Datenbank hinzu
Future<Transaction?> add(final Transaction transaction) async {
final Isar isar = await _isarService.getDatabase();
final int id = await isar.writeTxn(
() => isar.transactions.put(transaction),
);
Future<Transaction?> add(final TransactionsCompanion transaction) async {
final int id = await _db.into(_db.transactions).insert(transaction);
return find(id);
}
/// Entfernt eine Transaktion aus der Datenbank
Future<bool> remove(final Transaction transaction) async {
final Isar isar = await _isarService.getDatabase();
return isar.writeTxn(() => isar.transactions.delete(transaction.id));
Future<int> remove(final Transaction transaction) async {
return (_db.delete(_db.transactions)
..where((t) => t.id.equals(transaction.id))).go();
}
/// Sucht eine Transaktion anhand seiner Id aus der Datenbank
Future<Transaction?> find(final int id) async {
final Isar isar = await _isarService.getDatabase();
return isar.transactions.get(id);
return (_db.select(_db.transactions)
..where((t) => t.id.equals(id))).getSingleOrNull();
}
/// Sucht Transaktionen anhand der gegebenen Parameter aus der Datenbank
@@ -43,85 +37,63 @@ class TransactionRepository {
final double? amountMax,
final String? orderBy,
}) async {
final Isar isar = await _isarService.getDatabase();
final query = _db.select(_db.transactions);
final QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
baseQuery = isar.transactions
.filter()
.optional(
id != null,
(final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
q.idEqualTo(id!),
)
.optional(
name != null && name.isNotEmpty,
(
final QueryBuilder<Transaction, Transaction, QAfterFilterCondition>
q,
) => q.nameMatches('*$name*', caseSensitive: false),
)
.optional(
date != null,
(final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
q.dateEqualTo(date),
)
.optional(
dateBefore != null && dateAfter == null,
(final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
q.dateGreaterThan(dateBefore),
)
.optional(
dateBefore == null && dateAfter != null,
(final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
q.dateLessThan(dateAfter),
)
.optional(
dateBefore != null && dateAfter != null,
(final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
q.dateBetween(dateBefore, dateAfter),
)
.optional(
amount != null,
(final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
q.amountEqualTo(amount!),
)
.optional(
amountMin != null && amountMax == null,
(final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
q.amountGreaterThan(amountMin!),
)
.optional(
amountMin == null && amountMax != null,
(final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
q.amountLessThan(amountMax!),
)
.optional(
amountMin != null && amountMax != null,
(final QueryBuilder<Transaction, Transaction, QFilterCondition> q) =>
q.amountBetween(amountMin!, amountMax!),
);
if (id != null) {
query.where((t) => t.id.equals(id));
}
if (name != null && name.isNotEmpty) {
query.where((t) => t.name.like('%$name%'));
}
if (date != null) {
query.where((t) => t.date.equals(date));
}
if (dateBefore != null) {
query.where((t) => t.date.isBiggerThanValue(dateBefore));
}
if (dateAfter != null) {
query.where((t) => t.date.isSmallerThanValue(dateAfter));
}
if (amount != null) {
query.where((t) => t.amount.equals(amount));
}
if (amountMin != null) {
query.where((t) => t.amount.isBiggerThanValue(amountMin));
}
if (amountMax != null) {
query.where((t) => t.amount.isSmallerThanValue(amountMax));
}
if (orderBy != null) {
switch (orderBy) {
case 'nameAsc':
return baseQuery.sortByName().findAll();
query.orderBy([(t) => OrderingTerm.asc(t.name)]);
break;
case 'nameDesc':
return baseQuery.sortByNameDesc().findAll();
query.orderBy([(t) => OrderingTerm.desc(t.name)]);
break;
case 'dateAsc':
return baseQuery.sortByDate().findAll();
query.orderBy([(t) => OrderingTerm.asc(t.date)]);
break;
case 'dateDesc':
return baseQuery.sortByDateDesc().findAll();
query.orderBy([(t) => OrderingTerm.desc(t.date)]);
break;
case 'amountAsc':
return baseQuery.sortByAmount().findAll();
query.orderBy([(t) => OrderingTerm.asc(t.amount)]);
break;
case 'amountDesc':
return baseQuery.sortByAmountDesc().findAll();
default:
return baseQuery.findAll();
query.orderBy([(t) => OrderingTerm.desc(t.amount)]);
break;
}
}
return query.get();
}
}

View File

@@ -0,0 +1,16 @@
import '../Entities/drift_database.dart';
class DatabaseService {
factory DatabaseService() => _instance;
DatabaseService._internal();
static final DatabaseService _instance = DatabaseService._internal();
AppDatabase? _database;
AppDatabase get database {
_database ??= AppDatabase();
return _database!;
}
}

View File

@@ -1,40 +0,0 @@
import 'dart:io';
import 'package:isar/isar.dart';
import 'package:path_provider/path_provider.dart';
import '../Entities/account.dart';
import '../Entities/recurring_transaction.dart';
import '../Entities/transaction.dart';
/// Ein Service um auf die Datenbank zuzugreifen
class IsarService {
/// Gibt eine gültige Instanz der Klasse zurück
factory IsarService() => _instance;
/// Initialisiert eine neue Instanz dieser Klasse
IsarService._internal();
static final _instance = IsarService._internal();
Isar? _isar;
/// Gibt die Datenbank zurück.
Future<Isar> getDatabase() async {
if (_isar == null) {
await _initializeDatabase();
}
return _isar!;
}
/// Initialisiert die Datenbank
Future<void> _initializeDatabase() async {
final Directory dir = await getApplicationDocumentsDirectory();
_isar = await Isar.open([
AccountSchema,
TransactionSchema,
RecurringTransactionSchema,
], directory: dir.path);
}
}

View File

@@ -6,11 +6,11 @@
#include "generated_plugin_registrant.h"
#include <isar_flutter_libs/isar_flutter_libs_plugin.h>
#include <sqlite3_flutter_libs/sqlite3_flutter_libs_plugin.h>
void fl_register_plugins(FlPluginRegistry* registry) {
g_autoptr(FlPluginRegistrar)
isar_flutter_libs_registrar =
fl_plugin_registry_get_registrar_for_plugin(registry, "IsarFlutterLibsPlugin");
isar_flutter_libs_plugin_register_with_registrar(isar_flutter_libs_registrar);
sqlite3_flutter_libs_registrar =
fl_plugin_registry_get_registrar_for_plugin(registry, "Sqlite3FlutterLibsPlugin");
sqlite3_flutter_libs_plugin_register_with_registrar(sqlite3_flutter_libs_registrar);
}

View File

@@ -3,7 +3,7 @@
#
list(APPEND FLUTTER_PLUGIN_LIST
isar_flutter_libs
sqlite3_flutter_libs
)
list(APPEND FLUTTER_FFI_PLUGIN_LIST

View File

@@ -28,6 +28,8 @@ environment:
# the latest version available on pub.dev. To see which dependencies have newer
# versions available, run `flutter pub outdated`.
dependencies:
drift: ^2.30.0
drift_flutter: ^0.2.8
dropdown_search: ^6.0.2
fl_chart: ^1.1.1
flutter:
@@ -35,25 +37,17 @@ dependencies:
flutter_expandable_fab: ^2.5.2
flutter_sticky_header: ^0.8.0
font_awesome_flutter: ^10.10.0
isar: ^3.1.0+1
isar_flutter_libs: ^3.1.0+1
package_info_plus: ^9.0.0
path_provider: ^2.1.5
routemaster: ^1.0.1
dev_dependencies:
build_runner: ^2.10.4
drift_dev: ^2.30.0
flutter_lints: ^6.0.0
flutter_test:
sdk: flutter
# The "flutter_lints" package below contains a set of recommended lints to
# encourage good coding practices. The lint set provided by the package is
# activated in the `analysis_options.yaml` file located at the root of your
# package. See that file for information about deactivating specific lint
# rules and activating additional ones.
isar_generator: ^3.1.0+1
build_runner: ^2.4.13
# For information on the generic Dart part of this file, see the
# following page: https://dart.dev/tools/pub/pubspec

13389
web/drift_worker.js Normal file

File diff suppressed because one or more lines are too long

BIN
web/sqlite3.wasm Normal file

Binary file not shown.

View File

@@ -6,9 +6,9 @@
#include "generated_plugin_registrant.h"
#include <isar_flutter_libs/isar_flutter_libs_plugin.h>
#include <sqlite3_flutter_libs/sqlite3_flutter_libs_plugin.h>
void RegisterPlugins(flutter::PluginRegistry* registry) {
IsarFlutterLibsPluginRegisterWithRegistrar(
registry->GetRegistrarForPlugin("IsarFlutterLibsPlugin"));
Sqlite3FlutterLibsPluginRegisterWithRegistrar(
registry->GetRegistrarForPlugin("Sqlite3FlutterLibsPlugin"));
}

View File

@@ -3,7 +3,7 @@
#
list(APPEND FLUTTER_PLUGIN_LIST
isar_flutter_libs
sqlite3_flutter_libs
)
list(APPEND FLUTTER_FFI_PLUGIN_LIST