1408 lines
59 KiB
Dart
1408 lines
59 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'database.dart';
|
|
|
|
// **************************************************************************
|
|
// FloorGenerator
|
|
// **************************************************************************
|
|
|
|
abstract class $AppDatabaseBuilderContract {
|
|
/// Adds migrations to the builder.
|
|
$AppDatabaseBuilderContract addMigrations(List<Migration> migrations);
|
|
|
|
/// Adds a database [Callback] to the builder.
|
|
$AppDatabaseBuilderContract addCallback(Callback callback);
|
|
|
|
/// Creates the database and initializes it.
|
|
Future<AppDatabase> build();
|
|
}
|
|
|
|
// ignore: avoid_classes_with_only_static_members
|
|
class $FloorAppDatabase {
|
|
/// Creates a database builder for a persistent database.
|
|
/// Once a database is built, you should keep a reference to it and re-use it.
|
|
static $AppDatabaseBuilderContract databaseBuilder(String name) =>
|
|
_$AppDatabaseBuilder(name);
|
|
|
|
/// Creates a database builder for an in memory database.
|
|
/// Information stored in an in memory database disappears when the process is killed.
|
|
/// Once a database is built, you should keep a reference to it and re-use it.
|
|
static $AppDatabaseBuilderContract inMemoryDatabaseBuilder() =>
|
|
_$AppDatabaseBuilder(null);
|
|
}
|
|
|
|
class _$AppDatabaseBuilder implements $AppDatabaseBuilderContract {
|
|
_$AppDatabaseBuilder(this.name);
|
|
|
|
final String? name;
|
|
|
|
final List<Migration> _migrations = [];
|
|
|
|
Callback? _callback;
|
|
|
|
@override
|
|
$AppDatabaseBuilderContract addMigrations(List<Migration> migrations) {
|
|
_migrations.addAll(migrations);
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
$AppDatabaseBuilderContract addCallback(Callback callback) {
|
|
_callback = callback;
|
|
return this;
|
|
}
|
|
|
|
@override
|
|
Future<AppDatabase> build() async {
|
|
final path = name != null
|
|
? await sqfliteDatabaseFactory.getDatabasePath(name!)
|
|
: ':memory:';
|
|
final database = _$AppDatabase();
|
|
database.database = await database.open(
|
|
path,
|
|
_migrations,
|
|
_callback,
|
|
);
|
|
return database;
|
|
}
|
|
}
|
|
|
|
class _$AppDatabase extends AppDatabase {
|
|
_$AppDatabase([StreamController<String>? listener]) {
|
|
changeListener = listener ?? StreamController<String>.broadcast();
|
|
}
|
|
|
|
OrderDao? _getOrderDaoInstance;
|
|
|
|
ProductDao? _getProductDaoInstance;
|
|
|
|
ShopCardDao? _getShopCardDaoInstance;
|
|
|
|
ClassifyDao? _getClassifyDaoInstance;
|
|
|
|
PrintHistoryDao? _getPrintHistoryDaoInstance;
|
|
|
|
UserDao? _getUserDaoInstance;
|
|
|
|
FaceDao? _getFaceDaoInstance;
|
|
|
|
SettingDao? _getSettingDaoInstance;
|
|
|
|
Future<sqflite.Database> open(
|
|
String path,
|
|
List<Migration> migrations, [
|
|
Callback? callback,
|
|
]) async {
|
|
final databaseOptions = sqflite.OpenDatabaseOptions(
|
|
version: 1,
|
|
onConfigure: (database) async {
|
|
await database.execute('PRAGMA foreign_keys = ON');
|
|
await callback?.onConfigure?.call(database);
|
|
},
|
|
onOpen: (database) async {
|
|
await callback?.onOpen?.call(database);
|
|
},
|
|
onUpgrade: (database, startVersion, endVersion) async {
|
|
await MigrationAdapter.runMigrations(
|
|
database, startVersion, endVersion, migrations);
|
|
|
|
await callback?.onUpgrade?.call(database, startVersion, endVersion);
|
|
},
|
|
onCreate: (database, version) async {
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `order_record` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `uniqueCode` TEXT NOT NULL, `serviceUniqueCode` TEXT NOT NULL, `sysType` TEXT NOT NULL, `userCode` TEXT NOT NULL, `username` TEXT, `hourType` TEXT, `price` INTEGER NOT NULL, `extraPrice` INTEGER NOT NULL, `payPrice` INTEGER NOT NULL, `walletId` TEXT, `orderSourceTypeId` TEXT, `type` TEXT NOT NULL, `status` TEXT NOT NULL, `payType` TEXT NOT NULL, `productDesc` TEXT, `count` INTEGER NOT NULL, `weight` REAL NOT NULL, `payTime` TEXT, `createTime` TEXT NOT NULL)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `product` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `serviceUniqueCode` TEXT NOT NULL, `sysType` TEXT NOT NULL, `classifyServiceUniqueCode` TEXT NOT NULL, `hourType` INTEGER, `saleDate` TEXT, `name` TEXT NOT NULL, `price` INTEGER NOT NULL, `image` TEXT, `isDefault` INTEGER NOT NULL, `status` INTEGER NOT NULL, `sort` INTEGER NOT NULL, `createTime` TEXT NOT NULL, `updateTime` TEXT NOT NULL, `delFlag` INTEGER NOT NULL)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `shop_card` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `orderId` INTEGER NOT NULL, `productServiceUniqueCode` TEXT NOT NULL, `productName` TEXT NOT NULL, `productPic` TEXT NOT NULL, `productPrice` INTEGER NOT NULL, `productNumber` INTEGER NOT NULL, `productWidget` REAL NOT NULL, `totalPrice` INTEGER NOT NULL)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `classify` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `serviceUniqueCode` TEXT NOT NULL, `sysType` TEXT NOT NULL, `name` TEXT NOT NULL, `categoryType` TEXT NOT NULL, `sort` INTEGER NOT NULL, `createTime` TEXT NOT NULL, `updateTime` TEXT NOT NULL, `delFlag` INTEGER NOT NULL)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `print_history` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `orderId` TEXT NOT NULL, `serviceOrderId` TEXT NOT NULL, `servicePrintId` TEXT NOT NULL, `invoiceUrl` TEXT NOT NULL, `status` TEXT NOT NULL, `printTime` TEXT, `syncTime` TEXT, `createTime` TEXT NOT NULL)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `user_record` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `userId` TEXT NOT NULL, `nickname` TEXT NOT NULL, `mobile` TEXT, `avatar` TEXT, `walletCardNumber` TEXT, `walletId` TEXT, `walletTypeId` TEXT, `walletBalance` INTEGER, `createTime` TEXT, `updateTime` TEXT)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `face` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `userId` TEXT NOT NULL, `sampleId` TEXT NOT NULL, `userName` TEXT NOT NULL, `deptId` TEXT, `deptName` TEXT, `imagePath` TEXT NOT NULL, `path` TEXT, `faceModel` TEXT, `createTime` TEXT, `updateTime` TEXT)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `setting` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `userJson` TEXT NOT NULL, `sysJson` TEXT NOT NULL, `canteenExtraPriceConfigJson` TEXT)');
|
|
|
|
await callback?.onCreate?.call(database, version);
|
|
},
|
|
);
|
|
return sqfliteDatabaseFactory.openDatabase(path, options: databaseOptions);
|
|
}
|
|
|
|
@override
|
|
OrderDao get getOrderDao {
|
|
return _getOrderDaoInstance ??= _$OrderDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
ProductDao get getProductDao {
|
|
return _getProductDaoInstance ??= _$ProductDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
ShopCardDao get getShopCardDao {
|
|
return _getShopCardDaoInstance ??= _$ShopCardDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
ClassifyDao get getClassifyDao {
|
|
return _getClassifyDaoInstance ??= _$ClassifyDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
PrintHistoryDao get getPrintHistoryDao {
|
|
return _getPrintHistoryDaoInstance ??=
|
|
_$PrintHistoryDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
UserDao get getUserDao {
|
|
return _getUserDaoInstance ??= _$UserDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
FaceDao get getFaceDao {
|
|
return _getFaceDaoInstance ??= _$FaceDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
SettingDao get getSettingDao {
|
|
return _getSettingDaoInstance ??= _$SettingDao(database, changeListener);
|
|
}
|
|
}
|
|
|
|
class _$OrderDao extends OrderDao {
|
|
_$OrderDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_orderEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'order_record',
|
|
(OrderEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'uniqueCode': item.uniqueCode,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'sysType': _sysTypeConverter.encode(item.sysType),
|
|
'userCode': item.userCode,
|
|
'username': item.username,
|
|
'hourType': item.hourType,
|
|
'price': item.price,
|
|
'extraPrice': item.extraPrice,
|
|
'payPrice': item.payPrice,
|
|
'walletId': item.walletId,
|
|
'orderSourceTypeId': item.orderSourceTypeId,
|
|
'type': _orderTypeConverter.encode(item.type),
|
|
'status': _orderStatusConverter.encode(item.status),
|
|
'payType': _orderPayTypeConverter.encode(item.payType),
|
|
'productDesc': item.productDesc,
|
|
'count': item.count,
|
|
'weight': item.weight,
|
|
'payTime': _dateTimeEmptyConverter.encode(item.payTime),
|
|
'createTime': _dateTimeConverter.encode(item.createTime)
|
|
}),
|
|
_orderEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'order_record',
|
|
['id'],
|
|
(OrderEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'uniqueCode': item.uniqueCode,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'sysType': _sysTypeConverter.encode(item.sysType),
|
|
'userCode': item.userCode,
|
|
'username': item.username,
|
|
'hourType': item.hourType,
|
|
'price': item.price,
|
|
'extraPrice': item.extraPrice,
|
|
'payPrice': item.payPrice,
|
|
'walletId': item.walletId,
|
|
'orderSourceTypeId': item.orderSourceTypeId,
|
|
'type': _orderTypeConverter.encode(item.type),
|
|
'status': _orderStatusConverter.encode(item.status),
|
|
'payType': _orderPayTypeConverter.encode(item.payType),
|
|
'productDesc': item.productDesc,
|
|
'count': item.count,
|
|
'weight': item.weight,
|
|
'payTime': _dateTimeEmptyConverter.encode(item.payTime),
|
|
'createTime': _dateTimeConverter.encode(item.createTime)
|
|
}),
|
|
_orderEntityDeletionAdapter = DeletionAdapter(
|
|
database,
|
|
'order_record',
|
|
['id'],
|
|
(OrderEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'uniqueCode': item.uniqueCode,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'sysType': _sysTypeConverter.encode(item.sysType),
|
|
'userCode': item.userCode,
|
|
'username': item.username,
|
|
'hourType': item.hourType,
|
|
'price': item.price,
|
|
'extraPrice': item.extraPrice,
|
|
'payPrice': item.payPrice,
|
|
'walletId': item.walletId,
|
|
'orderSourceTypeId': item.orderSourceTypeId,
|
|
'type': _orderTypeConverter.encode(item.type),
|
|
'status': _orderStatusConverter.encode(item.status),
|
|
'payType': _orderPayTypeConverter.encode(item.payType),
|
|
'productDesc': item.productDesc,
|
|
'count': item.count,
|
|
'weight': item.weight,
|
|
'payTime': _dateTimeEmptyConverter.encode(item.payTime),
|
|
'createTime': _dateTimeConverter.encode(item.createTime)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<OrderEntity> _orderEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<OrderEntity> _orderEntityUpdateAdapter;
|
|
|
|
final DeletionAdapter<OrderEntity> _orderEntityDeletionAdapter;
|
|
|
|
@override
|
|
Future<void> editOfflineStatus(String codes) async {
|
|
await _queryAdapter.queryNoReturn(
|
|
'UPDATE order_record SET status = \'PAY\' WHERE uniqueCode IN ?1',
|
|
arguments: [codes]);
|
|
}
|
|
|
|
@override
|
|
Future<List<OrderEntity>> findAll(
|
|
String status,
|
|
DateTime startCreateOrderTime,
|
|
DateTime endCreateOrderTime,
|
|
int pageSize,
|
|
int offset,
|
|
String sysType,
|
|
String hourType,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM order_record WHERE (?1 == \"-1\" OR status = ?1) AND (?6 = \'-1\' OR sysType = ?6) AND (?7 = \'-1\' OR hourType = ?7) AND strftime(\'%Y-%m-%d\', createTime) >= strftime(\'%Y-%m-%d\', ?2) AND strftime(\'%Y-%m-%d\', createTime) <= strftime(\'%Y-%m-%d\', ?3) ORDER BY createTime DESC LIMIT ?4 OFFSET ?5',
|
|
mapper: (Map<String, Object?> row) => OrderEntity(
|
|
id: row['id'] as int?,
|
|
uniqueCode: row['uniqueCode'] as String,
|
|
serviceUniqueCode: row['serviceUniqueCode'] as String,
|
|
sysType: _sysTypeConverter.decode(row['sysType'] as String),
|
|
userCode: row['userCode'] as String,
|
|
username: row['username'] as String?,
|
|
hourType: row['hourType'] as String?,
|
|
price: row['price'] as int,
|
|
extraPrice: row['extraPrice'] as int,
|
|
payPrice: row['payPrice'] as int,
|
|
walletId: row['walletId'] as String?,
|
|
orderSourceTypeId: row['orderSourceTypeId'] as String?,
|
|
type: _orderTypeConverter.decode(row['type'] as String),
|
|
status: _orderStatusConverter.decode(row['status'] as String),
|
|
payType: _orderPayTypeConverter.decode(row['payType'] as String),
|
|
productDesc: row['productDesc'] as String?,
|
|
count: row['count'] as int,
|
|
weight: row['weight'] as double,
|
|
payTime: _dateTimeEmptyConverter.decode(row['payTime'] as String),
|
|
createTime: _dateTimeConverter.decode(row['createTime'] as String)),
|
|
arguments: [
|
|
status,
|
|
_dateTimeConverter.encode(startCreateOrderTime),
|
|
_dateTimeConverter.encode(endCreateOrderTime),
|
|
pageSize,
|
|
offset,
|
|
sysType,
|
|
hourType
|
|
]);
|
|
}
|
|
|
|
@override
|
|
Future<int?> count(
|
|
String status,
|
|
DateTime startCreateOrderTime,
|
|
DateTime endCreateOrderTime,
|
|
String sysType,
|
|
String hourType,
|
|
) async {
|
|
return _queryAdapter.query(
|
|
'SELECT COUNT(0) FROM order_record WHERE (?1 == \"-1\" OR status = ?1) AND (?4 = \'-1\' OR sysType = ?4) AND (?5 = \'-1\' OR hourType = ?5) AND strftime(\'%Y-%m-%d\', createTime) >= strftime(\'%Y-%m-%d\', ?2) AND strftime(\'%Y-%m-%d\', createTime) <= strftime(\'%Y-%m-%d\', ?3)',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int,
|
|
arguments: [
|
|
status,
|
|
_dateTimeConverter.encode(startCreateOrderTime),
|
|
_dateTimeConverter.encode(endCreateOrderTime),
|
|
sysType,
|
|
hourType
|
|
]);
|
|
}
|
|
|
|
@override
|
|
Future<List<OrderEntity>> findOffline(
|
|
String sysType,
|
|
DateTime startCreateOrderTime,
|
|
DateTime endCreateOrderTime,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM order_record WHERE status = \'OFFLINE_PAY\' AND (?1 = \'-1\' OR sysType = ?1) AND createTime >= ?2 AND createTime <= ?3',
|
|
mapper: (Map<String, Object?> row) => OrderEntity(
|
|
id: row['id'] as int?,
|
|
uniqueCode: row['uniqueCode'] as String,
|
|
serviceUniqueCode: row['serviceUniqueCode'] as String,
|
|
sysType: _sysTypeConverter.decode(row['sysType'] as String),
|
|
userCode: row['userCode'] as String,
|
|
username: row['username'] as String?,
|
|
hourType: row['hourType'] as String?,
|
|
price: row['price'] as int,
|
|
extraPrice: row['extraPrice'] as int,
|
|
payPrice: row['payPrice'] as int,
|
|
walletId: row['walletId'] as String?,
|
|
orderSourceTypeId: row['orderSourceTypeId'] as String?,
|
|
type: _orderTypeConverter.decode(row['type'] as String),
|
|
status: _orderStatusConverter.decode(row['status'] as String),
|
|
payType: _orderPayTypeConverter.decode(row['payType'] as String),
|
|
productDesc: row['productDesc'] as String?,
|
|
count: row['count'] as int,
|
|
weight: row['weight'] as double,
|
|
payTime: _dateTimeEmptyConverter.decode(row['payTime'] as String),
|
|
createTime: _dateTimeConverter.decode(row['createTime'] as String)),
|
|
arguments: [
|
|
sysType,
|
|
_dateTimeConverter.encode(startCreateOrderTime),
|
|
_dateTimeConverter.encode(endCreateOrderTime)
|
|
]);
|
|
}
|
|
|
|
@override
|
|
Future<OrderEntity?> findById(int id) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM order_record WHERE id = ?1',
|
|
mapper: (Map<String, Object?> row) => OrderEntity(
|
|
id: row['id'] as int?,
|
|
uniqueCode: row['uniqueCode'] as String,
|
|
serviceUniqueCode: row['serviceUniqueCode'] as String,
|
|
sysType: _sysTypeConverter.decode(row['sysType'] as String),
|
|
userCode: row['userCode'] as String,
|
|
username: row['username'] as String?,
|
|
hourType: row['hourType'] as String?,
|
|
price: row['price'] as int,
|
|
extraPrice: row['extraPrice'] as int,
|
|
payPrice: row['payPrice'] as int,
|
|
walletId: row['walletId'] as String?,
|
|
orderSourceTypeId: row['orderSourceTypeId'] as String?,
|
|
type: _orderTypeConverter.decode(row['type'] as String),
|
|
status: _orderStatusConverter.decode(row['status'] as String),
|
|
payType: _orderPayTypeConverter.decode(row['payType'] as String),
|
|
productDesc: row['productDesc'] as String?,
|
|
count: row['count'] as int,
|
|
weight: row['weight'] as double,
|
|
payTime: _dateTimeEmptyConverter.decode(row['payTime'] as String),
|
|
createTime: _dateTimeConverter.decode(row['createTime'] as String)),
|
|
arguments: [id]);
|
|
}
|
|
|
|
@override
|
|
Future<int> save(OrderEntity entity) {
|
|
return _orderEntityInsertionAdapter.insertAndReturnId(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<OrderEntity> entitys) async {
|
|
await _orderEntityInsertionAdapter.insertList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(OrderEntity entity) async {
|
|
await _orderEntityUpdateAdapter.update(entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchEdit(List<OrderEntity> entitys) async {
|
|
await _orderEntityUpdateAdapter.updateList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> del(OrderEntity entity) async {
|
|
await _orderEntityDeletionAdapter.delete(entity);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchDel(List<OrderEntity> entitys) async {
|
|
await _orderEntityDeletionAdapter.deleteList(entitys);
|
|
}
|
|
}
|
|
|
|
class _$ProductDao extends ProductDao {
|
|
_$ProductDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_productEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'product',
|
|
(ProductEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'sysType': _sysTypeConverter.encode(item.sysType),
|
|
'classifyServiceUniqueCode': item.classifyServiceUniqueCode,
|
|
'hourType': item.hourType?.index,
|
|
'saleDate': _dateTimeEmptyConverter.encode(item.saleDate),
|
|
'name': item.name,
|
|
'price': item.price,
|
|
'image': item.image,
|
|
'isDefault': _boolConverter.encode(item.isDefault),
|
|
'status': item.status,
|
|
'sort': item.sort,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime),
|
|
'delFlag': _boolConverter.encode(item.delFlag)
|
|
}),
|
|
_productEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'product',
|
|
['id'],
|
|
(ProductEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'sysType': _sysTypeConverter.encode(item.sysType),
|
|
'classifyServiceUniqueCode': item.classifyServiceUniqueCode,
|
|
'hourType': item.hourType?.index,
|
|
'saleDate': _dateTimeEmptyConverter.encode(item.saleDate),
|
|
'name': item.name,
|
|
'price': item.price,
|
|
'image': item.image,
|
|
'isDefault': _boolConverter.encode(item.isDefault),
|
|
'status': item.status,
|
|
'sort': item.sort,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime),
|
|
'delFlag': _boolConverter.encode(item.delFlag)
|
|
}),
|
|
_productEntityDeletionAdapter = DeletionAdapter(
|
|
database,
|
|
'product',
|
|
['id'],
|
|
(ProductEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'sysType': _sysTypeConverter.encode(item.sysType),
|
|
'classifyServiceUniqueCode': item.classifyServiceUniqueCode,
|
|
'hourType': item.hourType?.index,
|
|
'saleDate': _dateTimeEmptyConverter.encode(item.saleDate),
|
|
'name': item.name,
|
|
'price': item.price,
|
|
'image': item.image,
|
|
'isDefault': _boolConverter.encode(item.isDefault),
|
|
'status': item.status,
|
|
'sort': item.sort,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime),
|
|
'delFlag': _boolConverter.encode(item.delFlag)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<ProductEntity> _productEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<ProductEntity> _productEntityUpdateAdapter;
|
|
|
|
final DeletionAdapter<ProductEntity> _productEntityDeletionAdapter;
|
|
|
|
@override
|
|
Future<void> delAllByType(String sysType) async {
|
|
await _queryAdapter.queryNoReturn(
|
|
'DELETE FROM product WHERE (?1 = \'-1\' OR sysType = ?1)',
|
|
arguments: [sysType]);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(
|
|
bool isDefault,
|
|
String uniqueCode,
|
|
String hourType,
|
|
) async {
|
|
await _queryAdapter.queryNoReturn(
|
|
'UPDATE product SET isDefault = ?1 WHERE delFlag = 0 AND serviceUniqueCode = ?2 AND hourType = ?3 AND (sysType = \'CANTEEN\' OR strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', \'now\', \'localtime\'))',
|
|
arguments: [_boolConverter.encode(isDefault), uniqueCode, hourType]);
|
|
}
|
|
|
|
@override
|
|
Future<int?> getCount(
|
|
String sysType,
|
|
String hourType,
|
|
) async {
|
|
return _queryAdapter.query(
|
|
'SELECT DISTINCT COUNT(0) FROM product WHERE delFlag = 0 AND (?1 = \'-1\' OR sysType = ?1) AND (?2 = \'-1\' OR INSTR(\',\' || hourType || \',\', \',\' || ?2 || \',\') > 0) AND (?1 = \'CANTEEN\' OR strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', \'now\', \'localtime\'))',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int,
|
|
arguments: [sysType, hourType]);
|
|
}
|
|
|
|
@override
|
|
Future<ProductEntity?> getByCode(String code) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM product WHERE delFlag = 0 AND serviceUniqueCode = ?1',
|
|
mapper: (Map<String, Object?> row) => ProductEntity(
|
|
id: row['id'] as int?,
|
|
serviceUniqueCode: row['serviceUniqueCode'] as String,
|
|
sysType: _sysTypeConverter.decode(row['sysType'] as String),
|
|
classifyServiceUniqueCode:
|
|
row['classifyServiceUniqueCode'] as String,
|
|
hourType: row['hourType'] == null
|
|
? null
|
|
: ProductHourType.values[row['hourType'] as int],
|
|
saleDate: _dateTimeEmptyConverter.decode(row['saleDate'] as String),
|
|
name: row['name'] as String,
|
|
price: row['price'] as int,
|
|
image: row['image'] as String?,
|
|
isDefault: _boolConverter.decode(row['isDefault'] as int),
|
|
status: row['status'] as int,
|
|
sort: row['sort'] as int,
|
|
createTime: _dateTimeConverter.decode(row['createTime'] as String),
|
|
updateTime: _dateTimeConverter.decode(row['updateTime'] as String),
|
|
delFlag: _boolConverter.decode(row['delFlag'] as int)),
|
|
arguments: [code]);
|
|
}
|
|
|
|
@override
|
|
Future<List<ProductEntity>> getAll(
|
|
String classifyServiceUniqueCode,
|
|
String hourType,
|
|
String sysType,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT product.* FROM product LEFT JOIN classify ON product.classifyServiceUniqueCode = classify.serviceUniqueCode WHERE product.delFlag = 0 AND (?1 = \'-1\' OR product.classifyServiceUniqueCode = ?1) AND (?2 = \'-1\' OR INSTR(\',\' || hourType || \',\', \',\' || ?2 || \',\') > 0) AND (?3 = \'-1\' OR product.sysType = ?3) ORDER BY classify.sort, product.price',
|
|
mapper: (Map<String, Object?> row) => ProductEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, sysType: _sysTypeConverter.decode(row['sysType'] as String), classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, hourType: row['hourType'] == null ? null : ProductHourType.values[row['hourType'] as int], saleDate: _dateTimeEmptyConverter.decode(row['saleDate'] as String), name: row['name'] as String, price: row['price'] as int, image: row['image'] as String?, isDefault: _boolConverter.decode(row['isDefault'] as int), status: row['status'] as int, sort: row['sort'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), delFlag: _boolConverter.decode(row['delFlag'] as int)),
|
|
arguments: [classifyServiceUniqueCode, hourType, sysType]);
|
|
}
|
|
|
|
@override
|
|
Future<List<ProductEntity>> getAllPage(
|
|
String classifyServiceUniqueCode,
|
|
String hourType,
|
|
String sysType,
|
|
int pageSize,
|
|
int offset,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT product.* FROM product LEFT JOIN classify ON product.classifyServiceUniqueCode = classify.serviceUniqueCode WHERE product.delFlag = 0 AND (?1 = \'-1\' OR product.classifyServiceUniqueCode = ?1) AND (?2 = \'-1\' OR INSTR(\',\' || product.hourType || \',\', \',\' || ?2 || \',\') > 0) AND (?3 = \'-1\' OR product.sysType = ?3) AND (?3 = \'CANTEEN\' OR strftime(\'%Y-%m-%d\', product.saleDate) = strftime(\'%Y-%m-%d\', \'now\', \'localtime\')) ORDER BY classify.sort, classify.id, product.price LIMIT ?4 OFFSET ?5',
|
|
mapper: (Map<String, Object?> row) => ProductEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, sysType: _sysTypeConverter.decode(row['sysType'] as String), classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, hourType: row['hourType'] == null ? null : ProductHourType.values[row['hourType'] as int], saleDate: _dateTimeEmptyConverter.decode(row['saleDate'] as String), name: row['name'] as String, price: row['price'] as int, image: row['image'] as String?, isDefault: _boolConverter.decode(row['isDefault'] as int), status: row['status'] as int, sort: row['sort'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), delFlag: _boolConverter.decode(row['delFlag'] as int)),
|
|
arguments: [
|
|
classifyServiceUniqueCode,
|
|
hourType,
|
|
sysType,
|
|
pageSize,
|
|
offset
|
|
]);
|
|
}
|
|
|
|
@override
|
|
Future<List<ProductEntity>> getDefault(
|
|
String sysType,
|
|
String hourType,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM product WHERE delFlag = 0 AND isDefault = 1 AND (?1 = \'-1\' OR sysType = ?1) AND (?2 = \'-1\' OR hourType = ?2) AND (?1 = \'CANTEEN\' OR strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', \'now\', \'localtime\'))',
|
|
mapper: (Map<String, Object?> row) => ProductEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, sysType: _sysTypeConverter.decode(row['sysType'] as String), classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, hourType: row['hourType'] == null ? null : ProductHourType.values[row['hourType'] as int], saleDate: _dateTimeEmptyConverter.decode(row['saleDate'] as String), name: row['name'] as String, price: row['price'] as int, image: row['image'] as String?, isDefault: _boolConverter.decode(row['isDefault'] as int), status: row['status'] as int, sort: row['sort'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), delFlag: _boolConverter.decode(row['delFlag'] as int)),
|
|
arguments: [sysType, hourType]);
|
|
}
|
|
|
|
@override
|
|
Future<void> save(ProductEntity entity) async {
|
|
await _productEntityInsertionAdapter.insert(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<ProductEntity> entitys) async {
|
|
await _productEntityInsertionAdapter.insertList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchEdit(List<ProductEntity> entitys) async {
|
|
await _productEntityUpdateAdapter.updateList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchDel(List<ProductEntity> entitys) async {
|
|
await _productEntityDeletionAdapter.deleteList(entitys);
|
|
}
|
|
}
|
|
|
|
class _$ShopCardDao extends ShopCardDao {
|
|
_$ShopCardDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_shopCardEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'shop_card',
|
|
(ShopCardEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'orderId': item.orderId,
|
|
'productServiceUniqueCode': item.productServiceUniqueCode,
|
|
'productName': item.productName,
|
|
'productPic': item.productPic,
|
|
'productPrice': item.productPrice,
|
|
'productNumber': item.productNumber,
|
|
'productWidget': item.productWidget,
|
|
'totalPrice': item.totalPrice
|
|
}),
|
|
_shopCardEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'shop_card',
|
|
['id'],
|
|
(ShopCardEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'orderId': item.orderId,
|
|
'productServiceUniqueCode': item.productServiceUniqueCode,
|
|
'productName': item.productName,
|
|
'productPic': item.productPic,
|
|
'productPrice': item.productPrice,
|
|
'productNumber': item.productNumber,
|
|
'productWidget': item.productWidget,
|
|
'totalPrice': item.totalPrice
|
|
}),
|
|
_shopCardEntityDeletionAdapter = DeletionAdapter(
|
|
database,
|
|
'shop_card',
|
|
['id'],
|
|
(ShopCardEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'orderId': item.orderId,
|
|
'productServiceUniqueCode': item.productServiceUniqueCode,
|
|
'productName': item.productName,
|
|
'productPic': item.productPic,
|
|
'productPrice': item.productPrice,
|
|
'productNumber': item.productNumber,
|
|
'productWidget': item.productWidget,
|
|
'totalPrice': item.totalPrice
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<ShopCardEntity> _shopCardEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<ShopCardEntity> _shopCardEntityUpdateAdapter;
|
|
|
|
final DeletionAdapter<ShopCardEntity> _shopCardEntityDeletionAdapter;
|
|
|
|
@override
|
|
Future<List<ShopCardEntity>> findByOrderId(int orderId) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM shop_card WHERE orderId = ?1',
|
|
mapper: (Map<String, Object?> row) => ShopCardEntity(
|
|
id: row['id'] as int?,
|
|
orderId: row['orderId'] as int,
|
|
productServiceUniqueCode: row['productServiceUniqueCode'] as String,
|
|
productName: row['productName'] as String,
|
|
productPic: row['productPic'] as String,
|
|
productPrice: row['productPrice'] as int,
|
|
productNumber: row['productNumber'] as int,
|
|
productWidget: row['productWidget'] as double,
|
|
totalPrice: row['totalPrice'] as int),
|
|
arguments: [orderId]);
|
|
}
|
|
|
|
@override
|
|
Future<void> save(ShopCardEntity entity) async {
|
|
await _shopCardEntityInsertionAdapter.insert(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<ShopCardEntity> entitys) async {
|
|
await _shopCardEntityInsertionAdapter.insertList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(ShopCardEntity entity) async {
|
|
await _shopCardEntityUpdateAdapter.update(entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchEdit(List<ShopCardEntity> entitys) async {
|
|
await _shopCardEntityUpdateAdapter.updateList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> del(ShopCardEntity entity) async {
|
|
await _shopCardEntityDeletionAdapter.delete(entity);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchDel(List<ShopCardEntity> entitys) async {
|
|
await _shopCardEntityDeletionAdapter.deleteList(entitys);
|
|
}
|
|
}
|
|
|
|
class _$ClassifyDao extends ClassifyDao {
|
|
_$ClassifyDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_classifyEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'classify',
|
|
(ClassifyEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'sysType': _sysTypeConverter.encode(item.sysType),
|
|
'name': item.name,
|
|
'categoryType': item.categoryType,
|
|
'sort': item.sort,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime),
|
|
'delFlag': _boolConverter.encode(item.delFlag)
|
|
}),
|
|
_classifyEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'classify',
|
|
['id'],
|
|
(ClassifyEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'sysType': _sysTypeConverter.encode(item.sysType),
|
|
'name': item.name,
|
|
'categoryType': item.categoryType,
|
|
'sort': item.sort,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime),
|
|
'delFlag': _boolConverter.encode(item.delFlag)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<ClassifyEntity> _classifyEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<ClassifyEntity> _classifyEntityUpdateAdapter;
|
|
|
|
@override
|
|
Future<int?> getCount() async {
|
|
return _queryAdapter.query(
|
|
'SELECT DISTINCT COUNT(0) FROM classify WHERE delFlag = 0',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int);
|
|
}
|
|
|
|
@override
|
|
Future<ClassifyEntity?> getByCode(String code) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM classify WHERE delFlag = 0 AND serviceUniqueCode = ?1',
|
|
mapper: (Map<String, Object?> row) => ClassifyEntity(
|
|
id: row['id'] as int?,
|
|
serviceUniqueCode: row['serviceUniqueCode'] as String,
|
|
sysType: _sysTypeConverter.decode(row['sysType'] as String),
|
|
name: row['name'] as String,
|
|
categoryType: row['categoryType'] as String,
|
|
sort: row['sort'] as int,
|
|
createTime: _dateTimeConverter.decode(row['createTime'] as String),
|
|
updateTime: _dateTimeConverter.decode(row['updateTime'] as String),
|
|
delFlag: _boolConverter.decode(row['delFlag'] as int)),
|
|
arguments: [code]);
|
|
}
|
|
|
|
@override
|
|
Future<List<ClassifyEntity>> getAll(
|
|
String sysType,
|
|
String categoryType,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT classify.* FROM classify WHERE delFlag = 0 AND (?1 = \'-1\' OR sysType = ?1) AND (?2 = \'-1\' OR INSTR(\',\' || categoryType || \',\', \',\' || ?2 || \',\') > 0) ORDER BY classify.sort',
|
|
mapper: (Map<String, Object?> row) => ClassifyEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, sysType: _sysTypeConverter.decode(row['sysType'] as String), name: row['name'] as String, categoryType: row['categoryType'] as String, sort: row['sort'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), delFlag: _boolConverter.decode(row['delFlag'] as int)),
|
|
arguments: [sysType, categoryType]);
|
|
}
|
|
|
|
@override
|
|
Future<void> save(ClassifyEntity entity) async {
|
|
await _classifyEntityInsertionAdapter.insert(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<ClassifyEntity> entitys) async {
|
|
await _classifyEntityInsertionAdapter.insertList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(ClassifyEntity entity) async {
|
|
await _classifyEntityUpdateAdapter.update(entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchEdit(List<ClassifyEntity> entitys) async {
|
|
await _classifyEntityUpdateAdapter.updateList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
}
|
|
|
|
class _$PrintHistoryDao extends PrintHistoryDao {
|
|
_$PrintHistoryDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_printHistoryEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'print_history',
|
|
(PrintHistoryEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'orderId': item.orderId,
|
|
'serviceOrderId': item.serviceOrderId,
|
|
'servicePrintId': item.servicePrintId,
|
|
'invoiceUrl': item.invoiceUrl,
|
|
'status': _printStatusConverter.encode(item.status),
|
|
'printTime': item.printTime,
|
|
'syncTime': _dateTimeEmptyConverter.encode(item.syncTime),
|
|
'createTime': _dateTimeConverter.encode(item.createTime)
|
|
}),
|
|
_printHistoryEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'print_history',
|
|
['id'],
|
|
(PrintHistoryEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'orderId': item.orderId,
|
|
'serviceOrderId': item.serviceOrderId,
|
|
'servicePrintId': item.servicePrintId,
|
|
'invoiceUrl': item.invoiceUrl,
|
|
'status': _printStatusConverter.encode(item.status),
|
|
'printTime': item.printTime,
|
|
'syncTime': _dateTimeEmptyConverter.encode(item.syncTime),
|
|
'createTime': _dateTimeConverter.encode(item.createTime)
|
|
}),
|
|
_printHistoryEntityDeletionAdapter = DeletionAdapter(
|
|
database,
|
|
'print_history',
|
|
['id'],
|
|
(PrintHistoryEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'orderId': item.orderId,
|
|
'serviceOrderId': item.serviceOrderId,
|
|
'servicePrintId': item.servicePrintId,
|
|
'invoiceUrl': item.invoiceUrl,
|
|
'status': _printStatusConverter.encode(item.status),
|
|
'printTime': item.printTime,
|
|
'syncTime': _dateTimeEmptyConverter.encode(item.syncTime),
|
|
'createTime': _dateTimeConverter.encode(item.createTime)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<PrintHistoryEntity>
|
|
_printHistoryEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<PrintHistoryEntity> _printHistoryEntityUpdateAdapter;
|
|
|
|
final DeletionAdapter<PrintHistoryEntity> _printHistoryEntityDeletionAdapter;
|
|
|
|
@override
|
|
Future<void> delAll() async {
|
|
await _queryAdapter.queryNoReturn('DELETE FROM print_history');
|
|
}
|
|
|
|
@override
|
|
Future<List<PrintHistoryEntity>> getAll(String status) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM print_history WHERE (?1 = \'-1\' OR status = ?1)',
|
|
mapper: (Map<String, Object?> row) => PrintHistoryEntity(id: row['id'] as int?, orderId: row['orderId'] as String, serviceOrderId: row['serviceOrderId'] as String, servicePrintId: row['servicePrintId'] as String, invoiceUrl: row['invoiceUrl'] as String, status: _printStatusConverter.decode(row['status'] as String), printTime: row['printTime'] as String?, syncTime: _dateTimeEmptyConverter.decode(row['syncTime'] as String), createTime: _dateTimeConverter.decode(row['createTime'] as String)),
|
|
arguments: [status]);
|
|
}
|
|
|
|
@override
|
|
Future<void> save(PrintHistoryEntity entity) async {
|
|
await _printHistoryEntityInsertionAdapter.insert(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<PrintHistoryEntity> entitys) async {
|
|
await _printHistoryEntityInsertionAdapter.insertList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(PrintHistoryEntity entity) async {
|
|
await _printHistoryEntityUpdateAdapter.update(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchEdit(List<PrintHistoryEntity> entitys) async {
|
|
await _printHistoryEntityUpdateAdapter.updateList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> del(PrintHistoryEntity entity) async {
|
|
await _printHistoryEntityDeletionAdapter.delete(entity);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchDel(List<PrintHistoryEntity> entitys) async {
|
|
await _printHistoryEntityDeletionAdapter.deleteList(entitys);
|
|
}
|
|
}
|
|
|
|
class _$UserDao extends UserDao {
|
|
_$UserDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_userEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'user_record',
|
|
(UserEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'userId': item.userId,
|
|
'nickname': item.nickname,
|
|
'mobile': item.mobile,
|
|
'avatar': item.avatar,
|
|
'walletCardNumber': item.walletCardNumber,
|
|
'walletId': item.walletId,
|
|
'walletTypeId': item.walletTypeId,
|
|
'walletBalance': item.walletBalance,
|
|
'createTime': _dateTimeEmptyConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
|
|
}),
|
|
_userEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'user_record',
|
|
['id'],
|
|
(UserEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'userId': item.userId,
|
|
'nickname': item.nickname,
|
|
'mobile': item.mobile,
|
|
'avatar': item.avatar,
|
|
'walletCardNumber': item.walletCardNumber,
|
|
'walletId': item.walletId,
|
|
'walletTypeId': item.walletTypeId,
|
|
'walletBalance': item.walletBalance,
|
|
'createTime': _dateTimeEmptyConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
|
|
}),
|
|
_userEntityDeletionAdapter = DeletionAdapter(
|
|
database,
|
|
'user_record',
|
|
['id'],
|
|
(UserEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'userId': item.userId,
|
|
'nickname': item.nickname,
|
|
'mobile': item.mobile,
|
|
'avatar': item.avatar,
|
|
'walletCardNumber': item.walletCardNumber,
|
|
'walletId': item.walletId,
|
|
'walletTypeId': item.walletTypeId,
|
|
'walletBalance': item.walletBalance,
|
|
'createTime': _dateTimeEmptyConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<UserEntity> _userEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<UserEntity> _userEntityUpdateAdapter;
|
|
|
|
final DeletionAdapter<UserEntity> _userEntityDeletionAdapter;
|
|
|
|
@override
|
|
Future<UserEntity?> findByUserId(String userId) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM user_record WHERE userId = ?1',
|
|
mapper: (Map<String, Object?> row) => UserEntity(
|
|
id: row['id'] as int?,
|
|
userId: row['userId'] as String,
|
|
nickname: row['nickname'] as String,
|
|
mobile: row['mobile'] as String?,
|
|
avatar: row['avatar'] as String?,
|
|
walletCardNumber: row['walletCardNumber'] as String?,
|
|
walletId: row['walletId'] as String?,
|
|
walletTypeId: row['walletTypeId'] as String?,
|
|
walletBalance: row['walletBalance'] as int?,
|
|
createTime:
|
|
_dateTimeEmptyConverter.decode(row['createTime'] as String),
|
|
updateTime:
|
|
_dateTimeEmptyConverter.decode(row['updateTime'] as String)),
|
|
arguments: [userId]);
|
|
}
|
|
|
|
@override
|
|
Future<UserEntity?> findByCardNumber(String walletCardNumber) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM user_record WHERE walletCardNumber = ?1',
|
|
mapper: (Map<String, Object?> row) => UserEntity(
|
|
id: row['id'] as int?,
|
|
userId: row['userId'] as String,
|
|
nickname: row['nickname'] as String,
|
|
mobile: row['mobile'] as String?,
|
|
avatar: row['avatar'] as String?,
|
|
walletCardNumber: row['walletCardNumber'] as String?,
|
|
walletId: row['walletId'] as String?,
|
|
walletTypeId: row['walletTypeId'] as String?,
|
|
walletBalance: row['walletBalance'] as int?,
|
|
createTime:
|
|
_dateTimeEmptyConverter.decode(row['createTime'] as String),
|
|
updateTime:
|
|
_dateTimeEmptyConverter.decode(row['updateTime'] as String)),
|
|
arguments: [walletCardNumber]);
|
|
}
|
|
|
|
@override
|
|
Future<void> save(UserEntity entity) async {
|
|
await _userEntityInsertionAdapter.insert(entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<UserEntity> entitys) async {
|
|
await _userEntityInsertionAdapter.insertList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(UserEntity entity) async {
|
|
await _userEntityUpdateAdapter.update(entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchEdit(List<UserEntity> entitys) async {
|
|
await _userEntityUpdateAdapter.updateList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> del(UserEntity entity) async {
|
|
await _userEntityDeletionAdapter.delete(entity);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchDel(List<UserEntity> entitys) async {
|
|
await _userEntityDeletionAdapter.deleteList(entitys);
|
|
}
|
|
}
|
|
|
|
class _$FaceDao extends FaceDao {
|
|
_$FaceDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_faceEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'face',
|
|
(FaceEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'userId': item.userId,
|
|
'sampleId': item.sampleId,
|
|
'userName': item.userName,
|
|
'deptId': item.deptId,
|
|
'deptName': item.deptName,
|
|
'imagePath': item.imagePath,
|
|
'path': item.path,
|
|
'faceModel': _listIntConverter.encode(item.faceModel),
|
|
'createTime': _dateTimeEmptyConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
|
|
}),
|
|
_faceEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'face',
|
|
['id'],
|
|
(FaceEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'userId': item.userId,
|
|
'sampleId': item.sampleId,
|
|
'userName': item.userName,
|
|
'deptId': item.deptId,
|
|
'deptName': item.deptName,
|
|
'imagePath': item.imagePath,
|
|
'path': item.path,
|
|
'faceModel': _listIntConverter.encode(item.faceModel),
|
|
'createTime': _dateTimeEmptyConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
|
|
}),
|
|
_faceEntityDeletionAdapter = DeletionAdapter(
|
|
database,
|
|
'face',
|
|
['id'],
|
|
(FaceEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'userId': item.userId,
|
|
'sampleId': item.sampleId,
|
|
'userName': item.userName,
|
|
'deptId': item.deptId,
|
|
'deptName': item.deptName,
|
|
'imagePath': item.imagePath,
|
|
'path': item.path,
|
|
'faceModel': _listIntConverter.encode(item.faceModel),
|
|
'createTime': _dateTimeEmptyConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<FaceEntity> _faceEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<FaceEntity> _faceEntityUpdateAdapter;
|
|
|
|
final DeletionAdapter<FaceEntity> _faceEntityDeletionAdapter;
|
|
|
|
@override
|
|
Future<void> delAll() async {
|
|
await _queryAdapter.queryNoReturn('DELETE FROM face');
|
|
}
|
|
|
|
@override
|
|
Future<void> delById(int id) async {
|
|
await _queryAdapter
|
|
.queryNoReturn('DELETE FROM face WHERE id = ?1', arguments: [id]);
|
|
}
|
|
|
|
@override
|
|
Future<void> delByUserId(String userId) async {
|
|
await _queryAdapter.queryNoReturn('DELETE FROM face WHERE userId = ?1',
|
|
arguments: [userId]);
|
|
}
|
|
|
|
@override
|
|
Future<int?> findCount(String userName) async {
|
|
return _queryAdapter.query(
|
|
'SELECT DISTINCT COUNT(0) FROM face WHERE (?1 = \'-1\' OR userName LIKE \'%\' || ?1 || \'%\')',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int,
|
|
arguments: [userName]);
|
|
}
|
|
|
|
@override
|
|
Future<FaceEntity?> getById(int id) async {
|
|
return _queryAdapter.query('SELECT * FROM face WHERE id = ?1',
|
|
mapper: (Map<String, Object?> row) => FaceEntity(
|
|
id: row['id'] as int?,
|
|
userId: row['userId'] as String,
|
|
sampleId: row['sampleId'] as String,
|
|
userName: row['userName'] as String,
|
|
deptId: row['deptId'] as String?,
|
|
deptName: row['deptName'] as String?,
|
|
imagePath: row['imagePath'] as String,
|
|
path: row['path'] as String?,
|
|
faceModel: _listIntConverter.decode(row['faceModel'] as String),
|
|
createTime:
|
|
_dateTimeEmptyConverter.decode(row['createTime'] as String),
|
|
updateTime:
|
|
_dateTimeEmptyConverter.decode(row['updateTime'] as String)),
|
|
arguments: [id]);
|
|
}
|
|
|
|
@override
|
|
Future<FaceEntity?> findBySampleId(String sampleId) async {
|
|
return _queryAdapter.query('SELECT * FROM face WHERE sampleId = ?1',
|
|
mapper: (Map<String, Object?> row) => FaceEntity(
|
|
id: row['id'] as int?,
|
|
userId: row['userId'] as String,
|
|
sampleId: row['sampleId'] as String,
|
|
userName: row['userName'] as String,
|
|
deptId: row['deptId'] as String?,
|
|
deptName: row['deptName'] as String?,
|
|
imagePath: row['imagePath'] as String,
|
|
path: row['path'] as String?,
|
|
faceModel: _listIntConverter.decode(row['faceModel'] as String),
|
|
createTime:
|
|
_dateTimeEmptyConverter.decode(row['createTime'] as String),
|
|
updateTime:
|
|
_dateTimeEmptyConverter.decode(row['updateTime'] as String)),
|
|
arguments: [sampleId]);
|
|
}
|
|
|
|
@override
|
|
Future<List<FaceEntity>?> findByUserId(String userId) async {
|
|
return _queryAdapter.queryList('SELECT * FROM face WHERE userId = ?1',
|
|
mapper: (Map<String, Object?> row) => FaceEntity(
|
|
id: row['id'] as int?,
|
|
userId: row['userId'] as String,
|
|
sampleId: row['sampleId'] as String,
|
|
userName: row['userName'] as String,
|
|
deptId: row['deptId'] as String?,
|
|
deptName: row['deptName'] as String?,
|
|
imagePath: row['imagePath'] as String,
|
|
path: row['path'] as String?,
|
|
faceModel: _listIntConverter.decode(row['faceModel'] as String),
|
|
createTime:
|
|
_dateTimeEmptyConverter.decode(row['createTime'] as String),
|
|
updateTime:
|
|
_dateTimeEmptyConverter.decode(row['updateTime'] as String)),
|
|
arguments: [userId]);
|
|
}
|
|
|
|
@override
|
|
Future<List<FaceEntity>> findAll(
|
|
String userName,
|
|
int pageSize,
|
|
int offset,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM face WHERE (?1 = \'-1\' OR userName LIKE \'%\' || ?1 || \'%\') LIMIT ?2 OFFSET ?3',
|
|
mapper: (Map<String, Object?> row) => FaceEntity(id: row['id'] as int?, userId: row['userId'] as String, sampleId: row['sampleId'] as String, userName: row['userName'] as String, deptId: row['deptId'] as String?, deptName: row['deptName'] as String?, imagePath: row['imagePath'] as String, path: row['path'] as String?, faceModel: _listIntConverter.decode(row['faceModel'] as String), createTime: _dateTimeEmptyConverter.decode(row['createTime'] as String), updateTime: _dateTimeEmptyConverter.decode(row['updateTime'] as String)),
|
|
arguments: [userName, pageSize, offset]);
|
|
}
|
|
|
|
@override
|
|
Future<List<String>> findAllUserIds() async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT DISTINCT a.deptId FROM face a WHERE a.deptId IS NOT NULL',
|
|
mapper: (Map<String, Object?> row) => row.values.first as String);
|
|
}
|
|
|
|
@override
|
|
Future<int> save(FaceEntity entity) {
|
|
return _faceEntityInsertionAdapter.insertAndReturnId(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<FaceEntity> entitys) async {
|
|
await _faceEntityInsertionAdapter.insertList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(FaceEntity entity) async {
|
|
await _faceEntityUpdateAdapter.update(entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchEdit(List<FaceEntity> entitys) async {
|
|
await _faceEntityUpdateAdapter.updateList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> del(FaceEntity entity) async {
|
|
await _faceEntityDeletionAdapter.delete(entity);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchDel(List<FaceEntity> entitys) async {
|
|
await _faceEntityDeletionAdapter.deleteList(entitys);
|
|
}
|
|
}
|
|
|
|
class _$SettingDao extends SettingDao {
|
|
_$SettingDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_settingEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'setting',
|
|
(SettingEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'userJson': item.userJson,
|
|
'sysJson': item.sysJson,
|
|
'canteenExtraPriceConfigJson':
|
|
item.canteenExtraPriceConfigJson
|
|
}),
|
|
_settingEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'setting',
|
|
['id'],
|
|
(SettingEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'userJson': item.userJson,
|
|
'sysJson': item.sysJson,
|
|
'canteenExtraPriceConfigJson':
|
|
item.canteenExtraPriceConfigJson
|
|
}),
|
|
_settingEntityDeletionAdapter = DeletionAdapter(
|
|
database,
|
|
'setting',
|
|
['id'],
|
|
(SettingEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'userJson': item.userJson,
|
|
'sysJson': item.sysJson,
|
|
'canteenExtraPriceConfigJson':
|
|
item.canteenExtraPriceConfigJson
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<SettingEntity> _settingEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<SettingEntity> _settingEntityUpdateAdapter;
|
|
|
|
final DeletionAdapter<SettingEntity> _settingEntityDeletionAdapter;
|
|
|
|
@override
|
|
Future<SettingEntity?> get() async {
|
|
return _queryAdapter.query('SELECT * FROM setting LIMIT 1',
|
|
mapper: (Map<String, Object?> row) => SettingEntity(
|
|
id: row['id'] as int?,
|
|
userJson: row['userJson'] as String,
|
|
sysJson: row['sysJson'] as String,
|
|
canteenExtraPriceConfigJson:
|
|
row['canteenExtraPriceConfigJson'] as String?));
|
|
}
|
|
|
|
@override
|
|
Future<int> save(SettingEntity entity) {
|
|
return _settingEntityInsertionAdapter.insertAndReturnId(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(SettingEntity entity) async {
|
|
await _settingEntityUpdateAdapter.update(entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> del(SettingEntity entity) async {
|
|
await _settingEntityDeletionAdapter.delete(entity);
|
|
}
|
|
}
|
|
|
|
// ignore_for_file: unused_element
|
|
final _dateTimeConverter = DateTimeConverter();
|
|
final _dateTimeEmptyConverter = DateTimeEmptyConverter();
|
|
final _orderStatusConverter = OrderStatusConverter();
|
|
final _orderTypeConverter = OrderTypeConverter();
|
|
final _orderPayTypeConverter = OrderPayTypeConverter();
|
|
final _sysTypeConverter = SysTypeConverter();
|
|
final _printStatusConverter = PrintStatusConverter();
|
|
final _listIntConverter = ListIntConverter();
|
|
final _boolConverter = BoolConverter();
|