push temp list logic before saving

ios/Podfile.lock

@@ -291,4 +291,4 @@ SPEC CHECKSUMS:
 
 PODFILE CHECKSUM: cf86fcba3fb3dbd505936bc190bb0b8fe3dd2498
 
-COCOAPODS: 1.15.2
+COCOAPODS: 1.14.3

lib/features/scene/bloc/create_scene/create_scene_bloc.dart

@@ -1,5 +1,4 @@
 import 'dart:async';
-
 import 'package:bloc/bloc.dart';
 import 'package:equatable/equatable.dart';
 import 'package:syncrow_app/features/devices/model/device_control_model.dart';
@@ -17,18 +16,56 @@ class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState>
     on<CreateSceneWithTasksEvent>(_createSceneWithTasks);
     on<AddTaskEvent>(_onAddSceneTask);
     on<SelectedValueEvent>(_selectedValue);
-    on<RemoveTaskEvent>(_removeTaskById);
+    on<RemoveTaskByIdEvent>(_removeTaskById);
     on<ClearTaskListEvent>(_clearTaskList);
-    on<FetchSceneTasks>(_fetchSceneTasks);
+    on<ClearTempTaskListEvent>(_clearTempTaskList);
+    on<FetchSceneTasksEvent>(_fetchSceneTasks);
+    on<TempHoldSceneTasksEvent>(_onTempHoldSceneTask);
+    on<RemoveTempTaskByIdEvent>(_removeTempTaskById);
+    on<RemoveFromSelectedValueById>(_removeFromSelectedValueById);
   }
 
   List<SceneStaticFunction> tasksList = [];
-  dynamic selectedValue;
+  List<SceneStaticFunction> tempTasksList = [];
+  final Map<String, dynamic> selectedValues = {};
 
   FutureOr<void> _onAddSceneTask(
       AddTaskEvent event, Emitter<CreateSceneState> emit) {
-    tasksList.add(
+    tasksList = List<SceneStaticFunction>.from(tempTasksList);
-      SceneStaticFunction(
+    emit(AddSceneTask(tasksList: tasksList));
+    tempTasksList.clear();
+    emit(TempHoldSceneTask(tempTasksList: tempTasksList));
+  }
+
+  FutureOr<void> _onTempHoldSceneTask(
+      TempHoldSceneTasksEvent event, Emitter<CreateSceneState> emit) {
+    bool updated = false;
+    for (var element in tempTasksList) {
+      if (element.code == event.deviceControlModel.code) {
+        // Update the existing function with new values
+        var updatedElement = element.copyWith(
+          operationName: event.operation,
+          deviceName: event.deviceName,
+          icon: event.icon,
+          code: event.deviceControlModel.code ?? '',
+          deviceId: event.deviceId,
+          functionValue: event.deviceControlModel.value,
+          operationalValues: [
+            SceneOperationalValue(
+              value: event.deviceControlModel.value,
+              icon: '',
+            ),
+          ],
+        );
+        tempTasksList[tempTasksList.indexOf(element)] = updatedElement;
+        selectedValues[updatedElement.code] = event.deviceControlModel.value;
+        updated = true;
+        break;
+      }
+    }
+    if (!updated) {
+      // Add new function if not found
+      var newElement = SceneStaticFunction(
         operationName: event.operation,
         deviceName: event.deviceName,
         icon: event.icon,
@@ -41,19 +78,22 @@ class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState>
             icon: '',
           ),
         ],
-      ),
+      );
-    );
+      tempTasksList.add(newElement);
-    emit(AddSceneTask(tasksList: tasksList));
+      selectedValues[newElement.code] = event.deviceControlModel.value;
+    }
+
+    emit(TempHoldSceneTask(tempTasksList: tempTasksList));
   }
 
   FutureOr<void> _selectedValue(
       SelectedValueEvent event, Emitter<CreateSceneState> emit) {
-    selectedValue = event.value;
+    selectedValues[event.code] = event.value;
     emit(SelectedTaskValueState(value: event.value));
   }
 
   FutureOr<void> _removeTaskById(
-      RemoveTaskEvent event, Emitter<CreateSceneState> emit) {
+      RemoveTaskByIdEvent event, Emitter<CreateSceneState> emit) {
     emit(CreateSceneLoading());
 
     for (var element in tasksList) {
@@ -66,6 +106,18 @@ class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState>
     }
   }
 
+  FutureOr<void> _removeTempTaskById(
+      RemoveTempTaskByIdEvent event, Emitter<CreateSceneState> emit) {
+    for (var element in tempTasksList) {
+      if (element.code == event.code) {
+        tempTasksList.remove(element);
+
+        emit(TempHoldSceneTask(tempTasksList: tempTasksList));
+        break;
+      }
+    }
+  }
+
   FutureOr<void> _createSceneWithTasks(
       CreateSceneWithTasksEvent event, Emitter<CreateSceneState> emit) async {
     emit(CreateSceneLoading());
@@ -73,6 +125,7 @@ class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState>
       final response = await SceneApi.createScene(event.createSceneModel);
       if (response['success'] == true) {
         tasksList.clear();
+        tempTasksList.clear();
         emit(const CreateSceneWithTasks(success: true));
       } else {
         emit(const CreateSceneError(message: 'Something went wrong'));
@@ -90,14 +143,14 @@ class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState>
   }
 
   FutureOr<void> _fetchSceneTasks(
-      FetchSceneTasks event, Emitter<CreateSceneState> emit) async {
+      FetchSceneTasksEvent event, Emitter<CreateSceneState> emit) async {
     emit(CreateSceneLoading());
 
     try {
       final response = await SceneApi.getSceneDetails(event.sceneId);
       if (response.id.isNotEmpty) {
-        tasksList = getTaskListFunctionsFromApi(
+        tasksList = List.from(getTaskListFunctionsFromApi(
-            actions: response.actions, deviceId: response.id);
+            actions: response.actions, deviceId: response.id));
         emit(AddSceneTask(tasksList: tasksList));
       } else {
         emit(const CreateSceneError(message: 'Something went wrong'));
@@ -106,4 +159,19 @@ class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState>
       emit(CreateSceneError(message: e.toString()));
     }
   }
+
+  FutureOr<void> _clearTempTaskList(
+      ClearTempTaskListEvent event, Emitter<CreateSceneState> emit) {
+    tempTasksList.clear();
+    selectedValues.clear();
+    emit(TempHoldSceneTask(tempTasksList: tempTasksList));
+  }
+
+  FutureOr<void> _removeFromSelectedValueById(
+      RemoveFromSelectedValueById event, Emitter<CreateSceneState> emit) {
+    if (selectedValues.containsKey(event.code)) {
+      selectedValues.remove(event.code);
+      emit(const SelectedTaskValueState(value: null));
+    }
+  }
 }

lib/features/scene/bloc/create_scene/create_scene_event.dart

@@ -8,43 +8,76 @@ sealed class CreateSceneEvent extends Equatable {
 }
 
 class AddTaskEvent extends CreateSceneEvent {
+  @override
+  List<Object> get props => [];
+}
+
+class TempHoldSceneTasksEvent extends CreateSceneEvent {
   final DeviceControlModel deviceControlModel;
   final String deviceId;
   final String icon;
   final String operation;
   final String deviceName;
+  final String uniqueId;
 
-  const AddTaskEvent({
+  const TempHoldSceneTasksEvent({
     required this.deviceControlModel,
     required this.deviceId,
     required this.icon,
     required this.operation,
     required this.deviceName,
+    required this.uniqueId,
   });
 
   @override
-  List<Object> get props =>
+  List<Object> get props => [
-      [deviceControlModel, deviceId, deviceName, icon, operation];
+        deviceControlModel,
+        deviceId,
+        deviceName,
+        icon,
+        operation,
+        uniqueId,
+        deviceName,
+        icon
+      ];
 }
 
 class SelectedValueEvent extends CreateSceneEvent {
   final dynamic value;
+  final String code;
 
-  const SelectedValueEvent({this.value});
+  const SelectedValueEvent({this.value, required this.code});
 
   @override
-  List<Object> get props => [value!];
+  List<Object> get props => [value!, code];
 }
 
-class RemoveTaskEvent extends CreateSceneEvent {
+class RemoveTaskByIdEvent extends CreateSceneEvent {
   final String taskId;
 
-  const RemoveTaskEvent({required this.taskId});
+  const RemoveTaskByIdEvent({required this.taskId});
 
   @override
   List<Object> get props => [taskId];
 }
 
+class RemoveTempTaskByIdEvent extends CreateSceneEvent {
+  final String code;
+  const RemoveTempTaskByIdEvent({required this.code});
+
+  @override
+  List<Object> get props => [code];
+}
+
+class RemoveFromSelectedValueById extends CreateSceneEvent {
+  final String code;
+
+  const RemoveFromSelectedValueById({required this.code});
+
+  @override
+  List<Object> get props => [code];
+}
+
 class CreateSceneWithTasksEvent extends CreateSceneEvent {
   final CreateSceneModel createSceneModel;
   const CreateSceneWithTasksEvent({required this.createSceneModel});
@@ -60,9 +93,16 @@ class ClearTaskListEvent extends CreateSceneEvent {
   List<Object> get props => [];
 }
 
-class FetchSceneTasks extends CreateSceneEvent {
+class ClearTempTaskListEvent extends CreateSceneEvent {
-  final String sceneId;
+  const ClearTempTaskListEvent();
-  const FetchSceneTasks({required this.sceneId});
+
+  @override
+  List<Object> get props => [];
+}
+
+class FetchSceneTasksEvent extends CreateSceneEvent {
+  final String sceneId;
+  const FetchSceneTasksEvent({required this.sceneId});
 
   @override
   List<Object> get props => [];

lib/features/scene/bloc/create_scene/create_scene_state.dart

@@ -27,6 +27,14 @@ class AddSceneTask extends CreateSceneState {
   List<Object> get props => [tasksList];
 }
 
+class TempHoldSceneTask extends CreateSceneState {
+  final List<SceneStaticFunction> tempTasksList;
+  const TempHoldSceneTask({required this.tempTasksList});
+
+  @override
+  List<Object> get props => [tempTasksList];
+}
+
 class SelectedTaskValueState extends CreateSceneState {
   final dynamic value;
   const SelectedTaskValueState({required this.value});

lib/features/scene/bloc/scene_bloc/scene_bloc.dart

@@ -3,7 +3,6 @@ import 'dart:async';
 import 'package:equatable/equatable.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/scene/bloc/scene_bloc/scene_event.dart';
-import 'package:syncrow_app/features/scene/model/create_scene_model.dart';
 import 'package:syncrow_app/features/scene/model/scenes_model.dart';
 import 'package:syncrow_app/services/api/scene_api.dart';
 

lib/features/scene/helper/scene_logic_helper.dart

@@ -3,8 +3,7 @@ import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/app_layout/bloc/home_cubit.dart';
 import 'package:syncrow_app/features/scene/bloc/create_scene/create_scene_bloc.dart';
 import 'package:syncrow_app/features/scene/model/create_scene_model.dart';
-import 'package:syncrow_app/features/scene/model/scene_details_model.dart';
+
-import 'package:syncrow_app/features/scene/model/scenes_model.dart';
 import 'package:syncrow_app/features/scene/model/scene_static_function.dart';
 import 'package:syncrow_app/utils/context_extension.dart';
 

lib/features/scene/helper/scene_operations_data_helper.dart

@@ -1,8 +1,6 @@
 import 'package:syncrow_app/features/devices/model/function_model.dart';
 import 'package:syncrow_app/features/scene/enum/ac_values.dart';
-import 'package:syncrow_app/features/scene/model/create_scene_model.dart';
 import 'package:syncrow_app/features/scene/model/scene_details_model.dart';
-import 'package:syncrow_app/features/scene/model/scenes_model.dart';
 import 'package:syncrow_app/features/scene/model/scene_static_function.dart';
 import 'package:syncrow_app/generated/assets.dart';
 import 'package:syncrow_app/utils/resource_manager/constants.dart';

lib/features/scene/model/scene_static_function.dart

@@ -34,6 +34,7 @@ class SceneStaticFunction {
     String? operationName,
     dynamic functionValue,
     String? deviceIcon,
+    String? deviceName,
   }) {
     return SceneStaticFunction(
       icon: icon ?? this.icon,
@@ -57,6 +58,7 @@ class SceneStaticFunction {
       'operationName': operationName,
       'functionValue': functionValue,
       'deviceIcon': deviceIcon
+      
     };
   }
 

lib/features/scene/view/device_functions_view.dart

@@ -46,6 +46,7 @@ class DeviceFunctionsView extends StatelessWidget
         actions: [
           TextButton(
             onPressed: () {
+              context.read<CreateSceneBloc>().add(AddTaskEvent());
               Navigator.popUntil(context, (route) {
                 return route.settings.name == Routes.sceneTasksRoute;
               });
@@ -58,7 +59,10 @@ class DeviceFunctionsView extends StatelessWidget
           ),
         ],
         leading: TextButton(
-          onPressed: () => Navigator.pop(context),
+          onPressed: () {
+            context.read<CreateSceneBloc>().add(const ClearTaskListEvent());
+            Navigator.pop(context);
+          },
           child: BodyMedium(
             text: 'Cancel',
             fontWeight: FontWeight.normal,
@@ -114,10 +118,16 @@ class DeviceFunctionsView extends StatelessWidget
                             ],
                           ),
                           onPressed: () {
+                            final functionValues = context
+                                .read<CreateSceneBloc>()
+                                .selectedValues[functions[index].code];
                             context.customAlertDialog(
                               alertBody: functions[index].code == 'temp_set'
                                   ? AlertDialogTemperatureBody(
-                                      index: index, functions: functions,)
+                                      index: index,
+                                      functions: functions,
+                                      functionValue: functionValues,
+                                    )
                                   : (functions[index]
                                               .code
                                               .contains('countdown') ||
@@ -128,17 +138,23 @@ class DeviceFunctionsView extends StatelessWidget
                                           durationValue: functions[index]
                                               .operationalValues
                                               .first
-                                              .value)
+                                              .value,
+                                          function: functions[index],
+                                          functionValue: functionValues,
+                                        )
                                       : AlertDialogFunctionsOperationsBody(
-                                          index: index, functions: functions),
+                                          index: index,
+                                          functions: functions,
+                                          functionValue: functionValues,
+                                        ),
                               title: functions[index].operationName,
                               onConfirm: () {
                                 final selectedValue = context
                                     .read<CreateSceneBloc>()
-                                    .selectedValue;
+                                    .selectedValues[functions[index].code];
                                 context
                                     .read<CreateSceneBloc>()
-                                    .add(AddTaskEvent(
+                                    .add(TempHoldSceneTasksEvent(
                                       deviceControlModel: DeviceControlModel(
                                         deviceId: device.uuid,
                                         code: functions[index].code,
@@ -148,9 +164,32 @@ class DeviceFunctionsView extends StatelessWidget
                                       operation: functions[index].operationName,
                                       icon: device.icon ?? '',
                                       deviceName: device.name ?? '',
+                                      uniqueId: functions[index].uniqueCustomId,
                                     ));
                                 Navigator.pop(context);
                               },
+                              onDismiss: () {
+                                final tempTaskList = context
+                                    .read<CreateSceneBloc>()
+                                    .tempTasksList;
+                                if (tempTaskList.isEmpty) {
+                                  context
+                                      .read<CreateSceneBloc>()
+                                      .add(const ClearTempTaskListEvent());
+                                } else {
+                                  for (var element in tempTaskList) {
+                                    if (element.code == functions[index].code) {
+                                      context.read<CreateSceneBloc>().add(
+                                          RemoveTempTaskByIdEvent(
+                                              code: functions[index].code));
+                                      context.read<CreateSceneBloc>().add(
+                                          RemoveFromSelectedValueById(
+                                              code: functions[index].code));
+                                    }
+                                  }
+                                }
+                                Navigator.pop(context);
+                              },
                             );
                           },
                         );

lib/features/scene/widgets/alert_dialogs/alert_dialog_countdown.dart

@@ -1,14 +1,22 @@
+// ignore_for_file: must_be_immutable
+
 import 'package:flutter/cupertino.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/scene/bloc/create_scene/create_scene_bloc.dart';
+import 'package:syncrow_app/features/scene/model/scene_static_function.dart';
 
 class AlertDialogCountdown extends StatefulWidget {
-  AlertDialogCountdown(
+  AlertDialogCountdown({
-      {super.key, required this.durationValue, this.functionValue});
+    super.key,
+    required this.durationValue,
+    this.functionValue,
+    required this.function,
+  });
 
   final int durationValue;
   dynamic functionValue;
+  SceneStaticFunction function;
 
   @override
   State<AlertDialogCountdown> createState() => _AlertDialogCountdownState();
@@ -18,6 +26,17 @@ class _AlertDialogCountdownState extends State<AlertDialogCountdown> {
   @override
   didChangeDependencies() {
     super.didChangeDependencies();
+    final tempTaskList = context.read<CreateSceneBloc>().tempTasksList;
+
+    for (var element in tempTaskList) {
+      if (element.code == widget.function.code) {
+        durationInSeconds = element.functionValue;
+      } else {
+        context
+            .read<CreateSceneBloc>()
+            .add(RemoveFromSelectedValueById(code: widget.function.code));
+      }
+    }
     if (widget.functionValue != null) {
       setState(() {
         durationInSeconds = widget.functionValue;
@@ -41,9 +60,8 @@ class _AlertDialogCountdownState extends State<AlertDialogCountdown> {
           setState(() {
             durationInSeconds = newDuration.inSeconds;
           });
-          context
+          context.read<CreateSceneBloc>().add(SelectedValueEvent(
-              .read<CreateSceneBloc>()
+              value: newDuration.inSeconds, code: widget.function.code));
-              .add(SelectedValueEvent(value: newDuration.inSeconds));
         },
       ),
     );

lib/features/scene/widgets/alert_dialogs/alert_dialog_functions_body.dart

@@ -1,3 +1,5 @@
+// ignore_for_file: must_be_immutable
+
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/scene/bloc/create_scene/create_scene_bloc.dart';
@@ -26,6 +28,19 @@ class _AlertDialogFunctionsOperationsBodyState
   @override
   didChangeDependencies() {
     super.didChangeDependencies();
+    final tempTaskList = context.read<CreateSceneBloc>().tempTasksList;
+    if (tempTaskList.isEmpty) {
+      context.read<CreateSceneBloc>().add(const ClearTempTaskListEvent());
+    }
+
+    for (var element in tempTaskList) {
+      if (element.code == widget.functions[widget.index].code) {
+        groupValue = element.functionValue;
+      } else {
+        context.read<CreateSceneBloc>().add(RemoveFromSelectedValueById(
+            code: widget.functions[widget.index].code));
+      }
+    }
     if (widget.functionValue != null) {
       setState(() {
         groupValue = widget.functionValue;
@@ -60,18 +75,18 @@ class _AlertDialogFunctionsOperationsBodyState
                       setState(() {
                         groupValue = value;
                       });
-                      context
+                      context.read<CreateSceneBloc>().add(SelectedValueEvent(
-                          .read<CreateSceneBloc>()
+                          value: value!,
-                          .add(SelectedValueEvent(value: value!));
+                          code: widget.functions[widget.index].code));
                     },
                   ),
                   onPressed: () {
                     setState(() {
                       groupValue = operation.value;
                     });
-                    context
+                    context.read<CreateSceneBloc>().add(SelectedValueEvent(
-                        .read<CreateSceneBloc>()
+                        value: groupValue,
-                        .add(SelectedValueEvent(value: groupValue));
+                        code: widget.functions[widget.index].code));
                   },
                 );
               },

lib/features/scene/widgets/alert_dialogs/alert_dialog_temperature_body.dart

@@ -1,3 +1,5 @@
+// ignore_for_file: must_be_immutable
+
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:flutter_svg/flutter_svg.dart';
@@ -31,6 +33,16 @@ class _AlertDialogTemperatureBodyState
   @override
   didChangeDependencies() {
     super.didChangeDependencies();
+    final tempTaskList = context.read<CreateSceneBloc>().tempTasksList;
+
+    for (var element in tempTaskList) {
+      if (element.code == widget.functions[widget.index].code) {
+        temperature = element.functionValue;
+      } else {
+        context.read<CreateSceneBloc>().add(RemoveFromSelectedValueById(
+            code: widget.functions[widget.index].code));
+      }
+    }
     if (widget.functionValue != null) {
       setState(() {
         temperature = widget.functionValue;
@@ -50,9 +62,9 @@ class _AlertDialogTemperatureBodyState
                 temperature--;
               }
             });
-            context
+            context.read<CreateSceneBloc>().add(SelectedValueEvent(
-                .read<CreateSceneBloc>()
+                value: temperature * 10,
-                .add(SelectedValueEvent(value: temperature * 10));
+                code: widget.functions[widget.index].code));
           },
           icon: const Icon(
             Icons.remove,
@@ -93,9 +105,9 @@ class _AlertDialogTemperatureBodyState
                 temperature++;
               }
             });
-            context
+            context.read<CreateSceneBloc>().add(SelectedValueEvent(
-                .read<CreateSceneBloc>()
+                value: temperature * 10,
-                .add(SelectedValueEvent(value: temperature * 10));
+                code: widget.functions[widget.index].code));
           },
           icon: const Icon(
             Icons.add,

lib/features/scene/widgets/if_then_containers/then_added_tasks.dart

@@ -1,3 +1,5 @@
+// ignore_for_file: must_be_immutable
+
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:flutter_svg/flutter_svg.dart';
@@ -61,6 +63,7 @@ class ThenAddedTasksContainer extends StatelessWidget {
                       durationValue:
                           listOfSceneStaticFunction![index!].functionValue,
                       functionValue: taskList.functionValue,
+                      function: listOfSceneStaticFunction![index!],
                     )
                   : AlertDialogFunctionsOperationsBody(
                       index: index!,
@@ -69,7 +72,7 @@ class ThenAddedTasksContainer extends StatelessWidget {
           title: listOfSceneStaticFunction![index!].operationName,
           onConfirm: () {
             // final selectedValue = context.read<CreateSceneBloc>().selectedValue;
-            // context.read<CreateSceneBloc>().add(AddTaskEvent(
+            // context.read<CreateSceneBloc>().add(TempHoldSceneTasksEvent(
             //       deviceControlModel: DeviceControlModel(
             //         deviceId: device.uuid,
             //         code: functions[index].code,
@@ -111,7 +114,7 @@ class ThenAddedTasksContainer extends StatelessWidget {
 
           context
               .read<CreateSceneBloc>()
-              .add(RemoveTaskEvent(taskId: removeFunctionById));
+              .add(RemoveTaskByIdEvent(taskId: removeFunctionById));
 
           String removeFunction =
               "${taskList.operationName} with value ${taskList.operationalValues.first.value}";

lib/features/scene/widgets/if_then_containers/then_container.dart

@@ -52,8 +52,8 @@ class ThenDefaultContainer extends StatelessWidget {
           const LightDivider(),
           sceneId.isNotEmpty
               ? BlocProvider(
-                  create: (context) =>
+                  create: (context) => CreateSceneBloc()
-                      CreateSceneBloc()..add(FetchSceneTasks(sceneId: sceneId)),
+                    ..add(FetchSceneTasksEvent(sceneId: sceneId)),
                   child: BlocBuilder<CreateSceneBloc, CreateSceneState>(
                     builder: (context, state) {
                       if (state is CreateSceneLoading) {

lib/features/scene/widgets/scene_view_widget/scene_item.dart

@@ -69,12 +69,14 @@ class SceneItem extends StatelessWidget {
             ],
           ),
           const SizedBox(height: 10),
-          BodyMedium(
+          FittedBox(
-            text: scene.name,
+            child: BodyMedium(
-            maxLines: 1,
+              text: scene.name,
-            overflow: TextOverflow.fade,
+              maxLines: 1,
-            fontWeight: FontWeight.bold,
+              overflow: TextOverflow.fade,
-            fontSize: 16,
+              fontWeight: FontWeight.bold,
+              fontSize: 16,
+            ),
           ),
         ],
       ),

lib/utils/context_extension.dart

@@ -14,7 +14,8 @@ extension ContextExtension on BuildContext {
 
   double get height => MediaQuery.sizeOf(this).height;
 
-  InputDecorationTheme get inputDecoration => Theme.of(this).inputDecorationTheme;
+  InputDecorationTheme get inputDecoration =>
+      Theme.of(this).inputDecorationTheme;
 
   TextStyle get displayLarge => Theme.of(this).textTheme.displayLarge!;
 
@@ -59,8 +60,12 @@ extension ContextExtension on BuildContext {
     );
   }
 
-  void customAlertDialog(
+  void customAlertDialog({
-      {required Widget alertBody, required String title, required VoidCallback onConfirm}) {
+    required Widget alertBody,
+    required String title,
+    required VoidCallback onConfirm,
+    VoidCallback? onDismiss,
+  }) {
     showDialog(
       context: this,
       builder: (BuildContext context) {
@@ -109,13 +114,15 @@ extension ContextExtension on BuildContext {
                   mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                   children: [
                     GestureDetector(
-                      onTap: () {
+                      onTap: onDismiss ??
-                        Navigator.pop(context);
+                          () {
-                      },
+                            Navigator.pop(context);
+                          },
                       child: Center(
                         child: BodyMedium(
                           text: 'Cancel',
-                          style: context.bodyMedium.copyWith(color: ColorsManager.greyColor),
+                          style: context.bodyMedium
+                              .copyWith(color: ColorsManager.greyColor),
                         ),
                       ),
                     ),
@@ -129,8 +136,8 @@ extension ContextExtension on BuildContext {
                       child: Center(
                         child: BodyMedium(
                           text: 'Confirm',
-                          style: context.bodyMedium
+                          style: context.bodyMedium.copyWith(
-                              .copyWith(color: ColorsManager.primaryColorWithOpacity),
+                              color: ColorsManager.primaryColorWithOpacity),
                         ),
                       ),
                     ),