push connecting to automation api

lib/pages/routiens/bloc/routine_bloc/routine_bloc.dart

@@ -3,7 +3,8 @@ import 'dart:async';
 import 'package:bloc/bloc.dart';
 import 'package:equatable/equatable.dart';
 import 'package:flutter/material.dart';
-import 'package:syncrow_web/pages/routiens/models/create_scene/create_scene_model.dart';
+import 'package:syncrow_web/pages/routiens/models/create_scene_and_autoamtion/create_automation_model.dart';
+import 'package:syncrow_web/pages/routiens/models/create_scene_and_autoamtion/create_scene_model.dart';
 import 'package:syncrow_web/pages/routiens/models/device_functions.dart';
 import 'package:syncrow_web/pages/routiens/models/routine_model.dart';
 import 'package:syncrow_web/services/routines_api.dart';
@@ -28,6 +29,8 @@ class RoutineBloc extends Bloc<RoutineEvent, RoutineState> {
     on<CreateSceneEvent>(_onCreateScene);
     on<RemoveDragCard>(_onRemoveDragCard);
     on<ChangeAutomationOperator>(_changeOperatorOperator);
+    on<EffectiveTimePeriodEvent>(_onEffectiveTimeEvent);
+    on<CreateAutomationEvent>(_onCreateAutomation);
     // on<RemoveFunction>(_onRemoveFunction);
     // on<ClearFunctions>(_onClearFunctions);
   }
@@ -213,10 +216,119 @@ class RoutineBloc extends Bloc<RoutineEvent, RoutineState> {
     }
   }
 
+  Future<void> _onCreateAutomation(
+      CreateAutomationEvent event, Emitter<RoutineState> emit) async {
+    try {
+      if (state.routineName == null || state.routineName!.isEmpty) {
+        emit(state.copyWith(
+          errorMessage: 'Automation name is required',
+        ));
+        return;
+      }
+
+      emit(state.copyWith(isLoading: true));
+
+      final conditions = state.ifItems
+          .map((item) {
+            final functions =
+                state.selectedFunctions[item['uniqueCustomId']] ?? [];
+            if (functions.isEmpty) return null;
+
+            final function = functions.first;
+            return CreateCondition(
+              code: state.ifItems.indexOf(item) + 1,
+              entityId: function.entityId,
+              entityType: 'device_report',
+              expr: ConditionExpr(
+                statusCode: function.functionCode,
+                comparator: function.condition ?? '==',
+                statusValue: function.value,
+              ),
+            );
+          })
+          .whereType<CreateCondition>()
+          .toList();
+
+      if (conditions.isEmpty) {
+        emit(state.copyWith(
+          isLoading: false,
+          errorMessage: 'At least one condition is required',
+        ));
+        return;
+      }
+
+      final createAutomationModel = CreateAutomationModel(
+        unitUuid: spaceId,
+        automationName: state.routineName!,
+        decisionExpr: state.selectedAutomationOperator,
+        effectiveTime: state.effectiveTime ??
+            EffectiveTime(
+              start: '00:00',
+              end: '23:59',
+              loops: '1111111',
+            ),
+        conditions: conditions,
+        actions: state.thenItems
+            .map((item) {
+              final functions =
+                  state.selectedFunctions[item['uniqueCustomId']] ?? [];
+              if (functions.isEmpty) return null;
+
+              final function = functions.first;
+              if (function.functionCode == 'automation') {
+                return CreateSceneAction(
+                  entityId: function.entityId,
+                  actionExecutor: function.value,
+                  executorProperty: null,
+                );
+              }
+
+              if (item['deviceId'] == 'delay') {
+                return CreateSceneAction(
+                  entityId: function.entityId,
+                  actionExecutor: 'delay',
+                  executorProperty: CreateSceneExecutorProperty(
+                    functionCode: '',
+                    functionValue: '',
+                    delaySeconds: function.value,
+                  ),
+                );
+              }
+
+              return CreateSceneAction(
+                entityId: function.entityId,
+                actionExecutor: 'device_issue',
+                executorProperty: CreateSceneExecutorProperty(
+                  functionCode: function.functionCode,
+                  functionValue: function.value,
+                  delaySeconds: 0,
+                ),
+              );
+            })
+            .whereType<CreateSceneAction>()
+            .toList(),
+      );
+
+      final result = await SceneApi.createAutomation(createAutomationModel);
+      if (result['success']) {
+        emit(const RoutineState());
+      } else {
+        emit(state.copyWith(
+          isLoading: false,
+          errorMessage: result['message'],
+        ));
+      }
+    } catch (e) {
+      emit(state.copyWith(
+        isLoading: false,
+        errorMessage: e.toString(),
+      ));
+    }
+  }
+
   FutureOr<void> _onRemoveDragCard(
       RemoveDragCard event, Emitter<RoutineState> emit) {
     if (event.isFromThen) {
-      /// remove element from thenItems at specific index
       final thenItems = List<Map<String, dynamic>>.from(state.thenItems);
       thenItems.removeAt(event.index);
       emit(state.copyWith(thenItems: thenItems));
@@ -233,4 +345,9 @@ class RoutineBloc extends Bloc<RoutineEvent, RoutineState> {
       selectedAutomationOperator: event.operator,
     ));
   }
+
+  FutureOr<void> _onEffectiveTimeEvent(
+      EffectiveTimePeriodEvent event, Emitter<RoutineState> emit) {
+    emit(state.copyWith(effectiveTime: event.effectiveTime));
+  }
 }