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/lockUserManageList/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/card/addICCard/addICCard_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/fingerprint/addFingerprint/addFingerprint_entity.dart';
import '../main/lockDetail/fingerprint/fingerprintList/fingerprintListData_entity.dart';
import '../main/lockDetail/lcokSet/configuringWifi/configuringWifiEntity.dart';
import '../main/lockDetail/lcokSet/lockSet/checkingInInfoData_entity.dart';
import '../main/lockDetail/lcokSet/lockSet/lockSetInfo_entity.dart';
import '../main/lockDetail/lcokSet/lockTime/getServerDatetime_entity.dart';
import '../main/lockDetail/lockDetail/lockNetToken_entity.dart';
import '../main/lockDetail/lockOperatingRecord/lockOperatingRecordGetLastRecordTime_entity.dart';
import '../main/lockMian/entity/lockListInfo_entity.dart';
import '../mine/addLock/saveLock/entity/SaveLockEntity.dart';
import '../mine/minePersonInfo/minePersonInfoPage/minePersonGetUploadFileInfo_entity.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,
      String searchStr) async {
    final res = await apiProvider.electronicKeyList(endDate, keyId, keyStatus,
        lockId, operatorUid, pageNo, pageSize, startDate, keyRight, searchStr);
    return ElectronicKeyListEntity.fromJson(res.body);
  }

  //发送电子钥匙
  Future<AuthorizedAdminSendEntity> sendElectronicKey(
      {required String createUser,
      required String countryCode,
      required String usernameType,
      required String endDate,
      required String faceAuthentication,
      required String isCameraEnable,
      required String isRemoteUnlock,
      required String keyNameForAdmin,
      required String keyRight,
      required String keyType,
      required String lockId,
      required String operatorUid,
      required String receiverUsername,
      required String remarks,
      required String startDate,
      required 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);
  }

  // 获取手机联网token
  Future<LockNetTokenEntity> getLockNetToken({required String lockId}) async {
    final res = await apiProvider.getLockNetToken(lockId);
    return LockNetTokenEntity.fromJson(res.body);
  }

  //  更新锁用户NO
  Future<LockNetTokenEntity> updateLockUserNo({required String keyId, required String lockUserNo}) async {
    final res = await apiProvider.updateLockUserNo(keyId, lockUserNo);
    return LockNetTokenEntity.fromJson(res.body);
  }

  // 绑定蓝牙管理员
  Future<SaveLockEntity> bindingBlueAdmin(
      { required String lockAlias,
        required Map position,
        required Map bluetooth,
        required Map lockInfo,
        required String lockUserNo,
        required String pwdTimestamp,
        required String featureValue,
        required String featureSettingValue,
        required List featureSettingParams}) async {
    final res = await apiProvider.bindingBlueAdmin(
        lockAlias,
        position,
        bluetooth,
        lockInfo,
        lockUserNo,
        pwdTimestamp,
        featureValue,
        featureSettingValue,
        featureSettingParams);
    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(
  {
    required  String keyId,
    required String lockId,
    required String keyName
  }) async {
    final res =
        await apiProvider.modifyKeyName(keyId, lockId, keyName);
    return KeyOperationRecordEntity.fromJson(res.body);
  }

  //修改锁名(新)
  Future<KeyOperationRecordEntity> updateLockName(
      {
        required String lockId,
        required String lockName
      }) async {
    final res =
    await apiProvider.updateLockName(lockId, lockName);
    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 pageNo, String pageSize, String searchStr) async {
    final res = await apiProvider.passwordKeyList(
        keyStatus, lockId, pageNo, pageSize, searchStr);
    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<LockListInfoEntity> getStarLockListInfo(
      {required int pageNo, required int pageSize}) async {
    final res = await apiProvider.getStarLockListInfo(pageNo, pageSize);
    return LockListInfoEntity.fromJson(res.body);
  }

  // 获取所有锁设置信息
  Future<LockSetInfoEntity> getLockSettingInfoData(
      {required String lockId}) async {
    final res = await apiProvider.getLockSettingInfoData(lockId);
    return LockSetInfoEntity.fromJson(res.body);
  }

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

  // 删除钥匙
  Future<LockListInfoEntity> deletOwnerKeyData(
      {required String lockId, required String keyId}) async {
    final res = await apiProvider.deletOwnerKeyInfo(lockId, keyId);
    return LockListInfoEntity.fromJson(res.body);
  }

  // 检查账户密码
  Future<LockListInfoEntity> checkLoginPassword({required String password}) async {
    final res = await apiProvider.checkLoginPassword(password);
    return LockListInfoEntity.fromJson(res.body);
  }

  //获取密码
  Future<PasswordKeyEntity> getPasswordKey(
      {required String endDate,
      required String isExclusive,
      required String keyboardPwdName,
      required String keyboardPwdType,
      required String keyboardPwdVersion,
      required String lockId,
      required String operatorUid,
      required String startDate,
      required String timezoneRawOffSet,
      required int startHours,
      required int endHours,
      required int isCoerced}) async {
    final res = await apiProvider.getKeyboardPwd(
        endDate,
        isExclusive,
        keyboardPwdName,
        keyboardPwdType,
        keyboardPwdVersion,
        lockId,
        operatorUid,
        startDate,
        timezoneRawOffSet,
        startHours,
        endHours,
        isCoerced);
    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(
      {required int lockId,
      required String keyboardPwdId,
      required String keyboardPwdName,
      required String newKeyboardPwd,
      required int startDate,
      required int endDate,
      required String changeType,
      required String isCoerced,
      required int hoursStart,
      required int hoursEnd}) async {
    final res = await apiProvider.updateKeyboardPwd(
        lockId,
        keyboardPwdId,
        keyboardPwdName,
        newKeyboardPwd,
        startDate,
        endDate,
        changeType,
        isCoerced,
        hoursStart,
        hoursEnd);
    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> editLockGroupRequest({
    required int groupId,
    required String groupName
  }) async {
    final res = await apiProvider.editLockGroupRequest(groupId, groupName);
    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<MassSendLockGroupListEntity> deleteGroup(int groupId) async {
    final res =
    await apiProvider.deleteGroup(groupId);
    return MassSendLockGroupListEntity.fromJson(res.body);
  }

  //锁分组里面添加锁
  Future<MassSendLockGroupListEntity> lockGroupAddLock(
  {
    required List lockIds,
    required int groupId
  }) async {
    final res =
    await apiProvider.lockGroupAddLock(lockIds, groupId);
    return MassSendLockGroupListEntity.fromJson(res.body);
  }

  //锁分组里面删除锁
  Future<MassSendLockGroupListEntity> lockGroupDeletLock(
      {
        required List lockIds
      }) async {
    final res =
    await apiProvider.lockGroupDeletLock(lockIds);
    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> keyGroupList111(String type) async {
  //   final res = await apiProvider.keyGroupList(type);
  //   return PasswordKeyEntity.fromJson(res.body);
  // }
  //
  // //分组下的锁
  // Future<PasswordKeyEntity> lockListByGroup111(
  //     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> setAutoUnlock({
    required int lockId,
    required int autoLock,
    required int autoLockSecond,
  }) async {
    final res =
        await apiProvider.setAutoUnlockLoadData(lockId, autoLock, autoLockSecond);
    return LoginEntity.fromJson(res.body);
  }

  // 锁声音
  Future<LoginEntity> setLockSound({
    required int lockId,
    required int lockSound,
    required int lockSoundVolume,
  }) async {
    final res =
    await apiProvider.setLockSoundData(lockId, lockSound, lockSoundVolume);
    return LoginEntity.fromJson(res.body);
  }

  // 防撬报警
  Future<LoginEntity> setBurglarAlarmData({
    required int lockId,
    required int antiPrySwitch,
  }) async {
    final res =
    await apiProvider.setBurglarAlarmData(lockId, antiPrySwitch);
    return LoginEntity.fromJson(res.body);
  }

  // 远程开锁开/关
  Future<LoginEntity> remoteUnlockingOpenOrClose({
    required int lockId,
    required int remoteUnlock,
  }) async {
    final res = await apiProvider.remoteUnlockingOpenOrCloseLoadData(
        lockId, remoteUnlock);
    return LoginEntity.fromJson(res.body);
  }

  // 重置键
  Future<LoginEntity> setResetButtonData({
    required int lockId,
    required int resetSwitch,
  }) async {
    final res = await apiProvider.setResetButtonData(lockId, resetSwitch);
    return LoginEntity.fromJson(res.body);
  }

  // 设置考勤
  Future<LoginEntity> setCheckInData({
    required int lockId,
    required int attendance,
  }) async {
    final res = await apiProvider.setCheckInData(lockId, attendance);
    return LoginEntity.fromJson(res.body);
  }

  // 设置开锁时是否需联网
  Future<LoginEntity> setOpenLockNeedOnlineData({
    required int lockId,
    required int appUnlockOnline,
  }) async {
    final res = await apiProvider.setOpenLockNeedOnlineData(lockId, appUnlockOnline);
    return LoginEntity.fromJson(res.body);
  }

  // 设置开门方向
  Future<LoginEntity> setOpenDoorDirectionData({
    required int lockId,
    required int openDirectionValue,
  }) async {
    final res =
    await apiProvider.setOpenDoorDirectionData(lockId, openDirectionValue);
    return LoginEntity.fromJson(res.body);
  }

  // 设置房态
  Future<LoginEntity> setRoomStatusData({
    required int lockId,
    required int roomStatus,
  }) async {
    final res = await apiProvider.setRoomStatusData(lockId, roomStatus);
    return LoginEntity.fromJson(res.body);
  }

  // 配置锁的常开模式
  Future<LoginEntity> setNormallyModeData({
    required int lockId,
    required int passageMode,
    required List passageModeConfig,
  }) async {
    final res =
    await apiProvider.setNormallyModeData(lockId, passageMode, passageModeConfig);
    return LoginEntity.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<GetServerDatetimeEntity> getLockTimeFromGateway({
    required String lockId,
  }) async {
    final res = await apiProvider.getLockTimeFromGatewayLoadData(lockId);
    return GetServerDatetimeEntity.fromJson(res.body);
  }

  // 设置管理员密码
  Future<GetServerDatetimeEntity> setAdminPasswordData({
    required int lockId,
    required String adminPwd,
  }) async {
    final res = await apiProvider.setAdminPasswordData(lockId, adminPwd);
    return GetServerDatetimeEntity.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<LockUserListEntity> deletLockUser(int uid) async {
    final res = await apiProvider.deletLockUser(uid);
    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 lockIdList) async {
    final res =
        await apiProvider.canSendKey(endDate, 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<CheckingInInfoDataEntity> deletCompanyData(
      {required int companyId}) async {
    final res = await apiProvider.deletCompanyData(companyId);
    return CheckingInInfoDataEntity.fromJson(res.body);
  }

  // 设置锁开锁提醒
  Future<LoginEntity> setLockPickingReminderData({
    required int lockId,
    required int unlockReminderPush,
  }) async {
    final res = await apiProvider.setLockPickingReminderData(lockId, unlockReminderPush);
    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,
      required String changeType}) async {
    final res = await apiProvider.editFingerprintsData(fingerprintId, lockId,
        weekDay, startDate, endDate, isCoerced, fingerprintName, changeType);
    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);
  }

  // 校验指纹名字是否重复
  Future<LoginEntity> checkFingerprintNameDuplicatedData(
      {required String lockId,
        required String fingerprintName}) async {
    final res = await apiProvider.checkFingerprintNameDuplicatedData(
        lockId, fingerprintName);
    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,
      required String changeType}) async {
    final res = await apiProvider.editICCardData(
        lockId, cardId, cardName, startDate, endDate, isCoerced, weekDay, changeType);
    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> checkCardNameDuplicatedData(
      {required String lockId,
        required String cardName}) async {
    final res = await apiProvider.checkCardNameDuplicatedData(
        lockId, cardName);
    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 channel, String verificationCode) async {
    final res = await apiProvider.deleteAccount(channel, 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<MinePersonGetUploadFileInfoEntity> getUpToken(
  {
    required String module,
    required String typeKey,
    required String type,
    required String filename,
    required int size
  }
      ) async {
    final res = await apiProvider.getUpToken(module, typeKey, type, filename, size);
    return MinePersonGetUploadFileInfoEntity.fromJson(res.body);
  }

  // 文件上传
  Future<LoginEntity> uploadFile(
      {
        required String url,
        required dynamic body,
      }) async {
    final res = await apiProvider.uploadFile(url, body);
    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);
  }

  //推送绑定DeviceID
  Future<MineUnbindPhoneOrEmailEntity> pushBindAppId(
      String deviceId, int deviceType) async {
    final res = await apiProvider.pushBindAppId(deviceId, deviceType);
    return MineUnbindPhoneOrEmailEntity.fromJson(res.body);
  }
}