6967 lines
221 KiB
Dart
6967 lines
221 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'app_database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $ProductsTable extends Products
|
|
with TableInfo<$ProductsTable, ProductRow> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ProductsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _nameMeta = const VerificationMeta('name');
|
|
@override
|
|
late final GeneratedColumn<String> name = GeneratedColumn<String>(
|
|
'name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _categoryMeta = const VerificationMeta(
|
|
'category',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> category = GeneratedColumn<String>(
|
|
'category',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _stockQuantityMeta = const VerificationMeta(
|
|
'stockQuantity',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> stockQuantity = GeneratedColumn<int>(
|
|
'stock_quantity',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _lowStockThresholdMeta = const VerificationMeta(
|
|
'lowStockThreshold',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> lowStockThreshold = GeneratedColumn<int>(
|
|
'low_stock_threshold',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _infiniteStockMeta = const VerificationMeta(
|
|
'infiniteStock',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<bool> infiniteStock = GeneratedColumn<bool>(
|
|
'infinite_stock',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.bool,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'CHECK ("infinite_stock" IN (0, 1))',
|
|
),
|
|
defaultValue: const Constant(false),
|
|
);
|
|
static const VerificationMeta _priceInCentsMeta = const VerificationMeta(
|
|
'priceInCents',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> priceInCents = GeneratedColumn<int>(
|
|
'price_in_cents',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _imagePathMeta = const VerificationMeta(
|
|
'imagePath',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> imagePath = GeneratedColumn<String>(
|
|
'image_path',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _activeMeta = const VerificationMeta('active');
|
|
@override
|
|
late final GeneratedColumn<bool> active = GeneratedColumn<bool>(
|
|
'active',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.bool,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'CHECK ("active" IN (0, 1))',
|
|
),
|
|
defaultValue: const Constant(true),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
name,
|
|
category,
|
|
stockQuantity,
|
|
lowStockThreshold,
|
|
infiniteStock,
|
|
priceInCents,
|
|
imagePath,
|
|
active,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'products';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<ProductRow> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_idMeta);
|
|
}
|
|
if (data.containsKey('name')) {
|
|
context.handle(
|
|
_nameMeta,
|
|
name.isAcceptableOrUnknown(data['name']!, _nameMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_nameMeta);
|
|
}
|
|
if (data.containsKey('category')) {
|
|
context.handle(
|
|
_categoryMeta,
|
|
category.isAcceptableOrUnknown(data['category']!, _categoryMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_categoryMeta);
|
|
}
|
|
if (data.containsKey('stock_quantity')) {
|
|
context.handle(
|
|
_stockQuantityMeta,
|
|
stockQuantity.isAcceptableOrUnknown(
|
|
data['stock_quantity']!,
|
|
_stockQuantityMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_stockQuantityMeta);
|
|
}
|
|
if (data.containsKey('low_stock_threshold')) {
|
|
context.handle(
|
|
_lowStockThresholdMeta,
|
|
lowStockThreshold.isAcceptableOrUnknown(
|
|
data['low_stock_threshold']!,
|
|
_lowStockThresholdMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_lowStockThresholdMeta);
|
|
}
|
|
if (data.containsKey('infinite_stock')) {
|
|
context.handle(
|
|
_infiniteStockMeta,
|
|
infiniteStock.isAcceptableOrUnknown(
|
|
data['infinite_stock']!,
|
|
_infiniteStockMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('price_in_cents')) {
|
|
context.handle(
|
|
_priceInCentsMeta,
|
|
priceInCents.isAcceptableOrUnknown(
|
|
data['price_in_cents']!,
|
|
_priceInCentsMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_priceInCentsMeta);
|
|
}
|
|
if (data.containsKey('image_path')) {
|
|
context.handle(
|
|
_imagePathMeta,
|
|
imagePath.isAcceptableOrUnknown(data['image_path']!, _imagePathMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('active')) {
|
|
context.handle(
|
|
_activeMeta,
|
|
active.isAcceptableOrUnknown(data['active']!, _activeMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
ProductRow map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ProductRow(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
category: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}category'],
|
|
)!,
|
|
stockQuantity: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}stock_quantity'],
|
|
)!,
|
|
lowStockThreshold: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}low_stock_threshold'],
|
|
)!,
|
|
infiniteStock: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.bool,
|
|
data['${effectivePrefix}infinite_stock'],
|
|
)!,
|
|
priceInCents: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}price_in_cents'],
|
|
)!,
|
|
imagePath: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}image_path'],
|
|
),
|
|
active: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.bool,
|
|
data['${effectivePrefix}active'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ProductsTable createAlias(String alias) {
|
|
return $ProductsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class ProductRow extends DataClass implements Insertable<ProductRow> {
|
|
final String id;
|
|
final String name;
|
|
final String category;
|
|
final int stockQuantity;
|
|
final int lowStockThreshold;
|
|
|
|
/// Products like tap water that are never counted; their stock is ignored.
|
|
final bool infiniteStock;
|
|
final int priceInCents;
|
|
final String? imagePath;
|
|
final bool active;
|
|
const ProductRow({
|
|
required this.id,
|
|
required this.name,
|
|
required this.category,
|
|
required this.stockQuantity,
|
|
required this.lowStockThreshold,
|
|
required this.infiniteStock,
|
|
required this.priceInCents,
|
|
this.imagePath,
|
|
required this.active,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['name'] = Variable<String>(name);
|
|
map['category'] = Variable<String>(category);
|
|
map['stock_quantity'] = Variable<int>(stockQuantity);
|
|
map['low_stock_threshold'] = Variable<int>(lowStockThreshold);
|
|
map['infinite_stock'] = Variable<bool>(infiniteStock);
|
|
map['price_in_cents'] = Variable<int>(priceInCents);
|
|
if (!nullToAbsent || imagePath != null) {
|
|
map['image_path'] = Variable<String>(imagePath);
|
|
}
|
|
map['active'] = Variable<bool>(active);
|
|
return map;
|
|
}
|
|
|
|
ProductsCompanion toCompanion(bool nullToAbsent) {
|
|
return ProductsCompanion(
|
|
id: Value(id),
|
|
name: Value(name),
|
|
category: Value(category),
|
|
stockQuantity: Value(stockQuantity),
|
|
lowStockThreshold: Value(lowStockThreshold),
|
|
infiniteStock: Value(infiniteStock),
|
|
priceInCents: Value(priceInCents),
|
|
imagePath: imagePath == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(imagePath),
|
|
active: Value(active),
|
|
);
|
|
}
|
|
|
|
factory ProductRow.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return ProductRow(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
category: serializer.fromJson<String>(json['category']),
|
|
stockQuantity: serializer.fromJson<int>(json['stockQuantity']),
|
|
lowStockThreshold: serializer.fromJson<int>(json['lowStockThreshold']),
|
|
infiniteStock: serializer.fromJson<bool>(json['infiniteStock']),
|
|
priceInCents: serializer.fromJson<int>(json['priceInCents']),
|
|
imagePath: serializer.fromJson<String?>(json['imagePath']),
|
|
active: serializer.fromJson<bool>(json['active']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'name': serializer.toJson<String>(name),
|
|
'category': serializer.toJson<String>(category),
|
|
'stockQuantity': serializer.toJson<int>(stockQuantity),
|
|
'lowStockThreshold': serializer.toJson<int>(lowStockThreshold),
|
|
'infiniteStock': serializer.toJson<bool>(infiniteStock),
|
|
'priceInCents': serializer.toJson<int>(priceInCents),
|
|
'imagePath': serializer.toJson<String?>(imagePath),
|
|
'active': serializer.toJson<bool>(active),
|
|
};
|
|
}
|
|
|
|
ProductRow copyWith({
|
|
String? id,
|
|
String? name,
|
|
String? category,
|
|
int? stockQuantity,
|
|
int? lowStockThreshold,
|
|
bool? infiniteStock,
|
|
int? priceInCents,
|
|
Value<String?> imagePath = const Value.absent(),
|
|
bool? active,
|
|
}) => ProductRow(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
category: category ?? this.category,
|
|
stockQuantity: stockQuantity ?? this.stockQuantity,
|
|
lowStockThreshold: lowStockThreshold ?? this.lowStockThreshold,
|
|
infiniteStock: infiniteStock ?? this.infiniteStock,
|
|
priceInCents: priceInCents ?? this.priceInCents,
|
|
imagePath: imagePath.present ? imagePath.value : this.imagePath,
|
|
active: active ?? this.active,
|
|
);
|
|
ProductRow copyWithCompanion(ProductsCompanion data) {
|
|
return ProductRow(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
category: data.category.present ? data.category.value : this.category,
|
|
stockQuantity: data.stockQuantity.present
|
|
? data.stockQuantity.value
|
|
: this.stockQuantity,
|
|
lowStockThreshold: data.lowStockThreshold.present
|
|
? data.lowStockThreshold.value
|
|
: this.lowStockThreshold,
|
|
infiniteStock: data.infiniteStock.present
|
|
? data.infiniteStock.value
|
|
: this.infiniteStock,
|
|
priceInCents: data.priceInCents.present
|
|
? data.priceInCents.value
|
|
: this.priceInCents,
|
|
imagePath: data.imagePath.present ? data.imagePath.value : this.imagePath,
|
|
active: data.active.present ? data.active.value : this.active,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ProductRow(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('category: $category, ')
|
|
..write('stockQuantity: $stockQuantity, ')
|
|
..write('lowStockThreshold: $lowStockThreshold, ')
|
|
..write('infiniteStock: $infiniteStock, ')
|
|
..write('priceInCents: $priceInCents, ')
|
|
..write('imagePath: $imagePath, ')
|
|
..write('active: $active')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
name,
|
|
category,
|
|
stockQuantity,
|
|
lowStockThreshold,
|
|
infiniteStock,
|
|
priceInCents,
|
|
imagePath,
|
|
active,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is ProductRow &&
|
|
other.id == this.id &&
|
|
other.name == this.name &&
|
|
other.category == this.category &&
|
|
other.stockQuantity == this.stockQuantity &&
|
|
other.lowStockThreshold == this.lowStockThreshold &&
|
|
other.infiniteStock == this.infiniteStock &&
|
|
other.priceInCents == this.priceInCents &&
|
|
other.imagePath == this.imagePath &&
|
|
other.active == this.active);
|
|
}
|
|
|
|
class ProductsCompanion extends UpdateCompanion<ProductRow> {
|
|
final Value<String> id;
|
|
final Value<String> name;
|
|
final Value<String> category;
|
|
final Value<int> stockQuantity;
|
|
final Value<int> lowStockThreshold;
|
|
final Value<bool> infiniteStock;
|
|
final Value<int> priceInCents;
|
|
final Value<String?> imagePath;
|
|
final Value<bool> active;
|
|
final Value<int> rowid;
|
|
const ProductsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.category = const Value.absent(),
|
|
this.stockQuantity = const Value.absent(),
|
|
this.lowStockThreshold = const Value.absent(),
|
|
this.infiniteStock = const Value.absent(),
|
|
this.priceInCents = const Value.absent(),
|
|
this.imagePath = const Value.absent(),
|
|
this.active = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
ProductsCompanion.insert({
|
|
required String id,
|
|
required String name,
|
|
required String category,
|
|
required int stockQuantity,
|
|
required int lowStockThreshold,
|
|
this.infiniteStock = const Value.absent(),
|
|
required int priceInCents,
|
|
this.imagePath = const Value.absent(),
|
|
this.active = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
name = Value(name),
|
|
category = Value(category),
|
|
stockQuantity = Value(stockQuantity),
|
|
lowStockThreshold = Value(lowStockThreshold),
|
|
priceInCents = Value(priceInCents);
|
|
static Insertable<ProductRow> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? name,
|
|
Expression<String>? category,
|
|
Expression<int>? stockQuantity,
|
|
Expression<int>? lowStockThreshold,
|
|
Expression<bool>? infiniteStock,
|
|
Expression<int>? priceInCents,
|
|
Expression<String>? imagePath,
|
|
Expression<bool>? active,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (category != null) 'category': category,
|
|
if (stockQuantity != null) 'stock_quantity': stockQuantity,
|
|
if (lowStockThreshold != null) 'low_stock_threshold': lowStockThreshold,
|
|
if (infiniteStock != null) 'infinite_stock': infiniteStock,
|
|
if (priceInCents != null) 'price_in_cents': priceInCents,
|
|
if (imagePath != null) 'image_path': imagePath,
|
|
if (active != null) 'active': active,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
ProductsCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? name,
|
|
Value<String>? category,
|
|
Value<int>? stockQuantity,
|
|
Value<int>? lowStockThreshold,
|
|
Value<bool>? infiniteStock,
|
|
Value<int>? priceInCents,
|
|
Value<String?>? imagePath,
|
|
Value<bool>? active,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return ProductsCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
category: category ?? this.category,
|
|
stockQuantity: stockQuantity ?? this.stockQuantity,
|
|
lowStockThreshold: lowStockThreshold ?? this.lowStockThreshold,
|
|
infiniteStock: infiniteStock ?? this.infiniteStock,
|
|
priceInCents: priceInCents ?? this.priceInCents,
|
|
imagePath: imagePath ?? this.imagePath,
|
|
active: active ?? this.active,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (name.present) {
|
|
map['name'] = Variable<String>(name.value);
|
|
}
|
|
if (category.present) {
|
|
map['category'] = Variable<String>(category.value);
|
|
}
|
|
if (stockQuantity.present) {
|
|
map['stock_quantity'] = Variable<int>(stockQuantity.value);
|
|
}
|
|
if (lowStockThreshold.present) {
|
|
map['low_stock_threshold'] = Variable<int>(lowStockThreshold.value);
|
|
}
|
|
if (infiniteStock.present) {
|
|
map['infinite_stock'] = Variable<bool>(infiniteStock.value);
|
|
}
|
|
if (priceInCents.present) {
|
|
map['price_in_cents'] = Variable<int>(priceInCents.value);
|
|
}
|
|
if (imagePath.present) {
|
|
map['image_path'] = Variable<String>(imagePath.value);
|
|
}
|
|
if (active.present) {
|
|
map['active'] = Variable<bool>(active.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ProductsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('category: $category, ')
|
|
..write('stockQuantity: $stockQuantity, ')
|
|
..write('lowStockThreshold: $lowStockThreshold, ')
|
|
..write('infiniteStock: $infiniteStock, ')
|
|
..write('priceInCents: $priceInCents, ')
|
|
..write('imagePath: $imagePath, ')
|
|
..write('active: $active, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $BarTabsTable extends BarTabs with TableInfo<$BarTabsTable, BarTabRow> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$BarTabsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _customerNameMeta = const VerificationMeta(
|
|
'customerName',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> customerName = GeneratedColumn<String>(
|
|
'customer_name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _openedAtMeta = const VerificationMeta(
|
|
'openedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> openedAt = GeneratedColumn<DateTime>(
|
|
'opened_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _versionMeta = const VerificationMeta(
|
|
'version',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> version = GeneratedColumn<int>(
|
|
'version',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(0),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, customerName, openedAt, version];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'bar_tabs';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<BarTabRow> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_idMeta);
|
|
}
|
|
if (data.containsKey('customer_name')) {
|
|
context.handle(
|
|
_customerNameMeta,
|
|
customerName.isAcceptableOrUnknown(
|
|
data['customer_name']!,
|
|
_customerNameMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_customerNameMeta);
|
|
}
|
|
if (data.containsKey('opened_at')) {
|
|
context.handle(
|
|
_openedAtMeta,
|
|
openedAt.isAcceptableOrUnknown(data['opened_at']!, _openedAtMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_openedAtMeta);
|
|
}
|
|
if (data.containsKey('version')) {
|
|
context.handle(
|
|
_versionMeta,
|
|
version.isAcceptableOrUnknown(data['version']!, _versionMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
BarTabRow map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return BarTabRow(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
customerName: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}customer_name'],
|
|
)!,
|
|
openedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}opened_at'],
|
|
)!,
|
|
version: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}version'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$BarTabsTable createAlias(String alias) {
|
|
return $BarTabsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class BarTabRow extends DataClass implements Insertable<BarTabRow> {
|
|
final String id;
|
|
final String customerName;
|
|
final DateTime openedAt;
|
|
final int version;
|
|
const BarTabRow({
|
|
required this.id,
|
|
required this.customerName,
|
|
required this.openedAt,
|
|
required this.version,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['customer_name'] = Variable<String>(customerName);
|
|
map['opened_at'] = Variable<DateTime>(openedAt);
|
|
map['version'] = Variable<int>(version);
|
|
return map;
|
|
}
|
|
|
|
BarTabsCompanion toCompanion(bool nullToAbsent) {
|
|
return BarTabsCompanion(
|
|
id: Value(id),
|
|
customerName: Value(customerName),
|
|
openedAt: Value(openedAt),
|
|
version: Value(version),
|
|
);
|
|
}
|
|
|
|
factory BarTabRow.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return BarTabRow(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
customerName: serializer.fromJson<String>(json['customerName']),
|
|
openedAt: serializer.fromJson<DateTime>(json['openedAt']),
|
|
version: serializer.fromJson<int>(json['version']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'customerName': serializer.toJson<String>(customerName),
|
|
'openedAt': serializer.toJson<DateTime>(openedAt),
|
|
'version': serializer.toJson<int>(version),
|
|
};
|
|
}
|
|
|
|
BarTabRow copyWith({
|
|
String? id,
|
|
String? customerName,
|
|
DateTime? openedAt,
|
|
int? version,
|
|
}) => BarTabRow(
|
|
id: id ?? this.id,
|
|
customerName: customerName ?? this.customerName,
|
|
openedAt: openedAt ?? this.openedAt,
|
|
version: version ?? this.version,
|
|
);
|
|
BarTabRow copyWithCompanion(BarTabsCompanion data) {
|
|
return BarTabRow(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
customerName: data.customerName.present
|
|
? data.customerName.value
|
|
: this.customerName,
|
|
openedAt: data.openedAt.present ? data.openedAt.value : this.openedAt,
|
|
version: data.version.present ? data.version.value : this.version,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('BarTabRow(')
|
|
..write('id: $id, ')
|
|
..write('customerName: $customerName, ')
|
|
..write('openedAt: $openedAt, ')
|
|
..write('version: $version')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, customerName, openedAt, version);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is BarTabRow &&
|
|
other.id == this.id &&
|
|
other.customerName == this.customerName &&
|
|
other.openedAt == this.openedAt &&
|
|
other.version == this.version);
|
|
}
|
|
|
|
class BarTabsCompanion extends UpdateCompanion<BarTabRow> {
|
|
final Value<String> id;
|
|
final Value<String> customerName;
|
|
final Value<DateTime> openedAt;
|
|
final Value<int> version;
|
|
final Value<int> rowid;
|
|
const BarTabsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.customerName = const Value.absent(),
|
|
this.openedAt = const Value.absent(),
|
|
this.version = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
BarTabsCompanion.insert({
|
|
required String id,
|
|
required String customerName,
|
|
required DateTime openedAt,
|
|
this.version = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
customerName = Value(customerName),
|
|
openedAt = Value(openedAt);
|
|
static Insertable<BarTabRow> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? customerName,
|
|
Expression<DateTime>? openedAt,
|
|
Expression<int>? version,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (customerName != null) 'customer_name': customerName,
|
|
if (openedAt != null) 'opened_at': openedAt,
|
|
if (version != null) 'version': version,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
BarTabsCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? customerName,
|
|
Value<DateTime>? openedAt,
|
|
Value<int>? version,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return BarTabsCompanion(
|
|
id: id ?? this.id,
|
|
customerName: customerName ?? this.customerName,
|
|
openedAt: openedAt ?? this.openedAt,
|
|
version: version ?? this.version,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (customerName.present) {
|
|
map['customer_name'] = Variable<String>(customerName.value);
|
|
}
|
|
if (openedAt.present) {
|
|
map['opened_at'] = Variable<DateTime>(openedAt.value);
|
|
}
|
|
if (version.present) {
|
|
map['version'] = Variable<int>(version.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('BarTabsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('customerName: $customerName, ')
|
|
..write('openedAt: $openedAt, ')
|
|
..write('version: $version, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $TabItemsTable extends TabItems
|
|
with TableInfo<$TabItemsTable, TabItemRow> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$TabItemsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _tabIdMeta = const VerificationMeta('tabId');
|
|
@override
|
|
late final GeneratedColumn<String> tabId = GeneratedColumn<String>(
|
|
'tab_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES bar_tabs (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
static const VerificationMeta _productIdMeta = const VerificationMeta(
|
|
'productId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> productId = GeneratedColumn<String>(
|
|
'product_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES products (id)',
|
|
),
|
|
);
|
|
static const VerificationMeta _productNameMeta = const VerificationMeta(
|
|
'productName',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> productName = GeneratedColumn<String>(
|
|
'product_name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _quantityMeta = const VerificationMeta(
|
|
'quantity',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> quantity = GeneratedColumn<int>(
|
|
'quantity',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _unitPriceInCentsMeta = const VerificationMeta(
|
|
'unitPriceInCents',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> unitPriceInCents = GeneratedColumn<int>(
|
|
'unit_price_in_cents',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _createdAtMeta = const VerificationMeta(
|
|
'createdAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
tabId,
|
|
productId,
|
|
productName,
|
|
quantity,
|
|
unitPriceInCents,
|
|
createdAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'tab_items';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<TabItemRow> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_idMeta);
|
|
}
|
|
if (data.containsKey('tab_id')) {
|
|
context.handle(
|
|
_tabIdMeta,
|
|
tabId.isAcceptableOrUnknown(data['tab_id']!, _tabIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_tabIdMeta);
|
|
}
|
|
if (data.containsKey('product_id')) {
|
|
context.handle(
|
|
_productIdMeta,
|
|
productId.isAcceptableOrUnknown(data['product_id']!, _productIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_productIdMeta);
|
|
}
|
|
if (data.containsKey('product_name')) {
|
|
context.handle(
|
|
_productNameMeta,
|
|
productName.isAcceptableOrUnknown(
|
|
data['product_name']!,
|
|
_productNameMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_productNameMeta);
|
|
}
|
|
if (data.containsKey('quantity')) {
|
|
context.handle(
|
|
_quantityMeta,
|
|
quantity.isAcceptableOrUnknown(data['quantity']!, _quantityMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_quantityMeta);
|
|
}
|
|
if (data.containsKey('unit_price_in_cents')) {
|
|
context.handle(
|
|
_unitPriceInCentsMeta,
|
|
unitPriceInCents.isAcceptableOrUnknown(
|
|
data['unit_price_in_cents']!,
|
|
_unitPriceInCentsMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_unitPriceInCentsMeta);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_createdAtMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
TabItemRow map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return TabItemRow(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
tabId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}tab_id'],
|
|
)!,
|
|
productId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}product_id'],
|
|
)!,
|
|
productName: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}product_name'],
|
|
)!,
|
|
quantity: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}quantity'],
|
|
)!,
|
|
unitPriceInCents: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}unit_price_in_cents'],
|
|
)!,
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$TabItemsTable createAlias(String alias) {
|
|
return $TabItemsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class TabItemRow extends DataClass implements Insertable<TabItemRow> {
|
|
final String id;
|
|
final String tabId;
|
|
final String productId;
|
|
final String productName;
|
|
final int quantity;
|
|
final int unitPriceInCents;
|
|
final DateTime createdAt;
|
|
const TabItemRow({
|
|
required this.id,
|
|
required this.tabId,
|
|
required this.productId,
|
|
required this.productName,
|
|
required this.quantity,
|
|
required this.unitPriceInCents,
|
|
required this.createdAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['tab_id'] = Variable<String>(tabId);
|
|
map['product_id'] = Variable<String>(productId);
|
|
map['product_name'] = Variable<String>(productName);
|
|
map['quantity'] = Variable<int>(quantity);
|
|
map['unit_price_in_cents'] = Variable<int>(unitPriceInCents);
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
TabItemsCompanion toCompanion(bool nullToAbsent) {
|
|
return TabItemsCompanion(
|
|
id: Value(id),
|
|
tabId: Value(tabId),
|
|
productId: Value(productId),
|
|
productName: Value(productName),
|
|
quantity: Value(quantity),
|
|
unitPriceInCents: Value(unitPriceInCents),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory TabItemRow.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return TabItemRow(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
tabId: serializer.fromJson<String>(json['tabId']),
|
|
productId: serializer.fromJson<String>(json['productId']),
|
|
productName: serializer.fromJson<String>(json['productName']),
|
|
quantity: serializer.fromJson<int>(json['quantity']),
|
|
unitPriceInCents: serializer.fromJson<int>(json['unitPriceInCents']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'tabId': serializer.toJson<String>(tabId),
|
|
'productId': serializer.toJson<String>(productId),
|
|
'productName': serializer.toJson<String>(productName),
|
|
'quantity': serializer.toJson<int>(quantity),
|
|
'unitPriceInCents': serializer.toJson<int>(unitPriceInCents),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
TabItemRow copyWith({
|
|
String? id,
|
|
String? tabId,
|
|
String? productId,
|
|
String? productName,
|
|
int? quantity,
|
|
int? unitPriceInCents,
|
|
DateTime? createdAt,
|
|
}) => TabItemRow(
|
|
id: id ?? this.id,
|
|
tabId: tabId ?? this.tabId,
|
|
productId: productId ?? this.productId,
|
|
productName: productName ?? this.productName,
|
|
quantity: quantity ?? this.quantity,
|
|
unitPriceInCents: unitPriceInCents ?? this.unitPriceInCents,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
TabItemRow copyWithCompanion(TabItemsCompanion data) {
|
|
return TabItemRow(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
tabId: data.tabId.present ? data.tabId.value : this.tabId,
|
|
productId: data.productId.present ? data.productId.value : this.productId,
|
|
productName: data.productName.present
|
|
? data.productName.value
|
|
: this.productName,
|
|
quantity: data.quantity.present ? data.quantity.value : this.quantity,
|
|
unitPriceInCents: data.unitPriceInCents.present
|
|
? data.unitPriceInCents.value
|
|
: this.unitPriceInCents,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TabItemRow(')
|
|
..write('id: $id, ')
|
|
..write('tabId: $tabId, ')
|
|
..write('productId: $productId, ')
|
|
..write('productName: $productName, ')
|
|
..write('quantity: $quantity, ')
|
|
..write('unitPriceInCents: $unitPriceInCents, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
tabId,
|
|
productId,
|
|
productName,
|
|
quantity,
|
|
unitPriceInCents,
|
|
createdAt,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is TabItemRow &&
|
|
other.id == this.id &&
|
|
other.tabId == this.tabId &&
|
|
other.productId == this.productId &&
|
|
other.productName == this.productName &&
|
|
other.quantity == this.quantity &&
|
|
other.unitPriceInCents == this.unitPriceInCents &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class TabItemsCompanion extends UpdateCompanion<TabItemRow> {
|
|
final Value<String> id;
|
|
final Value<String> tabId;
|
|
final Value<String> productId;
|
|
final Value<String> productName;
|
|
final Value<int> quantity;
|
|
final Value<int> unitPriceInCents;
|
|
final Value<DateTime> createdAt;
|
|
final Value<int> rowid;
|
|
const TabItemsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.tabId = const Value.absent(),
|
|
this.productId = const Value.absent(),
|
|
this.productName = const Value.absent(),
|
|
this.quantity = const Value.absent(),
|
|
this.unitPriceInCents = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
TabItemsCompanion.insert({
|
|
required String id,
|
|
required String tabId,
|
|
required String productId,
|
|
required String productName,
|
|
required int quantity,
|
|
required int unitPriceInCents,
|
|
required DateTime createdAt,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
tabId = Value(tabId),
|
|
productId = Value(productId),
|
|
productName = Value(productName),
|
|
quantity = Value(quantity),
|
|
unitPriceInCents = Value(unitPriceInCents),
|
|
createdAt = Value(createdAt);
|
|
static Insertable<TabItemRow> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? tabId,
|
|
Expression<String>? productId,
|
|
Expression<String>? productName,
|
|
Expression<int>? quantity,
|
|
Expression<int>? unitPriceInCents,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (tabId != null) 'tab_id': tabId,
|
|
if (productId != null) 'product_id': productId,
|
|
if (productName != null) 'product_name': productName,
|
|
if (quantity != null) 'quantity': quantity,
|
|
if (unitPriceInCents != null) 'unit_price_in_cents': unitPriceInCents,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
TabItemsCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? tabId,
|
|
Value<String>? productId,
|
|
Value<String>? productName,
|
|
Value<int>? quantity,
|
|
Value<int>? unitPriceInCents,
|
|
Value<DateTime>? createdAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return TabItemsCompanion(
|
|
id: id ?? this.id,
|
|
tabId: tabId ?? this.tabId,
|
|
productId: productId ?? this.productId,
|
|
productName: productName ?? this.productName,
|
|
quantity: quantity ?? this.quantity,
|
|
unitPriceInCents: unitPriceInCents ?? this.unitPriceInCents,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (tabId.present) {
|
|
map['tab_id'] = Variable<String>(tabId.value);
|
|
}
|
|
if (productId.present) {
|
|
map['product_id'] = Variable<String>(productId.value);
|
|
}
|
|
if (productName.present) {
|
|
map['product_name'] = Variable<String>(productName.value);
|
|
}
|
|
if (quantity.present) {
|
|
map['quantity'] = Variable<int>(quantity.value);
|
|
}
|
|
if (unitPriceInCents.present) {
|
|
map['unit_price_in_cents'] = Variable<int>(unitPriceInCents.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TabItemsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('tabId: $tabId, ')
|
|
..write('productId: $productId, ')
|
|
..write('productName: $productName, ')
|
|
..write('quantity: $quantity, ')
|
|
..write('unitPriceInCents: $unitPriceInCents, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $TabItemPurchasesTable extends TabItemPurchases
|
|
with TableInfo<$TabItemPurchasesTable, TabItemPurchaseRow> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$TabItemPurchasesTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _tabItemIdMeta = const VerificationMeta(
|
|
'tabItemId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> tabItemId = GeneratedColumn<String>(
|
|
'tab_item_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES tab_items (id) ON DELETE CASCADE',
|
|
),
|
|
);
|
|
static const VerificationMeta _purchasedAtMeta = const VerificationMeta(
|
|
'purchasedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> purchasedAt = GeneratedColumn<DateTime>(
|
|
'purchased_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _removedAtMeta = const VerificationMeta(
|
|
'removedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> removedAt = GeneratedColumn<DateTime>(
|
|
'removed_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, tabItemId, purchasedAt, removedAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'tab_item_purchases';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<TabItemPurchaseRow> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_idMeta);
|
|
}
|
|
if (data.containsKey('tab_item_id')) {
|
|
context.handle(
|
|
_tabItemIdMeta,
|
|
tabItemId.isAcceptableOrUnknown(data['tab_item_id']!, _tabItemIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_tabItemIdMeta);
|
|
}
|
|
if (data.containsKey('purchased_at')) {
|
|
context.handle(
|
|
_purchasedAtMeta,
|
|
purchasedAt.isAcceptableOrUnknown(
|
|
data['purchased_at']!,
|
|
_purchasedAtMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_purchasedAtMeta);
|
|
}
|
|
if (data.containsKey('removed_at')) {
|
|
context.handle(
|
|
_removedAtMeta,
|
|
removedAt.isAcceptableOrUnknown(data['removed_at']!, _removedAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
TabItemPurchaseRow map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return TabItemPurchaseRow(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
tabItemId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}tab_item_id'],
|
|
)!,
|
|
purchasedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}purchased_at'],
|
|
)!,
|
|
removedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}removed_at'],
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$TabItemPurchasesTable createAlias(String alias) {
|
|
return $TabItemPurchasesTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class TabItemPurchaseRow extends DataClass
|
|
implements Insertable<TabItemPurchaseRow> {
|
|
final String id;
|
|
final String tabItemId;
|
|
final DateTime purchasedAt;
|
|
final DateTime? removedAt;
|
|
const TabItemPurchaseRow({
|
|
required this.id,
|
|
required this.tabItemId,
|
|
required this.purchasedAt,
|
|
this.removedAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['tab_item_id'] = Variable<String>(tabItemId);
|
|
map['purchased_at'] = Variable<DateTime>(purchasedAt);
|
|
if (!nullToAbsent || removedAt != null) {
|
|
map['removed_at'] = Variable<DateTime>(removedAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
TabItemPurchasesCompanion toCompanion(bool nullToAbsent) {
|
|
return TabItemPurchasesCompanion(
|
|
id: Value(id),
|
|
tabItemId: Value(tabItemId),
|
|
purchasedAt: Value(purchasedAt),
|
|
removedAt: removedAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(removedAt),
|
|
);
|
|
}
|
|
|
|
factory TabItemPurchaseRow.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return TabItemPurchaseRow(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
tabItemId: serializer.fromJson<String>(json['tabItemId']),
|
|
purchasedAt: serializer.fromJson<DateTime>(json['purchasedAt']),
|
|
removedAt: serializer.fromJson<DateTime?>(json['removedAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'tabItemId': serializer.toJson<String>(tabItemId),
|
|
'purchasedAt': serializer.toJson<DateTime>(purchasedAt),
|
|
'removedAt': serializer.toJson<DateTime?>(removedAt),
|
|
};
|
|
}
|
|
|
|
TabItemPurchaseRow copyWith({
|
|
String? id,
|
|
String? tabItemId,
|
|
DateTime? purchasedAt,
|
|
Value<DateTime?> removedAt = const Value.absent(),
|
|
}) => TabItemPurchaseRow(
|
|
id: id ?? this.id,
|
|
tabItemId: tabItemId ?? this.tabItemId,
|
|
purchasedAt: purchasedAt ?? this.purchasedAt,
|
|
removedAt: removedAt.present ? removedAt.value : this.removedAt,
|
|
);
|
|
TabItemPurchaseRow copyWithCompanion(TabItemPurchasesCompanion data) {
|
|
return TabItemPurchaseRow(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
tabItemId: data.tabItemId.present ? data.tabItemId.value : this.tabItemId,
|
|
purchasedAt: data.purchasedAt.present
|
|
? data.purchasedAt.value
|
|
: this.purchasedAt,
|
|
removedAt: data.removedAt.present ? data.removedAt.value : this.removedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TabItemPurchaseRow(')
|
|
..write('id: $id, ')
|
|
..write('tabItemId: $tabItemId, ')
|
|
..write('purchasedAt: $purchasedAt, ')
|
|
..write('removedAt: $removedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, tabItemId, purchasedAt, removedAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is TabItemPurchaseRow &&
|
|
other.id == this.id &&
|
|
other.tabItemId == this.tabItemId &&
|
|
other.purchasedAt == this.purchasedAt &&
|
|
other.removedAt == this.removedAt);
|
|
}
|
|
|
|
class TabItemPurchasesCompanion extends UpdateCompanion<TabItemPurchaseRow> {
|
|
final Value<String> id;
|
|
final Value<String> tabItemId;
|
|
final Value<DateTime> purchasedAt;
|
|
final Value<DateTime?> removedAt;
|
|
final Value<int> rowid;
|
|
const TabItemPurchasesCompanion({
|
|
this.id = const Value.absent(),
|
|
this.tabItemId = const Value.absent(),
|
|
this.purchasedAt = const Value.absent(),
|
|
this.removedAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
TabItemPurchasesCompanion.insert({
|
|
required String id,
|
|
required String tabItemId,
|
|
required DateTime purchasedAt,
|
|
this.removedAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
tabItemId = Value(tabItemId),
|
|
purchasedAt = Value(purchasedAt);
|
|
static Insertable<TabItemPurchaseRow> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? tabItemId,
|
|
Expression<DateTime>? purchasedAt,
|
|
Expression<DateTime>? removedAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (tabItemId != null) 'tab_item_id': tabItemId,
|
|
if (purchasedAt != null) 'purchased_at': purchasedAt,
|
|
if (removedAt != null) 'removed_at': removedAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
TabItemPurchasesCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? tabItemId,
|
|
Value<DateTime>? purchasedAt,
|
|
Value<DateTime?>? removedAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return TabItemPurchasesCompanion(
|
|
id: id ?? this.id,
|
|
tabItemId: tabItemId ?? this.tabItemId,
|
|
purchasedAt: purchasedAt ?? this.purchasedAt,
|
|
removedAt: removedAt ?? this.removedAt,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (tabItemId.present) {
|
|
map['tab_item_id'] = Variable<String>(tabItemId.value);
|
|
}
|
|
if (purchasedAt.present) {
|
|
map['purchased_at'] = Variable<DateTime>(purchasedAt.value);
|
|
}
|
|
if (removedAt.present) {
|
|
map['removed_at'] = Variable<DateTime>(removedAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TabItemPurchasesCompanion(')
|
|
..write('id: $id, ')
|
|
..write('tabItemId: $tabItemId, ')
|
|
..write('purchasedAt: $purchasedAt, ')
|
|
..write('removedAt: $removedAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ClosedTabsTable extends ClosedTabs
|
|
with TableInfo<$ClosedTabsTable, ClosedTabsRow> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ClosedTabsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _originalTabIdMeta = const VerificationMeta(
|
|
'originalTabId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> originalTabId = GeneratedColumn<String>(
|
|
'original_tab_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _customerNameMeta = const VerificationMeta(
|
|
'customerName',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> customerName = GeneratedColumn<String>(
|
|
'customer_name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _closedAtMeta = const VerificationMeta(
|
|
'closedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> closedAt = GeneratedColumn<DateTime>(
|
|
'closed_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
late final GeneratedColumnWithTypeConverter<PaymentMethod, String>
|
|
paymentMethod = GeneratedColumn<String>(
|
|
'payment_method',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant('cash'),
|
|
).withConverter<PaymentMethod>($ClosedTabsTable.$converterpaymentMethod);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
originalTabId,
|
|
customerName,
|
|
closedAt,
|
|
paymentMethod,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'closed_tabs';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<ClosedTabsRow> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_idMeta);
|
|
}
|
|
if (data.containsKey('original_tab_id')) {
|
|
context.handle(
|
|
_originalTabIdMeta,
|
|
originalTabId.isAcceptableOrUnknown(
|
|
data['original_tab_id']!,
|
|
_originalTabIdMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_originalTabIdMeta);
|
|
}
|
|
if (data.containsKey('customer_name')) {
|
|
context.handle(
|
|
_customerNameMeta,
|
|
customerName.isAcceptableOrUnknown(
|
|
data['customer_name']!,
|
|
_customerNameMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_customerNameMeta);
|
|
}
|
|
if (data.containsKey('closed_at')) {
|
|
context.handle(
|
|
_closedAtMeta,
|
|
closedAt.isAcceptableOrUnknown(data['closed_at']!, _closedAtMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_closedAtMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
ClosedTabsRow map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ClosedTabsRow(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
originalTabId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}original_tab_id'],
|
|
)!,
|
|
customerName: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}customer_name'],
|
|
)!,
|
|
closedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}closed_at'],
|
|
)!,
|
|
paymentMethod: $ClosedTabsTable.$converterpaymentMethod.fromSql(
|
|
attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}payment_method'],
|
|
)!,
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ClosedTabsTable createAlias(String alias) {
|
|
return $ClosedTabsTable(attachedDatabase, alias);
|
|
}
|
|
|
|
static TypeConverter<PaymentMethod, String> $converterpaymentMethod =
|
|
const PaymentMethodConverter();
|
|
}
|
|
|
|
class ClosedTabsRow extends DataClass implements Insertable<ClosedTabsRow> {
|
|
final String id;
|
|
final String originalTabId;
|
|
final String customerName;
|
|
final DateTime closedAt;
|
|
final PaymentMethod paymentMethod;
|
|
const ClosedTabsRow({
|
|
required this.id,
|
|
required this.originalTabId,
|
|
required this.customerName,
|
|
required this.closedAt,
|
|
required this.paymentMethod,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['original_tab_id'] = Variable<String>(originalTabId);
|
|
map['customer_name'] = Variable<String>(customerName);
|
|
map['closed_at'] = Variable<DateTime>(closedAt);
|
|
{
|
|
map['payment_method'] = Variable<String>(
|
|
$ClosedTabsTable.$converterpaymentMethod.toSql(paymentMethod),
|
|
);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
ClosedTabsCompanion toCompanion(bool nullToAbsent) {
|
|
return ClosedTabsCompanion(
|
|
id: Value(id),
|
|
originalTabId: Value(originalTabId),
|
|
customerName: Value(customerName),
|
|
closedAt: Value(closedAt),
|
|
paymentMethod: Value(paymentMethod),
|
|
);
|
|
}
|
|
|
|
factory ClosedTabsRow.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return ClosedTabsRow(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
originalTabId: serializer.fromJson<String>(json['originalTabId']),
|
|
customerName: serializer.fromJson<String>(json['customerName']),
|
|
closedAt: serializer.fromJson<DateTime>(json['closedAt']),
|
|
paymentMethod: serializer.fromJson<PaymentMethod>(json['paymentMethod']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'originalTabId': serializer.toJson<String>(originalTabId),
|
|
'customerName': serializer.toJson<String>(customerName),
|
|
'closedAt': serializer.toJson<DateTime>(closedAt),
|
|
'paymentMethod': serializer.toJson<PaymentMethod>(paymentMethod),
|
|
};
|
|
}
|
|
|
|
ClosedTabsRow copyWith({
|
|
String? id,
|
|
String? originalTabId,
|
|
String? customerName,
|
|
DateTime? closedAt,
|
|
PaymentMethod? paymentMethod,
|
|
}) => ClosedTabsRow(
|
|
id: id ?? this.id,
|
|
originalTabId: originalTabId ?? this.originalTabId,
|
|
customerName: customerName ?? this.customerName,
|
|
closedAt: closedAt ?? this.closedAt,
|
|
paymentMethod: paymentMethod ?? this.paymentMethod,
|
|
);
|
|
ClosedTabsRow copyWithCompanion(ClosedTabsCompanion data) {
|
|
return ClosedTabsRow(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
originalTabId: data.originalTabId.present
|
|
? data.originalTabId.value
|
|
: this.originalTabId,
|
|
customerName: data.customerName.present
|
|
? data.customerName.value
|
|
: this.customerName,
|
|
closedAt: data.closedAt.present ? data.closedAt.value : this.closedAt,
|
|
paymentMethod: data.paymentMethod.present
|
|
? data.paymentMethod.value
|
|
: this.paymentMethod,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ClosedTabsRow(')
|
|
..write('id: $id, ')
|
|
..write('originalTabId: $originalTabId, ')
|
|
..write('customerName: $customerName, ')
|
|
..write('closedAt: $closedAt, ')
|
|
..write('paymentMethod: $paymentMethod')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(id, originalTabId, customerName, closedAt, paymentMethod);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is ClosedTabsRow &&
|
|
other.id == this.id &&
|
|
other.originalTabId == this.originalTabId &&
|
|
other.customerName == this.customerName &&
|
|
other.closedAt == this.closedAt &&
|
|
other.paymentMethod == this.paymentMethod);
|
|
}
|
|
|
|
class ClosedTabsCompanion extends UpdateCompanion<ClosedTabsRow> {
|
|
final Value<String> id;
|
|
final Value<String> originalTabId;
|
|
final Value<String> customerName;
|
|
final Value<DateTime> closedAt;
|
|
final Value<PaymentMethod> paymentMethod;
|
|
final Value<int> rowid;
|
|
const ClosedTabsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.originalTabId = const Value.absent(),
|
|
this.customerName = const Value.absent(),
|
|
this.closedAt = const Value.absent(),
|
|
this.paymentMethod = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
ClosedTabsCompanion.insert({
|
|
required String id,
|
|
required String originalTabId,
|
|
required String customerName,
|
|
required DateTime closedAt,
|
|
this.paymentMethod = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
originalTabId = Value(originalTabId),
|
|
customerName = Value(customerName),
|
|
closedAt = Value(closedAt);
|
|
static Insertable<ClosedTabsRow> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? originalTabId,
|
|
Expression<String>? customerName,
|
|
Expression<DateTime>? closedAt,
|
|
Expression<String>? paymentMethod,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (originalTabId != null) 'original_tab_id': originalTabId,
|
|
if (customerName != null) 'customer_name': customerName,
|
|
if (closedAt != null) 'closed_at': closedAt,
|
|
if (paymentMethod != null) 'payment_method': paymentMethod,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
ClosedTabsCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? originalTabId,
|
|
Value<String>? customerName,
|
|
Value<DateTime>? closedAt,
|
|
Value<PaymentMethod>? paymentMethod,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return ClosedTabsCompanion(
|
|
id: id ?? this.id,
|
|
originalTabId: originalTabId ?? this.originalTabId,
|
|
customerName: customerName ?? this.customerName,
|
|
closedAt: closedAt ?? this.closedAt,
|
|
paymentMethod: paymentMethod ?? this.paymentMethod,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (originalTabId.present) {
|
|
map['original_tab_id'] = Variable<String>(originalTabId.value);
|
|
}
|
|
if (customerName.present) {
|
|
map['customer_name'] = Variable<String>(customerName.value);
|
|
}
|
|
if (closedAt.present) {
|
|
map['closed_at'] = Variable<DateTime>(closedAt.value);
|
|
}
|
|
if (paymentMethod.present) {
|
|
map['payment_method'] = Variable<String>(
|
|
$ClosedTabsTable.$converterpaymentMethod.toSql(paymentMethod.value),
|
|
);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ClosedTabsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('originalTabId: $originalTabId, ')
|
|
..write('customerName: $customerName, ')
|
|
..write('closedAt: $closedAt, ')
|
|
..write('paymentMethod: $paymentMethod, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ClosedTabItemsTable extends ClosedTabItems
|
|
with TableInfo<$ClosedTabItemsTable, ClosedTabItemRow> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ClosedTabItemsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _closedTabIdMeta = const VerificationMeta(
|
|
'closedTabId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> closedTabId = GeneratedColumn<String>(
|
|
'closed_tab_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _productIdMeta = const VerificationMeta(
|
|
'productId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> productId = GeneratedColumn<String>(
|
|
'product_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _productNameMeta = const VerificationMeta(
|
|
'productName',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> productName = GeneratedColumn<String>(
|
|
'product_name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _quantityMeta = const VerificationMeta(
|
|
'quantity',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> quantity = GeneratedColumn<int>(
|
|
'quantity',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _unitPriceInCentsMeta = const VerificationMeta(
|
|
'unitPriceInCents',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> unitPriceInCents = GeneratedColumn<int>(
|
|
'unit_price_in_cents',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _purchasedAtMeta = const VerificationMeta(
|
|
'purchasedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> purchasedAt = GeneratedColumn<DateTime>(
|
|
'purchased_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _removedAtMeta = const VerificationMeta(
|
|
'removedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> removedAt = GeneratedColumn<DateTime>(
|
|
'removed_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
closedTabId,
|
|
productId,
|
|
productName,
|
|
quantity,
|
|
unitPriceInCents,
|
|
purchasedAt,
|
|
removedAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'closed_tab_items';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<ClosedTabItemRow> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_idMeta);
|
|
}
|
|
if (data.containsKey('closed_tab_id')) {
|
|
context.handle(
|
|
_closedTabIdMeta,
|
|
closedTabId.isAcceptableOrUnknown(
|
|
data['closed_tab_id']!,
|
|
_closedTabIdMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_closedTabIdMeta);
|
|
}
|
|
if (data.containsKey('product_id')) {
|
|
context.handle(
|
|
_productIdMeta,
|
|
productId.isAcceptableOrUnknown(data['product_id']!, _productIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_productIdMeta);
|
|
}
|
|
if (data.containsKey('product_name')) {
|
|
context.handle(
|
|
_productNameMeta,
|
|
productName.isAcceptableOrUnknown(
|
|
data['product_name']!,
|
|
_productNameMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_productNameMeta);
|
|
}
|
|
if (data.containsKey('quantity')) {
|
|
context.handle(
|
|
_quantityMeta,
|
|
quantity.isAcceptableOrUnknown(data['quantity']!, _quantityMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_quantityMeta);
|
|
}
|
|
if (data.containsKey('unit_price_in_cents')) {
|
|
context.handle(
|
|
_unitPriceInCentsMeta,
|
|
unitPriceInCents.isAcceptableOrUnknown(
|
|
data['unit_price_in_cents']!,
|
|
_unitPriceInCentsMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_unitPriceInCentsMeta);
|
|
}
|
|
if (data.containsKey('purchased_at')) {
|
|
context.handle(
|
|
_purchasedAtMeta,
|
|
purchasedAt.isAcceptableOrUnknown(
|
|
data['purchased_at']!,
|
|
_purchasedAtMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('removed_at')) {
|
|
context.handle(
|
|
_removedAtMeta,
|
|
removedAt.isAcceptableOrUnknown(data['removed_at']!, _removedAtMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
ClosedTabItemRow map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ClosedTabItemRow(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
closedTabId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}closed_tab_id'],
|
|
)!,
|
|
productId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}product_id'],
|
|
)!,
|
|
productName: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}product_name'],
|
|
)!,
|
|
quantity: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}quantity'],
|
|
)!,
|
|
unitPriceInCents: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}unit_price_in_cents'],
|
|
)!,
|
|
purchasedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}purchased_at'],
|
|
),
|
|
removedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}removed_at'],
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ClosedTabItemsTable createAlias(String alias) {
|
|
return $ClosedTabItemsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class ClosedTabItemRow extends DataClass
|
|
implements Insertable<ClosedTabItemRow> {
|
|
final String id;
|
|
final String closedTabId;
|
|
final String productId;
|
|
final String productName;
|
|
final int quantity;
|
|
final int unitPriceInCents;
|
|
final DateTime? purchasedAt;
|
|
final DateTime? removedAt;
|
|
const ClosedTabItemRow({
|
|
required this.id,
|
|
required this.closedTabId,
|
|
required this.productId,
|
|
required this.productName,
|
|
required this.quantity,
|
|
required this.unitPriceInCents,
|
|
this.purchasedAt,
|
|
this.removedAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['closed_tab_id'] = Variable<String>(closedTabId);
|
|
map['product_id'] = Variable<String>(productId);
|
|
map['product_name'] = Variable<String>(productName);
|
|
map['quantity'] = Variable<int>(quantity);
|
|
map['unit_price_in_cents'] = Variable<int>(unitPriceInCents);
|
|
if (!nullToAbsent || purchasedAt != null) {
|
|
map['purchased_at'] = Variable<DateTime>(purchasedAt);
|
|
}
|
|
if (!nullToAbsent || removedAt != null) {
|
|
map['removed_at'] = Variable<DateTime>(removedAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
ClosedTabItemsCompanion toCompanion(bool nullToAbsent) {
|
|
return ClosedTabItemsCompanion(
|
|
id: Value(id),
|
|
closedTabId: Value(closedTabId),
|
|
productId: Value(productId),
|
|
productName: Value(productName),
|
|
quantity: Value(quantity),
|
|
unitPriceInCents: Value(unitPriceInCents),
|
|
purchasedAt: purchasedAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(purchasedAt),
|
|
removedAt: removedAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(removedAt),
|
|
);
|
|
}
|
|
|
|
factory ClosedTabItemRow.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return ClosedTabItemRow(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
closedTabId: serializer.fromJson<String>(json['closedTabId']),
|
|
productId: serializer.fromJson<String>(json['productId']),
|
|
productName: serializer.fromJson<String>(json['productName']),
|
|
quantity: serializer.fromJson<int>(json['quantity']),
|
|
unitPriceInCents: serializer.fromJson<int>(json['unitPriceInCents']),
|
|
purchasedAt: serializer.fromJson<DateTime?>(json['purchasedAt']),
|
|
removedAt: serializer.fromJson<DateTime?>(json['removedAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'closedTabId': serializer.toJson<String>(closedTabId),
|
|
'productId': serializer.toJson<String>(productId),
|
|
'productName': serializer.toJson<String>(productName),
|
|
'quantity': serializer.toJson<int>(quantity),
|
|
'unitPriceInCents': serializer.toJson<int>(unitPriceInCents),
|
|
'purchasedAt': serializer.toJson<DateTime?>(purchasedAt),
|
|
'removedAt': serializer.toJson<DateTime?>(removedAt),
|
|
};
|
|
}
|
|
|
|
ClosedTabItemRow copyWith({
|
|
String? id,
|
|
String? closedTabId,
|
|
String? productId,
|
|
String? productName,
|
|
int? quantity,
|
|
int? unitPriceInCents,
|
|
Value<DateTime?> purchasedAt = const Value.absent(),
|
|
Value<DateTime?> removedAt = const Value.absent(),
|
|
}) => ClosedTabItemRow(
|
|
id: id ?? this.id,
|
|
closedTabId: closedTabId ?? this.closedTabId,
|
|
productId: productId ?? this.productId,
|
|
productName: productName ?? this.productName,
|
|
quantity: quantity ?? this.quantity,
|
|
unitPriceInCents: unitPriceInCents ?? this.unitPriceInCents,
|
|
purchasedAt: purchasedAt.present ? purchasedAt.value : this.purchasedAt,
|
|
removedAt: removedAt.present ? removedAt.value : this.removedAt,
|
|
);
|
|
ClosedTabItemRow copyWithCompanion(ClosedTabItemsCompanion data) {
|
|
return ClosedTabItemRow(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
closedTabId: data.closedTabId.present
|
|
? data.closedTabId.value
|
|
: this.closedTabId,
|
|
productId: data.productId.present ? data.productId.value : this.productId,
|
|
productName: data.productName.present
|
|
? data.productName.value
|
|
: this.productName,
|
|
quantity: data.quantity.present ? data.quantity.value : this.quantity,
|
|
unitPriceInCents: data.unitPriceInCents.present
|
|
? data.unitPriceInCents.value
|
|
: this.unitPriceInCents,
|
|
purchasedAt: data.purchasedAt.present
|
|
? data.purchasedAt.value
|
|
: this.purchasedAt,
|
|
removedAt: data.removedAt.present ? data.removedAt.value : this.removedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ClosedTabItemRow(')
|
|
..write('id: $id, ')
|
|
..write('closedTabId: $closedTabId, ')
|
|
..write('productId: $productId, ')
|
|
..write('productName: $productName, ')
|
|
..write('quantity: $quantity, ')
|
|
..write('unitPriceInCents: $unitPriceInCents, ')
|
|
..write('purchasedAt: $purchasedAt, ')
|
|
..write('removedAt: $removedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
closedTabId,
|
|
productId,
|
|
productName,
|
|
quantity,
|
|
unitPriceInCents,
|
|
purchasedAt,
|
|
removedAt,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is ClosedTabItemRow &&
|
|
other.id == this.id &&
|
|
other.closedTabId == this.closedTabId &&
|
|
other.productId == this.productId &&
|
|
other.productName == this.productName &&
|
|
other.quantity == this.quantity &&
|
|
other.unitPriceInCents == this.unitPriceInCents &&
|
|
other.purchasedAt == this.purchasedAt &&
|
|
other.removedAt == this.removedAt);
|
|
}
|
|
|
|
class ClosedTabItemsCompanion extends UpdateCompanion<ClosedTabItemRow> {
|
|
final Value<String> id;
|
|
final Value<String> closedTabId;
|
|
final Value<String> productId;
|
|
final Value<String> productName;
|
|
final Value<int> quantity;
|
|
final Value<int> unitPriceInCents;
|
|
final Value<DateTime?> purchasedAt;
|
|
final Value<DateTime?> removedAt;
|
|
final Value<int> rowid;
|
|
const ClosedTabItemsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.closedTabId = const Value.absent(),
|
|
this.productId = const Value.absent(),
|
|
this.productName = const Value.absent(),
|
|
this.quantity = const Value.absent(),
|
|
this.unitPriceInCents = const Value.absent(),
|
|
this.purchasedAt = const Value.absent(),
|
|
this.removedAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
ClosedTabItemsCompanion.insert({
|
|
required String id,
|
|
required String closedTabId,
|
|
required String productId,
|
|
required String productName,
|
|
required int quantity,
|
|
required int unitPriceInCents,
|
|
this.purchasedAt = const Value.absent(),
|
|
this.removedAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
closedTabId = Value(closedTabId),
|
|
productId = Value(productId),
|
|
productName = Value(productName),
|
|
quantity = Value(quantity),
|
|
unitPriceInCents = Value(unitPriceInCents);
|
|
static Insertable<ClosedTabItemRow> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? closedTabId,
|
|
Expression<String>? productId,
|
|
Expression<String>? productName,
|
|
Expression<int>? quantity,
|
|
Expression<int>? unitPriceInCents,
|
|
Expression<DateTime>? purchasedAt,
|
|
Expression<DateTime>? removedAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (closedTabId != null) 'closed_tab_id': closedTabId,
|
|
if (productId != null) 'product_id': productId,
|
|
if (productName != null) 'product_name': productName,
|
|
if (quantity != null) 'quantity': quantity,
|
|
if (unitPriceInCents != null) 'unit_price_in_cents': unitPriceInCents,
|
|
if (purchasedAt != null) 'purchased_at': purchasedAt,
|
|
if (removedAt != null) 'removed_at': removedAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
ClosedTabItemsCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? closedTabId,
|
|
Value<String>? productId,
|
|
Value<String>? productName,
|
|
Value<int>? quantity,
|
|
Value<int>? unitPriceInCents,
|
|
Value<DateTime?>? purchasedAt,
|
|
Value<DateTime?>? removedAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return ClosedTabItemsCompanion(
|
|
id: id ?? this.id,
|
|
closedTabId: closedTabId ?? this.closedTabId,
|
|
productId: productId ?? this.productId,
|
|
productName: productName ?? this.productName,
|
|
quantity: quantity ?? this.quantity,
|
|
unitPriceInCents: unitPriceInCents ?? this.unitPriceInCents,
|
|
purchasedAt: purchasedAt ?? this.purchasedAt,
|
|
removedAt: removedAt ?? this.removedAt,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (closedTabId.present) {
|
|
map['closed_tab_id'] = Variable<String>(closedTabId.value);
|
|
}
|
|
if (productId.present) {
|
|
map['product_id'] = Variable<String>(productId.value);
|
|
}
|
|
if (productName.present) {
|
|
map['product_name'] = Variable<String>(productName.value);
|
|
}
|
|
if (quantity.present) {
|
|
map['quantity'] = Variable<int>(quantity.value);
|
|
}
|
|
if (unitPriceInCents.present) {
|
|
map['unit_price_in_cents'] = Variable<int>(unitPriceInCents.value);
|
|
}
|
|
if (purchasedAt.present) {
|
|
map['purchased_at'] = Variable<DateTime>(purchasedAt.value);
|
|
}
|
|
if (removedAt.present) {
|
|
map['removed_at'] = Variable<DateTime>(removedAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ClosedTabItemsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('closedTabId: $closedTabId, ')
|
|
..write('productId: $productId, ')
|
|
..write('productName: $productName, ')
|
|
..write('quantity: $quantity, ')
|
|
..write('unitPriceInCents: $unitPriceInCents, ')
|
|
..write('purchasedAt: $purchasedAt, ')
|
|
..write('removedAt: $removedAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $AppSettingsTableTable extends AppSettingsTable
|
|
with TableInfo<$AppSettingsTableTable, AppSettingsRow> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$AppSettingsTableTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _pinRequiredMeta = const VerificationMeta(
|
|
'pinRequired',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<bool> pinRequired = GeneratedColumn<bool>(
|
|
'pin_required',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.bool,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'CHECK ("pin_required" IN (0, 1))',
|
|
),
|
|
defaultValue: const Constant(false),
|
|
);
|
|
static const VerificationMeta _autoLockEnabledMeta = const VerificationMeta(
|
|
'autoLockEnabled',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<bool> autoLockEnabled = GeneratedColumn<bool>(
|
|
'auto_lock_enabled',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.bool,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'CHECK ("auto_lock_enabled" IN (0, 1))',
|
|
),
|
|
defaultValue: const Constant(true),
|
|
);
|
|
static const VerificationMeta _themeModeMeta = const VerificationMeta(
|
|
'themeMode',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> themeMode = GeneratedColumn<String>(
|
|
'theme_mode',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant('system'),
|
|
);
|
|
static const VerificationMeta _languageMeta = const VerificationMeta(
|
|
'language',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> language = GeneratedColumn<String>(
|
|
'language',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant('system'),
|
|
);
|
|
static const VerificationMeta _barGridRowsMeta = const VerificationMeta(
|
|
'barGridRows',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> barGridRows = GeneratedColumn<int>(
|
|
'bar_grid_rows',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(3),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
pinRequired,
|
|
autoLockEnabled,
|
|
themeMode,
|
|
language,
|
|
barGridRows,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'app_settings';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<AppSettingsRow> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_idMeta);
|
|
}
|
|
if (data.containsKey('pin_required')) {
|
|
context.handle(
|
|
_pinRequiredMeta,
|
|
pinRequired.isAcceptableOrUnknown(
|
|
data['pin_required']!,
|
|
_pinRequiredMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('auto_lock_enabled')) {
|
|
context.handle(
|
|
_autoLockEnabledMeta,
|
|
autoLockEnabled.isAcceptableOrUnknown(
|
|
data['auto_lock_enabled']!,
|
|
_autoLockEnabledMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('theme_mode')) {
|
|
context.handle(
|
|
_themeModeMeta,
|
|
themeMode.isAcceptableOrUnknown(data['theme_mode']!, _themeModeMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('language')) {
|
|
context.handle(
|
|
_languageMeta,
|
|
language.isAcceptableOrUnknown(data['language']!, _languageMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('bar_grid_rows')) {
|
|
context.handle(
|
|
_barGridRowsMeta,
|
|
barGridRows.isAcceptableOrUnknown(
|
|
data['bar_grid_rows']!,
|
|
_barGridRowsMeta,
|
|
),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
AppSettingsRow map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return AppSettingsRow(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
pinRequired: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.bool,
|
|
data['${effectivePrefix}pin_required'],
|
|
)!,
|
|
autoLockEnabled: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.bool,
|
|
data['${effectivePrefix}auto_lock_enabled'],
|
|
)!,
|
|
themeMode: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}theme_mode'],
|
|
)!,
|
|
language: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}language'],
|
|
)!,
|
|
barGridRows: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}bar_grid_rows'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$AppSettingsTableTable createAlias(String alias) {
|
|
return $AppSettingsTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class AppSettingsRow extends DataClass implements Insertable<AppSettingsRow> {
|
|
final String id;
|
|
final bool pinRequired;
|
|
final bool autoLockEnabled;
|
|
final String themeMode;
|
|
final String language;
|
|
final int barGridRows;
|
|
const AppSettingsRow({
|
|
required this.id,
|
|
required this.pinRequired,
|
|
required this.autoLockEnabled,
|
|
required this.themeMode,
|
|
required this.language,
|
|
required this.barGridRows,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['pin_required'] = Variable<bool>(pinRequired);
|
|
map['auto_lock_enabled'] = Variable<bool>(autoLockEnabled);
|
|
map['theme_mode'] = Variable<String>(themeMode);
|
|
map['language'] = Variable<String>(language);
|
|
map['bar_grid_rows'] = Variable<int>(barGridRows);
|
|
return map;
|
|
}
|
|
|
|
AppSettingsTableCompanion toCompanion(bool nullToAbsent) {
|
|
return AppSettingsTableCompanion(
|
|
id: Value(id),
|
|
pinRequired: Value(pinRequired),
|
|
autoLockEnabled: Value(autoLockEnabled),
|
|
themeMode: Value(themeMode),
|
|
language: Value(language),
|
|
barGridRows: Value(barGridRows),
|
|
);
|
|
}
|
|
|
|
factory AppSettingsRow.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return AppSettingsRow(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
pinRequired: serializer.fromJson<bool>(json['pinRequired']),
|
|
autoLockEnabled: serializer.fromJson<bool>(json['autoLockEnabled']),
|
|
themeMode: serializer.fromJson<String>(json['themeMode']),
|
|
language: serializer.fromJson<String>(json['language']),
|
|
barGridRows: serializer.fromJson<int>(json['barGridRows']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'pinRequired': serializer.toJson<bool>(pinRequired),
|
|
'autoLockEnabled': serializer.toJson<bool>(autoLockEnabled),
|
|
'themeMode': serializer.toJson<String>(themeMode),
|
|
'language': serializer.toJson<String>(language),
|
|
'barGridRows': serializer.toJson<int>(barGridRows),
|
|
};
|
|
}
|
|
|
|
AppSettingsRow copyWith({
|
|
String? id,
|
|
bool? pinRequired,
|
|
bool? autoLockEnabled,
|
|
String? themeMode,
|
|
String? language,
|
|
int? barGridRows,
|
|
}) => AppSettingsRow(
|
|
id: id ?? this.id,
|
|
pinRequired: pinRequired ?? this.pinRequired,
|
|
autoLockEnabled: autoLockEnabled ?? this.autoLockEnabled,
|
|
themeMode: themeMode ?? this.themeMode,
|
|
language: language ?? this.language,
|
|
barGridRows: barGridRows ?? this.barGridRows,
|
|
);
|
|
AppSettingsRow copyWithCompanion(AppSettingsTableCompanion data) {
|
|
return AppSettingsRow(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
pinRequired: data.pinRequired.present
|
|
? data.pinRequired.value
|
|
: this.pinRequired,
|
|
autoLockEnabled: data.autoLockEnabled.present
|
|
? data.autoLockEnabled.value
|
|
: this.autoLockEnabled,
|
|
themeMode: data.themeMode.present ? data.themeMode.value : this.themeMode,
|
|
language: data.language.present ? data.language.value : this.language,
|
|
barGridRows: data.barGridRows.present
|
|
? data.barGridRows.value
|
|
: this.barGridRows,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('AppSettingsRow(')
|
|
..write('id: $id, ')
|
|
..write('pinRequired: $pinRequired, ')
|
|
..write('autoLockEnabled: $autoLockEnabled, ')
|
|
..write('themeMode: $themeMode, ')
|
|
..write('language: $language, ')
|
|
..write('barGridRows: $barGridRows')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
pinRequired,
|
|
autoLockEnabled,
|
|
themeMode,
|
|
language,
|
|
barGridRows,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is AppSettingsRow &&
|
|
other.id == this.id &&
|
|
other.pinRequired == this.pinRequired &&
|
|
other.autoLockEnabled == this.autoLockEnabled &&
|
|
other.themeMode == this.themeMode &&
|
|
other.language == this.language &&
|
|
other.barGridRows == this.barGridRows);
|
|
}
|
|
|
|
class AppSettingsTableCompanion extends UpdateCompanion<AppSettingsRow> {
|
|
final Value<String> id;
|
|
final Value<bool> pinRequired;
|
|
final Value<bool> autoLockEnabled;
|
|
final Value<String> themeMode;
|
|
final Value<String> language;
|
|
final Value<int> barGridRows;
|
|
final Value<int> rowid;
|
|
const AppSettingsTableCompanion({
|
|
this.id = const Value.absent(),
|
|
this.pinRequired = const Value.absent(),
|
|
this.autoLockEnabled = const Value.absent(),
|
|
this.themeMode = const Value.absent(),
|
|
this.language = const Value.absent(),
|
|
this.barGridRows = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
AppSettingsTableCompanion.insert({
|
|
required String id,
|
|
this.pinRequired = const Value.absent(),
|
|
this.autoLockEnabled = const Value.absent(),
|
|
this.themeMode = const Value.absent(),
|
|
this.language = const Value.absent(),
|
|
this.barGridRows = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id);
|
|
static Insertable<AppSettingsRow> custom({
|
|
Expression<String>? id,
|
|
Expression<bool>? pinRequired,
|
|
Expression<bool>? autoLockEnabled,
|
|
Expression<String>? themeMode,
|
|
Expression<String>? language,
|
|
Expression<int>? barGridRows,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (pinRequired != null) 'pin_required': pinRequired,
|
|
if (autoLockEnabled != null) 'auto_lock_enabled': autoLockEnabled,
|
|
if (themeMode != null) 'theme_mode': themeMode,
|
|
if (language != null) 'language': language,
|
|
if (barGridRows != null) 'bar_grid_rows': barGridRows,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
AppSettingsTableCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<bool>? pinRequired,
|
|
Value<bool>? autoLockEnabled,
|
|
Value<String>? themeMode,
|
|
Value<String>? language,
|
|
Value<int>? barGridRows,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return AppSettingsTableCompanion(
|
|
id: id ?? this.id,
|
|
pinRequired: pinRequired ?? this.pinRequired,
|
|
autoLockEnabled: autoLockEnabled ?? this.autoLockEnabled,
|
|
themeMode: themeMode ?? this.themeMode,
|
|
language: language ?? this.language,
|
|
barGridRows: barGridRows ?? this.barGridRows,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (pinRequired.present) {
|
|
map['pin_required'] = Variable<bool>(pinRequired.value);
|
|
}
|
|
if (autoLockEnabled.present) {
|
|
map['auto_lock_enabled'] = Variable<bool>(autoLockEnabled.value);
|
|
}
|
|
if (themeMode.present) {
|
|
map['theme_mode'] = Variable<String>(themeMode.value);
|
|
}
|
|
if (language.present) {
|
|
map['language'] = Variable<String>(language.value);
|
|
}
|
|
if (barGridRows.present) {
|
|
map['bar_grid_rows'] = Variable<int>(barGridRows.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('AppSettingsTableCompanion(')
|
|
..write('id: $id, ')
|
|
..write('pinRequired: $pinRequired, ')
|
|
..write('autoLockEnabled: $autoLockEnabled, ')
|
|
..write('themeMode: $themeMode, ')
|
|
..write('language: $language, ')
|
|
..write('barGridRows: $barGridRows, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $RemoteSyncStateTable extends RemoteSyncState
|
|
with TableInfo<$RemoteSyncStateTable, RemoteSyncStateRow> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$RemoteSyncStateTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _deviceIdMeta = const VerificationMeta(
|
|
'deviceId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> deviceId = GeneratedColumn<String>(
|
|
'device_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _serverCursorMeta = const VerificationMeta(
|
|
'serverCursor',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> serverCursor = GeneratedColumn<String>(
|
|
'server_cursor',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _lastSuccessfulSyncAtMeta =
|
|
const VerificationMeta('lastSuccessfulSyncAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> lastSuccessfulSyncAt =
|
|
GeneratedColumn<DateTime>(
|
|
'last_successful_sync_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _lastAttemptedSyncAtMeta =
|
|
const VerificationMeta('lastAttemptedSyncAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> lastAttemptedSyncAt =
|
|
GeneratedColumn<DateTime>(
|
|
'last_attempted_sync_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _consecutiveFailureCountMeta =
|
|
const VerificationMeta('consecutiveFailureCount');
|
|
@override
|
|
late final GeneratedColumn<int> consecutiveFailureCount =
|
|
GeneratedColumn<int>(
|
|
'consecutive_failure_count',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(0),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
deviceId,
|
|
serverCursor,
|
|
lastSuccessfulSyncAt,
|
|
lastAttemptedSyncAt,
|
|
consecutiveFailureCount,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'remote_sync_state';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<RemoteSyncStateRow> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('device_id')) {
|
|
context.handle(
|
|
_deviceIdMeta,
|
|
deviceId.isAcceptableOrUnknown(data['device_id']!, _deviceIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_deviceIdMeta);
|
|
}
|
|
if (data.containsKey('server_cursor')) {
|
|
context.handle(
|
|
_serverCursorMeta,
|
|
serverCursor.isAcceptableOrUnknown(
|
|
data['server_cursor']!,
|
|
_serverCursorMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('last_successful_sync_at')) {
|
|
context.handle(
|
|
_lastSuccessfulSyncAtMeta,
|
|
lastSuccessfulSyncAt.isAcceptableOrUnknown(
|
|
data['last_successful_sync_at']!,
|
|
_lastSuccessfulSyncAtMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('last_attempted_sync_at')) {
|
|
context.handle(
|
|
_lastAttemptedSyncAtMeta,
|
|
lastAttemptedSyncAt.isAcceptableOrUnknown(
|
|
data['last_attempted_sync_at']!,
|
|
_lastAttemptedSyncAtMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('consecutive_failure_count')) {
|
|
context.handle(
|
|
_consecutiveFailureCountMeta,
|
|
consecutiveFailureCount.isAcceptableOrUnknown(
|
|
data['consecutive_failure_count']!,
|
|
_consecutiveFailureCountMeta,
|
|
),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {deviceId};
|
|
@override
|
|
RemoteSyncStateRow map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return RemoteSyncStateRow(
|
|
deviceId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}device_id'],
|
|
)!,
|
|
serverCursor: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}server_cursor'],
|
|
),
|
|
lastSuccessfulSyncAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}last_successful_sync_at'],
|
|
),
|
|
lastAttemptedSyncAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}last_attempted_sync_at'],
|
|
),
|
|
consecutiveFailureCount: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}consecutive_failure_count'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$RemoteSyncStateTable createAlias(String alias) {
|
|
return $RemoteSyncStateTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class RemoteSyncStateRow extends DataClass
|
|
implements Insertable<RemoteSyncStateRow> {
|
|
final String deviceId;
|
|
final String? serverCursor;
|
|
final DateTime? lastSuccessfulSyncAt;
|
|
final DateTime? lastAttemptedSyncAt;
|
|
final int consecutiveFailureCount;
|
|
const RemoteSyncStateRow({
|
|
required this.deviceId,
|
|
this.serverCursor,
|
|
this.lastSuccessfulSyncAt,
|
|
this.lastAttemptedSyncAt,
|
|
required this.consecutiveFailureCount,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['device_id'] = Variable<String>(deviceId);
|
|
if (!nullToAbsent || serverCursor != null) {
|
|
map['server_cursor'] = Variable<String>(serverCursor);
|
|
}
|
|
if (!nullToAbsent || lastSuccessfulSyncAt != null) {
|
|
map['last_successful_sync_at'] = Variable<DateTime>(lastSuccessfulSyncAt);
|
|
}
|
|
if (!nullToAbsent || lastAttemptedSyncAt != null) {
|
|
map['last_attempted_sync_at'] = Variable<DateTime>(lastAttemptedSyncAt);
|
|
}
|
|
map['consecutive_failure_count'] = Variable<int>(consecutiveFailureCount);
|
|
return map;
|
|
}
|
|
|
|
RemoteSyncStateCompanion toCompanion(bool nullToAbsent) {
|
|
return RemoteSyncStateCompanion(
|
|
deviceId: Value(deviceId),
|
|
serverCursor: serverCursor == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(serverCursor),
|
|
lastSuccessfulSyncAt: lastSuccessfulSyncAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(lastSuccessfulSyncAt),
|
|
lastAttemptedSyncAt: lastAttemptedSyncAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(lastAttemptedSyncAt),
|
|
consecutiveFailureCount: Value(consecutiveFailureCount),
|
|
);
|
|
}
|
|
|
|
factory RemoteSyncStateRow.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return RemoteSyncStateRow(
|
|
deviceId: serializer.fromJson<String>(json['deviceId']),
|
|
serverCursor: serializer.fromJson<String?>(json['serverCursor']),
|
|
lastSuccessfulSyncAt: serializer.fromJson<DateTime?>(
|
|
json['lastSuccessfulSyncAt'],
|
|
),
|
|
lastAttemptedSyncAt: serializer.fromJson<DateTime?>(
|
|
json['lastAttemptedSyncAt'],
|
|
),
|
|
consecutiveFailureCount: serializer.fromJson<int>(
|
|
json['consecutiveFailureCount'],
|
|
),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'deviceId': serializer.toJson<String>(deviceId),
|
|
'serverCursor': serializer.toJson<String?>(serverCursor),
|
|
'lastSuccessfulSyncAt': serializer.toJson<DateTime?>(
|
|
lastSuccessfulSyncAt,
|
|
),
|
|
'lastAttemptedSyncAt': serializer.toJson<DateTime?>(lastAttemptedSyncAt),
|
|
'consecutiveFailureCount': serializer.toJson<int>(
|
|
consecutiveFailureCount,
|
|
),
|
|
};
|
|
}
|
|
|
|
RemoteSyncStateRow copyWith({
|
|
String? deviceId,
|
|
Value<String?> serverCursor = const Value.absent(),
|
|
Value<DateTime?> lastSuccessfulSyncAt = const Value.absent(),
|
|
Value<DateTime?> lastAttemptedSyncAt = const Value.absent(),
|
|
int? consecutiveFailureCount,
|
|
}) => RemoteSyncStateRow(
|
|
deviceId: deviceId ?? this.deviceId,
|
|
serverCursor: serverCursor.present ? serverCursor.value : this.serverCursor,
|
|
lastSuccessfulSyncAt: lastSuccessfulSyncAt.present
|
|
? lastSuccessfulSyncAt.value
|
|
: this.lastSuccessfulSyncAt,
|
|
lastAttemptedSyncAt: lastAttemptedSyncAt.present
|
|
? lastAttemptedSyncAt.value
|
|
: this.lastAttemptedSyncAt,
|
|
consecutiveFailureCount:
|
|
consecutiveFailureCount ?? this.consecutiveFailureCount,
|
|
);
|
|
RemoteSyncStateRow copyWithCompanion(RemoteSyncStateCompanion data) {
|
|
return RemoteSyncStateRow(
|
|
deviceId: data.deviceId.present ? data.deviceId.value : this.deviceId,
|
|
serverCursor: data.serverCursor.present
|
|
? data.serverCursor.value
|
|
: this.serverCursor,
|
|
lastSuccessfulSyncAt: data.lastSuccessfulSyncAt.present
|
|
? data.lastSuccessfulSyncAt.value
|
|
: this.lastSuccessfulSyncAt,
|
|
lastAttemptedSyncAt: data.lastAttemptedSyncAt.present
|
|
? data.lastAttemptedSyncAt.value
|
|
: this.lastAttemptedSyncAt,
|
|
consecutiveFailureCount: data.consecutiveFailureCount.present
|
|
? data.consecutiveFailureCount.value
|
|
: this.consecutiveFailureCount,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('RemoteSyncStateRow(')
|
|
..write('deviceId: $deviceId, ')
|
|
..write('serverCursor: $serverCursor, ')
|
|
..write('lastSuccessfulSyncAt: $lastSuccessfulSyncAt, ')
|
|
..write('lastAttemptedSyncAt: $lastAttemptedSyncAt, ')
|
|
..write('consecutiveFailureCount: $consecutiveFailureCount')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
deviceId,
|
|
serverCursor,
|
|
lastSuccessfulSyncAt,
|
|
lastAttemptedSyncAt,
|
|
consecutiveFailureCount,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is RemoteSyncStateRow &&
|
|
other.deviceId == this.deviceId &&
|
|
other.serverCursor == this.serverCursor &&
|
|
other.lastSuccessfulSyncAt == this.lastSuccessfulSyncAt &&
|
|
other.lastAttemptedSyncAt == this.lastAttemptedSyncAt &&
|
|
other.consecutiveFailureCount == this.consecutiveFailureCount);
|
|
}
|
|
|
|
class RemoteSyncStateCompanion extends UpdateCompanion<RemoteSyncStateRow> {
|
|
final Value<String> deviceId;
|
|
final Value<String?> serverCursor;
|
|
final Value<DateTime?> lastSuccessfulSyncAt;
|
|
final Value<DateTime?> lastAttemptedSyncAt;
|
|
final Value<int> consecutiveFailureCount;
|
|
final Value<int> rowid;
|
|
const RemoteSyncStateCompanion({
|
|
this.deviceId = const Value.absent(),
|
|
this.serverCursor = const Value.absent(),
|
|
this.lastSuccessfulSyncAt = const Value.absent(),
|
|
this.lastAttemptedSyncAt = const Value.absent(),
|
|
this.consecutiveFailureCount = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
RemoteSyncStateCompanion.insert({
|
|
required String deviceId,
|
|
this.serverCursor = const Value.absent(),
|
|
this.lastSuccessfulSyncAt = const Value.absent(),
|
|
this.lastAttemptedSyncAt = const Value.absent(),
|
|
this.consecutiveFailureCount = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : deviceId = Value(deviceId);
|
|
static Insertable<RemoteSyncStateRow> custom({
|
|
Expression<String>? deviceId,
|
|
Expression<String>? serverCursor,
|
|
Expression<DateTime>? lastSuccessfulSyncAt,
|
|
Expression<DateTime>? lastAttemptedSyncAt,
|
|
Expression<int>? consecutiveFailureCount,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (deviceId != null) 'device_id': deviceId,
|
|
if (serverCursor != null) 'server_cursor': serverCursor,
|
|
if (lastSuccessfulSyncAt != null)
|
|
'last_successful_sync_at': lastSuccessfulSyncAt,
|
|
if (lastAttemptedSyncAt != null)
|
|
'last_attempted_sync_at': lastAttemptedSyncAt,
|
|
if (consecutiveFailureCount != null)
|
|
'consecutive_failure_count': consecutiveFailureCount,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
RemoteSyncStateCompanion copyWith({
|
|
Value<String>? deviceId,
|
|
Value<String?>? serverCursor,
|
|
Value<DateTime?>? lastSuccessfulSyncAt,
|
|
Value<DateTime?>? lastAttemptedSyncAt,
|
|
Value<int>? consecutiveFailureCount,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return RemoteSyncStateCompanion(
|
|
deviceId: deviceId ?? this.deviceId,
|
|
serverCursor: serverCursor ?? this.serverCursor,
|
|
lastSuccessfulSyncAt: lastSuccessfulSyncAt ?? this.lastSuccessfulSyncAt,
|
|
lastAttemptedSyncAt: lastAttemptedSyncAt ?? this.lastAttemptedSyncAt,
|
|
consecutiveFailureCount:
|
|
consecutiveFailureCount ?? this.consecutiveFailureCount,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (deviceId.present) {
|
|
map['device_id'] = Variable<String>(deviceId.value);
|
|
}
|
|
if (serverCursor.present) {
|
|
map['server_cursor'] = Variable<String>(serverCursor.value);
|
|
}
|
|
if (lastSuccessfulSyncAt.present) {
|
|
map['last_successful_sync_at'] = Variable<DateTime>(
|
|
lastSuccessfulSyncAt.value,
|
|
);
|
|
}
|
|
if (lastAttemptedSyncAt.present) {
|
|
map['last_attempted_sync_at'] = Variable<DateTime>(
|
|
lastAttemptedSyncAt.value,
|
|
);
|
|
}
|
|
if (consecutiveFailureCount.present) {
|
|
map['consecutive_failure_count'] = Variable<int>(
|
|
consecutiveFailureCount.value,
|
|
);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('RemoteSyncStateCompanion(')
|
|
..write('deviceId: $deviceId, ')
|
|
..write('serverCursor: $serverCursor, ')
|
|
..write('lastSuccessfulSyncAt: $lastSuccessfulSyncAt, ')
|
|
..write('lastAttemptedSyncAt: $lastAttemptedSyncAt, ')
|
|
..write('consecutiveFailureCount: $consecutiveFailureCount, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ProcessedRemoteCommandsTable extends ProcessedRemoteCommands
|
|
with TableInfo<$ProcessedRemoteCommandsTable, ProcessedRemoteCommandRow> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ProcessedRemoteCommandsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _commandIdMeta = const VerificationMeta(
|
|
'commandId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> commandId = GeneratedColumn<String>(
|
|
'command_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _commandTypeMeta = const VerificationMeta(
|
|
'commandType',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> commandType = GeneratedColumn<String>(
|
|
'command_type',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _processedAtMeta = const VerificationMeta(
|
|
'processedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> processedAt = GeneratedColumn<DateTime>(
|
|
'processed_at',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
late final GeneratedColumnWithTypeConverter<CommandResult, String> result =
|
|
GeneratedColumn<String>(
|
|
'result',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
).withConverter<CommandResult>(
|
|
$ProcessedRemoteCommandsTable.$converterresult,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
commandId,
|
|
commandType,
|
|
processedAt,
|
|
result,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'processed_remote_commands';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<ProcessedRemoteCommandRow> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('command_id')) {
|
|
context.handle(
|
|
_commandIdMeta,
|
|
commandId.isAcceptableOrUnknown(data['command_id']!, _commandIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_commandIdMeta);
|
|
}
|
|
if (data.containsKey('command_type')) {
|
|
context.handle(
|
|
_commandTypeMeta,
|
|
commandType.isAcceptableOrUnknown(
|
|
data['command_type']!,
|
|
_commandTypeMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_commandTypeMeta);
|
|
}
|
|
if (data.containsKey('processed_at')) {
|
|
context.handle(
|
|
_processedAtMeta,
|
|
processedAt.isAcceptableOrUnknown(
|
|
data['processed_at']!,
|
|
_processedAtMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_processedAtMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {commandId};
|
|
@override
|
|
ProcessedRemoteCommandRow map(
|
|
Map<String, dynamic> data, {
|
|
String? tablePrefix,
|
|
}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ProcessedRemoteCommandRow(
|
|
commandId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}command_id'],
|
|
)!,
|
|
commandType: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}command_type'],
|
|
)!,
|
|
processedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}processed_at'],
|
|
)!,
|
|
result: $ProcessedRemoteCommandsTable.$converterresult.fromSql(
|
|
attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}result'],
|
|
)!,
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ProcessedRemoteCommandsTable createAlias(String alias) {
|
|
return $ProcessedRemoteCommandsTable(attachedDatabase, alias);
|
|
}
|
|
|
|
static JsonTypeConverter2<CommandResult, String, String> $converterresult =
|
|
const EnumNameConverter<CommandResult>(CommandResult.values);
|
|
}
|
|
|
|
class ProcessedRemoteCommandRow extends DataClass
|
|
implements Insertable<ProcessedRemoteCommandRow> {
|
|
final String commandId;
|
|
final String commandType;
|
|
final DateTime processedAt;
|
|
final CommandResult result;
|
|
const ProcessedRemoteCommandRow({
|
|
required this.commandId,
|
|
required this.commandType,
|
|
required this.processedAt,
|
|
required this.result,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['command_id'] = Variable<String>(commandId);
|
|
map['command_type'] = Variable<String>(commandType);
|
|
map['processed_at'] = Variable<DateTime>(processedAt);
|
|
{
|
|
map['result'] = Variable<String>(
|
|
$ProcessedRemoteCommandsTable.$converterresult.toSql(result),
|
|
);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
ProcessedRemoteCommandsCompanion toCompanion(bool nullToAbsent) {
|
|
return ProcessedRemoteCommandsCompanion(
|
|
commandId: Value(commandId),
|
|
commandType: Value(commandType),
|
|
processedAt: Value(processedAt),
|
|
result: Value(result),
|
|
);
|
|
}
|
|
|
|
factory ProcessedRemoteCommandRow.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return ProcessedRemoteCommandRow(
|
|
commandId: serializer.fromJson<String>(json['commandId']),
|
|
commandType: serializer.fromJson<String>(json['commandType']),
|
|
processedAt: serializer.fromJson<DateTime>(json['processedAt']),
|
|
result: $ProcessedRemoteCommandsTable.$converterresult.fromJson(
|
|
serializer.fromJson<String>(json['result']),
|
|
),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'commandId': serializer.toJson<String>(commandId),
|
|
'commandType': serializer.toJson<String>(commandType),
|
|
'processedAt': serializer.toJson<DateTime>(processedAt),
|
|
'result': serializer.toJson<String>(
|
|
$ProcessedRemoteCommandsTable.$converterresult.toJson(result),
|
|
),
|
|
};
|
|
}
|
|
|
|
ProcessedRemoteCommandRow copyWith({
|
|
String? commandId,
|
|
String? commandType,
|
|
DateTime? processedAt,
|
|
CommandResult? result,
|
|
}) => ProcessedRemoteCommandRow(
|
|
commandId: commandId ?? this.commandId,
|
|
commandType: commandType ?? this.commandType,
|
|
processedAt: processedAt ?? this.processedAt,
|
|
result: result ?? this.result,
|
|
);
|
|
ProcessedRemoteCommandRow copyWithCompanion(
|
|
ProcessedRemoteCommandsCompanion data,
|
|
) {
|
|
return ProcessedRemoteCommandRow(
|
|
commandId: data.commandId.present ? data.commandId.value : this.commandId,
|
|
commandType: data.commandType.present
|
|
? data.commandType.value
|
|
: this.commandType,
|
|
processedAt: data.processedAt.present
|
|
? data.processedAt.value
|
|
: this.processedAt,
|
|
result: data.result.present ? data.result.value : this.result,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ProcessedRemoteCommandRow(')
|
|
..write('commandId: $commandId, ')
|
|
..write('commandType: $commandType, ')
|
|
..write('processedAt: $processedAt, ')
|
|
..write('result: $result')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(commandId, commandType, processedAt, result);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is ProcessedRemoteCommandRow &&
|
|
other.commandId == this.commandId &&
|
|
other.commandType == this.commandType &&
|
|
other.processedAt == this.processedAt &&
|
|
other.result == this.result);
|
|
}
|
|
|
|
class ProcessedRemoteCommandsCompanion
|
|
extends UpdateCompanion<ProcessedRemoteCommandRow> {
|
|
final Value<String> commandId;
|
|
final Value<String> commandType;
|
|
final Value<DateTime> processedAt;
|
|
final Value<CommandResult> result;
|
|
final Value<int> rowid;
|
|
const ProcessedRemoteCommandsCompanion({
|
|
this.commandId = const Value.absent(),
|
|
this.commandType = const Value.absent(),
|
|
this.processedAt = const Value.absent(),
|
|
this.result = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
ProcessedRemoteCommandsCompanion.insert({
|
|
required String commandId,
|
|
required String commandType,
|
|
required DateTime processedAt,
|
|
required CommandResult result,
|
|
this.rowid = const Value.absent(),
|
|
}) : commandId = Value(commandId),
|
|
commandType = Value(commandType),
|
|
processedAt = Value(processedAt),
|
|
result = Value(result);
|
|
static Insertable<ProcessedRemoteCommandRow> custom({
|
|
Expression<String>? commandId,
|
|
Expression<String>? commandType,
|
|
Expression<DateTime>? processedAt,
|
|
Expression<String>? result,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (commandId != null) 'command_id': commandId,
|
|
if (commandType != null) 'command_type': commandType,
|
|
if (processedAt != null) 'processed_at': processedAt,
|
|
if (result != null) 'result': result,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
ProcessedRemoteCommandsCompanion copyWith({
|
|
Value<String>? commandId,
|
|
Value<String>? commandType,
|
|
Value<DateTime>? processedAt,
|
|
Value<CommandResult>? result,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return ProcessedRemoteCommandsCompanion(
|
|
commandId: commandId ?? this.commandId,
|
|
commandType: commandType ?? this.commandType,
|
|
processedAt: processedAt ?? this.processedAt,
|
|
result: result ?? this.result,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (commandId.present) {
|
|
map['command_id'] = Variable<String>(commandId.value);
|
|
}
|
|
if (commandType.present) {
|
|
map['command_type'] = Variable<String>(commandType.value);
|
|
}
|
|
if (processedAt.present) {
|
|
map['processed_at'] = Variable<DateTime>(processedAt.value);
|
|
}
|
|
if (result.present) {
|
|
map['result'] = Variable<String>(
|
|
$ProcessedRemoteCommandsTable.$converterresult.toSql(result.value),
|
|
);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ProcessedRemoteCommandsCompanion(')
|
|
..write('commandId: $commandId, ')
|
|
..write('commandType: $commandType, ')
|
|
..write('processedAt: $processedAt, ')
|
|
..write('result: $result, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $TabEventsTable extends TabEvents
|
|
with TableInfo<$TabEventsTable, TabEventRow> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$TabEventsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<String> id = GeneratedColumn<String>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _payloadMeta = const VerificationMeta(
|
|
'payload',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> payload = GeneratedColumn<String>(
|
|
'payload',
|
|
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,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, payload, createdAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'tab_events';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<TabEventRow> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_idMeta);
|
|
}
|
|
if (data.containsKey('payload')) {
|
|
context.handle(
|
|
_payloadMeta,
|
|
payload.isAcceptableOrUnknown(data['payload']!, _payloadMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_payloadMeta);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(
|
|
_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_createdAtMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
TabEventRow map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return TabEventRow(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
payload: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}payload'],
|
|
)!,
|
|
createdAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}created_at'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$TabEventsTable createAlias(String alias) {
|
|
return $TabEventsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class TabEventRow extends DataClass implements Insertable<TabEventRow> {
|
|
/// The event's UUID.
|
|
final String id;
|
|
|
|
/// The event as JSON, exactly as it is sent.
|
|
final String payload;
|
|
final DateTime createdAt;
|
|
const TabEventRow({
|
|
required this.id,
|
|
required this.payload,
|
|
required this.createdAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['payload'] = Variable<String>(payload);
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
return map;
|
|
}
|
|
|
|
TabEventsCompanion toCompanion(bool nullToAbsent) {
|
|
return TabEventsCompanion(
|
|
id: Value(id),
|
|
payload: Value(payload),
|
|
createdAt: Value(createdAt),
|
|
);
|
|
}
|
|
|
|
factory TabEventRow.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return TabEventRow(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
payload: serializer.fromJson<String>(json['payload']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'payload': serializer.toJson<String>(payload),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
};
|
|
}
|
|
|
|
TabEventRow copyWith({String? id, String? payload, DateTime? createdAt}) =>
|
|
TabEventRow(
|
|
id: id ?? this.id,
|
|
payload: payload ?? this.payload,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
);
|
|
TabEventRow copyWithCompanion(TabEventsCompanion data) {
|
|
return TabEventRow(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
payload: data.payload.present ? data.payload.value : this.payload,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TabEventRow(')
|
|
..write('id: $id, ')
|
|
..write('payload: $payload, ')
|
|
..write('createdAt: $createdAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, payload, createdAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is TabEventRow &&
|
|
other.id == this.id &&
|
|
other.payload == this.payload &&
|
|
other.createdAt == this.createdAt);
|
|
}
|
|
|
|
class TabEventsCompanion extends UpdateCompanion<TabEventRow> {
|
|
final Value<String> id;
|
|
final Value<String> payload;
|
|
final Value<DateTime> createdAt;
|
|
final Value<int> rowid;
|
|
const TabEventsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.payload = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
TabEventsCompanion.insert({
|
|
required String id,
|
|
required String payload,
|
|
required DateTime createdAt,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
payload = Value(payload),
|
|
createdAt = Value(createdAt);
|
|
static Insertable<TabEventRow> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? payload,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (payload != null) 'payload': payload,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
TabEventsCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? payload,
|
|
Value<DateTime>? createdAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return TabEventsCompanion(
|
|
id: id ?? this.id,
|
|
payload: payload ?? this.payload,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<String>(id.value);
|
|
}
|
|
if (payload.present) {
|
|
map['payload'] = Variable<String>(payload.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('TabEventsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('payload: $payload, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $ProductsTable products = $ProductsTable(this);
|
|
late final $BarTabsTable barTabs = $BarTabsTable(this);
|
|
late final $TabItemsTable tabItems = $TabItemsTable(this);
|
|
late final $TabItemPurchasesTable tabItemPurchases = $TabItemPurchasesTable(
|
|
this,
|
|
);
|
|
late final $ClosedTabsTable closedTabs = $ClosedTabsTable(this);
|
|
late final $ClosedTabItemsTable closedTabItems = $ClosedTabItemsTable(this);
|
|
late final $AppSettingsTableTable appSettingsTable = $AppSettingsTableTable(
|
|
this,
|
|
);
|
|
late final $RemoteSyncStateTable remoteSyncState = $RemoteSyncStateTable(
|
|
this,
|
|
);
|
|
late final $ProcessedRemoteCommandsTable processedRemoteCommands =
|
|
$ProcessedRemoteCommandsTable(this);
|
|
late final $TabEventsTable tabEvents = $TabEventsTable(this);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
products,
|
|
barTabs,
|
|
tabItems,
|
|
tabItemPurchases,
|
|
closedTabs,
|
|
closedTabItems,
|
|
appSettingsTable,
|
|
remoteSyncState,
|
|
processedRemoteCommands,
|
|
tabEvents,
|
|
];
|
|
@override
|
|
StreamQueryUpdateRules get streamUpdateRules => const StreamQueryUpdateRules([
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'bar_tabs',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('tab_items', kind: UpdateKind.delete)],
|
|
),
|
|
WritePropagation(
|
|
on: TableUpdateQuery.onTableName(
|
|
'tab_items',
|
|
limitUpdateKind: UpdateKind.delete,
|
|
),
|
|
result: [TableUpdate('tab_item_purchases', kind: UpdateKind.delete)],
|
|
),
|
|
]);
|
|
}
|
|
|
|
typedef $$ProductsTableCreateCompanionBuilder =
|
|
ProductsCompanion Function({
|
|
required String id,
|
|
required String name,
|
|
required String category,
|
|
required int stockQuantity,
|
|
required int lowStockThreshold,
|
|
Value<bool> infiniteStock,
|
|
required int priceInCents,
|
|
Value<String?> imagePath,
|
|
Value<bool> active,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$ProductsTableUpdateCompanionBuilder =
|
|
ProductsCompanion Function({
|
|
Value<String> id,
|
|
Value<String> name,
|
|
Value<String> category,
|
|
Value<int> stockQuantity,
|
|
Value<int> lowStockThreshold,
|
|
Value<bool> infiniteStock,
|
|
Value<int> priceInCents,
|
|
Value<String?> imagePath,
|
|
Value<bool> active,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$ProductsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $ProductsTable, ProductRow> {
|
|
$$ProductsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$TabItemsTable, List<TabItemRow>>
|
|
_tabItemsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.tabItems,
|
|
aliasName: 'products__id__tab_items__product_id',
|
|
);
|
|
|
|
$$TabItemsTableProcessedTableManager get tabItemsRefs {
|
|
final manager = $$TabItemsTableTableManager(
|
|
$_db,
|
|
$_db.tabItems,
|
|
).filter((f) => f.productId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_tabItemsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$ProductsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ProductsTable> {
|
|
$$ProductsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get category => $composableBuilder(
|
|
column: $table.category,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get stockQuantity => $composableBuilder(
|
|
column: $table.stockQuantity,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get lowStockThreshold => $composableBuilder(
|
|
column: $table.lowStockThreshold,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<bool> get infiniteStock => $composableBuilder(
|
|
column: $table.infiniteStock,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get priceInCents => $composableBuilder(
|
|
column: $table.priceInCents,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get imagePath => $composableBuilder(
|
|
column: $table.imagePath,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<bool> get active => $composableBuilder(
|
|
column: $table.active,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> tabItemsRefs(
|
|
Expression<bool> Function($$TabItemsTableFilterComposer f) f,
|
|
) {
|
|
final $$TabItemsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.tabItems,
|
|
getReferencedColumn: (t) => t.productId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TabItemsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.tabItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$ProductsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ProductsTable> {
|
|
$$ProductsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get category => $composableBuilder(
|
|
column: $table.category,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get stockQuantity => $composableBuilder(
|
|
column: $table.stockQuantity,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get lowStockThreshold => $composableBuilder(
|
|
column: $table.lowStockThreshold,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<bool> get infiniteStock => $composableBuilder(
|
|
column: $table.infiniteStock,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get priceInCents => $composableBuilder(
|
|
column: $table.priceInCents,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get imagePath => $composableBuilder(
|
|
column: $table.imagePath,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<bool> get active => $composableBuilder(
|
|
column: $table.active,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$ProductsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ProductsTable> {
|
|
$$ProductsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get name =>
|
|
$composableBuilder(column: $table.name, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get category =>
|
|
$composableBuilder(column: $table.category, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get stockQuantity => $composableBuilder(
|
|
column: $table.stockQuantity,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<int> get lowStockThreshold => $composableBuilder(
|
|
column: $table.lowStockThreshold,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<bool> get infiniteStock => $composableBuilder(
|
|
column: $table.infiniteStock,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<int> get priceInCents => $composableBuilder(
|
|
column: $table.priceInCents,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get imagePath =>
|
|
$composableBuilder(column: $table.imagePath, builder: (column) => column);
|
|
|
|
GeneratedColumn<bool> get active =>
|
|
$composableBuilder(column: $table.active, builder: (column) => column);
|
|
|
|
Expression<T> tabItemsRefs<T extends Object>(
|
|
Expression<T> Function($$TabItemsTableAnnotationComposer a) f,
|
|
) {
|
|
final $$TabItemsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.tabItems,
|
|
getReferencedColumn: (t) => t.productId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TabItemsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.tabItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$ProductsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$ProductsTable,
|
|
ProductRow,
|
|
$$ProductsTableFilterComposer,
|
|
$$ProductsTableOrderingComposer,
|
|
$$ProductsTableAnnotationComposer,
|
|
$$ProductsTableCreateCompanionBuilder,
|
|
$$ProductsTableUpdateCompanionBuilder,
|
|
(ProductRow, $$ProductsTableReferences),
|
|
ProductRow,
|
|
PrefetchHooks Function({bool tabItemsRefs})
|
|
> {
|
|
$$ProductsTableTableManager(_$AppDatabase db, $ProductsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ProductsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ProductsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ProductsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<String> category = const Value.absent(),
|
|
Value<int> stockQuantity = const Value.absent(),
|
|
Value<int> lowStockThreshold = const Value.absent(),
|
|
Value<bool> infiniteStock = const Value.absent(),
|
|
Value<int> priceInCents = const Value.absent(),
|
|
Value<String?> imagePath = const Value.absent(),
|
|
Value<bool> active = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ProductsCompanion(
|
|
id: id,
|
|
name: name,
|
|
category: category,
|
|
stockQuantity: stockQuantity,
|
|
lowStockThreshold: lowStockThreshold,
|
|
infiniteStock: infiniteStock,
|
|
priceInCents: priceInCents,
|
|
imagePath: imagePath,
|
|
active: active,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String name,
|
|
required String category,
|
|
required int stockQuantity,
|
|
required int lowStockThreshold,
|
|
Value<bool> infiniteStock = const Value.absent(),
|
|
required int priceInCents,
|
|
Value<String?> imagePath = const Value.absent(),
|
|
Value<bool> active = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ProductsCompanion.insert(
|
|
id: id,
|
|
name: name,
|
|
category: category,
|
|
stockQuantity: stockQuantity,
|
|
lowStockThreshold: lowStockThreshold,
|
|
infiniteStock: infiniteStock,
|
|
priceInCents: priceInCents,
|
|
imagePath: imagePath,
|
|
active: active,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$ProductsTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({tabItemsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (tabItemsRefs) db.tabItems],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (tabItemsRefs)
|
|
await $_getPrefetchedData<
|
|
ProductRow,
|
|
$ProductsTable,
|
|
TabItemRow
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$ProductsTableReferences
|
|
._tabItemsRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$ProductsTableReferences(db, table, p0).tabItemsRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.productId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$ProductsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ProductsTable,
|
|
ProductRow,
|
|
$$ProductsTableFilterComposer,
|
|
$$ProductsTableOrderingComposer,
|
|
$$ProductsTableAnnotationComposer,
|
|
$$ProductsTableCreateCompanionBuilder,
|
|
$$ProductsTableUpdateCompanionBuilder,
|
|
(ProductRow, $$ProductsTableReferences),
|
|
ProductRow,
|
|
PrefetchHooks Function({bool tabItemsRefs})
|
|
>;
|
|
typedef $$BarTabsTableCreateCompanionBuilder =
|
|
BarTabsCompanion Function({
|
|
required String id,
|
|
required String customerName,
|
|
required DateTime openedAt,
|
|
Value<int> version,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$BarTabsTableUpdateCompanionBuilder =
|
|
BarTabsCompanion Function({
|
|
Value<String> id,
|
|
Value<String> customerName,
|
|
Value<DateTime> openedAt,
|
|
Value<int> version,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$BarTabsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $BarTabsTable, BarTabRow> {
|
|
$$BarTabsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$TabItemsTable, List<TabItemRow>>
|
|
_tabItemsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.tabItems,
|
|
aliasName: 'bar_tabs__id__tab_items__tab_id',
|
|
);
|
|
|
|
$$TabItemsTableProcessedTableManager get tabItemsRefs {
|
|
final manager = $$TabItemsTableTableManager(
|
|
$_db,
|
|
$_db.tabItems,
|
|
).filter((f) => f.tabId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_tabItemsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$BarTabsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $BarTabsTable> {
|
|
$$BarTabsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get customerName => $composableBuilder(
|
|
column: $table.customerName,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get openedAt => $composableBuilder(
|
|
column: $table.openedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get version => $composableBuilder(
|
|
column: $table.version,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> tabItemsRefs(
|
|
Expression<bool> Function($$TabItemsTableFilterComposer f) f,
|
|
) {
|
|
final $$TabItemsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.tabItems,
|
|
getReferencedColumn: (t) => t.tabId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TabItemsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.tabItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$BarTabsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $BarTabsTable> {
|
|
$$BarTabsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get customerName => $composableBuilder(
|
|
column: $table.customerName,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get openedAt => $composableBuilder(
|
|
column: $table.openedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get version => $composableBuilder(
|
|
column: $table.version,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$BarTabsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $BarTabsTable> {
|
|
$$BarTabsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get customerName => $composableBuilder(
|
|
column: $table.customerName,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get openedAt =>
|
|
$composableBuilder(column: $table.openedAt, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get version =>
|
|
$composableBuilder(column: $table.version, builder: (column) => column);
|
|
|
|
Expression<T> tabItemsRefs<T extends Object>(
|
|
Expression<T> Function($$TabItemsTableAnnotationComposer a) f,
|
|
) {
|
|
final $$TabItemsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.tabItems,
|
|
getReferencedColumn: (t) => t.tabId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TabItemsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.tabItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$BarTabsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$BarTabsTable,
|
|
BarTabRow,
|
|
$$BarTabsTableFilterComposer,
|
|
$$BarTabsTableOrderingComposer,
|
|
$$BarTabsTableAnnotationComposer,
|
|
$$BarTabsTableCreateCompanionBuilder,
|
|
$$BarTabsTableUpdateCompanionBuilder,
|
|
(BarTabRow, $$BarTabsTableReferences),
|
|
BarTabRow,
|
|
PrefetchHooks Function({bool tabItemsRefs})
|
|
> {
|
|
$$BarTabsTableTableManager(_$AppDatabase db, $BarTabsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$BarTabsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$BarTabsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$BarTabsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> customerName = const Value.absent(),
|
|
Value<DateTime> openedAt = const Value.absent(),
|
|
Value<int> version = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => BarTabsCompanion(
|
|
id: id,
|
|
customerName: customerName,
|
|
openedAt: openedAt,
|
|
version: version,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String customerName,
|
|
required DateTime openedAt,
|
|
Value<int> version = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => BarTabsCompanion.insert(
|
|
id: id,
|
|
customerName: customerName,
|
|
openedAt: openedAt,
|
|
version: version,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$BarTabsTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({tabItemsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (tabItemsRefs) db.tabItems],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (tabItemsRefs)
|
|
await $_getPrefetchedData<
|
|
BarTabRow,
|
|
$BarTabsTable,
|
|
TabItemRow
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$BarTabsTableReferences
|
|
._tabItemsRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$BarTabsTableReferences(db, table, p0).tabItemsRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.tabId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$BarTabsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$BarTabsTable,
|
|
BarTabRow,
|
|
$$BarTabsTableFilterComposer,
|
|
$$BarTabsTableOrderingComposer,
|
|
$$BarTabsTableAnnotationComposer,
|
|
$$BarTabsTableCreateCompanionBuilder,
|
|
$$BarTabsTableUpdateCompanionBuilder,
|
|
(BarTabRow, $$BarTabsTableReferences),
|
|
BarTabRow,
|
|
PrefetchHooks Function({bool tabItemsRefs})
|
|
>;
|
|
typedef $$TabItemsTableCreateCompanionBuilder =
|
|
TabItemsCompanion Function({
|
|
required String id,
|
|
required String tabId,
|
|
required String productId,
|
|
required String productName,
|
|
required int quantity,
|
|
required int unitPriceInCents,
|
|
required DateTime createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$TabItemsTableUpdateCompanionBuilder =
|
|
TabItemsCompanion Function({
|
|
Value<String> id,
|
|
Value<String> tabId,
|
|
Value<String> productId,
|
|
Value<String> productName,
|
|
Value<int> quantity,
|
|
Value<int> unitPriceInCents,
|
|
Value<DateTime> createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$TabItemsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $TabItemsTable, TabItemRow> {
|
|
$$TabItemsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $BarTabsTable _tabIdTable(_$AppDatabase db) =>
|
|
db.barTabs.createAlias('tab_items__tab_id__bar_tabs__id');
|
|
|
|
$$BarTabsTableProcessedTableManager get tabId {
|
|
final $_column = $_itemColumn<String>('tab_id')!;
|
|
|
|
final manager = $$BarTabsTableTableManager(
|
|
$_db,
|
|
$_db.barTabs,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_tabIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static $ProductsTable _productIdTable(_$AppDatabase db) =>
|
|
db.products.createAlias('tab_items__product_id__products__id');
|
|
|
|
$$ProductsTableProcessedTableManager get productId {
|
|
final $_column = $_itemColumn<String>('product_id')!;
|
|
|
|
final manager = $$ProductsTableTableManager(
|
|
$_db,
|
|
$_db.products,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_productIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static MultiTypedResultKey<$TabItemPurchasesTable, List<TabItemPurchaseRow>>
|
|
_tabItemPurchasesRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.tabItemPurchases,
|
|
aliasName: 'tab_items__id__tab_item_purchases__tab_item_id',
|
|
);
|
|
|
|
$$TabItemPurchasesTableProcessedTableManager get tabItemPurchasesRefs {
|
|
final manager = $$TabItemPurchasesTableTableManager(
|
|
$_db,
|
|
$_db.tabItemPurchases,
|
|
).filter((f) => f.tabItemId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(
|
|
_tabItemPurchasesRefsTable($_db),
|
|
);
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$TabItemsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $TabItemsTable> {
|
|
$$TabItemsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get productName => $composableBuilder(
|
|
column: $table.productName,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get quantity => $composableBuilder(
|
|
column: $table.quantity,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get unitPriceInCents => $composableBuilder(
|
|
column: $table.unitPriceInCents,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$BarTabsTableFilterComposer get tabId {
|
|
final $$BarTabsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.tabId,
|
|
referencedTable: $db.barTabs,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$BarTabsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.barTabs,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$ProductsTableFilterComposer get productId {
|
|
final $$ProductsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.productId,
|
|
referencedTable: $db.products,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ProductsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.products,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
Expression<bool> tabItemPurchasesRefs(
|
|
Expression<bool> Function($$TabItemPurchasesTableFilterComposer f) f,
|
|
) {
|
|
final $$TabItemPurchasesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.tabItemPurchases,
|
|
getReferencedColumn: (t) => t.tabItemId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TabItemPurchasesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.tabItemPurchases,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TabItemsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $TabItemsTable> {
|
|
$$TabItemsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get productName => $composableBuilder(
|
|
column: $table.productName,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get quantity => $composableBuilder(
|
|
column: $table.quantity,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get unitPriceInCents => $composableBuilder(
|
|
column: $table.unitPriceInCents,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$BarTabsTableOrderingComposer get tabId {
|
|
final $$BarTabsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.tabId,
|
|
referencedTable: $db.barTabs,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$BarTabsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.barTabs,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$ProductsTableOrderingComposer get productId {
|
|
final $$ProductsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.productId,
|
|
referencedTable: $db.products,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ProductsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.products,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TabItemsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $TabItemsTable> {
|
|
$$TabItemsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get productName => $composableBuilder(
|
|
column: $table.productName,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<int> get quantity =>
|
|
$composableBuilder(column: $table.quantity, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get unitPriceInCents => $composableBuilder(
|
|
column: $table.unitPriceInCents,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
$$BarTabsTableAnnotationComposer get tabId {
|
|
final $$BarTabsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.tabId,
|
|
referencedTable: $db.barTabs,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$BarTabsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.barTabs,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$ProductsTableAnnotationComposer get productId {
|
|
final $$ProductsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.productId,
|
|
referencedTable: $db.products,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ProductsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.products,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
Expression<T> tabItemPurchasesRefs<T extends Object>(
|
|
Expression<T> Function($$TabItemPurchasesTableAnnotationComposer a) f,
|
|
) {
|
|
final $$TabItemPurchasesTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.tabItemPurchases,
|
|
getReferencedColumn: (t) => t.tabItemId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TabItemPurchasesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.tabItemPurchases,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$TabItemsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$TabItemsTable,
|
|
TabItemRow,
|
|
$$TabItemsTableFilterComposer,
|
|
$$TabItemsTableOrderingComposer,
|
|
$$TabItemsTableAnnotationComposer,
|
|
$$TabItemsTableCreateCompanionBuilder,
|
|
$$TabItemsTableUpdateCompanionBuilder,
|
|
(TabItemRow, $$TabItemsTableReferences),
|
|
TabItemRow,
|
|
PrefetchHooks Function({
|
|
bool tabId,
|
|
bool productId,
|
|
bool tabItemPurchasesRefs,
|
|
})
|
|
> {
|
|
$$TabItemsTableTableManager(_$AppDatabase db, $TabItemsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$TabItemsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$TabItemsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$TabItemsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> tabId = const Value.absent(),
|
|
Value<String> productId = const Value.absent(),
|
|
Value<String> productName = const Value.absent(),
|
|
Value<int> quantity = const Value.absent(),
|
|
Value<int> unitPriceInCents = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => TabItemsCompanion(
|
|
id: id,
|
|
tabId: tabId,
|
|
productId: productId,
|
|
productName: productName,
|
|
quantity: quantity,
|
|
unitPriceInCents: unitPriceInCents,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String tabId,
|
|
required String productId,
|
|
required String productName,
|
|
required int quantity,
|
|
required int unitPriceInCents,
|
|
required DateTime createdAt,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => TabItemsCompanion.insert(
|
|
id: id,
|
|
tabId: tabId,
|
|
productId: productId,
|
|
productName: productName,
|
|
quantity: quantity,
|
|
unitPriceInCents: unitPriceInCents,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$TabItemsTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback:
|
|
({
|
|
tabId = false,
|
|
productId = false,
|
|
tabItemPurchasesRefs = false,
|
|
}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (tabItemPurchasesRefs) db.tabItemPurchases,
|
|
],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (tabId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.tabId,
|
|
referencedTable: $$TabItemsTableReferences
|
|
._tabIdTable(db),
|
|
referencedColumn: $$TabItemsTableReferences
|
|
._tabIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
if (productId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.productId,
|
|
referencedTable: $$TabItemsTableReferences
|
|
._productIdTable(db),
|
|
referencedColumn: $$TabItemsTableReferences
|
|
._productIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (tabItemPurchasesRefs)
|
|
await $_getPrefetchedData<
|
|
TabItemRow,
|
|
$TabItemsTable,
|
|
TabItemPurchaseRow
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$TabItemsTableReferences
|
|
._tabItemPurchasesRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$TabItemsTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).tabItemPurchasesRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems.where(
|
|
(e) => e.tabItemId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$TabItemsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$TabItemsTable,
|
|
TabItemRow,
|
|
$$TabItemsTableFilterComposer,
|
|
$$TabItemsTableOrderingComposer,
|
|
$$TabItemsTableAnnotationComposer,
|
|
$$TabItemsTableCreateCompanionBuilder,
|
|
$$TabItemsTableUpdateCompanionBuilder,
|
|
(TabItemRow, $$TabItemsTableReferences),
|
|
TabItemRow,
|
|
PrefetchHooks Function({
|
|
bool tabId,
|
|
bool productId,
|
|
bool tabItemPurchasesRefs,
|
|
})
|
|
>;
|
|
typedef $$TabItemPurchasesTableCreateCompanionBuilder =
|
|
TabItemPurchasesCompanion Function({
|
|
required String id,
|
|
required String tabItemId,
|
|
required DateTime purchasedAt,
|
|
Value<DateTime?> removedAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$TabItemPurchasesTableUpdateCompanionBuilder =
|
|
TabItemPurchasesCompanion Function({
|
|
Value<String> id,
|
|
Value<String> tabItemId,
|
|
Value<DateTime> purchasedAt,
|
|
Value<DateTime?> removedAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$TabItemPurchasesTableReferences
|
|
extends
|
|
BaseReferences<
|
|
_$AppDatabase,
|
|
$TabItemPurchasesTable,
|
|
TabItemPurchaseRow
|
|
> {
|
|
$$TabItemPurchasesTableReferences(
|
|
super.$_db,
|
|
super.$_table,
|
|
super.$_typedResult,
|
|
);
|
|
|
|
static $TabItemsTable _tabItemIdTable(_$AppDatabase db) =>
|
|
db.tabItems.createAlias('tab_item_purchases__tab_item_id__tab_items__id');
|
|
|
|
$$TabItemsTableProcessedTableManager get tabItemId {
|
|
final $_column = $_itemColumn<String>('tab_item_id')!;
|
|
|
|
final manager = $$TabItemsTableTableManager(
|
|
$_db,
|
|
$_db.tabItems,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_tabItemIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$TabItemPurchasesTableFilterComposer
|
|
extends Composer<_$AppDatabase, $TabItemPurchasesTable> {
|
|
$$TabItemPurchasesTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get purchasedAt => $composableBuilder(
|
|
column: $table.purchasedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get removedAt => $composableBuilder(
|
|
column: $table.removedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$TabItemsTableFilterComposer get tabItemId {
|
|
final $$TabItemsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.tabItemId,
|
|
referencedTable: $db.tabItems,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TabItemsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.tabItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TabItemPurchasesTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $TabItemPurchasesTable> {
|
|
$$TabItemPurchasesTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get purchasedAt => $composableBuilder(
|
|
column: $table.purchasedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get removedAt => $composableBuilder(
|
|
column: $table.removedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$TabItemsTableOrderingComposer get tabItemId {
|
|
final $$TabItemsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.tabItemId,
|
|
referencedTable: $db.tabItems,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TabItemsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.tabItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TabItemPurchasesTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $TabItemPurchasesTable> {
|
|
$$TabItemPurchasesTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get purchasedAt => $composableBuilder(
|
|
column: $table.purchasedAt,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get removedAt =>
|
|
$composableBuilder(column: $table.removedAt, builder: (column) => column);
|
|
|
|
$$TabItemsTableAnnotationComposer get tabItemId {
|
|
final $$TabItemsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.tabItemId,
|
|
referencedTable: $db.tabItems,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$TabItemsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.tabItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$TabItemPurchasesTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$TabItemPurchasesTable,
|
|
TabItemPurchaseRow,
|
|
$$TabItemPurchasesTableFilterComposer,
|
|
$$TabItemPurchasesTableOrderingComposer,
|
|
$$TabItemPurchasesTableAnnotationComposer,
|
|
$$TabItemPurchasesTableCreateCompanionBuilder,
|
|
$$TabItemPurchasesTableUpdateCompanionBuilder,
|
|
(TabItemPurchaseRow, $$TabItemPurchasesTableReferences),
|
|
TabItemPurchaseRow,
|
|
PrefetchHooks Function({bool tabItemId})
|
|
> {
|
|
$$TabItemPurchasesTableTableManager(
|
|
_$AppDatabase db,
|
|
$TabItemPurchasesTable table,
|
|
) : super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$TabItemPurchasesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$TabItemPurchasesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$TabItemPurchasesTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> tabItemId = const Value.absent(),
|
|
Value<DateTime> purchasedAt = const Value.absent(),
|
|
Value<DateTime?> removedAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => TabItemPurchasesCompanion(
|
|
id: id,
|
|
tabItemId: tabItemId,
|
|
purchasedAt: purchasedAt,
|
|
removedAt: removedAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String tabItemId,
|
|
required DateTime purchasedAt,
|
|
Value<DateTime?> removedAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => TabItemPurchasesCompanion.insert(
|
|
id: id,
|
|
tabItemId: tabItemId,
|
|
purchasedAt: purchasedAt,
|
|
removedAt: removedAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$TabItemPurchasesTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({tabItemId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (tabItemId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.tabItemId,
|
|
referencedTable:
|
|
$$TabItemPurchasesTableReferences
|
|
._tabItemIdTable(db),
|
|
referencedColumn:
|
|
$$TabItemPurchasesTableReferences
|
|
._tabItemIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$TabItemPurchasesTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$TabItemPurchasesTable,
|
|
TabItemPurchaseRow,
|
|
$$TabItemPurchasesTableFilterComposer,
|
|
$$TabItemPurchasesTableOrderingComposer,
|
|
$$TabItemPurchasesTableAnnotationComposer,
|
|
$$TabItemPurchasesTableCreateCompanionBuilder,
|
|
$$TabItemPurchasesTableUpdateCompanionBuilder,
|
|
(TabItemPurchaseRow, $$TabItemPurchasesTableReferences),
|
|
TabItemPurchaseRow,
|
|
PrefetchHooks Function({bool tabItemId})
|
|
>;
|
|
typedef $$ClosedTabsTableCreateCompanionBuilder =
|
|
ClosedTabsCompanion Function({
|
|
required String id,
|
|
required String originalTabId,
|
|
required String customerName,
|
|
required DateTime closedAt,
|
|
Value<PaymentMethod> paymentMethod,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$ClosedTabsTableUpdateCompanionBuilder =
|
|
ClosedTabsCompanion Function({
|
|
Value<String> id,
|
|
Value<String> originalTabId,
|
|
Value<String> customerName,
|
|
Value<DateTime> closedAt,
|
|
Value<PaymentMethod> paymentMethod,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$ClosedTabsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ClosedTabsTable> {
|
|
$$ClosedTabsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get originalTabId => $composableBuilder(
|
|
column: $table.originalTabId,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get customerName => $composableBuilder(
|
|
column: $table.customerName,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get closedAt => $composableBuilder(
|
|
column: $table.closedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnWithTypeConverterFilters<PaymentMethod, PaymentMethod, String>
|
|
get paymentMethod => $composableBuilder(
|
|
column: $table.paymentMethod,
|
|
builder: (column) => ColumnWithTypeConverterFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$ClosedTabsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ClosedTabsTable> {
|
|
$$ClosedTabsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get originalTabId => $composableBuilder(
|
|
column: $table.originalTabId,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get customerName => $composableBuilder(
|
|
column: $table.customerName,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get closedAt => $composableBuilder(
|
|
column: $table.closedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get paymentMethod => $composableBuilder(
|
|
column: $table.paymentMethod,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$ClosedTabsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ClosedTabsTable> {
|
|
$$ClosedTabsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get originalTabId => $composableBuilder(
|
|
column: $table.originalTabId,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get customerName => $composableBuilder(
|
|
column: $table.customerName,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get closedAt =>
|
|
$composableBuilder(column: $table.closedAt, builder: (column) => column);
|
|
|
|
GeneratedColumnWithTypeConverter<PaymentMethod, String> get paymentMethod =>
|
|
$composableBuilder(
|
|
column: $table.paymentMethod,
|
|
builder: (column) => column,
|
|
);
|
|
}
|
|
|
|
class $$ClosedTabsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$ClosedTabsTable,
|
|
ClosedTabsRow,
|
|
$$ClosedTabsTableFilterComposer,
|
|
$$ClosedTabsTableOrderingComposer,
|
|
$$ClosedTabsTableAnnotationComposer,
|
|
$$ClosedTabsTableCreateCompanionBuilder,
|
|
$$ClosedTabsTableUpdateCompanionBuilder,
|
|
(
|
|
ClosedTabsRow,
|
|
BaseReferences<_$AppDatabase, $ClosedTabsTable, ClosedTabsRow>,
|
|
),
|
|
ClosedTabsRow,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$ClosedTabsTableTableManager(_$AppDatabase db, $ClosedTabsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ClosedTabsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ClosedTabsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ClosedTabsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> originalTabId = const Value.absent(),
|
|
Value<String> customerName = const Value.absent(),
|
|
Value<DateTime> closedAt = const Value.absent(),
|
|
Value<PaymentMethod> paymentMethod = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ClosedTabsCompanion(
|
|
id: id,
|
|
originalTabId: originalTabId,
|
|
customerName: customerName,
|
|
closedAt: closedAt,
|
|
paymentMethod: paymentMethod,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String originalTabId,
|
|
required String customerName,
|
|
required DateTime closedAt,
|
|
Value<PaymentMethod> paymentMethod = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ClosedTabsCompanion.insert(
|
|
id: id,
|
|
originalTabId: originalTabId,
|
|
customerName: customerName,
|
|
closedAt: closedAt,
|
|
paymentMethod: paymentMethod,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$ClosedTabsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ClosedTabsTable,
|
|
ClosedTabsRow,
|
|
$$ClosedTabsTableFilterComposer,
|
|
$$ClosedTabsTableOrderingComposer,
|
|
$$ClosedTabsTableAnnotationComposer,
|
|
$$ClosedTabsTableCreateCompanionBuilder,
|
|
$$ClosedTabsTableUpdateCompanionBuilder,
|
|
(
|
|
ClosedTabsRow,
|
|
BaseReferences<_$AppDatabase, $ClosedTabsTable, ClosedTabsRow>,
|
|
),
|
|
ClosedTabsRow,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$ClosedTabItemsTableCreateCompanionBuilder =
|
|
ClosedTabItemsCompanion Function({
|
|
required String id,
|
|
required String closedTabId,
|
|
required String productId,
|
|
required String productName,
|
|
required int quantity,
|
|
required int unitPriceInCents,
|
|
Value<DateTime?> purchasedAt,
|
|
Value<DateTime?> removedAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$ClosedTabItemsTableUpdateCompanionBuilder =
|
|
ClosedTabItemsCompanion Function({
|
|
Value<String> id,
|
|
Value<String> closedTabId,
|
|
Value<String> productId,
|
|
Value<String> productName,
|
|
Value<int> quantity,
|
|
Value<int> unitPriceInCents,
|
|
Value<DateTime?> purchasedAt,
|
|
Value<DateTime?> removedAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$ClosedTabItemsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ClosedTabItemsTable> {
|
|
$$ClosedTabItemsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get closedTabId => $composableBuilder(
|
|
column: $table.closedTabId,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get productId => $composableBuilder(
|
|
column: $table.productId,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get productName => $composableBuilder(
|
|
column: $table.productName,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get quantity => $composableBuilder(
|
|
column: $table.quantity,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get unitPriceInCents => $composableBuilder(
|
|
column: $table.unitPriceInCents,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get purchasedAt => $composableBuilder(
|
|
column: $table.purchasedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get removedAt => $composableBuilder(
|
|
column: $table.removedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$ClosedTabItemsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ClosedTabItemsTable> {
|
|
$$ClosedTabItemsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get closedTabId => $composableBuilder(
|
|
column: $table.closedTabId,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get productId => $composableBuilder(
|
|
column: $table.productId,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get productName => $composableBuilder(
|
|
column: $table.productName,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get quantity => $composableBuilder(
|
|
column: $table.quantity,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get unitPriceInCents => $composableBuilder(
|
|
column: $table.unitPriceInCents,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get purchasedAt => $composableBuilder(
|
|
column: $table.purchasedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get removedAt => $composableBuilder(
|
|
column: $table.removedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$ClosedTabItemsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ClosedTabItemsTable> {
|
|
$$ClosedTabItemsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get closedTabId => $composableBuilder(
|
|
column: $table.closedTabId,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get productId =>
|
|
$composableBuilder(column: $table.productId, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get productName => $composableBuilder(
|
|
column: $table.productName,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<int> get quantity =>
|
|
$composableBuilder(column: $table.quantity, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get unitPriceInCents => $composableBuilder(
|
|
column: $table.unitPriceInCents,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get purchasedAt => $composableBuilder(
|
|
column: $table.purchasedAt,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get removedAt =>
|
|
$composableBuilder(column: $table.removedAt, builder: (column) => column);
|
|
}
|
|
|
|
class $$ClosedTabItemsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$ClosedTabItemsTable,
|
|
ClosedTabItemRow,
|
|
$$ClosedTabItemsTableFilterComposer,
|
|
$$ClosedTabItemsTableOrderingComposer,
|
|
$$ClosedTabItemsTableAnnotationComposer,
|
|
$$ClosedTabItemsTableCreateCompanionBuilder,
|
|
$$ClosedTabItemsTableUpdateCompanionBuilder,
|
|
(
|
|
ClosedTabItemRow,
|
|
BaseReferences<
|
|
_$AppDatabase,
|
|
$ClosedTabItemsTable,
|
|
ClosedTabItemRow
|
|
>,
|
|
),
|
|
ClosedTabItemRow,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$ClosedTabItemsTableTableManager(
|
|
_$AppDatabase db,
|
|
$ClosedTabItemsTable table,
|
|
) : super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ClosedTabItemsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ClosedTabItemsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ClosedTabItemsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> closedTabId = const Value.absent(),
|
|
Value<String> productId = const Value.absent(),
|
|
Value<String> productName = const Value.absent(),
|
|
Value<int> quantity = const Value.absent(),
|
|
Value<int> unitPriceInCents = const Value.absent(),
|
|
Value<DateTime?> purchasedAt = const Value.absent(),
|
|
Value<DateTime?> removedAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ClosedTabItemsCompanion(
|
|
id: id,
|
|
closedTabId: closedTabId,
|
|
productId: productId,
|
|
productName: productName,
|
|
quantity: quantity,
|
|
unitPriceInCents: unitPriceInCents,
|
|
purchasedAt: purchasedAt,
|
|
removedAt: removedAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String closedTabId,
|
|
required String productId,
|
|
required String productName,
|
|
required int quantity,
|
|
required int unitPriceInCents,
|
|
Value<DateTime?> purchasedAt = const Value.absent(),
|
|
Value<DateTime?> removedAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ClosedTabItemsCompanion.insert(
|
|
id: id,
|
|
closedTabId: closedTabId,
|
|
productId: productId,
|
|
productName: productName,
|
|
quantity: quantity,
|
|
unitPriceInCents: unitPriceInCents,
|
|
purchasedAt: purchasedAt,
|
|
removedAt: removedAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$ClosedTabItemsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ClosedTabItemsTable,
|
|
ClosedTabItemRow,
|
|
$$ClosedTabItemsTableFilterComposer,
|
|
$$ClosedTabItemsTableOrderingComposer,
|
|
$$ClosedTabItemsTableAnnotationComposer,
|
|
$$ClosedTabItemsTableCreateCompanionBuilder,
|
|
$$ClosedTabItemsTableUpdateCompanionBuilder,
|
|
(
|
|
ClosedTabItemRow,
|
|
BaseReferences<_$AppDatabase, $ClosedTabItemsTable, ClosedTabItemRow>,
|
|
),
|
|
ClosedTabItemRow,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$AppSettingsTableTableCreateCompanionBuilder =
|
|
AppSettingsTableCompanion Function({
|
|
required String id,
|
|
Value<bool> pinRequired,
|
|
Value<bool> autoLockEnabled,
|
|
Value<String> themeMode,
|
|
Value<String> language,
|
|
Value<int> barGridRows,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$AppSettingsTableTableUpdateCompanionBuilder =
|
|
AppSettingsTableCompanion Function({
|
|
Value<String> id,
|
|
Value<bool> pinRequired,
|
|
Value<bool> autoLockEnabled,
|
|
Value<String> themeMode,
|
|
Value<String> language,
|
|
Value<int> barGridRows,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$AppSettingsTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $AppSettingsTableTable> {
|
|
$$AppSettingsTableTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<bool> get pinRequired => $composableBuilder(
|
|
column: $table.pinRequired,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<bool> get autoLockEnabled => $composableBuilder(
|
|
column: $table.autoLockEnabled,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get themeMode => $composableBuilder(
|
|
column: $table.themeMode,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get language => $composableBuilder(
|
|
column: $table.language,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get barGridRows => $composableBuilder(
|
|
column: $table.barGridRows,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$AppSettingsTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $AppSettingsTableTable> {
|
|
$$AppSettingsTableTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<bool> get pinRequired => $composableBuilder(
|
|
column: $table.pinRequired,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<bool> get autoLockEnabled => $composableBuilder(
|
|
column: $table.autoLockEnabled,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get themeMode => $composableBuilder(
|
|
column: $table.themeMode,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get language => $composableBuilder(
|
|
column: $table.language,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get barGridRows => $composableBuilder(
|
|
column: $table.barGridRows,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$AppSettingsTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $AppSettingsTableTable> {
|
|
$$AppSettingsTableTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<bool> get pinRequired => $composableBuilder(
|
|
column: $table.pinRequired,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<bool> get autoLockEnabled => $composableBuilder(
|
|
column: $table.autoLockEnabled,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get themeMode =>
|
|
$composableBuilder(column: $table.themeMode, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get language =>
|
|
$composableBuilder(column: $table.language, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get barGridRows => $composableBuilder(
|
|
column: $table.barGridRows,
|
|
builder: (column) => column,
|
|
);
|
|
}
|
|
|
|
class $$AppSettingsTableTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$AppSettingsTableTable,
|
|
AppSettingsRow,
|
|
$$AppSettingsTableTableFilterComposer,
|
|
$$AppSettingsTableTableOrderingComposer,
|
|
$$AppSettingsTableTableAnnotationComposer,
|
|
$$AppSettingsTableTableCreateCompanionBuilder,
|
|
$$AppSettingsTableTableUpdateCompanionBuilder,
|
|
(
|
|
AppSettingsRow,
|
|
BaseReferences<
|
|
_$AppDatabase,
|
|
$AppSettingsTableTable,
|
|
AppSettingsRow
|
|
>,
|
|
),
|
|
AppSettingsRow,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$AppSettingsTableTableTableManager(
|
|
_$AppDatabase db,
|
|
$AppSettingsTableTable table,
|
|
) : super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$AppSettingsTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$AppSettingsTableTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$AppSettingsTableTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<bool> pinRequired = const Value.absent(),
|
|
Value<bool> autoLockEnabled = const Value.absent(),
|
|
Value<String> themeMode = const Value.absent(),
|
|
Value<String> language = const Value.absent(),
|
|
Value<int> barGridRows = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => AppSettingsTableCompanion(
|
|
id: id,
|
|
pinRequired: pinRequired,
|
|
autoLockEnabled: autoLockEnabled,
|
|
themeMode: themeMode,
|
|
language: language,
|
|
barGridRows: barGridRows,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
Value<bool> pinRequired = const Value.absent(),
|
|
Value<bool> autoLockEnabled = const Value.absent(),
|
|
Value<String> themeMode = const Value.absent(),
|
|
Value<String> language = const Value.absent(),
|
|
Value<int> barGridRows = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => AppSettingsTableCompanion.insert(
|
|
id: id,
|
|
pinRequired: pinRequired,
|
|
autoLockEnabled: autoLockEnabled,
|
|
themeMode: themeMode,
|
|
language: language,
|
|
barGridRows: barGridRows,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$AppSettingsTableTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$AppSettingsTableTable,
|
|
AppSettingsRow,
|
|
$$AppSettingsTableTableFilterComposer,
|
|
$$AppSettingsTableTableOrderingComposer,
|
|
$$AppSettingsTableTableAnnotationComposer,
|
|
$$AppSettingsTableTableCreateCompanionBuilder,
|
|
$$AppSettingsTableTableUpdateCompanionBuilder,
|
|
(
|
|
AppSettingsRow,
|
|
BaseReferences<_$AppDatabase, $AppSettingsTableTable, AppSettingsRow>,
|
|
),
|
|
AppSettingsRow,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$RemoteSyncStateTableCreateCompanionBuilder =
|
|
RemoteSyncStateCompanion Function({
|
|
required String deviceId,
|
|
Value<String?> serverCursor,
|
|
Value<DateTime?> lastSuccessfulSyncAt,
|
|
Value<DateTime?> lastAttemptedSyncAt,
|
|
Value<int> consecutiveFailureCount,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$RemoteSyncStateTableUpdateCompanionBuilder =
|
|
RemoteSyncStateCompanion Function({
|
|
Value<String> deviceId,
|
|
Value<String?> serverCursor,
|
|
Value<DateTime?> lastSuccessfulSyncAt,
|
|
Value<DateTime?> lastAttemptedSyncAt,
|
|
Value<int> consecutiveFailureCount,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$RemoteSyncStateTableFilterComposer
|
|
extends Composer<_$AppDatabase, $RemoteSyncStateTable> {
|
|
$$RemoteSyncStateTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get deviceId => $composableBuilder(
|
|
column: $table.deviceId,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get serverCursor => $composableBuilder(
|
|
column: $table.serverCursor,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get lastSuccessfulSyncAt => $composableBuilder(
|
|
column: $table.lastSuccessfulSyncAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get lastAttemptedSyncAt => $composableBuilder(
|
|
column: $table.lastAttemptedSyncAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get consecutiveFailureCount => $composableBuilder(
|
|
column: $table.consecutiveFailureCount,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$RemoteSyncStateTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $RemoteSyncStateTable> {
|
|
$$RemoteSyncStateTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get deviceId => $composableBuilder(
|
|
column: $table.deviceId,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get serverCursor => $composableBuilder(
|
|
column: $table.serverCursor,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get lastSuccessfulSyncAt => $composableBuilder(
|
|
column: $table.lastSuccessfulSyncAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get lastAttemptedSyncAt => $composableBuilder(
|
|
column: $table.lastAttemptedSyncAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get consecutiveFailureCount => $composableBuilder(
|
|
column: $table.consecutiveFailureCount,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$RemoteSyncStateTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $RemoteSyncStateTable> {
|
|
$$RemoteSyncStateTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get deviceId =>
|
|
$composableBuilder(column: $table.deviceId, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get serverCursor => $composableBuilder(
|
|
column: $table.serverCursor,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get lastSuccessfulSyncAt => $composableBuilder(
|
|
column: $table.lastSuccessfulSyncAt,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get lastAttemptedSyncAt => $composableBuilder(
|
|
column: $table.lastAttemptedSyncAt,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<int> get consecutiveFailureCount => $composableBuilder(
|
|
column: $table.consecutiveFailureCount,
|
|
builder: (column) => column,
|
|
);
|
|
}
|
|
|
|
class $$RemoteSyncStateTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$RemoteSyncStateTable,
|
|
RemoteSyncStateRow,
|
|
$$RemoteSyncStateTableFilterComposer,
|
|
$$RemoteSyncStateTableOrderingComposer,
|
|
$$RemoteSyncStateTableAnnotationComposer,
|
|
$$RemoteSyncStateTableCreateCompanionBuilder,
|
|
$$RemoteSyncStateTableUpdateCompanionBuilder,
|
|
(
|
|
RemoteSyncStateRow,
|
|
BaseReferences<
|
|
_$AppDatabase,
|
|
$RemoteSyncStateTable,
|
|
RemoteSyncStateRow
|
|
>,
|
|
),
|
|
RemoteSyncStateRow,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$RemoteSyncStateTableTableManager(
|
|
_$AppDatabase db,
|
|
$RemoteSyncStateTable table,
|
|
) : super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$RemoteSyncStateTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$RemoteSyncStateTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$RemoteSyncStateTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> deviceId = const Value.absent(),
|
|
Value<String?> serverCursor = const Value.absent(),
|
|
Value<DateTime?> lastSuccessfulSyncAt = const Value.absent(),
|
|
Value<DateTime?> lastAttemptedSyncAt = const Value.absent(),
|
|
Value<int> consecutiveFailureCount = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => RemoteSyncStateCompanion(
|
|
deviceId: deviceId,
|
|
serverCursor: serverCursor,
|
|
lastSuccessfulSyncAt: lastSuccessfulSyncAt,
|
|
lastAttemptedSyncAt: lastAttemptedSyncAt,
|
|
consecutiveFailureCount: consecutiveFailureCount,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String deviceId,
|
|
Value<String?> serverCursor = const Value.absent(),
|
|
Value<DateTime?> lastSuccessfulSyncAt = const Value.absent(),
|
|
Value<DateTime?> lastAttemptedSyncAt = const Value.absent(),
|
|
Value<int> consecutiveFailureCount = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => RemoteSyncStateCompanion.insert(
|
|
deviceId: deviceId,
|
|
serverCursor: serverCursor,
|
|
lastSuccessfulSyncAt: lastSuccessfulSyncAt,
|
|
lastAttemptedSyncAt: lastAttemptedSyncAt,
|
|
consecutiveFailureCount: consecutiveFailureCount,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$RemoteSyncStateTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$RemoteSyncStateTable,
|
|
RemoteSyncStateRow,
|
|
$$RemoteSyncStateTableFilterComposer,
|
|
$$RemoteSyncStateTableOrderingComposer,
|
|
$$RemoteSyncStateTableAnnotationComposer,
|
|
$$RemoteSyncStateTableCreateCompanionBuilder,
|
|
$$RemoteSyncStateTableUpdateCompanionBuilder,
|
|
(
|
|
RemoteSyncStateRow,
|
|
BaseReferences<
|
|
_$AppDatabase,
|
|
$RemoteSyncStateTable,
|
|
RemoteSyncStateRow
|
|
>,
|
|
),
|
|
RemoteSyncStateRow,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$ProcessedRemoteCommandsTableCreateCompanionBuilder =
|
|
ProcessedRemoteCommandsCompanion Function({
|
|
required String commandId,
|
|
required String commandType,
|
|
required DateTime processedAt,
|
|
required CommandResult result,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$ProcessedRemoteCommandsTableUpdateCompanionBuilder =
|
|
ProcessedRemoteCommandsCompanion Function({
|
|
Value<String> commandId,
|
|
Value<String> commandType,
|
|
Value<DateTime> processedAt,
|
|
Value<CommandResult> result,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$ProcessedRemoteCommandsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ProcessedRemoteCommandsTable> {
|
|
$$ProcessedRemoteCommandsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get commandId => $composableBuilder(
|
|
column: $table.commandId,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get commandType => $composableBuilder(
|
|
column: $table.commandType,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get processedAt => $composableBuilder(
|
|
column: $table.processedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnWithTypeConverterFilters<CommandResult, CommandResult, String>
|
|
get result => $composableBuilder(
|
|
column: $table.result,
|
|
builder: (column) => ColumnWithTypeConverterFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$ProcessedRemoteCommandsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ProcessedRemoteCommandsTable> {
|
|
$$ProcessedRemoteCommandsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get commandId => $composableBuilder(
|
|
column: $table.commandId,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get commandType => $composableBuilder(
|
|
column: $table.commandType,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get processedAt => $composableBuilder(
|
|
column: $table.processedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get result => $composableBuilder(
|
|
column: $table.result,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$ProcessedRemoteCommandsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ProcessedRemoteCommandsTable> {
|
|
$$ProcessedRemoteCommandsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get commandId =>
|
|
$composableBuilder(column: $table.commandId, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get commandType => $composableBuilder(
|
|
column: $table.commandType,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<DateTime> get processedAt => $composableBuilder(
|
|
column: $table.processedAt,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumnWithTypeConverter<CommandResult, String> get result =>
|
|
$composableBuilder(column: $table.result, builder: (column) => column);
|
|
}
|
|
|
|
class $$ProcessedRemoteCommandsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$ProcessedRemoteCommandsTable,
|
|
ProcessedRemoteCommandRow,
|
|
$$ProcessedRemoteCommandsTableFilterComposer,
|
|
$$ProcessedRemoteCommandsTableOrderingComposer,
|
|
$$ProcessedRemoteCommandsTableAnnotationComposer,
|
|
$$ProcessedRemoteCommandsTableCreateCompanionBuilder,
|
|
$$ProcessedRemoteCommandsTableUpdateCompanionBuilder,
|
|
(
|
|
ProcessedRemoteCommandRow,
|
|
BaseReferences<
|
|
_$AppDatabase,
|
|
$ProcessedRemoteCommandsTable,
|
|
ProcessedRemoteCommandRow
|
|
>,
|
|
),
|
|
ProcessedRemoteCommandRow,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$ProcessedRemoteCommandsTableTableManager(
|
|
_$AppDatabase db,
|
|
$ProcessedRemoteCommandsTable table,
|
|
) : super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ProcessedRemoteCommandsTableFilterComposer(
|
|
$db: db,
|
|
$table: table,
|
|
),
|
|
createOrderingComposer: () =>
|
|
$$ProcessedRemoteCommandsTableOrderingComposer(
|
|
$db: db,
|
|
$table: table,
|
|
),
|
|
createComputedFieldComposer: () =>
|
|
$$ProcessedRemoteCommandsTableAnnotationComposer(
|
|
$db: db,
|
|
$table: table,
|
|
),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> commandId = const Value.absent(),
|
|
Value<String> commandType = const Value.absent(),
|
|
Value<DateTime> processedAt = const Value.absent(),
|
|
Value<CommandResult> result = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ProcessedRemoteCommandsCompanion(
|
|
commandId: commandId,
|
|
commandType: commandType,
|
|
processedAt: processedAt,
|
|
result: result,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String commandId,
|
|
required String commandType,
|
|
required DateTime processedAt,
|
|
required CommandResult result,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ProcessedRemoteCommandsCompanion.insert(
|
|
commandId: commandId,
|
|
commandType: commandType,
|
|
processedAt: processedAt,
|
|
result: result,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$ProcessedRemoteCommandsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ProcessedRemoteCommandsTable,
|
|
ProcessedRemoteCommandRow,
|
|
$$ProcessedRemoteCommandsTableFilterComposer,
|
|
$$ProcessedRemoteCommandsTableOrderingComposer,
|
|
$$ProcessedRemoteCommandsTableAnnotationComposer,
|
|
$$ProcessedRemoteCommandsTableCreateCompanionBuilder,
|
|
$$ProcessedRemoteCommandsTableUpdateCompanionBuilder,
|
|
(
|
|
ProcessedRemoteCommandRow,
|
|
BaseReferences<
|
|
_$AppDatabase,
|
|
$ProcessedRemoteCommandsTable,
|
|
ProcessedRemoteCommandRow
|
|
>,
|
|
),
|
|
ProcessedRemoteCommandRow,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$TabEventsTableCreateCompanionBuilder =
|
|
TabEventsCompanion Function({
|
|
required String id,
|
|
required String payload,
|
|
required DateTime createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$TabEventsTableUpdateCompanionBuilder =
|
|
TabEventsCompanion Function({
|
|
Value<String> id,
|
|
Value<String> payload,
|
|
Value<DateTime> createdAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$TabEventsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $TabEventsTable> {
|
|
$$TabEventsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get payload => $composableBuilder(
|
|
column: $table.payload,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$TabEventsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $TabEventsTable> {
|
|
$$TabEventsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get payload => $composableBuilder(
|
|
column: $table.payload,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$TabEventsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $TabEventsTable> {
|
|
$$TabEventsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get payload =>
|
|
$composableBuilder(column: $table.payload, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
}
|
|
|
|
class $$TabEventsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$TabEventsTable,
|
|
TabEventRow,
|
|
$$TabEventsTableFilterComposer,
|
|
$$TabEventsTableOrderingComposer,
|
|
$$TabEventsTableAnnotationComposer,
|
|
$$TabEventsTableCreateCompanionBuilder,
|
|
$$TabEventsTableUpdateCompanionBuilder,
|
|
(
|
|
TabEventRow,
|
|
BaseReferences<_$AppDatabase, $TabEventsTable, TabEventRow>,
|
|
),
|
|
TabEventRow,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$TabEventsTableTableManager(_$AppDatabase db, $TabEventsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$TabEventsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$TabEventsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$TabEventsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> payload = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => TabEventsCompanion(
|
|
id: id,
|
|
payload: payload,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String payload,
|
|
required DateTime createdAt,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => TabEventsCompanion.insert(
|
|
id: id,
|
|
payload: payload,
|
|
createdAt: createdAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$TabEventsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$TabEventsTable,
|
|
TabEventRow,
|
|
$$TabEventsTableFilterComposer,
|
|
$$TabEventsTableOrderingComposer,
|
|
$$TabEventsTableAnnotationComposer,
|
|
$$TabEventsTableCreateCompanionBuilder,
|
|
$$TabEventsTableUpdateCompanionBuilder,
|
|
(
|
|
TabEventRow,
|
|
BaseReferences<_$AppDatabase, $TabEventsTable, TabEventRow>,
|
|
),
|
|
TabEventRow,
|
|
PrefetchHooks Function()
|
|
>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$ProductsTableTableManager get products =>
|
|
$$ProductsTableTableManager(_db, _db.products);
|
|
$$BarTabsTableTableManager get barTabs =>
|
|
$$BarTabsTableTableManager(_db, _db.barTabs);
|
|
$$TabItemsTableTableManager get tabItems =>
|
|
$$TabItemsTableTableManager(_db, _db.tabItems);
|
|
$$TabItemPurchasesTableTableManager get tabItemPurchases =>
|
|
$$TabItemPurchasesTableTableManager(_db, _db.tabItemPurchases);
|
|
$$ClosedTabsTableTableManager get closedTabs =>
|
|
$$ClosedTabsTableTableManager(_db, _db.closedTabs);
|
|
$$ClosedTabItemsTableTableManager get closedTabItems =>
|
|
$$ClosedTabItemsTableTableManager(_db, _db.closedTabItems);
|
|
$$AppSettingsTableTableTableManager get appSettingsTable =>
|
|
$$AppSettingsTableTableTableManager(_db, _db.appSettingsTable);
|
|
$$RemoteSyncStateTableTableManager get remoteSyncState =>
|
|
$$RemoteSyncStateTableTableManager(_db, _db.remoteSyncState);
|
|
$$ProcessedRemoteCommandsTableTableManager get processedRemoteCommands =>
|
|
$$ProcessedRemoteCommandsTableTableManager(
|
|
_db,
|
|
_db.processedRemoteCommands,
|
|
);
|
|
$$TabEventsTableTableManager get tabEvents =>
|
|
$$TabEventsTableTableManager(_db, _db.tabEvents);
|
|
}
|