All files / src/utils/execution executeTask.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
import { store } from "../../store/index.ts";
import { updateCardById } from "./updateCardById.ts";
import {
  currentPlaybookSelector,
  popFromExecutionStack,
} from "../../store/features/playbook/playbookSlice.ts";
import getCurrentTask from "../playbook/task/getCurrentTask.ts";
import { executionTaskExecute } from "../../store/features/playbook/api/executions/executionTaskExecuteApi.ts";
import checkId from "../common/checkId.ts";
import updateStepById from "../playbook/step/updateStepById.ts";
import { executionBulkTaskExecute } from "../../store/features/playbook/api/executions/executionBulkTaskExecuteApi.ts";
import { extractTimeFromHours } from "../../components/Playbooks/task/taskConfiguration/comparison/utils/extractTimeFromHours.ts";
import { setCurrentVisibleTaskFunction } from "../playbook/task/setCurrentVisibleTaskFunction.ts";
 
export async function executeTask(id?: string) {
  const [task] = getCurrentTask(id);
  const currentPlaybook = currentPlaybookSelector(store.getState());
  Iif (!task) return;
  const dispatch = store.dispatch;
  Iif (Object.keys(task?.ui_requirement.errors ?? {}).length > 0) {
    updateCardById("ui_requirement.showError", true, id);
    return;
  }
  const isBulk = task.execution_configuration.is_bulk_execution;
 
  const stepId = task.ui_requirement.stepId;
  updateStepById("ui_requirement.outputLoading", true, stepId);
  updateStepById("ui_requirement.showOutput", false, stepId);
  updateStepById("ui_requirement.outputError", undefined, stepId);
  updateStepById("ui_requirement.showError", false, stepId);
 
  updateCardById("ui_requirement.outputLoading", true, id);
  updateCardById("ui_requirement.showOutput", false, id);
  updateCardById("ui_requirement.outputError", undefined, id);
  updateCardById("ui_requirement.showError", false, id);
 
  dispatch(popFromExecutionStack());
 
  try {
    const res = await store
      .dispatch(
        isBulk
          ? executionBulkTaskExecute.initiate({
              ...task,
              id: checkId(task.id!),
              ui_requirement: undefined,
              global_variable_set: currentPlaybook?.global_variable_set,
              execution_configuration: task.execution_configuration
                ? {
                    ...task.execution_configuration,
                    timeseries_offsets: task?.execution_configuration
                      ?.timeseries_offsets?.[0]
                      ? [
                          extractTimeFromHours(
                            task?.execution_configuration
                              ?.timeseries_offsets?.[0],
                          ),
                        ]
                      : undefined,
                  }
                : {},
            })
          : executionTaskExecute.initiate({
              ...task,
              id: checkId(task.id!),
              ui_requirement: undefined,
              global_variable_set: currentPlaybook?.global_variable_set,
              execution_configuration: task.execution_configuration
                ? {
                    ...task.execution_configuration,
                    timeseries_offsets: task?.execution_configuration
                      ?.timeseries_offsets?.[0]
                      ? [
                          extractTimeFromHours(
                            task?.execution_configuration
                              ?.timeseries_offsets?.[0],
                          ),
                        ]
                      : undefined,
                  }
                : {},
            }),
      )
      .unwrap();
 
    const outputs = isBulk
      ? res?.playbook_task_execution_logs
      : [res?.playbook_task_execution_log];
 
    const list: any = [];
 
    outputs.forEach((output) => {
      const outputError = output?.result?.error;
 
      updateCardById("ui_requirement.showOutput", true, id);
      list.push({
        data: { ...output?.result, timestamp: output?.timestamp },
        error: outputError ? outputError : undefined,
        interpretation: output?.interpretation,
        execution_global_variable_set: output?.execution_global_variable_set,
      });
      Iif (outputError) {
        updateCardById("ui_requirement.showError", true, id);
      }
    });
    updateCardById("ui_requirement.outputs", list, id);
  } catch (e: any) {
    updateCardById("ui_requirement.showError", true, id);
    updateCardById("ui_requirement.outputError", e.message, id);
    console.error(e);
  } finally {
    updateCardById("ui_requirement.showOutput", true, id);
    updateCardById("ui_requirement.outputLoading", false, id);
 
    updateStepById("ui_requirement.showOutput", true, stepId);
    updateStepById("ui_requirement.outputLoading", false, stepId);
    setCurrentVisibleTaskFunction(id ?? "");
  }
}