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/passwordKey/passwordKeyList/passwordKeyListEntity.dart';
import 'package:star_lock/main/lockDetail/passwordKey/passwordKey_perpetual/passwordKeyEntity.dart';
import 'package:star_lock/mine/minePersonInfo/minePersonInfoEditAccount/minePersonInfoEditAccount/mineUnbindPhoneOrEmail_entity.dart';
import 'package:star_lock/mine/minePersonInfo/minePersonInfoPage/minePersonInfo_entity.dart';
import 'package:star_lock/mine/minePersonInfo/minePersonInfoSetSafetyProblem/minePersonInfoSetSafetyProblem_entity.dart';
import 'package:star_lock/mine/minePersonInfo/minePersonInfoViewSafetyProblem/minePersonInfoViewSafetyProblem_entity.dart';
import 'package:star_lock/mine/mineSet/appUnlockNeedMobileNetworkingLock/selectLockListEntity.dart';
import 'package:star_lock/mine/mineSet/authorizedAdministrator/administratorDetails/administratorDetailEntity.dart';
import 'package:star_lock/mine/mineSet/authorizedAdministrator/authorizedAdminListEntity.dart';
import 'package:star_lock/mine/mineSet/lockUserManage/expireLockList/expireLockListEntity.dart';
import 'package:star_lock/mine/mineSet/lockUserManage/keyListByUserEntity.dart';
import 'package:star_lock/mine/mineSet/mineSet/userSettingInfoEntity.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/authorizedAdmin/authorizedAdmin/authorizedAdmin_entity.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/lockOperatingRecord/lockOperatingRecordGetLastRecordTime_entity.dart';
import '../main/lockDetail/otherTypeKey/addFingerprint/addFingerprint/addFingerprint_entity.dart';
import '../main/lockDetail/otherTypeKey/addICCard/addICCard_entity.dart';
import '../main/lockDetail/otherTypeKey/otherTypeKeyList/fingerprintListData_entity.dart';
import '../main/lockMian/entity/lockInfoEntity.dart';
import '../mine/addLock/saveLock/entity/SaveLockEntity.dart';
import '../mine/mineSet/transferGateway/selectGetewayList_entity.dart';
import '../mine/mineSet/transferSmartLock/recipientInformation/recipientInformation_entity.dart';
import '../mine/mineSet/transferSmartLock/transferSmartLockList/transferSmartLock_entity.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<AuthorizedAdminSendEntity> 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 AuthorizedAdminSendEntity.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<KeyOperationRecordEntity> lockRecordUploadData(
      {required String lockId, required List records}) async {
    final res = await apiProvider.lockRecordUploadData(lockId, records);
    return KeyOperationRecordEntity.fromJson(res.body);
  }

  // 查询锁记录最后时间
  Future<LockOperatingRecordGetLastRecordTimeEntity>
      getLockRecordLastUploadDataTime({required String lockId}) async {
    final res = await apiProvider.getLockRecordLastUploadDataTime(lockId);
    return LockOperatingRecordGetLastRecordTimeEntity.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<SelectLockListEntity> selectLockList() async {
    final res = await apiProvider.selectLockList();
    return SelectLockListEntity.fromJson(res.body);
  }

  //APP开锁时需手机联网的锁
  Future<SelectLockListEntity> setAppUnlockMustOnline(List lockIdList) async {
    final res = await apiProvider.setAppUnlockMustOnline(lockIdList);
    return SelectLockListEntity.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 keyName,
      String endDate,
      String startDate,
      String remoteEnable) async {
    final res = await apiProvider.updateAdministrator(
        uid, keyName, endDate, startDate, remoteEnable);
    return ElectronicKeyListEntity.fromJson(res.body);
  }

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

  //删除密码
  Future<PasswordKeyEntity> deleteKeyboardPwd(
      String lockId, String keyboardPwdId, int 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.updateSetting(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<AdministratorDetailEntity> authorizedAdminDetail(int uid) async {
    final res = await apiProvider.authorizedAdminDetail(uid);
    return AdministratorDetailEntity.fromJson(res.body);
  }

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

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

  //提示音
  Future<ExpireLockListEntity> setAlertMode(
      String alertMode, String isOn) async {
    final res = await apiProvider.setAlertMode(alertMode, isOn);
    return ExpireLockListEntity.fromJson(res.body);
  }

  //触摸开锁
  Future<ExpireLockListEntity> setTouchUnlockFlag(String isOn) async {
    final res = await apiProvider.setTouchUnlockFlag(isOn);
    return ExpireLockListEntity.fromJson(res.body);
  }

  //触摸开锁
  Future<ExpireLockListEntity> changeSettings(String isOn, String type) async {
    final res = await apiProvider.changeSettings(isOn, type);
    return ExpireLockListEntity.fromJson(res.body);
  }

  //个人设置信息
  Future<UserSettingInfoEntity> userSettingsInfo() async {
    final res = await apiProvider.userSettingsInfo();
    return UserSettingInfoEntity.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<AddFingerprintEntity> 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 List weekDay,
  }) async {
    final res = await apiProvider.addFingerprintsData(
        lockId,
        endDate,
        addType,
        fingerprintName,
        fingerprintNumber,
        fingerprintType,
        isCoerced,
        startDate,
        weekDay);
    return AddFingerprintEntity.fromJson(res.body);
  }

  // 编辑指纹
  Future<LoginEntity> editFingerprintsData(
      {required String fingerprintId,
      required String lockId,
      required List weekDay,
      required String startDate,
      required String endDate,
      required String isCoerced,
      required String fingerprintName}) async {
    final res = await apiProvider.editFingerprintsData(fingerprintId, lockId,
        weekDay, startDate, endDate, isCoerced, fingerprintName);
    return LoginEntity.fromJson(res.body);
  }

  // 删除指纹
  Future<LoginEntity> deletFingerprintsData(
      {required String fingerprintId,
      required String lockId,
      required String type,
      required String deleteType}) async {
    final res = await apiProvider.deletFingerprintsData(
        fingerprintId, lockId, type, deleteType);
    return LoginEntity.fromJson(res.body);
  }

  // 更新指纹用户序号
  Future<LoginEntity> updateFingerprintUserNoLoadData(
      {required String fingerprintId,
      required String lockId,
      required String fingerprintUserNo}) async {
    final res = await apiProvider.updateFingerprintUserNoLoadData(
        fingerprintId, lockId, fingerprintUserNo);
    return LoginEntity.fromJson(res.body);
  }

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

  // 添加ID卡
  Future<AddICCardEntity> addICCardData({
    required String lockId,
    required String endDate,
    required String cardName,
    required String cardNumber,
    required String cardType,
    required String addType,
    required String startDate,
    required String isCoerced,
    required List weekDay,
  }) async {
    final res = await apiProvider.addICCardData(lockId, endDate, cardName,
        cardNumber, cardType, addType, startDate, isCoerced, weekDay);
    return AddICCardEntity.fromJson(res.body);
  }

  // 编辑IC卡
  Future<LoginEntity> editICCardData(
      {required String lockId,
      required String cardId,
      required String cardName,
      required String startDate,
      required String endDate,
      required String isCoerced,
      required List weekDay}) async {
    final res = await apiProvider.editICCardData(
        lockId, cardId, cardName, startDate, endDate, isCoerced, weekDay);
    return LoginEntity.fromJson(res.body);
  }

  // 删除ic卡
  Future<LoginEntity> deletIcCardData(
      {required String cardId,
      required String lockId,
      required String type,
      required String deleteType}) async {
    final res =
        await apiProvider.deletIcCardData(cardId, lockId, type, deleteType);
    return LoginEntity.fromJson(res.body);
  }

  // 更新ICCard用户序号
  Future<LoginEntity> updateIdCardUserNoLoadData(
      {required String lockId,
      required String cardId,
      required String cardUserNo}) async {
    final res = await apiProvider.updateIdCardUserNoLoadData(
        lockId, cardId, cardUserNo);
    return LoginEntity.fromJson(res.body);
  }

  // 退出登录
  Future<LoginEntity> userLogout() async {
    final res = await apiProvider.userLogout();
    return LoginEntity.fromJson(res.body);
  }

  // 获取转移锁锁列表
  Future<TransferSmartLockEntity> getTransferLockListData() async {
    final res = await apiProvider.getTransferLockListData();
    return TransferSmartLockEntity.fromJson(res.body);
  }

  // 转移智能锁确认
  Future<RecipientInformationEntity> transferLockConfirmInfoData(
      {required String receiverUserid,
      required String type,
      required String countryCode}) async {
    final res = await apiProvider.transferLockConfirmInfoData(
        receiverUserid, type, countryCode);
    return RecipientInformationEntity.fromJson(res.body);
  }

  // 转移智能锁
  Future<RecipientInformationEntity> transferLockInfoData(
      {required String receiverUserid,
      required List lockIdList,
      required String countryCode}) async {
    final res = await apiProvider.transferLockInfoData(
        receiverUserid, lockIdList, countryCode);
    return RecipientInformationEntity.fromJson(res.body);
  }

  // 获取网关列表
  Future<GetewayDataEntity> getGatewayListData(
      {required String pageNo, required String pageSize}) async {
    final res = await apiProvider.getGatewayListData(pageNo, pageSize);
    return GetewayDataEntity.fromJson(res.body);
  }

  // 转移网关确认
  Future<RecipientInformationEntity> transferGatewayConfirmInfoData(
      {required String receiverUserid,
      required String type,
      required String countryCode}) async {
    final res = await apiProvider.transferGatewayConfirmInfoData(
        receiverUserid, type, countryCode);
    return RecipientInformationEntity.fromJson(res.body);
  }

  // 转移智能锁
  Future<RecipientInformationEntity> transferGatewayInfoData(
      {required String receiverUserid,
      required List plugIdList,
      required String countryCode}) async {
    final res = await apiProvider.transferGatewayInfoData(
        receiverUserid, plugIdList, countryCode);
    return RecipientInformationEntity.fromJson(res.body);
  }

  //删除账号
  Future<LoginEntity> deleteAccount(
      String operatorUid, String uniqueid, String verificationCode) async {
    final res = await apiProvider.deleteAccount(
        operatorUid, uniqueid, verificationCode);
    return LoginEntity.fromJson(res.body);
  }

  //获取个人信息
  Future<MinePersonInfoEntity> getUserInfo(String operatorUid) async {
    final res = await apiProvider.getUserInfo(operatorUid);
    return MinePersonInfoEntity.fromJson(res.body);
  }

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

  // 发送验证码 2、登陆后可使用 sendValidationCodeAuth 接口，免图片滑动验证 5删除账号
  Future<SendValidationCodeEntity> getValidationCodeAuth(
      String countryCode,
      String account,
      String channel,
      String codeType,
      String uniqueid,
      String xWidth) async {
    final res = await apiProvider.getValidationCodeAuth(
        countryCode, account, channel, codeType, uniqueid, xWidth);
    return SendValidationCodeEntity.fromJson(res.body);
  }

  //更新个人信息-头像/昵称
  Future<PasswordKeyListEntity> updateUserInfo(String nickname) async {
    final res = await apiProvider.updateUserInfo(nickname);
    return PasswordKeyListEntity.fromJson(res.body);
  }

  //修改绑定手机号
  Future<PasswordKeyListEntity> bindPhone(String countryCode, String account,
      String verificationCode, String unbindToken) async {
    final res = await apiProvider.bindPhone(
        countryCode, account, verificationCode, unbindToken);
    return PasswordKeyListEntity.fromJson(res.body);
  }

  //修改绑定邮箱
  Future<PasswordKeyListEntity> bindEmail(
      String email, String verificationCode, String unbindToken) async {
    final res =
        await apiProvider.bindEmail(email, verificationCode, unbindToken);
    return PasswordKeyListEntity.fromJson(res.body);
  }

  //重置密码
  Future<LoginEntity> changePassword(String date, String newPassword,
      String oldPassword, String operatorUid) async {
    final res = await apiProvider.changePassword(
        date, newPassword, oldPassword, operatorUid);
    return LoginEntity.fromJson(res.body);
  }

  //获取安全信息列表
  Future<MineSetSafetyProblemEntity> getQuestionList(
      String operatorUid, String countryCode) async {
    final res = await apiProvider.getQuestionList(operatorUid, countryCode);
    return MineSetSafetyProblemEntity.fromJson(res.body);
  }

  //获取已设置的安全信息
  Future<MineViewSafetyProblemEntity> getOwnQuestionList() async {
    final res = await apiProvider.getOwnQuestionList();
    return MineViewSafetyProblemEntity.fromJson(res.body);
  }

  //设置安全信息
  Future<LoginEntity> setSafeAnswer(List questionAndAnswerList) async {
    final res = await apiProvider.setSafeAnswer(questionAndAnswerList);
    return LoginEntity.fromJson(res.body);
  }

  //上传头像 先获取upToken 再调用updateUserInfo
  Future<LoginEntity> getUpToken(String type) async {
    final res = await apiProvider.getUpToken(type);
    return LoginEntity.fromJson(res.body);
  }

  //获取解绑手机号Token
  Future<MineUnbindPhoneOrEmailEntity> unbindPhoneToken(
      String verificationCode) async {
    final res = await apiProvider.unbindPhoneToken(verificationCode);
    return MineUnbindPhoneOrEmailEntity.fromJson(res.body);
  }

  //获取解绑邮箱Token
  Future<MineUnbindPhoneOrEmailEntity> unbindEmailToken(
      String verificationCode) async {
    final res = await apiProvider.unbindEmailToken(verificationCode);
    return MineUnbindPhoneOrEmailEntity.fromJson(res.body);
  }
}