4438 lines
160 KiB
Dart
4438 lines
160 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $SessionsTable extends Sessions with TableInfo<$SessionsTable, Session> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$SessionsTable(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 _titleMeta = const VerificationMeta('title');
|
|
@override
|
|
late final GeneratedColumn<String> title = GeneratedColumn<String>(
|
|
'title', aliasedName, false,
|
|
additionalChecks:
|
|
GeneratedColumn.checkTextLength(minTextLength: 3, maxTextLength: 32),
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true);
|
|
static const VerificationMeta _contentMeta =
|
|
const VerificationMeta('content');
|
|
@override
|
|
late final GeneratedColumn<String> content = GeneratedColumn<String>(
|
|
'body', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
static const VerificationMeta _dateMeta = const VerificationMeta('date');
|
|
@override
|
|
late final GeneratedColumn<DateTime> date = GeneratedColumn<DateTime>(
|
|
'date', 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, true,
|
|
type: DriftSqlType.dateTime, requiredDuringInsert: false);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, title, content, date, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'sessions';
|
|
@override
|
|
VerificationContext validateIntegrity(Insertable<Session> 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('title')) {
|
|
context.handle(
|
|
_titleMeta, title.isAcceptableOrUnknown(data['title']!, _titleMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_titleMeta);
|
|
}
|
|
if (data.containsKey('body')) {
|
|
context.handle(_contentMeta,
|
|
content.isAcceptableOrUnknown(data['body']!, _contentMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_contentMeta);
|
|
}
|
|
if (data.containsKey('date')) {
|
|
context.handle(
|
|
_dateMeta, date.isAcceptableOrUnknown(data['date']!, _dateMeta));
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta));
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Session map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Session(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}id'])!,
|
|
title: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}title'])!,
|
|
content: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}body'])!,
|
|
date: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}date']),
|
|
createdAt: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}created_at']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$SessionsTable createAlias(String alias) {
|
|
return $SessionsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Session extends DataClass implements Insertable<Session> {
|
|
final int id;
|
|
final String title;
|
|
final String content;
|
|
final DateTime? date;
|
|
final DateTime? createdAt;
|
|
const Session(
|
|
{required this.id,
|
|
required this.title,
|
|
required this.content,
|
|
this.date,
|
|
this.createdAt});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['title'] = Variable<String>(title);
|
|
map['body'] = Variable<String>(content);
|
|
if (!nullToAbsent || date != null) {
|
|
map['date'] = Variable<DateTime>(date);
|
|
}
|
|
if (!nullToAbsent || createdAt != null) {
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
SessionsCompanion toCompanion(bool nullToAbsent) {
|
|
return SessionsCompanion(
|
|
id: Value(id),
|
|
title: Value(title),
|
|
content: Value(content),
|
|
date: date == null && nullToAbsent ? const Value.absent() : Value(date),
|
|
createdAt: createdAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory Session.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Session(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
title: serializer.fromJson<String>(json['title']),
|
|
content: serializer.fromJson<String>(json['content']),
|
|
date: serializer.fromJson<DateTime?>(json['date']),
|
|
createdAt: serializer.fromJson<DateTime?>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'title': serializer.toJson<String>(title),
|
|
'content': serializer.toJson<String>(content),
|
|
'date': serializer.toJson<DateTime?>(date),
|
|
'createdAt': serializer.toJson<DateTime?>(createdAt),
|
|
};
|
|
}
|
|
|
|
Session copyWith(
|
|
{int? id,
|
|
String? title,
|
|
String? content,
|
|
Value<DateTime?> date = const Value.absent(),
|
|
Value<DateTime?> createdAt = const Value.absent()}) =>
|
|
Session(
|
|
id: id ?? this.id,
|
|
title: title ?? this.title,
|
|
content: content ?? this.content,
|
|
date: date.present ? date.value : this.date,
|
|
createdAt: createdAt.present ? createdAt.value : this.createdAt,
|
|
);
|
|
Session copyWithCompanion(SessionsCompanion data) {
|
|
return Session(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
title: data.title.present ? data.title.value : this.title,
|
|
content: data.content.present ? data.content.value : this.content,
|
|
date: data.date.present ? data.date.value : this.date,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Session(')
|
|
..write('id: $id, ')
|
|
..write('title: $title, ')
|
|
..write('content: $content, ')
|
|
..write('date: $date, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, title, content, date, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Session &&
|
|
other.id == this.id &&
|
|
other.title == this.title &&
|
|
other.content == this.content &&
|
|
other.date == this.date &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class SessionsCompanion extends UpdateCompanion<Session> {
|
|
final Value<int> id;
|
|
final Value<String> title;
|
|
final Value<String> content;
|
|
final Value<DateTime?> date;
|
|
final Value<DateTime?> createdAt;
|
|
const SessionsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.content = const Value.absent(),
|
|
this.date = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
});
|
|
SessionsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String title,
|
|
required String content,
|
|
this.date = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
}) : title = Value(title),
|
|
content = Value(content);
|
|
static Insertable<Session> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? title,
|
|
Expression<String>? content,
|
|
Expression<DateTime>? date,
|
|
Expression<DateTime>? createdAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (title != null) 'title': title,
|
|
if (content != null) 'body': content,
|
|
if (date != null) 'date': date,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
});
|
|
}
|
|
|
|
SessionsCompanion copyWith(
|
|
{Value<int>? id,
|
|
Value<String>? title,
|
|
Value<String>? content,
|
|
Value<DateTime?>? date,
|
|
Value<DateTime?>? createdAt}) {
|
|
return SessionsCompanion(
|
|
id: id ?? this.id,
|
|
title: title ?? this.title,
|
|
content: content ?? this.content,
|
|
date: date ?? this.date,
|
|
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 (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (content.present) {
|
|
map['body'] = Variable<String>(content.value);
|
|
}
|
|
if (date.present) {
|
|
map['date'] = Variable<DateTime>(date.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('SessionsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('title: $title, ')
|
|
..write('content: $content, ')
|
|
..write('date: $date, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ActivitiesTable extends Activities
|
|
with TableInfo<$ActivitiesTable, Activity> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ActivitiesTable(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 _titleMeta = const VerificationMeta('title');
|
|
@override
|
|
late final GeneratedColumn<String> title = GeneratedColumn<String>(
|
|
'title', aliasedName, false,
|
|
additionalChecks:
|
|
GeneratedColumn.checkTextLength(minTextLength: 3, maxTextLength: 32),
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true);
|
|
static const VerificationMeta _typeMeta = const VerificationMeta('type');
|
|
@override
|
|
late final GeneratedColumn<String> type = GeneratedColumn<String>(
|
|
'type', aliasedName, false,
|
|
additionalChecks:
|
|
GeneratedColumn.checkTextLength(minTextLength: 3, maxTextLength: 32),
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true);
|
|
static const VerificationMeta _descriptionMeta =
|
|
const VerificationMeta('description');
|
|
@override
|
|
late final GeneratedColumn<String> description = GeneratedColumn<String>(
|
|
'body', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
static const VerificationMeta _categoriesMeta =
|
|
const VerificationMeta('categories');
|
|
@override
|
|
late final GeneratedColumnWithTypeConverter<Categories, String> categories =
|
|
GeneratedColumn<String>('categories', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true)
|
|
.withConverter<Categories>($ActivitiesTable.$convertercategories);
|
|
static const VerificationMeta _createdAtMeta =
|
|
const VerificationMeta('createdAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at', aliasedName, true,
|
|
type: DriftSqlType.dateTime, requiredDuringInsert: false);
|
|
@override
|
|
List<GeneratedColumn> get $columns =>
|
|
[id, title, type, description, categories, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'activities';
|
|
@override
|
|
VerificationContext validateIntegrity(Insertable<Activity> 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('title')) {
|
|
context.handle(
|
|
_titleMeta, title.isAcceptableOrUnknown(data['title']!, _titleMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_titleMeta);
|
|
}
|
|
if (data.containsKey('type')) {
|
|
context.handle(
|
|
_typeMeta, type.isAcceptableOrUnknown(data['type']!, _typeMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_typeMeta);
|
|
}
|
|
if (data.containsKey('body')) {
|
|
context.handle(_descriptionMeta,
|
|
description.isAcceptableOrUnknown(data['body']!, _descriptionMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_descriptionMeta);
|
|
}
|
|
context.handle(_categoriesMeta, const VerificationResult.success());
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta));
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Activity map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Activity(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}id'])!,
|
|
title: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}title'])!,
|
|
type: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}type'])!,
|
|
description: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}body'])!,
|
|
categories: $ActivitiesTable.$convertercategories.fromSql(attachedDatabase
|
|
.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}categories'])!),
|
|
createdAt: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}created_at']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ActivitiesTable createAlias(String alias) {
|
|
return $ActivitiesTable(attachedDatabase, alias);
|
|
}
|
|
|
|
static JsonTypeConverter2<Categories, String, String> $convertercategories =
|
|
const EnumNameConverter<Categories>(Categories.values);
|
|
}
|
|
|
|
class Activity extends DataClass implements Insertable<Activity> {
|
|
final int id;
|
|
final String title;
|
|
final String type;
|
|
final String description;
|
|
final Categories categories;
|
|
final DateTime? createdAt;
|
|
const Activity(
|
|
{required this.id,
|
|
required this.title,
|
|
required this.type,
|
|
required this.description,
|
|
required this.categories,
|
|
this.createdAt});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['title'] = Variable<String>(title);
|
|
map['type'] = Variable<String>(type);
|
|
map['body'] = Variable<String>(description);
|
|
{
|
|
map['categories'] = Variable<String>(
|
|
$ActivitiesTable.$convertercategories.toSql(categories));
|
|
}
|
|
if (!nullToAbsent || createdAt != null) {
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
ActivitiesCompanion toCompanion(bool nullToAbsent) {
|
|
return ActivitiesCompanion(
|
|
id: Value(id),
|
|
title: Value(title),
|
|
type: Value(type),
|
|
description: Value(description),
|
|
categories: Value(categories),
|
|
createdAt: createdAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory Activity.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Activity(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
title: serializer.fromJson<String>(json['title']),
|
|
type: serializer.fromJson<String>(json['type']),
|
|
description: serializer.fromJson<String>(json['description']),
|
|
categories: $ActivitiesTable.$convertercategories
|
|
.fromJson(serializer.fromJson<String>(json['categories'])),
|
|
createdAt: serializer.fromJson<DateTime?>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'title': serializer.toJson<String>(title),
|
|
'type': serializer.toJson<String>(type),
|
|
'description': serializer.toJson<String>(description),
|
|
'categories': serializer.toJson<String>(
|
|
$ActivitiesTable.$convertercategories.toJson(categories)),
|
|
'createdAt': serializer.toJson<DateTime?>(createdAt),
|
|
};
|
|
}
|
|
|
|
Activity copyWith(
|
|
{int? id,
|
|
String? title,
|
|
String? type,
|
|
String? description,
|
|
Categories? categories,
|
|
Value<DateTime?> createdAt = const Value.absent()}) =>
|
|
Activity(
|
|
id: id ?? this.id,
|
|
title: title ?? this.title,
|
|
type: type ?? this.type,
|
|
description: description ?? this.description,
|
|
categories: categories ?? this.categories,
|
|
createdAt: createdAt.present ? createdAt.value : this.createdAt,
|
|
);
|
|
Activity copyWithCompanion(ActivitiesCompanion data) {
|
|
return Activity(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
title: data.title.present ? data.title.value : this.title,
|
|
type: data.type.present ? data.type.value : this.type,
|
|
description:
|
|
data.description.present ? data.description.value : this.description,
|
|
categories:
|
|
data.categories.present ? data.categories.value : this.categories,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Activity(')
|
|
..write('id: $id, ')
|
|
..write('title: $title, ')
|
|
..write('type: $type, ')
|
|
..write('description: $description, ')
|
|
..write('categories: $categories, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(id, title, type, description, categories, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Activity &&
|
|
other.id == this.id &&
|
|
other.title == this.title &&
|
|
other.type == this.type &&
|
|
other.description == this.description &&
|
|
other.categories == this.categories &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class ActivitiesCompanion extends UpdateCompanion<Activity> {
|
|
final Value<int> id;
|
|
final Value<String> title;
|
|
final Value<String> type;
|
|
final Value<String> description;
|
|
final Value<Categories> categories;
|
|
final Value<DateTime?> createdAt;
|
|
const ActivitiesCompanion({
|
|
this.id = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.type = const Value.absent(),
|
|
this.description = const Value.absent(),
|
|
this.categories = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
});
|
|
ActivitiesCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String title,
|
|
required String type,
|
|
required String description,
|
|
required Categories categories,
|
|
this.createdAt = const Value.absent(),
|
|
}) : title = Value(title),
|
|
type = Value(type),
|
|
description = Value(description),
|
|
categories = Value(categories);
|
|
static Insertable<Activity> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? title,
|
|
Expression<String>? type,
|
|
Expression<String>? description,
|
|
Expression<String>? categories,
|
|
Expression<DateTime>? createdAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (title != null) 'title': title,
|
|
if (type != null) 'type': type,
|
|
if (description != null) 'body': description,
|
|
if (categories != null) 'categories': categories,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
});
|
|
}
|
|
|
|
ActivitiesCompanion copyWith(
|
|
{Value<int>? id,
|
|
Value<String>? title,
|
|
Value<String>? type,
|
|
Value<String>? description,
|
|
Value<Categories>? categories,
|
|
Value<DateTime?>? createdAt}) {
|
|
return ActivitiesCompanion(
|
|
id: id ?? this.id,
|
|
title: title ?? this.title,
|
|
type: type ?? this.type,
|
|
description: description ?? this.description,
|
|
categories: categories ?? this.categories,
|
|
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 (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (type.present) {
|
|
map['type'] = Variable<String>(type.value);
|
|
}
|
|
if (description.present) {
|
|
map['body'] = Variable<String>(description.value);
|
|
}
|
|
if (categories.present) {
|
|
map['categories'] = Variable<String>(
|
|
$ActivitiesTable.$convertercategories.toSql(categories.value));
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ActivitiesCompanion(')
|
|
..write('id: $id, ')
|
|
..write('title: $title, ')
|
|
..write('type: $type, ')
|
|
..write('description: $description, ')
|
|
..write('categories: $categories, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $SessionActivitiesTable extends SessionActivities
|
|
with TableInfo<$SessionActivitiesTable, SessionActivity> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$SessionActivitiesTable(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 _sessionIdMeta =
|
|
const VerificationMeta('sessionId');
|
|
@override
|
|
late final GeneratedColumn<int> sessionId = GeneratedColumn<int>(
|
|
'session_id', aliasedName, false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints:
|
|
GeneratedColumn.constraintIsAlways('REFERENCES sessions (id)'));
|
|
static const VerificationMeta _activityIdMeta =
|
|
const VerificationMeta('activityId');
|
|
@override
|
|
late final GeneratedColumn<int> activityId = GeneratedColumn<int>(
|
|
'activity_id', aliasedName, false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints:
|
|
GeneratedColumn.constraintIsAlways('REFERENCES activities (id)'));
|
|
static const VerificationMeta _resultsMeta =
|
|
const VerificationMeta('results');
|
|
@override
|
|
late final GeneratedColumn<String> results = GeneratedColumn<String>(
|
|
'results', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
static const VerificationMeta _achievementsMeta =
|
|
const VerificationMeta('achievements');
|
|
@override
|
|
late final GeneratedColumn<String> achievements = GeneratedColumn<String>(
|
|
'achievements', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
static const VerificationMeta _createdAtMeta =
|
|
const VerificationMeta('createdAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at', aliasedName, true,
|
|
type: DriftSqlType.dateTime, requiredDuringInsert: false);
|
|
@override
|
|
List<GeneratedColumn> get $columns =>
|
|
[id, sessionId, activityId, results, achievements, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'session_activities';
|
|
@override
|
|
VerificationContext validateIntegrity(Insertable<SessionActivity> 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('session_id')) {
|
|
context.handle(_sessionIdMeta,
|
|
sessionId.isAcceptableOrUnknown(data['session_id']!, _sessionIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_sessionIdMeta);
|
|
}
|
|
if (data.containsKey('activity_id')) {
|
|
context.handle(
|
|
_activityIdMeta,
|
|
activityId.isAcceptableOrUnknown(
|
|
data['activity_id']!, _activityIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_activityIdMeta);
|
|
}
|
|
if (data.containsKey('results')) {
|
|
context.handle(_resultsMeta,
|
|
results.isAcceptableOrUnknown(data['results']!, _resultsMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_resultsMeta);
|
|
}
|
|
if (data.containsKey('achievements')) {
|
|
context.handle(
|
|
_achievementsMeta,
|
|
achievements.isAcceptableOrUnknown(
|
|
data['achievements']!, _achievementsMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_achievementsMeta);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta));
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
SessionActivity map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return SessionActivity(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}id'])!,
|
|
sessionId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}session_id'])!,
|
|
activityId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}activity_id'])!,
|
|
results: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}results'])!,
|
|
achievements: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}achievements'])!,
|
|
createdAt: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}created_at']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$SessionActivitiesTable createAlias(String alias) {
|
|
return $SessionActivitiesTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class SessionActivity extends DataClass implements Insertable<SessionActivity> {
|
|
final int id;
|
|
final int sessionId;
|
|
final int activityId;
|
|
final String results;
|
|
final String achievements;
|
|
final DateTime? createdAt;
|
|
const SessionActivity(
|
|
{required this.id,
|
|
required this.sessionId,
|
|
required this.activityId,
|
|
required this.results,
|
|
required this.achievements,
|
|
this.createdAt});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['session_id'] = Variable<int>(sessionId);
|
|
map['activity_id'] = Variable<int>(activityId);
|
|
map['results'] = Variable<String>(results);
|
|
map['achievements'] = Variable<String>(achievements);
|
|
if (!nullToAbsent || createdAt != null) {
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
SessionActivitiesCompanion toCompanion(bool nullToAbsent) {
|
|
return SessionActivitiesCompanion(
|
|
id: Value(id),
|
|
sessionId: Value(sessionId),
|
|
activityId: Value(activityId),
|
|
results: Value(results),
|
|
achievements: Value(achievements),
|
|
createdAt: createdAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory SessionActivity.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return SessionActivity(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
sessionId: serializer.fromJson<int>(json['sessionId']),
|
|
activityId: serializer.fromJson<int>(json['activityId']),
|
|
results: serializer.fromJson<String>(json['results']),
|
|
achievements: serializer.fromJson<String>(json['achievements']),
|
|
createdAt: serializer.fromJson<DateTime?>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'sessionId': serializer.toJson<int>(sessionId),
|
|
'activityId': serializer.toJson<int>(activityId),
|
|
'results': serializer.toJson<String>(results),
|
|
'achievements': serializer.toJson<String>(achievements),
|
|
'createdAt': serializer.toJson<DateTime?>(createdAt),
|
|
};
|
|
}
|
|
|
|
SessionActivity copyWith(
|
|
{int? id,
|
|
int? sessionId,
|
|
int? activityId,
|
|
String? results,
|
|
String? achievements,
|
|
Value<DateTime?> createdAt = const Value.absent()}) =>
|
|
SessionActivity(
|
|
id: id ?? this.id,
|
|
sessionId: sessionId ?? this.sessionId,
|
|
activityId: activityId ?? this.activityId,
|
|
results: results ?? this.results,
|
|
achievements: achievements ?? this.achievements,
|
|
createdAt: createdAt.present ? createdAt.value : this.createdAt,
|
|
);
|
|
SessionActivity copyWithCompanion(SessionActivitiesCompanion data) {
|
|
return SessionActivity(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
sessionId: data.sessionId.present ? data.sessionId.value : this.sessionId,
|
|
activityId:
|
|
data.activityId.present ? data.activityId.value : this.activityId,
|
|
results: data.results.present ? data.results.value : this.results,
|
|
achievements: data.achievements.present
|
|
? data.achievements.value
|
|
: this.achievements,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('SessionActivity(')
|
|
..write('id: $id, ')
|
|
..write('sessionId: $sessionId, ')
|
|
..write('activityId: $activityId, ')
|
|
..write('results: $results, ')
|
|
..write('achievements: $achievements, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(id, sessionId, activityId, results, achievements, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is SessionActivity &&
|
|
other.id == this.id &&
|
|
other.sessionId == this.sessionId &&
|
|
other.activityId == this.activityId &&
|
|
other.results == this.results &&
|
|
other.achievements == this.achievements &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class SessionActivitiesCompanion extends UpdateCompanion<SessionActivity> {
|
|
final Value<int> id;
|
|
final Value<int> sessionId;
|
|
final Value<int> activityId;
|
|
final Value<String> results;
|
|
final Value<String> achievements;
|
|
final Value<DateTime?> createdAt;
|
|
const SessionActivitiesCompanion({
|
|
this.id = const Value.absent(),
|
|
this.sessionId = const Value.absent(),
|
|
this.activityId = const Value.absent(),
|
|
this.results = const Value.absent(),
|
|
this.achievements = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
});
|
|
SessionActivitiesCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required int sessionId,
|
|
required int activityId,
|
|
required String results,
|
|
required String achievements,
|
|
this.createdAt = const Value.absent(),
|
|
}) : sessionId = Value(sessionId),
|
|
activityId = Value(activityId),
|
|
results = Value(results),
|
|
achievements = Value(achievements);
|
|
static Insertable<SessionActivity> custom({
|
|
Expression<int>? id,
|
|
Expression<int>? sessionId,
|
|
Expression<int>? activityId,
|
|
Expression<String>? results,
|
|
Expression<String>? achievements,
|
|
Expression<DateTime>? createdAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (sessionId != null) 'session_id': sessionId,
|
|
if (activityId != null) 'activity_id': activityId,
|
|
if (results != null) 'results': results,
|
|
if (achievements != null) 'achievements': achievements,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
});
|
|
}
|
|
|
|
SessionActivitiesCompanion copyWith(
|
|
{Value<int>? id,
|
|
Value<int>? sessionId,
|
|
Value<int>? activityId,
|
|
Value<String>? results,
|
|
Value<String>? achievements,
|
|
Value<DateTime?>? createdAt}) {
|
|
return SessionActivitiesCompanion(
|
|
id: id ?? this.id,
|
|
sessionId: sessionId ?? this.sessionId,
|
|
activityId: activityId ?? this.activityId,
|
|
results: results ?? this.results,
|
|
achievements: achievements ?? this.achievements,
|
|
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 (sessionId.present) {
|
|
map['session_id'] = Variable<int>(sessionId.value);
|
|
}
|
|
if (activityId.present) {
|
|
map['activity_id'] = Variable<int>(activityId.value);
|
|
}
|
|
if (results.present) {
|
|
map['results'] = Variable<String>(results.value);
|
|
}
|
|
if (achievements.present) {
|
|
map['achievements'] = Variable<String>(achievements.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('SessionActivitiesCompanion(')
|
|
..write('id: $id, ')
|
|
..write('sessionId: $sessionId, ')
|
|
..write('activityId: $activityId, ')
|
|
..write('results: $results, ')
|
|
..write('achievements: $achievements, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ActionsTable extends Actions with TableInfo<$ActionsTable, Action> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ActionsTable(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 _titleMeta = const VerificationMeta('title');
|
|
@override
|
|
late final GeneratedColumn<String> title = GeneratedColumn<String>(
|
|
'title', aliasedName, false,
|
|
additionalChecks:
|
|
GeneratedColumn.checkTextLength(minTextLength: 3, maxTextLength: 32),
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true);
|
|
static const VerificationMeta _descriptionMeta =
|
|
const VerificationMeta('description');
|
|
@override
|
|
late final GeneratedColumn<String> description = GeneratedColumn<String>(
|
|
'body', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
static const VerificationMeta _setMeta = const VerificationMeta('set');
|
|
@override
|
|
late final GeneratedColumn<String> set = GeneratedColumn<String>(
|
|
'set', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
static const VerificationMeta _createdAtMeta =
|
|
const VerificationMeta('createdAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at', aliasedName, true,
|
|
type: DriftSqlType.dateTime, requiredDuringInsert: false);
|
|
@override
|
|
List<GeneratedColumn> get $columns =>
|
|
[id, title, description, set, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'actions';
|
|
@override
|
|
VerificationContext validateIntegrity(Insertable<Action> 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('title')) {
|
|
context.handle(
|
|
_titleMeta, title.isAcceptableOrUnknown(data['title']!, _titleMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_titleMeta);
|
|
}
|
|
if (data.containsKey('body')) {
|
|
context.handle(_descriptionMeta,
|
|
description.isAcceptableOrUnknown(data['body']!, _descriptionMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_descriptionMeta);
|
|
}
|
|
if (data.containsKey('set')) {
|
|
context.handle(
|
|
_setMeta, set.isAcceptableOrUnknown(data['set']!, _setMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_setMeta);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta));
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Action map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Action(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}id'])!,
|
|
title: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}title'])!,
|
|
description: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}body'])!,
|
|
set: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}set'])!,
|
|
createdAt: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}created_at']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ActionsTable createAlias(String alias) {
|
|
return $ActionsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Action extends DataClass implements Insertable<Action> {
|
|
final int id;
|
|
final String title;
|
|
final String description;
|
|
final String set;
|
|
final DateTime? createdAt;
|
|
const Action(
|
|
{required this.id,
|
|
required this.title,
|
|
required this.description,
|
|
required this.set,
|
|
this.createdAt});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['title'] = Variable<String>(title);
|
|
map['body'] = Variable<String>(description);
|
|
map['set'] = Variable<String>(set);
|
|
if (!nullToAbsent || createdAt != null) {
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
ActionsCompanion toCompanion(bool nullToAbsent) {
|
|
return ActionsCompanion(
|
|
id: Value(id),
|
|
title: Value(title),
|
|
description: Value(description),
|
|
set: Value(set),
|
|
createdAt: createdAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory Action.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Action(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
title: serializer.fromJson<String>(json['title']),
|
|
description: serializer.fromJson<String>(json['description']),
|
|
set: serializer.fromJson<String>(json['set']),
|
|
createdAt: serializer.fromJson<DateTime?>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'title': serializer.toJson<String>(title),
|
|
'description': serializer.toJson<String>(description),
|
|
'set': serializer.toJson<String>(set),
|
|
'createdAt': serializer.toJson<DateTime?>(createdAt),
|
|
};
|
|
}
|
|
|
|
Action copyWith(
|
|
{int? id,
|
|
String? title,
|
|
String? description,
|
|
String? set,
|
|
Value<DateTime?> createdAt = const Value.absent()}) =>
|
|
Action(
|
|
id: id ?? this.id,
|
|
title: title ?? this.title,
|
|
description: description ?? this.description,
|
|
set: set ?? this.set,
|
|
createdAt: createdAt.present ? createdAt.value : this.createdAt,
|
|
);
|
|
Action copyWithCompanion(ActionsCompanion data) {
|
|
return Action(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
title: data.title.present ? data.title.value : this.title,
|
|
description:
|
|
data.description.present ? data.description.value : this.description,
|
|
set: data.set.present ? data.set.value : this.set,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Action(')
|
|
..write('id: $id, ')
|
|
..write('title: $title, ')
|
|
..write('description: $description, ')
|
|
..write('set: $set, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, title, description, set, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Action &&
|
|
other.id == this.id &&
|
|
other.title == this.title &&
|
|
other.description == this.description &&
|
|
other.set == this.set &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class ActionsCompanion extends UpdateCompanion<Action> {
|
|
final Value<int> id;
|
|
final Value<String> title;
|
|
final Value<String> description;
|
|
final Value<String> set;
|
|
final Value<DateTime?> createdAt;
|
|
const ActionsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.description = const Value.absent(),
|
|
this.set = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
});
|
|
ActionsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String title,
|
|
required String description,
|
|
required String set,
|
|
this.createdAt = const Value.absent(),
|
|
}) : title = Value(title),
|
|
description = Value(description),
|
|
set = Value(set);
|
|
static Insertable<Action> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? title,
|
|
Expression<String>? description,
|
|
Expression<String>? set,
|
|
Expression<DateTime>? createdAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (title != null) 'title': title,
|
|
if (description != null) 'body': description,
|
|
if (set != null) 'set': set,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
});
|
|
}
|
|
|
|
ActionsCompanion copyWith(
|
|
{Value<int>? id,
|
|
Value<String>? title,
|
|
Value<String>? description,
|
|
Value<String>? set,
|
|
Value<DateTime?>? createdAt}) {
|
|
return ActionsCompanion(
|
|
id: id ?? this.id,
|
|
title: title ?? this.title,
|
|
description: description ?? this.description,
|
|
set: set ?? this.set,
|
|
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 (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (description.present) {
|
|
map['body'] = Variable<String>(description.value);
|
|
}
|
|
if (set.present) {
|
|
map['set'] = Variable<String>(set.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ActionsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('title: $title, ')
|
|
..write('description: $description, ')
|
|
..write('set: $set, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ActivityActionsTable extends ActivityActions
|
|
with TableInfo<$ActivityActionsTable, ActivityAction> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ActivityActionsTable(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 _activityIdMeta =
|
|
const VerificationMeta('activityId');
|
|
@override
|
|
late final GeneratedColumn<int> activityId = GeneratedColumn<int>(
|
|
'activity_id', aliasedName, false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints:
|
|
GeneratedColumn.constraintIsAlways('REFERENCES activities (id)'));
|
|
static const VerificationMeta _actionIdMeta =
|
|
const VerificationMeta('actionId');
|
|
@override
|
|
late final GeneratedColumn<int> actionId = GeneratedColumn<int>(
|
|
'action_id', aliasedName, false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints:
|
|
GeneratedColumn.constraintIsAlways('REFERENCES actions (id)'));
|
|
static const VerificationMeta _createdAtMeta =
|
|
const VerificationMeta('createdAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at', aliasedName, true,
|
|
type: DriftSqlType.dateTime, requiredDuringInsert: false);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, activityId, actionId, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'activity_actions';
|
|
@override
|
|
VerificationContext validateIntegrity(Insertable<ActivityAction> 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('activity_id')) {
|
|
context.handle(
|
|
_activityIdMeta,
|
|
activityId.isAcceptableOrUnknown(
|
|
data['activity_id']!, _activityIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_activityIdMeta);
|
|
}
|
|
if (data.containsKey('action_id')) {
|
|
context.handle(_actionIdMeta,
|
|
actionId.isAcceptableOrUnknown(data['action_id']!, _actionIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_actionIdMeta);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta));
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
ActivityAction map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ActivityAction(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}id'])!,
|
|
activityId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}activity_id'])!,
|
|
actionId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}action_id'])!,
|
|
createdAt: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}created_at']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ActivityActionsTable createAlias(String alias) {
|
|
return $ActivityActionsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class ActivityAction extends DataClass implements Insertable<ActivityAction> {
|
|
final int id;
|
|
final int activityId;
|
|
final int actionId;
|
|
final DateTime? createdAt;
|
|
const ActivityAction(
|
|
{required this.id,
|
|
required this.activityId,
|
|
required this.actionId,
|
|
this.createdAt});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['activity_id'] = Variable<int>(activityId);
|
|
map['action_id'] = Variable<int>(actionId);
|
|
if (!nullToAbsent || createdAt != null) {
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
ActivityActionsCompanion toCompanion(bool nullToAbsent) {
|
|
return ActivityActionsCompanion(
|
|
id: Value(id),
|
|
activityId: Value(activityId),
|
|
actionId: Value(actionId),
|
|
createdAt: createdAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory ActivityAction.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return ActivityAction(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
activityId: serializer.fromJson<int>(json['activityId']),
|
|
actionId: serializer.fromJson<int>(json['actionId']),
|
|
createdAt: serializer.fromJson<DateTime?>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'activityId': serializer.toJson<int>(activityId),
|
|
'actionId': serializer.toJson<int>(actionId),
|
|
'createdAt': serializer.toJson<DateTime?>(createdAt),
|
|
};
|
|
}
|
|
|
|
ActivityAction copyWith(
|
|
{int? id,
|
|
int? activityId,
|
|
int? actionId,
|
|
Value<DateTime?> createdAt = const Value.absent()}) =>
|
|
ActivityAction(
|
|
id: id ?? this.id,
|
|
activityId: activityId ?? this.activityId,
|
|
actionId: actionId ?? this.actionId,
|
|
createdAt: createdAt.present ? createdAt.value : this.createdAt,
|
|
);
|
|
ActivityAction copyWithCompanion(ActivityActionsCompanion data) {
|
|
return ActivityAction(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
activityId:
|
|
data.activityId.present ? data.activityId.value : this.activityId,
|
|
actionId: data.actionId.present ? data.actionId.value : this.actionId,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ActivityAction(')
|
|
..write('id: $id, ')
|
|
..write('activityId: $activityId, ')
|
|
..write('actionId: $actionId, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, activityId, actionId, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is ActivityAction &&
|
|
other.id == this.id &&
|
|
other.activityId == this.activityId &&
|
|
other.actionId == this.actionId &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class ActivityActionsCompanion extends UpdateCompanion<ActivityAction> {
|
|
final Value<int> id;
|
|
final Value<int> activityId;
|
|
final Value<int> actionId;
|
|
final Value<DateTime?> createdAt;
|
|
const ActivityActionsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.activityId = const Value.absent(),
|
|
this.actionId = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
});
|
|
ActivityActionsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required int activityId,
|
|
required int actionId,
|
|
this.createdAt = const Value.absent(),
|
|
}) : activityId = Value(activityId),
|
|
actionId = Value(actionId);
|
|
static Insertable<ActivityAction> custom({
|
|
Expression<int>? id,
|
|
Expression<int>? activityId,
|
|
Expression<int>? actionId,
|
|
Expression<DateTime>? createdAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (activityId != null) 'activity_id': activityId,
|
|
if (actionId != null) 'action_id': actionId,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
});
|
|
}
|
|
|
|
ActivityActionsCompanion copyWith(
|
|
{Value<int>? id,
|
|
Value<int>? activityId,
|
|
Value<int>? actionId,
|
|
Value<DateTime?>? createdAt}) {
|
|
return ActivityActionsCompanion(
|
|
id: id ?? this.id,
|
|
activityId: activityId ?? this.activityId,
|
|
actionId: actionId ?? this.actionId,
|
|
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 (activityId.present) {
|
|
map['activity_id'] = Variable<int>(activityId.value);
|
|
}
|
|
if (actionId.present) {
|
|
map['action_id'] = Variable<int>(actionId.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ActivityActionsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('activityId: $activityId, ')
|
|
..write('actionId: $actionId, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $MediaItemsTable extends MediaItems
|
|
with TableInfo<$MediaItemsTable, MediaItem> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$MediaItemsTable(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 _titleMeta = const VerificationMeta('title');
|
|
@override
|
|
late final GeneratedColumn<String> title = GeneratedColumn<String>(
|
|
'title', aliasedName, false,
|
|
additionalChecks:
|
|
GeneratedColumn.checkTextLength(minTextLength: 3, maxTextLength: 32),
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true);
|
|
static const VerificationMeta _descriptionMeta =
|
|
const VerificationMeta('description');
|
|
@override
|
|
late final GeneratedColumn<String> description = GeneratedColumn<String>(
|
|
'body', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
static const VerificationMeta _referenceMeta =
|
|
const VerificationMeta('reference');
|
|
@override
|
|
late final GeneratedColumn<String> reference = GeneratedColumn<String>(
|
|
'reference', aliasedName, false,
|
|
additionalChecks:
|
|
GeneratedColumn.checkTextLength(minTextLength: 3, maxTextLength: 32),
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true);
|
|
static const VerificationMeta _typeMeta = const VerificationMeta('type');
|
|
@override
|
|
late final GeneratedColumn<String> type = GeneratedColumn<String>(
|
|
'type', aliasedName, false,
|
|
additionalChecks:
|
|
GeneratedColumn.checkTextLength(minTextLength: 3, maxTextLength: 32),
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true);
|
|
static const VerificationMeta _createdAtMeta =
|
|
const VerificationMeta('createdAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at', aliasedName, true,
|
|
type: DriftSqlType.dateTime, requiredDuringInsert: false);
|
|
@override
|
|
List<GeneratedColumn> get $columns =>
|
|
[id, title, description, reference, type, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'media_items';
|
|
@override
|
|
VerificationContext validateIntegrity(Insertable<MediaItem> 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('title')) {
|
|
context.handle(
|
|
_titleMeta, title.isAcceptableOrUnknown(data['title']!, _titleMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_titleMeta);
|
|
}
|
|
if (data.containsKey('body')) {
|
|
context.handle(_descriptionMeta,
|
|
description.isAcceptableOrUnknown(data['body']!, _descriptionMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_descriptionMeta);
|
|
}
|
|
if (data.containsKey('reference')) {
|
|
context.handle(_referenceMeta,
|
|
reference.isAcceptableOrUnknown(data['reference']!, _referenceMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_referenceMeta);
|
|
}
|
|
if (data.containsKey('type')) {
|
|
context.handle(
|
|
_typeMeta, type.isAcceptableOrUnknown(data['type']!, _typeMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_typeMeta);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta));
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
MediaItem map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return MediaItem(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}id'])!,
|
|
title: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}title'])!,
|
|
description: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}body'])!,
|
|
reference: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}reference'])!,
|
|
type: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}type'])!,
|
|
createdAt: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}created_at']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$MediaItemsTable createAlias(String alias) {
|
|
return $MediaItemsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class MediaItem extends DataClass implements Insertable<MediaItem> {
|
|
final int id;
|
|
final String title;
|
|
final String description;
|
|
final String reference;
|
|
final String type;
|
|
final DateTime? createdAt;
|
|
const MediaItem(
|
|
{required this.id,
|
|
required this.title,
|
|
required this.description,
|
|
required this.reference,
|
|
required this.type,
|
|
this.createdAt});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['title'] = Variable<String>(title);
|
|
map['body'] = Variable<String>(description);
|
|
map['reference'] = Variable<String>(reference);
|
|
map['type'] = Variable<String>(type);
|
|
if (!nullToAbsent || createdAt != null) {
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
MediaItemsCompanion toCompanion(bool nullToAbsent) {
|
|
return MediaItemsCompanion(
|
|
id: Value(id),
|
|
title: Value(title),
|
|
description: Value(description),
|
|
reference: Value(reference),
|
|
type: Value(type),
|
|
createdAt: createdAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory MediaItem.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return MediaItem(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
title: serializer.fromJson<String>(json['title']),
|
|
description: serializer.fromJson<String>(json['description']),
|
|
reference: serializer.fromJson<String>(json['reference']),
|
|
type: serializer.fromJson<String>(json['type']),
|
|
createdAt: serializer.fromJson<DateTime?>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'title': serializer.toJson<String>(title),
|
|
'description': serializer.toJson<String>(description),
|
|
'reference': serializer.toJson<String>(reference),
|
|
'type': serializer.toJson<String>(type),
|
|
'createdAt': serializer.toJson<DateTime?>(createdAt),
|
|
};
|
|
}
|
|
|
|
MediaItem copyWith(
|
|
{int? id,
|
|
String? title,
|
|
String? description,
|
|
String? reference,
|
|
String? type,
|
|
Value<DateTime?> createdAt = const Value.absent()}) =>
|
|
MediaItem(
|
|
id: id ?? this.id,
|
|
title: title ?? this.title,
|
|
description: description ?? this.description,
|
|
reference: reference ?? this.reference,
|
|
type: type ?? this.type,
|
|
createdAt: createdAt.present ? createdAt.value : this.createdAt,
|
|
);
|
|
MediaItem copyWithCompanion(MediaItemsCompanion data) {
|
|
return MediaItem(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
title: data.title.present ? data.title.value : this.title,
|
|
description:
|
|
data.description.present ? data.description.value : this.description,
|
|
reference: data.reference.present ? data.reference.value : this.reference,
|
|
type: data.type.present ? data.type.value : this.type,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('MediaItem(')
|
|
..write('id: $id, ')
|
|
..write('title: $title, ')
|
|
..write('description: $description, ')
|
|
..write('reference: $reference, ')
|
|
..write('type: $type, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(id, title, description, reference, type, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is MediaItem &&
|
|
other.id == this.id &&
|
|
other.title == this.title &&
|
|
other.description == this.description &&
|
|
other.reference == this.reference &&
|
|
other.type == this.type &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class MediaItemsCompanion extends UpdateCompanion<MediaItem> {
|
|
final Value<int> id;
|
|
final Value<String> title;
|
|
final Value<String> description;
|
|
final Value<String> reference;
|
|
final Value<String> type;
|
|
final Value<DateTime?> createdAt;
|
|
const MediaItemsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.title = const Value.absent(),
|
|
this.description = const Value.absent(),
|
|
this.reference = const Value.absent(),
|
|
this.type = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
});
|
|
MediaItemsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String title,
|
|
required String description,
|
|
required String reference,
|
|
required String type,
|
|
this.createdAt = const Value.absent(),
|
|
}) : title = Value(title),
|
|
description = Value(description),
|
|
reference = Value(reference),
|
|
type = Value(type);
|
|
static Insertable<MediaItem> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? title,
|
|
Expression<String>? description,
|
|
Expression<String>? reference,
|
|
Expression<String>? type,
|
|
Expression<DateTime>? createdAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (title != null) 'title': title,
|
|
if (description != null) 'body': description,
|
|
if (reference != null) 'reference': reference,
|
|
if (type != null) 'type': type,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
});
|
|
}
|
|
|
|
MediaItemsCompanion copyWith(
|
|
{Value<int>? id,
|
|
Value<String>? title,
|
|
Value<String>? description,
|
|
Value<String>? reference,
|
|
Value<String>? type,
|
|
Value<DateTime?>? createdAt}) {
|
|
return MediaItemsCompanion(
|
|
id: id ?? this.id,
|
|
title: title ?? this.title,
|
|
description: description ?? this.description,
|
|
reference: reference ?? this.reference,
|
|
type: type ?? this.type,
|
|
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 (title.present) {
|
|
map['title'] = Variable<String>(title.value);
|
|
}
|
|
if (description.present) {
|
|
map['body'] = Variable<String>(description.value);
|
|
}
|
|
if (reference.present) {
|
|
map['reference'] = Variable<String>(reference.value);
|
|
}
|
|
if (type.present) {
|
|
map['type'] = Variable<String>(type.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('MediaItemsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('title: $title, ')
|
|
..write('description: $description, ')
|
|
..write('reference: $reference, ')
|
|
..write('type: $type, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ObjectMediaItemsTable extends ObjectMediaItems
|
|
with TableInfo<$ObjectMediaItemsTable, ObjectMediaItem> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ObjectMediaItemsTable(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 _objectIdMeta =
|
|
const VerificationMeta('objectId');
|
|
@override
|
|
late final GeneratedColumn<int> objectId = GeneratedColumn<int>(
|
|
'object_id', aliasedName, false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints:
|
|
GeneratedColumn.constraintIsAlways('REFERENCES actions (id)'));
|
|
static const VerificationMeta _mediaIdMeta =
|
|
const VerificationMeta('mediaId');
|
|
@override
|
|
late final GeneratedColumn<int> mediaId = GeneratedColumn<int>(
|
|
'media_id', aliasedName, false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints:
|
|
GeneratedColumn.constraintIsAlways('REFERENCES media_items (id)'));
|
|
static const VerificationMeta _createdAtMeta =
|
|
const VerificationMeta('createdAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at', aliasedName, true,
|
|
type: DriftSqlType.dateTime, requiredDuringInsert: false);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, objectId, mediaId, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'object_media_items';
|
|
@override
|
|
VerificationContext validateIntegrity(Insertable<ObjectMediaItem> 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('object_id')) {
|
|
context.handle(_objectIdMeta,
|
|
objectId.isAcceptableOrUnknown(data['object_id']!, _objectIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_objectIdMeta);
|
|
}
|
|
if (data.containsKey('media_id')) {
|
|
context.handle(_mediaIdMeta,
|
|
mediaId.isAcceptableOrUnknown(data['media_id']!, _mediaIdMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_mediaIdMeta);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta));
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
ObjectMediaItem map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ObjectMediaItem(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}id'])!,
|
|
objectId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}object_id'])!,
|
|
mediaId: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}media_id'])!,
|
|
createdAt: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}created_at']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ObjectMediaItemsTable createAlias(String alias) {
|
|
return $ObjectMediaItemsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class ObjectMediaItem extends DataClass implements Insertable<ObjectMediaItem> {
|
|
final int id;
|
|
final int objectId;
|
|
final int mediaId;
|
|
final DateTime? createdAt;
|
|
const ObjectMediaItem(
|
|
{required this.id,
|
|
required this.objectId,
|
|
required this.mediaId,
|
|
this.createdAt});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['object_id'] = Variable<int>(objectId);
|
|
map['media_id'] = Variable<int>(mediaId);
|
|
if (!nullToAbsent || createdAt != null) {
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
ObjectMediaItemsCompanion toCompanion(bool nullToAbsent) {
|
|
return ObjectMediaItemsCompanion(
|
|
id: Value(id),
|
|
objectId: Value(objectId),
|
|
mediaId: Value(mediaId),
|
|
createdAt: createdAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory ObjectMediaItem.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return ObjectMediaItem(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
objectId: serializer.fromJson<int>(json['objectId']),
|
|
mediaId: serializer.fromJson<int>(json['mediaId']),
|
|
createdAt: serializer.fromJson<DateTime?>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'objectId': serializer.toJson<int>(objectId),
|
|
'mediaId': serializer.toJson<int>(mediaId),
|
|
'createdAt': serializer.toJson<DateTime?>(createdAt),
|
|
};
|
|
}
|
|
|
|
ObjectMediaItem copyWith(
|
|
{int? id,
|
|
int? objectId,
|
|
int? mediaId,
|
|
Value<DateTime?> createdAt = const Value.absent()}) =>
|
|
ObjectMediaItem(
|
|
id: id ?? this.id,
|
|
objectId: objectId ?? this.objectId,
|
|
mediaId: mediaId ?? this.mediaId,
|
|
createdAt: createdAt.present ? createdAt.value : this.createdAt,
|
|
);
|
|
ObjectMediaItem copyWithCompanion(ObjectMediaItemsCompanion data) {
|
|
return ObjectMediaItem(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
objectId: data.objectId.present ? data.objectId.value : this.objectId,
|
|
mediaId: data.mediaId.present ? data.mediaId.value : this.mediaId,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ObjectMediaItem(')
|
|
..write('id: $id, ')
|
|
..write('objectId: $objectId, ')
|
|
..write('mediaId: $mediaId, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, objectId, mediaId, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is ObjectMediaItem &&
|
|
other.id == this.id &&
|
|
other.objectId == this.objectId &&
|
|
other.mediaId == this.mediaId &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class ObjectMediaItemsCompanion extends UpdateCompanion<ObjectMediaItem> {
|
|
final Value<int> id;
|
|
final Value<int> objectId;
|
|
final Value<int> mediaId;
|
|
final Value<DateTime?> createdAt;
|
|
const ObjectMediaItemsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.objectId = const Value.absent(),
|
|
this.mediaId = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
});
|
|
ObjectMediaItemsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required int objectId,
|
|
required int mediaId,
|
|
this.createdAt = const Value.absent(),
|
|
}) : objectId = Value(objectId),
|
|
mediaId = Value(mediaId);
|
|
static Insertable<ObjectMediaItem> custom({
|
|
Expression<int>? id,
|
|
Expression<int>? objectId,
|
|
Expression<int>? mediaId,
|
|
Expression<DateTime>? createdAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (objectId != null) 'object_id': objectId,
|
|
if (mediaId != null) 'media_id': mediaId,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
});
|
|
}
|
|
|
|
ObjectMediaItemsCompanion copyWith(
|
|
{Value<int>? id,
|
|
Value<int>? objectId,
|
|
Value<int>? mediaId,
|
|
Value<DateTime?>? createdAt}) {
|
|
return ObjectMediaItemsCompanion(
|
|
id: id ?? this.id,
|
|
objectId: objectId ?? this.objectId,
|
|
mediaId: mediaId ?? this.mediaId,
|
|
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 (objectId.present) {
|
|
map['object_id'] = Variable<int>(objectId.value);
|
|
}
|
|
if (mediaId.present) {
|
|
map['media_id'] = Variable<int>(mediaId.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ObjectMediaItemsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('objectId: $objectId, ')
|
|
..write('mediaId: $mediaId, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $SessionsTable sessions = $SessionsTable(this);
|
|
late final $ActivitiesTable activities = $ActivitiesTable(this);
|
|
late final $SessionActivitiesTable sessionActivities =
|
|
$SessionActivitiesTable(this);
|
|
late final $ActionsTable actions = $ActionsTable(this);
|
|
late final $ActivityActionsTable activityActions =
|
|
$ActivityActionsTable(this);
|
|
late final $MediaItemsTable mediaItems = $MediaItemsTable(this);
|
|
late final $ObjectMediaItemsTable objectMediaItems =
|
|
$ObjectMediaItemsTable(this);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
sessions,
|
|
activities,
|
|
sessionActivities,
|
|
actions,
|
|
activityActions,
|
|
mediaItems,
|
|
objectMediaItems
|
|
];
|
|
}
|
|
|
|
typedef $$SessionsTableCreateCompanionBuilder = SessionsCompanion Function({
|
|
Value<int> id,
|
|
required String title,
|
|
required String content,
|
|
Value<DateTime?> date,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
typedef $$SessionsTableUpdateCompanionBuilder = SessionsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> title,
|
|
Value<String> content,
|
|
Value<DateTime?> date,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
|
|
final class $$SessionsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $SessionsTable, Session> {
|
|
$$SessionsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$SessionActivitiesTable, List<SessionActivity>>
|
|
_sessionActivitiesRefsTable(_$AppDatabase db) =>
|
|
MultiTypedResultKey.fromTable(db.sessionActivities,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.sessions.id, db.sessionActivities.sessionId));
|
|
|
|
$$SessionActivitiesTableProcessedTableManager get sessionActivitiesRefs {
|
|
final manager =
|
|
$$SessionActivitiesTableTableManager($_db, $_db.sessionActivities)
|
|
.filter((f) => f.sessionId.id($_item.id));
|
|
|
|
final cache =
|
|
$_typedResult.readTableOrNull(_sessionActivitiesRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache));
|
|
}
|
|
}
|
|
|
|
class $$SessionsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $SessionsTable> {
|
|
$$SessionsTableFilterComposer({
|
|
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 title => $composableBuilder(
|
|
column: $table.title, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get content => $composableBuilder(
|
|
column: $table.content, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<DateTime> get date => $composableBuilder(
|
|
column: $table.date, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnFilters(column));
|
|
|
|
Expression<bool> sessionActivitiesRefs(
|
|
Expression<bool> Function($$SessionActivitiesTableFilterComposer f) f) {
|
|
final $$SessionActivitiesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.sessionActivities,
|
|
getReferencedColumn: (t) => t.sessionId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$SessionActivitiesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.sessionActivities,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$SessionsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $SessionsTable> {
|
|
$$SessionsTableOrderingComposer({
|
|
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 title => $composableBuilder(
|
|
column: $table.title, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get content => $composableBuilder(
|
|
column: $table.content, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<DateTime> get date => $composableBuilder(
|
|
column: $table.date, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnOrderings(column));
|
|
}
|
|
|
|
class $$SessionsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $SessionsTable> {
|
|
$$SessionsTableAnnotationComposer({
|
|
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 title =>
|
|
$composableBuilder(column: $table.title, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get content =>
|
|
$composableBuilder(column: $table.content, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get date =>
|
|
$composableBuilder(column: $table.date, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
Expression<T> sessionActivitiesRefs<T extends Object>(
|
|
Expression<T> Function($$SessionActivitiesTableAnnotationComposer a) f) {
|
|
final $$SessionActivitiesTableAnnotationComposer composer =
|
|
$composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.sessionActivities,
|
|
getReferencedColumn: (t) => t.sessionId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$SessionActivitiesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.sessionActivities,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$SessionsTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$SessionsTable,
|
|
Session,
|
|
$$SessionsTableFilterComposer,
|
|
$$SessionsTableOrderingComposer,
|
|
$$SessionsTableAnnotationComposer,
|
|
$$SessionsTableCreateCompanionBuilder,
|
|
$$SessionsTableUpdateCompanionBuilder,
|
|
(Session, $$SessionsTableReferences),
|
|
Session,
|
|
PrefetchHooks Function({bool sessionActivitiesRefs})> {
|
|
$$SessionsTableTableManager(_$AppDatabase db, $SessionsTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$SessionsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$SessionsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$SessionsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> title = const Value.absent(),
|
|
Value<String> content = const Value.absent(),
|
|
Value<DateTime?> date = const Value.absent(),
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
SessionsCompanion(
|
|
id: id,
|
|
title: title,
|
|
content: content,
|
|
date: date,
|
|
createdAt: createdAt,
|
|
),
|
|
createCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
required String title,
|
|
required String content,
|
|
Value<DateTime?> date = const Value.absent(),
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
SessionsCompanion.insert(
|
|
id: id,
|
|
title: title,
|
|
content: content,
|
|
date: date,
|
|
createdAt: createdAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) =>
|
|
(e.readTable(table), $$SessionsTableReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: ({sessionActivitiesRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (sessionActivitiesRefs) db.sessionActivities
|
|
],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (sessionActivitiesRefs)
|
|
await $_getPrefetchedData(
|
|
currentTable: table,
|
|
referencedTable: $$SessionsTableReferences
|
|
._sessionActivitiesRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$SessionsTableReferences(db, table, p0)
|
|
.sessionActivitiesRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems
|
|
.where((e) => e.sessionId == item.id),
|
|
typedResults: items)
|
|
];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $$SessionsTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$SessionsTable,
|
|
Session,
|
|
$$SessionsTableFilterComposer,
|
|
$$SessionsTableOrderingComposer,
|
|
$$SessionsTableAnnotationComposer,
|
|
$$SessionsTableCreateCompanionBuilder,
|
|
$$SessionsTableUpdateCompanionBuilder,
|
|
(Session, $$SessionsTableReferences),
|
|
Session,
|
|
PrefetchHooks Function({bool sessionActivitiesRefs})>;
|
|
typedef $$ActivitiesTableCreateCompanionBuilder = ActivitiesCompanion Function({
|
|
Value<int> id,
|
|
required String title,
|
|
required String type,
|
|
required String description,
|
|
required Categories categories,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
typedef $$ActivitiesTableUpdateCompanionBuilder = ActivitiesCompanion Function({
|
|
Value<int> id,
|
|
Value<String> title,
|
|
Value<String> type,
|
|
Value<String> description,
|
|
Value<Categories> categories,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
|
|
final class $$ActivitiesTableReferences
|
|
extends BaseReferences<_$AppDatabase, $ActivitiesTable, Activity> {
|
|
$$ActivitiesTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$SessionActivitiesTable, List<SessionActivity>>
|
|
_sessionActivitiesRefsTable(_$AppDatabase db) =>
|
|
MultiTypedResultKey.fromTable(db.sessionActivities,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.activities.id, db.sessionActivities.activityId));
|
|
|
|
$$SessionActivitiesTableProcessedTableManager get sessionActivitiesRefs {
|
|
final manager =
|
|
$$SessionActivitiesTableTableManager($_db, $_db.sessionActivities)
|
|
.filter((f) => f.activityId.id($_item.id));
|
|
|
|
final cache =
|
|
$_typedResult.readTableOrNull(_sessionActivitiesRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache));
|
|
}
|
|
|
|
static MultiTypedResultKey<$ActivityActionsTable, List<ActivityAction>>
|
|
_activityActionsRefsTable(_$AppDatabase db) =>
|
|
MultiTypedResultKey.fromTable(db.activityActions,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.activities.id, db.activityActions.activityId));
|
|
|
|
$$ActivityActionsTableProcessedTableManager get activityActionsRefs {
|
|
final manager =
|
|
$$ActivityActionsTableTableManager($_db, $_db.activityActions)
|
|
.filter((f) => f.activityId.id($_item.id));
|
|
|
|
final cache =
|
|
$_typedResult.readTableOrNull(_activityActionsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache));
|
|
}
|
|
}
|
|
|
|
class $$ActivitiesTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ActivitiesTable> {
|
|
$$ActivitiesTableFilterComposer({
|
|
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 title => $composableBuilder(
|
|
column: $table.title, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get type => $composableBuilder(
|
|
column: $table.type, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get description => $composableBuilder(
|
|
column: $table.description, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnWithTypeConverterFilters<Categories, Categories, String>
|
|
get categories => $composableBuilder(
|
|
column: $table.categories,
|
|
builder: (column) => ColumnWithTypeConverterFilters(column));
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnFilters(column));
|
|
|
|
Expression<bool> sessionActivitiesRefs(
|
|
Expression<bool> Function($$SessionActivitiesTableFilterComposer f) f) {
|
|
final $$SessionActivitiesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.sessionActivities,
|
|
getReferencedColumn: (t) => t.activityId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$SessionActivitiesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.sessionActivities,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<bool> activityActionsRefs(
|
|
Expression<bool> Function($$ActivityActionsTableFilterComposer f) f) {
|
|
final $$ActivityActionsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.activityActions,
|
|
getReferencedColumn: (t) => t.activityId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActivityActionsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.activityActions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$ActivitiesTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ActivitiesTable> {
|
|
$$ActivitiesTableOrderingComposer({
|
|
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 title => $composableBuilder(
|
|
column: $table.title, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get type => $composableBuilder(
|
|
column: $table.type, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get description => $composableBuilder(
|
|
column: $table.description, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get categories => $composableBuilder(
|
|
column: $table.categories, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnOrderings(column));
|
|
}
|
|
|
|
class $$ActivitiesTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ActivitiesTable> {
|
|
$$ActivitiesTableAnnotationComposer({
|
|
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 title =>
|
|
$composableBuilder(column: $table.title, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get type =>
|
|
$composableBuilder(column: $table.type, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get description => $composableBuilder(
|
|
column: $table.description, builder: (column) => column);
|
|
|
|
GeneratedColumnWithTypeConverter<Categories, String> get categories =>
|
|
$composableBuilder(
|
|
column: $table.categories, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
Expression<T> sessionActivitiesRefs<T extends Object>(
|
|
Expression<T> Function($$SessionActivitiesTableAnnotationComposer a) f) {
|
|
final $$SessionActivitiesTableAnnotationComposer composer =
|
|
$composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.sessionActivities,
|
|
getReferencedColumn: (t) => t.activityId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$SessionActivitiesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.sessionActivities,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<T> activityActionsRefs<T extends Object>(
|
|
Expression<T> Function($$ActivityActionsTableAnnotationComposer a) f) {
|
|
final $$ActivityActionsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.activityActions,
|
|
getReferencedColumn: (t) => t.activityId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActivityActionsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.activityActions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$ActivitiesTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$ActivitiesTable,
|
|
Activity,
|
|
$$ActivitiesTableFilterComposer,
|
|
$$ActivitiesTableOrderingComposer,
|
|
$$ActivitiesTableAnnotationComposer,
|
|
$$ActivitiesTableCreateCompanionBuilder,
|
|
$$ActivitiesTableUpdateCompanionBuilder,
|
|
(Activity, $$ActivitiesTableReferences),
|
|
Activity,
|
|
PrefetchHooks Function(
|
|
{bool sessionActivitiesRefs, bool activityActionsRefs})> {
|
|
$$ActivitiesTableTableManager(_$AppDatabase db, $ActivitiesTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ActivitiesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ActivitiesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ActivitiesTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> title = const Value.absent(),
|
|
Value<String> type = const Value.absent(),
|
|
Value<String> description = const Value.absent(),
|
|
Value<Categories> categories = const Value.absent(),
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
ActivitiesCompanion(
|
|
id: id,
|
|
title: title,
|
|
type: type,
|
|
description: description,
|
|
categories: categories,
|
|
createdAt: createdAt,
|
|
),
|
|
createCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
required String title,
|
|
required String type,
|
|
required String description,
|
|
required Categories categories,
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
ActivitiesCompanion.insert(
|
|
id: id,
|
|
title: title,
|
|
type: type,
|
|
description: description,
|
|
categories: categories,
|
|
createdAt: createdAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (
|
|
e.readTable(table),
|
|
$$ActivitiesTableReferences(db, table, e)
|
|
))
|
|
.toList(),
|
|
prefetchHooksCallback: (
|
|
{sessionActivitiesRefs = false, activityActionsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (sessionActivitiesRefs) db.sessionActivities,
|
|
if (activityActionsRefs) db.activityActions
|
|
],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (sessionActivitiesRefs)
|
|
await $_getPrefetchedData(
|
|
currentTable: table,
|
|
referencedTable: $$ActivitiesTableReferences
|
|
._sessionActivitiesRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$ActivitiesTableReferences(db, table, p0)
|
|
.sessionActivitiesRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems
|
|
.where((e) => e.activityId == item.id),
|
|
typedResults: items),
|
|
if (activityActionsRefs)
|
|
await $_getPrefetchedData(
|
|
currentTable: table,
|
|
referencedTable: $$ActivitiesTableReferences
|
|
._activityActionsRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$ActivitiesTableReferences(db, table, p0)
|
|
.activityActionsRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems
|
|
.where((e) => e.activityId == item.id),
|
|
typedResults: items)
|
|
];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $$ActivitiesTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ActivitiesTable,
|
|
Activity,
|
|
$$ActivitiesTableFilterComposer,
|
|
$$ActivitiesTableOrderingComposer,
|
|
$$ActivitiesTableAnnotationComposer,
|
|
$$ActivitiesTableCreateCompanionBuilder,
|
|
$$ActivitiesTableUpdateCompanionBuilder,
|
|
(Activity, $$ActivitiesTableReferences),
|
|
Activity,
|
|
PrefetchHooks Function(
|
|
{bool sessionActivitiesRefs, bool activityActionsRefs})>;
|
|
typedef $$SessionActivitiesTableCreateCompanionBuilder
|
|
= SessionActivitiesCompanion Function({
|
|
Value<int> id,
|
|
required int sessionId,
|
|
required int activityId,
|
|
required String results,
|
|
required String achievements,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
typedef $$SessionActivitiesTableUpdateCompanionBuilder
|
|
= SessionActivitiesCompanion Function({
|
|
Value<int> id,
|
|
Value<int> sessionId,
|
|
Value<int> activityId,
|
|
Value<String> results,
|
|
Value<String> achievements,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
|
|
final class $$SessionActivitiesTableReferences extends BaseReferences<
|
|
_$AppDatabase, $SessionActivitiesTable, SessionActivity> {
|
|
$$SessionActivitiesTableReferences(
|
|
super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $SessionsTable _sessionIdTable(_$AppDatabase db) =>
|
|
db.sessions.createAlias(
|
|
$_aliasNameGenerator(db.sessionActivities.sessionId, db.sessions.id));
|
|
|
|
$$SessionsTableProcessedTableManager get sessionId {
|
|
final manager = $$SessionsTableTableManager($_db, $_db.sessions)
|
|
.filter((f) => f.id($_item.sessionId!));
|
|
final item = $_typedResult.readTableOrNull(_sessionIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]));
|
|
}
|
|
|
|
static $ActivitiesTable _activityIdTable(_$AppDatabase db) =>
|
|
db.activities.createAlias($_aliasNameGenerator(
|
|
db.sessionActivities.activityId, db.activities.id));
|
|
|
|
$$ActivitiesTableProcessedTableManager get activityId {
|
|
final manager = $$ActivitiesTableTableManager($_db, $_db.activities)
|
|
.filter((f) => f.id($_item.activityId!));
|
|
final item = $_typedResult.readTableOrNull(_activityIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]));
|
|
}
|
|
}
|
|
|
|
class $$SessionActivitiesTableFilterComposer
|
|
extends Composer<_$AppDatabase, $SessionActivitiesTable> {
|
|
$$SessionActivitiesTableFilterComposer({
|
|
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 results => $composableBuilder(
|
|
column: $table.results, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get achievements => $composableBuilder(
|
|
column: $table.achievements, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnFilters(column));
|
|
|
|
$$SessionsTableFilterComposer get sessionId {
|
|
final $$SessionsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.sessionId,
|
|
referencedTable: $db.sessions,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$SessionsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.sessions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$ActivitiesTableFilterComposer get activityId {
|
|
final $$ActivitiesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.activityId,
|
|
referencedTable: $db.activities,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActivitiesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.activities,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$SessionActivitiesTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $SessionActivitiesTable> {
|
|
$$SessionActivitiesTableOrderingComposer({
|
|
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 results => $composableBuilder(
|
|
column: $table.results, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get achievements => $composableBuilder(
|
|
column: $table.achievements,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnOrderings(column));
|
|
|
|
$$SessionsTableOrderingComposer get sessionId {
|
|
final $$SessionsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.sessionId,
|
|
referencedTable: $db.sessions,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$SessionsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.sessions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$ActivitiesTableOrderingComposer get activityId {
|
|
final $$ActivitiesTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.activityId,
|
|
referencedTable: $db.activities,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActivitiesTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.activities,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$SessionActivitiesTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $SessionActivitiesTable> {
|
|
$$SessionActivitiesTableAnnotationComposer({
|
|
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 results =>
|
|
$composableBuilder(column: $table.results, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get achievements => $composableBuilder(
|
|
column: $table.achievements, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
$$SessionsTableAnnotationComposer get sessionId {
|
|
final $$SessionsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.sessionId,
|
|
referencedTable: $db.sessions,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$SessionsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.sessions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$ActivitiesTableAnnotationComposer get activityId {
|
|
final $$ActivitiesTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.activityId,
|
|
referencedTable: $db.activities,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActivitiesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.activities,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$SessionActivitiesTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$SessionActivitiesTable,
|
|
SessionActivity,
|
|
$$SessionActivitiesTableFilterComposer,
|
|
$$SessionActivitiesTableOrderingComposer,
|
|
$$SessionActivitiesTableAnnotationComposer,
|
|
$$SessionActivitiesTableCreateCompanionBuilder,
|
|
$$SessionActivitiesTableUpdateCompanionBuilder,
|
|
(SessionActivity, $$SessionActivitiesTableReferences),
|
|
SessionActivity,
|
|
PrefetchHooks Function({bool sessionId, bool activityId})> {
|
|
$$SessionActivitiesTableTableManager(
|
|
_$AppDatabase db, $SessionActivitiesTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$SessionActivitiesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$SessionActivitiesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$SessionActivitiesTableAnnotationComposer(
|
|
$db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
Value<int> sessionId = const Value.absent(),
|
|
Value<int> activityId = const Value.absent(),
|
|
Value<String> results = const Value.absent(),
|
|
Value<String> achievements = const Value.absent(),
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
SessionActivitiesCompanion(
|
|
id: id,
|
|
sessionId: sessionId,
|
|
activityId: activityId,
|
|
results: results,
|
|
achievements: achievements,
|
|
createdAt: createdAt,
|
|
),
|
|
createCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
required int sessionId,
|
|
required int activityId,
|
|
required String results,
|
|
required String achievements,
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
SessionActivitiesCompanion.insert(
|
|
id: id,
|
|
sessionId: sessionId,
|
|
activityId: activityId,
|
|
results: results,
|
|
achievements: achievements,
|
|
createdAt: createdAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (
|
|
e.readTable(table),
|
|
$$SessionActivitiesTableReferences(db, table, e)
|
|
))
|
|
.toList(),
|
|
prefetchHooksCallback: ({sessionId = false, activityId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins: <
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic>>(state) {
|
|
if (sessionId) {
|
|
state = state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.sessionId,
|
|
referencedTable:
|
|
$$SessionActivitiesTableReferences._sessionIdTable(db),
|
|
referencedColumn: $$SessionActivitiesTableReferences
|
|
._sessionIdTable(db)
|
|
.id,
|
|
) as T;
|
|
}
|
|
if (activityId) {
|
|
state = state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.activityId,
|
|
referencedTable:
|
|
$$SessionActivitiesTableReferences._activityIdTable(db),
|
|
referencedColumn: $$SessionActivitiesTableReferences
|
|
._activityIdTable(db)
|
|
.id,
|
|
) as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $$SessionActivitiesTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$SessionActivitiesTable,
|
|
SessionActivity,
|
|
$$SessionActivitiesTableFilterComposer,
|
|
$$SessionActivitiesTableOrderingComposer,
|
|
$$SessionActivitiesTableAnnotationComposer,
|
|
$$SessionActivitiesTableCreateCompanionBuilder,
|
|
$$SessionActivitiesTableUpdateCompanionBuilder,
|
|
(SessionActivity, $$SessionActivitiesTableReferences),
|
|
SessionActivity,
|
|
PrefetchHooks Function({bool sessionId, bool activityId})>;
|
|
typedef $$ActionsTableCreateCompanionBuilder = ActionsCompanion Function({
|
|
Value<int> id,
|
|
required String title,
|
|
required String description,
|
|
required String set,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
typedef $$ActionsTableUpdateCompanionBuilder = ActionsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> title,
|
|
Value<String> description,
|
|
Value<String> set,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
|
|
final class $$ActionsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $ActionsTable, Action> {
|
|
$$ActionsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$ActivityActionsTable, List<ActivityAction>>
|
|
_activityActionsRefsTable(_$AppDatabase db) =>
|
|
MultiTypedResultKey.fromTable(db.activityActions,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.actions.id, db.activityActions.actionId));
|
|
|
|
$$ActivityActionsTableProcessedTableManager get activityActionsRefs {
|
|
final manager =
|
|
$$ActivityActionsTableTableManager($_db, $_db.activityActions)
|
|
.filter((f) => f.actionId.id($_item.id));
|
|
|
|
final cache =
|
|
$_typedResult.readTableOrNull(_activityActionsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache));
|
|
}
|
|
|
|
static MultiTypedResultKey<$ObjectMediaItemsTable, List<ObjectMediaItem>>
|
|
_objectMediaItemsRefsTable(_$AppDatabase db) =>
|
|
MultiTypedResultKey.fromTable(db.objectMediaItems,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.actions.id, db.objectMediaItems.objectId));
|
|
|
|
$$ObjectMediaItemsTableProcessedTableManager get objectMediaItemsRefs {
|
|
final manager =
|
|
$$ObjectMediaItemsTableTableManager($_db, $_db.objectMediaItems)
|
|
.filter((f) => f.objectId.id($_item.id));
|
|
|
|
final cache =
|
|
$_typedResult.readTableOrNull(_objectMediaItemsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache));
|
|
}
|
|
}
|
|
|
|
class $$ActionsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ActionsTable> {
|
|
$$ActionsTableFilterComposer({
|
|
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 title => $composableBuilder(
|
|
column: $table.title, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get description => $composableBuilder(
|
|
column: $table.description, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get set => $composableBuilder(
|
|
column: $table.set, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnFilters(column));
|
|
|
|
Expression<bool> activityActionsRefs(
|
|
Expression<bool> Function($$ActivityActionsTableFilterComposer f) f) {
|
|
final $$ActivityActionsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.activityActions,
|
|
getReferencedColumn: (t) => t.actionId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActivityActionsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.activityActions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<bool> objectMediaItemsRefs(
|
|
Expression<bool> Function($$ObjectMediaItemsTableFilterComposer f) f) {
|
|
final $$ObjectMediaItemsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.objectMediaItems,
|
|
getReferencedColumn: (t) => t.objectId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ObjectMediaItemsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.objectMediaItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$ActionsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ActionsTable> {
|
|
$$ActionsTableOrderingComposer({
|
|
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 title => $composableBuilder(
|
|
column: $table.title, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get description => $composableBuilder(
|
|
column: $table.description, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get set => $composableBuilder(
|
|
column: $table.set, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnOrderings(column));
|
|
}
|
|
|
|
class $$ActionsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ActionsTable> {
|
|
$$ActionsTableAnnotationComposer({
|
|
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 title =>
|
|
$composableBuilder(column: $table.title, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get description => $composableBuilder(
|
|
column: $table.description, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get set =>
|
|
$composableBuilder(column: $table.set, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
Expression<T> activityActionsRefs<T extends Object>(
|
|
Expression<T> Function($$ActivityActionsTableAnnotationComposer a) f) {
|
|
final $$ActivityActionsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.activityActions,
|
|
getReferencedColumn: (t) => t.actionId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActivityActionsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.activityActions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
|
|
Expression<T> objectMediaItemsRefs<T extends Object>(
|
|
Expression<T> Function($$ObjectMediaItemsTableAnnotationComposer a) f) {
|
|
final $$ObjectMediaItemsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.objectMediaItems,
|
|
getReferencedColumn: (t) => t.objectId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ObjectMediaItemsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.objectMediaItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$ActionsTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$ActionsTable,
|
|
Action,
|
|
$$ActionsTableFilterComposer,
|
|
$$ActionsTableOrderingComposer,
|
|
$$ActionsTableAnnotationComposer,
|
|
$$ActionsTableCreateCompanionBuilder,
|
|
$$ActionsTableUpdateCompanionBuilder,
|
|
(Action, $$ActionsTableReferences),
|
|
Action,
|
|
PrefetchHooks Function(
|
|
{bool activityActionsRefs, bool objectMediaItemsRefs})> {
|
|
$$ActionsTableTableManager(_$AppDatabase db, $ActionsTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ActionsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ActionsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ActionsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> title = const Value.absent(),
|
|
Value<String> description = const Value.absent(),
|
|
Value<String> set = const Value.absent(),
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
ActionsCompanion(
|
|
id: id,
|
|
title: title,
|
|
description: description,
|
|
set: set,
|
|
createdAt: createdAt,
|
|
),
|
|
createCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
required String title,
|
|
required String description,
|
|
required String set,
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
ActionsCompanion.insert(
|
|
id: id,
|
|
title: title,
|
|
description: description,
|
|
set: set,
|
|
createdAt: createdAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) =>
|
|
(e.readTable(table), $$ActionsTableReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: (
|
|
{activityActionsRefs = false, objectMediaItemsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (activityActionsRefs) db.activityActions,
|
|
if (objectMediaItemsRefs) db.objectMediaItems
|
|
],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (activityActionsRefs)
|
|
await $_getPrefetchedData(
|
|
currentTable: table,
|
|
referencedTable: $$ActionsTableReferences
|
|
._activityActionsRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$ActionsTableReferences(db, table, p0)
|
|
.activityActionsRefs,
|
|
referencedItemsForCurrentItem: (item,
|
|
referencedItems) =>
|
|
referencedItems.where((e) => e.actionId == item.id),
|
|
typedResults: items),
|
|
if (objectMediaItemsRefs)
|
|
await $_getPrefetchedData(
|
|
currentTable: table,
|
|
referencedTable: $$ActionsTableReferences
|
|
._objectMediaItemsRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$ActionsTableReferences(db, table, p0)
|
|
.objectMediaItemsRefs,
|
|
referencedItemsForCurrentItem: (item,
|
|
referencedItems) =>
|
|
referencedItems.where((e) => e.objectId == item.id),
|
|
typedResults: items)
|
|
];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $$ActionsTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ActionsTable,
|
|
Action,
|
|
$$ActionsTableFilterComposer,
|
|
$$ActionsTableOrderingComposer,
|
|
$$ActionsTableAnnotationComposer,
|
|
$$ActionsTableCreateCompanionBuilder,
|
|
$$ActionsTableUpdateCompanionBuilder,
|
|
(Action, $$ActionsTableReferences),
|
|
Action,
|
|
PrefetchHooks Function(
|
|
{bool activityActionsRefs, bool objectMediaItemsRefs})>;
|
|
typedef $$ActivityActionsTableCreateCompanionBuilder = ActivityActionsCompanion
|
|
Function({
|
|
Value<int> id,
|
|
required int activityId,
|
|
required int actionId,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
typedef $$ActivityActionsTableUpdateCompanionBuilder = ActivityActionsCompanion
|
|
Function({
|
|
Value<int> id,
|
|
Value<int> activityId,
|
|
Value<int> actionId,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
|
|
final class $$ActivityActionsTableReferences extends BaseReferences<
|
|
_$AppDatabase, $ActivityActionsTable, ActivityAction> {
|
|
$$ActivityActionsTableReferences(
|
|
super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $ActivitiesTable _activityIdTable(_$AppDatabase db) =>
|
|
db.activities.createAlias($_aliasNameGenerator(
|
|
db.activityActions.activityId, db.activities.id));
|
|
|
|
$$ActivitiesTableProcessedTableManager get activityId {
|
|
final manager = $$ActivitiesTableTableManager($_db, $_db.activities)
|
|
.filter((f) => f.id($_item.activityId!));
|
|
final item = $_typedResult.readTableOrNull(_activityIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]));
|
|
}
|
|
|
|
static $ActionsTable _actionIdTable(_$AppDatabase db) =>
|
|
db.actions.createAlias(
|
|
$_aliasNameGenerator(db.activityActions.actionId, db.actions.id));
|
|
|
|
$$ActionsTableProcessedTableManager get actionId {
|
|
final manager = $$ActionsTableTableManager($_db, $_db.actions)
|
|
.filter((f) => f.id($_item.actionId!));
|
|
final item = $_typedResult.readTableOrNull(_actionIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]));
|
|
}
|
|
}
|
|
|
|
class $$ActivityActionsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ActivityActionsTable> {
|
|
$$ActivityActionsTableFilterComposer({
|
|
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 createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnFilters(column));
|
|
|
|
$$ActivitiesTableFilterComposer get activityId {
|
|
final $$ActivitiesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.activityId,
|
|
referencedTable: $db.activities,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActivitiesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.activities,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$ActionsTableFilterComposer get actionId {
|
|
final $$ActionsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.actionId,
|
|
referencedTable: $db.actions,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActionsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.actions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$ActivityActionsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ActivityActionsTable> {
|
|
$$ActivityActionsTableOrderingComposer({
|
|
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 createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnOrderings(column));
|
|
|
|
$$ActivitiesTableOrderingComposer get activityId {
|
|
final $$ActivitiesTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.activityId,
|
|
referencedTable: $db.activities,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActivitiesTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.activities,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$ActionsTableOrderingComposer get actionId {
|
|
final $$ActionsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.actionId,
|
|
referencedTable: $db.actions,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActionsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.actions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$ActivityActionsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ActivityActionsTable> {
|
|
$$ActivityActionsTableAnnotationComposer({
|
|
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 createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
$$ActivitiesTableAnnotationComposer get activityId {
|
|
final $$ActivitiesTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.activityId,
|
|
referencedTable: $db.activities,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActivitiesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.activities,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$ActionsTableAnnotationComposer get actionId {
|
|
final $$ActionsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.actionId,
|
|
referencedTable: $db.actions,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActionsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.actions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$ActivityActionsTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$ActivityActionsTable,
|
|
ActivityAction,
|
|
$$ActivityActionsTableFilterComposer,
|
|
$$ActivityActionsTableOrderingComposer,
|
|
$$ActivityActionsTableAnnotationComposer,
|
|
$$ActivityActionsTableCreateCompanionBuilder,
|
|
$$ActivityActionsTableUpdateCompanionBuilder,
|
|
(ActivityAction, $$ActivityActionsTableReferences),
|
|
ActivityAction,
|
|
PrefetchHooks Function({bool activityId, bool actionId})> {
|
|
$$ActivityActionsTableTableManager(
|
|
_$AppDatabase db, $ActivityActionsTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ActivityActionsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ActivityActionsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ActivityActionsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
Value<int> activityId = const Value.absent(),
|
|
Value<int> actionId = const Value.absent(),
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
ActivityActionsCompanion(
|
|
id: id,
|
|
activityId: activityId,
|
|
actionId: actionId,
|
|
createdAt: createdAt,
|
|
),
|
|
createCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
required int activityId,
|
|
required int actionId,
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
ActivityActionsCompanion.insert(
|
|
id: id,
|
|
activityId: activityId,
|
|
actionId: actionId,
|
|
createdAt: createdAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (
|
|
e.readTable(table),
|
|
$$ActivityActionsTableReferences(db, table, e)
|
|
))
|
|
.toList(),
|
|
prefetchHooksCallback: ({activityId = false, actionId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins: <
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic>>(state) {
|
|
if (activityId) {
|
|
state = state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.activityId,
|
|
referencedTable:
|
|
$$ActivityActionsTableReferences._activityIdTable(db),
|
|
referencedColumn: $$ActivityActionsTableReferences
|
|
._activityIdTable(db)
|
|
.id,
|
|
) as T;
|
|
}
|
|
if (actionId) {
|
|
state = state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.actionId,
|
|
referencedTable:
|
|
$$ActivityActionsTableReferences._actionIdTable(db),
|
|
referencedColumn:
|
|
$$ActivityActionsTableReferences._actionIdTable(db).id,
|
|
) as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $$ActivityActionsTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ActivityActionsTable,
|
|
ActivityAction,
|
|
$$ActivityActionsTableFilterComposer,
|
|
$$ActivityActionsTableOrderingComposer,
|
|
$$ActivityActionsTableAnnotationComposer,
|
|
$$ActivityActionsTableCreateCompanionBuilder,
|
|
$$ActivityActionsTableUpdateCompanionBuilder,
|
|
(ActivityAction, $$ActivityActionsTableReferences),
|
|
ActivityAction,
|
|
PrefetchHooks Function({bool activityId, bool actionId})>;
|
|
typedef $$MediaItemsTableCreateCompanionBuilder = MediaItemsCompanion Function({
|
|
Value<int> id,
|
|
required String title,
|
|
required String description,
|
|
required String reference,
|
|
required String type,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
typedef $$MediaItemsTableUpdateCompanionBuilder = MediaItemsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> title,
|
|
Value<String> description,
|
|
Value<String> reference,
|
|
Value<String> type,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
|
|
final class $$MediaItemsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $MediaItemsTable, MediaItem> {
|
|
$$MediaItemsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$ObjectMediaItemsTable, List<ObjectMediaItem>>
|
|
_objectMediaItemsRefsTable(_$AppDatabase db) =>
|
|
MultiTypedResultKey.fromTable(db.objectMediaItems,
|
|
aliasName: $_aliasNameGenerator(
|
|
db.mediaItems.id, db.objectMediaItems.mediaId));
|
|
|
|
$$ObjectMediaItemsTableProcessedTableManager get objectMediaItemsRefs {
|
|
final manager =
|
|
$$ObjectMediaItemsTableTableManager($_db, $_db.objectMediaItems)
|
|
.filter((f) => f.mediaId.id($_item.id));
|
|
|
|
final cache =
|
|
$_typedResult.readTableOrNull(_objectMediaItemsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache));
|
|
}
|
|
}
|
|
|
|
class $$MediaItemsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $MediaItemsTable> {
|
|
$$MediaItemsTableFilterComposer({
|
|
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 title => $composableBuilder(
|
|
column: $table.title, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get description => $composableBuilder(
|
|
column: $table.description, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get reference => $composableBuilder(
|
|
column: $table.reference, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get type => $composableBuilder(
|
|
column: $table.type, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnFilters(column));
|
|
|
|
Expression<bool> objectMediaItemsRefs(
|
|
Expression<bool> Function($$ObjectMediaItemsTableFilterComposer f) f) {
|
|
final $$ObjectMediaItemsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.objectMediaItems,
|
|
getReferencedColumn: (t) => t.mediaId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ObjectMediaItemsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.objectMediaItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$MediaItemsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $MediaItemsTable> {
|
|
$$MediaItemsTableOrderingComposer({
|
|
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 title => $composableBuilder(
|
|
column: $table.title, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get description => $composableBuilder(
|
|
column: $table.description, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get reference => $composableBuilder(
|
|
column: $table.reference, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get type => $composableBuilder(
|
|
column: $table.type, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnOrderings(column));
|
|
}
|
|
|
|
class $$MediaItemsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $MediaItemsTable> {
|
|
$$MediaItemsTableAnnotationComposer({
|
|
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 title =>
|
|
$composableBuilder(column: $table.title, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get description => $composableBuilder(
|
|
column: $table.description, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get reference =>
|
|
$composableBuilder(column: $table.reference, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get type =>
|
|
$composableBuilder(column: $table.type, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
Expression<T> objectMediaItemsRefs<T extends Object>(
|
|
Expression<T> Function($$ObjectMediaItemsTableAnnotationComposer a) f) {
|
|
final $$ObjectMediaItemsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.objectMediaItems,
|
|
getReferencedColumn: (t) => t.mediaId,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ObjectMediaItemsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.objectMediaItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$MediaItemsTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$MediaItemsTable,
|
|
MediaItem,
|
|
$$MediaItemsTableFilterComposer,
|
|
$$MediaItemsTableOrderingComposer,
|
|
$$MediaItemsTableAnnotationComposer,
|
|
$$MediaItemsTableCreateCompanionBuilder,
|
|
$$MediaItemsTableUpdateCompanionBuilder,
|
|
(MediaItem, $$MediaItemsTableReferences),
|
|
MediaItem,
|
|
PrefetchHooks Function({bool objectMediaItemsRefs})> {
|
|
$$MediaItemsTableTableManager(_$AppDatabase db, $MediaItemsTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$MediaItemsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$MediaItemsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$MediaItemsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> title = const Value.absent(),
|
|
Value<String> description = const Value.absent(),
|
|
Value<String> reference = const Value.absent(),
|
|
Value<String> type = const Value.absent(),
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
MediaItemsCompanion(
|
|
id: id,
|
|
title: title,
|
|
description: description,
|
|
reference: reference,
|
|
type: type,
|
|
createdAt: createdAt,
|
|
),
|
|
createCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
required String title,
|
|
required String description,
|
|
required String reference,
|
|
required String type,
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
MediaItemsCompanion.insert(
|
|
id: id,
|
|
title: title,
|
|
description: description,
|
|
reference: reference,
|
|
type: type,
|
|
createdAt: createdAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (
|
|
e.readTable(table),
|
|
$$MediaItemsTableReferences(db, table, e)
|
|
))
|
|
.toList(),
|
|
prefetchHooksCallback: ({objectMediaItemsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (objectMediaItemsRefs) db.objectMediaItems
|
|
],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (objectMediaItemsRefs)
|
|
await $_getPrefetchedData(
|
|
currentTable: table,
|
|
referencedTable: $$MediaItemsTableReferences
|
|
._objectMediaItemsRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$MediaItemsTableReferences(db, table, p0)
|
|
.objectMediaItemsRefs,
|
|
referencedItemsForCurrentItem: (item,
|
|
referencedItems) =>
|
|
referencedItems.where((e) => e.mediaId == item.id),
|
|
typedResults: items)
|
|
];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $$MediaItemsTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$MediaItemsTable,
|
|
MediaItem,
|
|
$$MediaItemsTableFilterComposer,
|
|
$$MediaItemsTableOrderingComposer,
|
|
$$MediaItemsTableAnnotationComposer,
|
|
$$MediaItemsTableCreateCompanionBuilder,
|
|
$$MediaItemsTableUpdateCompanionBuilder,
|
|
(MediaItem, $$MediaItemsTableReferences),
|
|
MediaItem,
|
|
PrefetchHooks Function({bool objectMediaItemsRefs})>;
|
|
typedef $$ObjectMediaItemsTableCreateCompanionBuilder
|
|
= ObjectMediaItemsCompanion Function({
|
|
Value<int> id,
|
|
required int objectId,
|
|
required int mediaId,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
typedef $$ObjectMediaItemsTableUpdateCompanionBuilder
|
|
= ObjectMediaItemsCompanion Function({
|
|
Value<int> id,
|
|
Value<int> objectId,
|
|
Value<int> mediaId,
|
|
Value<DateTime?> createdAt,
|
|
});
|
|
|
|
final class $$ObjectMediaItemsTableReferences extends BaseReferences<
|
|
_$AppDatabase, $ObjectMediaItemsTable, ObjectMediaItem> {
|
|
$$ObjectMediaItemsTableReferences(
|
|
super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $ActionsTable _objectIdTable(_$AppDatabase db) =>
|
|
db.actions.createAlias(
|
|
$_aliasNameGenerator(db.objectMediaItems.objectId, db.actions.id));
|
|
|
|
$$ActionsTableProcessedTableManager get objectId {
|
|
final manager = $$ActionsTableTableManager($_db, $_db.actions)
|
|
.filter((f) => f.id($_item.objectId!));
|
|
final item = $_typedResult.readTableOrNull(_objectIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]));
|
|
}
|
|
|
|
static $MediaItemsTable _mediaIdTable(_$AppDatabase db) =>
|
|
db.mediaItems.createAlias(
|
|
$_aliasNameGenerator(db.objectMediaItems.mediaId, db.mediaItems.id));
|
|
|
|
$$MediaItemsTableProcessedTableManager get mediaId {
|
|
final manager = $$MediaItemsTableTableManager($_db, $_db.mediaItems)
|
|
.filter((f) => f.id($_item.mediaId!));
|
|
final item = $_typedResult.readTableOrNull(_mediaIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]));
|
|
}
|
|
}
|
|
|
|
class $$ObjectMediaItemsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ObjectMediaItemsTable> {
|
|
$$ObjectMediaItemsTableFilterComposer({
|
|
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 createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnFilters(column));
|
|
|
|
$$ActionsTableFilterComposer get objectId {
|
|
final $$ActionsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.objectId,
|
|
referencedTable: $db.actions,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActionsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.actions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$MediaItemsTableFilterComposer get mediaId {
|
|
final $$MediaItemsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.mediaId,
|
|
referencedTable: $db.mediaItems,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$MediaItemsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.mediaItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$ObjectMediaItemsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ObjectMediaItemsTable> {
|
|
$$ObjectMediaItemsTableOrderingComposer({
|
|
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 createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnOrderings(column));
|
|
|
|
$$ActionsTableOrderingComposer get objectId {
|
|
final $$ActionsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.objectId,
|
|
referencedTable: $db.actions,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActionsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.actions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$MediaItemsTableOrderingComposer get mediaId {
|
|
final $$MediaItemsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.mediaId,
|
|
referencedTable: $db.mediaItems,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$MediaItemsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.mediaItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$ObjectMediaItemsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ObjectMediaItemsTable> {
|
|
$$ObjectMediaItemsTableAnnotationComposer({
|
|
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 createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
$$ActionsTableAnnotationComposer get objectId {
|
|
final $$ActionsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.objectId,
|
|
referencedTable: $db.actions,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$ActionsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.actions,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
|
|
$$MediaItemsTableAnnotationComposer get mediaId {
|
|
final $$MediaItemsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.mediaId,
|
|
referencedTable: $db.mediaItems,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder: (joinBuilder,
|
|
{$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer}) =>
|
|
$$MediaItemsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.mediaItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
));
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$ObjectMediaItemsTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$ObjectMediaItemsTable,
|
|
ObjectMediaItem,
|
|
$$ObjectMediaItemsTableFilterComposer,
|
|
$$ObjectMediaItemsTableOrderingComposer,
|
|
$$ObjectMediaItemsTableAnnotationComposer,
|
|
$$ObjectMediaItemsTableCreateCompanionBuilder,
|
|
$$ObjectMediaItemsTableUpdateCompanionBuilder,
|
|
(ObjectMediaItem, $$ObjectMediaItemsTableReferences),
|
|
ObjectMediaItem,
|
|
PrefetchHooks Function({bool objectId, bool mediaId})> {
|
|
$$ObjectMediaItemsTableTableManager(
|
|
_$AppDatabase db, $ObjectMediaItemsTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ObjectMediaItemsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ObjectMediaItemsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ObjectMediaItemsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
Value<int> objectId = const Value.absent(),
|
|
Value<int> mediaId = const Value.absent(),
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
ObjectMediaItemsCompanion(
|
|
id: id,
|
|
objectId: objectId,
|
|
mediaId: mediaId,
|
|
createdAt: createdAt,
|
|
),
|
|
createCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
required int objectId,
|
|
required int mediaId,
|
|
Value<DateTime?> createdAt = const Value.absent(),
|
|
}) =>
|
|
ObjectMediaItemsCompanion.insert(
|
|
id: id,
|
|
objectId: objectId,
|
|
mediaId: mediaId,
|
|
createdAt: createdAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (
|
|
e.readTable(table),
|
|
$$ObjectMediaItemsTableReferences(db, table, e)
|
|
))
|
|
.toList(),
|
|
prefetchHooksCallback: ({objectId = false, mediaId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins: <
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic>>(state) {
|
|
if (objectId) {
|
|
state = state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.objectId,
|
|
referencedTable:
|
|
$$ObjectMediaItemsTableReferences._objectIdTable(db),
|
|
referencedColumn:
|
|
$$ObjectMediaItemsTableReferences._objectIdTable(db).id,
|
|
) as T;
|
|
}
|
|
if (mediaId) {
|
|
state = state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.mediaId,
|
|
referencedTable:
|
|
$$ObjectMediaItemsTableReferences._mediaIdTable(db),
|
|
referencedColumn:
|
|
$$ObjectMediaItemsTableReferences._mediaIdTable(db).id,
|
|
) as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
));
|
|
}
|
|
|
|
typedef $$ObjectMediaItemsTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ObjectMediaItemsTable,
|
|
ObjectMediaItem,
|
|
$$ObjectMediaItemsTableFilterComposer,
|
|
$$ObjectMediaItemsTableOrderingComposer,
|
|
$$ObjectMediaItemsTableAnnotationComposer,
|
|
$$ObjectMediaItemsTableCreateCompanionBuilder,
|
|
$$ObjectMediaItemsTableUpdateCompanionBuilder,
|
|
(ObjectMediaItem, $$ObjectMediaItemsTableReferences),
|
|
ObjectMediaItem,
|
|
PrefetchHooks Function({bool objectId, bool mediaId})>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$SessionsTableTableManager get sessions =>
|
|
$$SessionsTableTableManager(_db, _db.sessions);
|
|
$$ActivitiesTableTableManager get activities =>
|
|
$$ActivitiesTableTableManager(_db, _db.activities);
|
|
$$SessionActivitiesTableTableManager get sessionActivities =>
|
|
$$SessionActivitiesTableTableManager(_db, _db.sessionActivities);
|
|
$$ActionsTableTableManager get actions =>
|
|
$$ActionsTableTableManager(_db, _db.actions);
|
|
$$ActivityActionsTableTableManager get activityActions =>
|
|
$$ActivityActionsTableTableManager(_db, _db.activityActions);
|
|
$$MediaItemsTableTableManager get mediaItems =>
|
|
$$MediaItemsTableTableManager(_db, _db.mediaItems);
|
|
$$ObjectMediaItemsTableTableManager get objectMediaItems =>
|
|
$$ObjectMediaItemsTableTableManager(_db, _db.objectMediaItems);
|
|
}
|