3070 lines
96 KiB
Dart
3070 lines
96 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $CustomersTable extends Customers
|
|
with TableInfo<$CustomersTable, Customer> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$CustomersTable(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 _displayNameMeta = const VerificationMeta(
|
|
'displayName',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> displayName = GeneratedColumn<String>(
|
|
'display_name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _formalNameMeta = const VerificationMeta(
|
|
'formalName',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> formalName = GeneratedColumn<String>(
|
|
'formal_name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _addressMeta = const VerificationMeta(
|
|
'address',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> address = GeneratedColumn<String>(
|
|
'address',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _zipCodeMeta = const VerificationMeta(
|
|
'zipCode',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> zipCode = GeneratedColumn<String>(
|
|
'zip_code',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _departmentMeta = const VerificationMeta(
|
|
'department',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> department = GeneratedColumn<String>(
|
|
'department',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _latitudeMeta = const VerificationMeta(
|
|
'latitude',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<double> latitude = GeneratedColumn<double>(
|
|
'latitude',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.double,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _longitudeMeta = const VerificationMeta(
|
|
'longitude',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<double> longitude = GeneratedColumn<double>(
|
|
'longitude',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.double,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _lastUpdatedAtMeta = const VerificationMeta(
|
|
'lastUpdatedAt',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<DateTime> lastUpdatedAt =
|
|
GeneratedColumn<DateTime>(
|
|
'last_updated_at',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
displayName,
|
|
formalName,
|
|
address,
|
|
zipCode,
|
|
department,
|
|
latitude,
|
|
longitude,
|
|
lastUpdatedAt,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'customers';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Customer> 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('display_name')) {
|
|
context.handle(
|
|
_displayNameMeta,
|
|
displayName.isAcceptableOrUnknown(
|
|
data['display_name']!,
|
|
_displayNameMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_displayNameMeta);
|
|
}
|
|
if (data.containsKey('formal_name')) {
|
|
context.handle(
|
|
_formalNameMeta,
|
|
formalName.isAcceptableOrUnknown(data['formal_name']!, _formalNameMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_formalNameMeta);
|
|
}
|
|
if (data.containsKey('address')) {
|
|
context.handle(
|
|
_addressMeta,
|
|
address.isAcceptableOrUnknown(data['address']!, _addressMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('zip_code')) {
|
|
context.handle(
|
|
_zipCodeMeta,
|
|
zipCode.isAcceptableOrUnknown(data['zip_code']!, _zipCodeMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('department')) {
|
|
context.handle(
|
|
_departmentMeta,
|
|
department.isAcceptableOrUnknown(data['department']!, _departmentMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('latitude')) {
|
|
context.handle(
|
|
_latitudeMeta,
|
|
latitude.isAcceptableOrUnknown(data['latitude']!, _latitudeMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('longitude')) {
|
|
context.handle(
|
|
_longitudeMeta,
|
|
longitude.isAcceptableOrUnknown(data['longitude']!, _longitudeMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('last_updated_at')) {
|
|
context.handle(
|
|
_lastUpdatedAtMeta,
|
|
lastUpdatedAt.isAcceptableOrUnknown(
|
|
data['last_updated_at']!,
|
|
_lastUpdatedAtMeta,
|
|
),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Customer map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Customer(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
displayName: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}display_name'],
|
|
)!,
|
|
formalName: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}formal_name'],
|
|
)!,
|
|
address: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}address'],
|
|
),
|
|
zipCode: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}zip_code'],
|
|
),
|
|
department: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}department'],
|
|
),
|
|
latitude: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.double,
|
|
data['${effectivePrefix}latitude'],
|
|
),
|
|
longitude: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.double,
|
|
data['${effectivePrefix}longitude'],
|
|
),
|
|
lastUpdatedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}last_updated_at'],
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$CustomersTable createAlias(String alias) {
|
|
return $CustomersTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Customer extends DataClass implements Insertable<Customer> {
|
|
final String id;
|
|
final String displayName;
|
|
final String formalName;
|
|
final String? address;
|
|
final String? zipCode;
|
|
final String? department;
|
|
final double? latitude;
|
|
final double? longitude;
|
|
final DateTime? lastUpdatedAt;
|
|
const Customer({
|
|
required this.id,
|
|
required this.displayName,
|
|
required this.formalName,
|
|
this.address,
|
|
this.zipCode,
|
|
this.department,
|
|
this.latitude,
|
|
this.longitude,
|
|
this.lastUpdatedAt,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['display_name'] = Variable<String>(displayName);
|
|
map['formal_name'] = Variable<String>(formalName);
|
|
if (!nullToAbsent || address != null) {
|
|
map['address'] = Variable<String>(address);
|
|
}
|
|
if (!nullToAbsent || zipCode != null) {
|
|
map['zip_code'] = Variable<String>(zipCode);
|
|
}
|
|
if (!nullToAbsent || department != null) {
|
|
map['department'] = Variable<String>(department);
|
|
}
|
|
if (!nullToAbsent || latitude != null) {
|
|
map['latitude'] = Variable<double>(latitude);
|
|
}
|
|
if (!nullToAbsent || longitude != null) {
|
|
map['longitude'] = Variable<double>(longitude);
|
|
}
|
|
if (!nullToAbsent || lastUpdatedAt != null) {
|
|
map['last_updated_at'] = Variable<DateTime>(lastUpdatedAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
CustomersCompanion toCompanion(bool nullToAbsent) {
|
|
return CustomersCompanion(
|
|
id: Value(id),
|
|
displayName: Value(displayName),
|
|
formalName: Value(formalName),
|
|
address: address == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(address),
|
|
zipCode: zipCode == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(zipCode),
|
|
department: department == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(department),
|
|
latitude: latitude == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(latitude),
|
|
longitude: longitude == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(longitude),
|
|
lastUpdatedAt: lastUpdatedAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(lastUpdatedAt),
|
|
);
|
|
}
|
|
|
|
factory Customer.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Customer(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
displayName: serializer.fromJson<String>(json['displayName']),
|
|
formalName: serializer.fromJson<String>(json['formalName']),
|
|
address: serializer.fromJson<String?>(json['address']),
|
|
zipCode: serializer.fromJson<String?>(json['zipCode']),
|
|
department: serializer.fromJson<String?>(json['department']),
|
|
latitude: serializer.fromJson<double?>(json['latitude']),
|
|
longitude: serializer.fromJson<double?>(json['longitude']),
|
|
lastUpdatedAt: serializer.fromJson<DateTime?>(json['lastUpdatedAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'displayName': serializer.toJson<String>(displayName),
|
|
'formalName': serializer.toJson<String>(formalName),
|
|
'address': serializer.toJson<String?>(address),
|
|
'zipCode': serializer.toJson<String?>(zipCode),
|
|
'department': serializer.toJson<String?>(department),
|
|
'latitude': serializer.toJson<double?>(latitude),
|
|
'longitude': serializer.toJson<double?>(longitude),
|
|
'lastUpdatedAt': serializer.toJson<DateTime?>(lastUpdatedAt),
|
|
};
|
|
}
|
|
|
|
Customer copyWith({
|
|
String? id,
|
|
String? displayName,
|
|
String? formalName,
|
|
Value<String?> address = const Value.absent(),
|
|
Value<String?> zipCode = const Value.absent(),
|
|
Value<String?> department = const Value.absent(),
|
|
Value<double?> latitude = const Value.absent(),
|
|
Value<double?> longitude = const Value.absent(),
|
|
Value<DateTime?> lastUpdatedAt = const Value.absent(),
|
|
}) => Customer(
|
|
id: id ?? this.id,
|
|
displayName: displayName ?? this.displayName,
|
|
formalName: formalName ?? this.formalName,
|
|
address: address.present ? address.value : this.address,
|
|
zipCode: zipCode.present ? zipCode.value : this.zipCode,
|
|
department: department.present ? department.value : this.department,
|
|
latitude: latitude.present ? latitude.value : this.latitude,
|
|
longitude: longitude.present ? longitude.value : this.longitude,
|
|
lastUpdatedAt: lastUpdatedAt.present
|
|
? lastUpdatedAt.value
|
|
: this.lastUpdatedAt,
|
|
);
|
|
Customer copyWithCompanion(CustomersCompanion data) {
|
|
return Customer(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
displayName: data.displayName.present
|
|
? data.displayName.value
|
|
: this.displayName,
|
|
formalName: data.formalName.present
|
|
? data.formalName.value
|
|
: this.formalName,
|
|
address: data.address.present ? data.address.value : this.address,
|
|
zipCode: data.zipCode.present ? data.zipCode.value : this.zipCode,
|
|
department: data.department.present
|
|
? data.department.value
|
|
: this.department,
|
|
latitude: data.latitude.present ? data.latitude.value : this.latitude,
|
|
longitude: data.longitude.present ? data.longitude.value : this.longitude,
|
|
lastUpdatedAt: data.lastUpdatedAt.present
|
|
? data.lastUpdatedAt.value
|
|
: this.lastUpdatedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Customer(')
|
|
..write('id: $id, ')
|
|
..write('displayName: $displayName, ')
|
|
..write('formalName: $formalName, ')
|
|
..write('address: $address, ')
|
|
..write('zipCode: $zipCode, ')
|
|
..write('department: $department, ')
|
|
..write('latitude: $latitude, ')
|
|
..write('longitude: $longitude, ')
|
|
..write('lastUpdatedAt: $lastUpdatedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
displayName,
|
|
formalName,
|
|
address,
|
|
zipCode,
|
|
department,
|
|
latitude,
|
|
longitude,
|
|
lastUpdatedAt,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Customer &&
|
|
other.id == this.id &&
|
|
other.displayName == this.displayName &&
|
|
other.formalName == this.formalName &&
|
|
other.address == this.address &&
|
|
other.zipCode == this.zipCode &&
|
|
other.department == this.department &&
|
|
other.latitude == this.latitude &&
|
|
other.longitude == this.longitude &&
|
|
other.lastUpdatedAt == this.lastUpdatedAt);
|
|
}
|
|
|
|
class CustomersCompanion extends UpdateCompanion<Customer> {
|
|
final Value<String> id;
|
|
final Value<String> displayName;
|
|
final Value<String> formalName;
|
|
final Value<String?> address;
|
|
final Value<String?> zipCode;
|
|
final Value<String?> department;
|
|
final Value<double?> latitude;
|
|
final Value<double?> longitude;
|
|
final Value<DateTime?> lastUpdatedAt;
|
|
final Value<int> rowid;
|
|
const CustomersCompanion({
|
|
this.id = const Value.absent(),
|
|
this.displayName = const Value.absent(),
|
|
this.formalName = const Value.absent(),
|
|
this.address = const Value.absent(),
|
|
this.zipCode = const Value.absent(),
|
|
this.department = const Value.absent(),
|
|
this.latitude = const Value.absent(),
|
|
this.longitude = const Value.absent(),
|
|
this.lastUpdatedAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
CustomersCompanion.insert({
|
|
required String id,
|
|
required String displayName,
|
|
required String formalName,
|
|
this.address = const Value.absent(),
|
|
this.zipCode = const Value.absent(),
|
|
this.department = const Value.absent(),
|
|
this.latitude = const Value.absent(),
|
|
this.longitude = const Value.absent(),
|
|
this.lastUpdatedAt = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
displayName = Value(displayName),
|
|
formalName = Value(formalName);
|
|
static Insertable<Customer> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? displayName,
|
|
Expression<String>? formalName,
|
|
Expression<String>? address,
|
|
Expression<String>? zipCode,
|
|
Expression<String>? department,
|
|
Expression<double>? latitude,
|
|
Expression<double>? longitude,
|
|
Expression<DateTime>? lastUpdatedAt,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (displayName != null) 'display_name': displayName,
|
|
if (formalName != null) 'formal_name': formalName,
|
|
if (address != null) 'address': address,
|
|
if (zipCode != null) 'zip_code': zipCode,
|
|
if (department != null) 'department': department,
|
|
if (latitude != null) 'latitude': latitude,
|
|
if (longitude != null) 'longitude': longitude,
|
|
if (lastUpdatedAt != null) 'last_updated_at': lastUpdatedAt,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
CustomersCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? displayName,
|
|
Value<String>? formalName,
|
|
Value<String?>? address,
|
|
Value<String?>? zipCode,
|
|
Value<String?>? department,
|
|
Value<double?>? latitude,
|
|
Value<double?>? longitude,
|
|
Value<DateTime?>? lastUpdatedAt,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return CustomersCompanion(
|
|
id: id ?? this.id,
|
|
displayName: displayName ?? this.displayName,
|
|
formalName: formalName ?? this.formalName,
|
|
address: address ?? this.address,
|
|
zipCode: zipCode ?? this.zipCode,
|
|
department: department ?? this.department,
|
|
latitude: latitude ?? this.latitude,
|
|
longitude: longitude ?? this.longitude,
|
|
lastUpdatedAt: lastUpdatedAt ?? this.lastUpdatedAt,
|
|
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 (displayName.present) {
|
|
map['display_name'] = Variable<String>(displayName.value);
|
|
}
|
|
if (formalName.present) {
|
|
map['formal_name'] = Variable<String>(formalName.value);
|
|
}
|
|
if (address.present) {
|
|
map['address'] = Variable<String>(address.value);
|
|
}
|
|
if (zipCode.present) {
|
|
map['zip_code'] = Variable<String>(zipCode.value);
|
|
}
|
|
if (department.present) {
|
|
map['department'] = Variable<String>(department.value);
|
|
}
|
|
if (latitude.present) {
|
|
map['latitude'] = Variable<double>(latitude.value);
|
|
}
|
|
if (longitude.present) {
|
|
map['longitude'] = Variable<double>(longitude.value);
|
|
}
|
|
if (lastUpdatedAt.present) {
|
|
map['last_updated_at'] = Variable<DateTime>(lastUpdatedAt.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('CustomersCompanion(')
|
|
..write('id: $id, ')
|
|
..write('displayName: $displayName, ')
|
|
..write('formalName: $formalName, ')
|
|
..write('address: $address, ')
|
|
..write('zipCode: $zipCode, ')
|
|
..write('department: $department, ')
|
|
..write('latitude: $latitude, ')
|
|
..write('longitude: $longitude, ')
|
|
..write('lastUpdatedAt: $lastUpdatedAt, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ProductsTable extends Products with TableInfo<$ProductsTable, Product> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ProductsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _nameMeta = const VerificationMeta('name');
|
|
@override
|
|
late final GeneratedColumn<String> name = GeneratedColumn<String>(
|
|
'name',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _defaultPriceMeta = const VerificationMeta(
|
|
'defaultPrice',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> defaultPrice = GeneratedColumn<int>(
|
|
'default_price',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _categoryMeta = const VerificationMeta(
|
|
'category',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> category = GeneratedColumn<String>(
|
|
'category',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, name, defaultPrice, category];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'products';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Product> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('name')) {
|
|
context.handle(
|
|
_nameMeta,
|
|
name.isAcceptableOrUnknown(data['name']!, _nameMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_nameMeta);
|
|
}
|
|
if (data.containsKey('default_price')) {
|
|
context.handle(
|
|
_defaultPriceMeta,
|
|
defaultPrice.isAcceptableOrUnknown(
|
|
data['default_price']!,
|
|
_defaultPriceMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_defaultPriceMeta);
|
|
}
|
|
if (data.containsKey('category')) {
|
|
context.handle(
|
|
_categoryMeta,
|
|
category.isAcceptableOrUnknown(data['category']!, _categoryMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Product map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Product(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
name: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}name'],
|
|
)!,
|
|
defaultPrice: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}default_price'],
|
|
)!,
|
|
category: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}category'],
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ProductsTable createAlias(String alias) {
|
|
return $ProductsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Product extends DataClass implements Insertable<Product> {
|
|
final int id;
|
|
final String name;
|
|
final int defaultPrice;
|
|
final String? category;
|
|
const Product({
|
|
required this.id,
|
|
required this.name,
|
|
required this.defaultPrice,
|
|
this.category,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['name'] = Variable<String>(name);
|
|
map['default_price'] = Variable<int>(defaultPrice);
|
|
if (!nullToAbsent || category != null) {
|
|
map['category'] = Variable<String>(category);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
ProductsCompanion toCompanion(bool nullToAbsent) {
|
|
return ProductsCompanion(
|
|
id: Value(id),
|
|
name: Value(name),
|
|
defaultPrice: Value(defaultPrice),
|
|
category: category == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(category),
|
|
);
|
|
}
|
|
|
|
factory Product.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Product(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
name: serializer.fromJson<String>(json['name']),
|
|
defaultPrice: serializer.fromJson<int>(json['defaultPrice']),
|
|
category: serializer.fromJson<String?>(json['category']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'name': serializer.toJson<String>(name),
|
|
'defaultPrice': serializer.toJson<int>(defaultPrice),
|
|
'category': serializer.toJson<String?>(category),
|
|
};
|
|
}
|
|
|
|
Product copyWith({
|
|
int? id,
|
|
String? name,
|
|
int? defaultPrice,
|
|
Value<String?> category = const Value.absent(),
|
|
}) => Product(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
defaultPrice: defaultPrice ?? this.defaultPrice,
|
|
category: category.present ? category.value : this.category,
|
|
);
|
|
Product copyWithCompanion(ProductsCompanion data) {
|
|
return Product(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
name: data.name.present ? data.name.value : this.name,
|
|
defaultPrice: data.defaultPrice.present
|
|
? data.defaultPrice.value
|
|
: this.defaultPrice,
|
|
category: data.category.present ? data.category.value : this.category,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Product(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('defaultPrice: $defaultPrice, ')
|
|
..write('category: $category')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, name, defaultPrice, category);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Product &&
|
|
other.id == this.id &&
|
|
other.name == this.name &&
|
|
other.defaultPrice == this.defaultPrice &&
|
|
other.category == this.category);
|
|
}
|
|
|
|
class ProductsCompanion extends UpdateCompanion<Product> {
|
|
final Value<int> id;
|
|
final Value<String> name;
|
|
final Value<int> defaultPrice;
|
|
final Value<String?> category;
|
|
const ProductsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.name = const Value.absent(),
|
|
this.defaultPrice = const Value.absent(),
|
|
this.category = const Value.absent(),
|
|
});
|
|
ProductsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String name,
|
|
required int defaultPrice,
|
|
this.category = const Value.absent(),
|
|
}) : name = Value(name),
|
|
defaultPrice = Value(defaultPrice);
|
|
static Insertable<Product> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? name,
|
|
Expression<int>? defaultPrice,
|
|
Expression<String>? category,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (name != null) 'name': name,
|
|
if (defaultPrice != null) 'default_price': defaultPrice,
|
|
if (category != null) 'category': category,
|
|
});
|
|
}
|
|
|
|
ProductsCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<String>? name,
|
|
Value<int>? defaultPrice,
|
|
Value<String?>? category,
|
|
}) {
|
|
return ProductsCompanion(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
defaultPrice: defaultPrice ?? this.defaultPrice,
|
|
category: category ?? this.category,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (name.present) {
|
|
map['name'] = Variable<String>(name.value);
|
|
}
|
|
if (defaultPrice.present) {
|
|
map['default_price'] = Variable<int>(defaultPrice.value);
|
|
}
|
|
if (category.present) {
|
|
map['category'] = Variable<String>(category.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ProductsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('defaultPrice: $defaultPrice, ')
|
|
..write('category: $category')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $InvoicesTable extends Invoices with TableInfo<$InvoicesTable, Invoice> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$InvoicesTable(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 _customerIdMeta = const VerificationMeta(
|
|
'customerId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> customerId = GeneratedColumn<String>(
|
|
'customer_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES customers (id)',
|
|
),
|
|
);
|
|
static const VerificationMeta _dateMeta = const VerificationMeta('date');
|
|
@override
|
|
late final GeneratedColumn<DateTime> date = GeneratedColumn<DateTime>(
|
|
'date',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _typeMeta = const VerificationMeta('type');
|
|
@override
|
|
late final GeneratedColumn<String> type = GeneratedColumn<String>(
|
|
'type',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _filePathMeta = const VerificationMeta(
|
|
'filePath',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> filePath = GeneratedColumn<String>(
|
|
'file_path',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _notesMeta = const VerificationMeta('notes');
|
|
@override
|
|
late final GeneratedColumn<String> notes = GeneratedColumn<String>(
|
|
'notes',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _totalAmountMeta = const VerificationMeta(
|
|
'totalAmount',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> totalAmount = GeneratedColumn<int>(
|
|
'total_amount',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
customerId,
|
|
date,
|
|
type,
|
|
filePath,
|
|
notes,
|
|
totalAmount,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'invoices';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Invoice> 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_id')) {
|
|
context.handle(
|
|
_customerIdMeta,
|
|
customerId.isAcceptableOrUnknown(data['customer_id']!, _customerIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_customerIdMeta);
|
|
}
|
|
if (data.containsKey('date')) {
|
|
context.handle(
|
|
_dateMeta,
|
|
date.isAcceptableOrUnknown(data['date']!, _dateMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_dateMeta);
|
|
}
|
|
if (data.containsKey('type')) {
|
|
context.handle(
|
|
_typeMeta,
|
|
type.isAcceptableOrUnknown(data['type']!, _typeMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_typeMeta);
|
|
}
|
|
if (data.containsKey('file_path')) {
|
|
context.handle(
|
|
_filePathMeta,
|
|
filePath.isAcceptableOrUnknown(data['file_path']!, _filePathMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('notes')) {
|
|
context.handle(
|
|
_notesMeta,
|
|
notes.isAcceptableOrUnknown(data['notes']!, _notesMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('total_amount')) {
|
|
context.handle(
|
|
_totalAmountMeta,
|
|
totalAmount.isAcceptableOrUnknown(
|
|
data['total_amount']!,
|
|
_totalAmountMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_totalAmountMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Invoice map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Invoice(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
customerId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}customer_id'],
|
|
)!,
|
|
date: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}date'],
|
|
)!,
|
|
type: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}type'],
|
|
)!,
|
|
filePath: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}file_path'],
|
|
),
|
|
notes: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}notes'],
|
|
),
|
|
totalAmount: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}total_amount'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$InvoicesTable createAlias(String alias) {
|
|
return $InvoicesTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Invoice extends DataClass implements Insertable<Invoice> {
|
|
final String id;
|
|
final String customerId;
|
|
final DateTime date;
|
|
final String type;
|
|
final String? filePath;
|
|
final String? notes;
|
|
final int totalAmount;
|
|
const Invoice({
|
|
required this.id,
|
|
required this.customerId,
|
|
required this.date,
|
|
required this.type,
|
|
this.filePath,
|
|
this.notes,
|
|
required this.totalAmount,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<String>(id);
|
|
map['customer_id'] = Variable<String>(customerId);
|
|
map['date'] = Variable<DateTime>(date);
|
|
map['type'] = Variable<String>(type);
|
|
if (!nullToAbsent || filePath != null) {
|
|
map['file_path'] = Variable<String>(filePath);
|
|
}
|
|
if (!nullToAbsent || notes != null) {
|
|
map['notes'] = Variable<String>(notes);
|
|
}
|
|
map['total_amount'] = Variable<int>(totalAmount);
|
|
return map;
|
|
}
|
|
|
|
InvoicesCompanion toCompanion(bool nullToAbsent) {
|
|
return InvoicesCompanion(
|
|
id: Value(id),
|
|
customerId: Value(customerId),
|
|
date: Value(date),
|
|
type: Value(type),
|
|
filePath: filePath == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(filePath),
|
|
notes: notes == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(notes),
|
|
totalAmount: Value(totalAmount),
|
|
);
|
|
}
|
|
|
|
factory Invoice.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Invoice(
|
|
id: serializer.fromJson<String>(json['id']),
|
|
customerId: serializer.fromJson<String>(json['customerId']),
|
|
date: serializer.fromJson<DateTime>(json['date']),
|
|
type: serializer.fromJson<String>(json['type']),
|
|
filePath: serializer.fromJson<String?>(json['filePath']),
|
|
notes: serializer.fromJson<String?>(json['notes']),
|
|
totalAmount: serializer.fromJson<int>(json['totalAmount']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<String>(id),
|
|
'customerId': serializer.toJson<String>(customerId),
|
|
'date': serializer.toJson<DateTime>(date),
|
|
'type': serializer.toJson<String>(type),
|
|
'filePath': serializer.toJson<String?>(filePath),
|
|
'notes': serializer.toJson<String?>(notes),
|
|
'totalAmount': serializer.toJson<int>(totalAmount),
|
|
};
|
|
}
|
|
|
|
Invoice copyWith({
|
|
String? id,
|
|
String? customerId,
|
|
DateTime? date,
|
|
String? type,
|
|
Value<String?> filePath = const Value.absent(),
|
|
Value<String?> notes = const Value.absent(),
|
|
int? totalAmount,
|
|
}) => Invoice(
|
|
id: id ?? this.id,
|
|
customerId: customerId ?? this.customerId,
|
|
date: date ?? this.date,
|
|
type: type ?? this.type,
|
|
filePath: filePath.present ? filePath.value : this.filePath,
|
|
notes: notes.present ? notes.value : this.notes,
|
|
totalAmount: totalAmount ?? this.totalAmount,
|
|
);
|
|
Invoice copyWithCompanion(InvoicesCompanion data) {
|
|
return Invoice(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
customerId: data.customerId.present
|
|
? data.customerId.value
|
|
: this.customerId,
|
|
date: data.date.present ? data.date.value : this.date,
|
|
type: data.type.present ? data.type.value : this.type,
|
|
filePath: data.filePath.present ? data.filePath.value : this.filePath,
|
|
notes: data.notes.present ? data.notes.value : this.notes,
|
|
totalAmount: data.totalAmount.present
|
|
? data.totalAmount.value
|
|
: this.totalAmount,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Invoice(')
|
|
..write('id: $id, ')
|
|
..write('customerId: $customerId, ')
|
|
..write('date: $date, ')
|
|
..write('type: $type, ')
|
|
..write('filePath: $filePath, ')
|
|
..write('notes: $notes, ')
|
|
..write('totalAmount: $totalAmount')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(id, customerId, date, type, filePath, notes, totalAmount);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Invoice &&
|
|
other.id == this.id &&
|
|
other.customerId == this.customerId &&
|
|
other.date == this.date &&
|
|
other.type == this.type &&
|
|
other.filePath == this.filePath &&
|
|
other.notes == this.notes &&
|
|
other.totalAmount == this.totalAmount);
|
|
}
|
|
|
|
class InvoicesCompanion extends UpdateCompanion<Invoice> {
|
|
final Value<String> id;
|
|
final Value<String> customerId;
|
|
final Value<DateTime> date;
|
|
final Value<String> type;
|
|
final Value<String?> filePath;
|
|
final Value<String?> notes;
|
|
final Value<int> totalAmount;
|
|
final Value<int> rowid;
|
|
const InvoicesCompanion({
|
|
this.id = const Value.absent(),
|
|
this.customerId = const Value.absent(),
|
|
this.date = const Value.absent(),
|
|
this.type = const Value.absent(),
|
|
this.filePath = const Value.absent(),
|
|
this.notes = const Value.absent(),
|
|
this.totalAmount = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
InvoicesCompanion.insert({
|
|
required String id,
|
|
required String customerId,
|
|
required DateTime date,
|
|
required String type,
|
|
this.filePath = const Value.absent(),
|
|
this.notes = const Value.absent(),
|
|
required int totalAmount,
|
|
this.rowid = const Value.absent(),
|
|
}) : id = Value(id),
|
|
customerId = Value(customerId),
|
|
date = Value(date),
|
|
type = Value(type),
|
|
totalAmount = Value(totalAmount);
|
|
static Insertable<Invoice> custom({
|
|
Expression<String>? id,
|
|
Expression<String>? customerId,
|
|
Expression<DateTime>? date,
|
|
Expression<String>? type,
|
|
Expression<String>? filePath,
|
|
Expression<String>? notes,
|
|
Expression<int>? totalAmount,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (customerId != null) 'customer_id': customerId,
|
|
if (date != null) 'date': date,
|
|
if (type != null) 'type': type,
|
|
if (filePath != null) 'file_path': filePath,
|
|
if (notes != null) 'notes': notes,
|
|
if (totalAmount != null) 'total_amount': totalAmount,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
InvoicesCompanion copyWith({
|
|
Value<String>? id,
|
|
Value<String>? customerId,
|
|
Value<DateTime>? date,
|
|
Value<String>? type,
|
|
Value<String?>? filePath,
|
|
Value<String?>? notes,
|
|
Value<int>? totalAmount,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return InvoicesCompanion(
|
|
id: id ?? this.id,
|
|
customerId: customerId ?? this.customerId,
|
|
date: date ?? this.date,
|
|
type: type ?? this.type,
|
|
filePath: filePath ?? this.filePath,
|
|
notes: notes ?? this.notes,
|
|
totalAmount: totalAmount ?? this.totalAmount,
|
|
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 (customerId.present) {
|
|
map['customer_id'] = Variable<String>(customerId.value);
|
|
}
|
|
if (date.present) {
|
|
map['date'] = Variable<DateTime>(date.value);
|
|
}
|
|
if (type.present) {
|
|
map['type'] = Variable<String>(type.value);
|
|
}
|
|
if (filePath.present) {
|
|
map['file_path'] = Variable<String>(filePath.value);
|
|
}
|
|
if (notes.present) {
|
|
map['notes'] = Variable<String>(notes.value);
|
|
}
|
|
if (totalAmount.present) {
|
|
map['total_amount'] = Variable<int>(totalAmount.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('InvoicesCompanion(')
|
|
..write('id: $id, ')
|
|
..write('customerId: $customerId, ')
|
|
..write('date: $date, ')
|
|
..write('type: $type, ')
|
|
..write('filePath: $filePath, ')
|
|
..write('notes: $notes, ')
|
|
..write('totalAmount: $totalAmount, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $InvoiceItemsTable extends InvoiceItems
|
|
with TableInfo<$InvoiceItemsTable, InvoiceItem> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$InvoiceItemsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _invoiceIdMeta = const VerificationMeta(
|
|
'invoiceId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> invoiceId = GeneratedColumn<String>(
|
|
'invoice_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES invoices (id)',
|
|
),
|
|
);
|
|
static const VerificationMeta _descriptionMeta = const VerificationMeta(
|
|
'description',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> description = GeneratedColumn<String>(
|
|
'description',
|
|
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 _unitPriceMeta = const VerificationMeta(
|
|
'unitPrice',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> unitPrice = GeneratedColumn<int>(
|
|
'unit_price',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
invoiceId,
|
|
description,
|
|
quantity,
|
|
unitPrice,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'invoice_items';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<InvoiceItem> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('invoice_id')) {
|
|
context.handle(
|
|
_invoiceIdMeta,
|
|
invoiceId.isAcceptableOrUnknown(data['invoice_id']!, _invoiceIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_invoiceIdMeta);
|
|
}
|
|
if (data.containsKey('description')) {
|
|
context.handle(
|
|
_descriptionMeta,
|
|
description.isAcceptableOrUnknown(
|
|
data['description']!,
|
|
_descriptionMeta,
|
|
),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_descriptionMeta);
|
|
}
|
|
if (data.containsKey('quantity')) {
|
|
context.handle(
|
|
_quantityMeta,
|
|
quantity.isAcceptableOrUnknown(data['quantity']!, _quantityMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_quantityMeta);
|
|
}
|
|
if (data.containsKey('unit_price')) {
|
|
context.handle(
|
|
_unitPriceMeta,
|
|
unitPrice.isAcceptableOrUnknown(data['unit_price']!, _unitPriceMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_unitPriceMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
InvoiceItem map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return InvoiceItem(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
invoiceId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}invoice_id'],
|
|
)!,
|
|
description: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}description'],
|
|
)!,
|
|
quantity: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}quantity'],
|
|
)!,
|
|
unitPrice: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}unit_price'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$InvoiceItemsTable createAlias(String alias) {
|
|
return $InvoiceItemsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class InvoiceItem extends DataClass implements Insertable<InvoiceItem> {
|
|
final int id;
|
|
final String invoiceId;
|
|
final String description;
|
|
final int quantity;
|
|
final int unitPrice;
|
|
const InvoiceItem({
|
|
required this.id,
|
|
required this.invoiceId,
|
|
required this.description,
|
|
required this.quantity,
|
|
required this.unitPrice,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['invoice_id'] = Variable<String>(invoiceId);
|
|
map['description'] = Variable<String>(description);
|
|
map['quantity'] = Variable<int>(quantity);
|
|
map['unit_price'] = Variable<int>(unitPrice);
|
|
return map;
|
|
}
|
|
|
|
InvoiceItemsCompanion toCompanion(bool nullToAbsent) {
|
|
return InvoiceItemsCompanion(
|
|
id: Value(id),
|
|
invoiceId: Value(invoiceId),
|
|
description: Value(description),
|
|
quantity: Value(quantity),
|
|
unitPrice: Value(unitPrice),
|
|
);
|
|
}
|
|
|
|
factory InvoiceItem.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return InvoiceItem(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
invoiceId: serializer.fromJson<String>(json['invoiceId']),
|
|
description: serializer.fromJson<String>(json['description']),
|
|
quantity: serializer.fromJson<int>(json['quantity']),
|
|
unitPrice: serializer.fromJson<int>(json['unitPrice']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'invoiceId': serializer.toJson<String>(invoiceId),
|
|
'description': serializer.toJson<String>(description),
|
|
'quantity': serializer.toJson<int>(quantity),
|
|
'unitPrice': serializer.toJson<int>(unitPrice),
|
|
};
|
|
}
|
|
|
|
InvoiceItem copyWith({
|
|
int? id,
|
|
String? invoiceId,
|
|
String? description,
|
|
int? quantity,
|
|
int? unitPrice,
|
|
}) => InvoiceItem(
|
|
id: id ?? this.id,
|
|
invoiceId: invoiceId ?? this.invoiceId,
|
|
description: description ?? this.description,
|
|
quantity: quantity ?? this.quantity,
|
|
unitPrice: unitPrice ?? this.unitPrice,
|
|
);
|
|
InvoiceItem copyWithCompanion(InvoiceItemsCompanion data) {
|
|
return InvoiceItem(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
invoiceId: data.invoiceId.present ? data.invoiceId.value : this.invoiceId,
|
|
description: data.description.present
|
|
? data.description.value
|
|
: this.description,
|
|
quantity: data.quantity.present ? data.quantity.value : this.quantity,
|
|
unitPrice: data.unitPrice.present ? data.unitPrice.value : this.unitPrice,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('InvoiceItem(')
|
|
..write('id: $id, ')
|
|
..write('invoiceId: $invoiceId, ')
|
|
..write('description: $description, ')
|
|
..write('quantity: $quantity, ')
|
|
..write('unitPrice: $unitPrice')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(id, invoiceId, description, quantity, unitPrice);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is InvoiceItem &&
|
|
other.id == this.id &&
|
|
other.invoiceId == this.invoiceId &&
|
|
other.description == this.description &&
|
|
other.quantity == this.quantity &&
|
|
other.unitPrice == this.unitPrice);
|
|
}
|
|
|
|
class InvoiceItemsCompanion extends UpdateCompanion<InvoiceItem> {
|
|
final Value<int> id;
|
|
final Value<String> invoiceId;
|
|
final Value<String> description;
|
|
final Value<int> quantity;
|
|
final Value<int> unitPrice;
|
|
const InvoiceItemsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.invoiceId = const Value.absent(),
|
|
this.description = const Value.absent(),
|
|
this.quantity = const Value.absent(),
|
|
this.unitPrice = const Value.absent(),
|
|
});
|
|
InvoiceItemsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String invoiceId,
|
|
required String description,
|
|
required int quantity,
|
|
required int unitPrice,
|
|
}) : invoiceId = Value(invoiceId),
|
|
description = Value(description),
|
|
quantity = Value(quantity),
|
|
unitPrice = Value(unitPrice);
|
|
static Insertable<InvoiceItem> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? invoiceId,
|
|
Expression<String>? description,
|
|
Expression<int>? quantity,
|
|
Expression<int>? unitPrice,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (invoiceId != null) 'invoice_id': invoiceId,
|
|
if (description != null) 'description': description,
|
|
if (quantity != null) 'quantity': quantity,
|
|
if (unitPrice != null) 'unit_price': unitPrice,
|
|
});
|
|
}
|
|
|
|
InvoiceItemsCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<String>? invoiceId,
|
|
Value<String>? description,
|
|
Value<int>? quantity,
|
|
Value<int>? unitPrice,
|
|
}) {
|
|
return InvoiceItemsCompanion(
|
|
id: id ?? this.id,
|
|
invoiceId: invoiceId ?? this.invoiceId,
|
|
description: description ?? this.description,
|
|
quantity: quantity ?? this.quantity,
|
|
unitPrice: unitPrice ?? this.unitPrice,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (invoiceId.present) {
|
|
map['invoice_id'] = Variable<String>(invoiceId.value);
|
|
}
|
|
if (description.present) {
|
|
map['description'] = Variable<String>(description.value);
|
|
}
|
|
if (quantity.present) {
|
|
map['quantity'] = Variable<int>(quantity.value);
|
|
}
|
|
if (unitPrice.present) {
|
|
map['unit_price'] = Variable<int>(unitPrice.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('InvoiceItemsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('invoiceId: $invoiceId, ')
|
|
..write('description: $description, ')
|
|
..write('quantity: $quantity, ')
|
|
..write('unitPrice: $unitPrice')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $CustomersTable customers = $CustomersTable(this);
|
|
late final $ProductsTable products = $ProductsTable(this);
|
|
late final $InvoicesTable invoices = $InvoicesTable(this);
|
|
late final $InvoiceItemsTable invoiceItems = $InvoiceItemsTable(this);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
customers,
|
|
products,
|
|
invoices,
|
|
invoiceItems,
|
|
];
|
|
}
|
|
|
|
typedef $$CustomersTableCreateCompanionBuilder =
|
|
CustomersCompanion Function({
|
|
required String id,
|
|
required String displayName,
|
|
required String formalName,
|
|
Value<String?> address,
|
|
Value<String?> zipCode,
|
|
Value<String?> department,
|
|
Value<double?> latitude,
|
|
Value<double?> longitude,
|
|
Value<DateTime?> lastUpdatedAt,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$CustomersTableUpdateCompanionBuilder =
|
|
CustomersCompanion Function({
|
|
Value<String> id,
|
|
Value<String> displayName,
|
|
Value<String> formalName,
|
|
Value<String?> address,
|
|
Value<String?> zipCode,
|
|
Value<String?> department,
|
|
Value<double?> latitude,
|
|
Value<double?> longitude,
|
|
Value<DateTime?> lastUpdatedAt,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$CustomersTableReferences
|
|
extends BaseReferences<_$AppDatabase, $CustomersTable, Customer> {
|
|
$$CustomersTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$InvoicesTable, List<Invoice>> _invoicesRefsTable(
|
|
_$AppDatabase db,
|
|
) => MultiTypedResultKey.fromTable(
|
|
db.invoices,
|
|
aliasName: $_aliasNameGenerator(db.customers.id, db.invoices.customerId),
|
|
);
|
|
|
|
$$InvoicesTableProcessedTableManager get invoicesRefs {
|
|
final manager = $$InvoicesTableTableManager(
|
|
$_db,
|
|
$_db.invoices,
|
|
).filter((f) => f.customerId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_invoicesRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$CustomersTableFilterComposer
|
|
extends Composer<_$AppDatabase, $CustomersTable> {
|
|
$$CustomersTableFilterComposer({
|
|
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 displayName => $composableBuilder(
|
|
column: $table.displayName,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get formalName => $composableBuilder(
|
|
column: $table.formalName,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get address => $composableBuilder(
|
|
column: $table.address,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get zipCode => $composableBuilder(
|
|
column: $table.zipCode,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get department => $composableBuilder(
|
|
column: $table.department,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<double> get latitude => $composableBuilder(
|
|
column: $table.latitude,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<double> get longitude => $composableBuilder(
|
|
column: $table.longitude,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get lastUpdatedAt => $composableBuilder(
|
|
column: $table.lastUpdatedAt,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> invoicesRefs(
|
|
Expression<bool> Function($$InvoicesTableFilterComposer f) f,
|
|
) {
|
|
final $$InvoicesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.invoices,
|
|
getReferencedColumn: (t) => t.customerId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$InvoicesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.invoices,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$CustomersTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $CustomersTable> {
|
|
$$CustomersTableOrderingComposer({
|
|
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 displayName => $composableBuilder(
|
|
column: $table.displayName,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get formalName => $composableBuilder(
|
|
column: $table.formalName,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get address => $composableBuilder(
|
|
column: $table.address,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get zipCode => $composableBuilder(
|
|
column: $table.zipCode,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get department => $composableBuilder(
|
|
column: $table.department,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<double> get latitude => $composableBuilder(
|
|
column: $table.latitude,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<double> get longitude => $composableBuilder(
|
|
column: $table.longitude,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get lastUpdatedAt => $composableBuilder(
|
|
column: $table.lastUpdatedAt,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$CustomersTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $CustomersTable> {
|
|
$$CustomersTableAnnotationComposer({
|
|
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 displayName => $composableBuilder(
|
|
column: $table.displayName,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get formalName => $composableBuilder(
|
|
column: $table.formalName,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get address =>
|
|
$composableBuilder(column: $table.address, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get zipCode =>
|
|
$composableBuilder(column: $table.zipCode, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get department => $composableBuilder(
|
|
column: $table.department,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<double> get latitude =>
|
|
$composableBuilder(column: $table.latitude, builder: (column) => column);
|
|
|
|
GeneratedColumn<double> get longitude =>
|
|
$composableBuilder(column: $table.longitude, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get lastUpdatedAt => $composableBuilder(
|
|
column: $table.lastUpdatedAt,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
Expression<T> invoicesRefs<T extends Object>(
|
|
Expression<T> Function($$InvoicesTableAnnotationComposer a) f,
|
|
) {
|
|
final $$InvoicesTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.invoices,
|
|
getReferencedColumn: (t) => t.customerId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$InvoicesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.invoices,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$CustomersTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$CustomersTable,
|
|
Customer,
|
|
$$CustomersTableFilterComposer,
|
|
$$CustomersTableOrderingComposer,
|
|
$$CustomersTableAnnotationComposer,
|
|
$$CustomersTableCreateCompanionBuilder,
|
|
$$CustomersTableUpdateCompanionBuilder,
|
|
(Customer, $$CustomersTableReferences),
|
|
Customer,
|
|
PrefetchHooks Function({bool invoicesRefs})
|
|
> {
|
|
$$CustomersTableTableManager(_$AppDatabase db, $CustomersTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$CustomersTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$CustomersTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$CustomersTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> displayName = const Value.absent(),
|
|
Value<String> formalName = const Value.absent(),
|
|
Value<String?> address = const Value.absent(),
|
|
Value<String?> zipCode = const Value.absent(),
|
|
Value<String?> department = const Value.absent(),
|
|
Value<double?> latitude = const Value.absent(),
|
|
Value<double?> longitude = const Value.absent(),
|
|
Value<DateTime?> lastUpdatedAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => CustomersCompanion(
|
|
id: id,
|
|
displayName: displayName,
|
|
formalName: formalName,
|
|
address: address,
|
|
zipCode: zipCode,
|
|
department: department,
|
|
latitude: latitude,
|
|
longitude: longitude,
|
|
lastUpdatedAt: lastUpdatedAt,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String displayName,
|
|
required String formalName,
|
|
Value<String?> address = const Value.absent(),
|
|
Value<String?> zipCode = const Value.absent(),
|
|
Value<String?> department = const Value.absent(),
|
|
Value<double?> latitude = const Value.absent(),
|
|
Value<double?> longitude = const Value.absent(),
|
|
Value<DateTime?> lastUpdatedAt = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => CustomersCompanion.insert(
|
|
id: id,
|
|
displayName: displayName,
|
|
formalName: formalName,
|
|
address: address,
|
|
zipCode: zipCode,
|
|
department: department,
|
|
latitude: latitude,
|
|
longitude: longitude,
|
|
lastUpdatedAt: lastUpdatedAt,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$CustomersTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({invoicesRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (invoicesRefs) db.invoices],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (invoicesRefs)
|
|
await $_getPrefetchedData<
|
|
Customer,
|
|
$CustomersTable,
|
|
Invoice
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$CustomersTableReferences
|
|
._invoicesRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$CustomersTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).invoicesRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.customerId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$CustomersTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$CustomersTable,
|
|
Customer,
|
|
$$CustomersTableFilterComposer,
|
|
$$CustomersTableOrderingComposer,
|
|
$$CustomersTableAnnotationComposer,
|
|
$$CustomersTableCreateCompanionBuilder,
|
|
$$CustomersTableUpdateCompanionBuilder,
|
|
(Customer, $$CustomersTableReferences),
|
|
Customer,
|
|
PrefetchHooks Function({bool invoicesRefs})
|
|
>;
|
|
typedef $$ProductsTableCreateCompanionBuilder =
|
|
ProductsCompanion Function({
|
|
Value<int> id,
|
|
required String name,
|
|
required int defaultPrice,
|
|
Value<String?> category,
|
|
});
|
|
typedef $$ProductsTableUpdateCompanionBuilder =
|
|
ProductsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> name,
|
|
Value<int> defaultPrice,
|
|
Value<String?> category,
|
|
});
|
|
|
|
class $$ProductsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ProductsTable> {
|
|
$$ProductsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get defaultPrice => $composableBuilder(
|
|
column: $table.defaultPrice,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get category => $composableBuilder(
|
|
column: $table.category,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$ProductsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ProductsTable> {
|
|
$$ProductsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get name => $composableBuilder(
|
|
column: $table.name,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get defaultPrice => $composableBuilder(
|
|
column: $table.defaultPrice,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get category => $composableBuilder(
|
|
column: $table.category,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$ProductsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ProductsTable> {
|
|
$$ProductsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get name =>
|
|
$composableBuilder(column: $table.name, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get defaultPrice => $composableBuilder(
|
|
column: $table.defaultPrice,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get category =>
|
|
$composableBuilder(column: $table.category, builder: (column) => column);
|
|
}
|
|
|
|
class $$ProductsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$ProductsTable,
|
|
Product,
|
|
$$ProductsTableFilterComposer,
|
|
$$ProductsTableOrderingComposer,
|
|
$$ProductsTableAnnotationComposer,
|
|
$$ProductsTableCreateCompanionBuilder,
|
|
$$ProductsTableUpdateCompanionBuilder,
|
|
(Product, BaseReferences<_$AppDatabase, $ProductsTable, Product>),
|
|
Product,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$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<int> id = const Value.absent(),
|
|
Value<String> name = const Value.absent(),
|
|
Value<int> defaultPrice = const Value.absent(),
|
|
Value<String?> category = const Value.absent(),
|
|
}) => ProductsCompanion(
|
|
id: id,
|
|
name: name,
|
|
defaultPrice: defaultPrice,
|
|
category: category,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required String name,
|
|
required int defaultPrice,
|
|
Value<String?> category = const Value.absent(),
|
|
}) => ProductsCompanion.insert(
|
|
id: id,
|
|
name: name,
|
|
defaultPrice: defaultPrice,
|
|
category: category,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$ProductsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ProductsTable,
|
|
Product,
|
|
$$ProductsTableFilterComposer,
|
|
$$ProductsTableOrderingComposer,
|
|
$$ProductsTableAnnotationComposer,
|
|
$$ProductsTableCreateCompanionBuilder,
|
|
$$ProductsTableUpdateCompanionBuilder,
|
|
(Product, BaseReferences<_$AppDatabase, $ProductsTable, Product>),
|
|
Product,
|
|
PrefetchHooks Function()
|
|
>;
|
|
typedef $$InvoicesTableCreateCompanionBuilder =
|
|
InvoicesCompanion Function({
|
|
required String id,
|
|
required String customerId,
|
|
required DateTime date,
|
|
required String type,
|
|
Value<String?> filePath,
|
|
Value<String?> notes,
|
|
required int totalAmount,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$InvoicesTableUpdateCompanionBuilder =
|
|
InvoicesCompanion Function({
|
|
Value<String> id,
|
|
Value<String> customerId,
|
|
Value<DateTime> date,
|
|
Value<String> type,
|
|
Value<String?> filePath,
|
|
Value<String?> notes,
|
|
Value<int> totalAmount,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
final class $$InvoicesTableReferences
|
|
extends BaseReferences<_$AppDatabase, $InvoicesTable, Invoice> {
|
|
$$InvoicesTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $CustomersTable _customerIdTable(_$AppDatabase db) =>
|
|
db.customers.createAlias(
|
|
$_aliasNameGenerator(db.invoices.customerId, db.customers.id),
|
|
);
|
|
|
|
$$CustomersTableProcessedTableManager get customerId {
|
|
final $_column = $_itemColumn<String>('customer_id')!;
|
|
|
|
final manager = $$CustomersTableTableManager(
|
|
$_db,
|
|
$_db.customers,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_customerIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static MultiTypedResultKey<$InvoiceItemsTable, List<InvoiceItem>>
|
|
_invoiceItemsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.invoiceItems,
|
|
aliasName: $_aliasNameGenerator(db.invoices.id, db.invoiceItems.invoiceId),
|
|
);
|
|
|
|
$$InvoiceItemsTableProcessedTableManager get invoiceItemsRefs {
|
|
final manager = $$InvoiceItemsTableTableManager(
|
|
$_db,
|
|
$_db.invoiceItems,
|
|
).filter((f) => f.invoiceId.id.sqlEquals($_itemColumn<String>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_invoiceItemsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$InvoicesTableFilterComposer
|
|
extends Composer<_$AppDatabase, $InvoicesTable> {
|
|
$$InvoicesTableFilterComposer({
|
|
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 date => $composableBuilder(
|
|
column: $table.date,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get type => $composableBuilder(
|
|
column: $table.type,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get filePath => $composableBuilder(
|
|
column: $table.filePath,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get notes => $composableBuilder(
|
|
column: $table.notes,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get totalAmount => $composableBuilder(
|
|
column: $table.totalAmount,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$CustomersTableFilterComposer get customerId {
|
|
final $$CustomersTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.customerId,
|
|
referencedTable: $db.customers,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$CustomersTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.customers,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
Expression<bool> invoiceItemsRefs(
|
|
Expression<bool> Function($$InvoiceItemsTableFilterComposer f) f,
|
|
) {
|
|
final $$InvoiceItemsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.invoiceItems,
|
|
getReferencedColumn: (t) => t.invoiceId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$InvoiceItemsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.invoiceItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$InvoicesTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $InvoicesTable> {
|
|
$$InvoicesTableOrderingComposer({
|
|
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 date => $composableBuilder(
|
|
column: $table.date,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get type => $composableBuilder(
|
|
column: $table.type,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get filePath => $composableBuilder(
|
|
column: $table.filePath,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get notes => $composableBuilder(
|
|
column: $table.notes,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get totalAmount => $composableBuilder(
|
|
column: $table.totalAmount,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$CustomersTableOrderingComposer get customerId {
|
|
final $$CustomersTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.customerId,
|
|
referencedTable: $db.customers,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$CustomersTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.customers,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$InvoicesTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $InvoicesTable> {
|
|
$$InvoicesTableAnnotationComposer({
|
|
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 date =>
|
|
$composableBuilder(column: $table.date, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get type =>
|
|
$composableBuilder(column: $table.type, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get filePath =>
|
|
$composableBuilder(column: $table.filePath, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get notes =>
|
|
$composableBuilder(column: $table.notes, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get totalAmount => $composableBuilder(
|
|
column: $table.totalAmount,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
$$CustomersTableAnnotationComposer get customerId {
|
|
final $$CustomersTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.customerId,
|
|
referencedTable: $db.customers,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$CustomersTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.customers,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
Expression<T> invoiceItemsRefs<T extends Object>(
|
|
Expression<T> Function($$InvoiceItemsTableAnnotationComposer a) f,
|
|
) {
|
|
final $$InvoiceItemsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.invoiceItems,
|
|
getReferencedColumn: (t) => t.invoiceId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$InvoiceItemsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.invoiceItems,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$InvoicesTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$InvoicesTable,
|
|
Invoice,
|
|
$$InvoicesTableFilterComposer,
|
|
$$InvoicesTableOrderingComposer,
|
|
$$InvoicesTableAnnotationComposer,
|
|
$$InvoicesTableCreateCompanionBuilder,
|
|
$$InvoicesTableUpdateCompanionBuilder,
|
|
(Invoice, $$InvoicesTableReferences),
|
|
Invoice,
|
|
PrefetchHooks Function({bool customerId, bool invoiceItemsRefs})
|
|
> {
|
|
$$InvoicesTableTableManager(_$AppDatabase db, $InvoicesTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$InvoicesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$InvoicesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$InvoicesTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> id = const Value.absent(),
|
|
Value<String> customerId = const Value.absent(),
|
|
Value<DateTime> date = const Value.absent(),
|
|
Value<String> type = const Value.absent(),
|
|
Value<String?> filePath = const Value.absent(),
|
|
Value<String?> notes = const Value.absent(),
|
|
Value<int> totalAmount = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => InvoicesCompanion(
|
|
id: id,
|
|
customerId: customerId,
|
|
date: date,
|
|
type: type,
|
|
filePath: filePath,
|
|
notes: notes,
|
|
totalAmount: totalAmount,
|
|
rowid: rowid,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
required String id,
|
|
required String customerId,
|
|
required DateTime date,
|
|
required String type,
|
|
Value<String?> filePath = const Value.absent(),
|
|
Value<String?> notes = const Value.absent(),
|
|
required int totalAmount,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => InvoicesCompanion.insert(
|
|
id: id,
|
|
customerId: customerId,
|
|
date: date,
|
|
type: type,
|
|
filePath: filePath,
|
|
notes: notes,
|
|
totalAmount: totalAmount,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$InvoicesTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback:
|
|
({customerId = false, invoiceItemsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [
|
|
if (invoiceItemsRefs) db.invoiceItems,
|
|
],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (customerId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.customerId,
|
|
referencedTable: $$InvoicesTableReferences
|
|
._customerIdTable(db),
|
|
referencedColumn: $$InvoicesTableReferences
|
|
._customerIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (invoiceItemsRefs)
|
|
await $_getPrefetchedData<
|
|
Invoice,
|
|
$InvoicesTable,
|
|
InvoiceItem
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$InvoicesTableReferences
|
|
._invoiceItemsRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$InvoicesTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).invoiceItemsRefs,
|
|
referencedItemsForCurrentItem:
|
|
(item, referencedItems) => referencedItems.where(
|
|
(e) => e.invoiceId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$InvoicesTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$InvoicesTable,
|
|
Invoice,
|
|
$$InvoicesTableFilterComposer,
|
|
$$InvoicesTableOrderingComposer,
|
|
$$InvoicesTableAnnotationComposer,
|
|
$$InvoicesTableCreateCompanionBuilder,
|
|
$$InvoicesTableUpdateCompanionBuilder,
|
|
(Invoice, $$InvoicesTableReferences),
|
|
Invoice,
|
|
PrefetchHooks Function({bool customerId, bool invoiceItemsRefs})
|
|
>;
|
|
typedef $$InvoiceItemsTableCreateCompanionBuilder =
|
|
InvoiceItemsCompanion Function({
|
|
Value<int> id,
|
|
required String invoiceId,
|
|
required String description,
|
|
required int quantity,
|
|
required int unitPrice,
|
|
});
|
|
typedef $$InvoiceItemsTableUpdateCompanionBuilder =
|
|
InvoiceItemsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> invoiceId,
|
|
Value<String> description,
|
|
Value<int> quantity,
|
|
Value<int> unitPrice,
|
|
});
|
|
|
|
final class $$InvoiceItemsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $InvoiceItemsTable, InvoiceItem> {
|
|
$$InvoiceItemsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $InvoicesTable _invoiceIdTable(_$AppDatabase db) =>
|
|
db.invoices.createAlias(
|
|
$_aliasNameGenerator(db.invoiceItems.invoiceId, db.invoices.id),
|
|
);
|
|
|
|
$$InvoicesTableProcessedTableManager get invoiceId {
|
|
final $_column = $_itemColumn<String>('invoice_id')!;
|
|
|
|
final manager = $$InvoicesTableTableManager(
|
|
$_db,
|
|
$_db.invoices,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_invoiceIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$InvoiceItemsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $InvoiceItemsTable> {
|
|
$$InvoiceItemsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get quantity => $composableBuilder(
|
|
column: $table.quantity,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get unitPrice => $composableBuilder(
|
|
column: $table.unitPrice,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$InvoicesTableFilterComposer get invoiceId {
|
|
final $$InvoicesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.invoiceId,
|
|
referencedTable: $db.invoices,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$InvoicesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.invoices,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$InvoiceItemsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $InvoiceItemsTable> {
|
|
$$InvoiceItemsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get quantity => $composableBuilder(
|
|
column: $table.quantity,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get unitPrice => $composableBuilder(
|
|
column: $table.unitPrice,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$InvoicesTableOrderingComposer get invoiceId {
|
|
final $$InvoicesTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.invoiceId,
|
|
referencedTable: $db.invoices,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$InvoicesTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.invoices,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$InvoiceItemsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $InvoiceItemsTable> {
|
|
$$InvoiceItemsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get description => $composableBuilder(
|
|
column: $table.description,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<int> get quantity =>
|
|
$composableBuilder(column: $table.quantity, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get unitPrice =>
|
|
$composableBuilder(column: $table.unitPrice, builder: (column) => column);
|
|
|
|
$$InvoicesTableAnnotationComposer get invoiceId {
|
|
final $$InvoicesTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.invoiceId,
|
|
referencedTable: $db.invoices,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$InvoicesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.invoices,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$InvoiceItemsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$InvoiceItemsTable,
|
|
InvoiceItem,
|
|
$$InvoiceItemsTableFilterComposer,
|
|
$$InvoiceItemsTableOrderingComposer,
|
|
$$InvoiceItemsTableAnnotationComposer,
|
|
$$InvoiceItemsTableCreateCompanionBuilder,
|
|
$$InvoiceItemsTableUpdateCompanionBuilder,
|
|
(InvoiceItem, $$InvoiceItemsTableReferences),
|
|
InvoiceItem,
|
|
PrefetchHooks Function({bool invoiceId})
|
|
> {
|
|
$$InvoiceItemsTableTableManager(_$AppDatabase db, $InvoiceItemsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$InvoiceItemsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$InvoiceItemsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$InvoiceItemsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> invoiceId = const Value.absent(),
|
|
Value<String> description = const Value.absent(),
|
|
Value<int> quantity = const Value.absent(),
|
|
Value<int> unitPrice = const Value.absent(),
|
|
}) => InvoiceItemsCompanion(
|
|
id: id,
|
|
invoiceId: invoiceId,
|
|
description: description,
|
|
quantity: quantity,
|
|
unitPrice: unitPrice,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required String invoiceId,
|
|
required String description,
|
|
required int quantity,
|
|
required int unitPrice,
|
|
}) => InvoiceItemsCompanion.insert(
|
|
id: id,
|
|
invoiceId: invoiceId,
|
|
description: description,
|
|
quantity: quantity,
|
|
unitPrice: unitPrice,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$InvoiceItemsTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({invoiceId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (invoiceId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.invoiceId,
|
|
referencedTable: $$InvoiceItemsTableReferences
|
|
._invoiceIdTable(db),
|
|
referencedColumn: $$InvoiceItemsTableReferences
|
|
._invoiceIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$InvoiceItemsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$InvoiceItemsTable,
|
|
InvoiceItem,
|
|
$$InvoiceItemsTableFilterComposer,
|
|
$$InvoiceItemsTableOrderingComposer,
|
|
$$InvoiceItemsTableAnnotationComposer,
|
|
$$InvoiceItemsTableCreateCompanionBuilder,
|
|
$$InvoiceItemsTableUpdateCompanionBuilder,
|
|
(InvoiceItem, $$InvoiceItemsTableReferences),
|
|
InvoiceItem,
|
|
PrefetchHooks Function({bool invoiceId})
|
|
>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$CustomersTableTableManager get customers =>
|
|
$$CustomersTableTableManager(_db, _db.customers);
|
|
$$ProductsTableTableManager get products =>
|
|
$$ProductsTableTableManager(_db, _db.products);
|
|
$$InvoicesTableTableManager get invoices =>
|
|
$$InvoicesTableTableManager(_db, _db.invoices);
|
|
$$InvoiceItemsTableTableManager get invoiceItems =>
|
|
$$InvoiceItemsTableTableManager(_db, _db.invoiceItems);
|
|
}
|