app-starlock/star_lock/lib/network/api_repository.dart

import 'package:get/get.dart';
import 'package:star_lock/login/seletCountryRegion/common/countryRegionEntity.dart';
import 'package:star_lock/main/lockDetail/electronicKey/electronicKeyDetail/keyOperationRecordEntity.dart';
import 'package:star_lock/main/lockDetail/electronicKey/electronicKeyList/entity/ElectronicKeyListEntity.dart';
import 'package:star_lock/main/lockDetail/electronicKey/massSendElectronicKey/massSendLockGroupList/lockUserList/lockUserListEntity.dart';
import 'package:star_lock/main/lockDetail/electronicKey/massSendElectronicKey/massSendLockGroupList/massSendLockGroupListEntity.dart';
import 'package:star_lock/main/lockDetail/lcokSet/basicInformation/basicInformation/KeyDetailEntity.dart';
import 'package:star_lock/main/lockDetail/lcokSet/basicInformation/lockSeletGrouping/LockGroupListEntity.dart';
import 'package:star_lock/main/lockDetail/passwordKey/passwordKeyList/passwordKeyListEntity.dart';
import 'package:star_lock/main/lockDetail/passwordKey/passwordKey_perpetual/passwordKeyEntity.dart';
import 'package:star_lock/mine/mineSet/authorizedAdministrator/authorizedAdminListEntity.dart';
import 'package:star_lock/mine/mineSet/lockUserManage/keyListByUserEntity.dart';
import '../common/safetyVerification/entity/CheckSafetyVerificationEntity.dart';
import '../common/safetyVerification/entity/SafetyVerificationEntity.dart';
import '../login/login/entity/LoginEntity.dart';
import '../login/register/entity/SendValidationCodeEntity.dart';
import '../main/lockDetail/checkingIn/checkingInDetail/checkingInDetail_entity.dart';
import '../main/lockDetail/checkingIn/checkingInHolidays/checkingInSetHolidays/checkingInSetHolidays_entity.dart';
import '../main/lockDetail/checkingIn/checkingInList/checkingInListDay_entity.dart';
import '../main/lockDetail/checkingIn/checkingInList/checkingInListMonth_entity.dart';
import '../main/lockDetail/checkingIn/checkingInSet/checkingInSet_entity.dart';
import '../main/lockDetail/checkingIn/checkingInStaff/checkingInSetAddStaff/checkingInAddStaffSeletKey_entity.dart';
import '../main/lockDetail/checkingIn/checkingInStaff/checkingInSetStaffList/checkingInStaffList_entity.dart';
import '../main/lockDetail/lcokSet/configuringWifi/configuringWifiEntity.dart';
import '../main/lockDetail/lcokSet/lockSet/CheckingInInfoDataEntity.dart';
import '../main/lockDetail/lcokSet/lockTime/GetServerDatetimeEntity.dart';
import '../main/lockDetail/lcokSet/normallyOpenMode/GetPassageModeConfigEntity.dart';
import '../main/lockDetail/otherTypeKey/otherTypeKeyList/fingerprintListData_entity.dart';
import '../main/lockMian/entity/lockInfoEntity.dart';
import '../mine/addLock/saveLock/entity/SaveLockEntity.dart';
import 'api_provider.dart';

class ApiRepository {
  final ApiProvider apiProvider;

  static ApiRepository get to => Get.find<ApiRepository>();
  ApiRepository(this.apiProvider);

  // 发送验证码  1注册，2找回密码，3绑定手机号，4解绑（换绑），5删除账号
  Future<SendValidationCodeEntity> sendValidationCode(
      String countryCode,
      String account,
      String channel,
      String codeType,
      String uniqueid,
      String xWidth) async {
    final res = await apiProvider.getVerificationCode(
        countryCode, account, channel, codeType, uniqueid, xWidth);
    return SendValidationCodeEntity.fromJson(res.body);
  }

  // 注册
  Future<LoginEntity> register(
      String countryCode,
      String countryId,
      String mobile,
      String password,
      String uniqueid,
      String verificationCode) async {
    final res = await apiProvider.register(
        countryCode, countryId, mobile, password, uniqueid, verificationCode);
    return LoginEntity.fromJson(res.body);
  }

  // 获取图片验证码
  Future<SafetyVerificationEntity> getSliderVerifyImg(
      String countryCode, String account) async {
    final res = await apiProvider.getSliderVerifyImg(countryCode, account);
    return SafetyVerificationEntity.fromJson(res.body);
  }

  // 检验图片验证码
  Future<CheckSafetyVerificationEntity> checkSliderVerifyImg(
      String countryCode, String account, String xWidth) async {
    final res =
        await apiProvider.checkSliderVerifyImg(countryCode, account, xWidth);
    return CheckSafetyVerificationEntity.fromJson(res.body);
  }

//登录
  Future<LoginEntity> login(String loginType, String password,
      String countryCode, String username) async {
    final res =
        await apiProvider.login(loginType, password, countryCode, username);
    return LoginEntity.fromJson(res.body);
  }

  //重置密码
  Future<LoginEntity> resetPassword(
      String countryCode,
      String account,
      String date,
      String newPassword,
      String uniqueid,
      String verificationCode) async {
    final res = await apiProvider.resetPassword(
        countryCode, account, date, newPassword, uniqueid, verificationCode);
    return LoginEntity.fromJson(res.body);
  }

  //获取国家或地区 json文件
  Future<CountryRegionEntity> getCountryRegion(String type) async {
    final res = await apiProvider.getCountryRegion(type);
    return CountryRegionEntity.fromJson(res.body);
  }

  //电子钥匙列表
  Future<ElectronicKeyListEntity> electronicKeyList(
      String endDate,
      String keyId,
      String keyStatus,
      String lockId,
      String operatorUid,
      String pageNo,
      String pageSize,
      String startDate,
      String keyRight) async {
    final res = await apiProvider.electronicKeyList(endDate, keyId, keyStatus,
        lockId, operatorUid, pageNo, pageSize, startDate, keyRight);
    return ElectronicKeyListEntity.fromJson(res.body);
  }

  //发送电子钥匙
  Future<ElectronicKeyListEntity> sendElectronicKey(
      String createUser,
      String countryCode,
      String usernameType,
      String endDate,
      String faceAuthentication,
      String isCameraEnable,
      String isRemoteUnlock,
      String keyNameForAdmin,
      String keyRight,
      String keyType,
      String lockId,
      String operatorUid,
      String receiverUsername,
      String remarks,
      String startDate,
      List weekDays) async {
    final res = await apiProvider.sendElectronicKey(
        createUser,
        countryCode,
        usernameType,
        endDate,
        faceAuthentication,
        isCameraEnable,
        isRemoteUnlock,
        keyNameForAdmin,
        keyRight,
        keyType,
        lockId,
        operatorUid,
        receiverUsername,
        remarks,
        startDate,
        weekDays);
    return ElectronicKeyListEntity.fromJson(res.body);
  }

  //重置电子钥匙
  Future<ElectronicKeyListEntity> resetElectronicKey(
      String lockId, String operatorUid) async {
    final res = await apiProvider.resetElectronicKey(lockId, operatorUid);
    return ElectronicKeyListEntity.fromJson(res.body);
  }

  //钥匙详情-操作记录
  Future<KeyOperationRecordEntity> lockRecordList(
      String endDate,
      String keyId,
      String keyStatus,
      String lockId,
      String operatorUid,
      String pageNo,
      String pageSize,
      String startDate,
      String recordType,
      String searchStr,
      String timezoneRawOffSet,
      String keyboardPwdId,
      String cardId,
      String fingerprintId) async {
    final res = await apiProvider.lockRecordList(
        endDate,
        keyId,
        keyStatus,
        lockId,
        operatorUid,
        pageNo,
        pageSize,
        startDate,
        recordType,
        searchStr,
        timezoneRawOffSet,
        keyboardPwdId,
        cardId,
        fingerprintId);
    return KeyOperationRecordEntity.fromJson(res.body);
  }

  // 绑定蓝牙管理员
  Future<SaveLockEntity> bindingBlueAdmin(
      {required String bindingDate,
      required String hotelMode,
      required String lockAlias,
      required Map lockData,
      required String nbInitSuccess,
      required Map position,
      required Map bluetooth,
      required String deviceNo,
      required String lockUserNo,
      required String pwdTimestamp}) async {
    final res = await apiProvider.bindingBlueAdmin(
        bindingDate,
        hotelMode,
        lockAlias,
        lockData,
        nbInitSuccess,
        position,
        bluetooth,
        deviceNo,
        lockUserNo,
        pwdTimestamp);
    return SaveLockEntity.fromJson(res.body);
  }

  //锁电量更新
  Future<KeyOperationRecordEntity> uploadElectricQuantity(
      String electricQuantity, String lockId) async {
    final res =
        await apiProvider.uploadElectricQuantity(electricQuantity, lockId);
    return KeyOperationRecordEntity.fromJson(res.body);
  }

  //锁名称修改
  Future<KeyOperationRecordEntity> modifyKeyName(
    String keyId,
    String lockId,
    String keyName,
    String operatorUid,
  ) async {
    final res =
        await apiProvider.modifyKeyName(keyId, lockId, keyName, operatorUid);
    return KeyOperationRecordEntity.fromJson(res.body);
  }

  //编辑电子钥匙名字
  Future<KeyOperationRecordEntity> modifyKeyNameForAdmin(
    String keyId,
    String keyNameForAdmin,
    String operatorUid,
  ) async {
    final res = await apiProvider.modifyKeyNameForAdmin(
        keyId, keyNameForAdmin, operatorUid);
    return KeyOperationRecordEntity.fromJson(res.body);
  }

  //编辑电子钥匙有效期
  Future<KeyOperationRecordEntity> updateKeyDate(
      String keyId,
      String lockId,
      String endDate,
      String endDay,
      String operatorUid,
      String startDate,
      String startDay,
      List weekDays) async {
    final res = await apiProvider.updateKeyDate(keyId, lockId, endDate, endDay,
        operatorUid, startDate, startDay, weekDays);
    return KeyOperationRecordEntity.fromJson(res.body);
  }

  //密码列表
  Future<PasswordKeyListEntity> passwordKeyList(
    String keyStatus,
    String lockId,
    String operatorUid,
    String pageNo,
    String pageSize,
  ) async {
    final res = await apiProvider.passwordKeyList(
        keyStatus, lockId, operatorUid, pageNo, pageSize);
    return PasswordKeyListEntity.fromJson(res.body);
  }

  //重置密码钥匙
  Future<PasswordKeyListEntity> resetPasswordKey(
      String lockId, String operatorUid) async {
    final res = await apiProvider.resetPasswordKey(lockId, operatorUid);
    return PasswordKeyListEntity.fromJson(res.body);
  }

  // 获取锁信息
  Future<LockMainEntity> getLockInfo(
      {required String lastUpdateDate, required String pageNo}) async {
    final res = await apiProvider.getLockInfo(lastUpdateDate, pageNo);
    return LockMainEntity.fromJson(res.body);
  }

  // 删除锁
  Future<LockMainEntity> deletLockData({required String lockId}) async {
    final res = await apiProvider.deletLockInfo(lockId);
    return LockMainEntity.fromJson(res.body);
  }

  //获取密码
  Future<PasswordKeyEntity> getPasswordKey(
    String endDate,
    String isExclusive,
    String keyboardPwdName,
    String keyboardPwdType,
    String keyboardPwdVersion,
    String lockId,
    String operatorUid,
    String startDate,
    String timezoneRawOffSet,
  ) async {
    final res = await apiProvider.getKeyboardPwd(
        endDate,
        isExclusive,
        keyboardPwdName,
        keyboardPwdType,
        keyboardPwdVersion,
        lockId,
        operatorUid,
        startDate,
        timezoneRawOffSet);
    return PasswordKeyEntity.fromJson(res.body);
  }

  //自定义密码
  Future<PasswordKeyEntity> addPasswordKey(
    String lockId,
    String keyboardPwdName,
    String keyboardPwd,
    String keyboardPwdType,
    String startDate,
    String endDate,
    String addType,
  ) async {
    final res = await apiProvider.addKeyboardPwd(lockId, keyboardPwdName,
        keyboardPwd, keyboardPwdType, startDate, endDate, addType);
    return PasswordKeyEntity.fromJson(res.body);
  }

  //修改密码
  Future<PasswordKeyEntity> updatePasswordKey(
    String lockId,
    String keyboardPwdId,
    String keyboardPwdName,
    String newKeyboardPwd,
    String startDate,
    String endDate,
    String changeType,
  ) async {
    final res = await apiProvider.updateKeyboardPwd(lockId, keyboardPwdId,
        keyboardPwdName, newKeyboardPwd, startDate, endDate, changeType);
    return PasswordKeyEntity.fromJson(res.body);
  }

  //清空操作记录
  Future<KeyOperationRecordEntity> clearOperationRecord(String lockId) async {
    final res = await apiProvider.clearOperationRecord(lockId);
    return KeyOperationRecordEntity.fromJson(res.body);
  }

  //创建锁分组
  Future<MassSendLockGroupListEntity> addLockGroup(
      String groupName, String operatorUid) async {
    final res = await apiProvider.addLockGroup(groupName, operatorUid);
    return MassSendLockGroupListEntity.fromJson(res.body);
  }

  //设置锁分组
  Future<MassSendLockGroupListEntity> setLockGroup(
      String lockId, String groupId) async {
    final res = await apiProvider.setLockGroup(lockId, groupId);
    return MassSendLockGroupListEntity.fromJson(res.body);
  }

  //锁分组列表
  Future<MassSendLockGroupListEntity> lockGroupList(String type) async {
    final res = await apiProvider.lockGroupList(type);
    return MassSendLockGroupListEntity.fromJson(res.body);
  }

  //删除电子钥匙
  Future<ElectronicKeyListEntity> deleteElectronicKey(String keyId) async {
    final res = await apiProvider.deleteElectronicKey(keyId);
    return ElectronicKeyListEntity.fromJson(res.body);
  }

  //删除授权管理员
  Future<ElectronicKeyListEntity> deleteAdministrator(
      String uid, String includeUnderlings) async {
    final res = await apiProvider.deleteAdministrator(uid, includeUnderlings);
    return ElectronicKeyListEntity.fromJson(res.body);
  }

  //更新授权管理员
  Future<ElectronicKeyListEntity> updateAdministrator(String uid, String name,
      String endDate, String startDate, String isRemoteUnlock) async {
    final res = await apiProvider.updateAdministrator(
        uid, name, endDate, startDate, isRemoteUnlock);
    return ElectronicKeyListEntity.fromJson(res.body);
  }

  //即将到期的锁列表
  Future<ElectronicKeyListEntity> expireLockList(
      String operatorUid, String pageNo, String pageSize) async {
    final res = await apiProvider.expireLockList(operatorUid, pageNo, pageSize);
    return ElectronicKeyListEntity.fromJson(res.body);
  }

  //删除密码
  Future<PasswordKeyEntity> deleteKeyboardPwd(
      String lockId, String keyboardPwdId, String deleteType) async {
    final res =
        await apiProvider.deleteKeyboardPwd(lockId, keyboardPwdId, deleteType);
    return PasswordKeyEntity.fromJson(res.body);
  }

  //标记房态
  Future<PasswordKeyEntity> updateSetting(
      String lockId, String isOn, String type) async {
    final res = await apiProvider.deleteKeyboardPwd(lockId, isOn, type);
    return PasswordKeyEntity.fromJson(res.body);
  }

  //分组列表
  Future<PasswordKeyEntity> keyGroupList(String type) async {
    final res = await apiProvider.keyGroupList(type);
    return PasswordKeyEntity.fromJson(res.body);
  }

  //分组下的锁
  Future<PasswordKeyEntity> lockListByGroup(
      String type, String keyGroupId) async {
    final res = await apiProvider.lockListByGroup(type, keyGroupId);
    return PasswordKeyEntity.fromJson(res.body);
  }

  // 获取Wifi锁服务器
  Future<ConfiguringWifiEntity> getWifiLockServiceIpAndPort() async {
    final res = await apiProvider.getWifiLockServiceIpAndPort();
    return ConfiguringWifiEntity.fromJson(res.body);
  }

  /// 锁设置模块
  // 远程开锁开/关
  Future<LoginEntity> remoteUnlockingOpenOrClose({
    required String lockId,
    required String featureValue,
  }) async {
    final res = await apiProvider.remoteUnlockingOpenOrCloseLoadData(
        lockId, featureValue);
    return LoginEntity.fromJson(res.body);
  }

  // 自动闭锁
  Future<LoginEntity> setAutoUnlock({
    required String lockId,
    required String autoLockTime,
    required String type,
  }) async {
    final res =
        await apiProvider.setAutoUnlockLoadData(lockId, autoLockTime, type);
    return LoginEntity.fromJson(res.body);
  }

  // 获取锁的常开模式设置 configPassageMode
  Future<GetPassageModeConfigEntity> getPassageModeConfig({
    required String lockId,
  }) async {
    final res = await apiProvider.getPassageModeConfigLoadData(lockId);
    return GetPassageModeConfigEntity.fromJson(res.body);
  }

  // 配置锁的常开模式
  Future<GetPassageModeConfigEntity> configPassageModeLoadData({
    required String lockId,
    required String passageMode,
    required String autoUnlock,
    required String type,
    required String startDate,
    required String endDate,
    required String isAllDay,
    required List weekDays,
  }) async {
    final res = await apiProvider.configPassageMode(lockId, passageMode,
        autoUnlock, type, startDate, endDate, isAllDay, weekDays);
    return GetPassageModeConfigEntity.fromJson(res.body);
  }

  // 配置锁的常规设置
  Future<LoginEntity> setLockSetGeneralSettingData({
    required String lockId,
    required String changeType,
    required String isOn,
    required String type,
  }) async {
    final res = await apiProvider.setLockSetGeneralSetting(
        lockId, changeType, isOn, type);
    return LoginEntity.fromJson(res.body);
  }

  // 获取锁时间 通过网关
  Future<GetPassageModeConfigEntity> getLockTimeFromGateway({
    required String lockId,
  }) async {
    final res = await apiProvider.getLockTimeFromGatewayLoadData(lockId);
    return GetPassageModeConfigEntity.fromJson(res.body);
  }

  // 获取服务器当前时间
  Future<GetServerDatetimeEntity> getServerDatetimeData({
    required String lockId,
  }) async {
    final res = await apiProvider.getServerDatetimeLoadData(lockId);
    return GetServerDatetimeEntity.fromJson(res.body);
  }

  // 锁诊断上传数据
  Future<LoginEntity> setLockDiagnoseData({
    required String lockId,
    required String electricQuantity,
    required String firmwareRevision,
    required String hardwareRevision,
    required String lockDate,
    required String modelNum,
    required String pwdInfo,
    required String timestamp,
  }) async {
    final res = await apiProvider.setLockDiagnoseData(
        lockId,
        electricQuantity,
        firmwareRevision,
        hardwareRevision,
        lockDate,
        modelNum,
        pwdInfo,
        timestamp);
    return LoginEntity.fromJson(res.body);
  }

  // 获取锁版本信息
  Future<GetServerDatetimeEntity> getLockVersionInfoData({
    required String lockId,
  }) async {
    final res = await apiProvider.getLockVersionInfoLoadData(lockId);
    return GetServerDatetimeEntity.fromJson(res.body);
  }

  //分组下的锁列表
  Future<MassSendLockGroupListEntity> listLockByGroup(
      String type, String keyGroupId) async {
    final res = await apiProvider.listLockByGroup(type, keyGroupId);
    return MassSendLockGroupListEntity.fromJson(res.body);
  }

  //获取单把钥匙详情信息
  Future<KeyDetailEntity> getKeyDetail(String lockId) async {
    final res = await apiProvider.getKeyDetail(lockId);
    return KeyDetailEntity.fromJson(res.body);
  }

  //锁用户列表
  Future<LockUserListEntity> lockUserList(
      String pageNo, String pageSize, String searchStr) async {
    final res = await apiProvider.lockUserList(pageNo, pageSize, searchStr);
    return LockUserListEntity.fromJson(res.body);
  }

  //用户拥有的钥匙
  Future<KeyListByUserEntity> keyListByUser(
      String pageNo, String pageSize, String uid) async {
    final res = await apiProvider.keyListByUser(pageNo, pageSize, uid);
    return KeyListByUserEntity.fromJson(res.body);
  }

  //群发电子钥匙检查
  Future<KeyDetailEntity> canSendKey(
      String endDate, List keyGroupIdList, List lockIdList) async {
    final res =
        await apiProvider.canSendKey(endDate, keyGroupIdList, lockIdList);
    return KeyDetailEntity.fromJson(res.body);
  }

  //群发电子钥匙
  Future<KeyDetailEntity> batchSendKey(
      String endDate,
      List keyGroupIdList,
      List lockIdList,
      String createUser,
      String isRemoteUnlock,
      String keyNameForAdmin,
      String receiverUsername,
      String startDate,
      String countryCode,
      String usernameType,
      List weekDays) async {
    final res = await apiProvider.batchSendKey(
        endDate,
        keyGroupIdList,
        lockIdList,
        createUser,
        isRemoteUnlock,
        keyNameForAdmin,
        receiverUsername,
        startDate,
        countryCode,
        usernameType,
        weekDays);
    return KeyDetailEntity.fromJson(res.body);
  }

  //增加授权管理员
  Future<KeyDetailEntity> addAuthorizedAdmin(
      String createUser,
      String endDate,
      String isRemoteUnlock,
      List keyGroupIdList,
      List lockIdList,
      String name,
      String startDate,
      String userid,
      String countryCode,
      String usernameType) async {
    final res = await apiProvider.addAuthorizedAdmin(
        createUser,
        endDate,
        isRemoteUnlock,
        keyGroupIdList,
        lockIdList,
        name,
        startDate,
        userid,
        countryCode,
        usernameType);
    return KeyDetailEntity.fromJson(res.body);
  }

  //授权管理员列表
  Future<AuthorizedAdminListEntity> authorizedAdminList(
      String pageNo, String pageSize) async {
    final res = await apiProvider.authorizedAdminList(pageNo, pageSize);
    return AuthorizedAdminListEntity.fromJson(res.body);
  }

  // 开启考勤 获取考勤信息
  Future<CheckingInInfoDataEntity> openCheckingInData(
      {required String lockId}) async {
    final res = await apiProvider.openCheckingInGetData(lockId);
    return CheckingInInfoDataEntity.fromJson(res.body);
  }

  // 设置考勤时创建公司
  Future<LoginEntity> setCheckInCreateCompanyData(
      {required String lockId,
      required String attendanceType,
      required String companyName,
      required List workDay,
      required String workEndTime,
      required String workStartTime}) async {
    final res = await apiProvider.setCheckInCreateCompanyData(lockId,
        attendanceType, companyName, workDay, workEndTime, workStartTime);
    return LoginEntity.fromJson(res.body);
  }

  // 设置锁开锁提醒
  Future<LoginEntity> setLockPickingReminderData({
    required String lockId,
    required String keyId,
    required String monitorFlag,
  }) async {
    final res = await apiProvider.setLockPickingReminderData(
        lockId, keyId, monitorFlag);
    return LoginEntity.fromJson(res.body);
  }

  // 获取考勤列表 - 早到榜日榜
  Future<CheckingInListDayEntity> getCheckInListEarlyArrivalWithDateData(
      {
        required String companyId,
        required String attendanceDate,
      }) async {
    final res =
    await apiProvider.getCheckInListEarlyArrivalWithDateData(companyId, attendanceDate);
    return CheckingInListDayEntity.fromJson(res.body);
  }

  // 获取考勤列表 - 早到榜月榜
  Future<CheckingInListMonthEntity> getCheckInListEarlyArrivalWithMonthData(
      {
        required String companyId,
        required String attendanceDate,
      }) async {
    final res =
    await apiProvider.getCheckInListEarlyArrivalWithMonthData(companyId, attendanceDate);
    return CheckingInListMonthEntity.fromJson(res.body);
  }

  // 获取考勤列表 - 迟到榜日榜
  Future<CheckingInListDayEntity> getCheckInListLateTimesWithDateData(
      {
        required String companyId,
        required String attendanceDate,
      }) async {
    final res =
    await apiProvider.getCheckInListLateTimesWithDateData(companyId, attendanceDate);
    return CheckingInListDayEntity.fromJson(res.body);
  }

  // 获取考勤列表 - 迟到榜月榜
  Future<CheckingInListMonthEntity> getCheckInListLateTimesWithMonthData(
      {
        required String companyId,
        required String attendanceDate,
      }) async {
    final res =
    await apiProvider.getCheckInListLateTimesWithMonthData(companyId, attendanceDate);
    return CheckingInListMonthEntity.fromJson(res.body);
  }

  // 获取考勤列表 - 勤奋榜
  Future<CheckingInListMonthEntity> getCheckInListHardworkingData(
      {
        required String companyId,
        required String attendanceDate,
        required String type,
      }) async {
    final res =
    await apiProvider.getCheckInListHardworkingData(companyId, attendanceDate, type);
    return CheckingInListMonthEntity.fromJson(res.body);
  }

  // 获取考勤详情
  Future<CheckingInDetailEntity> getCheckInDetailData(
      {
        required String companyId,
        required String attendanceDate,
        required String staffId,
      }) async {
    final res =
    await apiProvider.getCheckInDetailData(companyId, attendanceDate, staffId);
    return CheckingInDetailEntity.fromJson(res.body);
  }

  // 获取员工列表
  Future<CheckingInAddStaffListEntity> getStaffListData(
      {
        required String companyId,
        required String lockId,
      }) async {
    final res =
    await apiProvider.getStaffListData(companyId, lockId);
    return CheckingInAddStaffListEntity.fromJson(res.body);
  }

  // 添加员工
  Future<LoginEntity> addStaffData({
    required String attendanceType,
    required String attendanceWay,
    required String companyId,
    required String have,
    required String staffName,
    required String countryCode,
    required String usernameType,
  }) async {
    final res = await apiProvider.addStaffData(attendanceType, attendanceWay,
        companyId, have, staffName, countryCode, usernameType);
    return LoginEntity.fromJson(res.body);
  }

  // 编辑员工
  Future<LoginEntity> editStaffData(
      {
        required String attendanceType,
        required String attendanceWay,
        required String staffId,
        required String have,
        required String staffName,
        required String countryCode,
        required String usernameType,
      }) async {
    final res =
    await apiProvider.editStaffData(attendanceType, attendanceWay, staffId, have, staffName, countryCode, usernameType);
    return LoginEntity.fromJson(res.body);
  }

  // 添加员工选择钥匙
  Future<CheckingInAddStaffSeletKeyEntity> addStaffSeletKeyData(
      {
        required String companyId,
        required String type,
      }) async {
    final res =
    await apiProvider.addStaffSeletKeyData(companyId, type);
    return CheckingInAddStaffSeletKeyEntity.fromJson(res.body);
  }

  // 添加假期
  Future<LoginEntity> addHolidaysData(
      {
        required String companyId,
        required String fillClassDate,
        required String vacationEndDate,
        required String vacationName,
        required String vacationStartDate,
      }) async {
    final res =
    await apiProvider.addHolidaysData(companyId, fillClassDate, vacationEndDate, vacationName, vacationStartDate);
    return LoginEntity.fromJson(res.body);
  }

  // 假期列表
  Future<CheckingInSetHolidaysInfoDataEntity> holidaysListData(
      {
        required String companyId,
        required String vacationYear,
      }) async {
    final res =
    await apiProvider.holidaysListData(companyId, vacationYear);
    return CheckingInSetHolidaysInfoDataEntity.fromJson(res.body);
  }

  // 删除假期
  Future<LoginEntity> deletHolidaysData(
      {
        required String vacationId
      }) async {
    final res =
    await apiProvider.deletHolidaysData(vacationId);
    return LoginEntity.fromJson(res.body);
  }

  // 获取考勤设置信息
  Future<CheckingInSetEntity> getCheckInSetInfoData(
      {
        required String companyId,
      }) async {
    final res =
    await apiProvider.getCheckInSetInfoData(companyId);
    return CheckingInSetEntity.fromJson(res.body);
  }

  // 修改考勤设置信息
  Future<CheckingInSetEntity> editCheckInSetInfoData(
      {
        required String attendanceType,
        required String companyId,
        required String type,
        required String companyName,
        required String workEndTime,
        required String workStartTime,
        required List<int> workDay,
      }) async {
    final res =
    await apiProvider.editCheckInSetInfoData(attendanceType, companyId, type, companyName, workEndTime, workStartTime, workDay);
    return CheckingInSetEntity.fromJson(res.body);
  }

  // 获取指纹列表
  Future<FingerprintListDataEntity> getFingerprintsListData(
      {
        required String lockId,
        required String pageNo,
        required String pageSize,
        required String searchStr,
      }) async {
    final res =
    await apiProvider.getFingerprintsListData(lockId, pageNo, pageSize, searchStr);
    return FingerprintListDataEntity.fromJson(res.body);
  }

  // 添加指纹
  Future<CheckingInListMonthEntity> addFingerprintsData(
      {
        required String lockId,
        required String endDate,
        required String addType,
        required String fingerprintName,
        required String fingerprintNumber,
        required String fingerprintType,
        required String isCoerced,
        required String startDate,
        required String cyclicConfig,
      }) async {
    final res =
    await apiProvider.addFingerprintsData(lockId, endDate, addType, fingerprintName, fingerprintNumber, fingerprintType, isCoerced, startDate, cyclicConfig);
    return CheckingInListMonthEntity.fromJson(res.body);
  }
}