1658 lines
53 KiB
Dart
1658 lines
53 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'local_db_service.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $MessagesTable extends Messages with TableInfo<$MessagesTable, Message> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$MessagesTable(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 _senderIdMeta = const VerificationMeta(
|
|
'senderId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> senderId = GeneratedColumn<int>(
|
|
'sender_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _receiverIdMeta = const VerificationMeta(
|
|
'receiverId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> receiverId = GeneratedColumn<int>(
|
|
'receiver_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _contentMeta = const VerificationMeta(
|
|
'content',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> content = GeneratedColumn<String>(
|
|
'content',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _timestampMeta = const VerificationMeta(
|
|
'timestamp',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> timestamp = GeneratedColumn<String>(
|
|
'timestamp',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _deliveredAtMeta = const VerificationMeta(
|
|
'deliveredAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> deliveredAt = GeneratedColumn<String>(
|
|
'delivered_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _readAtMeta = const VerificationMeta('readAt');
|
|
@override
|
|
late final GeneratedColumn<String> readAt = GeneratedColumn<String>(
|
|
'read_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _replyToIdMeta = const VerificationMeta(
|
|
'replyToId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> replyToId = GeneratedColumn<int>(
|
|
'reply_to_id',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _replyToTextMeta = const VerificationMeta(
|
|
'replyToText',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> replyToText = GeneratedColumn<String>(
|
|
'reply_to_text',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _editedAtMeta = const VerificationMeta(
|
|
'editedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> editedAt = GeneratedColumn<String>(
|
|
'edited_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _messageTypeMeta = const VerificationMeta(
|
|
'messageType',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> messageType = GeneratedColumn<String>(
|
|
'message_type',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant('text'),
|
|
);
|
|
static const VerificationMeta _fileIdMeta = const VerificationMeta('fileId');
|
|
@override
|
|
late final GeneratedColumn<String> fileId = GeneratedColumn<String>(
|
|
'file_id',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _encryptedKeyMeta = const VerificationMeta(
|
|
'encryptedKey',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> encryptedKey = GeneratedColumn<String>(
|
|
'encrypted_key',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _fileNameMeta = const VerificationMeta(
|
|
'fileName',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> fileName = GeneratedColumn<String>(
|
|
'file_name',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _fileSizeMeta = const VerificationMeta(
|
|
'fileSize',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> fileSize = GeneratedColumn<int>(
|
|
'file_size',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
senderId,
|
|
receiverId,
|
|
content,
|
|
timestamp,
|
|
deliveredAt,
|
|
readAt,
|
|
replyToId,
|
|
replyToText,
|
|
editedAt,
|
|
messageType,
|
|
fileId,
|
|
encryptedKey,
|
|
fileName,
|
|
fileSize,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'messages';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Message> 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('sender_id')) {
|
|
context.handle(
|
|
_senderIdMeta,
|
|
senderId.isAcceptableOrUnknown(data['sender_id']!, _senderIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_senderIdMeta);
|
|
}
|
|
if (data.containsKey('receiver_id')) {
|
|
context.handle(
|
|
_receiverIdMeta,
|
|
receiverId.isAcceptableOrUnknown(data['receiver_id']!, _receiverIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_receiverIdMeta);
|
|
}
|
|
if (data.containsKey('content')) {
|
|
context.handle(
|
|
_contentMeta,
|
|
content.isAcceptableOrUnknown(data['content']!, _contentMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_contentMeta);
|
|
}
|
|
if (data.containsKey('timestamp')) {
|
|
context.handle(
|
|
_timestampMeta,
|
|
timestamp.isAcceptableOrUnknown(data['timestamp']!, _timestampMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_timestampMeta);
|
|
}
|
|
if (data.containsKey('delivered_at')) {
|
|
context.handle(
|
|
_deliveredAtMeta,
|
|
deliveredAt.isAcceptableOrUnknown(
|
|
data['delivered_at']!,
|
|
_deliveredAtMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('read_at')) {
|
|
context.handle(
|
|
_readAtMeta,
|
|
readAt.isAcceptableOrUnknown(data['read_at']!, _readAtMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('reply_to_id')) {
|
|
context.handle(
|
|
_replyToIdMeta,
|
|
replyToId.isAcceptableOrUnknown(data['reply_to_id']!, _replyToIdMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('reply_to_text')) {
|
|
context.handle(
|
|
_replyToTextMeta,
|
|
replyToText.isAcceptableOrUnknown(
|
|
data['reply_to_text']!,
|
|
_replyToTextMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('edited_at')) {
|
|
context.handle(
|
|
_editedAtMeta,
|
|
editedAt.isAcceptableOrUnknown(data['edited_at']!, _editedAtMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('message_type')) {
|
|
context.handle(
|
|
_messageTypeMeta,
|
|
messageType.isAcceptableOrUnknown(
|
|
data['message_type']!,
|
|
_messageTypeMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('file_id')) {
|
|
context.handle(
|
|
_fileIdMeta,
|
|
fileId.isAcceptableOrUnknown(data['file_id']!, _fileIdMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('encrypted_key')) {
|
|
context.handle(
|
|
_encryptedKeyMeta,
|
|
encryptedKey.isAcceptableOrUnknown(
|
|
data['encrypted_key']!,
|
|
_encryptedKeyMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('file_name')) {
|
|
context.handle(
|
|
_fileNameMeta,
|
|
fileName.isAcceptableOrUnknown(data['file_name']!, _fileNameMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('file_size')) {
|
|
context.handle(
|
|
_fileSizeMeta,
|
|
fileSize.isAcceptableOrUnknown(data['file_size']!, _fileSizeMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Message map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Message(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
senderId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}sender_id'],
|
|
)!,
|
|
receiverId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}receiver_id'],
|
|
)!,
|
|
content: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}content'],
|
|
)!,
|
|
timestamp: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}timestamp'],
|
|
)!,
|
|
deliveredAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}delivered_at'],
|
|
),
|
|
readAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}read_at'],
|
|
),
|
|
replyToId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}reply_to_id'],
|
|
),
|
|
replyToText: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}reply_to_text'],
|
|
),
|
|
editedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}edited_at'],
|
|
),
|
|
messageType: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}message_type'],
|
|
)!,
|
|
fileId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}file_id'],
|
|
),
|
|
encryptedKey: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}encrypted_key'],
|
|
),
|
|
fileName: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}file_name'],
|
|
),
|
|
fileSize: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}file_size'],
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$MessagesTable createAlias(String alias) {
|
|
return $MessagesTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Message extends DataClass implements Insertable<Message> {
|
|
final int id;
|
|
final int senderId;
|
|
final int receiverId;
|
|
final String content;
|
|
final String timestamp;
|
|
final String? deliveredAt;
|
|
final String? readAt;
|
|
final int? replyToId;
|
|
final String? replyToText;
|
|
final String? editedAt;
|
|
final String messageType;
|
|
final String? fileId;
|
|
final String? encryptedKey;
|
|
final String? fileName;
|
|
final int? fileSize;
|
|
const Message({
|
|
required this.id,
|
|
required this.senderId,
|
|
required this.receiverId,
|
|
required this.content,
|
|
required this.timestamp,
|
|
this.deliveredAt,
|
|
this.readAt,
|
|
this.replyToId,
|
|
this.replyToText,
|
|
this.editedAt,
|
|
required this.messageType,
|
|
this.fileId,
|
|
this.encryptedKey,
|
|
this.fileName,
|
|
this.fileSize,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['sender_id'] = Variable<int>(senderId);
|
|
map['receiver_id'] = Variable<int>(receiverId);
|
|
map['content'] = Variable<String>(content);
|
|
map['timestamp'] = Variable<String>(timestamp);
|
|
if (!nullToAbsent || deliveredAt != null) {
|
|
map['delivered_at'] = Variable<String>(deliveredAt);
|
|
}
|
|
if (!nullToAbsent || readAt != null) {
|
|
map['read_at'] = Variable<String>(readAt);
|
|
}
|
|
if (!nullToAbsent || replyToId != null) {
|
|
map['reply_to_id'] = Variable<int>(replyToId);
|
|
}
|
|
if (!nullToAbsent || replyToText != null) {
|
|
map['reply_to_text'] = Variable<String>(replyToText);
|
|
}
|
|
if (!nullToAbsent || editedAt != null) {
|
|
map['edited_at'] = Variable<String>(editedAt);
|
|
}
|
|
map['message_type'] = Variable<String>(messageType);
|
|
if (!nullToAbsent || fileId != null) {
|
|
map['file_id'] = Variable<String>(fileId);
|
|
}
|
|
if (!nullToAbsent || encryptedKey != null) {
|
|
map['encrypted_key'] = Variable<String>(encryptedKey);
|
|
}
|
|
if (!nullToAbsent || fileName != null) {
|
|
map['file_name'] = Variable<String>(fileName);
|
|
}
|
|
if (!nullToAbsent || fileSize != null) {
|
|
map['file_size'] = Variable<int>(fileSize);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
MessagesCompanion toCompanion(bool nullToAbsent) {
|
|
return MessagesCompanion(
|
|
id: Value(id),
|
|
senderId: Value(senderId),
|
|
receiverId: Value(receiverId),
|
|
content: Value(content),
|
|
timestamp: Value(timestamp),
|
|
deliveredAt: deliveredAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(deliveredAt),
|
|
readAt: readAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(readAt),
|
|
replyToId: replyToId == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(replyToId),
|
|
replyToText: replyToText == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(replyToText),
|
|
editedAt: editedAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(editedAt),
|
|
messageType: Value(messageType),
|
|
fileId: fileId == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(fileId),
|
|
encryptedKey: encryptedKey == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(encryptedKey),
|
|
fileName: fileName == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(fileName),
|
|
fileSize: fileSize == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(fileSize),
|
|
);
|
|
}
|
|
|
|
factory Message.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Message(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
senderId: serializer.fromJson<int>(json['senderId']),
|
|
receiverId: serializer.fromJson<int>(json['receiverId']),
|
|
content: serializer.fromJson<String>(json['content']),
|
|
timestamp: serializer.fromJson<String>(json['timestamp']),
|
|
deliveredAt: serializer.fromJson<String?>(json['deliveredAt']),
|
|
readAt: serializer.fromJson<String?>(json['readAt']),
|
|
replyToId: serializer.fromJson<int?>(json['replyToId']),
|
|
replyToText: serializer.fromJson<String?>(json['replyToText']),
|
|
editedAt: serializer.fromJson<String?>(json['editedAt']),
|
|
messageType: serializer.fromJson<String>(json['messageType']),
|
|
fileId: serializer.fromJson<String?>(json['fileId']),
|
|
encryptedKey: serializer.fromJson<String?>(json['encryptedKey']),
|
|
fileName: serializer.fromJson<String?>(json['fileName']),
|
|
fileSize: serializer.fromJson<int?>(json['fileSize']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'senderId': serializer.toJson<int>(senderId),
|
|
'receiverId': serializer.toJson<int>(receiverId),
|
|
'content': serializer.toJson<String>(content),
|
|
'timestamp': serializer.toJson<String>(timestamp),
|
|
'deliveredAt': serializer.toJson<String?>(deliveredAt),
|
|
'readAt': serializer.toJson<String?>(readAt),
|
|
'replyToId': serializer.toJson<int?>(replyToId),
|
|
'replyToText': serializer.toJson<String?>(replyToText),
|
|
'editedAt': serializer.toJson<String?>(editedAt),
|
|
'messageType': serializer.toJson<String>(messageType),
|
|
'fileId': serializer.toJson<String?>(fileId),
|
|
'encryptedKey': serializer.toJson<String?>(encryptedKey),
|
|
'fileName': serializer.toJson<String?>(fileName),
|
|
'fileSize': serializer.toJson<int?>(fileSize),
|
|
};
|
|
}
|
|
|
|
Message copyWith({
|
|
int? id,
|
|
int? senderId,
|
|
int? receiverId,
|
|
String? content,
|
|
String? timestamp,
|
|
Value<String?> deliveredAt = const Value.absent(),
|
|
Value<String?> readAt = const Value.absent(),
|
|
Value<int?> replyToId = const Value.absent(),
|
|
Value<String?> replyToText = const Value.absent(),
|
|
Value<String?> editedAt = const Value.absent(),
|
|
String? messageType,
|
|
Value<String?> fileId = const Value.absent(),
|
|
Value<String?> encryptedKey = const Value.absent(),
|
|
Value<String?> fileName = const Value.absent(),
|
|
Value<int?> fileSize = const Value.absent(),
|
|
}) => Message(
|
|
id: id ?? this.id,
|
|
senderId: senderId ?? this.senderId,
|
|
receiverId: receiverId ?? this.receiverId,
|
|
content: content ?? this.content,
|
|
timestamp: timestamp ?? this.timestamp,
|
|
deliveredAt: deliveredAt.present ? deliveredAt.value : this.deliveredAt,
|
|
readAt: readAt.present ? readAt.value : this.readAt,
|
|
replyToId: replyToId.present ? replyToId.value : this.replyToId,
|
|
replyToText: replyToText.present ? replyToText.value : this.replyToText,
|
|
editedAt: editedAt.present ? editedAt.value : this.editedAt,
|
|
messageType: messageType ?? this.messageType,
|
|
fileId: fileId.present ? fileId.value : this.fileId,
|
|
encryptedKey: encryptedKey.present ? encryptedKey.value : this.encryptedKey,
|
|
fileName: fileName.present ? fileName.value : this.fileName,
|
|
fileSize: fileSize.present ? fileSize.value : this.fileSize,
|
|
);
|
|
Message copyWithCompanion(MessagesCompanion data) {
|
|
return Message(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
senderId: data.senderId.present ? data.senderId.value : this.senderId,
|
|
receiverId: data.receiverId.present
|
|
? data.receiverId.value
|
|
: this.receiverId,
|
|
content: data.content.present ? data.content.value : this.content,
|
|
timestamp: data.timestamp.present ? data.timestamp.value : this.timestamp,
|
|
deliveredAt: data.deliveredAt.present
|
|
? data.deliveredAt.value
|
|
: this.deliveredAt,
|
|
readAt: data.readAt.present ? data.readAt.value : this.readAt,
|
|
replyToId: data.replyToId.present ? data.replyToId.value : this.replyToId,
|
|
replyToText: data.replyToText.present
|
|
? data.replyToText.value
|
|
: this.replyToText,
|
|
editedAt: data.editedAt.present ? data.editedAt.value : this.editedAt,
|
|
messageType: data.messageType.present
|
|
? data.messageType.value
|
|
: this.messageType,
|
|
fileId: data.fileId.present ? data.fileId.value : this.fileId,
|
|
encryptedKey: data.encryptedKey.present
|
|
? data.encryptedKey.value
|
|
: this.encryptedKey,
|
|
fileName: data.fileName.present ? data.fileName.value : this.fileName,
|
|
fileSize: data.fileSize.present ? data.fileSize.value : this.fileSize,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Message(')
|
|
..write('id: $id, ')
|
|
..write('senderId: $senderId, ')
|
|
..write('receiverId: $receiverId, ')
|
|
..write('content: $content, ')
|
|
..write('timestamp: $timestamp, ')
|
|
..write('deliveredAt: $deliveredAt, ')
|
|
..write('readAt: $readAt, ')
|
|
..write('replyToId: $replyToId, ')
|
|
..write('replyToText: $replyToText, ')
|
|
..write('editedAt: $editedAt, ')
|
|
..write('messageType: $messageType, ')
|
|
..write('fileId: $fileId, ')
|
|
..write('encryptedKey: $encryptedKey, ')
|
|
..write('fileName: $fileName, ')
|
|
..write('fileSize: $fileSize')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
senderId,
|
|
receiverId,
|
|
content,
|
|
timestamp,
|
|
deliveredAt,
|
|
readAt,
|
|
replyToId,
|
|
replyToText,
|
|
editedAt,
|
|
messageType,
|
|
fileId,
|
|
encryptedKey,
|
|
fileName,
|
|
fileSize,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Message &&
|
|
other.id == this.id &&
|
|
other.senderId == this.senderId &&
|
|
other.receiverId == this.receiverId &&
|
|
other.content == this.content &&
|
|
other.timestamp == this.timestamp &&
|
|
other.deliveredAt == this.deliveredAt &&
|
|
other.readAt == this.readAt &&
|
|
other.replyToId == this.replyToId &&
|
|
other.replyToText == this.replyToText &&
|
|
other.editedAt == this.editedAt &&
|
|
other.messageType == this.messageType &&
|
|
other.fileId == this.fileId &&
|
|
other.encryptedKey == this.encryptedKey &&
|
|
other.fileName == this.fileName &&
|
|
other.fileSize == this.fileSize);
|
|
}
|
|
|
|
class MessagesCompanion extends UpdateCompanion<Message> {
|
|
final Value<int> id;
|
|
final Value<int> senderId;
|
|
final Value<int> receiverId;
|
|
final Value<String> content;
|
|
final Value<String> timestamp;
|
|
final Value<String?> deliveredAt;
|
|
final Value<String?> readAt;
|
|
final Value<int?> replyToId;
|
|
final Value<String?> replyToText;
|
|
final Value<String?> editedAt;
|
|
final Value<String> messageType;
|
|
final Value<String?> fileId;
|
|
final Value<String?> encryptedKey;
|
|
final Value<String?> fileName;
|
|
final Value<int?> fileSize;
|
|
const MessagesCompanion({
|
|
this.id = const Value.absent(),
|
|
this.senderId = const Value.absent(),
|
|
this.receiverId = const Value.absent(),
|
|
this.content = const Value.absent(),
|
|
this.timestamp = const Value.absent(),
|
|
this.deliveredAt = const Value.absent(),
|
|
this.readAt = const Value.absent(),
|
|
this.replyToId = const Value.absent(),
|
|
this.replyToText = const Value.absent(),
|
|
this.editedAt = const Value.absent(),
|
|
this.messageType = const Value.absent(),
|
|
this.fileId = const Value.absent(),
|
|
this.encryptedKey = const Value.absent(),
|
|
this.fileName = const Value.absent(),
|
|
this.fileSize = const Value.absent(),
|
|
});
|
|
MessagesCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required int senderId,
|
|
required int receiverId,
|
|
required String content,
|
|
required String timestamp,
|
|
this.deliveredAt = const Value.absent(),
|
|
this.readAt = const Value.absent(),
|
|
this.replyToId = const Value.absent(),
|
|
this.replyToText = const Value.absent(),
|
|
this.editedAt = const Value.absent(),
|
|
this.messageType = const Value.absent(),
|
|
this.fileId = const Value.absent(),
|
|
this.encryptedKey = const Value.absent(),
|
|
this.fileName = const Value.absent(),
|
|
this.fileSize = const Value.absent(),
|
|
}) : senderId = Value(senderId),
|
|
receiverId = Value(receiverId),
|
|
content = Value(content),
|
|
timestamp = Value(timestamp);
|
|
static Insertable<Message> custom({
|
|
Expression<int>? id,
|
|
Expression<int>? senderId,
|
|
Expression<int>? receiverId,
|
|
Expression<String>? content,
|
|
Expression<String>? timestamp,
|
|
Expression<String>? deliveredAt,
|
|
Expression<String>? readAt,
|
|
Expression<int>? replyToId,
|
|
Expression<String>? replyToText,
|
|
Expression<String>? editedAt,
|
|
Expression<String>? messageType,
|
|
Expression<String>? fileId,
|
|
Expression<String>? encryptedKey,
|
|
Expression<String>? fileName,
|
|
Expression<int>? fileSize,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (senderId != null) 'sender_id': senderId,
|
|
if (receiverId != null) 'receiver_id': receiverId,
|
|
if (content != null) 'content': content,
|
|
if (timestamp != null) 'timestamp': timestamp,
|
|
if (deliveredAt != null) 'delivered_at': deliveredAt,
|
|
if (readAt != null) 'read_at': readAt,
|
|
if (replyToId != null) 'reply_to_id': replyToId,
|
|
if (replyToText != null) 'reply_to_text': replyToText,
|
|
if (editedAt != null) 'edited_at': editedAt,
|
|
if (messageType != null) 'message_type': messageType,
|
|
if (fileId != null) 'file_id': fileId,
|
|
if (encryptedKey != null) 'encrypted_key': encryptedKey,
|
|
if (fileName != null) 'file_name': fileName,
|
|
if (fileSize != null) 'file_size': fileSize,
|
|
});
|
|
}
|
|
|
|
MessagesCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<int>? senderId,
|
|
Value<int>? receiverId,
|
|
Value<String>? content,
|
|
Value<String>? timestamp,
|
|
Value<String?>? deliveredAt,
|
|
Value<String?>? readAt,
|
|
Value<int?>? replyToId,
|
|
Value<String?>? replyToText,
|
|
Value<String?>? editedAt,
|
|
Value<String>? messageType,
|
|
Value<String?>? fileId,
|
|
Value<String?>? encryptedKey,
|
|
Value<String?>? fileName,
|
|
Value<int?>? fileSize,
|
|
}) {
|
|
return MessagesCompanion(
|
|
id: id ?? this.id,
|
|
senderId: senderId ?? this.senderId,
|
|
receiverId: receiverId ?? this.receiverId,
|
|
content: content ?? this.content,
|
|
timestamp: timestamp ?? this.timestamp,
|
|
deliveredAt: deliveredAt ?? this.deliveredAt,
|
|
readAt: readAt ?? this.readAt,
|
|
replyToId: replyToId ?? this.replyToId,
|
|
replyToText: replyToText ?? this.replyToText,
|
|
editedAt: editedAt ?? this.editedAt,
|
|
messageType: messageType ?? this.messageType,
|
|
fileId: fileId ?? this.fileId,
|
|
encryptedKey: encryptedKey ?? this.encryptedKey,
|
|
fileName: fileName ?? this.fileName,
|
|
fileSize: fileSize ?? this.fileSize,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (senderId.present) {
|
|
map['sender_id'] = Variable<int>(senderId.value);
|
|
}
|
|
if (receiverId.present) {
|
|
map['receiver_id'] = Variable<int>(receiverId.value);
|
|
}
|
|
if (content.present) {
|
|
map['content'] = Variable<String>(content.value);
|
|
}
|
|
if (timestamp.present) {
|
|
map['timestamp'] = Variable<String>(timestamp.value);
|
|
}
|
|
if (deliveredAt.present) {
|
|
map['delivered_at'] = Variable<String>(deliveredAt.value);
|
|
}
|
|
if (readAt.present) {
|
|
map['read_at'] = Variable<String>(readAt.value);
|
|
}
|
|
if (replyToId.present) {
|
|
map['reply_to_id'] = Variable<int>(replyToId.value);
|
|
}
|
|
if (replyToText.present) {
|
|
map['reply_to_text'] = Variable<String>(replyToText.value);
|
|
}
|
|
if (editedAt.present) {
|
|
map['edited_at'] = Variable<String>(editedAt.value);
|
|
}
|
|
if (messageType.present) {
|
|
map['message_type'] = Variable<String>(messageType.value);
|
|
}
|
|
if (fileId.present) {
|
|
map['file_id'] = Variable<String>(fileId.value);
|
|
}
|
|
if (encryptedKey.present) {
|
|
map['encrypted_key'] = Variable<String>(encryptedKey.value);
|
|
}
|
|
if (fileName.present) {
|
|
map['file_name'] = Variable<String>(fileName.value);
|
|
}
|
|
if (fileSize.present) {
|
|
map['file_size'] = Variable<int>(fileSize.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('MessagesCompanion(')
|
|
..write('id: $id, ')
|
|
..write('senderId: $senderId, ')
|
|
..write('receiverId: $receiverId, ')
|
|
..write('content: $content, ')
|
|
..write('timestamp: $timestamp, ')
|
|
..write('deliveredAt: $deliveredAt, ')
|
|
..write('readAt: $readAt, ')
|
|
..write('replyToId: $replyToId, ')
|
|
..write('replyToText: $replyToText, ')
|
|
..write('editedAt: $editedAt, ')
|
|
..write('messageType: $messageType, ')
|
|
..write('fileId: $fileId, ')
|
|
..write('encryptedKey: $encryptedKey, ')
|
|
..write('fileName: $fileName, ')
|
|
..write('fileSize: $fileSize')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $FileNameMappingsTable extends FileNameMappings
|
|
with TableInfo<$FileNameMappingsTable, FileNameMapping> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$FileNameMappingsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _fileIdMeta = const VerificationMeta('fileId');
|
|
@override
|
|
late final GeneratedColumn<String> fileId = GeneratedColumn<String>(
|
|
'file_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _originalFileNameMeta = const VerificationMeta(
|
|
'originalFileName',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> originalFileName = GeneratedColumn<String>(
|
|
'original_file_name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [fileId, originalFileName];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'file_name_mappings';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<FileNameMapping> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('file_id')) {
|
|
context.handle(
|
|
_fileIdMeta,
|
|
fileId.isAcceptableOrUnknown(data['file_id']!, _fileIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_fileIdMeta);
|
|
}
|
|
if (data.containsKey('original_file_name')) {
|
|
context.handle(
|
|
_originalFileNameMeta,
|
|
originalFileName.isAcceptableOrUnknown(
|
|
data['original_file_name']!,
|
|
_originalFileNameMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_originalFileNameMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {fileId};
|
|
@override
|
|
FileNameMapping map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return FileNameMapping(
|
|
fileId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}file_id'],
|
|
)!,
|
|
originalFileName: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}original_file_name'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$FileNameMappingsTable createAlias(String alias) {
|
|
return $FileNameMappingsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class FileNameMapping extends DataClass implements Insertable<FileNameMapping> {
|
|
final String fileId;
|
|
final String originalFileName;
|
|
const FileNameMapping({required this.fileId, required this.originalFileName});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['file_id'] = Variable<String>(fileId);
|
|
map['original_file_name'] = Variable<String>(originalFileName);
|
|
return map;
|
|
}
|
|
|
|
FileNameMappingsCompanion toCompanion(bool nullToAbsent) {
|
|
return FileNameMappingsCompanion(
|
|
fileId: Value(fileId),
|
|
originalFileName: Value(originalFileName),
|
|
);
|
|
}
|
|
|
|
factory FileNameMapping.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return FileNameMapping(
|
|
fileId: serializer.fromJson<String>(json['fileId']),
|
|
originalFileName: serializer.fromJson<String>(json['originalFileName']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'fileId': serializer.toJson<String>(fileId),
|
|
'originalFileName': serializer.toJson<String>(originalFileName),
|
|
};
|
|
}
|
|
|
|
FileNameMapping copyWith({String? fileId, String? originalFileName}) =>
|
|
FileNameMapping(
|
|
fileId: fileId ?? this.fileId,
|
|
originalFileName: originalFileName ?? this.originalFileName,
|
|
);
|
|
FileNameMapping copyWithCompanion(FileNameMappingsCompanion data) {
|
|
return FileNameMapping(
|
|
fileId: data.fileId.present ? data.fileId.value : this.fileId,
|
|
originalFileName: data.originalFileName.present
|
|
? data.originalFileName.value
|
|
: this.originalFileName,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('FileNameMapping(')
|
|
..write('fileId: $fileId, ')
|
|
..write('originalFileName: $originalFileName')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(fileId, originalFileName);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is FileNameMapping &&
|
|
other.fileId == this.fileId &&
|
|
other.originalFileName == this.originalFileName);
|
|
}
|
|
|
|
class FileNameMappingsCompanion extends UpdateCompanion<FileNameMapping> {
|
|
final Value<String> fileId;
|
|
final Value<String> originalFileName;
|
|
final Value<int> rowid;
|
|
const FileNameMappingsCompanion({
|
|
this.fileId = const Value.absent(),
|
|
this.originalFileName = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
FileNameMappingsCompanion.insert({
|
|
required String fileId,
|
|
required String originalFileName,
|
|
this.rowid = const Value.absent(),
|
|
}) : fileId = Value(fileId),
|
|
originalFileName = Value(originalFileName);
|
|
static Insertable<FileNameMapping> custom({
|
|
Expression<String>? fileId,
|
|
Expression<String>? originalFileName,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (fileId != null) 'file_id': fileId,
|
|
if (originalFileName != null) 'original_file_name': originalFileName,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
FileNameMappingsCompanion copyWith({
|
|
Value<String>? fileId,
|
|
Value<String>? originalFileName,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return FileNameMappingsCompanion(
|
|
fileId: fileId ?? this.fileId,
|
|
originalFileName: originalFileName ?? this.originalFileName,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (fileId.present) {
|
|
map['file_id'] = Variable<String>(fileId.value);
|
|
}
|
|
if (originalFileName.present) {
|
|
map['original_file_name'] = Variable<String>(originalFileName.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('FileNameMappingsCompanion(')
|
|
..write('fileId: $fileId, ')
|
|
..write('originalFileName: $originalFileName, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$LocalDbService extends GeneratedDatabase {
|
|
_$LocalDbService(QueryExecutor e) : super(e);
|
|
$LocalDbServiceManager get managers => $LocalDbServiceManager(this);
|
|
late final $MessagesTable messages = $MessagesTable(this);
|
|
late final $FileNameMappingsTable fileNameMappings = $FileNameMappingsTable(
|
|
this,
|
|
);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
messages,
|
|
fileNameMappings,
|
|
];
|
|
}
|
|
|
|
typedef $$MessagesTableCreateCompanionBuilder =
|
|
MessagesCompanion Function({
|
|
Value<int> id,
|
|
required int senderId,
|
|
required int receiverId,
|
|
required String content,
|
|
required String timestamp,
|
|
Value<String?> deliveredAt,
|
|
Value<String?> readAt,
|
|
Value<int?> replyToId,
|
|
Value<String?> replyToText,
|
|
Value<String?> editedAt,
|
|
Value<String> messageType,
|
|
Value<String?> fileId,
|
|
Value<String?> encryptedKey,
|
|
Value<String?> fileName,
|
|
Value<int?> fileSize,
|
|
});
|
|
typedef $$MessagesTableUpdateCompanionBuilder =
|
|
MessagesCompanion Function({
|
|
Value<int> id,
|
|
Value<int> senderId,
|
|
Value<int> receiverId,
|
|
Value<String> content,
|
|
Value<String> timestamp,
|
|
Value<String?> deliveredAt,
|
|
Value<String?> readAt,
|
|
Value<int?> replyToId,
|
|
Value<String?> replyToText,
|
|
Value<String?> editedAt,
|
|
Value<String> messageType,
|
|
Value<String?> fileId,
|
|
Value<String?> encryptedKey,
|
|
Value<String?> fileName,
|
|
Value<int?> fileSize,
|
|
});
|
|
|
|
class $$MessagesTableFilterComposer
|
|
extends Composer<_$LocalDbService, $MessagesTable> {
|
|
$$MessagesTableFilterComposer({
|
|
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<int> get senderId => $composableBuilder(
|
|
column: $table.senderId,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get receiverId => $composableBuilder(
|
|
column: $table.receiverId,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get content => $composableBuilder(
|
|
column: $table.content,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get timestamp => $composableBuilder(
|
|
column: $table.timestamp,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get deliveredAt => $composableBuilder(
|
|
column: $table.deliveredAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get readAt => $composableBuilder(
|
|
column: $table.readAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get replyToId => $composableBuilder(
|
|
column: $table.replyToId,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get replyToText => $composableBuilder(
|
|
column: $table.replyToText,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get editedAt => $composableBuilder(
|
|
column: $table.editedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get messageType => $composableBuilder(
|
|
column: $table.messageType,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get fileId => $composableBuilder(
|
|
column: $table.fileId,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get encryptedKey => $composableBuilder(
|
|
column: $table.encryptedKey,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get fileName => $composableBuilder(
|
|
column: $table.fileName,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get fileSize => $composableBuilder(
|
|
column: $table.fileSize,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$MessagesTableOrderingComposer
|
|
extends Composer<_$LocalDbService, $MessagesTable> {
|
|
$$MessagesTableOrderingComposer({
|
|
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<int> get senderId => $composableBuilder(
|
|
column: $table.senderId,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get receiverId => $composableBuilder(
|
|
column: $table.receiverId,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get content => $composableBuilder(
|
|
column: $table.content,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get timestamp => $composableBuilder(
|
|
column: $table.timestamp,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get deliveredAt => $composableBuilder(
|
|
column: $table.deliveredAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get readAt => $composableBuilder(
|
|
column: $table.readAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get replyToId => $composableBuilder(
|
|
column: $table.replyToId,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get replyToText => $composableBuilder(
|
|
column: $table.replyToText,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get editedAt => $composableBuilder(
|
|
column: $table.editedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get messageType => $composableBuilder(
|
|
column: $table.messageType,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get fileId => $composableBuilder(
|
|
column: $table.fileId,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get encryptedKey => $composableBuilder(
|
|
column: $table.encryptedKey,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get fileName => $composableBuilder(
|
|
column: $table.fileName,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get fileSize => $composableBuilder(
|
|
column: $table.fileSize,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$MessagesTableAnnotationComposer
|
|
extends Composer<_$LocalDbService, $MessagesTable> {
|
|
$$MessagesTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get senderId =>
|
|
$composableBuilder(column: $table.senderId, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get receiverId => $composableBuilder(
|
|
column: $table.receiverId,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get content =>
|
|
$composableBuilder(column: $table.content, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get timestamp =>
|
|
$composableBuilder(column: $table.timestamp, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get deliveredAt => $composableBuilder(
|
|
column: $table.deliveredAt,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get readAt =>
|
|
$composableBuilder(column: $table.readAt, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get replyToId =>
|
|
$composableBuilder(column: $table.replyToId, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get replyToText => $composableBuilder(
|
|
column: $table.replyToText,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get editedAt =>
|
|
$composableBuilder(column: $table.editedAt, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get messageType => $composableBuilder(
|
|
column: $table.messageType,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get fileId =>
|
|
$composableBuilder(column: $table.fileId, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get encryptedKey => $composableBuilder(
|
|
column: $table.encryptedKey,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get fileName =>
|
|
$composableBuilder(column: $table.fileName, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get fileSize =>
|
|
$composableBuilder(column: $table.fileSize, builder: (column) => column);
|
|
}
|
|
|
|
class $$MessagesTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$LocalDbService,
|
|
$MessagesTable,
|
|
Message,
|
|
$$MessagesTableFilterComposer,
|
|
$$MessagesTableOrderingComposer,
|
|
$$MessagesTableAnnotationComposer,
|
|
$$MessagesTableCreateCompanionBuilder,
|
|
$$MessagesTableUpdateCompanionBuilder,
|
|
(Message, BaseReferences<_$LocalDbService, $MessagesTable, Message>),
|
|
Message,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$MessagesTableTableManager(_$LocalDbService db, $MessagesTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$MessagesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$MessagesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$MessagesTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<int> senderId = const Value.absent(),
|
|
Value<int> receiverId = const Value.absent(),
|
|
Value<String> content = const Value.absent(),
|
|
Value<String> timestamp = const Value.absent(),
|
|
Value<String?> deliveredAt = const Value.absent(),
|
|
Value<String?> readAt = const Value.absent(),
|
|
Value<int?> replyToId = const Value.absent(),
|
|
Value<String?> replyToText = const Value.absent(),
|
|
Value<String?> editedAt = const Value.absent(),
|
|
Value<String> messageType = const Value.absent(),
|
|
Value<String?> fileId = const Value.absent(),
|
|
Value<String?> encryptedKey = const Value.absent(),
|
|
Value<String?> fileName = const Value.absent(),
|
|
Value<int?> fileSize = const Value.absent(),
|
|
}) => MessagesCompanion(
|
|
id: id,
|
|
senderId: senderId,
|
|
receiverId: receiverId,
|
|
content: content,
|
|
timestamp: timestamp,
|
|
deliveredAt: deliveredAt,
|
|
readAt: readAt,
|
|
replyToId: replyToId,
|
|
replyToText: replyToText,
|
|
editedAt: editedAt,
|
|
messageType: messageType,
|
|
fileId: fileId,
|
|
encryptedKey: encryptedKey,
|
|
fileName: fileName,
|
|
fileSize: fileSize,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required int senderId,
|
|
required int receiverId,
|
|
required String content,
|
|
required String timestamp,
|
|
Value<String?> deliveredAt = const Value.absent(),
|
|
Value<String?> readAt = const Value.absent(),
|
|
Value<int?> replyToId = const Value.absent(),
|
|
Value<String?> replyToText = const Value.absent(),
|
|
Value<String?> editedAt = const Value.absent(),
|
|
Value<String> messageType = const Value.absent(),
|
|
Value<String?> fileId = const Value.absent(),
|
|
Value<String?> encryptedKey = const Value.absent(),
|
|
Value<String?> fileName = const Value.absent(),
|
|
Value<int?> fileSize = const Value.absent(),
|
|
}) => MessagesCompanion.insert(
|
|
id: id,
|
|
senderId: senderId,
|
|
receiverId: receiverId,
|
|
content: content,
|
|
timestamp: timestamp,
|
|
deliveredAt: deliveredAt,
|
|
readAt: readAt,
|
|
replyToId: replyToId,
|
|
replyToText: replyToText,
|
|
editedAt: editedAt,
|
|
messageType: messageType,
|
|
fileId: fileId,
|
|
encryptedKey: encryptedKey,
|
|
fileName: fileName,
|
|
fileSize: fileSize,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$MessagesTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$LocalDbService,
|
|
$MessagesTable,
|
|
Message,
|
|
$$MessagesTableFilterComposer,
|
|
$$MessagesTableOrderingComposer,
|
|
$$MessagesTableAnnotationComposer,
|
|
$$MessagesTableCreateCompanionBuilder,
|
|
$$MessagesTableUpdateCompanionBuilder,
|
|
(Message, BaseReferences<_$LocalDbService, $MessagesTable, Message>),
|
|
Message,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$FileNameMappingsTableCreateCompanionBuilder =
|
|
FileNameMappingsCompanion Function({
|
|
required String fileId,
|
|
required String originalFileName,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$FileNameMappingsTableUpdateCompanionBuilder =
|
|
FileNameMappingsCompanion Function({
|
|
Value<String> fileId,
|
|
Value<String> originalFileName,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$FileNameMappingsTableFilterComposer
|
|
extends Composer<_$LocalDbService, $FileNameMappingsTable> {
|
|
$$FileNameMappingsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get fileId => $composableBuilder(
|
|
column: $table.fileId,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get originalFileName => $composableBuilder(
|
|
column: $table.originalFileName,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$FileNameMappingsTableOrderingComposer
|
|
extends Composer<_$LocalDbService, $FileNameMappingsTable> {
|
|
$$FileNameMappingsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get fileId => $composableBuilder(
|
|
column: $table.fileId,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get originalFileName => $composableBuilder(
|
|
column: $table.originalFileName,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$FileNameMappingsTableAnnotationComposer
|
|
extends Composer<_$LocalDbService, $FileNameMappingsTable> {
|
|
$$FileNameMappingsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get fileId =>
|
|
$composableBuilder(column: $table.fileId, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get originalFileName => $composableBuilder(
|
|
column: $table.originalFileName,
|
|
builder: (column) => column,
|
|
);
|
|
}
|
|
|
|
class $$FileNameMappingsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$LocalDbService,
|
|
$FileNameMappingsTable,
|
|
FileNameMapping,
|
|
$$FileNameMappingsTableFilterComposer,
|
|
$$FileNameMappingsTableOrderingComposer,
|
|
$$FileNameMappingsTableAnnotationComposer,
|
|
$$FileNameMappingsTableCreateCompanionBuilder,
|
|
$$FileNameMappingsTableUpdateCompanionBuilder,
|
|
(
|
|
FileNameMapping,
|
|
BaseReferences<
|
|
_$LocalDbService,
|
|
$FileNameMappingsTable,
|
|
FileNameMapping
|
|
>,
|
|
),
|
|
FileNameMapping,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$FileNameMappingsTableTableManager(
|
|
_$LocalDbService db,
|
|
$FileNameMappingsTable table,
|
|
) : super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$FileNameMappingsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$FileNameMappingsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$FileNameMappingsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> fileId = const Value.absent(),
|
|
Value<String> originalFileName = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => FileNameMappingsCompanion(
|
|
fileId: fileId,
|
|
originalFileName: originalFileName,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String fileId,
|
|
required String originalFileName,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => FileNameMappingsCompanion.insert(
|
|
fileId: fileId,
|
|
originalFileName: originalFileName,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$FileNameMappingsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$LocalDbService,
|
|
$FileNameMappingsTable,
|
|
FileNameMapping,
|
|
$$FileNameMappingsTableFilterComposer,
|
|
$$FileNameMappingsTableOrderingComposer,
|
|
$$FileNameMappingsTableAnnotationComposer,
|
|
$$FileNameMappingsTableCreateCompanionBuilder,
|
|
$$FileNameMappingsTableUpdateCompanionBuilder,
|
|
(
|
|
FileNameMapping,
|
|
BaseReferences<
|
|
_$LocalDbService,
|
|
$FileNameMappingsTable,
|
|
FileNameMapping
|
|
>,
|
|
),
|
|
FileNameMapping,
|
|
PrefetchHooks Function()
|
|
>;
|
|
|
|
class $LocalDbServiceManager {
|
|
final _$LocalDbService _db;
|
|
$LocalDbServiceManager(this._db);
|
|
$$MessagesTableTableManager get messages =>
|
|
$$MessagesTableTableManager(_db, _db.messages);
|
|
$$FileNameMappingsTableTableManager get fileNameMappings =>
|
|
$$FileNameMappingsTableTableManager(_db, _db.fileNameMappings);
|
|
}
|