2709 lines
86 KiB
Dart
2709 lines
86 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'app_database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $ProjectsTable extends Projects with TableInfo<$ProjectsTable, Project> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ProjectsTable(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,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways('UNIQUE'),
|
|
);
|
|
static const VerificationMeta _colorValueMeta = const VerificationMeta(
|
|
'colorValue',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> colorValue = GeneratedColumn<int>(
|
|
'color_value',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
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,
|
|
);
|
|
static const VerificationMeta _archivedAtMeta = const VerificationMeta(
|
|
'archivedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> archivedAt = GeneratedColumn<DateTime>(
|
|
'archived_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
name,
|
|
colorValue,
|
|
description,
|
|
archivedAt,
|
|
createdAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'projects';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Project> 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('color_value')) {
|
|
context.handle(
|
|
_colorValueMeta,
|
|
colorValue.isAcceptableOrUnknown(data['color_value']!, _colorValueMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_colorValueMeta);
|
|
}
|
|
if (data.containsKey('description')) {
|
|
context.handle(
|
|
_descriptionMeta,
|
|
description.isAcceptableOrUnknown(
|
|
data['description']!,
|
|
_descriptionMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('archived_at')) {
|
|
context.handle(
|
|
_archivedAtMeta,
|
|
archivedAt.isAcceptableOrUnknown(data['archived_at']!, _archivedAtMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Project map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Project(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
colorValue: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}color_value'],
|
|
)!,
|
|
description: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}description'],
|
|
),
|
|
archivedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}archived_at'],
|
|
),
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ProjectsTable createAlias(String alias) {
|
|
return $ProjectsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Project extends DataClass implements Insertable<Project> {
|
|
final int id;
|
|
final String name;
|
|
final int colorValue;
|
|
final String? description;
|
|
final DateTime? archivedAt;
|
|
final DateTime createdAt;
|
|
const Project({
|
|
required this.id,
|
|
required this.name,
|
|
required this.colorValue,
|
|
this.description,
|
|
this.archivedAt,
|
|
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['color_value'] = Variable<int>(colorValue);
|
|
if (!nullToAbsent || description != null) {
|
|
map['description'] = Variable<String>(description);
|
|
}
|
|
if (!nullToAbsent || archivedAt != null) {
|
|
map['archived_at'] = Variable<DateTime>(archivedAt);
|
|
}
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
ProjectsCompanion toCompanion(bool nullToAbsent) {
|
|
return ProjectsCompanion(
|
|
id: Value(id),
|
|
name: Value(name),
|
|
colorValue: Value(colorValue),
|
|
description: description == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(description),
|
|
archivedAt: archivedAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(archivedAt),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory Project.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Project(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
colorValue: serializer.fromJson<int>(json['colorValue']),
|
|
description: serializer.fromJson<String?>(json['description']),
|
|
archivedAt: serializer.fromJson<DateTime?>(json['archivedAt']),
|
|
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),
|
|
'colorValue': serializer.toJson<int>(colorValue),
|
|
'description': serializer.toJson<String?>(description),
|
|
'archivedAt': serializer.toJson<DateTime?>(archivedAt),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
Project copyWith({
|
|
int? id,
|
|
String? name,
|
|
int? colorValue,
|
|
Value<String?> description = const Value.absent(),
|
|
Value<DateTime?> archivedAt = const Value.absent(),
|
|
DateTime? createdAt,
|
|
}) => Project(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
colorValue: colorValue ?? this.colorValue,
|
|
description: description.present ? description.value : this.description,
|
|
archivedAt: archivedAt.present ? archivedAt.value : this.archivedAt,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
Project copyWithCompanion(ProjectsCompanion data) {
|
|
return Project(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
colorValue: data.colorValue.present
|
|
? data.colorValue.value
|
|
: this.colorValue,
|
|
description: data.description.present
|
|
? data.description.value
|
|
: this.description,
|
|
archivedAt: data.archivedAt.present
|
|
? data.archivedAt.value
|
|
: this.archivedAt,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Project(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('colorValue: $colorValue, ')
|
|
..write('description: $description, ')
|
|
..write('archivedAt: $archivedAt, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(id, name, colorValue, description, archivedAt, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Project &&
|
|
other.id == this.id &&
|
|
other.name == this.name &&
|
|
other.colorValue == this.colorValue &&
|
|
other.description == this.description &&
|
|
other.archivedAt == this.archivedAt &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class ProjectsCompanion extends UpdateCompanion<Project> {
|
|
final Value<int> id;
|
|
final Value<String> name;
|
|
final Value<int> colorValue;
|
|
final Value<String?> description;
|
|
final Value<DateTime?> archivedAt;
|
|
final Value<DateTime> createdAt;
|
|
const ProjectsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.colorValue = const Value.absent(),
|
|
this.description = const Value.absent(),
|
|
this.archivedAt = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
});
|
|
ProjectsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String name,
|
|
required int colorValue,
|
|
this.description = const Value.absent(),
|
|
this.archivedAt = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
}) : name = Value(name),
|
|
colorValue = Value(colorValue);
|
|
static Insertable<Project> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? name,
|
|
Expression<int>? colorValue,
|
|
Expression<String>? description,
|
|
Expression<DateTime>? archivedAt,
|
|
Expression<DateTime>? createdAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (colorValue != null) 'color_value': colorValue,
|
|
if (description != null) 'description': description,
|
|
if (archivedAt != null) 'archived_at': archivedAt,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
});
|
|
}
|
|
|
|
ProjectsCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<String>? name,
|
|
Value<int>? colorValue,
|
|
Value<String?>? description,
|
|
Value<DateTime?>? archivedAt,
|
|
Value<DateTime>? createdAt,
|
|
}) {
|
|
return ProjectsCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
colorValue: colorValue ?? this.colorValue,
|
|
description: description ?? this.description,
|
|
archivedAt: archivedAt ?? this.archivedAt,
|
|
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 (colorValue.present) {
|
|
map['color_value'] = Variable<int>(colorValue.value);
|
|
}
|
|
if (description.present) {
|
|
map['description'] = Variable<String>(description.value);
|
|
}
|
|
if (archivedAt.present) {
|
|
map['archived_at'] = Variable<DateTime>(archivedAt.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ProjectsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('colorValue: $colorValue, ')
|
|
..write('description: $description, ')
|
|
..write('archivedAt: $archivedAt, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $TimeEntriesTable extends TimeEntries
|
|
with TableInfo<$TimeEntriesTable, TimeEntry> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$TimeEntriesTable(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 _projectIdMeta = const VerificationMeta(
|
|
'projectId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> projectId = GeneratedColumn<int>(
|
|
'project_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES projects (id) ON DELETE RESTRICT',
|
|
),
|
|
);
|
|
static const VerificationMeta _startTimeMeta = const VerificationMeta(
|
|
'startTime',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> startTime = GeneratedColumn<DateTime>(
|
|
'start_time',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _endTimeMeta = const VerificationMeta(
|
|
'endTime',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> endTime = GeneratedColumn<DateTime>(
|
|
'end_time',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _durationSecondsMeta = const VerificationMeta(
|
|
'durationSeconds',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> durationSeconds = GeneratedColumn<int>(
|
|
'duration_seconds',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _noteMeta = const VerificationMeta('note');
|
|
@override
|
|
late final GeneratedColumn<String> note = GeneratedColumn<String>(
|
|
'note',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
projectId,
|
|
startTime,
|
|
endTime,
|
|
durationSeconds,
|
|
note,
|
|
createdAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'time_entries';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<TimeEntry> 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('project_id')) {
|
|
context.handle(
|
|
_projectIdMeta,
|
|
projectId.isAcceptableOrUnknown(data['project_id']!, _projectIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_projectIdMeta);
|
|
}
|
|
if (data.containsKey('start_time')) {
|
|
context.handle(
|
|
_startTimeMeta,
|
|
startTime.isAcceptableOrUnknown(data['start_time']!, _startTimeMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_startTimeMeta);
|
|
}
|
|
if (data.containsKey('end_time')) {
|
|
context.handle(
|
|
_endTimeMeta,
|
|
endTime.isAcceptableOrUnknown(data['end_time']!, _endTimeMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('duration_seconds')) {
|
|
context.handle(
|
|
_durationSecondsMeta,
|
|
durationSeconds.isAcceptableOrUnknown(
|
|
data['duration_seconds']!,
|
|
_durationSecondsMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('note')) {
|
|
context.handle(
|
|
_noteMeta,
|
|
note.isAcceptableOrUnknown(data['note']!, _noteMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
TimeEntry map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return TimeEntry(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
projectId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}project_id'],
|
|
)!,
|
|
startTime: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}start_time'],
|
|
)!,
|
|
endTime: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}end_time'],
|
|
),
|
|
durationSeconds: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}duration_seconds'],
|
|
),
|
|
note: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}note'],
|
|
),
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$TimeEntriesTable createAlias(String alias) {
|
|
return $TimeEntriesTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class TimeEntry extends DataClass implements Insertable<TimeEntry> {
|
|
final int id;
|
|
final int projectId;
|
|
final DateTime startTime;
|
|
final DateTime? endTime;
|
|
final int? durationSeconds;
|
|
final String? note;
|
|
final DateTime createdAt;
|
|
const TimeEntry({
|
|
required this.id,
|
|
required this.projectId,
|
|
required this.startTime,
|
|
this.endTime,
|
|
this.durationSeconds,
|
|
this.note,
|
|
required this.createdAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['project_id'] = Variable<int>(projectId);
|
|
map['start_time'] = Variable<DateTime>(startTime);
|
|
if (!nullToAbsent || endTime != null) {
|
|
map['end_time'] = Variable<DateTime>(endTime);
|
|
}
|
|
if (!nullToAbsent || durationSeconds != null) {
|
|
map['duration_seconds'] = Variable<int>(durationSeconds);
|
|
}
|
|
if (!nullToAbsent || note != null) {
|
|
map['note'] = Variable<String>(note);
|
|
}
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
TimeEntriesCompanion toCompanion(bool nullToAbsent) {
|
|
return TimeEntriesCompanion(
|
|
id: Value(id),
|
|
projectId: Value(projectId),
|
|
startTime: Value(startTime),
|
|
endTime: endTime == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(endTime),
|
|
durationSeconds: durationSeconds == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(durationSeconds),
|
|
note: note == null && nullToAbsent ? const Value.absent() : Value(note),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory TimeEntry.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return TimeEntry(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
projectId: serializer.fromJson<int>(json['projectId']),
|
|
startTime: serializer.fromJson<DateTime>(json['startTime']),
|
|
endTime: serializer.fromJson<DateTime?>(json['endTime']),
|
|
durationSeconds: serializer.fromJson<int?>(json['durationSeconds']),
|
|
note: serializer.fromJson<String?>(json['note']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'projectId': serializer.toJson<int>(projectId),
|
|
'startTime': serializer.toJson<DateTime>(startTime),
|
|
'endTime': serializer.toJson<DateTime?>(endTime),
|
|
'durationSeconds': serializer.toJson<int?>(durationSeconds),
|
|
'note': serializer.toJson<String?>(note),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
TimeEntry copyWith({
|
|
int? id,
|
|
int? projectId,
|
|
DateTime? startTime,
|
|
Value<DateTime?> endTime = const Value.absent(),
|
|
Value<int?> durationSeconds = const Value.absent(),
|
|
Value<String?> note = const Value.absent(),
|
|
DateTime? createdAt,
|
|
}) => TimeEntry(
|
|
id: id ?? this.id,
|
|
projectId: projectId ?? this.projectId,
|
|
startTime: startTime ?? this.startTime,
|
|
endTime: endTime.present ? endTime.value : this.endTime,
|
|
durationSeconds: durationSeconds.present
|
|
? durationSeconds.value
|
|
: this.durationSeconds,
|
|
note: note.present ? note.value : this.note,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
TimeEntry copyWithCompanion(TimeEntriesCompanion data) {
|
|
return TimeEntry(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
projectId: data.projectId.present ? data.projectId.value : this.projectId,
|
|
startTime: data.startTime.present ? data.startTime.value : this.startTime,
|
|
endTime: data.endTime.present ? data.endTime.value : this.endTime,
|
|
durationSeconds: data.durationSeconds.present
|
|
? data.durationSeconds.value
|
|
: this.durationSeconds,
|
|
note: data.note.present ? data.note.value : this.note,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TimeEntry(')
|
|
..write('id: $id, ')
|
|
..write('projectId: $projectId, ')
|
|
..write('startTime: $startTime, ')
|
|
..write('endTime: $endTime, ')
|
|
..write('durationSeconds: $durationSeconds, ')
|
|
..write('note: $note, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
projectId,
|
|
startTime,
|
|
endTime,
|
|
durationSeconds,
|
|
note,
|
|
createdAt,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is TimeEntry &&
|
|
other.id == this.id &&
|
|
other.projectId == this.projectId &&
|
|
other.startTime == this.startTime &&
|
|
other.endTime == this.endTime &&
|
|
other.durationSeconds == this.durationSeconds &&
|
|
other.note == this.note &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class TimeEntriesCompanion extends UpdateCompanion<TimeEntry> {
|
|
final Value<int> id;
|
|
final Value<int> projectId;
|
|
final Value<DateTime> startTime;
|
|
final Value<DateTime?> endTime;
|
|
final Value<int?> durationSeconds;
|
|
final Value<String?> note;
|
|
final Value<DateTime> createdAt;
|
|
const TimeEntriesCompanion({
|
|
this.id = const Value.absent(),
|
|
this.projectId = const Value.absent(),
|
|
this.startTime = const Value.absent(),
|
|
this.endTime = const Value.absent(),
|
|
this.durationSeconds = const Value.absent(),
|
|
this.note = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
});
|
|
TimeEntriesCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required int projectId,
|
|
required DateTime startTime,
|
|
this.endTime = const Value.absent(),
|
|
this.durationSeconds = const Value.absent(),
|
|
this.note = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
}) : projectId = Value(projectId),
|
|
startTime = Value(startTime);
|
|
static Insertable<TimeEntry> custom({
|
|
Expression<int>? id,
|
|
Expression<int>? projectId,
|
|
Expression<DateTime>? startTime,
|
|
Expression<DateTime>? endTime,
|
|
Expression<int>? durationSeconds,
|
|
Expression<String>? note,
|
|
Expression<DateTime>? createdAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (projectId != null) 'project_id': projectId,
|
|
if (startTime != null) 'start_time': startTime,
|
|
if (endTime != null) 'end_time': endTime,
|
|
if (durationSeconds != null) 'duration_seconds': durationSeconds,
|
|
if (note != null) 'note': note,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
});
|
|
}
|
|
|
|
TimeEntriesCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<int>? projectId,
|
|
Value<DateTime>? startTime,
|
|
Value<DateTime?>? endTime,
|
|
Value<int?>? durationSeconds,
|
|
Value<String?>? note,
|
|
Value<DateTime>? createdAt,
|
|
}) {
|
|
return TimeEntriesCompanion(
|
|
id: id ?? this.id,
|
|
projectId: projectId ?? this.projectId,
|
|
startTime: startTime ?? this.startTime,
|
|
endTime: endTime ?? this.endTime,
|
|
durationSeconds: durationSeconds ?? this.durationSeconds,
|
|
note: note ?? this.note,
|
|
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 (projectId.present) {
|
|
map['project_id'] = Variable<int>(projectId.value);
|
|
}
|
|
if (startTime.present) {
|
|
map['start_time'] = Variable<DateTime>(startTime.value);
|
|
}
|
|
if (endTime.present) {
|
|
map['end_time'] = Variable<DateTime>(endTime.value);
|
|
}
|
|
if (durationSeconds.present) {
|
|
map['duration_seconds'] = Variable<int>(durationSeconds.value);
|
|
}
|
|
if (note.present) {
|
|
map['note'] = Variable<String>(note.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TimeEntriesCompanion(')
|
|
..write('id: $id, ')
|
|
..write('projectId: $projectId, ')
|
|
..write('startTime: $startTime, ')
|
|
..write('endTime: $endTime, ')
|
|
..write('durationSeconds: $durationSeconds, ')
|
|
..write('note: $note, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $TagsTable extends Tags with TableInfo<$TagsTable, Tag> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$TagsTable(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: 50,
|
|
),
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways('UNIQUE'),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, name];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'tags';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Tag> 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);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Tag map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Tag(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$TagsTable createAlias(String alias) {
|
|
return $TagsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Tag extends DataClass implements Insertable<Tag> {
|
|
final int id;
|
|
final String name;
|
|
const Tag({required this.id, required this.name});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['name'] = Variable<String>(name);
|
|
return map;
|
|
}
|
|
|
|
TagsCompanion toCompanion(bool nullToAbsent) {
|
|
return TagsCompanion(id: Value(id), name: Value(name));
|
|
}
|
|
|
|
factory Tag.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Tag(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'name': serializer.toJson<String>(name),
|
|
};
|
|
}
|
|
|
|
Tag copyWith({int? id, String? name}) =>
|
|
Tag(id: id ?? this.id, name: name ?? this.name);
|
|
Tag copyWithCompanion(TagsCompanion data) {
|
|
return Tag(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Tag(')
|
|
..write('id: $id, ')
|
|
..write('name: $name')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, name);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Tag && other.id == this.id && other.name == this.name);
|
|
}
|
|
|
|
class TagsCompanion extends UpdateCompanion<Tag> {
|
|
final Value<int> id;
|
|
final Value<String> name;
|
|
const TagsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
});
|
|
TagsCompanion.insert({this.id = const Value.absent(), required String name})
|
|
: name = Value(name);
|
|
static Insertable<Tag> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? name,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
});
|
|
}
|
|
|
|
TagsCompanion copyWith({Value<int>? id, Value<String>? name}) {
|
|
return TagsCompanion(id: id ?? this.id, name: name ?? this.name);
|
|
}
|
|
|
|
@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);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TagsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $TimeEntryTagsTable extends TimeEntryTags
|
|
with TableInfo<$TimeEntryTagsTable, TimeEntryTag> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$TimeEntryTagsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _timeEntryIdMeta = const VerificationMeta(
|
|
'timeEntryId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> timeEntryId = GeneratedColumn<int>(
|
|
'time_entry_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES time_entries (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
static const VerificationMeta _tagIdMeta = const VerificationMeta('tagId');
|
|
@override
|
|
late final GeneratedColumn<int> tagId = GeneratedColumn<int>(
|
|
'tag_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES tags (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [timeEntryId, tagId];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'time_entry_tags';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<TimeEntryTag> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('time_entry_id')) {
|
|
context.handle(
|
|
_timeEntryIdMeta,
|
|
timeEntryId.isAcceptableOrUnknown(
|
|
data['time_entry_id']!,
|
|
_timeEntryIdMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_timeEntryIdMeta);
|
|
}
|
|
if (data.containsKey('tag_id')) {
|
|
context.handle(
|
|
_tagIdMeta,
|
|
tagId.isAcceptableOrUnknown(data['tag_id']!, _tagIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_tagIdMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {timeEntryId, tagId};
|
|
@override
|
|
TimeEntryTag map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return TimeEntryTag(
|
|
timeEntryId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}time_entry_id'],
|
|
)!,
|
|
tagId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}tag_id'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$TimeEntryTagsTable createAlias(String alias) {
|
|
return $TimeEntryTagsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class TimeEntryTag extends DataClass implements Insertable<TimeEntryTag> {
|
|
final int timeEntryId;
|
|
final int tagId;
|
|
const TimeEntryTag({required this.timeEntryId, required this.tagId});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['time_entry_id'] = Variable<int>(timeEntryId);
|
|
map['tag_id'] = Variable<int>(tagId);
|
|
return map;
|
|
}
|
|
|
|
TimeEntryTagsCompanion toCompanion(bool nullToAbsent) {
|
|
return TimeEntryTagsCompanion(
|
|
timeEntryId: Value(timeEntryId),
|
|
tagId: Value(tagId),
|
|
);
|
|
}
|
|
|
|
factory TimeEntryTag.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return TimeEntryTag(
|
|
timeEntryId: serializer.fromJson<int>(json['timeEntryId']),
|
|
tagId: serializer.fromJson<int>(json['tagId']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'timeEntryId': serializer.toJson<int>(timeEntryId),
|
|
'tagId': serializer.toJson<int>(tagId),
|
|
};
|
|
}
|
|
|
|
TimeEntryTag copyWith({int? timeEntryId, int? tagId}) => TimeEntryTag(
|
|
timeEntryId: timeEntryId ?? this.timeEntryId,
|
|
tagId: tagId ?? this.tagId,
|
|
);
|
|
TimeEntryTag copyWithCompanion(TimeEntryTagsCompanion data) {
|
|
return TimeEntryTag(
|
|
timeEntryId: data.timeEntryId.present
|
|
? data.timeEntryId.value
|
|
: this.timeEntryId,
|
|
tagId: data.tagId.present ? data.tagId.value : this.tagId,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TimeEntryTag(')
|
|
..write('timeEntryId: $timeEntryId, ')
|
|
..write('tagId: $tagId')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(timeEntryId, tagId);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is TimeEntryTag &&
|
|
other.timeEntryId == this.timeEntryId &&
|
|
other.tagId == this.tagId);
|
|
}
|
|
|
|
class TimeEntryTagsCompanion extends UpdateCompanion<TimeEntryTag> {
|
|
final Value<int> timeEntryId;
|
|
final Value<int> tagId;
|
|
final Value<int> rowid;
|
|
const TimeEntryTagsCompanion({
|
|
this.timeEntryId = const Value.absent(),
|
|
this.tagId = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
TimeEntryTagsCompanion.insert({
|
|
required int timeEntryId,
|
|
required int tagId,
|
|
this.rowid = const Value.absent(),
|
|
}) : timeEntryId = Value(timeEntryId),
|
|
tagId = Value(tagId);
|
|
static Insertable<TimeEntryTag> custom({
|
|
Expression<int>? timeEntryId,
|
|
Expression<int>? tagId,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (timeEntryId != null) 'time_entry_id': timeEntryId,
|
|
if (tagId != null) 'tag_id': tagId,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
TimeEntryTagsCompanion copyWith({
|
|
Value<int>? timeEntryId,
|
|
Value<int>? tagId,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return TimeEntryTagsCompanion(
|
|
timeEntryId: timeEntryId ?? this.timeEntryId,
|
|
tagId: tagId ?? this.tagId,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (timeEntryId.present) {
|
|
map['time_entry_id'] = Variable<int>(timeEntryId.value);
|
|
}
|
|
if (tagId.present) {
|
|
map['tag_id'] = Variable<int>(tagId.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TimeEntryTagsCompanion(')
|
|
..write('timeEntryId: $timeEntryId, ')
|
|
..write('tagId: $tagId, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $ProjectsTable projects = $ProjectsTable(this);
|
|
late final $TimeEntriesTable timeEntries = $TimeEntriesTable(this);
|
|
late final $TagsTable tags = $TagsTable(this);
|
|
late final $TimeEntryTagsTable timeEntryTags = $TimeEntryTagsTable(this);
|
|
late final ProjectsDao projectsDao = ProjectsDao(this as AppDatabase);
|
|
late final TimeEntriesDao timeEntriesDao = TimeEntriesDao(
|
|
this as AppDatabase,
|
|
);
|
|
late final TagsDao tagsDao = TagsDao(this as AppDatabase);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
projects,
|
|
timeEntries,
|
|
tags,
|
|
timeEntryTags,
|
|
];
|
|
@override
|
|
StreamQueryUpdateRules get streamUpdateRules => const StreamQueryUpdateRules([
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'time_entries',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('time_entry_tags', kind: UpdateKind.delete)],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'tags',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('time_entry_tags', kind: UpdateKind.delete)],
|
|
),
|
|
]);
|
|
}
|
|
|
|
typedef $$ProjectsTableCreateCompanionBuilder =
|
|
ProjectsCompanion Function({
|
|
Value<int> id,
|
|
required String name,
|
|
required int colorValue,
|
|
Value<String?> description,
|
|
Value<DateTime?> archivedAt,
|
|
Value<DateTime> createdAt,
|
|
});
|
|
typedef $$ProjectsTableUpdateCompanionBuilder =
|
|
ProjectsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> name,
|
|
Value<int> colorValue,
|
|
Value<String?> description,
|
|
Value<DateTime?> archivedAt,
|
|
Value<DateTime> createdAt,
|
|
});
|
|
|
|
final class $$ProjectsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $ProjectsTable, Project> {
|
|
$$ProjectsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$TimeEntriesTable, List<TimeEntry>>
|
|
_timeEntriesRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.timeEntries,
|
|
aliasName: $_aliasNameGenerator(db.projects.id, db.timeEntries.projectId),
|
|
);
|
|
|
|
$$TimeEntriesTableProcessedTableManager get timeEntriesRefs {
|
|
final manager = $$TimeEntriesTableTableManager(
|
|
$_db,
|
|
$_db.timeEntries,
|
|
).filter((f) => f.projectId.id.sqlEquals($_itemColumn<int>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_timeEntriesRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$ProjectsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ProjectsTable> {
|
|
$$ProjectsTableFilterComposer({
|
|
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<int> get colorValue => $composableBuilder(
|
|
column: $table.colorValue,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get archivedAt => $composableBuilder(
|
|
column: $table.archivedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> timeEntriesRefs(
|
|
Expression<bool> Function($$TimeEntriesTableFilterComposer f) f,
|
|
) {
|
|
final $$TimeEntriesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.timeEntries,
|
|
getReferencedColumn: (t) => t.projectId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TimeEntriesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.timeEntries,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$ProjectsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ProjectsTable> {
|
|
$$ProjectsTableOrderingComposer({
|
|
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<int> get colorValue => $composableBuilder(
|
|
column: $table.colorValue,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get archivedAt => $composableBuilder(
|
|
column: $table.archivedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$ProjectsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ProjectsTable> {
|
|
$$ProjectsTableAnnotationComposer({
|
|
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<int> get colorValue => $composableBuilder(
|
|
column: $table.colorValue,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get archivedAt => $composableBuilder(
|
|
column: $table.archivedAt,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
Expression<T> timeEntriesRefs<T extends Object>(
|
|
Expression<T> Function($$TimeEntriesTableAnnotationComposer a) f,
|
|
) {
|
|
final $$TimeEntriesTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.timeEntries,
|
|
getReferencedColumn: (t) => t.projectId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TimeEntriesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.timeEntries,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$ProjectsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$ProjectsTable,
|
|
Project,
|
|
$$ProjectsTableFilterComposer,
|
|
$$ProjectsTableOrderingComposer,
|
|
$$ProjectsTableAnnotationComposer,
|
|
$$ProjectsTableCreateCompanionBuilder,
|
|
$$ProjectsTableUpdateCompanionBuilder,
|
|
(Project, $$ProjectsTableReferences),
|
|
Project,
|
|
PrefetchHooks Function({bool timeEntriesRefs})
|
|
> {
|
|
$$ProjectsTableTableManager(_$AppDatabase db, $ProjectsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ProjectsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ProjectsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ProjectsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<int> colorValue = const Value.absent(),
|
|
Value<String?> description = const Value.absent(),
|
|
Value<DateTime?> archivedAt = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
}) => ProjectsCompanion(
|
|
id: id,
|
|
name: name,
|
|
colorValue: colorValue,
|
|
description: description,
|
|
archivedAt: archivedAt,
|
|
createdAt: createdAt,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required String name,
|
|
required int colorValue,
|
|
Value<String?> description = const Value.absent(),
|
|
Value<DateTime?> archivedAt = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
}) => ProjectsCompanion.insert(
|
|
id: id,
|
|
name: name,
|
|
colorValue: colorValue,
|
|
description: description,
|
|
archivedAt: archivedAt,
|
|
createdAt: createdAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$ProjectsTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({timeEntriesRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (timeEntriesRefs) db.timeEntries],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (timeEntriesRefs)
|
|
await $_getPrefetchedData<
|
|
Project,
|
|
$ProjectsTable,
|
|
TimeEntry
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$ProjectsTableReferences
|
|
._timeEntriesRefsTable(db),
|
|
managerFromTypedResult: (p0) => $$ProjectsTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).timeEntriesRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.projectId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$ProjectsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ProjectsTable,
|
|
Project,
|
|
$$ProjectsTableFilterComposer,
|
|
$$ProjectsTableOrderingComposer,
|
|
$$ProjectsTableAnnotationComposer,
|
|
$$ProjectsTableCreateCompanionBuilder,
|
|
$$ProjectsTableUpdateCompanionBuilder,
|
|
(Project, $$ProjectsTableReferences),
|
|
Project,
|
|
PrefetchHooks Function({bool timeEntriesRefs})
|
|
>;
|
|
typedef $$TimeEntriesTableCreateCompanionBuilder =
|
|
TimeEntriesCompanion Function({
|
|
Value<int> id,
|
|
required int projectId,
|
|
required DateTime startTime,
|
|
Value<DateTime?> endTime,
|
|
Value<int?> durationSeconds,
|
|
Value<String?> note,
|
|
Value<DateTime> createdAt,
|
|
});
|
|
typedef $$TimeEntriesTableUpdateCompanionBuilder =
|
|
TimeEntriesCompanion Function({
|
|
Value<int> id,
|
|
Value<int> projectId,
|
|
Value<DateTime> startTime,
|
|
Value<DateTime?> endTime,
|
|
Value<int?> durationSeconds,
|
|
Value<String?> note,
|
|
Value<DateTime> createdAt,
|
|
});
|
|
|
|
final class $$TimeEntriesTableReferences
|
|
extends BaseReferences<_$AppDatabase, $TimeEntriesTable, TimeEntry> {
|
|
$$TimeEntriesTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $ProjectsTable _projectIdTable(_$AppDatabase db) =>
|
|
db.projects.createAlias(
|
|
$_aliasNameGenerator(db.timeEntries.projectId, db.projects.id),
|
|
);
|
|
|
|
$$ProjectsTableProcessedTableManager get projectId {
|
|
final $_column = $_itemColumn<int>('project_id')!;
|
|
|
|
final manager = $$ProjectsTableTableManager(
|
|
$_db,
|
|
$_db.projects,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_projectIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static MultiTypedResultKey<$TimeEntryTagsTable, List<TimeEntryTag>>
|
|
_timeEntryTagsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.timeEntryTags,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.timeEntries.id,
|
|
db.timeEntryTags.timeEntryId,
|
|
),
|
|
);
|
|
|
|
$$TimeEntryTagsTableProcessedTableManager get timeEntryTagsRefs {
|
|
final manager = $$TimeEntryTagsTableTableManager(
|
|
$_db,
|
|
$_db.timeEntryTags,
|
|
).filter((f) => f.timeEntryId.id.sqlEquals($_itemColumn<int>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_timeEntryTagsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$TimeEntriesTableFilterComposer
|
|
extends Composer<_$AppDatabase, $TimeEntriesTable> {
|
|
$$TimeEntriesTableFilterComposer({
|
|
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 startTime => $composableBuilder(
|
|
column: $table.startTime,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get endTime => $composableBuilder(
|
|
column: $table.endTime,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get durationSeconds => $composableBuilder(
|
|
column: $table.durationSeconds,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get note => $composableBuilder(
|
|
column: $table.note,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$ProjectsTableFilterComposer get projectId {
|
|
final $$ProjectsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.projectId,
|
|
referencedTable: $db.projects,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ProjectsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.projects,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
Expression<bool> timeEntryTagsRefs(
|
|
Expression<bool> Function($$TimeEntryTagsTableFilterComposer f) f,
|
|
) {
|
|
final $$TimeEntryTagsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.timeEntryTags,
|
|
getReferencedColumn: (t) => t.timeEntryId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TimeEntryTagsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.timeEntryTags,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TimeEntriesTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $TimeEntriesTable> {
|
|
$$TimeEntriesTableOrderingComposer({
|
|
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 startTime => $composableBuilder(
|
|
column: $table.startTime,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get endTime => $composableBuilder(
|
|
column: $table.endTime,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get durationSeconds => $composableBuilder(
|
|
column: $table.durationSeconds,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get note => $composableBuilder(
|
|
column: $table.note,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$ProjectsTableOrderingComposer get projectId {
|
|
final $$ProjectsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.projectId,
|
|
referencedTable: $db.projects,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ProjectsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.projects,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TimeEntriesTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $TimeEntriesTable> {
|
|
$$TimeEntriesTableAnnotationComposer({
|
|
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 startTime =>
|
|
$composableBuilder(column: $table.startTime, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get endTime =>
|
|
$composableBuilder(column: $table.endTime, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get durationSeconds => $composableBuilder(
|
|
column: $table.durationSeconds,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get note =>
|
|
$composableBuilder(column: $table.note, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
$$ProjectsTableAnnotationComposer get projectId {
|
|
final $$ProjectsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.projectId,
|
|
referencedTable: $db.projects,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ProjectsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.projects,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
Expression<T> timeEntryTagsRefs<T extends Object>(
|
|
Expression<T> Function($$TimeEntryTagsTableAnnotationComposer a) f,
|
|
) {
|
|
final $$TimeEntryTagsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.timeEntryTags,
|
|
getReferencedColumn: (t) => t.timeEntryId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TimeEntryTagsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.timeEntryTags,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TimeEntriesTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$TimeEntriesTable,
|
|
TimeEntry,
|
|
$$TimeEntriesTableFilterComposer,
|
|
$$TimeEntriesTableOrderingComposer,
|
|
$$TimeEntriesTableAnnotationComposer,
|
|
$$TimeEntriesTableCreateCompanionBuilder,
|
|
$$TimeEntriesTableUpdateCompanionBuilder,
|
|
(TimeEntry, $$TimeEntriesTableReferences),
|
|
TimeEntry,
|
|
PrefetchHooks Function({bool projectId, bool timeEntryTagsRefs})
|
|
> {
|
|
$$TimeEntriesTableTableManager(_$AppDatabase db, $TimeEntriesTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$TimeEntriesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$TimeEntriesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$TimeEntriesTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<int> projectId = const Value.absent(),
|
|
Value<DateTime> startTime = const Value.absent(),
|
|
Value<DateTime?> endTime = const Value.absent(),
|
|
Value<int?> durationSeconds = const Value.absent(),
|
|
Value<String?> note = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
}) => TimeEntriesCompanion(
|
|
id: id,
|
|
projectId: projectId,
|
|
startTime: startTime,
|
|
endTime: endTime,
|
|
durationSeconds: durationSeconds,
|
|
note: note,
|
|
createdAt: createdAt,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required int projectId,
|
|
required DateTime startTime,
|
|
Value<DateTime?> endTime = const Value.absent(),
|
|
Value<int?> durationSeconds = const Value.absent(),
|
|
Value<String?> note = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
}) => TimeEntriesCompanion.insert(
|
|
id: id,
|
|
projectId: projectId,
|
|
startTime: startTime,
|
|
endTime: endTime,
|
|
durationSeconds: durationSeconds,
|
|
note: note,
|
|
createdAt: createdAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$TimeEntriesTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback:
|
|
({projectId = false, timeEntryTagsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (timeEntryTagsRefs) db.timeEntryTags,
|
|
],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (projectId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.projectId,
|
|
referencedTable:
|
|
$$TimeEntriesTableReferences
|
|
._projectIdTable(db),
|
|
referencedColumn:
|
|
$$TimeEntriesTableReferences
|
|
._projectIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (timeEntryTagsRefs)
|
|
await $_getPrefetchedData<
|
|
TimeEntry,
|
|
$TimeEntriesTable,
|
|
TimeEntryTag
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$TimeEntriesTableReferences
|
|
._timeEntryTagsRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$TimeEntriesTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).timeEntryTagsRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems.where(
|
|
(e) => e.timeEntryId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$TimeEntriesTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$TimeEntriesTable,
|
|
TimeEntry,
|
|
$$TimeEntriesTableFilterComposer,
|
|
$$TimeEntriesTableOrderingComposer,
|
|
$$TimeEntriesTableAnnotationComposer,
|
|
$$TimeEntriesTableCreateCompanionBuilder,
|
|
$$TimeEntriesTableUpdateCompanionBuilder,
|
|
(TimeEntry, $$TimeEntriesTableReferences),
|
|
TimeEntry,
|
|
PrefetchHooks Function({bool projectId, bool timeEntryTagsRefs})
|
|
>;
|
|
typedef $$TagsTableCreateCompanionBuilder =
|
|
TagsCompanion Function({Value<int> id, required String name});
|
|
typedef $$TagsTableUpdateCompanionBuilder =
|
|
TagsCompanion Function({Value<int> id, Value<String> name});
|
|
|
|
final class $$TagsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $TagsTable, Tag> {
|
|
$$TagsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$TimeEntryTagsTable, List<TimeEntryTag>>
|
|
_timeEntryTagsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.timeEntryTags,
|
|
aliasName: $_aliasNameGenerator(db.tags.id, db.timeEntryTags.tagId),
|
|
);
|
|
|
|
$$TimeEntryTagsTableProcessedTableManager get timeEntryTagsRefs {
|
|
final manager = $$TimeEntryTagsTableTableManager(
|
|
$_db,
|
|
$_db.timeEntryTags,
|
|
).filter((f) => f.tagId.id.sqlEquals($_itemColumn<int>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_timeEntryTagsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$TagsTableFilterComposer extends Composer<_$AppDatabase, $TagsTable> {
|
|
$$TagsTableFilterComposer({
|
|
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),
|
|
);
|
|
|
|
Expression<bool> timeEntryTagsRefs(
|
|
Expression<bool> Function($$TimeEntryTagsTableFilterComposer f) f,
|
|
) {
|
|
final $$TimeEntryTagsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.timeEntryTags,
|
|
getReferencedColumn: (t) => t.tagId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TimeEntryTagsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.timeEntryTags,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TagsTableOrderingComposer extends Composer<_$AppDatabase, $TagsTable> {
|
|
$$TagsTableOrderingComposer({
|
|
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),
|
|
);
|
|
}
|
|
|
|
class $$TagsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $TagsTable> {
|
|
$$TagsTableAnnotationComposer({
|
|
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);
|
|
|
|
Expression<T> timeEntryTagsRefs<T extends Object>(
|
|
Expression<T> Function($$TimeEntryTagsTableAnnotationComposer a) f,
|
|
) {
|
|
final $$TimeEntryTagsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.timeEntryTags,
|
|
getReferencedColumn: (t) => t.tagId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TimeEntryTagsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.timeEntryTags,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TagsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$TagsTable,
|
|
Tag,
|
|
$$TagsTableFilterComposer,
|
|
$$TagsTableOrderingComposer,
|
|
$$TagsTableAnnotationComposer,
|
|
$$TagsTableCreateCompanionBuilder,
|
|
$$TagsTableUpdateCompanionBuilder,
|
|
(Tag, $$TagsTableReferences),
|
|
Tag,
|
|
PrefetchHooks Function({bool timeEntryTagsRefs})
|
|
> {
|
|
$$TagsTableTableManager(_$AppDatabase db, $TagsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$TagsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$TagsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$TagsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
}) => TagsCompanion(id: id, name: name),
|
|
createCompanionCallback:
|
|
({Value<int> id = const Value.absent(), required String name}) =>
|
|
TagsCompanion.insert(id: id, name: name),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) =>
|
|
(e.readTable(table), $$TagsTableReferences(db, table, e)),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({timeEntryTagsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (timeEntryTagsRefs) db.timeEntryTags,
|
|
],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (timeEntryTagsRefs)
|
|
await $_getPrefetchedData<Tag, $TagsTable, TimeEntryTag>(
|
|
currentTable: table,
|
|
referencedTable: $$TagsTableReferences
|
|
._timeEntryTagsRefsTable(db),
|
|
managerFromTypedResult: (p0) => $$TagsTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).timeEntryTagsRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.tagId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$TagsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$TagsTable,
|
|
Tag,
|
|
$$TagsTableFilterComposer,
|
|
$$TagsTableOrderingComposer,
|
|
$$TagsTableAnnotationComposer,
|
|
$$TagsTableCreateCompanionBuilder,
|
|
$$TagsTableUpdateCompanionBuilder,
|
|
(Tag, $$TagsTableReferences),
|
|
Tag,
|
|
PrefetchHooks Function({bool timeEntryTagsRefs})
|
|
>;
|
|
typedef $$TimeEntryTagsTableCreateCompanionBuilder =
|
|
TimeEntryTagsCompanion Function({
|
|
required int timeEntryId,
|
|
required int tagId,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$TimeEntryTagsTableUpdateCompanionBuilder =
|
|
TimeEntryTagsCompanion Function({
|
|
Value<int> timeEntryId,
|
|
Value<int> tagId,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$TimeEntryTagsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $TimeEntryTagsTable, TimeEntryTag> {
|
|
$$TimeEntryTagsTableReferences(
|
|
super.$_db,
|
|
super.$_table,
|
|
super.$_typedResult,
|
|
);
|
|
|
|
static $TimeEntriesTable _timeEntryIdTable(_$AppDatabase db) =>
|
|
db.timeEntries.createAlias(
|
|
$_aliasNameGenerator(db.timeEntryTags.timeEntryId, db.timeEntries.id),
|
|
);
|
|
|
|
$$TimeEntriesTableProcessedTableManager get timeEntryId {
|
|
final $_column = $_itemColumn<int>('time_entry_id')!;
|
|
|
|
final manager = $$TimeEntriesTableTableManager(
|
|
$_db,
|
|
$_db.timeEntries,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_timeEntryIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static $TagsTable _tagIdTable(_$AppDatabase db) => db.tags.createAlias(
|
|
$_aliasNameGenerator(db.timeEntryTags.tagId, db.tags.id),
|
|
);
|
|
|
|
$$TagsTableProcessedTableManager get tagId {
|
|
final $_column = $_itemColumn<int>('tag_id')!;
|
|
|
|
final manager = $$TagsTableTableManager(
|
|
$_db,
|
|
$_db.tags,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_tagIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$TimeEntryTagsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $TimeEntryTagsTable> {
|
|
$$TimeEntryTagsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
$$TimeEntriesTableFilterComposer get timeEntryId {
|
|
final $$TimeEntriesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.timeEntryId,
|
|
referencedTable: $db.timeEntries,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TimeEntriesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.timeEntries,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$TagsTableFilterComposer get tagId {
|
|
final $$TagsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.tagId,
|
|
referencedTable: $db.tags,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TagsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.tags,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TimeEntryTagsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $TimeEntryTagsTable> {
|
|
$$TimeEntryTagsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
$$TimeEntriesTableOrderingComposer get timeEntryId {
|
|
final $$TimeEntriesTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.timeEntryId,
|
|
referencedTable: $db.timeEntries,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TimeEntriesTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.timeEntries,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$TagsTableOrderingComposer get tagId {
|
|
final $$TagsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.tagId,
|
|
referencedTable: $db.tags,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TagsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.tags,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TimeEntryTagsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $TimeEntryTagsTable> {
|
|
$$TimeEntryTagsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
$$TimeEntriesTableAnnotationComposer get timeEntryId {
|
|
final $$TimeEntriesTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.timeEntryId,
|
|
referencedTable: $db.timeEntries,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TimeEntriesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.timeEntries,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$TagsTableAnnotationComposer get tagId {
|
|
final $$TagsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.tagId,
|
|
referencedTable: $db.tags,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TagsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.tags,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TimeEntryTagsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$TimeEntryTagsTable,
|
|
TimeEntryTag,
|
|
$$TimeEntryTagsTableFilterComposer,
|
|
$$TimeEntryTagsTableOrderingComposer,
|
|
$$TimeEntryTagsTableAnnotationComposer,
|
|
$$TimeEntryTagsTableCreateCompanionBuilder,
|
|
$$TimeEntryTagsTableUpdateCompanionBuilder,
|
|
(TimeEntryTag, $$TimeEntryTagsTableReferences),
|
|
TimeEntryTag,
|
|
PrefetchHooks Function({bool timeEntryId, bool tagId})
|
|
> {
|
|
$$TimeEntryTagsTableTableManager(_$AppDatabase db, $TimeEntryTagsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$TimeEntryTagsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$TimeEntryTagsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$TimeEntryTagsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> timeEntryId = const Value.absent(),
|
|
Value<int> tagId = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => TimeEntryTagsCompanion(
|
|
timeEntryId: timeEntryId,
|
|
tagId: tagId,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required int timeEntryId,
|
|
required int tagId,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => TimeEntryTagsCompanion.insert(
|
|
timeEntryId: timeEntryId,
|
|
tagId: tagId,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$TimeEntryTagsTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({timeEntryId = false, tagId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (timeEntryId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.timeEntryId,
|
|
referencedTable: $$TimeEntryTagsTableReferences
|
|
._timeEntryIdTable(db),
|
|
referencedColumn: $$TimeEntryTagsTableReferences
|
|
._timeEntryIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
if (tagId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.tagId,
|
|
referencedTable: $$TimeEntryTagsTableReferences
|
|
._tagIdTable(db),
|
|
referencedColumn: $$TimeEntryTagsTableReferences
|
|
._tagIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$TimeEntryTagsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$TimeEntryTagsTable,
|
|
TimeEntryTag,
|
|
$$TimeEntryTagsTableFilterComposer,
|
|
$$TimeEntryTagsTableOrderingComposer,
|
|
$$TimeEntryTagsTableAnnotationComposer,
|
|
$$TimeEntryTagsTableCreateCompanionBuilder,
|
|
$$TimeEntryTagsTableUpdateCompanionBuilder,
|
|
(TimeEntryTag, $$TimeEntryTagsTableReferences),
|
|
TimeEntryTag,
|
|
PrefetchHooks Function({bool timeEntryId, bool tagId})
|
|
>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$ProjectsTableTableManager get projects =>
|
|
$$ProjectsTableTableManager(_db, _db.projects);
|
|
$$TimeEntriesTableTableManager get timeEntries =>
|
|
$$TimeEntriesTableTableManager(_db, _db.timeEntries);
|
|
$$TagsTableTableManager get tags => $$TagsTableTableManager(_db, _db.tags);
|
|
$$TimeEntryTagsTableTableManager get timeEntryTags =>
|
|
$$TimeEntryTagsTableTableManager(_db, _db.timeEntryTags);
|
|
}
|
|
|
|
// **************************************************************************
|
|
// RiverpodGenerator
|
|
// **************************************************************************
|
|
|
|
String _$appDatabaseHash() => r'96b544ff7ce456f0fc1edbdafdf332306a9affed';
|
|
|
|
/// See also [appDatabase].
|
|
@ProviderFor(appDatabase)
|
|
final appDatabaseProvider = Provider<AppDatabase>.internal(
|
|
appDatabase,
|
|
name: r'appDatabaseProvider',
|
|
debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
|
|
? null
|
|
: _$appDatabaseHash,
|
|
dependencies: null,
|
|
allTransitiveDependencies: null,
|
|
);
|
|
|
|
@Deprecated('Will be removed in 3.0. Use Ref instead')
|
|
// ignore: unused_element
|
|
typedef AppDatabaseRef = ProviderRef<AppDatabase>;
|
|
// ignore_for_file: type=lint
|
|
// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package
|