garage door

lib/features/devices/bloc/garage_door_bloc/garage_door_bloc.dart

@@ -0,0 +1,411 @@
+import 'dart:async';
+import 'package:dio/dio.dart';
+import 'package:firebase_database/firebase_database.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:syncrow_app/features/devices/bloc/garage_door_bloc/garage_door_event.dart';
+import 'package:syncrow_app/features/devices/bloc/garage_door_bloc/garage_door_state.dart';
+import 'package:syncrow_app/features/devices/model/device_control_model.dart';
+import 'package:syncrow_app/features/devices/model/device_report_model.dart';
+import 'package:syncrow_app/features/devices/model/garage_door_model.dart';
+import 'package:syncrow_app/features/devices/model/schedule_model.dart';
+import 'package:syncrow_app/features/devices/model/status_model.dart';
+import 'package:syncrow_app/services/api/devices_api.dart';
+import 'package:syncrow_app/utils/helpers/snack_bar.dart';
+
+class GarageDoorBloc extends Bloc<GarageDoorEvent, GarageDoorSensorState> {
+  final String GDId;
+  GarageDoorBloc({
+    required this.GDId,
+  }) : super(const GarageDoorSensorState()) {
+    on<GarageDoorInitial>(_fetchStatus);
+    on<ReportLogsInitial>(fetchLogsForLastMonth);
+    on<ToggleClosingReminderEvent>(_toggleClosingReminder);
+    on<ToggleDoorAlarmEvent>(_toggleDoorAlarm);
+    on<ToggleDaySelectionEvent>(toggleDaySelection);
+    on<ScheduleSaveapp>(saveSchedule);
+    on<GetScheduleEvent>(getSchedule);
+    on<ToggleScheduleEvent>(toggleChange);
+    on<ToggleCreateScheduleEvent>(toggleCreateSchedule);
+    on<OnClose>(_onClose);
+    on<SelectSecondsEvent>(selectSeconds);
+    on<ToggleDoorEvent>(openCloseGarageDoor);
+    on<GetCounterEvent>(_getCounterValue);
+    on<SetCounterValue>(_setCounterValue);
+    on<TickTimer>(_onTickTimer);
+  }
+  void _onClose(OnClose event, Emitter<GarageDoorSensorState> emit) {
+    _timer?.cancel();
+  }
+
+  Timer? _timer;
+  bool lowBattery = false;
+  bool closingReminder = false;
+  bool doorAlarm = false;
+
+  GarageDoorModel deviceStatus = GarageDoorModel(
+    tr_timecon: 0,
+    countdown1: 0,
+    countdownAlarm: 0,
+    doorContactState: false,
+    doorControl1: '',
+    doorState1: '',
+    switch1: false,
+    voiceControl1: false,
+    batteryPercentage: 0,
+  );
+
+  void _fetchStatus(
+      GarageDoorInitial event, Emitter<GarageDoorSensorState> emit) async {
+    emit(GarageDoorLoadingState());
+    try {
+      var response = await DevicesAPI.getDeviceStatus(GDId);
+      List<StatusModel> statusModelList = [];
+      for (var status in response['status']) {
+        statusModelList.add(StatusModel.fromJson(status));
+      }
+      deviceStatus = GarageDoorModel.fromJson(
+        statusModelList,
+      );
+      secondSelected = deviceStatus.tr_timecon;
+      toggleDoor = deviceStatus.switch1;
+      emit(UpdateState(garageSensor: deviceStatus));
+      Future.delayed(const Duration(milliseconds: 500));
+      _listenToChanges();
+    } catch (e) {
+      emit(GarageDoorFailedState(errorMessage: e.toString()));
+      return;
+    }
+  }
+
+  void _toggleClosingReminder(ToggleClosingReminderEvent event,
+      Emitter<GarageDoorSensorState> emit) async {
+    emit(LoadingNewSate(doorSensor: deviceStatus));
+    try {
+      closingReminder = event.isClosingReminderEnabled;
+      emit(UpdateState(garageSensor: deviceStatus));
+      await DevicesAPI.controlDevice(
+        DeviceControlModel(
+          deviceId: GDId,
+          code: 'closing_reminder',
+          value: closingReminder,
+        ),
+        GDId,
+      );
+    } catch (e) {
+      emit(GarageDoorFailedState(errorMessage: e.toString()));
+    }
+  }
+
+  void _toggleDoorAlarm(
+      ToggleDoorAlarmEvent event, Emitter<GarageDoorSensorState> emit) async {
+    emit(LoadingNewSate(doorSensor: deviceStatus));
+    try {
+      doorAlarm = event.isDoorAlarmEnabled;
+      emit(UpdateState(garageSensor: deviceStatus));
+      await DevicesAPI.controlDevice(
+        DeviceControlModel(
+          deviceId: GDId,
+          code: 'door_alarm',
+          value: doorAlarm,
+        ),
+        GDId,
+      );
+    } catch (e) {
+      emit(GarageDoorFailedState(errorMessage: e.toString()));
+    }
+  }
+
+  DeviceReport recordGroups =
+      DeviceReport(startTime: '0', endTime: '0', data: []);
+
+  Future<void> fetchLogsForLastMonth(
+      ReportLogsInitial event, Emitter<GarageDoorSensorState> emit) async {
+    DateTime now = DateTime.now();
+
+    DateTime lastMonth = DateTime(now.year, now.month - 1, now.day);
+    int startTime = lastMonth.millisecondsSinceEpoch;
+    int endTime = now.millisecondsSinceEpoch;
+    try {
+      emit(GarageDoorLoadingState());
+      var response = await DevicesAPI.getReportLogs(
+        startTime: startTime.toString(),
+        endTime: endTime.toString(),
+        deviceUuid: GDId,
+        code: 'doorcontact_state',
+      );
+      recordGroups = response;
+      emit(UpdateState(garageSensor: deviceStatus));
+    } on DioException catch (e) {
+      final errorData = e.response!.data;
+      String errorMessage = errorData['message'];
+      emit(GarageDoorFailedState(errorMessage: errorMessage));
+    }
+  }
+
+  _listenToChanges() {
+    try {
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$GDId');
+      Stream<DatabaseEvent> stream = ref.onValue;
+
+      stream.listen((DatabaseEvent event) async {
+        if (_timer != null) {
+          await Future.delayed(const Duration(seconds: 2));
+        }
+        Map<dynamic, dynamic> usersMap =
+            event.snapshot.value as Map<dynamic, dynamic>;
+        List<StatusModel> statusList = [];
+        usersMap['status'].forEach((element) {
+          statusList.add(StatusModel(code: element['code'], value: true));
+        });
+
+        deviceStatus = GarageDoorModel.fromJson(statusList);
+        if (!isClosed) {
+          // add(
+          //   DoorSensorSwitch(switchD: deviceStatus.doorContactState),
+          // );
+        }
+      });
+    } catch (_) {}
+  }
+
+  List<Map<String, String>> days = [
+    {"day": "Sun", "key": "Sun"},
+    {"day": "Mon", "key": "Mon"},
+    {"day": "Tue", "key": "Tue"},
+    {"day": "Wed", "key": "Wed"},
+    {"day": "Thu", "key": "Thu"},
+    {"day": "Fri", "key": "Fri"},
+    {"day": "Sat", "key": "Sat"},
+  ];
+
+  Future<void> toggleDaySelection(
+    ToggleDaySelectionEvent event,
+    Emitter<GarageDoorSensorState> emit,
+  ) async {
+    emit(GarageDoorLoadingState());
+    if (selectedDays.contains(event.key)) {
+      selectedDays.remove(event.key);
+    } else {
+      selectedDays.add(event.key);
+    }
+    emit(ChangeTimeState());
+  }
+
+  Future<void> saveSchedule(
+    ScheduleSaveapp event,
+    Emitter<GarageDoorSensorState> emit,
+  ) async {
+    try {
+      if (selectedDays.isNotEmpty) {
+        emit(GarageDoorLoadingState());
+        await DevicesAPI.postSchedule(
+            category: 'switch_1',
+            deviceId: GDId,
+            time: getTimeStampWithoutSeconds(selectedTime).toString(),
+            code: 'switch_1',
+            value: toggleSchedule,
+            days: selectedDays);
+        CustomSnackBar.displaySnackBar('Save Successfully');
+        add(GetScheduleEvent());
+      } else {
+        CustomSnackBar.displaySnackBar('Please select days');
+      }
+    } catch (e) {
+      emit(GarageDoorFailedState(errorMessage: e.toString()));
+    }
+  }
+
+  Future<void> getSchedule(
+    GetScheduleEvent event,
+    Emitter<GarageDoorSensorState> emit,
+  ) async {
+    try {
+      emit(GarageDoorLoadingState());
+      final response = await DevicesAPI.getSchedule(
+        category: 'switch_1',
+        deviceId: GDId,
+      );
+      List<dynamic> jsonData = response;
+      listSchedule =
+          jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
+    } on DioException catch (e) {
+      final errorData = e.response!.data;
+      String errorMessage = errorData['message'];
+      emit(GarageDoorFailedState(errorMessage: errorMessage.toString()));
+    }
+  }
+
+  int? getTimeStampWithoutSeconds(DateTime? dateTime) {
+    if (dateTime == null) return null;
+    DateTime dateTimeWithoutSeconds = DateTime(dateTime.year, dateTime.month,
+        dateTime.day, dateTime.hour, dateTime.minute);
+    return dateTimeWithoutSeconds.millisecondsSinceEpoch ~/ 1000;
+  }
+
+  Future toggleChange(
+      ToggleScheduleEvent event, Emitter<GarageDoorSensorState> emit) async {
+    try {
+      emit(GarageDoorLoadingState());
+      final response = await DevicesAPI.changeSchedule(
+          scheduleId: event.id, deviceUuid: GDId, enable: event.toggle);
+      if (response == true) {
+        add(GetScheduleEvent());
+        toggleSchedule = event.toggle;
+        return toggleSchedule;
+      }
+      emit(IsToggleState(onOff: toggleSchedule));
+    } on DioException catch (e) {
+      final errorData = e.response!.data;
+      String errorMessage = errorData['message'];
+      emit(GarageDoorFailedState(errorMessage: errorMessage.toString()));
+    }
+  }
+
+  Future deleteSchedule(
+      DeleteScheduleEvent event, Emitter<GarageDoorSensorState> emit) async {
+    try {
+      emit(GarageDoorLoadingState());
+      final response = await DevicesAPI.deleteSchedule(
+        scheduleId: event.id,
+        deviceUuid: GDId,
+      );
+      if (response == true) {
+        add(GetScheduleEvent());
+        return toggleSchedule;
+      }
+      emit(IsToggleState(onOff: toggleSchedule));
+    } on DioException catch (e) {
+      final errorData = e.response!.data;
+      String errorMessage = errorData['message'];
+      emit(GarageDoorFailedState(errorMessage: errorMessage.toString()));
+    }
+  }
+
+  void toggleSelectedIndex(
+      ToggleSelectedEvent event, Emitter<GarageDoorSensorState> emit) {
+    emit(GarageDoorLoadingState());
+    selectedTabIndex = event.index;
+    emit(ChangeSlidingSegmentState(value: selectedTabIndex));
+  }
+
+  void toggleCreateSchedule(
+      ToggleCreateScheduleEvent event, Emitter<GarageDoorSensorState> emit) {
+    emit(GarageDoorLoadingState());
+    createSchedule = !createSchedule;
+    selectedDays.clear();
+    selectedTime = DateTime.now();
+    emit(UpdateCreateScheduleState(createSchedule));
+  }
+
+  int selectedTabIndex = 0;
+  bool toggleSchedule = true;
+  List<String> selectedDays = [];
+  bool createSchedule = false;
+  List<ScheduleModel> listSchedule = [];
+  DateTime? selectedTime = DateTime.now();
+
+  int secondSelected = 0;
+  bool toggleDoor = false;
+  Future<void> selectSeconds(
+      SelectSecondsEvent event, Emitter<GarageDoorSensorState> emit) async {
+    try {
+      emit(GarageDoorLoadingState());
+      secondSelected = event.seconds;
+
+      final response = await DevicesAPI.controlDevice(
+          DeviceControlModel(
+              deviceId: GDId, code: 'tr_timecon', value: secondSelected),
+          GDId);
+      emit(UpdateState(garageSensor: deviceStatus));
+    } on DioException catch (e) {
+      final errorData = e.response!.data;
+      String errorMessage = errorData['message'];
+      emit(GarageDoorFailedState(errorMessage: errorMessage.toString()));
+    }
+  }
+
+  openCloseGarageDoor(
+      ToggleDoorEvent event, Emitter<GarageDoorSensorState> emit) async {
+    emit(GarageDoorLoadingState());
+    try {
+      toggleDoor = !event.toggle;
+      final response = await DevicesAPI.controlDevice(
+          DeviceControlModel(
+              deviceId: GDId, code: 'switch_1', value: toggleDoor),
+          GDId);
+      add(GarageDoorInitial());
+      emit(UpdateState(garageSensor: deviceStatus));
+    } on DioException catch (e) {
+      final errorData = e.response!.data;
+      String errorMessage = errorData['message'];
+      emit(GarageDoorFailedState(errorMessage: errorMessage.toString()));
+    }
+  }
+
+  void _setCounterValue(
+      SetCounterValue event, Emitter<GarageDoorSensorState> emit) async {
+    emit(LoadingNewSate(doorSensor: deviceStatus));
+    int seconds = 0;
+    try {
+      seconds = event.duration.inSeconds;
+      final response = await DevicesAPI.controlDevice(
+          DeviceControlModel(
+              deviceId: GDId, code: 'countdown_1', value: seconds),
+          GDId);
+
+      if (response['success'] ?? false) {
+        deviceStatus.countdown1 = seconds;
+      } else {
+        emit(GarageDoorFailedState(errorMessage: 'Something went wrong'));
+        return;
+      }
+    } catch (e) {
+      emit(GarageDoorFailedState(errorMessage: e.toString()));
+      return;
+    }
+    if (seconds > 0) {
+      _onStartTimer(seconds);
+    } else {
+      _timer?.cancel();
+      emit(TimerRunComplete());
+    }
+  }
+
+  void _getCounterValue(
+      GetCounterEvent event, Emitter<GarageDoorSensorState> emit) async {
+    emit(LoadingInitialState());
+    try {
+      var response = await DevicesAPI.getDeviceStatus(GDId);
+      List<StatusModel> statusModelList = [];
+      for (var status in response['status']) {
+        statusModelList.add(StatusModel.fromJson(status));
+      }
+      deviceStatus = GarageDoorModel.fromJson(statusModelList);
+      if (event.deviceCode == 'countdown_1') {
+        deviceStatus.countdown1 > 0
+            ? _onStartTimer(deviceStatus.countdown1)
+            : emit(UpdateTimerState(seconds: deviceStatus.countdown1));
+      }
+    } catch (e) {
+      emit(GarageDoorFailedState(errorMessage: e.toString()));
+      return;
+    }
+  }
+
+  void _onStartTimer(int seconds) {
+    _timer?.cancel();
+    _timer = Timer.periodic(const Duration(seconds: 1), (timer) {
+      add(TickTimer(remainingTime: seconds - timer.tick));
+    });
+  }
+
+  void _onTickTimer(TickTimer event, Emitter<GarageDoorSensorState> emit) {
+    if (event.remainingTime > 0) {
+      emit(TimerRunInProgress(event.remainingTime));
+    } else {
+      _timer?.cancel();
+      emit(TimerRunComplete());
+    }
+  }
+}

lib/features/devices/bloc/garage_door_bloc/garage_door_event.dart

@@ -0,0 +1,162 @@
+import 'package:equatable/equatable.dart';
+
+abstract class GarageDoorEvent extends Equatable {
+  const GarageDoorEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class GarageDoorLoading extends GarageDoorEvent {}
+
+class GarageDoorSwitch extends GarageDoorEvent {
+  final bool switchD;
+  final String deviceId;
+  final String productId;
+  const GarageDoorSwitch(
+      {required this.switchD, this.deviceId = '', this.productId = ''});
+
+  @override
+  List<Object> get props => [switchD, deviceId, productId];
+}
+
+class GarageDoorUpdated extends GarageDoorEvent {}
+
+class GarageDoorInitial extends GarageDoorEvent {
+  const GarageDoorInitial();
+}
+
+class ReportLogsInitial extends GarageDoorEvent {
+  const ReportLogsInitial();
+}
+
+class GarageDoorChangeStatus extends GarageDoorEvent {}
+
+class GetCounterEvent extends GarageDoorEvent {
+  final String deviceCode;
+  const GetCounterEvent({required this.deviceCode});
+  @override
+  List<Object> get props => [deviceCode];
+}
+
+class ToggleLowBatteryEvent extends GarageDoorEvent {
+  final bool isLowBatteryEnabled;
+
+  const ToggleLowBatteryEvent(this.isLowBatteryEnabled);
+
+  @override
+  List<Object> get props => [isLowBatteryEnabled];
+}
+
+class ToggleClosingReminderEvent extends GarageDoorEvent {
+  final bool isClosingReminderEnabled;
+
+  const ToggleClosingReminderEvent(this.isClosingReminderEnabled);
+
+  @override
+  List<Object> get props => [isClosingReminderEnabled];
+}
+
+class ToggleDoorAlarmEvent extends GarageDoorEvent {
+  final bool isDoorAlarmEnabled;
+
+  const ToggleDoorAlarmEvent(this.isDoorAlarmEnabled);
+
+  @override
+  List<Object> get props => [isDoorAlarmEnabled];
+}
+
+class SetCounterValue extends GarageDoorEvent {
+  final Duration duration;
+  final String deviceCode;
+  const SetCounterValue({required this.duration, required this.deviceCode});
+  @override
+  List<Object> get props => [duration, deviceCode];
+}
+
+class StartTimer extends GarageDoorEvent {
+  final int duration;
+
+  const StartTimer(this.duration);
+
+  @override
+  List<Object> get props => [duration];
+}
+
+class TickTimer extends GarageDoorEvent {
+  final int remainingTime;
+
+  const TickTimer({required this.remainingTime});
+
+  @override
+  List<Object> get props => [remainingTime];
+}
+
+class StopTimer extends GarageDoorEvent {}
+
+class OnClose extends GarageDoorEvent {}
+
+//------------------- Schedule ----------=---------
+class GetScheduleEvent extends GarageDoorEvent {}
+
+class ScheduleSaveapp extends GarageDoorEvent {}
+
+class ToggleScheduleEvent extends GarageDoorEvent {
+  final String id;
+  final bool toggle;
+  const ToggleScheduleEvent({required this.toggle, required this.id});
+  @override
+  List<Object> get props => [toggle, id];
+}
+
+class ToggleDaySelectionEvent extends GarageDoorEvent {
+  final String key;
+
+  const ToggleDaySelectionEvent({required this.key});
+  @override
+  List<Object> get props => [key];
+}
+
+class DeleteScheduleEvent extends GarageDoorEvent {
+  final String id;
+  const DeleteScheduleEvent({required this.id});
+  @override
+  List<Object> get props => [id];
+}
+
+class ToggleSelectedEvent extends GarageDoorEvent {
+  final int index;
+  const ToggleSelectedEvent({required this.index});
+  @override
+  List<Object> get props => [index];
+}
+
+class ToggleCreateScheduleEvent extends GarageDoorEvent {
+  final int index;
+  const ToggleCreateScheduleEvent({required this.index});
+  @override
+  List<Object> get props => [index];
+}
+
+class ChangeFirstWizardSwitchStatusEvent extends GarageDoorEvent {
+  final bool value;
+  final String deviceId;
+  const ChangeFirstWizardSwitchStatusEvent(
+      {required this.value, this.deviceId = ''});
+  @override
+  List<Object> get props => [value, deviceId];
+}
+
+class SelectSecondsEvent extends GarageDoorEvent {
+  final int seconds;
+  const SelectSecondsEvent({required this.seconds});
+  @override
+  List<Object> get props => [seconds];
+}
+
+class ToggleDoorEvent extends GarageDoorEvent {
+  final bool toggle;
+  const ToggleDoorEvent({required this.toggle});
+  @override
+  List<Object> get props => [toggle];
+}

lib/features/devices/bloc/garage_door_bloc/garage_door_state.dart

@@ -0,0 +1,82 @@
+import 'package:equatable/equatable.dart';
+import 'package:syncrow_app/features/devices/model/garage_door_model.dart';
+
+class GarageDoorSensorState extends Equatable {
+  const GarageDoorSensorState();
+
+  @override
+  List<Object> get props => [];
+}
+
+class GarageDoorInitialState extends GarageDoorSensorState {}
+
+class GarageDoorLoadingState extends GarageDoorSensorState {}
+
+class GarageDoorFailedState extends GarageDoorSensorState {
+  final String errorMessage;
+
+  const GarageDoorFailedState({required this.errorMessage});
+
+  @override
+  List<Object> get props => [errorMessage];
+}
+
+class UpdateState extends GarageDoorSensorState {
+  final GarageDoorModel garageSensor;
+  const UpdateState({required this.garageSensor});
+
+  @override
+  List<Object> get props => [garageSensor];
+}
+
+class LoadingNewSate extends GarageDoorSensorState {
+  final GarageDoorModel doorSensor;
+  const LoadingNewSate({required this.doorSensor});
+
+  @override
+  List<Object> get props => [doorSensor];
+}
+
+class ChangeSlidingSegmentState extends GarageDoorSensorState {
+  final int value;
+
+  const ChangeSlidingSegmentState({required this.value});
+
+  @override
+  List<Object> get props => [value];
+}
+
+class UpdateTimerState extends GarageDoorSensorState {
+  final int seconds;
+  const UpdateTimerState({required this.seconds});
+
+  @override
+  List<Object> get props => [seconds];
+}
+
+class TimerRunInProgress extends GarageDoorSensorState {
+  final int remainingTime;
+
+  const TimerRunInProgress(this.remainingTime);
+
+  @override
+  List<Object> get props => [remainingTime];
+}
+
+class TimerRunComplete extends GarageDoorSensorState {}
+
+class SaveSchedule extends GarageDoorSensorState {}
+
+class IsToggleState extends GarageDoorSensorState {
+  final bool? onOff;
+  const IsToggleState({this.onOff});
+}
+
+class ChangeTimeState extends GarageDoorSensorState {}
+
+class LoadingInitialState extends GarageDoorSensorState {}
+
+class UpdateCreateScheduleState extends GarageDoorSensorState {
+  final bool createSchedule;
+  UpdateCreateScheduleState(this.createSchedule);
+}

lib/features/devices/bloc/one_touch_bloc/one_touch_bloc.dart

@@ -1,7 +1,6 @@
 import 'dart:async';
 import 'package:dio/dio.dart';
 import 'package:firebase_database/firebase_database.dart';
-import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/app_layout/bloc/home_cubit.dart';
 import 'package:syncrow_app/features/devices/bloc/one_touch_bloc/one_touch_state.dart';

lib/features/devices/bloc/three_gang_bloc/three_gang_bloc.dart

@@ -31,7 +31,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
   List<GroupThreeGangModel> groupThreeGangList = [];
   bool allSwitchesOn = true;
 
-  ThreeGangBloc({required this.threeGangId, required this.switchCode}) : super(InitialState()) {
+  ThreeGangBloc({required this.threeGangId, required this.switchCode})
+      : super(InitialState()) {
     on<InitialEvent>(_fetchThreeGangStatus);
     on<ThreeGangUpdated>(_threeGangUpdated);
     on<ChangeFirstSwitchStatusEvent>(_changeFirstSwitch);
@@ -57,7 +58,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
     on<ToggleCreateScheduleEvent>(toggleCreateSchedule);
   }
 
-  void _fetchThreeGangStatus(InitialEvent event, Emitter<ThreeGangState> emit) async {
+  void _fetchThreeGangStatus(
+      InitialEvent event, Emitter<ThreeGangState> emit) async {
     emit(LoadingInitialState());
     try {
       threeGangGroup = event.groupScreen;
@@ -69,7 +71,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
             HomeCubit.getInstance().selectedSpace?.id ?? '', '3G');
 
         for (int i = 0; i < devicesList.length; i++) {
-          var response = await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
+          var response =
+              await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
           List<StatusModel> statusModelList = [];
           for (var status in response['status']) {
             statusModelList.add(StatusModel.fromJson(status));
@@ -86,13 +89,16 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
 
         if (groupThreeGangList.isNotEmpty) {
           groupThreeGangList.firstWhere((element) {
-            if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+            if (!element.firstSwitch ||
+                !element.secondSwitch ||
+                !element.thirdSwitch) {
               allSwitchesOn = false;
             }
             return true;
           });
         }
-        emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: allSwitchesOn));
+        emit(UpdateGroupState(
+            threeGangList: groupThreeGangList, allSwitches: allSwitchesOn));
       } else {
         var response = await DevicesAPI.getDeviceStatus(threeGangId);
         List<StatusModel> statusModelList = [];
@@ -111,18 +117,21 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
 
   _listenToChanges() {
     try {
-      DatabaseReference ref = FirebaseDatabase.instance.ref('device-status/$threeGangId');
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$threeGangId');
       Stream<DatabaseEvent> stream = ref.onValue;
 
-      stream.listen((DatabaseEvent event) async { 
+      stream.listen((DatabaseEvent event) async {
         if (_timer != null) {
           await Future.delayed(const Duration(seconds: 2));
         }
-        Map<dynamic, dynamic> usersMap = event.snapshot.value as Map<dynamic, dynamic>;
+        Map<dynamic, dynamic> usersMap =
+            event.snapshot.value as Map<dynamic, dynamic>;
         List<StatusModel> statusList = [];
 
         usersMap['status'].forEach((element) {
-          statusList.add(StatusModel(code: element['code'], value: element['value']));
+          statusList
+              .add(StatusModel(code: element['code'], value: element['value']));
         });
 
         deviceStatus = ThreeGangModel.fromJson(statusList);
@@ -137,7 +146,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
     emit(UpdateState(threeGangModel: deviceStatus));
   }
 
-  void _changeFirstSwitch(ChangeFirstSwitchStatusEvent event, Emitter<ThreeGangState> emit) async {
+  void _changeFirstSwitch(
+      ChangeFirstSwitchStatusEvent event, Emitter<ThreeGangState> emit) async {
     emit(LoadingNewSate(threeGangModel: deviceStatus));
     try {
       if (threeGangGroup) {
@@ -146,11 +156,14 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
           if (element.deviceId == event.deviceId) {
             element.firstSwitch = !event.value;
           }
-          if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+          if (!element.firstSwitch ||
+              !element.secondSwitch ||
+              !element.thirdSwitch) {
             allSwitchesValue = false;
           }
         });
-        emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
+        emit(UpdateGroupState(
+            threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
       } else {
         deviceStatus.firstSwitch = !event.value;
         emit(UpdateState(threeGangModel: deviceStatus));
@@ -187,11 +200,14 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
           if (element.deviceId == event.deviceId) {
             element.secondSwitch = !event.value;
           }
-          if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+          if (!element.firstSwitch ||
+              !element.secondSwitch ||
+              !element.thirdSwitch) {
             allSwitchesValue = false;
           }
         });
-        emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
+        emit(UpdateGroupState(
+            threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
       } else {
         deviceStatus.secondSwitch = !event.value;
         emit(UpdateState(threeGangModel: deviceStatus));
@@ -217,7 +233,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
     }
   }
 
-  void _changeThirdSwitch(ChangeThirdSwitchStatusEvent event, Emitter<ThreeGangState> emit) async {
+  void _changeThirdSwitch(
+      ChangeThirdSwitchStatusEvent event, Emitter<ThreeGangState> emit) async {
     emit(LoadingNewSate(threeGangModel: deviceStatus));
     try {
       if (threeGangGroup) {
@@ -226,11 +243,14 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
           if (element.deviceId == event.deviceId) {
             element.thirdSwitch = !event.value;
           }
-          if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+          if (!element.firstSwitch ||
+              !element.secondSwitch ||
+              !element.thirdSwitch) {
             allSwitchesValue = false;
           }
         });
-        emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
+        emit(UpdateGroupState(
+            threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
       } else {
         deviceStatus.thirdSwitch = !event.value;
         emit(UpdateState(threeGangModel: deviceStatus));
@@ -269,15 +289,21 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
       final response = await Future.wait([
         DevicesAPI.controlDevice(
             DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_1', value: deviceStatus.firstSwitch),
+                deviceId: threeGangId,
+                code: 'switch_1',
+                value: deviceStatus.firstSwitch),
             threeGangId),
         DevicesAPI.controlDevice(
             DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_2', value: deviceStatus.secondSwitch),
+                deviceId: threeGangId,
+                code: 'switch_2',
+                value: deviceStatus.secondSwitch),
             threeGangId),
         DevicesAPI.controlDevice(
             DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_3', value: deviceStatus.thirdSwitch),
+                deviceId: threeGangId,
+                code: 'switch_3',
+                value: deviceStatus.thirdSwitch),
             threeGangId),
       ]);
 
@@ -303,15 +329,21 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
       final response = await Future.wait([
         DevicesAPI.controlDevice(
             DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_1', value: deviceStatus.firstSwitch),
+                deviceId: threeGangId,
+                code: 'switch_1',
+                value: deviceStatus.firstSwitch),
             threeGangId),
         DevicesAPI.controlDevice(
             DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_2', value: deviceStatus.secondSwitch),
+                deviceId: threeGangId,
+                code: 'switch_2',
+                value: deviceStatus.secondSwitch),
             threeGangId),
         DevicesAPI.controlDevice(
             DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_3', value: deviceStatus.thirdSwitch),
+                deviceId: threeGangId,
+                code: 'switch_3',
+                value: deviceStatus.thirdSwitch),
             threeGangId),
       ]);
 
@@ -333,21 +365,28 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
         groupThreeGangList[i].secondSwitch = true;
         groupThreeGangList[i].thirdSwitch = true;
       }
-      emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: true));
+      emit(UpdateGroupState(
+          threeGangList: groupThreeGangList, allSwitches: true));
 
       for (int i = 0; i < groupThreeGangList.length; i++) {
         final response = await Future.wait([
           DevicesAPI.controlDevice(
               DeviceControlModel(
-                  deviceId: groupThreeGangList[i].deviceId, code: 'switch_1', value: true),
+                  deviceId: groupThreeGangList[i].deviceId,
+                  code: 'switch_1',
+                  value: true),
               groupThreeGangList[i].deviceId),
           DevicesAPI.controlDevice(
               DeviceControlModel(
-                  deviceId: groupThreeGangList[i].deviceId, code: 'switch_2', value: true),
+                  deviceId: groupThreeGangList[i].deviceId,
+                  code: 'switch_2',
+                  value: true),
               groupThreeGangList[i].deviceId),
           DevicesAPI.controlDevice(
               DeviceControlModel(
-                  deviceId: groupThreeGangList[i].deviceId, code: 'switch_3', value: true),
+                  deviceId: groupThreeGangList[i].deviceId,
+                  code: 'switch_3',
+                  value: true),
               groupThreeGangList[i].deviceId),
         ]);
 
@@ -363,7 +402,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
     }
   }
 
-  void _groupAllOff(GroupAllOffEvent event, Emitter<ThreeGangState> emit) async {
+  void _groupAllOff(
+      GroupAllOffEvent event, Emitter<ThreeGangState> emit) async {
     emit(LoadingNewSate(threeGangModel: deviceStatus));
     try {
       for (int i = 0; i < groupThreeGangList.length; i++) {
@@ -371,21 +411,28 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
         groupThreeGangList[i].secondSwitch = false;
         groupThreeGangList[i].thirdSwitch = false;
       }
-      emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: false));
+      emit(UpdateGroupState(
+          threeGangList: groupThreeGangList, allSwitches: false));
 
       for (int i = 0; i < groupThreeGangList.length; i++) {
         final response = await Future.wait([
           DevicesAPI.controlDevice(
               DeviceControlModel(
-                  deviceId: groupThreeGangList[i].deviceId, code: 'switch_1', value: false),
+                  deviceId: groupThreeGangList[i].deviceId,
+                  code: 'switch_1',
+                  value: false),
               groupThreeGangList[i].deviceId),
           DevicesAPI.controlDevice(
               DeviceControlModel(
-                  deviceId: groupThreeGangList[i].deviceId, code: 'switch_2', value: false),
+                  deviceId: groupThreeGangList[i].deviceId,
+                  code: 'switch_2',
+                  value: false),
               groupThreeGangList[i].deviceId),
           DevicesAPI.controlDevice(
               DeviceControlModel(
-                  deviceId: groupThreeGangList[i].deviceId, code: 'switch_3', value: false),
+                  deviceId: groupThreeGangList[i].deviceId,
+                  code: 'switch_3',
+                  value: false),
               groupThreeGangList[i].deviceId),
         ]);
 
@@ -401,17 +448,20 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
     }
   }
 
-  void _changeSliding(ChangeSlidingSegment event, Emitter<ThreeGangState> emit) async {
+  void _changeSliding(
+      ChangeSlidingSegment event, Emitter<ThreeGangState> emit) async {
     emit(ChangeSlidingSegmentState(value: event.value));
   }
 
-  void _setCounterValue(SetCounterValue event, Emitter<ThreeGangState> emit) async {
+  void _setCounterValue(
+      SetCounterValue event, Emitter<ThreeGangState> emit) async {
     emit(LoadingNewSate(threeGangModel: deviceStatus));
     int seconds = 0;
     try {
       seconds = event.duration.inSeconds;
       final response = await DevicesAPI.controlDevice(
-          DeviceControlModel(deviceId: threeGangId, code: event.deviceCode, value: seconds),
+          DeviceControlModel(
+              deviceId: threeGangId, code: event.deviceCode, value: seconds),
           threeGangId);
 
       if (response['success'] ?? false) {
@@ -438,7 +488,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
     }
   }
 
-  void _getCounterValue(GetCounterEvent event, Emitter<ThreeGangState> emit) async {
+  void _getCounterValue(
+      GetCounterEvent event, Emitter<ThreeGangState> emit) async {
     emit(LoadingInitialState());
     try {
       var response = await DevicesAPI.getDeviceStatus(threeGangId);
@@ -541,6 +592,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
     GetScheduleEvent event,
     Emitter<ThreeGangState> emit,
   ) async {
+    print('getSchedule=${switchCode}');
+
     try {
       emit(LoadingInitialState());
       final response = await DevicesAPI.getSchedule(
@@ -548,7 +601,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
         deviceId: threeGangId,
       );
       List<dynamic> jsonData = response;
-      listSchedule = jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
+      listSchedule =
+          jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
       emit(InitialState());
     } on DioException catch (e) {
       final errorData = e.response!.data;
@@ -559,12 +613,13 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
 
   int? getTimeStampWithoutSeconds(DateTime? dateTime) {
     if (dateTime == null) return null;
-    DateTime dateTimeWithoutSeconds =
-        DateTime(dateTime.year, dateTime.month, dateTime.day, dateTime.hour, dateTime.minute);
+    DateTime dateTimeWithoutSeconds = DateTime(dateTime.year, dateTime.month,
+        dateTime.day, dateTime.hour, dateTime.minute);
     return dateTimeWithoutSeconds.millisecondsSinceEpoch ~/ 1000;
   }
 
-  Future toggleChange(ToggleScheduleEvent event, Emitter<ThreeGangState> emit) async {
+  Future toggleChange(
+      ToggleScheduleEvent event, Emitter<ThreeGangState> emit) async {
     try {
       emit(LoadingInitialState());
       final response = await DevicesAPI.changeSchedule(
@@ -583,7 +638,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
     }
   }
 
-  Future deleteSchedule(DeleteScheduleEvent event, Emitter<ThreeGangState> emit) async {
+  Future deleteSchedule(
+      DeleteScheduleEvent event, Emitter<ThreeGangState> emit) async {
     try {
       emit(LoadingInitialState());
       final response = await DevicesAPI.deleteSchedule(
@@ -603,13 +659,15 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
     }
   }
 
-  void toggleSelectedIndex(ToggleSelectedEvent event, Emitter<ThreeGangState> emit) {
+  void toggleSelectedIndex(
+      ToggleSelectedEvent event, Emitter<ThreeGangState> emit) {
     emit(LoadingInitialState());
     selectedTabIndex = event.index;
     emit(ChangeSlidingSegmentState(value: selectedTabIndex));
   }
 
-  void toggleCreateSchedule(ToggleCreateScheduleEvent event, Emitter<ThreeGangState> emit) {
+  void toggleCreateSchedule(
+      ToggleCreateScheduleEvent event, Emitter<ThreeGangState> emit) {
     emit(LoadingInitialState());
     createSchedule = !createSchedule;
     selectedDays.clear();