2988 lines
161 KiB
Dart
2988 lines
161 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();
|
|
}
|
|
|
|
BroadcastDao? _getBroadcastDaoInstance;
|
|
|
|
OrderDao? _getOrderDaoInstance;
|
|
|
|
OrderHoldBillDao? _getOrderHoldBillDaoInstance;
|
|
|
|
CanteenSpuDao? _getCanteenSpuDaoInstance;
|
|
|
|
SupermarketSkuDao? _getSupermarketSkuDaoInstance;
|
|
|
|
SupermarketSpuDao? _getSupermarketSpuDaoInstance;
|
|
|
|
SupermarketCodeDao? _getSupermarketCodeDaoInstance;
|
|
|
|
ShopCardDao? _getShopCardDaoInstance;
|
|
|
|
ClassifyDao? _getClassifyDaoInstance;
|
|
|
|
PrintHistoryDao? _getPrintHistoryDaoInstance;
|
|
|
|
UserDao? _getUserDaoInstance;
|
|
|
|
FaceDao? _getFaceDaoInstance;
|
|
|
|
SettingDao? _getSettingDaoInstance;
|
|
|
|
ScheduledTaskDao? _getScheduledTaskDaoInstance;
|
|
|
|
ScheduledTaskLogDao? _getScheduledTaskLogDaoInstance;
|
|
|
|
FileUploadRecordDao? _getFileUploadRecordDaoInstance;
|
|
|
|
OrderEvidenceUploadTaskDao? _getOrderEvidenceUploadTaskDaoInstance;
|
|
|
|
Future<sqflite.Database> open(
|
|
String path,
|
|
List<Migration> migrations, [
|
|
Callback? callback,
|
|
]) async {
|
|
final databaseOptions = sqflite.OpenDatabaseOptions(
|
|
version: 13,
|
|
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 `broadcast` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `content` TEXT NOT NULL, `broadcastCount` INTEGER NOT NULL, `broadcastMaxCount` INTEGER NOT NULL, `isBroadcast` INTEGER NOT NULL, `isDone` INTEGER NOT NULL, `isDoneTime` TEXT, `serviceCode` TEXT NOT NULL, `serviceOrderCode` TEXT NOT NULL, `userId` TEXT NOT NULL, `username` TEXT NOT NULL, `userMobile` TEXT NOT NULL, `productDesc` TEXT NOT NULL, `payPrice` INTEGER NOT NULL, `hourType` INTEGER, `enable` INTEGER NOT NULL, `createTime` TEXT NOT NULL)');
|
|
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 `order_hold_bill` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `sysType` TEXT NOT NULL, `carListJson` TEXT, `userJson` TEXT, `price` INTEGER NOT NULL, `extraPrice` INTEGER NOT NULL, `payPrice` INTEGER NOT NULL, `createTime` TEXT NOT NULL)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `canteen_spu` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `serviceUniqueCode` TEXT NOT NULL, `classifyServiceUniqueCode` TEXT NOT NULL, `hourType` INTEGER, `saleDate` TEXT NOT NULL, `name` TEXT NOT NULL, `price` INTEGER NOT NULL, `stock` INTEGER, `image` TEXT, `isDefault` INTEGER NOT NULL, `status` INTEGER NOT NULL, `sort` INTEGER NOT NULL, `isPriceIncreased` INTEGER NOT NULL, `spuType` INTEGER NOT NULL, `createTime` TEXT NOT NULL, `updateTime` TEXT NOT NULL)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `canteen_spu_combo_item` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `parentServiceUniqueCode` TEXT NOT NULL, `saleDate` TEXT NOT NULL, `childServiceUniqueCode` TEXT NOT NULL, `name` TEXT NOT NULL, `image` TEXT, `quantity` INTEGER NOT NULL, `sort` INTEGER NOT NULL, `price` INTEGER NOT NULL)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `supermarket_sku` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `serviceUniqueCode` TEXT NOT NULL, `spuId` TEXT NOT NULL, `barCode` TEXT NOT NULL, `spec` TEXT NOT NULL, `unit` TEXT NOT NULL, `packageNum` INTEGER NOT NULL, `purchasePrice` INTEGER NOT NULL, `retailPrice` INTEGER NOT NULL, `promotionPrice` INTEGER NOT NULL)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `supermarket_spu` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `serviceUniqueCode` TEXT NOT NULL, `classifyServiceUniqueCode` TEXT NOT NULL, `productCode` TEXT NOT NULL, `productName` TEXT NOT NULL, `productNamePy` TEXT, `productNature` TEXT NOT NULL, `barCode` TEXT, `packageNum` INTEGER NOT NULL, `unit` TEXT NOT NULL, `spec` TEXT NOT NULL, `picUrl` TEXT, `stock` REAL, `salesCount` REAL, `purchasePrice` INTEGER NOT NULL, `retailPrice` INTEGER NOT NULL, `promotionPrice` 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 `supermarket_code` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `serviceUniqueCode` TEXT NOT NULL, `spuId` TEXT NOT NULL, `unitId` TEXT NOT NULL, `barCode` TEXT 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, `nature` TEXT NOT NULL, `productNumber` INTEGER NOT NULL, `productWidget` REAL NOT NULL, `totalPrice` INTEGER NOT NULL, `isPriceIncreased` 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, `printType` TEXT NOT NULL, `printNo` INTEGER NOT NULL, `retryVersion` INTEGER NOT NULL, `attemptCount` INTEGER NOT NULL, `lastError` TEXT, `resultPending` INTEGER 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, `canteenId` TEXT, `discountsList` TEXT, `discountsUpdateTime` TEXT, `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, `qualityScore` REAL, `qualityStatus` TEXT NOT NULL, `qualityCheckedAt` TEXT, `qualityErrorCode` INTEGER)');
|
|
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 database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `scheduled_task` (`taskCode` TEXT NOT NULL, `enabled` INTEGER NOT NULL, `cronExpression` TEXT NOT NULL, `idleOnly` INTEGER NOT NULL, `lastRunAt` TEXT, `lastSuccessAt` TEXT, `lastStatus` TEXT NOT NULL, `lastMessage` TEXT NOT NULL, `createTime` TEXT NOT NULL, `updateTime` TEXT NOT NULL, PRIMARY KEY (`taskCode`))');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `scheduled_task_log` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `taskCode` TEXT NOT NULL, `taskName` TEXT NOT NULL, `triggerType` TEXT NOT NULL, `sourceType` TEXT NOT NULL, `sourceName` TEXT NOT NULL, `status` TEXT NOT NULL, `message` TEXT NOT NULL, `errorType` TEXT, `errorMessage` TEXT, `errorStack` TEXT, `startedAt` TEXT NOT NULL, `finishedAt` TEXT, `durationMs` INTEGER NOT NULL, `scannedCount` INTEGER, `skippedCount` INTEGER, `successCount` INTEGER, `failureCount` INTEGER)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `file_upload_record` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `hardId` TEXT NOT NULL, `bizType` TEXT NOT NULL, `relativePath` TEXT NOT NULL, `originalName` TEXT NOT NULL, `sourceSize` INTEGER NOT NULL, `sourceModifiedTime` TEXT NOT NULL, `sanitizedHash` TEXT NOT NULL, `sanitizedSize` INTEGER NOT NULL, `status` TEXT NOT NULL, `serverFileId` TEXT, `attemptCount` INTEGER NOT NULL, `lastAttemptAt` TEXT, `uploadedAt` TEXT, `lastError` TEXT, `createTime` TEXT NOT NULL, `updateTime` TEXT NOT NULL)');
|
|
await database.execute(
|
|
'CREATE TABLE IF NOT EXISTS `order_evidence_upload_task` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `androidOrderCode` TEXT, `serverOrderId` TEXT, `recognitionSessionId` TEXT NOT NULL, `evidenceType` TEXT NOT NULL, `evidenceRole` TEXT NOT NULL, `sequenceNo` INTEGER NOT NULL, `userId` TEXT NOT NULL, `faceSampleId` TEXT, `referenceImageUrl` TEXT, `referenceImageVersion` TEXT, `localFilePath` TEXT, `imageHash` TEXT, `imageSize` INTEGER, `imageWidth` INTEGER, `imageHeight` INTEGER, `similarity` REAL, `similarityThreshold` REAL, `capturedAt` TEXT NOT NULL, `appVersion` TEXT NOT NULL, `status` TEXT NOT NULL, `attemptCount` INTEGER NOT NULL, `nextRetryAt` TEXT, `serverEvidenceId` TEXT, `serverImageUrl` TEXT, `lastError` TEXT, `unavailableReportedAt` TEXT, `completedAt` TEXT, `createTime` TEXT NOT NULL, `updateTime` TEXT NOT NULL, `expiresAt` TEXT NOT NULL)');
|
|
await database.execute(
|
|
'CREATE INDEX `index_canteen_spu_combo_item_parentServiceUniqueCode_saleDate` ON `canteen_spu_combo_item` (`parentServiceUniqueCode`, `saleDate`)');
|
|
await database.execute(
|
|
'CREATE UNIQUE INDEX `index_canteen_spu_combo_item_parentServiceUniqueCode_saleDate_childServiceUniqueCode` ON `canteen_spu_combo_item` (`parentServiceUniqueCode`, `saleDate`, `childServiceUniqueCode`)');
|
|
await database.execute(
|
|
'CREATE UNIQUE INDEX `index_print_history_servicePrintId` ON `print_history` (`servicePrintId`)');
|
|
await database.execute(
|
|
'CREATE INDEX `index_scheduled_task_log_taskCode_startedAt` ON `scheduled_task_log` (`taskCode`, `startedAt`)');
|
|
await database.execute(
|
|
'CREATE INDEX `index_scheduled_task_log_sourceType_status_startedAt` ON `scheduled_task_log` (`sourceType`, `status`, `startedAt`)');
|
|
await database.execute(
|
|
'CREATE UNIQUE INDEX `index_file_upload_record_hardId_bizType_relativePath` ON `file_upload_record` (`hardId`, `bizType`, `relativePath`)');
|
|
await database.execute(
|
|
'CREATE INDEX `index_file_upload_record_bizType_status_updateTime` ON `file_upload_record` (`bizType`, `status`, `updateTime`)');
|
|
await database.execute(
|
|
'CREATE UNIQUE INDEX `index_order_evidence_upload_task_androidOrderCode_evidenceType_evidenceRole_sequenceNo` ON `order_evidence_upload_task` (`androidOrderCode`, `evidenceType`, `evidenceRole`, `sequenceNo`)');
|
|
await database.execute(
|
|
'CREATE INDEX `index_order_evidence_upload_task_status_nextRetryAt_createTime` ON `order_evidence_upload_task` (`status`, `nextRetryAt`, `createTime`)');
|
|
|
|
await callback?.onCreate?.call(database, version);
|
|
},
|
|
);
|
|
return sqfliteDatabaseFactory.openDatabase(path, options: databaseOptions);
|
|
}
|
|
|
|
@override
|
|
BroadcastDao get getBroadcastDao {
|
|
return _getBroadcastDaoInstance ??=
|
|
_$BroadcastDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
OrderDao get getOrderDao {
|
|
return _getOrderDaoInstance ??= _$OrderDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
OrderHoldBillDao get getOrderHoldBillDao {
|
|
return _getOrderHoldBillDaoInstance ??=
|
|
_$OrderHoldBillDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
CanteenSpuDao get getCanteenSpuDao {
|
|
return _getCanteenSpuDaoInstance ??=
|
|
_$CanteenSpuDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
SupermarketSkuDao get getSupermarketSkuDao {
|
|
return _getSupermarketSkuDaoInstance ??=
|
|
_$SupermarketSkuDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
SupermarketSpuDao get getSupermarketSpuDao {
|
|
return _getSupermarketSpuDaoInstance ??=
|
|
_$SupermarketSpuDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
SupermarketCodeDao get getSupermarketCodeDao {
|
|
return _getSupermarketCodeDaoInstance ??=
|
|
_$SupermarketCodeDao(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);
|
|
}
|
|
|
|
@override
|
|
ScheduledTaskDao get getScheduledTaskDao {
|
|
return _getScheduledTaskDaoInstance ??=
|
|
_$ScheduledTaskDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
ScheduledTaskLogDao get getScheduledTaskLogDao {
|
|
return _getScheduledTaskLogDaoInstance ??=
|
|
_$ScheduledTaskLogDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
FileUploadRecordDao get getFileUploadRecordDao {
|
|
return _getFileUploadRecordDaoInstance ??=
|
|
_$FileUploadRecordDao(database, changeListener);
|
|
}
|
|
|
|
@override
|
|
OrderEvidenceUploadTaskDao get getOrderEvidenceUploadTaskDao {
|
|
return _getOrderEvidenceUploadTaskDaoInstance ??=
|
|
_$OrderEvidenceUploadTaskDao(database, changeListener);
|
|
}
|
|
}
|
|
|
|
class _$BroadcastDao extends BroadcastDao {
|
|
_$BroadcastDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_broadcastEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'broadcast',
|
|
(BroadcastEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'content': item.content,
|
|
'broadcastCount': item.broadcastCount,
|
|
'broadcastMaxCount': item.broadcastMaxCount,
|
|
'isBroadcast': _boolConverter.encode(item.isBroadcast),
|
|
'isDone': _boolConverter.encode(item.isDone),
|
|
'isDoneTime': _dateTimeEmptyConverter.encode(item.isDoneTime),
|
|
'serviceCode': item.serviceCode,
|
|
'serviceOrderCode': item.serviceOrderCode,
|
|
'userId': item.userId,
|
|
'username': item.username,
|
|
'userMobile': item.userMobile,
|
|
'productDesc': item.productDesc,
|
|
'payPrice': item.payPrice,
|
|
'hourType': item.hourType?.index,
|
|
'enable': _boolConverter.encode(item.enable),
|
|
'createTime': _dateTimeConverter.encode(item.createTime)
|
|
}),
|
|
_broadcastEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'broadcast',
|
|
['id'],
|
|
(BroadcastEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'content': item.content,
|
|
'broadcastCount': item.broadcastCount,
|
|
'broadcastMaxCount': item.broadcastMaxCount,
|
|
'isBroadcast': _boolConverter.encode(item.isBroadcast),
|
|
'isDone': _boolConverter.encode(item.isDone),
|
|
'isDoneTime': _dateTimeEmptyConverter.encode(item.isDoneTime),
|
|
'serviceCode': item.serviceCode,
|
|
'serviceOrderCode': item.serviceOrderCode,
|
|
'userId': item.userId,
|
|
'username': item.username,
|
|
'userMobile': item.userMobile,
|
|
'productDesc': item.productDesc,
|
|
'payPrice': item.payPrice,
|
|
'hourType': item.hourType?.index,
|
|
'enable': _boolConverter.encode(item.enable),
|
|
'createTime': _dateTimeConverter.encode(item.createTime)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<BroadcastEntity> _broadcastEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<BroadcastEntity> _broadcastEntityUpdateAdapter;
|
|
|
|
@override
|
|
Future<void> del(String serviceOrderCode) async {
|
|
await _queryAdapter.queryNoReturn(
|
|
'DELETE FROM broadcast WHERE isDone = 0 AND (?1 = \'-1\' OR serviceOrderCode = ?1)',
|
|
arguments: [serviceOrderCode]);
|
|
}
|
|
|
|
@override
|
|
Future<List<BroadcastEntity>> getAll(String hourType) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM broadcast WHERE isDone = 0 AND enable = 1 AND broadcastCount < broadcastMaxCount AND (?1 = \'-1\' OR hourType = ?1) AND strftime(\'%Y-%m-%d\', createTime) = strftime(\'%Y-%m-%d\', \'now\', \'localtime\')',
|
|
mapper: (Map<String, Object?> row) => BroadcastEntity(id: row['id'] as int?, content: row['content'] as String, broadcastCount: row['broadcastCount'] as int, broadcastMaxCount: row['broadcastMaxCount'] as int, isBroadcast: _boolConverter.decode(row['isBroadcast'] as int), isDone: _boolConverter.decode(row['isDone'] as int), createTime: _dateTimeConverter.decode(row['createTime'] as String), serviceCode: row['serviceCode'] as String, serviceOrderCode: row['serviceOrderCode'] as String, userId: row['userId'] as String, username: row['username'] as String, userMobile: row['userMobile'] as String, productDesc: row['productDesc'] as String, payPrice: row['payPrice'] as int, hourType: row['hourType'] == null ? null : ProductHourType.values[row['hourType'] as int], enable: _boolConverter.decode(row['enable'] as int)),
|
|
arguments: [hourType]);
|
|
}
|
|
|
|
@override
|
|
Future<List<BroadcastEntity>> findAllPage(
|
|
String hourType,
|
|
int pageSize,
|
|
int offset,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM broadcast WHERE strftime(\'%Y-%m-%d\', createTime) = strftime(\'%Y-%m-%d\', \'now\', \'localtime\') AND (?1 = \'-1\' OR hourType = ?1) LIMIT ?2 OFFSET ?3',
|
|
mapper: (Map<String, Object?> row) => BroadcastEntity(id: row['id'] as int?, content: row['content'] as String, broadcastCount: row['broadcastCount'] as int, broadcastMaxCount: row['broadcastMaxCount'] as int, isBroadcast: _boolConverter.decode(row['isBroadcast'] as int), isDone: _boolConverter.decode(row['isDone'] as int), createTime: _dateTimeConverter.decode(row['createTime'] as String), serviceCode: row['serviceCode'] as String, serviceOrderCode: row['serviceOrderCode'] as String, userId: row['userId'] as String, username: row['username'] as String, userMobile: row['userMobile'] as String, productDesc: row['productDesc'] as String, payPrice: row['payPrice'] as int, hourType: row['hourType'] == null ? null : ProductHourType.values[row['hourType'] as int], enable: _boolConverter.decode(row['enable'] as int)),
|
|
arguments: [hourType, pageSize, offset]);
|
|
}
|
|
|
|
@override
|
|
Future<int?> count(String hourType) async {
|
|
return _queryAdapter.query(
|
|
'SELECT COUNT(0) FROM broadcast WHERE strftime(\'%Y-%m-%d\', createTime) = strftime(\'%Y-%m-%d\', \'now\', \'localtime\') AND (?1 = \'-1\' OR hourType = ?1)',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int,
|
|
arguments: [hourType]);
|
|
}
|
|
|
|
@override
|
|
Future<void> save(BroadcastEntity entity) async {
|
|
await _broadcastEntityInsertionAdapter.insert(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<BroadcastEntity> entitys) async {
|
|
await _broadcastEntityInsertionAdapter.insertList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(BroadcastEntity entity) async {
|
|
await _broadcastEntityUpdateAdapter.update(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
}
|
|
|
|
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<void> decreaseCanteenStock(
|
|
String productServiceUniqueCode,
|
|
String stockDate,
|
|
int quantity,
|
|
) async {
|
|
await _queryAdapter.queryNoReturn(
|
|
'UPDATE canteen_spu SET stock = MAX(stock - ?3, 0) WHERE serviceUniqueCode = ?1 AND strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', ?2) AND stock IS NOT NULL',
|
|
arguments: [productServiceUniqueCode, stockDate, quantity]);
|
|
}
|
|
|
|
@override
|
|
Future<List<OrderEntity>> findAll(
|
|
String status,
|
|
DateTime startCreateOrderTime,
|
|
DateTime endCreateOrderTime,
|
|
int pageSize,
|
|
int offset,
|
|
String sysType,
|
|
String hourType,
|
|
String keyword,
|
|
) 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 (?8 = \'\' OR serviceUniqueCode LIKE \'%\' || ?8 || \'%\' OR uniqueCode LIKE \'%\' || ?8 || \'%\' OR userCode LIKE \'%\' || ?8 || \'%\' OR username LIKE \'%\' || ?8 || \'%\' OR productDesc LIKE \'%\' || ?8 || \'%\') 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,
|
|
keyword
|
|
]);
|
|
}
|
|
|
|
@override
|
|
Future<int?> count(
|
|
String status,
|
|
DateTime startCreateOrderTime,
|
|
DateTime endCreateOrderTime,
|
|
String sysType,
|
|
String hourType,
|
|
String keyword,
|
|
) 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 (?6 = \'\' OR serviceUniqueCode LIKE \'%\' || ?6 || \'%\' OR uniqueCode LIKE \'%\' || ?6 || \'%\' OR userCode LIKE \'%\' || ?6 || \'%\' OR username LIKE \'%\' || ?6 || \'%\' OR productDesc LIKE \'%\' || ?6 || \'%\') 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,
|
|
keyword
|
|
]);
|
|
}
|
|
|
|
@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);
|
|
}
|
|
|
|
@override
|
|
Future<bool> completePaidCanteenOrder(
|
|
OrderEntity paidOrder,
|
|
List<ShopCardEntity> cartItems,
|
|
String stockDate,
|
|
) async {
|
|
if (database is sqflite.Transaction) {
|
|
return super.completePaidCanteenOrder(paidOrder, cartItems, stockDate);
|
|
} else {
|
|
return (database as sqflite.Database)
|
|
.transaction<bool>((transaction) async {
|
|
final transactionDatabase = _$AppDatabase(changeListener)
|
|
..database = transaction;
|
|
return transactionDatabase.getOrderDao
|
|
.completePaidCanteenOrder(paidOrder, cartItems, stockDate);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
class _$OrderHoldBillDao extends OrderHoldBillDao {
|
|
_$OrderHoldBillDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_orderHoldBillEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'order_hold_bill',
|
|
(OrderHoldBillEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'sysType': _sysTypeConverter.encode(item.sysType),
|
|
'carListJson': item.carListJson,
|
|
'userJson': item.userJson,
|
|
'price': item.price,
|
|
'extraPrice': item.extraPrice,
|
|
'payPrice': item.payPrice,
|
|
'createTime': _dateTimeConverter.encode(item.createTime)
|
|
}),
|
|
_orderHoldBillEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'order_hold_bill',
|
|
['id'],
|
|
(OrderHoldBillEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'sysType': _sysTypeConverter.encode(item.sysType),
|
|
'carListJson': item.carListJson,
|
|
'userJson': item.userJson,
|
|
'price': item.price,
|
|
'extraPrice': item.extraPrice,
|
|
'payPrice': item.payPrice,
|
|
'createTime': _dateTimeConverter.encode(item.createTime)
|
|
}),
|
|
_orderHoldBillEntityDeletionAdapter = DeletionAdapter(
|
|
database,
|
|
'order_hold_bill',
|
|
['id'],
|
|
(OrderHoldBillEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'sysType': _sysTypeConverter.encode(item.sysType),
|
|
'carListJson': item.carListJson,
|
|
'userJson': item.userJson,
|
|
'price': item.price,
|
|
'extraPrice': item.extraPrice,
|
|
'payPrice': item.payPrice,
|
|
'createTime': _dateTimeConverter.encode(item.createTime)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<OrderHoldBillEntity>
|
|
_orderHoldBillEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<OrderHoldBillEntity> _orderHoldBillEntityUpdateAdapter;
|
|
|
|
final DeletionAdapter<OrderHoldBillEntity>
|
|
_orderHoldBillEntityDeletionAdapter;
|
|
|
|
@override
|
|
Future<List<OrderHoldBillEntity>> list(
|
|
String startTime,
|
|
String endTime,
|
|
int pageSize,
|
|
int offset,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM order_hold_bill WHERE createTime >= ?1 AND createTime <= ?2 ORDER BY createTime DESC LIMIT ?3 OFFSET ?4',
|
|
mapper: (Map<String, Object?> row) => OrderHoldBillEntity(id: row['id'] as int?, sysType: _sysTypeConverter.decode(row['sysType'] as String), carListJson: row['carListJson'] as String?, userJson: row['userJson'] as String?, price: row['price'] as int, extraPrice: row['extraPrice'] as int, payPrice: row['payPrice'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String)),
|
|
arguments: [startTime, endTime, pageSize, offset]);
|
|
}
|
|
|
|
@override
|
|
Future<int?> count(
|
|
String startTime,
|
|
String endTime,
|
|
) async {
|
|
return _queryAdapter.query(
|
|
'SELECT COUNT(*) FROM order_hold_bill WHERE createTime >= ?1 AND createTime <= ?2',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int,
|
|
arguments: [startTime, endTime]);
|
|
}
|
|
|
|
@override
|
|
Future<int?> deleteOlderThan7Days() async {
|
|
return _queryAdapter.query(
|
|
'DELETE FROM order_hold_bill WHERE createTime < datetime(\'now\', \'-7 days\')',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int);
|
|
}
|
|
|
|
@override
|
|
Future<int> save(OrderHoldBillEntity entity) {
|
|
return _orderHoldBillEntityInsertionAdapter.insertAndReturnId(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(OrderHoldBillEntity entity) async {
|
|
await _orderHoldBillEntityUpdateAdapter.update(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> del(OrderHoldBillEntity entity) async {
|
|
await _orderHoldBillEntityDeletionAdapter.delete(entity);
|
|
}
|
|
}
|
|
|
|
class _$CanteenSpuDao extends CanteenSpuDao {
|
|
_$CanteenSpuDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_canteenSpuEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'canteen_spu',
|
|
(CanteenSpuEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'classifyServiceUniqueCode': item.classifyServiceUniqueCode,
|
|
'hourType': item.hourType?.index,
|
|
'saleDate': _dateTimeConverter.encode(item.saleDate),
|
|
'name': item.name,
|
|
'price': item.price,
|
|
'stock': item.stock,
|
|
'image': item.image,
|
|
'isDefault': _boolConverter.encode(item.isDefault),
|
|
'status': item.status,
|
|
'sort': item.sort,
|
|
'isPriceIncreased':
|
|
_boolConverter.encode(item.isPriceIncreased),
|
|
'spuType': item.spuType,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime)
|
|
}),
|
|
_canteenSpuComboItemEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'canteen_spu_combo_item',
|
|
(CanteenSpuComboItemEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'parentServiceUniqueCode': item.parentServiceUniqueCode,
|
|
'saleDate': _dateTimeConverter.encode(item.saleDate),
|
|
'childServiceUniqueCode': item.childServiceUniqueCode,
|
|
'name': item.name,
|
|
'image': item.image,
|
|
'quantity': item.quantity,
|
|
'sort': item.sort,
|
|
'price': item.price
|
|
}),
|
|
_canteenSpuEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'canteen_spu',
|
|
['id'],
|
|
(CanteenSpuEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'classifyServiceUniqueCode': item.classifyServiceUniqueCode,
|
|
'hourType': item.hourType?.index,
|
|
'saleDate': _dateTimeConverter.encode(item.saleDate),
|
|
'name': item.name,
|
|
'price': item.price,
|
|
'stock': item.stock,
|
|
'image': item.image,
|
|
'isDefault': _boolConverter.encode(item.isDefault),
|
|
'status': item.status,
|
|
'sort': item.sort,
|
|
'isPriceIncreased':
|
|
_boolConverter.encode(item.isPriceIncreased),
|
|
'spuType': item.spuType,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime)
|
|
}),
|
|
_canteenSpuEntityDeletionAdapter = DeletionAdapter(
|
|
database,
|
|
'canteen_spu',
|
|
['id'],
|
|
(CanteenSpuEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'classifyServiceUniqueCode': item.classifyServiceUniqueCode,
|
|
'hourType': item.hourType?.index,
|
|
'saleDate': _dateTimeConverter.encode(item.saleDate),
|
|
'name': item.name,
|
|
'price': item.price,
|
|
'stock': item.stock,
|
|
'image': item.image,
|
|
'isDefault': _boolConverter.encode(item.isDefault),
|
|
'status': item.status,
|
|
'sort': item.sort,
|
|
'isPriceIncreased':
|
|
_boolConverter.encode(item.isPriceIncreased),
|
|
'spuType': item.spuType,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<CanteenSpuEntity> _canteenSpuEntityInsertionAdapter;
|
|
|
|
final InsertionAdapter<CanteenSpuComboItemEntity>
|
|
_canteenSpuComboItemEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<CanteenSpuEntity> _canteenSpuEntityUpdateAdapter;
|
|
|
|
final DeletionAdapter<CanteenSpuEntity> _canteenSpuEntityDeletionAdapter;
|
|
|
|
@override
|
|
Future<void> delAllByType() async {
|
|
await _queryAdapter.queryNoReturn('DELETE FROM canteen_spu');
|
|
}
|
|
|
|
@override
|
|
Future<void> delAllByDay(String dayStr) async {
|
|
await _queryAdapter.queryNoReturn(
|
|
'DELETE FROM canteen_spu WHERE strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', ?1)',
|
|
arguments: [dayStr]);
|
|
}
|
|
|
|
@override
|
|
Future<void> delAllComboItems() async {
|
|
await _queryAdapter.queryNoReturn('DELETE FROM canteen_spu_combo_item');
|
|
}
|
|
|
|
@override
|
|
Future<void> delComboItemsByDay(String dayStr) async {
|
|
await _queryAdapter.queryNoReturn(
|
|
'DELETE FROM canteen_spu_combo_item WHERE strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', ?1)',
|
|
arguments: [dayStr]);
|
|
}
|
|
|
|
@override
|
|
Future<List<CanteenSpuComboItemEntity>> getComboItems(
|
|
String parentServiceUniqueCode,
|
|
String saleDate,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM canteen_spu_combo_item WHERE parentServiceUniqueCode = ?1 AND strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', ?2) ORDER BY sort ASC, id ASC',
|
|
mapper: (Map<String, Object?> row) => CanteenSpuComboItemEntity(id: row['id'] as int?, parentServiceUniqueCode: row['parentServiceUniqueCode'] as String, saleDate: _dateTimeConverter.decode(row['saleDate'] as String), childServiceUniqueCode: row['childServiceUniqueCode'] as String, name: row['name'] as String, image: row['image'] as String?, quantity: row['quantity'] as int, sort: row['sort'] as int, price: row['price'] as int),
|
|
arguments: [parentServiceUniqueCode, saleDate]);
|
|
}
|
|
|
|
@override
|
|
Future<void> editDefault(
|
|
bool isDefault,
|
|
String uniqueCode,
|
|
String hourType,
|
|
) async {
|
|
await _queryAdapter.queryNoReturn(
|
|
'UPDATE canteen_spu SET isDefault = ?1 WHERE serviceUniqueCode = ?2 AND hourType = ?3',
|
|
arguments: [_boolConverter.encode(isDefault), uniqueCode, hourType]);
|
|
}
|
|
|
|
@override
|
|
Future<int?> getCount(String hourType) async {
|
|
return _queryAdapter.query(
|
|
'SELECT DISTINCT COUNT(0) FROM canteen_spu WHERE (?1 = \'-1\' OR INSTR(\',\' || hourType || \',\', \',\' || ?1 || \',\') > 0) AND strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', \'now\', \'localtime\')',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int,
|
|
arguments: [hourType]);
|
|
}
|
|
|
|
@override
|
|
Future<CanteenSpuEntity?> getByCode(
|
|
String code,
|
|
String saleDate,
|
|
) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM canteen_spu WHERE serviceUniqueCode = ?1 AND (?2 = \'-1\' OR strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', ?2)) LIMIT 1',
|
|
mapper: (Map<String, Object?> row) => CanteenSpuEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, hourType: row['hourType'] == null ? null : ProductHourType.values[row['hourType'] as int], saleDate: _dateTimeConverter.decode(row['saleDate'] as String), name: row['name'] as String, price: row['price'] as int, stock: row['stock'] as int?, image: row['image'] as String?, isDefault: _boolConverter.decode(row['isDefault'] as int), status: row['status'] as int, sort: row['sort'] as int, isPriceIncreased: _boolConverter.decode(row['isPriceIncreased'] as int), spuType: row['spuType'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String)),
|
|
arguments: [code, saleDate]);
|
|
}
|
|
|
|
@override
|
|
Future<List<CanteenSpuEntity>> getAll(
|
|
String classifyServiceUniqueCode,
|
|
String hourType,
|
|
String saleDate,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT canteen_spu.* FROM canteen_spu LEFT JOIN classify ON canteen_spu.classifyServiceUniqueCode = classify.serviceUniqueCode AND classify.delFlag = 0 WHERE (?1 = \'-1\' OR canteen_spu.classifyServiceUniqueCode = ?1) AND (?2 = \'-1\' OR INSTR(\',\' || hourType || \',\', \',\' || ?2 || \',\') > 0) AND (?3 = \'-1\' OR strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', ?3)) ORDER BY classify.sort,canteen_spu.sort desc,canteen_spu.price',
|
|
mapper: (Map<String, Object?> row) => CanteenSpuEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, hourType: row['hourType'] == null ? null : ProductHourType.values[row['hourType'] as int], saleDate: _dateTimeConverter.decode(row['saleDate'] as String), name: row['name'] as String, price: row['price'] as int, stock: row['stock'] as int?, image: row['image'] as String?, isDefault: _boolConverter.decode(row['isDefault'] as int), status: row['status'] as int, sort: row['sort'] as int, isPriceIncreased: _boolConverter.decode(row['isPriceIncreased'] as int), spuType: row['spuType'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String)),
|
|
arguments: [classifyServiceUniqueCode, hourType, saleDate]);
|
|
}
|
|
|
|
@override
|
|
Future<List<CanteenSpuEntity>> getAllPage(
|
|
String classifyServiceUniqueCode,
|
|
String hourType,
|
|
int pageSize,
|
|
int offset,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT canteen_spu.* FROM canteen_spu LEFT JOIN classify ON canteen_spu.classifyServiceUniqueCode = classify.serviceUniqueCode AND classify.delFlag = 0 WHERE (?1 = \'-1\' OR canteen_spu.classifyServiceUniqueCode = ?1) AND (?2 = \'-1\' OR INSTR(\',\' || canteen_spu.hourType || \',\', \',\' || ?2 || \',\') > 0) AND strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', \'now\', \'localtime\') ORDER BY classify.sort, classify.id, canteen_spu.price LIMIT ?3 OFFSET ?4',
|
|
mapper: (Map<String, Object?> row) => CanteenSpuEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, hourType: row['hourType'] == null ? null : ProductHourType.values[row['hourType'] as int], saleDate: _dateTimeConverter.decode(row['saleDate'] as String), name: row['name'] as String, price: row['price'] as int, stock: row['stock'] as int?, image: row['image'] as String?, isDefault: _boolConverter.decode(row['isDefault'] as int), status: row['status'] as int, sort: row['sort'] as int, isPriceIncreased: _boolConverter.decode(row['isPriceIncreased'] as int), spuType: row['spuType'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String)),
|
|
arguments: [classifyServiceUniqueCode, hourType, pageSize, offset]);
|
|
}
|
|
|
|
@override
|
|
Future<List<CanteenSpuEntity>> getDefault(String hourType) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM canteen_spu WHERE isDefault = 1 AND (?1 = \'-1\' OR hourType = ?1) AND strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', \'now\', \'localtime\')',
|
|
mapper: (Map<String, Object?> row) => CanteenSpuEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, hourType: row['hourType'] == null ? null : ProductHourType.values[row['hourType'] as int], saleDate: _dateTimeConverter.decode(row['saleDate'] as String), name: row['name'] as String, price: row['price'] as int, stock: row['stock'] as int?, image: row['image'] as String?, isDefault: _boolConverter.decode(row['isDefault'] as int), status: row['status'] as int, sort: row['sort'] as int, isPriceIncreased: _boolConverter.decode(row['isPriceIncreased'] as int), spuType: row['spuType'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String)),
|
|
arguments: [hourType]);
|
|
}
|
|
|
|
@override
|
|
Future<void> save(CanteenSpuEntity entity) async {
|
|
await _canteenSpuEntityInsertionAdapter.insert(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<CanteenSpuEntity> entitys) async {
|
|
await _canteenSpuEntityInsertionAdapter.insertList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSaveComboItems(
|
|
List<CanteenSpuComboItemEntity> entities) async {
|
|
await _canteenSpuComboItemEntityInsertionAdapter.insertList(
|
|
entities, OnConflictStrategy.replace);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchEdit(List<CanteenSpuEntity> entitys) async {
|
|
await _canteenSpuEntityUpdateAdapter.updateList(
|
|
entitys, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchDel(List<CanteenSpuEntity> entitys) async {
|
|
await _canteenSpuEntityDeletionAdapter.deleteList(entitys);
|
|
}
|
|
|
|
@override
|
|
Future<void> replaceByDay(
|
|
String dayStr,
|
|
List<CanteenSpuEntity> products,
|
|
List<CanteenSpuComboItemEntity> comboItems,
|
|
) async {
|
|
if (database is sqflite.Transaction) {
|
|
await super.replaceByDay(dayStr, products, comboItems);
|
|
} else {
|
|
await (database as sqflite.Database)
|
|
.transaction<void>((transaction) async {
|
|
final transactionDatabase = _$AppDatabase(changeListener)
|
|
..database = transaction;
|
|
await transactionDatabase.getCanteenSpuDao
|
|
.replaceByDay(dayStr, products, comboItems);
|
|
});
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<void> delAllCanteenData() async {
|
|
if (database is sqflite.Transaction) {
|
|
await super.delAllCanteenData();
|
|
} else {
|
|
await (database as sqflite.Database)
|
|
.transaction<void>((transaction) async {
|
|
final transactionDatabase = _$AppDatabase(changeListener)
|
|
..database = transaction;
|
|
await transactionDatabase.getCanteenSpuDao.delAllCanteenData();
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
class _$SupermarketSkuDao extends SupermarketSkuDao {
|
|
_$SupermarketSkuDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_supermarketSkuEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'supermarket_sku',
|
|
(SupermarketSkuEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'spuId': item.spuId,
|
|
'barCode': item.barCode,
|
|
'spec': item.spec,
|
|
'unit': item.unit,
|
|
'packageNum': item.packageNum,
|
|
'purchasePrice': item.purchasePrice,
|
|
'retailPrice': item.retailPrice,
|
|
'promotionPrice': item.promotionPrice
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<SupermarketSkuEntity>
|
|
_supermarketSkuEntityInsertionAdapter;
|
|
|
|
@override
|
|
Future<void> delAllForce() async {
|
|
await _queryAdapter.queryNoReturn('DELETE FROM supermarket_sku');
|
|
}
|
|
|
|
@override
|
|
Future<int?> getCount(
|
|
String barCode,
|
|
String classifyServiceUniqueCode,
|
|
) async {
|
|
return _queryAdapter.query(
|
|
'SELECT DISTINCT COUNT(0) FROM supermarket_sku INNER JOIN supermarket_spu ON supermarket_sku.spuId = supermarket_spu.serviceUniqueCode AND supermarket_spu.delFlag = 0 WHERE 1 = 1 AND (?1 = \'-1\' OR supermarket_sku.barCode LIKE \'%\' || ?1 || \'%\' OR supermarket_spu.productName LIKE \'%\' || ?1 || \'%\' OR (?1 != \'\' AND supermarket_spu.productNamePy LIKE \'%\' || ?1 || \'%\') ) AND (?2 = \'-1\' OR supermarket_spu.classifyServiceUniqueCode = ?2)',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int,
|
|
arguments: [barCode, classifyServiceUniqueCode]);
|
|
}
|
|
|
|
@override
|
|
Future<List<SupermarketSpuEntity>> getAllPage(
|
|
String barCode,
|
|
String classifyServiceUniqueCode,
|
|
int pageSize,
|
|
int offset,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT supermarket_sku.id, supermarket_sku.serviceUniqueCode, supermarket_sku.spuId, supermarket_spu.productCode, supermarket_spu.classifyServiceUniqueCode, supermarket_spu.productName, supermarket_spu.productNamePy, supermarket_spu.picUrl, supermarket_spu.productNature, supermarket_spu.salesCount, supermarket_spu.stock, supermarket_spu.sort, supermarket_spu.createTime, supermarket_spu.updateTime, supermarket_spu.delFlag, supermarket_sku.barCode, supermarket_sku.promotionPrice, supermarket_sku.purchasePrice, supermarket_sku.retailPrice, supermarket_sku.spec, supermarket_sku.packageNum, supermarket_sku.unit, supermarket_sku.packageNum FROM supermarket_sku INNER JOIN supermarket_spu ON supermarket_sku.spuId = supermarket_spu.serviceUniqueCode AND supermarket_spu.delFlag = 0 WHERE 1 = 1 AND (?1 = \'-1\' OR supermarket_sku.barCode LIKE \'%\' || ?1 || \'%\' OR supermarket_spu.productName LIKE \'%\' || ?1 || \'%\' OR (?1 != \'\' AND supermarket_spu.productNamePy LIKE \'%\' || ?1 || \'%\') ) AND (?2 = \'-1\' OR supermarket_spu.classifyServiceUniqueCode = ?2) ORDER BY supermarket_sku.spuId LIMIT ?3 OFFSET ?4',
|
|
mapper: (Map<String, Object?> row) => SupermarketSpuEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, productCode: row['productCode'] as String, productName: row['productName'] as String, productNature: _supermarketNatureConverter.decode(row['productNature'] as String), barCode: row['barCode'] as String?, packageNum: row['packageNum'] as int, unit: row['unit'] as String, spec: row['spec'] as String, picUrl: row['picUrl'] as String?, stock: row['stock'] as double?, salesCount: row['salesCount'] as double?, purchasePrice: row['purchasePrice'] as int, retailPrice: row['retailPrice'] as int, promotionPrice: row['promotionPrice'] 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: [barCode, classifyServiceUniqueCode, pageSize, offset]);
|
|
}
|
|
|
|
@override
|
|
Future<SupermarketSpuEntity?> getByBarCode(String barCode) async {
|
|
return _queryAdapter.query(
|
|
'SELECT supermarket_sku.id, supermarket_sku.serviceUniqueCode, supermarket_sku.spuId, supermarket_spu.productCode, supermarket_spu.classifyServiceUniqueCode, supermarket_spu.productName, supermarket_spu.picUrl, supermarket_spu.productNature, supermarket_spu.salesCount, supermarket_spu.stock, supermarket_spu.sort, supermarket_spu.createTime, supermarket_spu.updateTime, supermarket_spu.delFlag, supermarket_sku.barCode, supermarket_sku.promotionPrice, supermarket_sku.purchasePrice, supermarket_sku.retailPrice, supermarket_sku.spec, supermarket_sku.packageNum, supermarket_sku.unit, supermarket_sku.packageNum FROM supermarket_sku INNER JOIN supermarket_spu ON supermarket_sku.spuId = supermarket_spu.serviceUniqueCode AND supermarket_spu.delFlag = 0 WHERE 1 = 1 AND (?1 = \'-1\' OR supermarket_sku.barCode = ?1) LIMIT 1',
|
|
mapper: (Map<String, Object?> row) => SupermarketSpuEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, productCode: row['productCode'] as String, productName: row['productName'] as String, productNature: _supermarketNatureConverter.decode(row['productNature'] as String), barCode: row['barCode'] as String?, packageNum: row['packageNum'] as int, unit: row['unit'] as String, spec: row['spec'] as String, picUrl: row['picUrl'] as String?, stock: row['stock'] as double?, salesCount: row['salesCount'] as double?, purchasePrice: row['purchasePrice'] as int, retailPrice: row['retailPrice'] as int, promotionPrice: row['promotionPrice'] 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: [barCode]);
|
|
}
|
|
|
|
@override
|
|
Future<SupermarketSpuEntity?> getBySkuCode(String skuCode) async {
|
|
return _queryAdapter.query(
|
|
'SELECT supermarket_sku.id, supermarket_sku.serviceUniqueCode, supermarket_sku.spuId, supermarket_spu.productCode, supermarket_spu.classifyServiceUniqueCode, supermarket_spu.productName, supermarket_spu.picUrl, supermarket_spu.productNature, supermarket_spu.salesCount, supermarket_spu.stock, supermarket_spu.sort, supermarket_spu.createTime, supermarket_spu.updateTime, supermarket_spu.delFlag, supermarket_sku.barCode, supermarket_sku.promotionPrice, supermarket_sku.purchasePrice, supermarket_sku.retailPrice, supermarket_sku.spec, supermarket_sku.packageNum, supermarket_sku.unit, supermarket_sku.packageNum FROM supermarket_sku INNER JOIN supermarket_spu ON supermarket_sku.spuId = supermarket_spu.serviceUniqueCode AND supermarket_spu.delFlag = 0 WHERE 1 = 1 AND (?1 = \'-1\' OR supermarket_sku.serviceUniqueCode = ?1) LIMIT 1',
|
|
mapper: (Map<String, Object?> row) => SupermarketSpuEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, productCode: row['productCode'] as String, productName: row['productName'] as String, productNature: _supermarketNatureConverter.decode(row['productNature'] as String), barCode: row['barCode'] as String?, packageNum: row['packageNum'] as int, unit: row['unit'] as String, spec: row['spec'] as String, picUrl: row['picUrl'] as String?, stock: row['stock'] as double?, salesCount: row['salesCount'] as double?, purchasePrice: row['purchasePrice'] as int, retailPrice: row['retailPrice'] as int, promotionPrice: row['promotionPrice'] 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: [skuCode]);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<SupermarketSkuEntity> changeList) async {
|
|
await _supermarketSkuEntityInsertionAdapter.insertList(
|
|
changeList, OnConflictStrategy.abort);
|
|
}
|
|
}
|
|
|
|
class _$SupermarketSpuDao extends SupermarketSpuDao {
|
|
_$SupermarketSpuDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_supermarketSpuEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'supermarket_spu',
|
|
(SupermarketSpuEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'classifyServiceUniqueCode': item.classifyServiceUniqueCode,
|
|
'productCode': item.productCode,
|
|
'productName': item.productName,
|
|
'productNamePy': item.productNamePy,
|
|
'productNature':
|
|
_supermarketNatureConverter.encode(item.productNature),
|
|
'barCode': item.barCode,
|
|
'packageNum': item.packageNum,
|
|
'unit': item.unit,
|
|
'spec': item.spec,
|
|
'picUrl': item.picUrl,
|
|
'stock': item.stock,
|
|
'salesCount': item.salesCount,
|
|
'purchasePrice': item.purchasePrice,
|
|
'retailPrice': item.retailPrice,
|
|
'promotionPrice': item.promotionPrice,
|
|
'sort': item.sort,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime),
|
|
'delFlag': _boolConverter.encode(item.delFlag)
|
|
}),
|
|
_supermarketSpuEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'supermarket_spu',
|
|
['id'],
|
|
(SupermarketSpuEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'classifyServiceUniqueCode': item.classifyServiceUniqueCode,
|
|
'productCode': item.productCode,
|
|
'productName': item.productName,
|
|
'productNamePy': item.productNamePy,
|
|
'productNature':
|
|
_supermarketNatureConverter.encode(item.productNature),
|
|
'barCode': item.barCode,
|
|
'packageNum': item.packageNum,
|
|
'unit': item.unit,
|
|
'spec': item.spec,
|
|
'picUrl': item.picUrl,
|
|
'stock': item.stock,
|
|
'salesCount': item.salesCount,
|
|
'purchasePrice': item.purchasePrice,
|
|
'retailPrice': item.retailPrice,
|
|
'promotionPrice': item.promotionPrice,
|
|
'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<SupermarketSpuEntity>
|
|
_supermarketSpuEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<SupermarketSpuEntity> _supermarketSpuEntityUpdateAdapter;
|
|
|
|
@override
|
|
Future<List<SupermarketSpuEntity>> getAll(
|
|
String classifyServiceUniqueCode) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT supermarket_spu.* FROM supermarket_spu LEFT JOIN classify ON supermarket_spu.classifyServiceUniqueCode = classify.serviceUniqueCode AND classify.delFlag = 0 WHERE supermarket_spu.delFlag = 0 AND (?1 = \'-1\' OR supermarket_spu.classifyServiceUniqueCode = ?1) ORDER BY classify.sort',
|
|
mapper: (Map<String, Object?> row) => SupermarketSpuEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, productCode: row['productCode'] as String, productName: row['productName'] as String, productNature: _supermarketNatureConverter.decode(row['productNature'] as String), barCode: row['barCode'] as String?, packageNum: row['packageNum'] as int, unit: row['unit'] as String, spec: row['spec'] as String, picUrl: row['picUrl'] as String?, stock: row['stock'] as double?, salesCount: row['salesCount'] as double?, purchasePrice: row['purchasePrice'] as int, retailPrice: row['retailPrice'] as int, promotionPrice: row['promotionPrice'] 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]);
|
|
}
|
|
|
|
@override
|
|
Future<int?> getCount() async {
|
|
return _queryAdapter.query(
|
|
'SELECT DISTINCT COUNT(0) FROM supermarket_spu WHERE delFlag = 0',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int);
|
|
}
|
|
|
|
@override
|
|
Future<List<SupermarketSpuEntity>> getAllPage(
|
|
String classifyServiceUniqueCode,
|
|
int pageSize,
|
|
int offset,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT supermarket_spu.* FROM supermarket_spu LEFT JOIN classify ON supermarket_spu.classifyServiceUniqueCode = classify.serviceUniqueCode AND classify.delFlag = 0 WHERE supermarket_spu.delFlag = 0 AND (?1 = \'-1\' OR supermarket_spu.classifyServiceUniqueCode = ?1) ORDER BY classify.sort LIMIT ?2 OFFSET ?3',
|
|
mapper: (Map<String, Object?> row) => SupermarketSpuEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, productCode: row['productCode'] as String, productName: row['productName'] as String, productNature: _supermarketNatureConverter.decode(row['productNature'] as String), barCode: row['barCode'] as String?, packageNum: row['packageNum'] as int, unit: row['unit'] as String, spec: row['spec'] as String, picUrl: row['picUrl'] as String?, stock: row['stock'] as double?, salesCount: row['salesCount'] as double?, purchasePrice: row['purchasePrice'] as int, retailPrice: row['retailPrice'] as int, promotionPrice: row['promotionPrice'] 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, pageSize, offset]);
|
|
}
|
|
|
|
@override
|
|
Future<SupermarketSpuEntity?> getByCode(String code) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM supermarket_spu WHERE delFlag = 0 AND serviceUniqueCode = ?1',
|
|
mapper: (Map<String, Object?> row) => SupermarketSpuEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, productCode: row['productCode'] as String, productName: row['productName'] as String, productNature: _supermarketNatureConverter.decode(row['productNature'] as String), barCode: row['barCode'] as String?, packageNum: row['packageNum'] as int, unit: row['unit'] as String, spec: row['spec'] as String, picUrl: row['picUrl'] as String?, stock: row['stock'] as double?, salesCount: row['salesCount'] as double?, purchasePrice: row['purchasePrice'] as int, retailPrice: row['retailPrice'] as int, promotionPrice: row['promotionPrice'] 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<void> delAllForce() async {
|
|
await _queryAdapter.queryNoReturn('DELETE FROM supermarket_spu');
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<SupermarketSpuEntity> changeList) async {
|
|
await _supermarketSpuEntityInsertionAdapter.insertList(
|
|
changeList, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchEdit(List<SupermarketSpuEntity> changeList) async {
|
|
await _supermarketSpuEntityUpdateAdapter.updateList(
|
|
changeList, OnConflictStrategy.abort);
|
|
}
|
|
}
|
|
|
|
class _$SupermarketCodeDao extends SupermarketCodeDao {
|
|
_$SupermarketCodeDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_supermarketCodeEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'supermarket_code',
|
|
(SupermarketCodeEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'serviceUniqueCode': item.serviceUniqueCode,
|
|
'spuId': item.spuId,
|
|
'unitId': item.unitId,
|
|
'barCode': item.barCode
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<SupermarketCodeEntity>
|
|
_supermarketCodeEntityInsertionAdapter;
|
|
|
|
@override
|
|
Future<void> delAllForce() async {
|
|
await _queryAdapter.queryNoReturn('DELETE FROM supermarket_code');
|
|
}
|
|
|
|
@override
|
|
Future<SupermarketSpuEntity?> getByBarCode(String barCode) async {
|
|
return _queryAdapter.query(
|
|
'SELECT supermarket_sku.id, supermarket_sku.serviceUniqueCode, supermarket_sku.spuId, supermarket_spu.productCode, supermarket_spu.classifyServiceUniqueCode, supermarket_spu.productName, supermarket_spu.picUrl, supermarket_spu.productNature, supermarket_spu.salesCount, supermarket_spu.stock, supermarket_spu.sort, supermarket_spu.createTime, supermarket_spu.updateTime, supermarket_spu.delFlag, supermarket_sku.barCode, supermarket_sku.promotionPrice, supermarket_sku.purchasePrice, supermarket_sku.retailPrice, supermarket_sku.spec, supermarket_sku.packageNum, supermarket_sku.unit, supermarket_sku.packageNum FROM supermarket_code INNER JOIN supermarket_spu ON supermarket_code.spuId = supermarket_spu.serviceUniqueCode AND supermarket_spu.delFlag = 0 INNER JOIN supermarket_sku ON supermarket_spu.serviceUniqueCode = supermarket_sku.spuId WHERE 1 = 1 AND (?1 = \'-1\' OR supermarket_code.barCode = ?1) LIMIT 1',
|
|
mapper: (Map<String, Object?> row) => SupermarketSpuEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, classifyServiceUniqueCode: row['classifyServiceUniqueCode'] as String, productCode: row['productCode'] as String, productName: row['productName'] as String, productNature: _supermarketNatureConverter.decode(row['productNature'] as String), barCode: row['barCode'] as String?, packageNum: row['packageNum'] as int, unit: row['unit'] as String, spec: row['spec'] as String, picUrl: row['picUrl'] as String?, stock: row['stock'] as double?, salesCount: row['salesCount'] as double?, purchasePrice: row['purchasePrice'] as int, retailPrice: row['retailPrice'] as int, promotionPrice: row['promotionPrice'] 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: [barCode]);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<SupermarketCodeEntity> changeList) async {
|
|
await _supermarketCodeEntityInsertionAdapter.insertList(
|
|
changeList, OnConflictStrategy.abort);
|
|
}
|
|
}
|
|
|
|
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,
|
|
'nature': _supermarketNatureConverter.encode(item.nature),
|
|
'productNumber': item.productNumber,
|
|
'productWidget': item.productWidget,
|
|
'totalPrice': item.totalPrice,
|
|
'isPriceIncreased':
|
|
_boolConverter.encode(item.isPriceIncreased)
|
|
}),
|
|
_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,
|
|
'nature': _supermarketNatureConverter.encode(item.nature),
|
|
'productNumber': item.productNumber,
|
|
'productWidget': item.productWidget,
|
|
'totalPrice': item.totalPrice,
|
|
'isPriceIncreased':
|
|
_boolConverter.encode(item.isPriceIncreased)
|
|
}),
|
|
_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,
|
|
'nature': _supermarketNatureConverter.encode(item.nature),
|
|
'productNumber': item.productNumber,
|
|
'productWidget': item.productWidget,
|
|
'totalPrice': item.totalPrice,
|
|
'isPriceIncreased':
|
|
_boolConverter.encode(item.isPriceIncreased)
|
|
});
|
|
|
|
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,
|
|
nature: _supermarketNatureConverter.decode(row['nature'] as String),
|
|
productNumber: row['productNumber'] as int,
|
|
productWidget: row['productWidget'] as double,
|
|
totalPrice: row['totalPrice'] as int,
|
|
isPriceIncreased:
|
|
_boolConverter.decode(row['isPriceIncreased'] 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<void> delAllForce() async {
|
|
await _queryAdapter.queryNoReturn('DELETE FROM classify');
|
|
}
|
|
|
|
@override
|
|
Future<int?> delBySysType(String sysType) async {
|
|
return _queryAdapter.query(
|
|
'UPDATE classify SET delFlag = 1 WHERE delFlag = 0 AND (?1 = \'-1\' OR sysType = ?1)',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int,
|
|
arguments: [sysType]);
|
|
}
|
|
|
|
@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,
|
|
'printType': item.printType,
|
|
'printNo': item.printNo,
|
|
'retryVersion': item.retryVersion,
|
|
'attemptCount': item.attemptCount,
|
|
'lastError': item.lastError,
|
|
'resultPending': _boolConverter.encode(item.resultPending),
|
|
'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,
|
|
'printType': item.printType,
|
|
'printNo': item.printNo,
|
|
'retryVersion': item.retryVersion,
|
|
'attemptCount': item.attemptCount,
|
|
'lastError': item.lastError,
|
|
'resultPending': _boolConverter.encode(item.resultPending),
|
|
'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,
|
|
'printType': item.printType,
|
|
'printNo': item.printNo,
|
|
'retryVersion': item.retryVersion,
|
|
'attemptCount': item.attemptCount,
|
|
'lastError': item.lastError,
|
|
'resultPending': _boolConverter.encode(item.resultPending),
|
|
'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, printType: row['printType'] as String, printNo: row['printNo'] as int, retryVersion: row['retryVersion'] as int, attemptCount: row['attemptCount'] as int, lastError: row['lastError'] as String?, resultPending: _boolConverter.decode(row['resultPending'] as int), 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<PrintHistoryEntity?> findByServicePrintId(
|
|
String servicePrintId) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM print_history WHERE servicePrintId = ?1 LIMIT 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,
|
|
printType: row['printType'] as String,
|
|
printNo: row['printNo'] as int,
|
|
retryVersion: row['retryVersion'] as int,
|
|
attemptCount: row['attemptCount'] as int,
|
|
lastError: row['lastError'] as String?,
|
|
resultPending: _boolConverter.decode(row['resultPending'] as int),
|
|
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: [servicePrintId]);
|
|
}
|
|
|
|
@override
|
|
Future<List<PrintHistoryEntity>> getPendingResults() async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM print_history WHERE resultPending = 1 ORDER BY createTime ASC',
|
|
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,
|
|
printType: row['printType'] as String,
|
|
printNo: row['printNo'] as int,
|
|
retryVersion: row['retryVersion'] as int,
|
|
attemptCount: row['attemptCount'] as int,
|
|
lastError: row['lastError'] as String?,
|
|
resultPending: _boolConverter.decode(row['resultPending'] as int),
|
|
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)));
|
|
}
|
|
|
|
@override
|
|
Future<int?> countPending() async {
|
|
return _queryAdapter.query(
|
|
'SELECT COUNT(*) FROM print_history WHERE status = \'NONE\'',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int);
|
|
}
|
|
|
|
@override
|
|
Future<int?> countFailed() async {
|
|
return _queryAdapter.query(
|
|
'SELECT COUNT(*) FROM print_history WHERE status = \'ERROR\'',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int);
|
|
}
|
|
|
|
@override
|
|
Future<PrintHistoryEntity?> findLatestError() async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM print_history WHERE lastError IS NOT NULL AND lastError != \'\' ORDER BY id DESC LIMIT 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,
|
|
printType: row['printType'] as String,
|
|
printNo: row['printNo'] as int,
|
|
retryVersion: row['retryVersion'] as int,
|
|
attemptCount: row['attemptCount'] as int,
|
|
lastError: row['lastError'] as String?,
|
|
resultPending: _boolConverter.decode(row['resultPending'] as int),
|
|
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)));
|
|
}
|
|
|
|
@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,
|
|
'canteenId': item.canteenId,
|
|
'discountsList':
|
|
_listDiscountsConverter.encode(item.discountsList),
|
|
'discountsUpdateTime':
|
|
_dateTimeEmptyConverter.encode(item.discountsUpdateTime),
|
|
'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,
|
|
'canteenId': item.canteenId,
|
|
'discountsList':
|
|
_listDiscountsConverter.encode(item.discountsList),
|
|
'discountsUpdateTime':
|
|
_dateTimeEmptyConverter.encode(item.discountsUpdateTime),
|
|
'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,
|
|
'canteenId': item.canteenId,
|
|
'discountsList':
|
|
_listDiscountsConverter.encode(item.discountsList),
|
|
'discountsUpdateTime':
|
|
_dateTimeEmptyConverter.encode(item.discountsUpdateTime),
|
|
'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?,
|
|
canteenId: row['canteenId'] as String?,
|
|
createTime:
|
|
_dateTimeEmptyConverter.decode(row['createTime'] as String),
|
|
updateTime:
|
|
_dateTimeEmptyConverter.decode(row['updateTime'] as String),
|
|
discountsUpdateTime: _dateTimeEmptyConverter
|
|
.decode(row['discountsUpdateTime'] as String),
|
|
discountsList:
|
|
_listDiscountsConverter.decode(row['discountsList'] 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?,
|
|
canteenId: row['canteenId'] as String?,
|
|
createTime:
|
|
_dateTimeEmptyConverter.decode(row['createTime'] as String),
|
|
updateTime:
|
|
_dateTimeEmptyConverter.decode(row['updateTime'] as String),
|
|
discountsUpdateTime: _dateTimeEmptyConverter
|
|
.decode(row['discountsUpdateTime'] as String),
|
|
discountsList:
|
|
_listDiscountsConverter.decode(row['discountsList'] 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),
|
|
'qualityScore': item.qualityScore,
|
|
'qualityStatus': item.qualityStatus,
|
|
'qualityCheckedAt':
|
|
_dateTimeEmptyConverter.encode(item.qualityCheckedAt),
|
|
'qualityErrorCode': item.qualityErrorCode
|
|
}),
|
|
_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),
|
|
'qualityScore': item.qualityScore,
|
|
'qualityStatus': item.qualityStatus,
|
|
'qualityCheckedAt':
|
|
_dateTimeEmptyConverter.encode(item.qualityCheckedAt),
|
|
'qualityErrorCode': item.qualityErrorCode
|
|
}),
|
|
_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),
|
|
'qualityScore': item.qualityScore,
|
|
'qualityStatus': item.qualityStatus,
|
|
'qualityCheckedAt':
|
|
_dateTimeEmptyConverter.encode(item.qualityCheckedAt),
|
|
'qualityErrorCode': item.qualityErrorCode
|
|
});
|
|
|
|
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<void> delBySampleId(String sampleId) async {
|
|
await _queryAdapter.queryNoReturn('DELETE FROM face WHERE sampleId = ?1',
|
|
arguments: [sampleId]);
|
|
}
|
|
|
|
@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<int?> findLowQualityCount(
|
|
String userName,
|
|
double threshold,
|
|
) async {
|
|
return _queryAdapter.query(
|
|
'SELECT COUNT(0) FROM face WHERE qualityStatus = \'detected\' AND qualityScore IS NOT NULL AND qualityScore < ?2 AND (?1 = \'-1\' OR userName LIKE \'%\' || ?1 || \'%\')',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int,
|
|
arguments: [userName, threshold]);
|
|
}
|
|
|
|
@override
|
|
Future<List<FaceEntity>> findLowQuality(
|
|
String userName,
|
|
double threshold,
|
|
int pageSize,
|
|
int offset,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM face WHERE qualityStatus = \'detected\' AND qualityScore IS NOT NULL AND qualityScore < ?2 AND (?1 = \'-1\' OR userName LIKE \'%\' || ?1 || \'%\') ORDER BY id ASC LIMIT ?3 OFFSET ?4',
|
|
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), qualityScore: row['qualityScore'] as double?, qualityStatus: row['qualityStatus'] as String, qualityCheckedAt: _dateTimeEmptyConverter.decode(row['qualityCheckedAt'] as String), qualityErrorCode: row['qualityErrorCode'] as int?),
|
|
arguments: [userName, threshold, pageSize, offset]);
|
|
}
|
|
|
|
@override
|
|
Future<List<FaceEntity>> findAllLowQuality(double threshold) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM face WHERE qualityStatus = \'detected\' AND qualityScore IS NOT NULL AND qualityScore < ?1 ORDER BY id ASC',
|
|
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), qualityScore: row['qualityScore'] as double?, qualityStatus: row['qualityStatus'] as String, qualityCheckedAt: _dateTimeEmptyConverter.decode(row['qualityCheckedAt'] as String), qualityErrorCode: row['qualityErrorCode'] as int?),
|
|
arguments: [threshold]);
|
|
}
|
|
|
|
@override
|
|
Future<int?> findPendingQualityCount() async {
|
|
return _queryAdapter.query(
|
|
'SELECT COUNT(0) FROM face WHERE qualityStatus = \'pending\'',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int);
|
|
}
|
|
|
|
@override
|
|
Future<int?> findFailedQualityCount() async {
|
|
return _queryAdapter.query(
|
|
'SELECT COUNT(0) FROM face WHERE qualityStatus = \'failed\'',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int);
|
|
}
|
|
|
|
@override
|
|
Future<List<FaceEntity>> findQualityAuditCandidates() async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM face WHERE qualityStatus IN (\'pending\', \'failed\') ORDER BY id ASC',
|
|
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),
|
|
qualityScore: row['qualityScore'] as double?,
|
|
qualityStatus: row['qualityStatus'] as String,
|
|
qualityCheckedAt: _dateTimeEmptyConverter
|
|
.decode(row['qualityCheckedAt'] as String),
|
|
qualityErrorCode: row['qualityErrorCode'] as int?));
|
|
}
|
|
|
|
@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),
|
|
qualityScore: row['qualityScore'] as double?,
|
|
qualityStatus: row['qualityStatus'] as String,
|
|
qualityCheckedAt: _dateTimeEmptyConverter
|
|
.decode(row['qualityCheckedAt'] as String),
|
|
qualityErrorCode: row['qualityErrorCode'] as int?),
|
|
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),
|
|
qualityScore: row['qualityScore'] as double?,
|
|
qualityStatus: row['qualityStatus'] as String,
|
|
qualityCheckedAt: _dateTimeEmptyConverter
|
|
.decode(row['qualityCheckedAt'] as String),
|
|
qualityErrorCode: row['qualityErrorCode'] as int?),
|
|
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),
|
|
qualityScore: row['qualityScore'] as double?,
|
|
qualityStatus: row['qualityStatus'] as String,
|
|
qualityCheckedAt: _dateTimeEmptyConverter
|
|
.decode(row['qualityCheckedAt'] as String),
|
|
qualityErrorCode: row['qualityErrorCode'] as int?),
|
|
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), qualityScore: row['qualityScore'] as double?, qualityStatus: row['qualityStatus'] as String, qualityCheckedAt: _dateTimeEmptyConverter.decode(row['qualityCheckedAt'] as String), qualityErrorCode: row['qualityErrorCode'] as int?),
|
|
arguments: [userName, pageSize, offset]);
|
|
}
|
|
|
|
@override
|
|
Future<List<FaceEntity>> getAll() async {
|
|
return _queryAdapter.queryList('SELECT * FROM face ORDER BY sampleId ASC',
|
|
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),
|
|
qualityScore: row['qualityScore'] as double?,
|
|
qualityStatus: row['qualityStatus'] as String,
|
|
qualityCheckedAt: _dateTimeEmptyConverter
|
|
.decode(row['qualityCheckedAt'] as String),
|
|
qualityErrorCode: row['qualityErrorCode'] as int?));
|
|
}
|
|
|
|
@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<List<FaceEntity>?> getEmptyFaceList() async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM face WHERE faceModel = \'\' OR faceModel IS NULL',
|
|
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),
|
|
qualityScore: row['qualityScore'] as double?,
|
|
qualityStatus: row['qualityStatus'] as String,
|
|
qualityCheckedAt: _dateTimeEmptyConverter
|
|
.decode(row['qualityCheckedAt'] as String),
|
|
qualityErrorCode: row['qualityErrorCode'] as int?));
|
|
}
|
|
|
|
@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);
|
|
}
|
|
}
|
|
|
|
class _$ScheduledTaskDao extends ScheduledTaskDao {
|
|
_$ScheduledTaskDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_scheduledTaskEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'scheduled_task',
|
|
(ScheduledTaskEntity item) => <String, Object?>{
|
|
'taskCode': item.taskCode,
|
|
'enabled': _boolConverter.encode(item.enabled),
|
|
'cronExpression': item.cronExpression,
|
|
'idleOnly': _boolConverter.encode(item.idleOnly),
|
|
'lastRunAt': _dateTimeEmptyConverter.encode(item.lastRunAt),
|
|
'lastSuccessAt':
|
|
_dateTimeEmptyConverter.encode(item.lastSuccessAt),
|
|
'lastStatus': item.lastStatus,
|
|
'lastMessage': item.lastMessage,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime)
|
|
}),
|
|
_scheduledTaskEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'scheduled_task',
|
|
['taskCode'],
|
|
(ScheduledTaskEntity item) => <String, Object?>{
|
|
'taskCode': item.taskCode,
|
|
'enabled': _boolConverter.encode(item.enabled),
|
|
'cronExpression': item.cronExpression,
|
|
'idleOnly': _boolConverter.encode(item.idleOnly),
|
|
'lastRunAt': _dateTimeEmptyConverter.encode(item.lastRunAt),
|
|
'lastSuccessAt':
|
|
_dateTimeEmptyConverter.encode(item.lastSuccessAt),
|
|
'lastStatus': item.lastStatus,
|
|
'lastMessage': item.lastMessage,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<ScheduledTaskEntity>
|
|
_scheduledTaskEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<ScheduledTaskEntity> _scheduledTaskEntityUpdateAdapter;
|
|
|
|
@override
|
|
Future<List<ScheduledTaskEntity>> getAll() async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM scheduled_task ORDER BY taskCode',
|
|
mapper: (Map<String, Object?> row) => ScheduledTaskEntity(
|
|
taskCode: row['taskCode'] as String,
|
|
enabled: _boolConverter.decode(row['enabled'] as int),
|
|
cronExpression: row['cronExpression'] as String,
|
|
idleOnly: _boolConverter.decode(row['idleOnly'] as int),
|
|
lastRunAt:
|
|
_dateTimeEmptyConverter.decode(row['lastRunAt'] as String),
|
|
lastSuccessAt:
|
|
_dateTimeEmptyConverter.decode(row['lastSuccessAt'] as String),
|
|
lastStatus: row['lastStatus'] as String,
|
|
lastMessage: row['lastMessage'] as String,
|
|
createTime: _dateTimeConverter.decode(row['createTime'] as String),
|
|
updateTime:
|
|
_dateTimeConverter.decode(row['updateTime'] as String)));
|
|
}
|
|
|
|
@override
|
|
Future<ScheduledTaskEntity?> getByCode(String taskCode) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM scheduled_task WHERE taskCode = ?1 LIMIT 1',
|
|
mapper: (Map<String, Object?> row) => ScheduledTaskEntity(
|
|
taskCode: row['taskCode'] as String,
|
|
enabled: _boolConverter.decode(row['enabled'] as int),
|
|
cronExpression: row['cronExpression'] as String,
|
|
idleOnly: _boolConverter.decode(row['idleOnly'] as int),
|
|
lastRunAt:
|
|
_dateTimeEmptyConverter.decode(row['lastRunAt'] as String),
|
|
lastSuccessAt:
|
|
_dateTimeEmptyConverter.decode(row['lastSuccessAt'] as String),
|
|
lastStatus: row['lastStatus'] as String,
|
|
lastMessage: row['lastMessage'] as String,
|
|
createTime: _dateTimeConverter.decode(row['createTime'] as String),
|
|
updateTime: _dateTimeConverter.decode(row['updateTime'] as String)),
|
|
arguments: [taskCode]);
|
|
}
|
|
|
|
@override
|
|
Future<void> save(ScheduledTaskEntity entity) async {
|
|
await _scheduledTaskEntityInsertionAdapter.insert(
|
|
entity, OnConflictStrategy.replace);
|
|
}
|
|
|
|
@override
|
|
Future<void> batchSave(List<ScheduledTaskEntity> entities) async {
|
|
await _scheduledTaskEntityInsertionAdapter.insertList(
|
|
entities, OnConflictStrategy.replace);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(ScheduledTaskEntity entity) async {
|
|
await _scheduledTaskEntityUpdateAdapter.update(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
}
|
|
|
|
class _$ScheduledTaskLogDao extends ScheduledTaskLogDao {
|
|
_$ScheduledTaskLogDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_scheduledTaskLogEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'scheduled_task_log',
|
|
(ScheduledTaskLogEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'taskCode': item.taskCode,
|
|
'taskName': item.taskName,
|
|
'triggerType': item.triggerType,
|
|
'sourceType': item.sourceType,
|
|
'sourceName': item.sourceName,
|
|
'status': item.status,
|
|
'message': item.message,
|
|
'errorType': item.errorType,
|
|
'errorMessage': item.errorMessage,
|
|
'errorStack': item.errorStack,
|
|
'startedAt': _dateTimeConverter.encode(item.startedAt),
|
|
'finishedAt': _dateTimeEmptyConverter.encode(item.finishedAt),
|
|
'durationMs': item.durationMs,
|
|
'scannedCount': item.scannedCount,
|
|
'skippedCount': item.skippedCount,
|
|
'successCount': item.successCount,
|
|
'failureCount': item.failureCount
|
|
}),
|
|
_scheduledTaskLogEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'scheduled_task_log',
|
|
['id'],
|
|
(ScheduledTaskLogEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'taskCode': item.taskCode,
|
|
'taskName': item.taskName,
|
|
'triggerType': item.triggerType,
|
|
'sourceType': item.sourceType,
|
|
'sourceName': item.sourceName,
|
|
'status': item.status,
|
|
'message': item.message,
|
|
'errorType': item.errorType,
|
|
'errorMessage': item.errorMessage,
|
|
'errorStack': item.errorStack,
|
|
'startedAt': _dateTimeConverter.encode(item.startedAt),
|
|
'finishedAt': _dateTimeEmptyConverter.encode(item.finishedAt),
|
|
'durationMs': item.durationMs,
|
|
'scannedCount': item.scannedCount,
|
|
'skippedCount': item.skippedCount,
|
|
'successCount': item.successCount,
|
|
'failureCount': item.failureCount
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<ScheduledTaskLogEntity>
|
|
_scheduledTaskLogEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<ScheduledTaskLogEntity>
|
|
_scheduledTaskLogEntityUpdateAdapter;
|
|
|
|
@override
|
|
Future<List<ScheduledTaskLogEntity>> getByTask(
|
|
String taskCode,
|
|
String sourceType,
|
|
int limit,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM scheduled_task_log WHERE taskCode = ?1 AND (?2 = \'\' OR sourceType = ?2) ORDER BY id DESC LIMIT ?3',
|
|
mapper: (Map<String, Object?> row) => ScheduledTaskLogEntity(id: row['id'] as int?, taskCode: row['taskCode'] as String, taskName: row['taskName'] as String, triggerType: row['triggerType'] as String, sourceType: row['sourceType'] as String, sourceName: row['sourceName'] as String, status: row['status'] as String, message: row['message'] as String, errorType: row['errorType'] as String?, errorMessage: row['errorMessage'] as String?, errorStack: row['errorStack'] as String?, startedAt: _dateTimeConverter.decode(row['startedAt'] as String), finishedAt: _dateTimeEmptyConverter.decode(row['finishedAt'] as String), durationMs: row['durationMs'] as int, scannedCount: row['scannedCount'] as int?, skippedCount: row['skippedCount'] as int?, successCount: row['successCount'] as int?, failureCount: row['failureCount'] as int?),
|
|
arguments: [taskCode, sourceType, limit]);
|
|
}
|
|
|
|
@override
|
|
Future<List<ScheduledTaskLogEntity>> getPageByTask(
|
|
String taskCode,
|
|
String sourceType,
|
|
int pageSize,
|
|
int offset,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM scheduled_task_log WHERE taskCode = ?1 AND (?2 = \'\' OR sourceType = ?2) ORDER BY id DESC LIMIT ?3 OFFSET ?4',
|
|
mapper: (Map<String, Object?> row) => ScheduledTaskLogEntity(id: row['id'] as int?, taskCode: row['taskCode'] as String, taskName: row['taskName'] as String, triggerType: row['triggerType'] as String, sourceType: row['sourceType'] as String, sourceName: row['sourceName'] as String, status: row['status'] as String, message: row['message'] as String, errorType: row['errorType'] as String?, errorMessage: row['errorMessage'] as String?, errorStack: row['errorStack'] as String?, startedAt: _dateTimeConverter.decode(row['startedAt'] as String), finishedAt: _dateTimeEmptyConverter.decode(row['finishedAt'] as String), durationMs: row['durationMs'] as int, scannedCount: row['scannedCount'] as int?, skippedCount: row['skippedCount'] as int?, successCount: row['successCount'] as int?, failureCount: row['failureCount'] as int?),
|
|
arguments: [taskCode, sourceType, pageSize, offset]);
|
|
}
|
|
|
|
@override
|
|
Future<int?> countByTask(
|
|
String taskCode,
|
|
String sourceType,
|
|
) async {
|
|
return _queryAdapter.query(
|
|
'SELECT COUNT(0) FROM scheduled_task_log WHERE taskCode = ?1 AND (?2 = \'\' OR sourceType = ?2)',
|
|
mapper: (Map<String, Object?> row) => row.values.first as int,
|
|
arguments: [taskCode, sourceType]);
|
|
}
|
|
|
|
@override
|
|
Future<ScheduledTaskLogEntity?> getLatest(String taskCode) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM scheduled_task_log WHERE taskCode = ?1 ORDER BY id DESC LIMIT 1',
|
|
mapper: (Map<String, Object?> row) => ScheduledTaskLogEntity(id: row['id'] as int?, taskCode: row['taskCode'] as String, taskName: row['taskName'] as String, triggerType: row['triggerType'] as String, sourceType: row['sourceType'] as String, sourceName: row['sourceName'] as String, status: row['status'] as String, message: row['message'] as String, errorType: row['errorType'] as String?, errorMessage: row['errorMessage'] as String?, errorStack: row['errorStack'] as String?, startedAt: _dateTimeConverter.decode(row['startedAt'] as String), finishedAt: _dateTimeEmptyConverter.decode(row['finishedAt'] as String), durationMs: row['durationMs'] as int, scannedCount: row['scannedCount'] as int?, skippedCount: row['skippedCount'] as int?, successCount: row['successCount'] as int?, failureCount: row['failureCount'] as int?),
|
|
arguments: [taskCode]);
|
|
}
|
|
|
|
@override
|
|
Future<void> trimHistory() async {
|
|
await _queryAdapter.queryNoReturn(
|
|
'DELETE FROM scheduled_task_log WHERE id NOT IN ( SELECT id FROM scheduled_task_log ORDER BY id DESC LIMIT 2000 )');
|
|
}
|
|
|
|
@override
|
|
Future<int> save(ScheduledTaskLogEntity entity) {
|
|
return _scheduledTaskLogEntityInsertionAdapter.insertAndReturnId(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(ScheduledTaskLogEntity entity) async {
|
|
await _scheduledTaskLogEntityUpdateAdapter.update(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
}
|
|
|
|
class _$FileUploadRecordDao extends FileUploadRecordDao {
|
|
_$FileUploadRecordDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_fileUploadRecordEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'file_upload_record',
|
|
(FileUploadRecordEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'hardId': item.hardId,
|
|
'bizType': item.bizType,
|
|
'relativePath': item.relativePath,
|
|
'originalName': item.originalName,
|
|
'sourceSize': item.sourceSize,
|
|
'sourceModifiedTime':
|
|
_dateTimeConverter.encode(item.sourceModifiedTime),
|
|
'sanitizedHash': item.sanitizedHash,
|
|
'sanitizedSize': item.sanitizedSize,
|
|
'status': item.status,
|
|
'serverFileId': item.serverFileId,
|
|
'attemptCount': item.attemptCount,
|
|
'lastAttemptAt':
|
|
_dateTimeEmptyConverter.encode(item.lastAttemptAt),
|
|
'uploadedAt': _dateTimeEmptyConverter.encode(item.uploadedAt),
|
|
'lastError': item.lastError,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime)
|
|
}),
|
|
_fileUploadRecordEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'file_upload_record',
|
|
['id'],
|
|
(FileUploadRecordEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'hardId': item.hardId,
|
|
'bizType': item.bizType,
|
|
'relativePath': item.relativePath,
|
|
'originalName': item.originalName,
|
|
'sourceSize': item.sourceSize,
|
|
'sourceModifiedTime':
|
|
_dateTimeConverter.encode(item.sourceModifiedTime),
|
|
'sanitizedHash': item.sanitizedHash,
|
|
'sanitizedSize': item.sanitizedSize,
|
|
'status': item.status,
|
|
'serverFileId': item.serverFileId,
|
|
'attemptCount': item.attemptCount,
|
|
'lastAttemptAt':
|
|
_dateTimeEmptyConverter.encode(item.lastAttemptAt),
|
|
'uploadedAt': _dateTimeEmptyConverter.encode(item.uploadedAt),
|
|
'lastError': item.lastError,
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<FileUploadRecordEntity>
|
|
_fileUploadRecordEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<FileUploadRecordEntity>
|
|
_fileUploadRecordEntityUpdateAdapter;
|
|
|
|
@override
|
|
Future<List<FileUploadRecordEntity>> getAll(
|
|
String hardId,
|
|
String bizType,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM file_upload_record WHERE hardId = ?1 AND bizType = ?2 ORDER BY updateTime DESC',
|
|
mapper: (Map<String, Object?> row) => FileUploadRecordEntity(id: row['id'] as int?, hardId: row['hardId'] as String, bizType: row['bizType'] as String, relativePath: row['relativePath'] as String, originalName: row['originalName'] as String, sourceSize: row['sourceSize'] as int, sourceModifiedTime: _dateTimeConverter.decode(row['sourceModifiedTime'] as String), sanitizedHash: row['sanitizedHash'] as String, sanitizedSize: row['sanitizedSize'] as int, status: row['status'] as String, serverFileId: row['serverFileId'] as String?, attemptCount: row['attemptCount'] as int, lastAttemptAt: _dateTimeEmptyConverter.decode(row['lastAttemptAt'] as String), uploadedAt: _dateTimeEmptyConverter.decode(row['uploadedAt'] as String), lastError: row['lastError'] as String?, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String)),
|
|
arguments: [hardId, bizType]);
|
|
}
|
|
|
|
@override
|
|
Future<FileUploadRecordEntity?> getByPath(
|
|
String hardId,
|
|
String bizType,
|
|
String relativePath,
|
|
) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM file_upload_record WHERE hardId = ?1 AND bizType = ?2 AND relativePath = ?3 LIMIT 1',
|
|
mapper: (Map<String, Object?> row) => FileUploadRecordEntity(id: row['id'] as int?, hardId: row['hardId'] as String, bizType: row['bizType'] as String, relativePath: row['relativePath'] as String, originalName: row['originalName'] as String, sourceSize: row['sourceSize'] as int, sourceModifiedTime: _dateTimeConverter.decode(row['sourceModifiedTime'] as String), sanitizedHash: row['sanitizedHash'] as String, sanitizedSize: row['sanitizedSize'] as int, status: row['status'] as String, serverFileId: row['serverFileId'] as String?, attemptCount: row['attemptCount'] as int, lastAttemptAt: _dateTimeEmptyConverter.decode(row['lastAttemptAt'] as String), uploadedAt: _dateTimeEmptyConverter.decode(row['uploadedAt'] as String), lastError: row['lastError'] as String?, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String)),
|
|
arguments: [hardId, bizType, relativePath]);
|
|
}
|
|
|
|
@override
|
|
Future<int> save(FileUploadRecordEntity entity) {
|
|
return _fileUploadRecordEntityInsertionAdapter.insertAndReturnId(
|
|
entity, OnConflictStrategy.replace);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(FileUploadRecordEntity entity) async {
|
|
await _fileUploadRecordEntityUpdateAdapter.update(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
}
|
|
|
|
class _$OrderEvidenceUploadTaskDao extends OrderEvidenceUploadTaskDao {
|
|
_$OrderEvidenceUploadTaskDao(
|
|
this.database,
|
|
this.changeListener,
|
|
) : _queryAdapter = QueryAdapter(database),
|
|
_orderEvidenceUploadTaskEntityInsertionAdapter = InsertionAdapter(
|
|
database,
|
|
'order_evidence_upload_task',
|
|
(OrderEvidenceUploadTaskEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'androidOrderCode': item.androidOrderCode,
|
|
'serverOrderId': item.serverOrderId,
|
|
'recognitionSessionId': item.recognitionSessionId,
|
|
'evidenceType': item.evidenceType,
|
|
'evidenceRole': item.evidenceRole,
|
|
'sequenceNo': item.sequenceNo,
|
|
'userId': item.userId,
|
|
'faceSampleId': item.faceSampleId,
|
|
'referenceImageUrl': item.referenceImageUrl,
|
|
'referenceImageVersion': item.referenceImageVersion,
|
|
'localFilePath': item.localFilePath,
|
|
'imageHash': item.imageHash,
|
|
'imageSize': item.imageSize,
|
|
'imageWidth': item.imageWidth,
|
|
'imageHeight': item.imageHeight,
|
|
'similarity': item.similarity,
|
|
'similarityThreshold': item.similarityThreshold,
|
|
'capturedAt': _dateTimeConverter.encode(item.capturedAt),
|
|
'appVersion': item.appVersion,
|
|
'status': item.status,
|
|
'attemptCount': item.attemptCount,
|
|
'nextRetryAt':
|
|
_dateTimeEmptyConverter.encode(item.nextRetryAt),
|
|
'serverEvidenceId': item.serverEvidenceId,
|
|
'serverImageUrl': item.serverImageUrl,
|
|
'lastError': item.lastError,
|
|
'unavailableReportedAt': _dateTimeEmptyConverter
|
|
.encode(item.unavailableReportedAt),
|
|
'completedAt':
|
|
_dateTimeEmptyConverter.encode(item.completedAt),
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime),
|
|
'expiresAt': _dateTimeConverter.encode(item.expiresAt)
|
|
}),
|
|
_orderEvidenceUploadTaskEntityUpdateAdapter = UpdateAdapter(
|
|
database,
|
|
'order_evidence_upload_task',
|
|
['id'],
|
|
(OrderEvidenceUploadTaskEntity item) => <String, Object?>{
|
|
'id': item.id,
|
|
'androidOrderCode': item.androidOrderCode,
|
|
'serverOrderId': item.serverOrderId,
|
|
'recognitionSessionId': item.recognitionSessionId,
|
|
'evidenceType': item.evidenceType,
|
|
'evidenceRole': item.evidenceRole,
|
|
'sequenceNo': item.sequenceNo,
|
|
'userId': item.userId,
|
|
'faceSampleId': item.faceSampleId,
|
|
'referenceImageUrl': item.referenceImageUrl,
|
|
'referenceImageVersion': item.referenceImageVersion,
|
|
'localFilePath': item.localFilePath,
|
|
'imageHash': item.imageHash,
|
|
'imageSize': item.imageSize,
|
|
'imageWidth': item.imageWidth,
|
|
'imageHeight': item.imageHeight,
|
|
'similarity': item.similarity,
|
|
'similarityThreshold': item.similarityThreshold,
|
|
'capturedAt': _dateTimeConverter.encode(item.capturedAt),
|
|
'appVersion': item.appVersion,
|
|
'status': item.status,
|
|
'attemptCount': item.attemptCount,
|
|
'nextRetryAt':
|
|
_dateTimeEmptyConverter.encode(item.nextRetryAt),
|
|
'serverEvidenceId': item.serverEvidenceId,
|
|
'serverImageUrl': item.serverImageUrl,
|
|
'lastError': item.lastError,
|
|
'unavailableReportedAt': _dateTimeEmptyConverter
|
|
.encode(item.unavailableReportedAt),
|
|
'completedAt':
|
|
_dateTimeEmptyConverter.encode(item.completedAt),
|
|
'createTime': _dateTimeConverter.encode(item.createTime),
|
|
'updateTime': _dateTimeConverter.encode(item.updateTime),
|
|
'expiresAt': _dateTimeConverter.encode(item.expiresAt)
|
|
});
|
|
|
|
final sqflite.DatabaseExecutor database;
|
|
|
|
final StreamController<String> changeListener;
|
|
|
|
final QueryAdapter _queryAdapter;
|
|
|
|
final InsertionAdapter<OrderEvidenceUploadTaskEntity>
|
|
_orderEvidenceUploadTaskEntityInsertionAdapter;
|
|
|
|
final UpdateAdapter<OrderEvidenceUploadTaskEntity>
|
|
_orderEvidenceUploadTaskEntityUpdateAdapter;
|
|
|
|
@override
|
|
Future<OrderEvidenceUploadTaskEntity?> getByPosition(
|
|
String androidOrderCode,
|
|
String evidenceType,
|
|
String evidenceRole,
|
|
int sequenceNo,
|
|
) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM order_evidence_upload_task WHERE androidOrderCode = ?1 AND evidenceType = ?2 AND evidenceRole = ?3 AND sequenceNo = ?4 LIMIT 1',
|
|
mapper: (Map<String, Object?> row) => OrderEvidenceUploadTaskEntity(id: row['id'] as int?, androidOrderCode: row['androidOrderCode'] as String?, serverOrderId: row['serverOrderId'] as String?, recognitionSessionId: row['recognitionSessionId'] as String, evidenceType: row['evidenceType'] as String, evidenceRole: row['evidenceRole'] as String, sequenceNo: row['sequenceNo'] as int, userId: row['userId'] as String, faceSampleId: row['faceSampleId'] as String?, referenceImageUrl: row['referenceImageUrl'] as String?, referenceImageVersion: row['referenceImageVersion'] as String?, localFilePath: row['localFilePath'] as String?, imageHash: row['imageHash'] as String?, imageSize: row['imageSize'] as int?, imageWidth: row['imageWidth'] as int?, imageHeight: row['imageHeight'] as int?, similarity: row['similarity'] as double?, similarityThreshold: row['similarityThreshold'] as double?, capturedAt: _dateTimeConverter.decode(row['capturedAt'] as String), appVersion: row['appVersion'] as String, status: row['status'] as String, attemptCount: row['attemptCount'] as int, nextRetryAt: _dateTimeEmptyConverter.decode(row['nextRetryAt'] as String), serverEvidenceId: row['serverEvidenceId'] as String?, serverImageUrl: row['serverImageUrl'] as String?, lastError: row['lastError'] as String?, unavailableReportedAt: _dateTimeEmptyConverter.decode(row['unavailableReportedAt'] as String), completedAt: _dateTimeEmptyConverter.decode(row['completedAt'] as String), createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), expiresAt: _dateTimeConverter.decode(row['expiresAt'] as String)),
|
|
arguments: [androidOrderCode, evidenceType, evidenceRole, sequenceNo]);
|
|
}
|
|
|
|
@override
|
|
Future<OrderEvidenceUploadTaskEntity?> getByServerOrderPosition(
|
|
String serverOrderId,
|
|
String evidenceType,
|
|
String evidenceRole,
|
|
int sequenceNo,
|
|
) async {
|
|
return _queryAdapter.query(
|
|
'SELECT * FROM order_evidence_upload_task WHERE serverOrderId = ?1 AND evidenceType = ?2 AND evidenceRole = ?3 AND sequenceNo = ?4 LIMIT 1',
|
|
mapper: (Map<String, Object?> row) => OrderEvidenceUploadTaskEntity(id: row['id'] as int?, androidOrderCode: row['androidOrderCode'] as String?, serverOrderId: row['serverOrderId'] as String?, recognitionSessionId: row['recognitionSessionId'] as String, evidenceType: row['evidenceType'] as String, evidenceRole: row['evidenceRole'] as String, sequenceNo: row['sequenceNo'] as int, userId: row['userId'] as String, faceSampleId: row['faceSampleId'] as String?, referenceImageUrl: row['referenceImageUrl'] as String?, referenceImageVersion: row['referenceImageVersion'] as String?, localFilePath: row['localFilePath'] as String?, imageHash: row['imageHash'] as String?, imageSize: row['imageSize'] as int?, imageWidth: row['imageWidth'] as int?, imageHeight: row['imageHeight'] as int?, similarity: row['similarity'] as double?, similarityThreshold: row['similarityThreshold'] as double?, capturedAt: _dateTimeConverter.decode(row['capturedAt'] as String), appVersion: row['appVersion'] as String, status: row['status'] as String, attemptCount: row['attemptCount'] as int, nextRetryAt: _dateTimeEmptyConverter.decode(row['nextRetryAt'] as String), serverEvidenceId: row['serverEvidenceId'] as String?, serverImageUrl: row['serverImageUrl'] as String?, lastError: row['lastError'] as String?, unavailableReportedAt: _dateTimeEmptyConverter.decode(row['unavailableReportedAt'] as String), completedAt: _dateTimeEmptyConverter.decode(row['completedAt'] as String), createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), expiresAt: _dateTimeConverter.decode(row['expiresAt'] as String)),
|
|
arguments: [serverOrderId, evidenceType, evidenceRole, sequenceNo]);
|
|
}
|
|
|
|
@override
|
|
Future<List<OrderEvidenceUploadTaskEntity>> getByOrderCode(
|
|
String androidOrderCode) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM order_evidence_upload_task WHERE androidOrderCode = ?1 ORDER BY evidenceType, evidenceRole, sequenceNo',
|
|
mapper: (Map<String, Object?> row) => OrderEvidenceUploadTaskEntity(id: row['id'] as int?, androidOrderCode: row['androidOrderCode'] as String?, serverOrderId: row['serverOrderId'] as String?, recognitionSessionId: row['recognitionSessionId'] as String, evidenceType: row['evidenceType'] as String, evidenceRole: row['evidenceRole'] as String, sequenceNo: row['sequenceNo'] as int, userId: row['userId'] as String, faceSampleId: row['faceSampleId'] as String?, referenceImageUrl: row['referenceImageUrl'] as String?, referenceImageVersion: row['referenceImageVersion'] as String?, localFilePath: row['localFilePath'] as String?, imageHash: row['imageHash'] as String?, imageSize: row['imageSize'] as int?, imageWidth: row['imageWidth'] as int?, imageHeight: row['imageHeight'] as int?, similarity: row['similarity'] as double?, similarityThreshold: row['similarityThreshold'] as double?, capturedAt: _dateTimeConverter.decode(row['capturedAt'] as String), appVersion: row['appVersion'] as String, status: row['status'] as String, attemptCount: row['attemptCount'] as int, nextRetryAt: _dateTimeEmptyConverter.decode(row['nextRetryAt'] as String), serverEvidenceId: row['serverEvidenceId'] as String?, serverImageUrl: row['serverImageUrl'] as String?, lastError: row['lastError'] as String?, unavailableReportedAt: _dateTimeEmptyConverter.decode(row['unavailableReportedAt'] as String), completedAt: _dateTimeEmptyConverter.decode(row['completedAt'] as String), createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), expiresAt: _dateTimeConverter.decode(row['expiresAt'] as String)),
|
|
arguments: [androidOrderCode]);
|
|
}
|
|
|
|
@override
|
|
Future<List<OrderEvidenceUploadTaskEntity>> getByRecognitionSession(
|
|
String recognitionSessionId) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM order_evidence_upload_task WHERE recognitionSessionId = ?1 ORDER BY evidenceRole, sequenceNo',
|
|
mapper: (Map<String, Object?> row) => OrderEvidenceUploadTaskEntity(id: row['id'] as int?, androidOrderCode: row['androidOrderCode'] as String?, serverOrderId: row['serverOrderId'] as String?, recognitionSessionId: row['recognitionSessionId'] as String, evidenceType: row['evidenceType'] as String, evidenceRole: row['evidenceRole'] as String, sequenceNo: row['sequenceNo'] as int, userId: row['userId'] as String, faceSampleId: row['faceSampleId'] as String?, referenceImageUrl: row['referenceImageUrl'] as String?, referenceImageVersion: row['referenceImageVersion'] as String?, localFilePath: row['localFilePath'] as String?, imageHash: row['imageHash'] as String?, imageSize: row['imageSize'] as int?, imageWidth: row['imageWidth'] as int?, imageHeight: row['imageHeight'] as int?, similarity: row['similarity'] as double?, similarityThreshold: row['similarityThreshold'] as double?, capturedAt: _dateTimeConverter.decode(row['capturedAt'] as String), appVersion: row['appVersion'] as String, status: row['status'] as String, attemptCount: row['attemptCount'] as int, nextRetryAt: _dateTimeEmptyConverter.decode(row['nextRetryAt'] as String), serverEvidenceId: row['serverEvidenceId'] as String?, serverImageUrl: row['serverImageUrl'] as String?, lastError: row['lastError'] as String?, unavailableReportedAt: _dateTimeEmptyConverter.decode(row['unavailableReportedAt'] as String), completedAt: _dateTimeEmptyConverter.decode(row['completedAt'] as String), createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), expiresAt: _dateTimeConverter.decode(row['expiresAt'] as String)),
|
|
arguments: [recognitionSessionId]);
|
|
}
|
|
|
|
@override
|
|
Future<List<OrderEvidenceUploadTaskEntity>> getDueTasks(
|
|
DateTime now,
|
|
int limit,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM order_evidence_upload_task WHERE status IN (\'WAITING_ORDER\', \'READY\', \'UPLOADING\', \'RETRY_WAIT\') AND (androidOrderCode IS NOT NULL OR serverOrderId IS NOT NULL) AND (nextRetryAt IS NULL OR nextRetryAt <= ?1) ORDER BY createTime ASC, id ASC LIMIT ?2',
|
|
mapper: (Map<String, Object?> row) => OrderEvidenceUploadTaskEntity(id: row['id'] as int?, androidOrderCode: row['androidOrderCode'] as String?, serverOrderId: row['serverOrderId'] as String?, recognitionSessionId: row['recognitionSessionId'] as String, evidenceType: row['evidenceType'] as String, evidenceRole: row['evidenceRole'] as String, sequenceNo: row['sequenceNo'] as int, userId: row['userId'] as String, faceSampleId: row['faceSampleId'] as String?, referenceImageUrl: row['referenceImageUrl'] as String?, referenceImageVersion: row['referenceImageVersion'] as String?, localFilePath: row['localFilePath'] as String?, imageHash: row['imageHash'] as String?, imageSize: row['imageSize'] as int?, imageWidth: row['imageWidth'] as int?, imageHeight: row['imageHeight'] as int?, similarity: row['similarity'] as double?, similarityThreshold: row['similarityThreshold'] as double?, capturedAt: _dateTimeConverter.decode(row['capturedAt'] as String), appVersion: row['appVersion'] as String, status: row['status'] as String, attemptCount: row['attemptCount'] as int, nextRetryAt: _dateTimeEmptyConverter.decode(row['nextRetryAt'] as String), serverEvidenceId: row['serverEvidenceId'] as String?, serverImageUrl: row['serverImageUrl'] as String?, lastError: row['lastError'] as String?, unavailableReportedAt: _dateTimeEmptyConverter.decode(row['unavailableReportedAt'] as String), completedAt: _dateTimeEmptyConverter.decode(row['completedAt'] as String), createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), expiresAt: _dateTimeConverter.decode(row['expiresAt'] as String)),
|
|
arguments: [_dateTimeConverter.encode(now), limit]);
|
|
}
|
|
|
|
@override
|
|
Future<List<OrderEvidenceUploadTaskEntity>> getUnavailableReportTasks(
|
|
DateTime now,
|
|
int limit,
|
|
) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM order_evidence_upload_task WHERE status IN (\'PERMANENT_FAILED\', \'EXPIRED\') AND (androidOrderCode IS NOT NULL OR serverOrderId IS NOT NULL) AND unavailableReportedAt IS NULL AND (nextRetryAt IS NULL OR nextRetryAt <= ?1) ORDER BY updateTime ASC, id ASC LIMIT ?2',
|
|
mapper: (Map<String, Object?> row) => OrderEvidenceUploadTaskEntity(id: row['id'] as int?, androidOrderCode: row['androidOrderCode'] as String?, serverOrderId: row['serverOrderId'] as String?, recognitionSessionId: row['recognitionSessionId'] as String, evidenceType: row['evidenceType'] as String, evidenceRole: row['evidenceRole'] as String, sequenceNo: row['sequenceNo'] as int, userId: row['userId'] as String, faceSampleId: row['faceSampleId'] as String?, referenceImageUrl: row['referenceImageUrl'] as String?, referenceImageVersion: row['referenceImageVersion'] as String?, localFilePath: row['localFilePath'] as String?, imageHash: row['imageHash'] as String?, imageSize: row['imageSize'] as int?, imageWidth: row['imageWidth'] as int?, imageHeight: row['imageHeight'] as int?, similarity: row['similarity'] as double?, similarityThreshold: row['similarityThreshold'] as double?, capturedAt: _dateTimeConverter.decode(row['capturedAt'] as String), appVersion: row['appVersion'] as String, status: row['status'] as String, attemptCount: row['attemptCount'] as int, nextRetryAt: _dateTimeEmptyConverter.decode(row['nextRetryAt'] as String), serverEvidenceId: row['serverEvidenceId'] as String?, serverImageUrl: row['serverImageUrl'] as String?, lastError: row['lastError'] as String?, unavailableReportedAt: _dateTimeEmptyConverter.decode(row['unavailableReportedAt'] as String), completedAt: _dateTimeEmptyConverter.decode(row['completedAt'] as String), createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), expiresAt: _dateTimeConverter.decode(row['expiresAt'] as String)),
|
|
arguments: [_dateTimeConverter.encode(now), limit]);
|
|
}
|
|
|
|
@override
|
|
Future<List<OrderEvidenceUploadTaskEntity>> getExpiredWaitingTasks(
|
|
DateTime now) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM order_evidence_upload_task WHERE status = \'WAITING_ORDER\' AND expiresAt <= ?1 ORDER BY expiresAt ASC',
|
|
mapper: (Map<String, Object?> row) => OrderEvidenceUploadTaskEntity(id: row['id'] as int?, androidOrderCode: row['androidOrderCode'] as String?, serverOrderId: row['serverOrderId'] as String?, recognitionSessionId: row['recognitionSessionId'] as String, evidenceType: row['evidenceType'] as String, evidenceRole: row['evidenceRole'] as String, sequenceNo: row['sequenceNo'] as int, userId: row['userId'] as String, faceSampleId: row['faceSampleId'] as String?, referenceImageUrl: row['referenceImageUrl'] as String?, referenceImageVersion: row['referenceImageVersion'] as String?, localFilePath: row['localFilePath'] as String?, imageHash: row['imageHash'] as String?, imageSize: row['imageSize'] as int?, imageWidth: row['imageWidth'] as int?, imageHeight: row['imageHeight'] as int?, similarity: row['similarity'] as double?, similarityThreshold: row['similarityThreshold'] as double?, capturedAt: _dateTimeConverter.decode(row['capturedAt'] as String), appVersion: row['appVersion'] as String, status: row['status'] as String, attemptCount: row['attemptCount'] as int, nextRetryAt: _dateTimeEmptyConverter.decode(row['nextRetryAt'] as String), serverEvidenceId: row['serverEvidenceId'] as String?, serverImageUrl: row['serverImageUrl'] as String?, lastError: row['lastError'] as String?, unavailableReportedAt: _dateTimeEmptyConverter.decode(row['unavailableReportedAt'] as String), completedAt: _dateTimeEmptyConverter.decode(row['completedAt'] as String), createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), expiresAt: _dateTimeConverter.decode(row['expiresAt'] as String)),
|
|
arguments: [_dateTimeConverter.encode(now)]);
|
|
}
|
|
|
|
@override
|
|
Future<List<OrderEvidenceUploadTaskEntity>> getExpiredImageTasks(
|
|
DateTime now) async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM order_evidence_upload_task WHERE localFilePath IS NOT NULL AND status NOT IN (\'SUCCESS\', \'CANCELLED\') AND expiresAt <= ?1 ORDER BY expiresAt ASC',
|
|
mapper: (Map<String, Object?> row) => OrderEvidenceUploadTaskEntity(id: row['id'] as int?, androidOrderCode: row['androidOrderCode'] as String?, serverOrderId: row['serverOrderId'] as String?, recognitionSessionId: row['recognitionSessionId'] as String, evidenceType: row['evidenceType'] as String, evidenceRole: row['evidenceRole'] as String, sequenceNo: row['sequenceNo'] as int, userId: row['userId'] as String, faceSampleId: row['faceSampleId'] as String?, referenceImageUrl: row['referenceImageUrl'] as String?, referenceImageVersion: row['referenceImageVersion'] as String?, localFilePath: row['localFilePath'] as String?, imageHash: row['imageHash'] as String?, imageSize: row['imageSize'] as int?, imageWidth: row['imageWidth'] as int?, imageHeight: row['imageHeight'] as int?, similarity: row['similarity'] as double?, similarityThreshold: row['similarityThreshold'] as double?, capturedAt: _dateTimeConverter.decode(row['capturedAt'] as String), appVersion: row['appVersion'] as String, status: row['status'] as String, attemptCount: row['attemptCount'] as int, nextRetryAt: _dateTimeEmptyConverter.decode(row['nextRetryAt'] as String), serverEvidenceId: row['serverEvidenceId'] as String?, serverImageUrl: row['serverImageUrl'] as String?, lastError: row['lastError'] as String?, unavailableReportedAt: _dateTimeEmptyConverter.decode(row['unavailableReportedAt'] as String), completedAt: _dateTimeEmptyConverter.decode(row['completedAt'] as String), createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), expiresAt: _dateTimeConverter.decode(row['expiresAt'] as String)),
|
|
arguments: [_dateTimeConverter.encode(now)]);
|
|
}
|
|
|
|
@override
|
|
Future<void> deleteSuccessfulBefore(DateTime before) async {
|
|
await _queryAdapter.queryNoReturn(
|
|
'DELETE FROM order_evidence_upload_task WHERE status = \'SUCCESS\' AND completedAt IS NOT NULL AND completedAt < ?1',
|
|
arguments: [_dateTimeConverter.encode(before)]);
|
|
}
|
|
|
|
@override
|
|
Future<List<OrderEvidenceUploadTaskEntity>> getAll() async {
|
|
return _queryAdapter.queryList(
|
|
'SELECT * FROM order_evidence_upload_task ORDER BY id ASC',
|
|
mapper: (Map<String, Object?> row) => OrderEvidenceUploadTaskEntity(
|
|
id: row['id'] as int?,
|
|
androidOrderCode: row['androidOrderCode'] as String?,
|
|
serverOrderId: row['serverOrderId'] as String?,
|
|
recognitionSessionId: row['recognitionSessionId'] as String,
|
|
evidenceType: row['evidenceType'] as String,
|
|
evidenceRole: row['evidenceRole'] as String,
|
|
sequenceNo: row['sequenceNo'] as int,
|
|
userId: row['userId'] as String,
|
|
faceSampleId: row['faceSampleId'] as String?,
|
|
referenceImageUrl: row['referenceImageUrl'] as String?,
|
|
referenceImageVersion: row['referenceImageVersion'] as String?,
|
|
localFilePath: row['localFilePath'] as String?,
|
|
imageHash: row['imageHash'] as String?,
|
|
imageSize: row['imageSize'] as int?,
|
|
imageWidth: row['imageWidth'] as int?,
|
|
imageHeight: row['imageHeight'] as int?,
|
|
similarity: row['similarity'] as double?,
|
|
similarityThreshold: row['similarityThreshold'] as double?,
|
|
capturedAt: _dateTimeConverter.decode(row['capturedAt'] as String),
|
|
appVersion: row['appVersion'] as String,
|
|
status: row['status'] as String,
|
|
attemptCount: row['attemptCount'] as int,
|
|
nextRetryAt:
|
|
_dateTimeEmptyConverter.decode(row['nextRetryAt'] as String),
|
|
serverEvidenceId: row['serverEvidenceId'] as String?,
|
|
serverImageUrl: row['serverImageUrl'] as String?,
|
|
lastError: row['lastError'] as String?,
|
|
unavailableReportedAt: _dateTimeEmptyConverter
|
|
.decode(row['unavailableReportedAt'] as String),
|
|
completedAt:
|
|
_dateTimeEmptyConverter.decode(row['completedAt'] as String),
|
|
createTime: _dateTimeConverter.decode(row['createTime'] as String),
|
|
updateTime: _dateTimeConverter.decode(row['updateTime'] as String),
|
|
expiresAt: _dateTimeConverter.decode(row['expiresAt'] as String)));
|
|
}
|
|
|
|
@override
|
|
Future<int> save(OrderEvidenceUploadTaskEntity entity) {
|
|
return _orderEvidenceUploadTaskEntityInsertionAdapter.insertAndReturnId(
|
|
entity, OnConflictStrategy.replace);
|
|
}
|
|
|
|
@override
|
|
Future<void> edit(OrderEvidenceUploadTaskEntity entity) async {
|
|
await _orderEvidenceUploadTaskEntityUpdateAdapter.update(
|
|
entity, OnConflictStrategy.abort);
|
|
}
|
|
}
|
|
|
|
// 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 _productHourTypeConverter = ProductHourTypeConverter();
|
|
final _supermarketNatureConverter = SupermarketNatureConverter();
|
|
final _discountsTypeConverter = DiscountsTypeConverter();
|
|
final _listDiscountsConverter = ListDiscountsConverter();
|
|
final _listIntConverter = ListIntConverter();
|
|
final _boolConverter = BoolConverter();
|