Files
Shortumation/webapp/src/components/DAGGraph/elements/index.tsx
T
2022-07-12 20:25:20 -04:00

276 lines
7.7 KiB
TypeScript

import {
DAGDims,
ElementData,
ElementMaker,
ElementMakerBaseProps,
LastNode,
} from "./types";
import { AutomationTrigger } from "types/automations/triggers";
import * as distance from "./distance";
import { getDescriptionFromAutomationNode } from "utils/formatting";
import {
AutomationActionData,
AutomationSequenceNode,
} from "types/automations";
import { AutomationCondition } from "types/automations/conditions";
import { CollectionNodeMaker } from "../nodes/CollectionNode";
import { ChooseAction } from "types/automations/actions";
import { XYPosition } from "react-flow-renderer";
import { DAGElementsState } from "./state";
import { SequenceNodeMaker } from "../nodes/SequenceNode";
import { getNodeType } from "utils/automations";
import { ButtonNodeMaker } from "../nodes/ButtonNode";
import { AddIcon } from "components/Icons";
export const makeAutomationNodes = (
automation: AutomationActionData,
args: ElementMakerBaseProps
) => {
const dims: DAGDims = {
...args.dims,
// think of a better to do this
// condition: args.dims.flipped
// ? args.dims.condition
// : {
// height: args.dims.condition.width,
// width: args.dims.condition.height,
// },
// trigger: args.dims.flipped
// ? args.dims.trigger
// : {
// height: args.dims.trigger.width,
// width: args.dims.trigger.height,
// },
};
const state = new DAGElementsState();
state.extend(
makeTriggerNodes(automation.trigger, {
...args,
dims,
position: dims.position,
nodeId: `${dims.flipped}-trigger`,
nodeIndex: 0,
})
);
state.extend(
makeConditionNodes(automation.condition, {
...args,
dims,
position: distance.moveFromTo(
"trigger",
"condition",
state.lastNodePos,
dims
),
nodeId: `${dims.flipped}-condition`,
nodeIndex: 1,
lastNodeId: state.lastNodeId,
})
);
state.extend(
makeSequenceNodes(automation.sequence, {
...args,
dims,
position: distance.moveFromTo(
"condition",
"node",
state.lastNodePos,
dims
),
nodeId: `${dims.flipped}-sequence`,
nodeIndex: 2,
lastNodeId: state.lastNodeId,
})
);
return state.data;
};
export const makeTriggerNodes: ElementMaker<AutomationTrigger> = (
nodes,
{ dims, namer, stateUpdater, nodeId, position }
) => {
const state = new DAGElementsState();
state.addNode(
CollectionNodeMaker.makeElement({ id: nodeId, position }, dims, {
...dims.trigger,
collectionType: "trigger",
onAddNode: () => stateUpdater.basic.trigger.addNode(null),
nodes: nodes.map((node, index) => ({
enabled: node.enabled ?? true,
label: getDescriptionFromAutomationNode(node, namer, true),
...stateUpdater.createNodeActions("trigger", index, {}),
})),
})
);
return state;
};
export const makeConditionNodes: ElementMaker<AutomationCondition> = (
nodes,
{ nodeId, stateUpdater, position, dims, namer, lastNodeId }
) => {
const state = new DAGElementsState();
state.addNode(
CollectionNodeMaker.makeElement({ id: nodeId, position }, dims, {
...dims.condition,
collectionType: "condition",
hasInput: !!lastNodeId,
onAddNode: () => stateUpdater.basic.condition.addNode(null),
nodes: nodes.map((node, index) => ({
enabled: node.enabled ?? true,
label: getDescriptionFromAutomationNode(node, namer, true),
...stateUpdater.createNodeActions("condition", index, {}),
})),
})
);
console.log("pre", { lastNodeId, stateLast: state.lastNodeId });
if (lastNodeId && state.lastNodeId) {
state.addEdge(lastNodeId, state.lastNodeId, true);
}
return state;
};
export const makeSequenceNodes: ElementMaker<AutomationSequenceNode> = (
nodes,
args
) => {
const state = new DAGElementsState();
const { lastNodeId, nodeId, position, dims, namer, stateUpdater } = args;
nodes.forEach((node, nodeIndex) => {
const element = state.addNode(
SequenceNodeMaker.makeElement(
{
// the JSON.stringify is hack to make the edges render nicely
id: `${nodeId}-${args.nodeIndex}-${nodeIndex}-${JSON.stringify(
node
)}`,
position: distance.moveAlong("node", position, nodeIndex, dims),
},
dims,
{
color: getNodeType(node) === "action" ? "green" : "blue",
enabled: node.enabled ?? true,
hasInput: true,
label: getDescriptionFromAutomationNode(node, namer, true),
...stateUpdater.createNodeActions("sequence", nodeIndex, {
includeAdd: true,
flipped: dims.flipped,
}),
}
),
true
);
if (nodeIndex === 0 && lastNodeId) {
state.addEdge(lastNodeId, element.id);
}
if ("choose" in node) {
state.extend(
makeChooseeNodes([node], {
...args,
lastNodeId: element.id,
position: state.lastNodePos,
nodeIndex,
}),
true
);
}
});
const addElement = state.addNode(
ButtonNodeMaker.makeElement(
{
id: `${nodeId}-add-new`,
position: distance.moveAlong("node", position, nodes.length, dims),
},
dims,
{
icon: <AddIcon />,
onClick: () => stateUpdater.basic.sequence.addNode(null),
}
),
true
);
if (nodes.length === 0 && lastNodeId) {
state.addEdge(lastNodeId, addElement.id);
}
return state;
};
export const makeChooseeNodes: ElementMaker<ChooseAction> = (nodes, args) => {
const state = new DAGElementsState();
if (nodes.length !== 1) {
throw new Error("makeChooseNodes only access a list of 1");
}
const node = nodes[0];
if (node.enabled ?? true) {
// offset position
let offsetPos: XYPosition = {
x: args.position.x + args.dims.distanceFactor.node * args.dims.node.width,
y:
args.position.y + args.dims.distanceFactor.node * args.dims.node.height,
};
// functions
const processSequence = (j: number | "else") => {
const stateUpdater = args.stateUpdater.createChoosNodeUpdater(
args.nodeIndex,
j
);
let pos = offsetPos;
let lastNodeId = args.lastNodeId;
if (j !== "else") {
const conditionState = makeConditionNodes(node.choose[j].conditions, {
...args,
stateUpdater,
position: pos,
lastNodeId,
nodeIndex: j,
nodeId: `${args.nodeId}-choose-${j}-condition`,
});
conditionState.data.edges[0].label = `Condition #${j}`;
state.extend(conditionState);
pos = distance.moveFromTo("condition", "node", pos, args.dims);
lastNodeId = conditionState.lastNodeId;
}
const sequence =
j === "else" ? node.default ?? [] : node.choose[j].sequence;
const output = makeSequenceNodes(sequence, {
...args,
stateUpdater,
position: pos,
lastNodeId: undefined,
nodeIndex: j === "else" ? node.choose.length : j,
nodeId: `${args.nodeId}-choose-${j}-sequence`,
});
if (lastNodeId && output.data.nodes.length > 0) {
state.addEdge(
lastNodeId,
output.data.nodes[0].id,
true,
j === "else" ? "else" : undefined
);
}
offsetPos = distance.moveAlongRelativeTo(
offsetPos,
output.bbox[1],
args.dims,
j === "else" ? "node" : "condition"
);
state.extend(output);
};
// process options
for (let sIndex = 0; sIndex < node.choose.length; sIndex++) {
processSequence(sIndex);
}
// else
processSequence("else");
}
return state;
};