Files
Shortumation/webapp/src/components/DAGGraph/updater/index.ts
T
ari e769a8e798 clean up
added mock large qty autos
2022-07-15 12:37:10 -04:00

404 lines
11 KiB
TypeScript

import {
AutomationActionData,
AutomationSequenceNode,
} from "types/automations";
import { ModalState } from "../board/types";
import { SequenceNodeActions } from "../nodes/SequenceNode/types";
import { DAGUpdaterArgs, DAGUpdaterInput } from "./types";
import { mapAutoActionKeyToNodeType } from "./util";
import {
ChooseAction,
RepeatAction,
ParallelAction,
} from "types/automations/actions";
import { convertScriptConditionFieldToAutomationConditions } from "utils/automations";
import { AutomationNode } from "types/automations";
export const createBasicUpdater =
<K extends keyof AutomationActionData, N extends AutomationActionData[K][0]>(
k: K,
defaultNode: AutomationActionData[K][0]
) =>
(args: DAGUpdaterArgs<K>) => {
return {
get defaultNode() {
return JSON.parse(JSON.stringify(defaultNode));
},
setEnabled: (i: number) =>
args[k].onUpdate([
...args[k].data.slice(0, i),
{ ...args[k].data[i], enabled: !(args[k].data[i].enabled ?? true) },
...args[k].data.slice(i + 1),
]),
updateNode: (n: N, i: number) =>
args[k].onUpdate([
...args[k].data.slice(0, i),
n,
...args[k].data.slice(i + 1),
]),
deleteNode: (i: number) =>
args[k].onUpdate([
...args[k].data.slice(0, i),
...args[k].data.slice(i + 1),
]),
addNode: (afterIndex: number | null) =>
args.openModal({
allowedTypes: mapAutoActionKeyToNodeType(k),
saveBtnCreateText: true,
node: JSON.parse(JSON.stringify(defaultNode)),
update: (n) => {
if (afterIndex !== null) {
args[k].onUpdate([
...args[k].data.slice(0, afterIndex),
n,
...args[k].data.slice(afterIndex),
]);
} else {
args[k].onUpdate([...args[k].data, n]);
}
},
}),
onMove: (i: number, direction: "back" | "forward") => {
if (direction === "back" && i > 0) {
return args[k].onUpdate([
...args[k].data.slice(0, i - 1),
args[k].data[i],
args[k].data[i - 1],
...args[k].data.slice(i + 1),
]);
} else if (direction === "forward" && i < args[k].data.length - 1) {
return args[k].onUpdate([
...args[k].data.slice(0, i),
args[k].data[i + 1],
args[k].data[i],
...args[k].data.slice(i + 2),
]);
}
},
};
};
export const createDummyUpdater = (): DAGUpdaterInput<any> => ({
data: [],
onUpdate: console.warn,
});
// export const createScriptConditionFieldUpdater = (f: ScriptConditionField, )
export type DAGGraphUpdater = ReturnType<typeof createUpdater>;
export type DAGGraphChooseUpdater = ReturnType<
DAGGraphUpdater["createChoosNodeUpdater"]
>;
export const createUpdater = (
args: DAGUpdaterArgs<"sequence" | "condition" | "trigger">
) => {
const basic = {
sequence: createBasicUpdater("sequence", {
device_id: "",
})({
sequence: args.sequence,
openModal: args.openModal,
}),
trigger: createBasicUpdater("trigger", {
platform: "device",
})({
trigger: args.trigger,
openModal: args.openModal,
} as any),
condition: createBasicUpdater("condition", {
condition: "device",
device_id: "",
domain: "",
type: "",
})({
condition: args.condition,
openModal: args.openModal,
} as any),
};
return {
basic,
createNodeActions<K extends keyof AutomationActionData>(
k: K,
i: number,
flags: Partial<{
includeAdd: boolean;
flipped: boolean;
}>
): Partial<SequenceNodeActions> {
// alias
const allowedTypes = mapAutoActionKeyToNodeType(k);
// build move
const onMove: SequenceNodeActions["onMove"] = {};
if (!flags.flipped) {
if (i > 0) {
onMove["left"] = () => basic[k].onMove(i, "back");
}
if (i < args[k].data.length - 1) {
onMove["right"] = () => basic[k].onMove(i, "forward");
}
} else {
if (i > 0) {
onMove["up"] = () => basic[k].onMove(i, "back");
}
if (i < args[k].data.length - 1) {
onMove["down"] = () => basic[k].onMove(i, "forward");
}
}
// build add
let onAdd: SequenceNodeActions["onAdd"] = {};
if (flags.includeAdd) {
if (!flags.flipped) {
onAdd["left"] = () => basic[k].addNode(i);
onAdd["right"] = () => basic[k].addNode(i + 1);
} else {
onAdd["up"] = () => basic[k].addNode(i);
onAdd["down"] = () => basic[k].addNode(i + 1);
}
}
return {
onEditClick: () =>
args.openModal({
allowedTypes,
node: args[k].data[i],
saveBtnCreateText: false,
update: (n) => basic[k].updateNode(n, i),
}),
onXClick: () => basic[k].deleteNode(i),
onSetEnabled: () => basic[k].setEnabled(i),
onAdd,
onMove,
};
},
createChoosNodeUpdater(i: number, j: number | "else") {
const node = args.sequence.data[i] as ChooseAction;
if (j === "else") {
return {
stateUpdater: createUpdater({
openModal: args.openModal,
condition: {
data: [],
onUpdate: console.warn,
},
sequence: {
data: node.default ?? [],
onUpdate: (upd) =>
basic.sequence.updateNode(
{
...node,
default: upd,
},
i
),
},
trigger: {
data: [],
onUpdate: console.warn,
},
}),
onRemove: () => {},
};
} else {
return {
onRemove: () =>
basic.sequence.updateNode(
{
...node,
choose: [
...node.choose.slice(0, j),
...node.choose.slice(j + 1),
],
},
i
),
stateUpdater: createUpdater({
openModal: args.openModal,
condition: {
data: node.choose[j].conditions,
onUpdate: (upd: any) =>
basic.sequence.updateNode(
{
...node,
choose: [
...node.choose.slice(0, j),
{
...node.choose[j],
conditions: upd,
},
...node.choose.slice(j + 1),
],
},
i
),
},
sequence: {
data: node.choose[j].sequence,
onUpdate: (upd) =>
basic.sequence.updateNode(
{
...node,
choose: [
...node.choose.slice(0, j),
{
...node.choose[j],
sequence: upd,
},
...node.choose.slice(j + 1),
],
},
i
),
},
trigger: {
data: [],
onUpdate: console.warn,
},
}),
};
}
},
createRepeatNodeUpdater(i: number) {
const { repeat, ...rest } = args.sequence.data[i] as RepeatAction;
const sequence = {
data: repeat.sequence,
onUpdate: (upd: AutomationNode[]) =>
basic.sequence.updateNode(
{
...rest,
repeat: {
...repeat,
sequence: upd,
},
},
i
),
};
if ("while" in repeat) {
return createUpdater({
openModal: args.openModal,
condition: {
data: convertScriptConditionFieldToAutomationConditions(
repeat.while
),
onUpdate: (upd: any) =>
basic.sequence.updateNode(
{
...rest,
repeat: {
...repeat,
while: upd,
},
},
i
),
},
trigger: createDummyUpdater(),
sequence,
});
}
if ("until" in repeat) {
return createUpdater({
openModal: args.openModal,
condition: {
data: convertScriptConditionFieldToAutomationConditions(
repeat.until
),
onUpdate: (upd: any) =>
basic.sequence.updateNode(
{
...rest,
repeat: {
...repeat,
until: upd,
},
},
i
),
},
trigger: createDummyUpdater(),
sequence,
});
}
return createUpdater({
openModal: args.openModal,
condition: createDummyUpdater(),
trigger: createDummyUpdater(),
sequence,
});
},
createParallelNodeUpdater(i: number, j: number) {
const { parallel, ...rest } = args.sequence.data[i] as ParallelAction;
const child = parallel[j];
return {
onRemove: () =>
basic.sequence.updateNode(
{
...rest,
parallel: [...parallel.slice(0, j), ...parallel.slice(j + 1)],
},
i
),
stateUpdater: createUpdater({
openModal: args.openModal,
condition: createDummyUpdater(),
trigger: createDummyUpdater(),
sequence: {
data: "sequence" in child ? child.sequence : [child],
onUpdate(d) {
basic.sequence.updateNode(
{
...rest,
parallel: [
...parallel.slice(0, j),
{ sequence: d },
...parallel.slice(j + 1),
],
},
i
);
},
},
}),
};
},
};
};
export const createUpdaterFromAutomationData = (
openModal: (m: ModalState) => void,
auto: AutomationActionData,
onUpdate: (a: AutomationActionData) => void
): DAGGraphUpdater =>
createUpdater({
sequence: {
data: auto.sequence,
onUpdate: (s: AutomationSequenceNode[]) =>
onUpdate({
...auto,
sequence: s,
}),
},
condition: {
data: auto.condition,
onUpdate: (s: any) =>
onUpdate({
...auto,
condition: s,
}),
},
trigger: {
data: auto.trigger,
onUpdate: (s: any) =>
onUpdate({
...auto,
trigger: s,
}),
},
openModal,
});