changing ac bloc

lib/pages/device_managment/ac/bloc/ac_bloc.dart

@@ -1,16 +1,31 @@
-
 import 'dart:async';
 import 'package:bloc/bloc.dart';
 import 'package:syncrow_web/pages/device_managment/ac/bloc/ac_event.dart';
 import 'package:syncrow_web/pages/device_managment/ac/bloc/ac_state.dart';
+import 'package:syncrow_web/pages/device_managment/ac/model/ac_model.dart';
+import 'package:syncrow_web/pages/device_managment/all_devices/models/device_status.dart';
 import 'package:syncrow_web/services/devices_mang_api.dart';
 
-
 class AcBloc extends Bloc<AcsEvent, AcsState> {
+  AcStatusModel deviceStatus = AcStatusModel(
+    uuid: '',
+    acSwitch: true,
+    modeString: 'hot',
+    tempSet: 300,
+    currentTemp: 315,
+    fanSpeedsString: 'low',
+    childLock: false,
+  );
 
   AcBloc() : super(AcsInitialState()) {
     on<AcFetchDeviceStatus>(_onFetchAcStatus);
-
+    on<AcControl>(_onAcControl);
+    on<AcSwitch>(_changeAcSwitch);
+    on<IncreaseCoolToTemp>(_increaseCoolTo);
+    on<DecreaseCoolToTemp>(_decreaseCoolTo);
+    on<ChangeLock>(_changeLockValue);
+    on<ChangeAcMode>(_changeAcMode);
+    on<ChangeFanSpeed>(_changeFanSpeed);
   }
 
   FutureOr<void> _onFetchAcStatus(
@@ -18,11 +33,121 @@ class AcBloc extends Bloc<AcsEvent, AcsState> {
     emit(AcsLoadingState());
     try {
       final status =
-      await DevicesManagementApi().getDeviceStatus(event.deviceId);
-      emit(ACStatusLoaded(status));
+          await DevicesManagementApi().getDeviceStatus(event.deviceId);
+      deviceStatus = AcStatusModel.fromJson(status.productUuid, status.status);
+      emit(ACStatusLoaded(deviceStatus));
     } catch (e) {
-      emit(AcsFailedState( error: e.toString()));
+      emit(AcsFailedState(error: e.toString()));
     }
   }
 
+  FutureOr<void> _onAcControl(AcControl event, Emitter<AcsState> emit) async {
+    final oldValue = _getValueByCode(event.code);
+
+    _updateLocalValue(event.code, event.value);
+    emit(ACStatusLoaded(deviceStatus));
+
+    try {
+      final status = Status(code: event.code, value: event.value);
+      final response =
+          await DevicesManagementApi().deviceControl(event.deviceId, status);
+
+      if (!response) {
+        _updateLocalValue(event.code, oldValue);
+        emit(ACStatusLoaded(deviceStatus));
+        emit(AcsFailedState(error: 'Failed to control the device.'));
+      }
+    } catch (e) {
+      _updateLocalValue(event.code, oldValue);
+      emit(ACStatusLoaded(deviceStatus));
+      emit(AcsFailedState(error: 'Error controlling the device: $e'));
+    }
+  }
+
+  void _updateLocalValue(String code, dynamic value) {
+    switch (code) {
+      case 'switch':
+        deviceStatus.acSwitch = value;
+        break;
+      case 'temp_set':
+        deviceStatus.tempSet = value;
+        break;
+      case 'mode':
+        deviceStatus.modeString = value;
+        deviceStatus.acMode = AcStatusModel.getACMode(value);
+        break;
+      case 'level':
+        deviceStatus.fanSpeedsString = value;
+        deviceStatus.acFanSpeed = AcStatusModel.getFanSpeed(value);
+        break;
+      case 'child_lock':
+        deviceStatus.childLock = value;
+        break;
+      default:
+        break;
+    }
+  }
+
+  dynamic _getValueByCode(String code) {
+    switch (code) {
+      case 'switch':
+        return deviceStatus.acSwitch;
+      case 'temp_set':
+        return deviceStatus.tempSet;
+      case 'mode':
+        return deviceStatus.modeString;
+      case 'level':
+        return deviceStatus.fanSpeedsString;
+      case 'child_lock':
+        return deviceStatus.childLock;
+      default:
+        return null;
+    }
+  }
+
+  FutureOr<void> _changeAcSwitch(AcSwitch event, Emitter<AcsState> emit) async {
+    final newValue = !event.acSwitch;
+    add(AcControl(deviceId: event.deviceId, code: 'switch', value: newValue));
+  }
+
+  FutureOr<void> _increaseCoolTo(
+      IncreaseCoolToTemp event, Emitter<AcsState> emit) async {
+    final newValue = (event.value * 10).toInt() + 5;
+    if (_isValidTemperature(newValue)) {
+      add(AcControl(
+          deviceId: event.deviceId, code: 'temp_set', value: newValue));
+    }
+  }
+
+  FutureOr<void> _decreaseCoolTo(
+      DecreaseCoolToTemp event, Emitter<AcsState> emit) async {
+    final newValue = (event.value * 10).toInt() - 5;
+    if (_isValidTemperature(newValue)) {
+      add(AcControl(
+          deviceId: event.deviceId, code: 'temp_set', value: newValue));
+    }
+  }
+
+  FutureOr<void> _changeLockValue(
+      ChangeLock event, Emitter<AcsState> emit) async {
+    final newValue = !event.lockBool;
+    add(AcControl(
+        deviceId: event.deviceId, code: 'child_lock', value: newValue));
+  }
+
+  FutureOr<void> _changeAcMode(
+      ChangeAcMode event, Emitter<AcsState> emit) async {
+    final newValue = AcStatusModel.getACMode(event.tempModes.name);
+    add(AcControl(deviceId: event.deviceId, code: 'mode', value: newValue));
+  }
+
+  FutureOr<void> _changeFanSpeed(
+      ChangeFanSpeed event, Emitter<AcsState> emit) async {
+    final newValue = AcStatusModel.getFanSpeed(event.fanSpeeds.name);
+    add(AcControl(deviceId: event.deviceId, code: 'level', value: newValue));
+  }
+
+  bool _isValidTemperature(int value) {
+    return value >= 200 && value <= 300;
+  }
 }

lib/pages/device_managment/ac/bloc/ac_event.dart

@@ -1,6 +1,5 @@
-
-
 import 'package:equatable/equatable.dart';
+import 'package:syncrow_web/pages/device_managment/ac/model/ac_model.dart';
 
 sealed class AcsEvent extends Equatable {
   const AcsEvent();
@@ -21,12 +20,74 @@ class AcFetchDeviceStatus extends AcsEvent {
 class AcControl extends AcsEvent {
   final String deviceId;
   final String code;
-  final bool value;
+  final dynamic value;
 
-  const AcControl(
-      {required this.deviceId, required this.code, required this.value});
+  const AcControl({
+    required this.deviceId,
+    required this.code,
+    required this.value,
+  });
 
   @override
   List<Object> get props => [deviceId, code, value];
 }
 
+class AcSwitch extends AcsEvent {
+  final bool acSwitch;
+  final String deviceId;
+
+  const AcSwitch({required this.acSwitch, required this.deviceId});
+
+  @override
+  List<Object> get props => [acSwitch, deviceId];
+}
+
+class IncreaseCoolToTemp extends AcsEvent {
+  final double value;
+  final String deviceId;
+
+  const IncreaseCoolToTemp({required this.value, required this.deviceId});
+
+  @override
+  List<Object> get props => [value, deviceId];
+}
+
+class DecreaseCoolToTemp extends AcsEvent {
+  final double value;
+  final String deviceId;
+
+  const DecreaseCoolToTemp({required this.value, required this.deviceId});
+
+  @override
+  List<Object> get props => [value, deviceId];
+}
+
+class ChangeLock extends AcsEvent {
+  final bool lockBool;
+  final String deviceId;
+
+  const ChangeLock({required this.lockBool, required this.deviceId});
+
+  @override
+  List<Object> get props => [lockBool, deviceId];
+}
+
+class ChangeAcMode extends AcsEvent {
+  final TempModes tempModes;
+  final String deviceId;
+
+  const ChangeAcMode({required this.tempModes, required this.deviceId});
+
+  @override
+  List<Object> get props => [tempModes, deviceId];
+}
+
+class ChangeFanSpeed extends AcsEvent {
+  final FanSpeeds fanSpeeds;
+  final String deviceId;
+
+  const ChangeFanSpeed({required this.fanSpeeds, required this.deviceId});
+
+  @override
+  List<Object> get props => [fanSpeeds, deviceId];
+}

lib/pages/device_managment/ac/bloc/ac_state.dart

@@ -1,7 +1,5 @@
 import 'package:equatable/equatable.dart';
 import 'package:syncrow_web/pages/device_managment/ac/model/ac_model.dart';
-import 'package:syncrow_web/pages/device_managment/all_devices/models/device_status.dart';
-import 'package:syncrow_web/pages/visitor_password/model/device_model.dart';
 
 abstract class AcsState extends Equatable {
   const AcsState();
@@ -14,9 +12,8 @@ class AcsInitialState extends AcsState {}
 
 class AcsLoadingState extends AcsState {}
 
-
 class ACStatusLoaded extends AcsState {
-  final DeviceStatus status;
+  final AcStatusModel status;
 
   const ACStatusLoaded(this.status);
 
@@ -24,46 +21,49 @@ class ACStatusLoaded extends AcsState {
   List<Object> get props => [status];
 }
 
-class AcChangeLoading extends AcsState {
-  final AcStatusModel acStatusModel;
-  const AcChangeLoading({required this.acStatusModel});
+class AcSwitchChanged extends AcsState {
+  final bool acSwitch;
+
+  const AcSwitchChanged(this.acSwitch);
 
   @override
-  List<Object> get props => [acStatusModel];
+  List<Object> get props => [acSwitch];
 }
 
-class AcModifyingState extends AcsState {
-  final AcStatusModel acStatusModel;
-  const AcModifyingState({required this.acStatusModel});
+class AcTempChanged extends AcsState {
+  final double tempSet;
+
+  const AcTempChanged(this.tempSet);
 
   @override
-  List<Object> get props => [acStatusModel];
+  List<Object> get props => [tempSet];
 }
 
-class GetAcStatusState extends AcsState {
-  final AcStatusModel acStatusModel;
-  const GetAcStatusState({required this.acStatusModel});
+class AcModeChanged extends AcsState {
+  final TempModes mode;
+
+  const AcModeChanged(this.mode);
 
   @override
-  List<Object> get props => [acStatusModel];
+  List<Object> get props => [mode];
 }
 
-class GetAllAcsStatusState extends AcsState {
-  final List<AcStatusModel> allAcsStatues;
-  final List<DeviceModel> allAcs;
-  final bool allOn;
-  final bool allTempSame;
-  final int temp;
+class AcFanSpeedChanged extends AcsState {
+  final FanSpeeds fanSpeed;
 
-  const GetAllAcsStatusState(
-      {required this.allAcsStatues,
-        required this.allAcs,
-        required this.allOn,
-        required this.allTempSame,
-        required this.temp});
+  const AcFanSpeedChanged(this.fanSpeed);
 
   @override
-  List<Object> get props => [allAcsStatues, allAcs, allAcs, allTempSame, temp];
+  List<Object> get props => [fanSpeed];
+}
+
+class AcLockChanged extends AcsState {
+  final bool lock;
+
+  const AcLockChanged(this.lock);
+
+  @override
+  List<Object> get props => [lock];
 }
 
 class AcsFailedState extends AcsState {