// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'database.dart';

// **************************************************************************
// FloorGenerator
// **************************************************************************

abstract class $AppDatabaseBuilderContract {
  /// Adds migrations to the builder.
  $AppDatabaseBuilderContract addMigrations(List<Migration> migrations);

  /// Adds a database [Callback] to the builder.
  $AppDatabaseBuilderContract addCallback(Callback callback);

  /// Creates the database and initializes it.
  Future<AppDatabase> build();
}

// ignore: avoid_classes_with_only_static_members
class $FloorAppDatabase {
  /// Creates a database builder for a persistent database.
  /// Once a database is built, you should keep a reference to it and re-use it.
  static $AppDatabaseBuilderContract databaseBuilder(String name) =>
      _$AppDatabaseBuilder(name);

  /// Creates a database builder for an in memory database.
  /// Information stored in an in memory database disappears when the process is killed.
  /// Once a database is built, you should keep a reference to it and re-use it.
  static $AppDatabaseBuilderContract inMemoryDatabaseBuilder() =>
      _$AppDatabaseBuilder(null);
}

class _$AppDatabaseBuilder implements $AppDatabaseBuilderContract {
  _$AppDatabaseBuilder(this.name);

  final String? name;

  final List<Migration> _migrations = [];

  Callback? _callback;

  @override
  $AppDatabaseBuilderContract addMigrations(List<Migration> migrations) {
    _migrations.addAll(migrations);
    return this;
  }

  @override
  $AppDatabaseBuilderContract addCallback(Callback callback) {
    _callback = callback;
    return this;
  }

  @override
  Future<AppDatabase> build() async {
    final path = name != null
        ? await sqfliteDatabaseFactory.getDatabasePath(name!)
        : ':memory:';
    final database = _$AppDatabase();
    database.database = await database.open(
      path,
      _migrations,
      _callback,
    );
    return database;
  }
}

class _$AppDatabase extends AppDatabase {
  _$AppDatabase([StreamController<String>? listener]) {
    changeListener = listener ?? StreamController<String>.broadcast();
  }

  OrderDao? _getOrderDaoInstance;

  CanteenSpuDao? _getCanteenSpuDaoInstance;

  SupermarketSkuDao? _getSupermarketSkuDaoInstance;

  SupermarketSpuDao? _getSupermarketSpuDaoInstance;

  SupermarketCodeDao? _getSupermarketCodeDaoInstance;

  ShopCardDao? _getShopCardDaoInstance;

  ClassifyDao? _getClassifyDaoInstance;

  PrintHistoryDao? _getPrintHistoryDaoInstance;

  UserDao? _getUserDaoInstance;

  FaceDao? _getFaceDaoInstance;

  SettingDao? _getSettingDaoInstance;

  Future<sqflite.Database> open(
    String path,
    List<Migration> migrations, [
    Callback? callback,
  ]) async {
    final databaseOptions = sqflite.OpenDatabaseOptions(
      version: 1,
      onConfigure: (database) async {
        await database.execute('PRAGMA foreign_keys = ON');
        await callback?.onConfigure?.call(database);
      },
      onOpen: (database) async {
        await callback?.onOpen?.call(database);
      },
      onUpgrade: (database, startVersion, endVersion) async {
        await MigrationAdapter.runMigrations(
            database, startVersion, endVersion, migrations);

        await callback?.onUpgrade?.call(database, startVersion, endVersion);
      },
      onCreate: (database, version) async {
        await database.execute(
            'CREATE TABLE IF NOT EXISTS `order_record` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `uniqueCode` TEXT NOT NULL, `serviceUniqueCode` TEXT NOT NULL, `sysType` TEXT NOT NULL, `userCode` TEXT NOT NULL, `username` TEXT, `hourType` TEXT, `price` INTEGER NOT NULL, `extraPrice` INTEGER NOT NULL, `payPrice` INTEGER NOT NULL, `walletId` TEXT, `orderSourceTypeId` TEXT, `type` TEXT NOT NULL, `status` TEXT NOT NULL, `payType` TEXT NOT NULL, `productDesc` TEXT, `count` INTEGER NOT NULL, `weight` REAL NOT NULL, `payTime` TEXT, `createTime` TEXT NOT NULL)');
        await database.execute(
            'CREATE TABLE IF NOT EXISTS `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, `image` TEXT, `isDefault` INTEGER NOT NULL, `status` INTEGER NOT NULL, `sort` INTEGER NOT NULL, `createTime` TEXT NOT NULL, `updateTime` TEXT NOT NULL, `delFlag` INTEGER NOT NULL)');
        await database.execute(
            'CREATE TABLE IF NOT EXISTS `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, `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)');
        await database.execute(
            'CREATE TABLE IF NOT EXISTS `classify` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `serviceUniqueCode` TEXT NOT NULL, `sysType` TEXT NOT NULL, `name` TEXT NOT NULL, `categoryType` TEXT NOT NULL, `sort` INTEGER NOT NULL, `createTime` TEXT NOT NULL, `updateTime` TEXT NOT NULL, `delFlag` INTEGER NOT NULL)');
        await database.execute(
            'CREATE TABLE IF NOT EXISTS `print_history` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `orderId` TEXT NOT NULL, `serviceOrderId` TEXT NOT NULL, `servicePrintId` TEXT NOT NULL, `invoiceUrl` TEXT NOT NULL, `status` TEXT NOT NULL, `printTime` TEXT, `syncTime` TEXT, `createTime` TEXT NOT NULL)');
        await database.execute(
            'CREATE TABLE IF NOT EXISTS `user_record` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `userId` TEXT NOT NULL, `nickname` TEXT NOT NULL, `mobile` TEXT, `avatar` TEXT, `walletCardNumber` TEXT, `walletId` TEXT, `walletTypeId` TEXT, `walletBalance` INTEGER, `createTime` TEXT, `updateTime` TEXT)');
        await database.execute(
            'CREATE TABLE IF NOT EXISTS `face` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `userId` TEXT NOT NULL, `sampleId` TEXT NOT NULL, `userName` TEXT NOT NULL, `deptId` TEXT, `deptName` TEXT, `imagePath` TEXT NOT NULL, `path` TEXT, `faceModel` TEXT, `createTime` TEXT, `updateTime` TEXT)');
        await database.execute(
            'CREATE TABLE IF NOT EXISTS `setting` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `userJson` TEXT NOT NULL, `sysJson` TEXT NOT NULL, `canteenExtraPriceConfigJson` TEXT)');

        await callback?.onCreate?.call(database, version);
      },
    );
    return sqfliteDatabaseFactory.openDatabase(path, options: databaseOptions);
  }

  @override
  OrderDao get getOrderDao {
    return _getOrderDaoInstance ??= _$OrderDao(database, changeListener);
  }

  @override
  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);
  }
}

class _$OrderDao extends OrderDao {
  _$OrderDao(
    this.database,
    this.changeListener,
  )   : _queryAdapter = QueryAdapter(database),
        _orderEntityInsertionAdapter = InsertionAdapter(
            database,
            'order_record',
            (OrderEntity item) => <String, Object?>{
                  'id': item.id,
                  'uniqueCode': item.uniqueCode,
                  'serviceUniqueCode': item.serviceUniqueCode,
                  'sysType': _sysTypeConverter.encode(item.sysType),
                  'userCode': item.userCode,
                  'username': item.username,
                  'hourType': item.hourType,
                  'price': item.price,
                  'extraPrice': item.extraPrice,
                  'payPrice': item.payPrice,
                  'walletId': item.walletId,
                  'orderSourceTypeId': item.orderSourceTypeId,
                  'type': _orderTypeConverter.encode(item.type),
                  'status': _orderStatusConverter.encode(item.status),
                  'payType': _orderPayTypeConverter.encode(item.payType),
                  'productDesc': item.productDesc,
                  'count': item.count,
                  'weight': item.weight,
                  'payTime': _dateTimeEmptyConverter.encode(item.payTime),
                  'createTime': _dateTimeConverter.encode(item.createTime)
                }),
        _orderEntityUpdateAdapter = UpdateAdapter(
            database,
            'order_record',
            ['id'],
            (OrderEntity item) => <String, Object?>{
                  'id': item.id,
                  'uniqueCode': item.uniqueCode,
                  'serviceUniqueCode': item.serviceUniqueCode,
                  'sysType': _sysTypeConverter.encode(item.sysType),
                  'userCode': item.userCode,
                  'username': item.username,
                  'hourType': item.hourType,
                  'price': item.price,
                  'extraPrice': item.extraPrice,
                  'payPrice': item.payPrice,
                  'walletId': item.walletId,
                  'orderSourceTypeId': item.orderSourceTypeId,
                  'type': _orderTypeConverter.encode(item.type),
                  'status': _orderStatusConverter.encode(item.status),
                  'payType': _orderPayTypeConverter.encode(item.payType),
                  'productDesc': item.productDesc,
                  'count': item.count,
                  'weight': item.weight,
                  'payTime': _dateTimeEmptyConverter.encode(item.payTime),
                  'createTime': _dateTimeConverter.encode(item.createTime)
                }),
        _orderEntityDeletionAdapter = DeletionAdapter(
            database,
            'order_record',
            ['id'],
            (OrderEntity item) => <String, Object?>{
                  'id': item.id,
                  'uniqueCode': item.uniqueCode,
                  'serviceUniqueCode': item.serviceUniqueCode,
                  'sysType': _sysTypeConverter.encode(item.sysType),
                  'userCode': item.userCode,
                  'username': item.username,
                  'hourType': item.hourType,
                  'price': item.price,
                  'extraPrice': item.extraPrice,
                  'payPrice': item.payPrice,
                  'walletId': item.walletId,
                  'orderSourceTypeId': item.orderSourceTypeId,
                  'type': _orderTypeConverter.encode(item.type),
                  'status': _orderStatusConverter.encode(item.status),
                  'payType': _orderPayTypeConverter.encode(item.payType),
                  'productDesc': item.productDesc,
                  'count': item.count,
                  'weight': item.weight,
                  'payTime': _dateTimeEmptyConverter.encode(item.payTime),
                  'createTime': _dateTimeConverter.encode(item.createTime)
                });

  final sqflite.DatabaseExecutor database;

  final StreamController<String> changeListener;

  final QueryAdapter _queryAdapter;

  final InsertionAdapter<OrderEntity> _orderEntityInsertionAdapter;

  final UpdateAdapter<OrderEntity> _orderEntityUpdateAdapter;

  final DeletionAdapter<OrderEntity> _orderEntityDeletionAdapter;

  @override
  Future<void> editOfflineStatus(String codes) async {
    await _queryAdapter.queryNoReturn(
        'UPDATE order_record SET status = \'PAY\' WHERE uniqueCode IN ?1',
        arguments: [codes]);
  }

  @override
  Future<List<OrderEntity>> findAll(
    String status,
    DateTime startCreateOrderTime,
    DateTime endCreateOrderTime,
    int pageSize,
    int offset,
    String sysType,
    String hourType,
  ) async {
    return _queryAdapter.queryList(
        'SELECT * FROM order_record      WHERE         (?1 == \"-1\" OR status = ?1) AND        (?6 = \'-1\' OR sysType = ?6) AND        (?7 = \'-1\' OR hourType = ?7) AND        strftime(\'%Y-%m-%d\', createTime) >= strftime(\'%Y-%m-%d\', ?2) AND strftime(\'%Y-%m-%d\', createTime) <= strftime(\'%Y-%m-%d\', ?3)        ORDER BY createTime DESC        LIMIT ?4 OFFSET ?5',
        mapper: (Map<String, Object?> row) => OrderEntity(
            id: row['id'] as int?,
            uniqueCode: row['uniqueCode'] as String,
            serviceUniqueCode: row['serviceUniqueCode'] as String,
            sysType: _sysTypeConverter.decode(row['sysType'] as String),
            userCode: row['userCode'] as String,
            username: row['username'] as String?,
            hourType: row['hourType'] as String?,
            price: row['price'] as int,
            extraPrice: row['extraPrice'] as int,
            payPrice: row['payPrice'] as int,
            walletId: row['walletId'] as String?,
            orderSourceTypeId: row['orderSourceTypeId'] as String?,
            type: _orderTypeConverter.decode(row['type'] as String),
            status: _orderStatusConverter.decode(row['status'] as String),
            payType: _orderPayTypeConverter.decode(row['payType'] as String),
            productDesc: row['productDesc'] as String?,
            count: row['count'] as int,
            weight: row['weight'] as double,
            payTime: _dateTimeEmptyConverter.decode(row['payTime'] as String),
            createTime: _dateTimeConverter.decode(row['createTime'] as String)),
        arguments: [
          status,
          _dateTimeConverter.encode(startCreateOrderTime),
          _dateTimeConverter.encode(endCreateOrderTime),
          pageSize,
          offset,
          sysType,
          hourType
        ]);
  }

  @override
  Future<int?> count(
    String status,
    DateTime startCreateOrderTime,
    DateTime endCreateOrderTime,
    String sysType,
    String hourType,
  ) async {
    return _queryAdapter.query(
        'SELECT COUNT(0) FROM order_record      WHERE         (?1 == \"-1\" OR status = ?1) AND        (?4 = \'-1\' OR sysType = ?4) AND        (?5 = \'-1\' OR hourType = ?5) AND        strftime(\'%Y-%m-%d\', createTime) >= strftime(\'%Y-%m-%d\', ?2) AND strftime(\'%Y-%m-%d\', createTime) <= strftime(\'%Y-%m-%d\', ?3)',
        mapper: (Map<String, Object?> row) => row.values.first as int,
        arguments: [
          status,
          _dateTimeConverter.encode(startCreateOrderTime),
          _dateTimeConverter.encode(endCreateOrderTime),
          sysType,
          hourType
        ]);
  }

  @override
  Future<List<OrderEntity>> findOffline(
    String sysType,
    DateTime startCreateOrderTime,
    DateTime endCreateOrderTime,
  ) async {
    return _queryAdapter.queryList(
        'SELECT * FROM order_record      WHERE         status = \'OFFLINE_PAY\' AND        (?1 = \'-1\' OR sysType = ?1) AND        createTime >= ?2 AND createTime <= ?3',
        mapper: (Map<String, Object?> row) => OrderEntity(
            id: row['id'] as int?,
            uniqueCode: row['uniqueCode'] as String,
            serviceUniqueCode: row['serviceUniqueCode'] as String,
            sysType: _sysTypeConverter.decode(row['sysType'] as String),
            userCode: row['userCode'] as String,
            username: row['username'] as String?,
            hourType: row['hourType'] as String?,
            price: row['price'] as int,
            extraPrice: row['extraPrice'] as int,
            payPrice: row['payPrice'] as int,
            walletId: row['walletId'] as String?,
            orderSourceTypeId: row['orderSourceTypeId'] as String?,
            type: _orderTypeConverter.decode(row['type'] as String),
            status: _orderStatusConverter.decode(row['status'] as String),
            payType: _orderPayTypeConverter.decode(row['payType'] as String),
            productDesc: row['productDesc'] as String?,
            count: row['count'] as int,
            weight: row['weight'] as double,
            payTime: _dateTimeEmptyConverter.decode(row['payTime'] as String),
            createTime: _dateTimeConverter.decode(row['createTime'] as String)),
        arguments: [
          sysType,
          _dateTimeConverter.encode(startCreateOrderTime),
          _dateTimeConverter.encode(endCreateOrderTime)
        ]);
  }

  @override
  Future<OrderEntity?> findById(int id) async {
    return _queryAdapter.query(
        'SELECT * FROM order_record      WHERE       id = ?1',
        mapper: (Map<String, Object?> row) => OrderEntity(
            id: row['id'] as int?,
            uniqueCode: row['uniqueCode'] as String,
            serviceUniqueCode: row['serviceUniqueCode'] as String,
            sysType: _sysTypeConverter.decode(row['sysType'] as String),
            userCode: row['userCode'] as String,
            username: row['username'] as String?,
            hourType: row['hourType'] as String?,
            price: row['price'] as int,
            extraPrice: row['extraPrice'] as int,
            payPrice: row['payPrice'] as int,
            walletId: row['walletId'] as String?,
            orderSourceTypeId: row['orderSourceTypeId'] as String?,
            type: _orderTypeConverter.decode(row['type'] as String),
            status: _orderStatusConverter.decode(row['status'] as String),
            payType: _orderPayTypeConverter.decode(row['payType'] as String),
            productDesc: row['productDesc'] as String?,
            count: row['count'] as int,
            weight: row['weight'] as double,
            payTime: _dateTimeEmptyConverter.decode(row['payTime'] as String),
            createTime: _dateTimeConverter.decode(row['createTime'] as String)),
        arguments: [id]);
  }

  @override
  Future<int> save(OrderEntity entity) {
    return _orderEntityInsertionAdapter.insertAndReturnId(
        entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> batchSave(List<OrderEntity> entitys) async {
    await _orderEntityInsertionAdapter.insertList(
        entitys, OnConflictStrategy.abort);
  }

  @override
  Future<void> edit(OrderEntity entity) async {
    await _orderEntityUpdateAdapter.update(entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> batchEdit(List<OrderEntity> entitys) async {
    await _orderEntityUpdateAdapter.updateList(
        entitys, OnConflictStrategy.abort);
  }

  @override
  Future<void> del(OrderEntity entity) async {
    await _orderEntityDeletionAdapter.delete(entity);
  }

  @override
  Future<void> batchDel(List<OrderEntity> entitys) async {
    await _orderEntityDeletionAdapter.deleteList(entitys);
  }
}

class _$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,
                  'image': item.image,
                  'isDefault': _boolConverter.encode(item.isDefault),
                  'status': item.status,
                  'sort': item.sort,
                  'createTime': _dateTimeConverter.encode(item.createTime),
                  'updateTime': _dateTimeConverter.encode(item.updateTime),
                  'delFlag': _boolConverter.encode(item.delFlag)
                }),
        _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,
                  'image': item.image,
                  'isDefault': _boolConverter.encode(item.isDefault),
                  'status': item.status,
                  'sort': item.sort,
                  'createTime': _dateTimeConverter.encode(item.createTime),
                  'updateTime': _dateTimeConverter.encode(item.updateTime),
                  'delFlag': _boolConverter.encode(item.delFlag)
                }),
        _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,
                  'image': item.image,
                  'isDefault': _boolConverter.encode(item.isDefault),
                  'status': item.status,
                  'sort': item.sort,
                  'createTime': _dateTimeConverter.encode(item.createTime),
                  'updateTime': _dateTimeConverter.encode(item.updateTime),
                  'delFlag': _boolConverter.encode(item.delFlag)
                });

  final sqflite.DatabaseExecutor database;

  final StreamController<String> changeListener;

  final QueryAdapter _queryAdapter;

  final InsertionAdapter<CanteenSpuEntity> _canteenSpuEntityInsertionAdapter;

  final UpdateAdapter<CanteenSpuEntity> _canteenSpuEntityUpdateAdapter;

  final DeletionAdapter<CanteenSpuEntity> _canteenSpuEntityDeletionAdapter;

  @override
  Future<void> delAllByType() async {
    await _queryAdapter.queryNoReturn('DELETE FROM canteen_spu');
  }

  @override
  Future<void> edit(
    bool isDefault,
    String uniqueCode,
    String hourType,
  ) async {
    await _queryAdapter.queryNoReturn(
        'UPDATE canteen_spu SET isDefault = ?1    WHERE   delFlag = 0    AND serviceUniqueCode = ?2 AND hourType = ?3   AND strftime(\'%Y-%m-%d\', saleDate) = strftime(\'%Y-%m-%d\', \'now\', \'localtime\')',
        arguments: [_boolConverter.encode(isDefault), uniqueCode, hourType]);
  }

  @override
  Future<int?> getCount(String hourType) async {
    return _queryAdapter.query(
        'SELECT DISTINCT COUNT(0) FROM canteen_spu        WHERE       delFlag = 0       AND (?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    delFlag = 0   AND 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, image: row['image'] as String?, isDefault: _boolConverter.decode(row['isDefault'] as int), status: row['status'] as int, sort: row['sort'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), delFlag: _boolConverter.decode(row['delFlag'] as int)),
        arguments: [code, saleDate]);
  }

  @override
  Future<List<CanteenSpuEntity>> getAll(
    String classifyServiceUniqueCode,
    String hourType,
  ) async {
    return _queryAdapter.queryList(
        'SELECT canteen_spu.*     FROM canteen_spu     LEFT JOIN classify ON canteen_spu.classifyServiceUniqueCode = classify.serviceUniqueCode     WHERE          canteen_spu.delFlag = 0         AND (?1 = \'-1\' OR canteen_spu.classifyServiceUniqueCode = ?1)           AND (?2 = \'-1\' OR INSTR(\',\' || hourType || \',\', \',\' || ?2 || \',\') > 0)      ORDER BY classify.sort, 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, image: row['image'] as String?, isDefault: _boolConverter.decode(row['isDefault'] as int), status: row['status'] as int, sort: row['sort'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), delFlag: _boolConverter.decode(row['delFlag'] as int)),
        arguments: [classifyServiceUniqueCode, hourType]);
  }

  @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     WHERE          canteen_spu.delFlag = 0         AND (?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, image: row['image'] as String?, isDefault: _boolConverter.decode(row['isDefault'] as int), status: row['status'] as int, sort: row['sort'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), delFlag: _boolConverter.decode(row['delFlag'] as int)),
        arguments: [classifyServiceUniqueCode, hourType, pageSize, offset]);
  }

  @override
  Future<List<CanteenSpuEntity>> getDefault(String hourType) async {
    return _queryAdapter.queryList(
        'SELECT * FROM canteen_spu        WHERE       delFlag = 0       AND 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, image: row['image'] as String?, isDefault: _boolConverter.decode(row['isDefault'] as int), status: row['status'] as int, sort: row['sort'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), delFlag: _boolConverter.decode(row['delFlag'] as int)),
        arguments: [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> batchEdit(List<CanteenSpuEntity> entitys) async {
    await _canteenSpuEntityUpdateAdapter.updateList(
        entitys, OnConflictStrategy.abort);
  }

  @override
  Future<void> batchDel(List<CanteenSpuEntity> entitys) async {
    await _canteenSpuEntityDeletionAdapter.deleteList(entitys);
  }
}

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 || \'%\')     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.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 || \'%\')     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<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,
                  '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,
                  '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     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     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
                }),
        _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
                }),
        _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
                });

  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),
        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?> getCount() async {
    return _queryAdapter.query(
        'SELECT DISTINCT COUNT(0) FROM classify WHERE delFlag = 0',
        mapper: (Map<String, Object?> row) => row.values.first as int);
  }

  @override
  Future<ClassifyEntity?> getByCode(String code) async {
    return _queryAdapter.query(
        'SELECT * FROM classify WHERE delFlag = 0 AND serviceUniqueCode = ?1',
        mapper: (Map<String, Object?> row) => ClassifyEntity(
            id: row['id'] as int?,
            serviceUniqueCode: row['serviceUniqueCode'] as String,
            sysType: _sysTypeConverter.decode(row['sysType'] as String),
            name: row['name'] as String,
            categoryType: row['categoryType'] as String,
            sort: row['sort'] as int,
            createTime: _dateTimeConverter.decode(row['createTime'] as String),
            updateTime: _dateTimeConverter.decode(row['updateTime'] as String),
            delFlag: _boolConverter.decode(row['delFlag'] as int)),
        arguments: [code]);
  }

  @override
  Future<List<ClassifyEntity>> getAll(
    String sysType,
    String categoryType,
  ) async {
    return _queryAdapter.queryList(
        'SELECT classify.* FROM classify   WHERE   delFlag = 0 AND   (?1 = \'-1\' OR sysType = ?1) AND   (?2 = \'-1\' OR INSTR(\',\' || categoryType || \',\', \',\' || ?2 || \',\') > 0)   ORDER BY classify.sort',
        mapper: (Map<String, Object?> row) => ClassifyEntity(id: row['id'] as int?, serviceUniqueCode: row['serviceUniqueCode'] as String, sysType: _sysTypeConverter.decode(row['sysType'] as String), name: row['name'] as String, categoryType: row['categoryType'] as String, sort: row['sort'] as int, createTime: _dateTimeConverter.decode(row['createTime'] as String), updateTime: _dateTimeConverter.decode(row['updateTime'] as String), delFlag: _boolConverter.decode(row['delFlag'] as int)),
        arguments: [sysType, categoryType]);
  }

  @override
  Future<void> save(ClassifyEntity entity) async {
    await _classifyEntityInsertionAdapter.insert(
        entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> batchSave(List<ClassifyEntity> entitys) async {
    await _classifyEntityInsertionAdapter.insertList(
        entitys, OnConflictStrategy.abort);
  }

  @override
  Future<void> edit(ClassifyEntity entity) async {
    await _classifyEntityUpdateAdapter.update(entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> batchEdit(List<ClassifyEntity> entitys) async {
    await _classifyEntityUpdateAdapter.updateList(
        entitys, OnConflictStrategy.abort);
  }
}

class _$PrintHistoryDao extends PrintHistoryDao {
  _$PrintHistoryDao(
    this.database,
    this.changeListener,
  )   : _queryAdapter = QueryAdapter(database),
        _printHistoryEntityInsertionAdapter = InsertionAdapter(
            database,
            'print_history',
            (PrintHistoryEntity item) => <String, Object?>{
                  'id': item.id,
                  'orderId': item.orderId,
                  'serviceOrderId': item.serviceOrderId,
                  'servicePrintId': item.servicePrintId,
                  'invoiceUrl': item.invoiceUrl,
                  'status': _printStatusConverter.encode(item.status),
                  'printTime': item.printTime,
                  'syncTime': _dateTimeEmptyConverter.encode(item.syncTime),
                  'createTime': _dateTimeConverter.encode(item.createTime)
                }),
        _printHistoryEntityUpdateAdapter = UpdateAdapter(
            database,
            'print_history',
            ['id'],
            (PrintHistoryEntity item) => <String, Object?>{
                  'id': item.id,
                  'orderId': item.orderId,
                  'serviceOrderId': item.serviceOrderId,
                  'servicePrintId': item.servicePrintId,
                  'invoiceUrl': item.invoiceUrl,
                  'status': _printStatusConverter.encode(item.status),
                  'printTime': item.printTime,
                  'syncTime': _dateTimeEmptyConverter.encode(item.syncTime),
                  'createTime': _dateTimeConverter.encode(item.createTime)
                }),
        _printHistoryEntityDeletionAdapter = DeletionAdapter(
            database,
            'print_history',
            ['id'],
            (PrintHistoryEntity item) => <String, Object?>{
                  'id': item.id,
                  'orderId': item.orderId,
                  'serviceOrderId': item.serviceOrderId,
                  'servicePrintId': item.servicePrintId,
                  'invoiceUrl': item.invoiceUrl,
                  'status': _printStatusConverter.encode(item.status),
                  'printTime': item.printTime,
                  'syncTime': _dateTimeEmptyConverter.encode(item.syncTime),
                  'createTime': _dateTimeConverter.encode(item.createTime)
                });

  final sqflite.DatabaseExecutor database;

  final StreamController<String> changeListener;

  final QueryAdapter _queryAdapter;

  final InsertionAdapter<PrintHistoryEntity>
      _printHistoryEntityInsertionAdapter;

  final UpdateAdapter<PrintHistoryEntity> _printHistoryEntityUpdateAdapter;

  final DeletionAdapter<PrintHistoryEntity> _printHistoryEntityDeletionAdapter;

  @override
  Future<void> delAll() async {
    await _queryAdapter.queryNoReturn('DELETE FROM print_history');
  }

  @override
  Future<List<PrintHistoryEntity>> getAll(String status) async {
    return _queryAdapter.queryList(
        'SELECT * FROM print_history      WHERE      (?1 = \'-1\' OR status = ?1)',
        mapper: (Map<String, Object?> row) => PrintHistoryEntity(id: row['id'] as int?, orderId: row['orderId'] as String, serviceOrderId: row['serviceOrderId'] as String, servicePrintId: row['servicePrintId'] as String, invoiceUrl: row['invoiceUrl'] as String, status: _printStatusConverter.decode(row['status'] as String), printTime: row['printTime'] as String?, syncTime: _dateTimeEmptyConverter.decode(row['syncTime'] as String), createTime: _dateTimeConverter.decode(row['createTime'] as String)),
        arguments: [status]);
  }

  @override
  Future<void> save(PrintHistoryEntity entity) async {
    await _printHistoryEntityInsertionAdapter.insert(
        entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> batchSave(List<PrintHistoryEntity> entitys) async {
    await _printHistoryEntityInsertionAdapter.insertList(
        entitys, OnConflictStrategy.abort);
  }

  @override
  Future<void> edit(PrintHistoryEntity entity) async {
    await _printHistoryEntityUpdateAdapter.update(
        entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> batchEdit(List<PrintHistoryEntity> entitys) async {
    await _printHistoryEntityUpdateAdapter.updateList(
        entitys, OnConflictStrategy.abort);
  }

  @override
  Future<void> del(PrintHistoryEntity entity) async {
    await _printHistoryEntityDeletionAdapter.delete(entity);
  }

  @override
  Future<void> batchDel(List<PrintHistoryEntity> entitys) async {
    await _printHistoryEntityDeletionAdapter.deleteList(entitys);
  }
}

class _$UserDao extends UserDao {
  _$UserDao(
    this.database,
    this.changeListener,
  )   : _queryAdapter = QueryAdapter(database),
        _userEntityInsertionAdapter = InsertionAdapter(
            database,
            'user_record',
            (UserEntity item) => <String, Object?>{
                  'id': item.id,
                  'userId': item.userId,
                  'nickname': item.nickname,
                  'mobile': item.mobile,
                  'avatar': item.avatar,
                  'walletCardNumber': item.walletCardNumber,
                  'walletId': item.walletId,
                  'walletTypeId': item.walletTypeId,
                  'walletBalance': item.walletBalance,
                  'createTime': _dateTimeEmptyConverter.encode(item.createTime),
                  'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
                }),
        _userEntityUpdateAdapter = UpdateAdapter(
            database,
            'user_record',
            ['id'],
            (UserEntity item) => <String, Object?>{
                  'id': item.id,
                  'userId': item.userId,
                  'nickname': item.nickname,
                  'mobile': item.mobile,
                  'avatar': item.avatar,
                  'walletCardNumber': item.walletCardNumber,
                  'walletId': item.walletId,
                  'walletTypeId': item.walletTypeId,
                  'walletBalance': item.walletBalance,
                  'createTime': _dateTimeEmptyConverter.encode(item.createTime),
                  'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
                }),
        _userEntityDeletionAdapter = DeletionAdapter(
            database,
            'user_record',
            ['id'],
            (UserEntity item) => <String, Object?>{
                  'id': item.id,
                  'userId': item.userId,
                  'nickname': item.nickname,
                  'mobile': item.mobile,
                  'avatar': item.avatar,
                  'walletCardNumber': item.walletCardNumber,
                  'walletId': item.walletId,
                  'walletTypeId': item.walletTypeId,
                  'walletBalance': item.walletBalance,
                  'createTime': _dateTimeEmptyConverter.encode(item.createTime),
                  'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
                });

  final sqflite.DatabaseExecutor database;

  final StreamController<String> changeListener;

  final QueryAdapter _queryAdapter;

  final InsertionAdapter<UserEntity> _userEntityInsertionAdapter;

  final UpdateAdapter<UserEntity> _userEntityUpdateAdapter;

  final DeletionAdapter<UserEntity> _userEntityDeletionAdapter;

  @override
  Future<UserEntity?> findByUserId(String userId) async {
    return _queryAdapter.query(
        'SELECT * FROM user_record     WHERE       userId = ?1',
        mapper: (Map<String, Object?> row) => UserEntity(
            id: row['id'] as int?,
            userId: row['userId'] as String,
            nickname: row['nickname'] as String,
            mobile: row['mobile'] as String?,
            avatar: row['avatar'] as String?,
            walletCardNumber: row['walletCardNumber'] as String?,
            walletId: row['walletId'] as String?,
            walletTypeId: row['walletTypeId'] as String?,
            walletBalance: row['walletBalance'] as int?,
            createTime:
                _dateTimeEmptyConverter.decode(row['createTime'] as String),
            updateTime:
                _dateTimeEmptyConverter.decode(row['updateTime'] as String)),
        arguments: [userId]);
  }

  @override
  Future<UserEntity?> findByCardNumber(String walletCardNumber) async {
    return _queryAdapter.query(
        'SELECT * FROM user_record     WHERE       walletCardNumber = ?1',
        mapper: (Map<String, Object?> row) => UserEntity(
            id: row['id'] as int?,
            userId: row['userId'] as String,
            nickname: row['nickname'] as String,
            mobile: row['mobile'] as String?,
            avatar: row['avatar'] as String?,
            walletCardNumber: row['walletCardNumber'] as String?,
            walletId: row['walletId'] as String?,
            walletTypeId: row['walletTypeId'] as String?,
            walletBalance: row['walletBalance'] as int?,
            createTime:
                _dateTimeEmptyConverter.decode(row['createTime'] as String),
            updateTime:
                _dateTimeEmptyConverter.decode(row['updateTime'] as String)),
        arguments: [walletCardNumber]);
  }

  @override
  Future<void> save(UserEntity entity) async {
    await _userEntityInsertionAdapter.insert(entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> batchSave(List<UserEntity> entitys) async {
    await _userEntityInsertionAdapter.insertList(
        entitys, OnConflictStrategy.abort);
  }

  @override
  Future<void> edit(UserEntity entity) async {
    await _userEntityUpdateAdapter.update(entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> batchEdit(List<UserEntity> entitys) async {
    await _userEntityUpdateAdapter.updateList(
        entitys, OnConflictStrategy.abort);
  }

  @override
  Future<void> del(UserEntity entity) async {
    await _userEntityDeletionAdapter.delete(entity);
  }

  @override
  Future<void> batchDel(List<UserEntity> entitys) async {
    await _userEntityDeletionAdapter.deleteList(entitys);
  }
}

class _$FaceDao extends FaceDao {
  _$FaceDao(
    this.database,
    this.changeListener,
  )   : _queryAdapter = QueryAdapter(database),
        _faceEntityInsertionAdapter = InsertionAdapter(
            database,
            'face',
            (FaceEntity item) => <String, Object?>{
                  'id': item.id,
                  'userId': item.userId,
                  'sampleId': item.sampleId,
                  'userName': item.userName,
                  'deptId': item.deptId,
                  'deptName': item.deptName,
                  'imagePath': item.imagePath,
                  'path': item.path,
                  'faceModel': _listIntConverter.encode(item.faceModel),
                  'createTime': _dateTimeEmptyConverter.encode(item.createTime),
                  'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
                }),
        _faceEntityUpdateAdapter = UpdateAdapter(
            database,
            'face',
            ['id'],
            (FaceEntity item) => <String, Object?>{
                  'id': item.id,
                  'userId': item.userId,
                  'sampleId': item.sampleId,
                  'userName': item.userName,
                  'deptId': item.deptId,
                  'deptName': item.deptName,
                  'imagePath': item.imagePath,
                  'path': item.path,
                  'faceModel': _listIntConverter.encode(item.faceModel),
                  'createTime': _dateTimeEmptyConverter.encode(item.createTime),
                  'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
                }),
        _faceEntityDeletionAdapter = DeletionAdapter(
            database,
            'face',
            ['id'],
            (FaceEntity item) => <String, Object?>{
                  'id': item.id,
                  'userId': item.userId,
                  'sampleId': item.sampleId,
                  'userName': item.userName,
                  'deptId': item.deptId,
                  'deptName': item.deptName,
                  'imagePath': item.imagePath,
                  'path': item.path,
                  'faceModel': _listIntConverter.encode(item.faceModel),
                  'createTime': _dateTimeEmptyConverter.encode(item.createTime),
                  'updateTime': _dateTimeEmptyConverter.encode(item.updateTime)
                });

  final sqflite.DatabaseExecutor database;

  final StreamController<String> changeListener;

  final QueryAdapter _queryAdapter;

  final InsertionAdapter<FaceEntity> _faceEntityInsertionAdapter;

  final UpdateAdapter<FaceEntity> _faceEntityUpdateAdapter;

  final DeletionAdapter<FaceEntity> _faceEntityDeletionAdapter;

  @override
  Future<void> delAll() async {
    await _queryAdapter.queryNoReturn('DELETE FROM face');
  }

  @override
  Future<void> delById(int id) async {
    await _queryAdapter
        .queryNoReturn('DELETE FROM face WHERE id = ?1', arguments: [id]);
  }

  @override
  Future<void> delByUserId(String userId) async {
    await _queryAdapter.queryNoReturn('DELETE FROM face WHERE userId = ?1',
        arguments: [userId]);
  }

  @override
  Future<int?> findCount(String userName) async {
    return _queryAdapter.query(
        'SELECT DISTINCT COUNT(0) FROM face     WHERE       (?1 = \'-1\' OR userName LIKE \'%\' || ?1 || \'%\')',
        mapper: (Map<String, Object?> row) => row.values.first as int,
        arguments: [userName]);
  }

  @override
  Future<FaceEntity?> getById(int id) async {
    return _queryAdapter.query('SELECT * FROM face WHERE id = ?1',
        mapper: (Map<String, Object?> row) => FaceEntity(
            id: row['id'] as int?,
            userId: row['userId'] as String,
            sampleId: row['sampleId'] as String,
            userName: row['userName'] as String,
            deptId: row['deptId'] as String?,
            deptName: row['deptName'] as String?,
            imagePath: row['imagePath'] as String,
            path: row['path'] as String?,
            faceModel: _listIntConverter.decode(row['faceModel'] as String),
            createTime:
                _dateTimeEmptyConverter.decode(row['createTime'] as String),
            updateTime:
                _dateTimeEmptyConverter.decode(row['updateTime'] as String)),
        arguments: [id]);
  }

  @override
  Future<FaceEntity?> findBySampleId(String sampleId) async {
    return _queryAdapter.query('SELECT * FROM face WHERE sampleId = ?1',
        mapper: (Map<String, Object?> row) => FaceEntity(
            id: row['id'] as int?,
            userId: row['userId'] as String,
            sampleId: row['sampleId'] as String,
            userName: row['userName'] as String,
            deptId: row['deptId'] as String?,
            deptName: row['deptName'] as String?,
            imagePath: row['imagePath'] as String,
            path: row['path'] as String?,
            faceModel: _listIntConverter.decode(row['faceModel'] as String),
            createTime:
                _dateTimeEmptyConverter.decode(row['createTime'] as String),
            updateTime:
                _dateTimeEmptyConverter.decode(row['updateTime'] as String)),
        arguments: [sampleId]);
  }

  @override
  Future<List<FaceEntity>?> findByUserId(String userId) async {
    return _queryAdapter.queryList('SELECT * FROM face WHERE userId = ?1',
        mapper: (Map<String, Object?> row) => FaceEntity(
            id: row['id'] as int?,
            userId: row['userId'] as String,
            sampleId: row['sampleId'] as String,
            userName: row['userName'] as String,
            deptId: row['deptId'] as String?,
            deptName: row['deptName'] as String?,
            imagePath: row['imagePath'] as String,
            path: row['path'] as String?,
            faceModel: _listIntConverter.decode(row['faceModel'] as String),
            createTime:
                _dateTimeEmptyConverter.decode(row['createTime'] as String),
            updateTime:
                _dateTimeEmptyConverter.decode(row['updateTime'] as String)),
        arguments: [userId]);
  }

  @override
  Future<List<FaceEntity>> findAll(
    String userName,
    int pageSize,
    int offset,
  ) async {
    return _queryAdapter.queryList(
        'SELECT * FROM face      WHERE       (?1 = \'-1\' OR userName LIKE \'%\' || ?1 || \'%\')     LIMIT ?2 OFFSET ?3',
        mapper: (Map<String, Object?> row) => FaceEntity(id: row['id'] as int?, userId: row['userId'] as String, sampleId: row['sampleId'] as String, userName: row['userName'] as String, deptId: row['deptId'] as String?, deptName: row['deptName'] as String?, imagePath: row['imagePath'] as String, path: row['path'] as String?, faceModel: _listIntConverter.decode(row['faceModel'] as String), createTime: _dateTimeEmptyConverter.decode(row['createTime'] as String), updateTime: _dateTimeEmptyConverter.decode(row['updateTime'] as String)),
        arguments: [userName, pageSize, offset]);
  }

  @override
  Future<List<String>> findAllUserIds() async {
    return _queryAdapter.queryList(
        'SELECT DISTINCT a.deptId FROM face a WHERE a.deptId IS NOT NULL',
        mapper: (Map<String, Object?> row) => row.values.first as String);
  }

  @override
  Future<int> save(FaceEntity entity) {
    return _faceEntityInsertionAdapter.insertAndReturnId(
        entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> batchSave(List<FaceEntity> entitys) async {
    await _faceEntityInsertionAdapter.insertList(
        entitys, OnConflictStrategy.abort);
  }

  @override
  Future<void> edit(FaceEntity entity) async {
    await _faceEntityUpdateAdapter.update(entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> batchEdit(List<FaceEntity> entitys) async {
    await _faceEntityUpdateAdapter.updateList(
        entitys, OnConflictStrategy.abort);
  }

  @override
  Future<void> del(FaceEntity entity) async {
    await _faceEntityDeletionAdapter.delete(entity);
  }

  @override
  Future<void> batchDel(List<FaceEntity> entitys) async {
    await _faceEntityDeletionAdapter.deleteList(entitys);
  }
}

class _$SettingDao extends SettingDao {
  _$SettingDao(
    this.database,
    this.changeListener,
  )   : _queryAdapter = QueryAdapter(database),
        _settingEntityInsertionAdapter = InsertionAdapter(
            database,
            'setting',
            (SettingEntity item) => <String, Object?>{
                  'id': item.id,
                  'userJson': item.userJson,
                  'sysJson': item.sysJson,
                  'canteenExtraPriceConfigJson':
                      item.canteenExtraPriceConfigJson
                }),
        _settingEntityUpdateAdapter = UpdateAdapter(
            database,
            'setting',
            ['id'],
            (SettingEntity item) => <String, Object?>{
                  'id': item.id,
                  'userJson': item.userJson,
                  'sysJson': item.sysJson,
                  'canteenExtraPriceConfigJson':
                      item.canteenExtraPriceConfigJson
                }),
        _settingEntityDeletionAdapter = DeletionAdapter(
            database,
            'setting',
            ['id'],
            (SettingEntity item) => <String, Object?>{
                  'id': item.id,
                  'userJson': item.userJson,
                  'sysJson': item.sysJson,
                  'canteenExtraPriceConfigJson':
                      item.canteenExtraPriceConfigJson
                });

  final sqflite.DatabaseExecutor database;

  final StreamController<String> changeListener;

  final QueryAdapter _queryAdapter;

  final InsertionAdapter<SettingEntity> _settingEntityInsertionAdapter;

  final UpdateAdapter<SettingEntity> _settingEntityUpdateAdapter;

  final DeletionAdapter<SettingEntity> _settingEntityDeletionAdapter;

  @override
  Future<SettingEntity?> get() async {
    return _queryAdapter.query('SELECT * FROM setting LIMIT 1',
        mapper: (Map<String, Object?> row) => SettingEntity(
            id: row['id'] as int?,
            userJson: row['userJson'] as String,
            sysJson: row['sysJson'] as String,
            canteenExtraPriceConfigJson:
                row['canteenExtraPriceConfigJson'] as String?));
  }

  @override
  Future<int> save(SettingEntity entity) {
    return _settingEntityInsertionAdapter.insertAndReturnId(
        entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> edit(SettingEntity entity) async {
    await _settingEntityUpdateAdapter.update(entity, OnConflictStrategy.abort);
  }

  @override
  Future<void> del(SettingEntity entity) async {
    await _settingEntityDeletionAdapter.delete(entity);
  }
}

// ignore_for_file: unused_element
final _dateTimeConverter = DateTimeConverter();
final _dateTimeEmptyConverter = DateTimeEmptyConverter();
final _orderStatusConverter = OrderStatusConverter();
final _orderTypeConverter = OrderTypeConverter();
final _orderPayTypeConverter = OrderPayTypeConverter();
final _sysTypeConverter = SysTypeConverter();
final _printStatusConverter = PrintStatusConverter();
final _supermarketNatureConverter = SupermarketNatureConverter();
final _listIntConverter = ListIntConverter();
final _boolConverter = BoolConverter();