Jean-Luc Makiola
4b51f5fa04
- Add isActive BoolColumn (default true) to Tasks table - Bump schema version from 2 to 3 with addColumn migration - Filter watchTasksInRoom to isActive=true only - Filter getOverdueTaskCount to isActive=true only - Add softDeleteTask(taskId) - sets isActive=false without removing data - Add getCompletionCount(taskId) - counts TaskCompletions for a task
2423 lines
76 KiB
Dart
2423 lines
76 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $RoomsTable extends Rooms with TableInfo<$RoomsTable, Room> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$RoomsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _nameMeta = const VerificationMeta('name');
|
|
@override
|
|
late final GeneratedColumn<String> name = GeneratedColumn<String>(
|
|
'name',
|
|
aliasedName,
|
|
false,
|
|
additionalChecks: GeneratedColumn.checkTextLength(
|
|
minTextLength: 1,
|
|
maxTextLength: 100,
|
|
),
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _iconNameMeta = const VerificationMeta(
|
|
'iconName',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> iconName = GeneratedColumn<String>(
|
|
'icon_name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _sortOrderMeta = const VerificationMeta(
|
|
'sortOrder',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> sortOrder = GeneratedColumn<int>(
|
|
'sort_order',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(0),
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
clientDefault: () => DateTime.now(),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
name,
|
|
iconName,
|
|
sortOrder,
|
|
createdAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'rooms';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Room> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('name')) {
|
|
context.handle(
|
|
_nameMeta,
|
|
name.isAcceptableOrUnknown(data['name']!, _nameMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_nameMeta);
|
|
}
|
|
if (data.containsKey('icon_name')) {
|
|
context.handle(
|
|
_iconNameMeta,
|
|
iconName.isAcceptableOrUnknown(data['icon_name']!, _iconNameMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_iconNameMeta);
|
|
}
|
|
if (data.containsKey('sort_order')) {
|
|
context.handle(
|
|
_sortOrderMeta,
|
|
sortOrder.isAcceptableOrUnknown(data['sort_order']!, _sortOrderMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Room map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Room(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
iconName: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}icon_name'],
|
|
)!,
|
|
sortOrder: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}sort_order'],
|
|
)!,
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$RoomsTable createAlias(String alias) {
|
|
return $RoomsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Room extends DataClass implements Insertable<Room> {
|
|
final int id;
|
|
final String name;
|
|
final String iconName;
|
|
final int sortOrder;
|
|
final DateTime createdAt;
|
|
const Room({
|
|
required this.id,
|
|
required this.name,
|
|
required this.iconName,
|
|
required this.sortOrder,
|
|
required this.createdAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['name'] = Variable<String>(name);
|
|
map['icon_name'] = Variable<String>(iconName);
|
|
map['sort_order'] = Variable<int>(sortOrder);
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
RoomsCompanion toCompanion(bool nullToAbsent) {
|
|
return RoomsCompanion(
|
|
id: Value(id),
|
|
name: Value(name),
|
|
iconName: Value(iconName),
|
|
sortOrder: Value(sortOrder),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory Room.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Room(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
iconName: serializer.fromJson<String>(json['iconName']),
|
|
sortOrder: serializer.fromJson<int>(json['sortOrder']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'name': serializer.toJson<String>(name),
|
|
'iconName': serializer.toJson<String>(iconName),
|
|
'sortOrder': serializer.toJson<int>(sortOrder),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
Room copyWith({
|
|
int? id,
|
|
String? name,
|
|
String? iconName,
|
|
int? sortOrder,
|
|
DateTime? createdAt,
|
|
}) => Room(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
iconName: iconName ?? this.iconName,
|
|
sortOrder: sortOrder ?? this.sortOrder,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
Room copyWithCompanion(RoomsCompanion data) {
|
|
return Room(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
iconName: data.iconName.present ? data.iconName.value : this.iconName,
|
|
sortOrder: data.sortOrder.present ? data.sortOrder.value : this.sortOrder,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Room(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('iconName: $iconName, ')
|
|
..write('sortOrder: $sortOrder, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, name, iconName, sortOrder, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Room &&
|
|
other.id == this.id &&
|
|
other.name == this.name &&
|
|
other.iconName == this.iconName &&
|
|
other.sortOrder == this.sortOrder &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class RoomsCompanion extends UpdateCompanion<Room> {
|
|
final Value<int> id;
|
|
final Value<String> name;
|
|
final Value<String> iconName;
|
|
final Value<int> sortOrder;
|
|
final Value<DateTime> createdAt;
|
|
const RoomsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.iconName = const Value.absent(),
|
|
this.sortOrder = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
});
|
|
RoomsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String name,
|
|
required String iconName,
|
|
this.sortOrder = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
}) : name = Value(name),
|
|
iconName = Value(iconName);
|
|
static Insertable<Room> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? name,
|
|
Expression<String>? iconName,
|
|
Expression<int>? sortOrder,
|
|
Expression<DateTime>? createdAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (iconName != null) 'icon_name': iconName,
|
|
if (sortOrder != null) 'sort_order': sortOrder,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
});
|
|
}
|
|
|
|
RoomsCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<String>? name,
|
|
Value<String>? iconName,
|
|
Value<int>? sortOrder,
|
|
Value<DateTime>? createdAt,
|
|
}) {
|
|
return RoomsCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
iconName: iconName ?? this.iconName,
|
|
sortOrder: sortOrder ?? this.sortOrder,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (name.present) {
|
|
map['name'] = Variable<String>(name.value);
|
|
}
|
|
if (iconName.present) {
|
|
map['icon_name'] = Variable<String>(iconName.value);
|
|
}
|
|
if (sortOrder.present) {
|
|
map['sort_order'] = Variable<int>(sortOrder.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('RoomsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('iconName: $iconName, ')
|
|
..write('sortOrder: $sortOrder, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $TasksTable extends Tasks with TableInfo<$TasksTable, Task> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$TasksTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _roomIdMeta = const VerificationMeta('roomId');
|
|
@override
|
|
late final GeneratedColumn<int> roomId = GeneratedColumn<int>(
|
|
'room_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES rooms (id)',
|
|
),
|
|
);
|
|
static const VerificationMeta _nameMeta = const VerificationMeta('name');
|
|
@override
|
|
late final GeneratedColumn<String> name = GeneratedColumn<String>(
|
|
'name',
|
|
aliasedName,
|
|
false,
|
|
additionalChecks: GeneratedColumn.checkTextLength(
|
|
minTextLength: 1,
|
|
maxTextLength: 200,
|
|
),
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _descriptionMeta = const VerificationMeta(
|
|
'description',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> description = GeneratedColumn<String>(
|
|
'description',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
@override
|
|
late final GeneratedColumnWithTypeConverter<IntervalType, int> intervalType =
|
|
GeneratedColumn<int>(
|
|
'interval_type',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
).withConverter<IntervalType>($TasksTable.$converterintervalType);
|
|
static const VerificationMeta _intervalDaysMeta = const VerificationMeta(
|
|
'intervalDays',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> intervalDays = GeneratedColumn<int>(
|
|
'interval_days',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(1),
|
|
);
|
|
static const VerificationMeta _anchorDayMeta = const VerificationMeta(
|
|
'anchorDay',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> anchorDay = GeneratedColumn<int>(
|
|
'anchor_day',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
);
|
|
@override
|
|
late final GeneratedColumnWithTypeConverter<EffortLevel, int> effortLevel =
|
|
GeneratedColumn<int>(
|
|
'effort_level',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
).withConverter<EffortLevel>($TasksTable.$convertereffortLevel);
|
|
static const VerificationMeta _nextDueDateMeta = const VerificationMeta(
|
|
'nextDueDate',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> nextDueDate = GeneratedColumn<DateTime>(
|
|
'next_due_date',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
clientDefault: () => DateTime.now(),
|
|
);
|
|
static const VerificationMeta _isActiveMeta = const VerificationMeta(
|
|
'isActive',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<bool> isActive = GeneratedColumn<bool>(
|
|
'is_active',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.bool,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'CHECK ("is_active" IN (0, 1))',
|
|
),
|
|
defaultValue: const Constant(true),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
roomId,
|
|
name,
|
|
description,
|
|
intervalType,
|
|
intervalDays,
|
|
anchorDay,
|
|
effortLevel,
|
|
nextDueDate,
|
|
createdAt,
|
|
isActive,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'tasks';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Task> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('room_id')) {
|
|
context.handle(
|
|
_roomIdMeta,
|
|
roomId.isAcceptableOrUnknown(data['room_id']!, _roomIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_roomIdMeta);
|
|
}
|
|
if (data.containsKey('name')) {
|
|
context.handle(
|
|
_nameMeta,
|
|
name.isAcceptableOrUnknown(data['name']!, _nameMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_nameMeta);
|
|
}
|
|
if (data.containsKey('description')) {
|
|
context.handle(
|
|
_descriptionMeta,
|
|
description.isAcceptableOrUnknown(
|
|
data['description']!,
|
|
_descriptionMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('interval_days')) {
|
|
context.handle(
|
|
_intervalDaysMeta,
|
|
intervalDays.isAcceptableOrUnknown(
|
|
data['interval_days']!,
|
|
_intervalDaysMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('anchor_day')) {
|
|
context.handle(
|
|
_anchorDayMeta,
|
|
anchorDay.isAcceptableOrUnknown(data['anchor_day']!, _anchorDayMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('next_due_date')) {
|
|
context.handle(
|
|
_nextDueDateMeta,
|
|
nextDueDate.isAcceptableOrUnknown(
|
|
data['next_due_date']!,
|
|
_nextDueDateMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_nextDueDateMeta);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('is_active')) {
|
|
context.handle(
|
|
_isActiveMeta,
|
|
isActive.isAcceptableOrUnknown(data['is_active']!, _isActiveMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Task map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Task(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
roomId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}room_id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
description: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}description'],
|
|
),
|
|
intervalType: $TasksTable.$converterintervalType.fromSql(
|
|
attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}interval_type'],
|
|
)!,
|
|
),
|
|
intervalDays: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}interval_days'],
|
|
)!,
|
|
anchorDay: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}anchor_day'],
|
|
),
|
|
effortLevel: $TasksTable.$convertereffortLevel.fromSql(
|
|
attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}effort_level'],
|
|
)!,
|
|
),
|
|
nextDueDate: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}next_due_date'],
|
|
)!,
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
isActive: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.bool,
|
|
data['${effectivePrefix}is_active'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$TasksTable createAlias(String alias) {
|
|
return $TasksTable(attachedDatabase, alias);
|
|
}
|
|
|
|
static JsonTypeConverter2<IntervalType, int, int> $converterintervalType =
|
|
const EnumIndexConverter<IntervalType>(IntervalType.values);
|
|
static JsonTypeConverter2<EffortLevel, int, int> $convertereffortLevel =
|
|
const EnumIndexConverter<EffortLevel>(EffortLevel.values);
|
|
}
|
|
|
|
class Task extends DataClass implements Insertable<Task> {
|
|
final int id;
|
|
final int roomId;
|
|
final String name;
|
|
final String? description;
|
|
final IntervalType intervalType;
|
|
final int intervalDays;
|
|
final int? anchorDay;
|
|
final EffortLevel effortLevel;
|
|
final DateTime nextDueDate;
|
|
final DateTime createdAt;
|
|
final bool isActive;
|
|
const Task({
|
|
required this.id,
|
|
required this.roomId,
|
|
required this.name,
|
|
this.description,
|
|
required this.intervalType,
|
|
required this.intervalDays,
|
|
this.anchorDay,
|
|
required this.effortLevel,
|
|
required this.nextDueDate,
|
|
required this.createdAt,
|
|
required this.isActive,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['room_id'] = Variable<int>(roomId);
|
|
map['name'] = Variable<String>(name);
|
|
if (!nullToAbsent || description != null) {
|
|
map['description'] = Variable<String>(description);
|
|
}
|
|
{
|
|
map['interval_type'] = Variable<int>(
|
|
$TasksTable.$converterintervalType.toSql(intervalType),
|
|
);
|
|
}
|
|
map['interval_days'] = Variable<int>(intervalDays);
|
|
if (!nullToAbsent || anchorDay != null) {
|
|
map['anchor_day'] = Variable<int>(anchorDay);
|
|
}
|
|
{
|
|
map['effort_level'] = Variable<int>(
|
|
$TasksTable.$convertereffortLevel.toSql(effortLevel),
|
|
);
|
|
}
|
|
map['next_due_date'] = Variable<DateTime>(nextDueDate);
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
map['is_active'] = Variable<bool>(isActive);
|
|
return map;
|
|
}
|
|
|
|
TasksCompanion toCompanion(bool nullToAbsent) {
|
|
return TasksCompanion(
|
|
id: Value(id),
|
|
roomId: Value(roomId),
|
|
name: Value(name),
|
|
description: description == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(description),
|
|
intervalType: Value(intervalType),
|
|
intervalDays: Value(intervalDays),
|
|
anchorDay: anchorDay == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(anchorDay),
|
|
effortLevel: Value(effortLevel),
|
|
nextDueDate: Value(nextDueDate),
|
|
createdAt: Value(createdAt),
|
|
isActive: Value(isActive),
|
|
);
|
|
}
|
|
|
|
factory Task.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Task(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
roomId: serializer.fromJson<int>(json['roomId']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
description: serializer.fromJson<String?>(json['description']),
|
|
intervalType: $TasksTable.$converterintervalType.fromJson(
|
|
serializer.fromJson<int>(json['intervalType']),
|
|
),
|
|
intervalDays: serializer.fromJson<int>(json['intervalDays']),
|
|
anchorDay: serializer.fromJson<int?>(json['anchorDay']),
|
|
effortLevel: $TasksTable.$convertereffortLevel.fromJson(
|
|
serializer.fromJson<int>(json['effortLevel']),
|
|
),
|
|
nextDueDate: serializer.fromJson<DateTime>(json['nextDueDate']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
isActive: serializer.fromJson<bool>(json['isActive']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'roomId': serializer.toJson<int>(roomId),
|
|
'name': serializer.toJson<String>(name),
|
|
'description': serializer.toJson<String?>(description),
|
|
'intervalType': serializer.toJson<int>(
|
|
$TasksTable.$converterintervalType.toJson(intervalType),
|
|
),
|
|
'intervalDays': serializer.toJson<int>(intervalDays),
|
|
'anchorDay': serializer.toJson<int?>(anchorDay),
|
|
'effortLevel': serializer.toJson<int>(
|
|
$TasksTable.$convertereffortLevel.toJson(effortLevel),
|
|
),
|
|
'nextDueDate': serializer.toJson<DateTime>(nextDueDate),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
'isActive': serializer.toJson<bool>(isActive),
|
|
};
|
|
}
|
|
|
|
Task copyWith({
|
|
int? id,
|
|
int? roomId,
|
|
String? name,
|
|
Value<String?> description = const Value.absent(),
|
|
IntervalType? intervalType,
|
|
int? intervalDays,
|
|
Value<int?> anchorDay = const Value.absent(),
|
|
EffortLevel? effortLevel,
|
|
DateTime? nextDueDate,
|
|
DateTime? createdAt,
|
|
bool? isActive,
|
|
}) => Task(
|
|
id: id ?? this.id,
|
|
roomId: roomId ?? this.roomId,
|
|
name: name ?? this.name,
|
|
description: description.present ? description.value : this.description,
|
|
intervalType: intervalType ?? this.intervalType,
|
|
intervalDays: intervalDays ?? this.intervalDays,
|
|
anchorDay: anchorDay.present ? anchorDay.value : this.anchorDay,
|
|
effortLevel: effortLevel ?? this.effortLevel,
|
|
nextDueDate: nextDueDate ?? this.nextDueDate,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
isActive: isActive ?? this.isActive,
|
|
);
|
|
Task copyWithCompanion(TasksCompanion data) {
|
|
return Task(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
roomId: data.roomId.present ? data.roomId.value : this.roomId,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
description: data.description.present
|
|
? data.description.value
|
|
: this.description,
|
|
intervalType: data.intervalType.present
|
|
? data.intervalType.value
|
|
: this.intervalType,
|
|
intervalDays: data.intervalDays.present
|
|
? data.intervalDays.value
|
|
: this.intervalDays,
|
|
anchorDay: data.anchorDay.present ? data.anchorDay.value : this.anchorDay,
|
|
effortLevel: data.effortLevel.present
|
|
? data.effortLevel.value
|
|
: this.effortLevel,
|
|
nextDueDate: data.nextDueDate.present
|
|
? data.nextDueDate.value
|
|
: this.nextDueDate,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
isActive: data.isActive.present ? data.isActive.value : this.isActive,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Task(')
|
|
..write('id: $id, ')
|
|
..write('roomId: $roomId, ')
|
|
..write('name: $name, ')
|
|
..write('description: $description, ')
|
|
..write('intervalType: $intervalType, ')
|
|
..write('intervalDays: $intervalDays, ')
|
|
..write('anchorDay: $anchorDay, ')
|
|
..write('effortLevel: $effortLevel, ')
|
|
..write('nextDueDate: $nextDueDate, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('isActive: $isActive')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
roomId,
|
|
name,
|
|
description,
|
|
intervalType,
|
|
intervalDays,
|
|
anchorDay,
|
|
effortLevel,
|
|
nextDueDate,
|
|
createdAt,
|
|
isActive,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Task &&
|
|
other.id == this.id &&
|
|
other.roomId == this.roomId &&
|
|
other.name == this.name &&
|
|
other.description == this.description &&
|
|
other.intervalType == this.intervalType &&
|
|
other.intervalDays == this.intervalDays &&
|
|
other.anchorDay == this.anchorDay &&
|
|
other.effortLevel == this.effortLevel &&
|
|
other.nextDueDate == this.nextDueDate &&
|
|
other.createdAt == this.createdAt &&
|
|
other.isActive == this.isActive);
|
|
}
|
|
|
|
class TasksCompanion extends UpdateCompanion<Task> {
|
|
final Value<int> id;
|
|
final Value<int> roomId;
|
|
final Value<String> name;
|
|
final Value<String?> description;
|
|
final Value<IntervalType> intervalType;
|
|
final Value<int> intervalDays;
|
|
final Value<int?> anchorDay;
|
|
final Value<EffortLevel> effortLevel;
|
|
final Value<DateTime> nextDueDate;
|
|
final Value<DateTime> createdAt;
|
|
final Value<bool> isActive;
|
|
const TasksCompanion({
|
|
this.id = const Value.absent(),
|
|
this.roomId = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.description = const Value.absent(),
|
|
this.intervalType = const Value.absent(),
|
|
this.intervalDays = const Value.absent(),
|
|
this.anchorDay = const Value.absent(),
|
|
this.effortLevel = const Value.absent(),
|
|
this.nextDueDate = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.isActive = const Value.absent(),
|
|
});
|
|
TasksCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required int roomId,
|
|
required String name,
|
|
this.description = const Value.absent(),
|
|
required IntervalType intervalType,
|
|
this.intervalDays = const Value.absent(),
|
|
this.anchorDay = const Value.absent(),
|
|
required EffortLevel effortLevel,
|
|
required DateTime nextDueDate,
|
|
this.createdAt = const Value.absent(),
|
|
this.isActive = const Value.absent(),
|
|
}) : roomId = Value(roomId),
|
|
name = Value(name),
|
|
intervalType = Value(intervalType),
|
|
effortLevel = Value(effortLevel),
|
|
nextDueDate = Value(nextDueDate);
|
|
static Insertable<Task> custom({
|
|
Expression<int>? id,
|
|
Expression<int>? roomId,
|
|
Expression<String>? name,
|
|
Expression<String>? description,
|
|
Expression<int>? intervalType,
|
|
Expression<int>? intervalDays,
|
|
Expression<int>? anchorDay,
|
|
Expression<int>? effortLevel,
|
|
Expression<DateTime>? nextDueDate,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<bool>? isActive,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (roomId != null) 'room_id': roomId,
|
|
if (name != null) 'name': name,
|
|
if (description != null) 'description': description,
|
|
if (intervalType != null) 'interval_type': intervalType,
|
|
if (intervalDays != null) 'interval_days': intervalDays,
|
|
if (anchorDay != null) 'anchor_day': anchorDay,
|
|
if (effortLevel != null) 'effort_level': effortLevel,
|
|
if (nextDueDate != null) 'next_due_date': nextDueDate,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (isActive != null) 'is_active': isActive,
|
|
});
|
|
}
|
|
|
|
TasksCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<int>? roomId,
|
|
Value<String>? name,
|
|
Value<String?>? description,
|
|
Value<IntervalType>? intervalType,
|
|
Value<int>? intervalDays,
|
|
Value<int?>? anchorDay,
|
|
Value<EffortLevel>? effortLevel,
|
|
Value<DateTime>? nextDueDate,
|
|
Value<DateTime>? createdAt,
|
|
Value<bool>? isActive,
|
|
}) {
|
|
return TasksCompanion(
|
|
id: id ?? this.id,
|
|
roomId: roomId ?? this.roomId,
|
|
name: name ?? this.name,
|
|
description: description ?? this.description,
|
|
intervalType: intervalType ?? this.intervalType,
|
|
intervalDays: intervalDays ?? this.intervalDays,
|
|
anchorDay: anchorDay ?? this.anchorDay,
|
|
effortLevel: effortLevel ?? this.effortLevel,
|
|
nextDueDate: nextDueDate ?? this.nextDueDate,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
isActive: isActive ?? this.isActive,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (roomId.present) {
|
|
map['room_id'] = Variable<int>(roomId.value);
|
|
}
|
|
if (name.present) {
|
|
map['name'] = Variable<String>(name.value);
|
|
}
|
|
if (description.present) {
|
|
map['description'] = Variable<String>(description.value);
|
|
}
|
|
if (intervalType.present) {
|
|
map['interval_type'] = Variable<int>(
|
|
$TasksTable.$converterintervalType.toSql(intervalType.value),
|
|
);
|
|
}
|
|
if (intervalDays.present) {
|
|
map['interval_days'] = Variable<int>(intervalDays.value);
|
|
}
|
|
if (anchorDay.present) {
|
|
map['anchor_day'] = Variable<int>(anchorDay.value);
|
|
}
|
|
if (effortLevel.present) {
|
|
map['effort_level'] = Variable<int>(
|
|
$TasksTable.$convertereffortLevel.toSql(effortLevel.value),
|
|
);
|
|
}
|
|
if (nextDueDate.present) {
|
|
map['next_due_date'] = Variable<DateTime>(nextDueDate.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (isActive.present) {
|
|
map['is_active'] = Variable<bool>(isActive.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TasksCompanion(')
|
|
..write('id: $id, ')
|
|
..write('roomId: $roomId, ')
|
|
..write('name: $name, ')
|
|
..write('description: $description, ')
|
|
..write('intervalType: $intervalType, ')
|
|
..write('intervalDays: $intervalDays, ')
|
|
..write('anchorDay: $anchorDay, ')
|
|
..write('effortLevel: $effortLevel, ')
|
|
..write('nextDueDate: $nextDueDate, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('isActive: $isActive')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $TaskCompletionsTable extends TaskCompletions
|
|
with TableInfo<$TaskCompletionsTable, TaskCompletion> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$TaskCompletionsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _taskIdMeta = const VerificationMeta('taskId');
|
|
@override
|
|
late final GeneratedColumn<int> taskId = GeneratedColumn<int>(
|
|
'task_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES tasks (id)',
|
|
),
|
|
);
|
|
static const VerificationMeta _completedAtMeta = const VerificationMeta(
|
|
'completedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> completedAt = GeneratedColumn<DateTime>(
|
|
'completed_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, taskId, completedAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'task_completions';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<TaskCompletion> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('task_id')) {
|
|
context.handle(
|
|
_taskIdMeta,
|
|
taskId.isAcceptableOrUnknown(data['task_id']!, _taskIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_taskIdMeta);
|
|
}
|
|
if (data.containsKey('completed_at')) {
|
|
context.handle(
|
|
_completedAtMeta,
|
|
completedAt.isAcceptableOrUnknown(
|
|
data['completed_at']!,
|
|
_completedAtMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_completedAtMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
TaskCompletion map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return TaskCompletion(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
taskId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}task_id'],
|
|
)!,
|
|
completedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}completed_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$TaskCompletionsTable createAlias(String alias) {
|
|
return $TaskCompletionsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class TaskCompletion extends DataClass implements Insertable<TaskCompletion> {
|
|
final int id;
|
|
final int taskId;
|
|
final DateTime completedAt;
|
|
const TaskCompletion({
|
|
required this.id,
|
|
required this.taskId,
|
|
required this.completedAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['task_id'] = Variable<int>(taskId);
|
|
map['completed_at'] = Variable<DateTime>(completedAt);
|
|
return map;
|
|
}
|
|
|
|
TaskCompletionsCompanion toCompanion(bool nullToAbsent) {
|
|
return TaskCompletionsCompanion(
|
|
id: Value(id),
|
|
taskId: Value(taskId),
|
|
completedAt: Value(completedAt),
|
|
);
|
|
}
|
|
|
|
factory TaskCompletion.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return TaskCompletion(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
taskId: serializer.fromJson<int>(json['taskId']),
|
|
completedAt: serializer.fromJson<DateTime>(json['completedAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'taskId': serializer.toJson<int>(taskId),
|
|
'completedAt': serializer.toJson<DateTime>(completedAt),
|
|
};
|
|
}
|
|
|
|
TaskCompletion copyWith({int? id, int? taskId, DateTime? completedAt}) =>
|
|
TaskCompletion(
|
|
id: id ?? this.id,
|
|
taskId: taskId ?? this.taskId,
|
|
completedAt: completedAt ?? this.completedAt,
|
|
);
|
|
TaskCompletion copyWithCompanion(TaskCompletionsCompanion data) {
|
|
return TaskCompletion(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
taskId: data.taskId.present ? data.taskId.value : this.taskId,
|
|
completedAt: data.completedAt.present
|
|
? data.completedAt.value
|
|
: this.completedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TaskCompletion(')
|
|
..write('id: $id, ')
|
|
..write('taskId: $taskId, ')
|
|
..write('completedAt: $completedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, taskId, completedAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is TaskCompletion &&
|
|
other.id == this.id &&
|
|
other.taskId == this.taskId &&
|
|
other.completedAt == this.completedAt);
|
|
}
|
|
|
|
class TaskCompletionsCompanion extends UpdateCompanion<TaskCompletion> {
|
|
final Value<int> id;
|
|
final Value<int> taskId;
|
|
final Value<DateTime> completedAt;
|
|
const TaskCompletionsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.taskId = const Value.absent(),
|
|
this.completedAt = const Value.absent(),
|
|
});
|
|
TaskCompletionsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required int taskId,
|
|
required DateTime completedAt,
|
|
}) : taskId = Value(taskId),
|
|
completedAt = Value(completedAt);
|
|
static Insertable<TaskCompletion> custom({
|
|
Expression<int>? id,
|
|
Expression<int>? taskId,
|
|
Expression<DateTime>? completedAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (taskId != null) 'task_id': taskId,
|
|
if (completedAt != null) 'completed_at': completedAt,
|
|
});
|
|
}
|
|
|
|
TaskCompletionsCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<int>? taskId,
|
|
Value<DateTime>? completedAt,
|
|
}) {
|
|
return TaskCompletionsCompanion(
|
|
id: id ?? this.id,
|
|
taskId: taskId ?? this.taskId,
|
|
completedAt: completedAt ?? this.completedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (taskId.present) {
|
|
map['task_id'] = Variable<int>(taskId.value);
|
|
}
|
|
if (completedAt.present) {
|
|
map['completed_at'] = Variable<DateTime>(completedAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TaskCompletionsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('taskId: $taskId, ')
|
|
..write('completedAt: $completedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $RoomsTable rooms = $RoomsTable(this);
|
|
late final $TasksTable tasks = $TasksTable(this);
|
|
late final $TaskCompletionsTable taskCompletions = $TaskCompletionsTable(
|
|
this,
|
|
);
|
|
late final RoomsDao roomsDao = RoomsDao(this as AppDatabase);
|
|
late final TasksDao tasksDao = TasksDao(this as AppDatabase);
|
|
late final DailyPlanDao dailyPlanDao = DailyPlanDao(this as AppDatabase);
|
|
late final CalendarDao calendarDao = CalendarDao(this as AppDatabase);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
rooms,
|
|
tasks,
|
|
taskCompletions,
|
|
];
|
|
}
|
|
|
|
typedef $$RoomsTableCreateCompanionBuilder =
|
|
RoomsCompanion Function({
|
|
Value<int> id,
|
|
required String name,
|
|
required String iconName,
|
|
Value<int> sortOrder,
|
|
Value<DateTime> createdAt,
|
|
});
|
|
typedef $$RoomsTableUpdateCompanionBuilder =
|
|
RoomsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> name,
|
|
Value<String> iconName,
|
|
Value<int> sortOrder,
|
|
Value<DateTime> createdAt,
|
|
});
|
|
|
|
final class $$RoomsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $RoomsTable, Room> {
|
|
$$RoomsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$TasksTable, List<Task>> _tasksRefsTable(
|
|
_$AppDatabase db,
|
|
) => MultiTypedResultKey.fromTable(
|
|
db.tasks,
|
|
aliasName: $_aliasNameGenerator(db.rooms.id, db.tasks.roomId),
|
|
);
|
|
|
|
$$TasksTableProcessedTableManager get tasksRefs {
|
|
final manager = $$TasksTableTableManager(
|
|
$_db,
|
|
$_db.tasks,
|
|
).filter((f) => f.roomId.id.sqlEquals($_itemColumn<int>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_tasksRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$RoomsTableFilterComposer extends Composer<_$AppDatabase, $RoomsTable> {
|
|
$$RoomsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get iconName => $composableBuilder(
|
|
column: $table.iconName,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get sortOrder => $composableBuilder(
|
|
column: $table.sortOrder,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> tasksRefs(
|
|
Expression<bool> Function($$TasksTableFilterComposer f) f,
|
|
) {
|
|
final $$TasksTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.tasks,
|
|
getReferencedColumn: (t) => t.roomId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TasksTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.tasks,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$RoomsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $RoomsTable> {
|
|
$$RoomsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get iconName => $composableBuilder(
|
|
column: $table.iconName,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get sortOrder => $composableBuilder(
|
|
column: $table.sortOrder,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$RoomsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $RoomsTable> {
|
|
$$RoomsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get name =>
|
|
$composableBuilder(column: $table.name, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get iconName =>
|
|
$composableBuilder(column: $table.iconName, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get sortOrder =>
|
|
$composableBuilder(column: $table.sortOrder, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
Expression<T> tasksRefs<T extends Object>(
|
|
Expression<T> Function($$TasksTableAnnotationComposer a) f,
|
|
) {
|
|
final $$TasksTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.tasks,
|
|
getReferencedColumn: (t) => t.roomId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TasksTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.tasks,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$RoomsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$RoomsTable,
|
|
Room,
|
|
$$RoomsTableFilterComposer,
|
|
$$RoomsTableOrderingComposer,
|
|
$$RoomsTableAnnotationComposer,
|
|
$$RoomsTableCreateCompanionBuilder,
|
|
$$RoomsTableUpdateCompanionBuilder,
|
|
(Room, $$RoomsTableReferences),
|
|
Room,
|
|
PrefetchHooks Function({bool tasksRefs})
|
|
> {
|
|
$$RoomsTableTableManager(_$AppDatabase db, $RoomsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$RoomsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$RoomsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$RoomsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<String> iconName = const Value.absent(),
|
|
Value<int> sortOrder = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
}) => RoomsCompanion(
|
|
id: id,
|
|
name: name,
|
|
iconName: iconName,
|
|
sortOrder: sortOrder,
|
|
createdAt: createdAt,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required String name,
|
|
required String iconName,
|
|
Value<int> sortOrder = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
}) => RoomsCompanion.insert(
|
|
id: id,
|
|
name: name,
|
|
iconName: iconName,
|
|
sortOrder: sortOrder,
|
|
createdAt: createdAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) =>
|
|
(e.readTable(table), $$RoomsTableReferences(db, table, e)),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({tasksRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (tasksRefs) db.tasks],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (tasksRefs)
|
|
await $_getPrefetchedData<Room, $RoomsTable, Task>(
|
|
currentTable: table,
|
|
referencedTable: $$RoomsTableReferences._tasksRefsTable(
|
|
db,
|
|
),
|
|
managerFromTypedResult: (p0) =>
|
|
$$RoomsTableReferences(db, table, p0).tasksRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.roomId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$RoomsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$RoomsTable,
|
|
Room,
|
|
$$RoomsTableFilterComposer,
|
|
$$RoomsTableOrderingComposer,
|
|
$$RoomsTableAnnotationComposer,
|
|
$$RoomsTableCreateCompanionBuilder,
|
|
$$RoomsTableUpdateCompanionBuilder,
|
|
(Room, $$RoomsTableReferences),
|
|
Room,
|
|
PrefetchHooks Function({bool tasksRefs})
|
|
>;
|
|
typedef $$TasksTableCreateCompanionBuilder =
|
|
TasksCompanion Function({
|
|
Value<int> id,
|
|
required int roomId,
|
|
required String name,
|
|
Value<String?> description,
|
|
required IntervalType intervalType,
|
|
Value<int> intervalDays,
|
|
Value<int?> anchorDay,
|
|
required EffortLevel effortLevel,
|
|
required DateTime nextDueDate,
|
|
Value<DateTime> createdAt,
|
|
Value<bool> isActive,
|
|
});
|
|
typedef $$TasksTableUpdateCompanionBuilder =
|
|
TasksCompanion Function({
|
|
Value<int> id,
|
|
Value<int> roomId,
|
|
Value<String> name,
|
|
Value<String?> description,
|
|
Value<IntervalType> intervalType,
|
|
Value<int> intervalDays,
|
|
Value<int?> anchorDay,
|
|
Value<EffortLevel> effortLevel,
|
|
Value<DateTime> nextDueDate,
|
|
Value<DateTime> createdAt,
|
|
Value<bool> isActive,
|
|
});
|
|
|
|
final class $$TasksTableReferences
|
|
extends BaseReferences<_$AppDatabase, $TasksTable, Task> {
|
|
$$TasksTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $RoomsTable _roomIdTable(_$AppDatabase db) =>
|
|
db.rooms.createAlias($_aliasNameGenerator(db.tasks.roomId, db.rooms.id));
|
|
|
|
$$RoomsTableProcessedTableManager get roomId {
|
|
final $_column = $_itemColumn<int>('room_id')!;
|
|
|
|
final manager = $$RoomsTableTableManager(
|
|
$_db,
|
|
$_db.rooms,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_roomIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static MultiTypedResultKey<$TaskCompletionsTable, List<TaskCompletion>>
|
|
_taskCompletionsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.taskCompletions,
|
|
aliasName: $_aliasNameGenerator(db.tasks.id, db.taskCompletions.taskId),
|
|
);
|
|
|
|
$$TaskCompletionsTableProcessedTableManager get taskCompletionsRefs {
|
|
final manager = $$TaskCompletionsTableTableManager(
|
|
$_db,
|
|
$_db.taskCompletions,
|
|
).filter((f) => f.taskId.id.sqlEquals($_itemColumn<int>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(
|
|
_taskCompletionsRefsTable($_db),
|
|
);
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$TasksTableFilterComposer extends Composer<_$AppDatabase, $TasksTable> {
|
|
$$TasksTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnWithTypeConverterFilters<IntervalType, IntervalType, int>
|
|
get intervalType => $composableBuilder(
|
|
column: $table.intervalType,
|
|
builder: (column) => ColumnWithTypeConverterFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get intervalDays => $composableBuilder(
|
|
column: $table.intervalDays,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get anchorDay => $composableBuilder(
|
|
column: $table.anchorDay,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnWithTypeConverterFilters<EffortLevel, EffortLevel, int>
|
|
get effortLevel => $composableBuilder(
|
|
column: $table.effortLevel,
|
|
builder: (column) => ColumnWithTypeConverterFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get nextDueDate => $composableBuilder(
|
|
column: $table.nextDueDate,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<bool> get isActive => $composableBuilder(
|
|
column: $table.isActive,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$RoomsTableFilterComposer get roomId {
|
|
final $$RoomsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.roomId,
|
|
referencedTable: $db.rooms,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$RoomsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.rooms,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
Expression<bool> taskCompletionsRefs(
|
|
Expression<bool> Function($$TaskCompletionsTableFilterComposer f) f,
|
|
) {
|
|
final $$TaskCompletionsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.taskCompletions,
|
|
getReferencedColumn: (t) => t.taskId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TaskCompletionsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.taskCompletions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TasksTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $TasksTable> {
|
|
$$TasksTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get intervalType => $composableBuilder(
|
|
column: $table.intervalType,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get intervalDays => $composableBuilder(
|
|
column: $table.intervalDays,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get anchorDay => $composableBuilder(
|
|
column: $table.anchorDay,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get effortLevel => $composableBuilder(
|
|
column: $table.effortLevel,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get nextDueDate => $composableBuilder(
|
|
column: $table.nextDueDate,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<bool> get isActive => $composableBuilder(
|
|
column: $table.isActive,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$RoomsTableOrderingComposer get roomId {
|
|
final $$RoomsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.roomId,
|
|
referencedTable: $db.rooms,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$RoomsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.rooms,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TasksTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $TasksTable> {
|
|
$$TasksTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get name =>
|
|
$composableBuilder(column: $table.name, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumnWithTypeConverter<IntervalType, int> get intervalType =>
|
|
$composableBuilder(
|
|
column: $table.intervalType,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<int> get intervalDays => $composableBuilder(
|
|
column: $table.intervalDays,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<int> get anchorDay =>
|
|
$composableBuilder(column: $table.anchorDay, builder: (column) => column);
|
|
|
|
GeneratedColumnWithTypeConverter<EffortLevel, int> get effortLevel =>
|
|
$composableBuilder(
|
|
column: $table.effortLevel,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get nextDueDate => $composableBuilder(
|
|
column: $table.nextDueDate,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
GeneratedColumn<bool> get isActive =>
|
|
$composableBuilder(column: $table.isActive, builder: (column) => column);
|
|
|
|
$$RoomsTableAnnotationComposer get roomId {
|
|
final $$RoomsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.roomId,
|
|
referencedTable: $db.rooms,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$RoomsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.rooms,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
Expression<T> taskCompletionsRefs<T extends Object>(
|
|
Expression<T> Function($$TaskCompletionsTableAnnotationComposer a) f,
|
|
) {
|
|
final $$TaskCompletionsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.taskCompletions,
|
|
getReferencedColumn: (t) => t.taskId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TaskCompletionsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.taskCompletions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TasksTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$TasksTable,
|
|
Task,
|
|
$$TasksTableFilterComposer,
|
|
$$TasksTableOrderingComposer,
|
|
$$TasksTableAnnotationComposer,
|
|
$$TasksTableCreateCompanionBuilder,
|
|
$$TasksTableUpdateCompanionBuilder,
|
|
(Task, $$TasksTableReferences),
|
|
Task,
|
|
PrefetchHooks Function({bool roomId, bool taskCompletionsRefs})
|
|
> {
|
|
$$TasksTableTableManager(_$AppDatabase db, $TasksTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$TasksTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$TasksTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$TasksTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<int> roomId = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<String?> description = const Value.absent(),
|
|
Value<IntervalType> intervalType = const Value.absent(),
|
|
Value<int> intervalDays = const Value.absent(),
|
|
Value<int?> anchorDay = const Value.absent(),
|
|
Value<EffortLevel> effortLevel = const Value.absent(),
|
|
Value<DateTime> nextDueDate = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<bool> isActive = const Value.absent(),
|
|
}) => TasksCompanion(
|
|
id: id,
|
|
roomId: roomId,
|
|
name: name,
|
|
description: description,
|
|
intervalType: intervalType,
|
|
intervalDays: intervalDays,
|
|
anchorDay: anchorDay,
|
|
effortLevel: effortLevel,
|
|
nextDueDate: nextDueDate,
|
|
createdAt: createdAt,
|
|
isActive: isActive,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required int roomId,
|
|
required String name,
|
|
Value<String?> description = const Value.absent(),
|
|
required IntervalType intervalType,
|
|
Value<int> intervalDays = const Value.absent(),
|
|
Value<int?> anchorDay = const Value.absent(),
|
|
required EffortLevel effortLevel,
|
|
required DateTime nextDueDate,
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<bool> isActive = const Value.absent(),
|
|
}) => TasksCompanion.insert(
|
|
id: id,
|
|
roomId: roomId,
|
|
name: name,
|
|
description: description,
|
|
intervalType: intervalType,
|
|
intervalDays: intervalDays,
|
|
anchorDay: anchorDay,
|
|
effortLevel: effortLevel,
|
|
nextDueDate: nextDueDate,
|
|
createdAt: createdAt,
|
|
isActive: isActive,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) =>
|
|
(e.readTable(table), $$TasksTableReferences(db, table, e)),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback:
|
|
({roomId = false, taskCompletionsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (taskCompletionsRefs) db.taskCompletions,
|
|
],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (roomId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.roomId,
|
|
referencedTable: $$TasksTableReferences
|
|
._roomIdTable(db),
|
|
referencedColumn: $$TasksTableReferences
|
|
._roomIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (taskCompletionsRefs)
|
|
await $_getPrefetchedData<
|
|
Task,
|
|
$TasksTable,
|
|
TaskCompletion
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$TasksTableReferences
|
|
._taskCompletionsRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$TasksTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).taskCompletionsRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems.where(
|
|
(e) => e.taskId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$TasksTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$TasksTable,
|
|
Task,
|
|
$$TasksTableFilterComposer,
|
|
$$TasksTableOrderingComposer,
|
|
$$TasksTableAnnotationComposer,
|
|
$$TasksTableCreateCompanionBuilder,
|
|
$$TasksTableUpdateCompanionBuilder,
|
|
(Task, $$TasksTableReferences),
|
|
Task,
|
|
PrefetchHooks Function({bool roomId, bool taskCompletionsRefs})
|
|
>;
|
|
typedef $$TaskCompletionsTableCreateCompanionBuilder =
|
|
TaskCompletionsCompanion Function({
|
|
Value<int> id,
|
|
required int taskId,
|
|
required DateTime completedAt,
|
|
});
|
|
typedef $$TaskCompletionsTableUpdateCompanionBuilder =
|
|
TaskCompletionsCompanion Function({
|
|
Value<int> id,
|
|
Value<int> taskId,
|
|
Value<DateTime> completedAt,
|
|
});
|
|
|
|
final class $$TaskCompletionsTableReferences
|
|
extends
|
|
BaseReferences<_$AppDatabase, $TaskCompletionsTable, TaskCompletion> {
|
|
$$TaskCompletionsTableReferences(
|
|
super.$_db,
|
|
super.$_table,
|
|
super.$_typedResult,
|
|
);
|
|
|
|
static $TasksTable _taskIdTable(_$AppDatabase db) => db.tasks.createAlias(
|
|
$_aliasNameGenerator(db.taskCompletions.taskId, db.tasks.id),
|
|
);
|
|
|
|
$$TasksTableProcessedTableManager get taskId {
|
|
final $_column = $_itemColumn<int>('task_id')!;
|
|
|
|
final manager = $$TasksTableTableManager(
|
|
$_db,
|
|
$_db.tasks,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_taskIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$TaskCompletionsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $TaskCompletionsTable> {
|
|
$$TaskCompletionsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get completedAt => $composableBuilder(
|
|
column: $table.completedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$TasksTableFilterComposer get taskId {
|
|
final $$TasksTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.taskId,
|
|
referencedTable: $db.tasks,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TasksTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.tasks,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TaskCompletionsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $TaskCompletionsTable> {
|
|
$$TaskCompletionsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get completedAt => $composableBuilder(
|
|
column: $table.completedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$TasksTableOrderingComposer get taskId {
|
|
final $$TasksTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.taskId,
|
|
referencedTable: $db.tasks,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TasksTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.tasks,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TaskCompletionsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $TaskCompletionsTable> {
|
|
$$TaskCompletionsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get completedAt => $composableBuilder(
|
|
column: $table.completedAt,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
$$TasksTableAnnotationComposer get taskId {
|
|
final $$TasksTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.taskId,
|
|
referencedTable: $db.tasks,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TasksTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.tasks,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TaskCompletionsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$TaskCompletionsTable,
|
|
TaskCompletion,
|
|
$$TaskCompletionsTableFilterComposer,
|
|
$$TaskCompletionsTableOrderingComposer,
|
|
$$TaskCompletionsTableAnnotationComposer,
|
|
$$TaskCompletionsTableCreateCompanionBuilder,
|
|
$$TaskCompletionsTableUpdateCompanionBuilder,
|
|
(TaskCompletion, $$TaskCompletionsTableReferences),
|
|
TaskCompletion,
|
|
PrefetchHooks Function({bool taskId})
|
|
> {
|
|
$$TaskCompletionsTableTableManager(
|
|
_$AppDatabase db,
|
|
$TaskCompletionsTable table,
|
|
) : super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$TaskCompletionsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$TaskCompletionsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$TaskCompletionsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<int> taskId = const Value.absent(),
|
|
Value<DateTime> completedAt = const Value.absent(),
|
|
}) => TaskCompletionsCompanion(
|
|
id: id,
|
|
taskId: taskId,
|
|
completedAt: completedAt,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required int taskId,
|
|
required DateTime completedAt,
|
|
}) => TaskCompletionsCompanion.insert(
|
|
id: id,
|
|
taskId: taskId,
|
|
completedAt: completedAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$TaskCompletionsTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({taskId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (taskId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.taskId,
|
|
referencedTable:
|
|
$$TaskCompletionsTableReferences
|
|
._taskIdTable(db),
|
|
referencedColumn:
|
|
$$TaskCompletionsTableReferences
|
|
._taskIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$TaskCompletionsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$TaskCompletionsTable,
|
|
TaskCompletion,
|
|
$$TaskCompletionsTableFilterComposer,
|
|
$$TaskCompletionsTableOrderingComposer,
|
|
$$TaskCompletionsTableAnnotationComposer,
|
|
$$TaskCompletionsTableCreateCompanionBuilder,
|
|
$$TaskCompletionsTableUpdateCompanionBuilder,
|
|
(TaskCompletion, $$TaskCompletionsTableReferences),
|
|
TaskCompletion,
|
|
PrefetchHooks Function({bool taskId})
|
|
>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$RoomsTableTableManager get rooms =>
|
|
$$RoomsTableTableManager(_db, _db.rooms);
|
|
$$TasksTableTableManager get tasks =>
|
|
$$TasksTableTableManager(_db, _db.tasks);
|
|
$$TaskCompletionsTableTableManager get taskCompletions =>
|
|
$$TaskCompletionsTableTableManager(_db, _db.taskCompletions);
|
|
}
|