Compare commits
7 Commits
slice/38-d
...
5533293647
| Author | SHA1 | Date | |
|---|---|---|---|
|
5533293647 | ||
|
|
990a8c09ea | ||
| dc08c85409 | |||
| 2b745dfb51 | |||
| 3c8427ed7a | |||
| 8964b0b638 | |||
| a76f22281e |
@@ -122,7 +122,12 @@
|
||||
}
|
||||
],
|
||||
"title": "Scaling",
|
||||
"type": "stat"
|
||||
"type": "stat",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"scaling"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"datasource": {
|
||||
@@ -174,7 +179,12 @@
|
||||
}
|
||||
],
|
||||
"title": "Abs Dist Peak",
|
||||
"type": "stat"
|
||||
"type": "stat",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"absDistFromPeak"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"datasource": {
|
||||
@@ -227,7 +237,12 @@
|
||||
}
|
||||
],
|
||||
"title": "Rel Dist Peak",
|
||||
"type": "stat"
|
||||
"type": "stat",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"relDistFromPeak"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"gridPos": {
|
||||
@@ -253,7 +268,58 @@
|
||||
"fillOpacity": 10
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
"overrides": [
|
||||
{
|
||||
"matcher": {
|
||||
"id": "byRegexp",
|
||||
"options": ".+\\.min$"
|
||||
},
|
||||
"properties": [
|
||||
{
|
||||
"id": "custom.lineStyle",
|
||||
"value": {
|
||||
"fill": "dash",
|
||||
"dash": [
|
||||
10,
|
||||
10
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "color",
|
||||
"value": {
|
||||
"mode": "fixed",
|
||||
"fixedColor": "orange"
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"matcher": {
|
||||
"id": "byRegexp",
|
||||
"options": ".+\\.max$"
|
||||
},
|
||||
"properties": [
|
||||
{
|
||||
"id": "custom.lineStyle",
|
||||
"value": {
|
||||
"fill": "dash",
|
||||
"dash": [
|
||||
10,
|
||||
10
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "color",
|
||||
"value": {
|
||||
"mode": "fixed",
|
||||
"fixedColor": "red"
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 8,
|
||||
@@ -278,7 +344,13 @@
|
||||
}
|
||||
],
|
||||
"title": "Total Flow",
|
||||
"type": "timeseries"
|
||||
"type": "timeseries",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"flow.total",
|
||||
"flow.group"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"datasource": {
|
||||
@@ -293,7 +365,58 @@
|
||||
"fillOpacity": 10
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
"overrides": [
|
||||
{
|
||||
"matcher": {
|
||||
"id": "byRegexp",
|
||||
"options": ".+\\.min$"
|
||||
},
|
||||
"properties": [
|
||||
{
|
||||
"id": "custom.lineStyle",
|
||||
"value": {
|
||||
"fill": "dash",
|
||||
"dash": [
|
||||
10,
|
||||
10
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "color",
|
||||
"value": {
|
||||
"mode": "fixed",
|
||||
"fixedColor": "orange"
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"matcher": {
|
||||
"id": "byRegexp",
|
||||
"options": ".+\\.max$"
|
||||
},
|
||||
"properties": [
|
||||
{
|
||||
"id": "custom.lineStyle",
|
||||
"value": {
|
||||
"fill": "dash",
|
||||
"dash": [
|
||||
10,
|
||||
10
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "color",
|
||||
"value": {
|
||||
"mode": "fixed",
|
||||
"fixedColor": "red"
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 8,
|
||||
@@ -318,7 +441,13 @@
|
||||
}
|
||||
],
|
||||
"title": "Total Power",
|
||||
"type": "timeseries"
|
||||
"type": "timeseries",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"power.total",
|
||||
"power.group"
|
||||
]
|
||||
}
|
||||
}
|
||||
],
|
||||
"schemaVersion": 39,
|
||||
|
||||
@@ -3,7 +3,10 @@
|
||||
"list": [
|
||||
{
|
||||
"builtIn": 1,
|
||||
"datasource": { "type": "grafana", "uid": "-- Grafana --" },
|
||||
"datasource": {
|
||||
"type": "grafana",
|
||||
"uid": "-- Grafana --"
|
||||
},
|
||||
"enable": true,
|
||||
"hide": true,
|
||||
"iconColor": "rgba(0, 211, 255, 1)",
|
||||
@@ -17,153 +20,680 @@
|
||||
"id": null,
|
||||
"links": [],
|
||||
"panels": [
|
||||
{ "gridPos": { "h": 1, "w": 24, "x": 0, "y": 0 }, "id": 1, "title": "Status", "type": "row" },
|
||||
{
|
||||
"datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
|
||||
"fieldConfig": { "defaults": { "thresholds": { "mode": "absolute", "steps": [{ "color": "blue", "value": null }] } }, "overrides": [] },
|
||||
"gridPos": { "h": 4, "w": 5, "x": 0, "y": 1 },
|
||||
"gridPos": {
|
||||
"h": 1,
|
||||
"w": 24,
|
||||
"x": 0,
|
||||
"y": 0
|
||||
},
|
||||
"id": 1,
|
||||
"title": "Status",
|
||||
"type": "row"
|
||||
},
|
||||
{
|
||||
"datasource": {
|
||||
"type": "influxdb",
|
||||
"uid": "cdzg44tv250jkd"
|
||||
},
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"thresholds": {
|
||||
"mode": "absolute",
|
||||
"steps": [
|
||||
{
|
||||
"color": "blue",
|
||||
"value": null
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 4,
|
||||
"w": 5,
|
||||
"x": 0,
|
||||
"y": 1
|
||||
},
|
||||
"id": 2,
|
||||
"options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "none" },
|
||||
"options": {
|
||||
"reduceOptions": {
|
||||
"calcs": [
|
||||
"lastNotNull"
|
||||
]
|
||||
},
|
||||
"colorMode": "value",
|
||||
"graphMode": "none"
|
||||
},
|
||||
"targets": [
|
||||
{ "query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"direction\")\n |> last()", "refId": "A" }
|
||||
{
|
||||
"query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"direction\")\n |> last()",
|
||||
"refId": "A"
|
||||
}
|
||||
],
|
||||
"title": "Direction",
|
||||
"type": "stat"
|
||||
"type": "stat",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"direction"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
|
||||
"fieldConfig": { "defaults": { "unit": "s", "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }, { "color": "orange", "value": 300 }, { "color": "red", "value": 600 }] } }, "overrides": [] },
|
||||
"gridPos": { "h": 4, "w": 5, "x": 5, "y": 1 },
|
||||
"datasource": {
|
||||
"type": "influxdb",
|
||||
"uid": "cdzg44tv250jkd"
|
||||
},
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"unit": "s",
|
||||
"thresholds": {
|
||||
"mode": "absolute",
|
||||
"steps": [
|
||||
{
|
||||
"color": "green",
|
||||
"value": null
|
||||
},
|
||||
{
|
||||
"color": "orange",
|
||||
"value": 300
|
||||
},
|
||||
{
|
||||
"color": "red",
|
||||
"value": 600
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 4,
|
||||
"w": 5,
|
||||
"x": 5,
|
||||
"y": 1
|
||||
},
|
||||
"id": 3,
|
||||
"options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "area" },
|
||||
"options": {
|
||||
"reduceOptions": {
|
||||
"calcs": [
|
||||
"lastNotNull"
|
||||
]
|
||||
},
|
||||
"colorMode": "value",
|
||||
"graphMode": "area"
|
||||
},
|
||||
"targets": [
|
||||
{ "query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"timeleft\")\n |> last()", "refId": "A" }
|
||||
{
|
||||
"query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"timeleft\")\n |> last()",
|
||||
"refId": "A"
|
||||
}
|
||||
],
|
||||
"title": "Time Left",
|
||||
"type": "stat"
|
||||
"type": "stat",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"timeLeft"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
|
||||
"fieldConfig": { "defaults": { "thresholds": { "mode": "absolute", "steps": [{ "color": "purple", "value": null }] } }, "overrides": [] },
|
||||
"gridPos": { "h": 4, "w": 4, "x": 10, "y": 1 },
|
||||
"datasource": {
|
||||
"type": "influxdb",
|
||||
"uid": "cdzg44tv250jkd"
|
||||
},
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"thresholds": {
|
||||
"mode": "absolute",
|
||||
"steps": [
|
||||
{
|
||||
"color": "purple",
|
||||
"value": null
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 4,
|
||||
"w": 4,
|
||||
"x": 10,
|
||||
"y": 1
|
||||
},
|
||||
"id": 4,
|
||||
"options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "none" },
|
||||
"options": {
|
||||
"reduceOptions": {
|
||||
"calcs": [
|
||||
"lastNotNull"
|
||||
]
|
||||
},
|
||||
"colorMode": "value",
|
||||
"graphMode": "none"
|
||||
},
|
||||
"targets": [
|
||||
{ "query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"flowSource\")\n |> last()", "refId": "A" }
|
||||
{
|
||||
"query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"flowSource\")\n |> last()",
|
||||
"refId": "A"
|
||||
}
|
||||
],
|
||||
"title": "Flow Source",
|
||||
"type": "stat"
|
||||
"type": "stat",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"flowSource"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
|
||||
"fieldConfig": { "defaults": { "min": 0, "max": 100, "unit": "percent", "thresholds": { "mode": "absolute", "steps": [{ "color": "red", "value": null }, { "color": "orange", "value": 20 }, { "color": "green", "value": 40 }, { "color": "orange", "value": 80 }, { "color": "red", "value": 95 }] } }, "overrides": [] },
|
||||
"gridPos": { "h": 4, "w": 5, "x": 14, "y": 1 },
|
||||
"datasource": {
|
||||
"type": "influxdb",
|
||||
"uid": "cdzg44tv250jkd"
|
||||
},
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"min": 0,
|
||||
"max": 100,
|
||||
"unit": "percent",
|
||||
"thresholds": {
|
||||
"mode": "absolute",
|
||||
"steps": [
|
||||
{
|
||||
"color": "red",
|
||||
"value": null
|
||||
},
|
||||
{
|
||||
"color": "orange",
|
||||
"value": 20
|
||||
},
|
||||
{
|
||||
"color": "green",
|
||||
"value": 40
|
||||
},
|
||||
{
|
||||
"color": "orange",
|
||||
"value": 80
|
||||
},
|
||||
{
|
||||
"color": "red",
|
||||
"value": 95
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 4,
|
||||
"w": 5,
|
||||
"x": 14,
|
||||
"y": 1
|
||||
},
|
||||
"id": 5,
|
||||
"options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "showThresholdLabels": false, "showThresholdMarkers": true },
|
||||
"options": {
|
||||
"reduceOptions": {
|
||||
"calcs": [
|
||||
"lastNotNull"
|
||||
]
|
||||
},
|
||||
"showThresholdLabels": false,
|
||||
"showThresholdMarkers": true
|
||||
},
|
||||
"targets": [
|
||||
{ "query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^volumePercent\\.predicted\\.atequipment/)\n |> last()", "refId": "A" }
|
||||
{
|
||||
"query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^volumePercent\\.predicted\\.atequipment/)\n |> last()",
|
||||
"refId": "A"
|
||||
}
|
||||
],
|
||||
"title": "Fill %",
|
||||
"type": "gauge"
|
||||
"type": "gauge",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"volumePercent"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
|
||||
"fieldConfig": { "defaults": { "unit": "m", "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }] } }, "overrides": [] },
|
||||
"gridPos": { "h": 4, "w": 5, "x": 19, "y": 1 },
|
||||
"datasource": {
|
||||
"type": "influxdb",
|
||||
"uid": "cdzg44tv250jkd"
|
||||
},
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"unit": "m",
|
||||
"thresholds": {
|
||||
"mode": "absolute",
|
||||
"steps": [
|
||||
{
|
||||
"color": "green",
|
||||
"value": null
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 4,
|
||||
"w": 5,
|
||||
"x": 19,
|
||||
"y": 1
|
||||
},
|
||||
"id": 6,
|
||||
"options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "area" },
|
||||
"options": {
|
||||
"reduceOptions": {
|
||||
"calcs": [
|
||||
"lastNotNull"
|
||||
]
|
||||
},
|
||||
"colorMode": "value",
|
||||
"graphMode": "area"
|
||||
},
|
||||
"targets": [
|
||||
{ "query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^level\\.predicted\\.atequipment/)\n |> last()", "refId": "A" }
|
||||
{
|
||||
"query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^level\\.predicted\\.atequipment/)\n |> last()",
|
||||
"refId": "A"
|
||||
}
|
||||
],
|
||||
"title": "Level",
|
||||
"type": "stat"
|
||||
"type": "stat",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"level"
|
||||
]
|
||||
}
|
||||
},
|
||||
{ "gridPos": { "h": 1, "w": 24, "x": 0, "y": 5 }, "id": 7, "title": "Basin", "type": "row" },
|
||||
{
|
||||
"datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
|
||||
"fieldConfig": { "defaults": { "unit": "m", "custom": { "drawStyle": "line", "lineWidth": 2, "fillOpacity": 10 } }, "overrides": [] },
|
||||
"gridPos": { "h": 8, "w": 12, "x": 0, "y": 6 },
|
||||
"gridPos": {
|
||||
"h": 1,
|
||||
"w": 24,
|
||||
"x": 0,
|
||||
"y": 5
|
||||
},
|
||||
"id": 7,
|
||||
"title": "Basin",
|
||||
"type": "row"
|
||||
},
|
||||
{
|
||||
"datasource": {
|
||||
"type": "influxdb",
|
||||
"uid": "cdzg44tv250jkd"
|
||||
},
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"unit": "m",
|
||||
"custom": {
|
||||
"drawStyle": "line",
|
||||
"lineWidth": 2,
|
||||
"fillOpacity": 10
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 8,
|
||||
"w": 12,
|
||||
"x": 0,
|
||||
"y": 6
|
||||
},
|
||||
"id": 8,
|
||||
"options": { "legend": { "displayMode": "list", "placement": "bottom" }, "tooltip": { "mode": "multi" } },
|
||||
"options": {
|
||||
"legend": {
|
||||
"displayMode": "list",
|
||||
"placement": "bottom"
|
||||
},
|
||||
"tooltip": {
|
||||
"mode": "multi"
|
||||
}
|
||||
},
|
||||
"targets": [
|
||||
{ "query": "from(bucket: \"${bucket}\")\n |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^level\\.(predicted|measured)\\.atequipment/)\n |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)", "refId": "A" }
|
||||
{
|
||||
"query": "from(bucket: \"${bucket}\")\n |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^level\\.(predicted|measured)\\.atequipment/)\n |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)",
|
||||
"refId": "A"
|
||||
}
|
||||
],
|
||||
"title": "Level",
|
||||
"type": "timeseries"
|
||||
"type": "timeseries",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"level"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
|
||||
"fieldConfig": { "defaults": { "unit": "m\u00b3", "custom": { "drawStyle": "line", "lineWidth": 2, "fillOpacity": 10 } }, "overrides": [] },
|
||||
"gridPos": { "h": 8, "w": 12, "x": 12, "y": 6 },
|
||||
"datasource": {
|
||||
"type": "influxdb",
|
||||
"uid": "cdzg44tv250jkd"
|
||||
},
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"unit": "m\u00b3",
|
||||
"custom": {
|
||||
"drawStyle": "line",
|
||||
"lineWidth": 2,
|
||||
"fillOpacity": 10
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 8,
|
||||
"w": 12,
|
||||
"x": 12,
|
||||
"y": 6
|
||||
},
|
||||
"id": 9,
|
||||
"options": { "legend": { "displayMode": "list", "placement": "bottom" }, "tooltip": { "mode": "multi" } },
|
||||
"options": {
|
||||
"legend": {
|
||||
"displayMode": "list",
|
||||
"placement": "bottom"
|
||||
},
|
||||
"tooltip": {
|
||||
"mode": "multi"
|
||||
}
|
||||
},
|
||||
"targets": [
|
||||
{ "query": "from(bucket: \"${bucket}\")\n |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^volume\\.predicted\\.atequipment/)\n |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)", "refId": "A" }
|
||||
{
|
||||
"query": "from(bucket: \"${bucket}\")\n |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^volume\\.predicted\\.atequipment/)\n |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)",
|
||||
"refId": "A"
|
||||
}
|
||||
],
|
||||
"title": "Volume",
|
||||
"type": "timeseries"
|
||||
"type": "timeseries",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"volume"
|
||||
]
|
||||
}
|
||||
},
|
||||
{ "gridPos": { "h": 1, "w": 24, "x": 0, "y": 14 }, "id": 10, "title": "Flow", "type": "row" },
|
||||
{
|
||||
"datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
|
||||
"fieldConfig": { "defaults": { "unit": "m\u00b3/h", "custom": { "drawStyle": "line", "lineWidth": 2, "fillOpacity": 10 } }, "overrides": [] },
|
||||
"gridPos": { "h": 8, "w": 12, "x": 0, "y": 15 },
|
||||
"gridPos": {
|
||||
"h": 1,
|
||||
"w": 24,
|
||||
"x": 0,
|
||||
"y": 14
|
||||
},
|
||||
"id": 10,
|
||||
"title": "Flow",
|
||||
"type": "row"
|
||||
},
|
||||
{
|
||||
"datasource": {
|
||||
"type": "influxdb",
|
||||
"uid": "cdzg44tv250jkd"
|
||||
},
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"unit": "m\u00b3/h",
|
||||
"custom": {
|
||||
"drawStyle": "line",
|
||||
"lineWidth": 2,
|
||||
"fillOpacity": 10
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 8,
|
||||
"w": 12,
|
||||
"x": 0,
|
||||
"y": 15
|
||||
},
|
||||
"id": 11,
|
||||
"options": { "legend": { "displayMode": "list", "placement": "bottom" }, "tooltip": { "mode": "multi" } },
|
||||
"options": {
|
||||
"legend": {
|
||||
"displayMode": "list",
|
||||
"placement": "bottom"
|
||||
},
|
||||
"tooltip": {
|
||||
"mode": "multi"
|
||||
}
|
||||
},
|
||||
"targets": [
|
||||
{ "query": "from(bucket: \"${bucket}\")\n |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^netFlowRate\\.predicted\\.atequipment/)\n |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)", "refId": "A" }
|
||||
{
|
||||
"query": "from(bucket: \"${bucket}\")\n |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^netFlowRate\\.(predicted|measured)\\.atequipment/)\n |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)",
|
||||
"refId": "A"
|
||||
}
|
||||
],
|
||||
"title": "Net Flow Rate",
|
||||
"type": "timeseries"
|
||||
"type": "timeseries",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"flow.net",
|
||||
"flow"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
|
||||
"fieldConfig": { "defaults": { "unit": "m\u00b3/h", "custom": { "drawStyle": "line", "lineWidth": 2, "fillOpacity": 10 } }, "overrides": [] },
|
||||
"gridPos": { "h": 8, "w": 12, "x": 12, "y": 15 },
|
||||
"datasource": {
|
||||
"type": "influxdb",
|
||||
"uid": "cdzg44tv250jkd"
|
||||
},
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"unit": "m\u00b3/h",
|
||||
"custom": {
|
||||
"drawStyle": "line",
|
||||
"lineWidth": 2,
|
||||
"fillOpacity": 10
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 8,
|
||||
"w": 12,
|
||||
"x": 12,
|
||||
"y": 15
|
||||
},
|
||||
"id": 12,
|
||||
"options": { "legend": { "displayMode": "list", "placement": "bottom" }, "tooltip": { "mode": "multi" } },
|
||||
"options": {
|
||||
"legend": {
|
||||
"displayMode": "list",
|
||||
"placement": "bottom"
|
||||
},
|
||||
"tooltip": {
|
||||
"mode": "multi"
|
||||
}
|
||||
},
|
||||
"targets": [
|
||||
{ "query": "from(bucket: \"${bucket}\")\n |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^flow\\.(predicted|measured)\\.atequipment/)\n |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)", "refId": "A" }
|
||||
{
|
||||
"query": "from(bucket: \"${bucket}\")\n |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^flow\\.(predicted|measured)\\.(upstream|in|out|overflow)/)\n |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)",
|
||||
"refId": "A"
|
||||
}
|
||||
],
|
||||
"title": "Inflow + Outflow",
|
||||
"type": "timeseries"
|
||||
"type": "timeseries",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"flow.in",
|
||||
"flow.out"
|
||||
]
|
||||
}
|
||||
},
|
||||
{ "gridPos": { "h": 1, "w": 24, "x": 0, "y": 23 }, "id": 13, "title": "Configuration", "type": "row" },
|
||||
{
|
||||
"datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
|
||||
"fieldConfig": { "defaults": { "unit": "m", "thresholds": { "mode": "absolute", "steps": [{ "color": "blue", "value": null }] } }, "overrides": [] },
|
||||
"gridPos": { "h": 4, "w": 12, "x": 0, "y": 24 },
|
||||
"gridPos": {
|
||||
"h": 1,
|
||||
"w": 24,
|
||||
"x": 0,
|
||||
"y": 23
|
||||
},
|
||||
"id": 13,
|
||||
"title": "Configuration",
|
||||
"type": "row"
|
||||
},
|
||||
{
|
||||
"datasource": {
|
||||
"type": "influxdb",
|
||||
"uid": "cdzg44tv250jkd"
|
||||
},
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"unit": "m",
|
||||
"thresholds": {
|
||||
"mode": "absolute",
|
||||
"steps": [
|
||||
{
|
||||
"color": "blue",
|
||||
"value": null
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 4,
|
||||
"w": 12,
|
||||
"x": 0,
|
||||
"y": 24
|
||||
},
|
||||
"id": 14,
|
||||
"options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "none" },
|
||||
"options": {
|
||||
"reduceOptions": {
|
||||
"calcs": [
|
||||
"lastNotNull"
|
||||
]
|
||||
},
|
||||
"colorMode": "value",
|
||||
"graphMode": "none"
|
||||
},
|
||||
"targets": [
|
||||
{ "query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and (r._field==\"heightInlet\" or r._field==\"heightOverflow\" or r._field==\"volEmptyBasin\"))\n |> last()", "refId": "A" }
|
||||
{
|
||||
"query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and (r._field==\"inflowLevel\" or r._field==\"outflowLevel\" or r._field==\"overflowLevel\" or r._field==\"heightBasin\"))\n |> last()",
|
||||
"refId": "A"
|
||||
}
|
||||
],
|
||||
"title": "Heights",
|
||||
"type": "stat"
|
||||
"type": "stat",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"heights.min",
|
||||
"heights.max"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
|
||||
"fieldConfig": { "defaults": { "unit": "m\u00b3", "thresholds": { "mode": "absolute", "steps": [{ "color": "blue", "value": null }] } }, "overrides": [] },
|
||||
"gridPos": { "h": 4, "w": 12, "x": 12, "y": 24 },
|
||||
"datasource": {
|
||||
"type": "influxdb",
|
||||
"uid": "cdzg44tv250jkd"
|
||||
},
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"unit": "m\u00b3",
|
||||
"thresholds": {
|
||||
"mode": "absolute",
|
||||
"steps": [
|
||||
{
|
||||
"color": "blue",
|
||||
"value": null
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"overrides": []
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 4,
|
||||
"w": 12,
|
||||
"x": 12,
|
||||
"y": 24
|
||||
},
|
||||
"id": 15,
|
||||
"options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "none" },
|
||||
"options": {
|
||||
"reduceOptions": {
|
||||
"calcs": [
|
||||
"lastNotNull"
|
||||
]
|
||||
},
|
||||
"colorMode": "value",
|
||||
"graphMode": "none"
|
||||
},
|
||||
"targets": [
|
||||
{ "query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and (r._field==\"maxVol\" or r._field==\"minVol\" or r._field==\"maxVolOverflow\" or r._field==\"minVolOut\" or r._field==\"minVolIn\"))\n |> last()", "refId": "A" }
|
||||
{
|
||||
"query": "from(bucket: \"${bucket}\")\n |> range(start: -7d)\n |> filter(fn:(r) => r._measurement==\"${measurement}\" and (r._field==\"maxVol\" or r._field==\"minVol\" or r._field==\"maxVolAtOverflow\" or r._field==\"minVolAtOutflow\" or r._field==\"minVolAtInflow\"))\n |> last()",
|
||||
"refId": "A"
|
||||
}
|
||||
],
|
||||
"title": "Volume Limits",
|
||||
"type": "stat"
|
||||
"type": "stat",
|
||||
"meta": {
|
||||
"emittedFields": [
|
||||
"volume.min",
|
||||
"volume.max"
|
||||
]
|
||||
}
|
||||
}
|
||||
],
|
||||
"schemaVersion": 39,
|
||||
"tags": ["EVOLV", "pumpingStation", "template"],
|
||||
"tags": [
|
||||
"EVOLV",
|
||||
"pumpingStation",
|
||||
"template"
|
||||
],
|
||||
"templating": {
|
||||
"list": [
|
||||
{ "name": "dbase", "type": "custom", "label": "dbase", "query": "cdzg44tv250jkd", "current": { "text": "cdzg44tv250jkd", "value": "cdzg44tv250jkd", "selected": false }, "options": [{ "text": "cdzg44tv250jkd", "value": "cdzg44tv250jkd", "selected": true }], "hide": 2 },
|
||||
{ "name": "measurement", "type": "custom", "query": "template", "current": { "text": "template", "value": "template", "selected": false }, "options": [{ "text": "template", "value": "template", "selected": true }] },
|
||||
{ "name": "bucket", "type": "custom", "query": "lvl2", "current": { "text": "lvl2", "value": "lvl2", "selected": false }, "options": [{ "text": "lvl2", "value": "lvl2", "selected": true }] }
|
||||
{
|
||||
"name": "dbase",
|
||||
"type": "custom",
|
||||
"label": "dbase",
|
||||
"query": "cdzg44tv250jkd",
|
||||
"current": {
|
||||
"text": "cdzg44tv250jkd",
|
||||
"value": "cdzg44tv250jkd",
|
||||
"selected": false
|
||||
},
|
||||
"options": [
|
||||
{
|
||||
"text": "cdzg44tv250jkd",
|
||||
"value": "cdzg44tv250jkd",
|
||||
"selected": true
|
||||
}
|
||||
],
|
||||
"hide": 2
|
||||
},
|
||||
{
|
||||
"name": "measurement",
|
||||
"type": "custom",
|
||||
"query": "template",
|
||||
"current": {
|
||||
"text": "template",
|
||||
"value": "template",
|
||||
"selected": false
|
||||
},
|
||||
"options": [
|
||||
{
|
||||
"text": "template",
|
||||
"value": "template",
|
||||
"selected": true
|
||||
}
|
||||
]
|
||||
},
|
||||
"time": { "from": "now-6h", "to": "now" },
|
||||
{
|
||||
"name": "bucket",
|
||||
"type": "custom",
|
||||
"query": "lvl2",
|
||||
"current": {
|
||||
"text": "lvl2",
|
||||
"value": "lvl2",
|
||||
"selected": false
|
||||
},
|
||||
"options": [
|
||||
{
|
||||
"text": "lvl2",
|
||||
"value": "lvl2",
|
||||
"selected": true
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
"time": {
|
||||
"from": "now-6h",
|
||||
"to": "now"
|
||||
},
|
||||
"timezone": "",
|
||||
"title": "template",
|
||||
"uid": null,
|
||||
|
||||
@@ -1,6 +1,70 @@
|
||||
[
|
||||
{"id":"dashboardAPI_basic_tab","type":"tab","label":"dashboardAPI basic","disabled":false,"info":"dashboardAPI basic example"},
|
||||
{"id":"dashboardAPI_basic_node","type":"dashboardapi","z":"dashboardAPI_basic_tab","name":"dashboardAPI basic","x":420,"y":180,"wires":[["dashboardAPI_basic_dbg"]]},
|
||||
{"id":"dashboardAPI_basic_inj","type":"inject","z":"dashboardAPI_basic_tab","name":"basic trigger","props":[{"p":"topic","vt":"str"},{"p":"payload","vt":"str"}],"topic":"ping","payload":"1","payloadType":"str","x":160,"y":180,"wires":[["dashboardAPI_basic_node"]]},
|
||||
{"id":"dashboardAPI_basic_dbg","type":"debug","z":"dashboardAPI_basic_tab","name":"dashboardAPI basic debug","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"true","targetType":"full","x":660,"y":180,"wires":[]}
|
||||
{
|
||||
"id": "dashboardAPI_basic_tab",
|
||||
"type": "tab",
|
||||
"label": "dashboardAPI basic — measurement → Grafana",
|
||||
"disabled": false,
|
||||
"info": "Demonstrates the round-trip:\n- inject simulates a child.register message from a measurement node\n- dashboardapi composes a Grafana dashboard for that child\n- http request posts the dashboard to Grafana\n- debug shows the HTTP response\n\nConfigure the dashboardapi node with your Grafana host/port + bearer token\n(encrypted via Node-RED credentials). Default targets http://grafana:3000\nfrom inside the Docker compose stack."
|
||||
},
|
||||
{
|
||||
"id": "dashboardAPI_basic_node",
|
||||
"type": "dashboardapi",
|
||||
"z": "dashboardAPI_basic_tab",
|
||||
"name": "dashboardAPI",
|
||||
"protocol": "http",
|
||||
"host": "grafana",
|
||||
"port": 3000,
|
||||
"folderUid": "",
|
||||
"defaultBucket": "telemetry",
|
||||
"x": 460,
|
||||
"y": 200,
|
||||
"wires": [["dashboardAPI_basic_http"]]
|
||||
},
|
||||
{
|
||||
"id": "dashboardAPI_basic_inj",
|
||||
"type": "inject",
|
||||
"z": "dashboardAPI_basic_tab",
|
||||
"name": "simulate child.register (measurement)",
|
||||
"props": [
|
||||
{ "p": "topic", "vt": "str" },
|
||||
{ "p": "payload", "v": "{\"config\":{\"general\":{\"id\":\"meas-demo-001\",\"name\":\"FT-001 demo\"},\"functionality\":{\"softwareType\":\"measurement\",\"positionVsParent\":\"downstream\"}}}", "vt": "json" }
|
||||
],
|
||||
"topic": "child.register",
|
||||
"x": 180,
|
||||
"y": 200,
|
||||
"wires": [["dashboardAPI_basic_node"]]
|
||||
},
|
||||
{
|
||||
"id": "dashboardAPI_basic_http",
|
||||
"type": "http request",
|
||||
"z": "dashboardAPI_basic_tab",
|
||||
"name": "POST /api/dashboards/db",
|
||||
"method": "use",
|
||||
"ret": "obj",
|
||||
"paytoqs": "ignore",
|
||||
"url": "",
|
||||
"tls": "",
|
||||
"persist": false,
|
||||
"proxy": "",
|
||||
"authType": "",
|
||||
"senderr": false,
|
||||
"x": 720,
|
||||
"y": 200,
|
||||
"wires": [["dashboardAPI_basic_dbg"]]
|
||||
},
|
||||
{
|
||||
"id": "dashboardAPI_basic_dbg",
|
||||
"type": "debug",
|
||||
"z": "dashboardAPI_basic_tab",
|
||||
"name": "Grafana response",
|
||||
"active": true,
|
||||
"tosidebar": true,
|
||||
"console": false,
|
||||
"tostatus": false,
|
||||
"complete": "payload",
|
||||
"targetType": "msg",
|
||||
"x": 960,
|
||||
"y": 200,
|
||||
"wires": []
|
||||
}
|
||||
]
|
||||
|
||||
@@ -22,35 +22,9 @@ function resolveChildNode(childId, ctx) {
|
||||
return runtimeNode || flowNode || null;
|
||||
}
|
||||
|
||||
// On child.register: build the dashboard graph (root + direct children) and
|
||||
// emit one Grafana upsert HTTP request per dashboard on Port 0.
|
||||
//
|
||||
// Diff-skip behavior (PRD F-1, S1 spike #32): if the latest flows:started
|
||||
// payload's `diff` indicates that NEITHER the dashboardAPI itself NOR this
|
||||
// child NOR its grandchildren changed, skip composition and log no-diff. The
|
||||
// first call after startup (no cached diff yet) regenerates unconditionally.
|
||||
function registerChild(source, msg, ctx) {
|
||||
const childSource = resolveChildSource(msg.payload, ctx);
|
||||
if (!childSource?.config) {
|
||||
throw new Error('Missing or invalid child node');
|
||||
}
|
||||
|
||||
const subtreeIds = source.subtreeIdsFor(ctx.node?.id, childSource);
|
||||
const changed = source.subtreeChanged(source.lastFlowsStartedDiff, subtreeIds);
|
||||
if (!changed) {
|
||||
if (source.logger?.info) {
|
||||
source.logger.info({
|
||||
event: 'regen-skipped',
|
||||
outcome: 'no-diff',
|
||||
trigger: 'child.register',
|
||||
dashboardApiId: ctx.node?.id,
|
||||
childId: childSource?.config?.general?.id,
|
||||
subtreeSize: subtreeIds.size,
|
||||
});
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Shared emit path used by both child.register (auto, deploy-driven) and
|
||||
// regenerate-dashboard (manual). `trigger` distinguishes the two for logs.
|
||||
function emitDashboardsFor(source, childSource, ctx, msg, trigger) {
|
||||
const dashboards = source.generateDashboardsForGraph(childSource, {
|
||||
includeChildren: Boolean(msg.includeChildren ?? true),
|
||||
});
|
||||
@@ -77,9 +51,73 @@ function registerChild(source, msg, ctx) {
|
||||
softwareType: dash.softwareType,
|
||||
uid: dash.uid,
|
||||
title: dash.title,
|
||||
trigger,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
if (source.logger?.info) {
|
||||
source.logger.info({
|
||||
event: 'regen-emitted',
|
||||
trigger,
|
||||
dashboardApiId: ctx.node?.id,
|
||||
childId: childSource?.config?.general?.id,
|
||||
dashboardCount: dashboards.length,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = { registerChild };
|
||||
// On child.register: build the dashboard graph (root + direct children) and
|
||||
// emit one Grafana upsert HTTP request per dashboard on Port 0.
|
||||
//
|
||||
// Diff-skip behavior (PRD F-1, S1 spike #32): if the latest flows:started
|
||||
// payload's `diff` indicates that NEITHER the dashboardAPI itself NOR this
|
||||
// child NOR its grandchildren changed, skip composition and log no-diff. The
|
||||
// first call after startup (no cached diff yet) regenerates unconditionally.
|
||||
function registerChild(source, msg, ctx) {
|
||||
const childSource = resolveChildSource(msg.payload, ctx);
|
||||
if (!childSource?.config) {
|
||||
throw new Error('Missing or invalid child node');
|
||||
}
|
||||
|
||||
// Cache the child source for later manual regen (#41).
|
||||
source.recordChild?.(childSource);
|
||||
|
||||
const subtreeIds = source.subtreeIdsFor(ctx.node?.id, childSource);
|
||||
const changed = source.subtreeChanged(source.lastFlowsStartedDiff, subtreeIds);
|
||||
if (!changed) {
|
||||
if (source.logger?.info) {
|
||||
source.logger.info({
|
||||
event: 'regen-skipped',
|
||||
outcome: 'no-diff',
|
||||
trigger: 'child.register',
|
||||
dashboardApiId: ctx.node?.id,
|
||||
childId: childSource?.config?.general?.id,
|
||||
subtreeSize: subtreeIds.size,
|
||||
});
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
emitDashboardsFor(source, childSource, ctx, msg, 'child.register');
|
||||
}
|
||||
|
||||
// On regenerate-dashboard: re-emit dashboards for every cached child source,
|
||||
// bypassing the diff predicate. Useful as an operator escape hatch when
|
||||
// auto-regen missed an edge case or when the operator just wants to refresh.
|
||||
function regenerateDashboard(source, msg, ctx) {
|
||||
const cached = source.cachedChildSources?.() || [];
|
||||
if (source.logger?.info) {
|
||||
source.logger.info({
|
||||
event: 'manual-regen-requested',
|
||||
trigger: 'manual',
|
||||
dashboardApiId: ctx.node?.id,
|
||||
cachedChildCount: cached.length,
|
||||
});
|
||||
}
|
||||
for (const childSource of cached) {
|
||||
emitDashboardsFor(source, childSource, ctx, msg, 'manual');
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = { registerChild, regenerateDashboard };
|
||||
|
||||
@@ -13,4 +13,10 @@ module.exports = [
|
||||
payloadSchema: { type: 'any' },
|
||||
handler: handlers.registerChild,
|
||||
},
|
||||
{
|
||||
topic: 'regenerate-dashboard',
|
||||
aliases: ['regen'],
|
||||
payloadSchema: { type: 'any' },
|
||||
handler: handlers.regenerateDashboard,
|
||||
},
|
||||
];
|
||||
|
||||
@@ -18,6 +18,28 @@ function slugify(input) {
|
||||
.slice(0, 60);
|
||||
}
|
||||
|
||||
// Map a node's lowercased softwareType to its Grafana template file in config/.
|
||||
// Nodes report softwareType as the lowercased node name (e.g. 'rotatingmachine',
|
||||
// 'machinegroupcontrol'), but several template files are camelCase and some node
|
||||
// types share a template (rotatingMachine → machine, diffuser → aeration). The
|
||||
// keys here are always lowercase; lookup lowercases the input first.
|
||||
const TEMPLATE_FILE_BY_SOFTWARE_TYPE = {
|
||||
rotatingmachine: 'machine.json',
|
||||
machine: 'machine.json',
|
||||
machinegroupcontrol: 'machineGroup.json',
|
||||
machinegroup: 'machineGroup.json',
|
||||
pumpingstation: 'pumpingStation.json',
|
||||
valvegroupcontrol: 'valveGroupControl.json',
|
||||
diffuser: 'aeration.json',
|
||||
aeration: 'aeration.json',
|
||||
measurement: 'measurement.json',
|
||||
monster: 'monster.json',
|
||||
reactor: 'reactor.json',
|
||||
settler: 'settler.json',
|
||||
valve: 'valve.json',
|
||||
dashboardapi: 'dashboardapi.json',
|
||||
};
|
||||
|
||||
function defaultBucketForPosition(positionVsParent) {
|
||||
const pos = String(positionVsParent || '').toLowerCase();
|
||||
if (pos === 'upstream') return 'lvl1';
|
||||
@@ -75,6 +97,20 @@ class DashboardApi {
|
||||
this.config.general.logging.logLevel,
|
||||
this.config.general.name
|
||||
);
|
||||
|
||||
// Light state cache for manual regen (#41). Stores the latest child
|
||||
// source object per child id so `regenerate-dashboard` can re-emit
|
||||
// dashboards without waiting for children to re-register.
|
||||
this._lastChildSources = new Map();
|
||||
}
|
||||
|
||||
recordChild(childSource) {
|
||||
const id = childSource?.config?.general?.id;
|
||||
if (id) this._lastChildSources.set(id, childSource);
|
||||
}
|
||||
|
||||
cachedChildSources() {
|
||||
return Array.from(this._lastChildSources.values());
|
||||
}
|
||||
|
||||
_templatesDir() {
|
||||
@@ -84,9 +120,9 @@ class DashboardApi {
|
||||
_templateFileForSoftwareType(softwareType) {
|
||||
const st = String(softwareType || '').trim();
|
||||
const candidates = [
|
||||
TEMPLATE_FILE_BY_SOFTWARE_TYPE[st.toLowerCase()],
|
||||
`${st}.json`,
|
||||
`${st.toLowerCase()}.json`,
|
||||
st === 'machineGroupControl' ? 'machineGroup.json' : null,
|
||||
].filter(Boolean);
|
||||
|
||||
for (const filename of candidates) {
|
||||
@@ -128,7 +164,11 @@ class DashboardApi {
|
||||
nodeConfig?.functionality?.software_type ||
|
||||
'measurement';
|
||||
const nodeId = nodeConfig?.general?.id || nodeConfig?.general?.name || softwareType;
|
||||
const measurementName = `${softwareType}_${nodeId}`;
|
||||
// Mirror outputUtils.formatMsg: telemetry is written under general.name when
|
||||
// set, falling back to `<softwareType>_<id>`. The dashboard's _measurement var
|
||||
// must match that exactly or every panel queries a non-existent series.
|
||||
const measurementName =
|
||||
nodeConfig?.general?.name || `${softwareType}_${nodeConfig?.general?.id || softwareType}`;
|
||||
const title = nodeConfig?.general?.name || String(nodeId);
|
||||
|
||||
// Missing templates are treated as non-fatal: we skip only that dashboard.
|
||||
@@ -154,7 +194,7 @@ class DashboardApi {
|
||||
updateTemplatingVar(dashboard, 'measurement', measurementName);
|
||||
updateTemplatingVar(dashboard, 'bucket', bucket);
|
||||
|
||||
return { dashboard, uid, title, softwareType, nodeId, measurementName };
|
||||
return { dashboard, uid, title, softwareType, nodeId, measurementName, bucket };
|
||||
}
|
||||
|
||||
buildUpsertRequest({ dashboard, folderId, folderUid, overwrite = true }) {
|
||||
@@ -194,43 +234,111 @@ class DashboardApi {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Collect ids that constitute "this dashboardAPI + this child + its grandchildren"
|
||||
// for the diff predicate. Pulls grandchildren via the existing extractChildren walk.
|
||||
// Collect every node id in "this dashboardAPI + this child's full subtree" for
|
||||
// the diff predicate. Recurses the whole registered-child tree (not just
|
||||
// grandchildren) so a change anywhere below a wired root triggers a regen.
|
||||
// `visited` guards cycles / diamond topologies.
|
||||
subtreeIdsFor(dashboardApiNodeId, childSource) {
|
||||
const ids = new Set();
|
||||
if (dashboardApiNodeId) ids.add(dashboardApiNodeId);
|
||||
const childId = childSource?.config?.general?.id;
|
||||
if (childId) ids.add(childId);
|
||||
for (const { childSource: gc } of this.extractChildren(childSource)) {
|
||||
const gcId = gc?.config?.general?.id;
|
||||
if (gcId) ids.add(gcId);
|
||||
}
|
||||
this._collectSubtreeIds(childSource, ids, new Set());
|
||||
return ids;
|
||||
}
|
||||
|
||||
_collectSubtreeIds(nodeSource, ids, visited) {
|
||||
const id = nodeSource?.config?.general?.id;
|
||||
if (id) {
|
||||
if (visited.has(id)) return;
|
||||
visited.add(id);
|
||||
ids.add(id);
|
||||
}
|
||||
for (const { childSource } of this.extractChildren(nodeSource)) {
|
||||
this._collectSubtreeIds(childSource, ids, visited);
|
||||
}
|
||||
}
|
||||
|
||||
// Compose a dashboard for a wired root and EVERY descendant in its registered-
|
||||
// child tree. Operators wire only subtree roots; dashboardAPI recurses the
|
||||
// parent-child relationships to discover the rest. Returns a flat, pre-order
|
||||
// array (root first) of buildDashboard results.
|
||||
generateDashboardsForGraph(rootSource, { includeChildren = true } = {}) {
|
||||
if (!rootSource?.config) {
|
||||
this.logger.warn('generateDashboardsForGraph skipped: root source missing config');
|
||||
return [];
|
||||
}
|
||||
|
||||
const rootPosition = rootSource?.positionVsParent || rootSource?.config?.functionality?.positionVsParent;
|
||||
const rootDash = this.buildDashboard({ nodeConfig: rootSource.config, positionVsParent: rootPosition });
|
||||
if (!rootDash) return [];
|
||||
|
||||
const results = [rootDash];
|
||||
|
||||
if (!includeChildren) return results;
|
||||
|
||||
const children = this.extractChildren(rootSource);
|
||||
for (const { childSource, positionVsParent } of children) {
|
||||
const childDash = this.buildDashboard({ nodeConfig: childSource.config, positionVsParent });
|
||||
if (childDash) results.push(childDash);
|
||||
const results = [];
|
||||
this._composeNode(rootSource, includeChildren, results, new Set());
|
||||
return results;
|
||||
}
|
||||
|
||||
// Add links from the root dashboard to children dashboards (when possible)
|
||||
if (children.length > 0) {
|
||||
rootDash.dashboard.links = Array.isArray(rootDash.dashboard.links) ? rootDash.dashboard.links : [];
|
||||
// Recursively compose `nodeSource` then its descendants. Per-parent dedup and
|
||||
// links are applied at every level (each parent is deduped against / links to
|
||||
// its own direct children). `visited` ensures one dashboard per node id even
|
||||
// when the topology has cycles or diamonds.
|
||||
_composeNode(nodeSource, includeChildren, results, visited) {
|
||||
const nodeId = nodeSource?.config?.general?.id;
|
||||
if (nodeId) {
|
||||
if (visited.has(nodeId)) return null;
|
||||
visited.add(nodeId);
|
||||
}
|
||||
|
||||
const position = nodeSource?.positionVsParent || nodeSource?.config?.functionality?.positionVsParent;
|
||||
const nodeDash = this.buildDashboard({ nodeConfig: nodeSource.config, positionVsParent: position });
|
||||
if (!nodeDash) return null;
|
||||
results.push(nodeDash);
|
||||
|
||||
if (!includeChildren) return nodeDash;
|
||||
|
||||
const children = this.extractChildren(nodeSource);
|
||||
const childDashes = [];
|
||||
for (const { childSource } of children) {
|
||||
const childDash = this._composeNode(childSource, includeChildren, results, visited);
|
||||
if (childDash) childDashes.push(childDash);
|
||||
}
|
||||
|
||||
this._dedupParentPanels(nodeDash, childDashes);
|
||||
this._linkToChildren(nodeDash, children);
|
||||
// Inject the per-pump fan-out panels AFTER dedup so they survive: these
|
||||
// panels intentionally aggregate child data onto the parent dashboard
|
||||
// (the operator wants every pump on one MGC graph), which is exactly what
|
||||
// the no-duplication rule strips elsewhere. Run last so nothing removes them.
|
||||
this._injectMachineGroupPumpPanels(nodeDash, children);
|
||||
|
||||
return nodeDash;
|
||||
}
|
||||
|
||||
// No-data-duplication rule (PRD F-5, #39): remove a parent's panels whose
|
||||
// emittedFields are fully covered by its direct children's panels, so the
|
||||
// same series isn't rendered twice across the parent/child dashboards.
|
||||
_dedupParentPanels(parentDash, childDashes) {
|
||||
if (childDashes.length === 0 || !parentDash.dashboard) return;
|
||||
|
||||
const childCoveredFields = new Set();
|
||||
for (const dash of childDashes) {
|
||||
for (const f of this.collectEmittedFields(dash.dashboard)) childCoveredFields.add(f);
|
||||
}
|
||||
const before = parentDash.dashboard.panels.length;
|
||||
parentDash.dashboard.panels = parentDash.dashboard.panels.filter((p) => {
|
||||
if (p.type === 'row') return true; // never drop rows
|
||||
const fields = p?.meta?.emittedFields;
|
||||
if (!Array.isArray(fields) || fields.length === 0) return true; // no declaration, keep
|
||||
return !fields.every((f) => childCoveredFields.has(f));
|
||||
});
|
||||
if (this.logger?.debug && before !== parentDash.dashboard.panels.length) {
|
||||
this.logger.debug({
|
||||
event: 'parent-panels-deduped',
|
||||
before,
|
||||
after: parentDash.dashboard.panels.length,
|
||||
rootTitle: parentDash.title,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
_linkToChildren(parentDash, children) {
|
||||
if (children.length === 0 || !parentDash.dashboard) return;
|
||||
|
||||
parentDash.dashboard.links = Array.isArray(parentDash.dashboard.links) ? parentDash.dashboard.links : [];
|
||||
for (const { childSource } of children) {
|
||||
const childConfig = childSource.config;
|
||||
const childSoftwareType = childConfig?.functionality?.softwareType || 'measurement';
|
||||
@@ -238,7 +346,7 @@ class DashboardApi {
|
||||
const childUid = stableUid(`${childSoftwareType}:${childNodeId}`);
|
||||
const childTitle = childConfig?.general?.name || String(childNodeId);
|
||||
|
||||
rootDash.dashboard.links.push({
|
||||
parentDash.dashboard.links.push({
|
||||
type: 'link',
|
||||
title: childTitle,
|
||||
url: `/d/${childUid}/${slugify(childTitle)}`,
|
||||
@@ -250,7 +358,221 @@ class DashboardApi {
|
||||
}
|
||||
}
|
||||
|
||||
return results;
|
||||
// Software types that count as a "pump" child of a machine group. Mirrors the
|
||||
// template-alias map: a rotatingMachine reports softwareType 'rotatingmachine'
|
||||
// in production, 'machine' in tests / shared template.
|
||||
static _PUMP_SOFTWARE_TYPES = new Set(['rotatingmachine', 'machine']);
|
||||
|
||||
// Replicate the measurement-name convention from outputUtils.formatMsg /
|
||||
// buildDashboard so the dashboard queries the exact series each pump writes:
|
||||
// `general.name` when set, else `<softwareType>_<id>`.
|
||||
_measurementNameForConfig(config) {
|
||||
const softwareType = config?.functionality?.softwareType || 'measurement';
|
||||
return config?.general?.name || `${softwareType}_${config?.general?.id || softwareType}`;
|
||||
}
|
||||
|
||||
// Datasource block reused for injected panels. Pull it off an existing panel
|
||||
// so the dashboard keeps a single influxdb datasource uid; fall back to the
|
||||
// template's known uid if every panel was deduped away.
|
||||
_datasourceFor(dashboard) {
|
||||
const withDs = (dashboard.panels || []).find((p) => p?.datasource?.type === 'influxdb');
|
||||
return withDs?.datasource || { type: 'influxdb', uid: 'cdzg44tv250jkd' };
|
||||
}
|
||||
|
||||
// Build the per-pump + group-aggregate timeseries panels for a machineGroup
|
||||
// dashboard. The operator asked for one graph each of pump % control, pump
|
||||
// predicted flow, and pump predicted power, with the group total folded in,
|
||||
// the resolved demand overlaid on the flow graph, and the flow-capacity
|
||||
// envelope drawn as dashed min/max lines.
|
||||
//
|
||||
// Per-pump series live in each pump's OWN InfluxDB measurement (not the
|
||||
// MGC's), so the queries are generated at compose time from the known child
|
||||
// topology. Pump series are kept by `_measurement` (legend = pump name);
|
||||
// group series are kept by `_field` and renamed via byName overrides.
|
||||
_injectMachineGroupPumpPanels(parentDash, children) {
|
||||
if (!parentDash?.dashboard) return;
|
||||
const st = String(parentDash.softwareType || '').toLowerCase();
|
||||
if (st !== 'machinegroupcontrol' && st !== 'machinegroup') return;
|
||||
|
||||
const pumps = (children || [])
|
||||
.map(({ childSource }) => childSource?.config)
|
||||
.filter((c) => c && DashboardApi._PUMP_SOFTWARE_TYPES.has(
|
||||
String(c?.functionality?.softwareType || '').toLowerCase()))
|
||||
.map((c) => ({ measurement: this._measurementNameForConfig(c), title: c?.general?.name || c?.general?.id }));
|
||||
|
||||
if (pumps.length === 0) return; // No pumps wired → leave the static totals.
|
||||
|
||||
const dashboard = parentDash.dashboard;
|
||||
const datasource = this._datasourceFor(dashboard);
|
||||
// The richer flow/power panels below supersede the static group-total
|
||||
// panels — drop them so the same series isn't drawn twice.
|
||||
dashboard.panels = (dashboard.panels || []).filter(
|
||||
(p) => p.title !== 'Total Flow' && p.title !== 'Total Power');
|
||||
|
||||
const measFilter = pumps.map((p) => `r._measurement == "${p.measurement}"`).join(' or ');
|
||||
const nextId = Math.max(0, ...dashboard.panels.map((p) => Number(p.id) || 0)) + 1;
|
||||
|
||||
dashboard.panels.push(
|
||||
this._pumpControlPanel({ datasource, measFilter, id: nextId, y: 6 }),
|
||||
this._pumpFlowPanel({ datasource, measFilter, id: nextId + 1, y: 14 }),
|
||||
this._pumpPowerPanel({ datasource, measFilter, id: nextId + 2, y: 22 }),
|
||||
);
|
||||
}
|
||||
|
||||
// ── Injected-panel builders ──────────────────────────────────────────────
|
||||
// All three use `${bucket}` / `${measurement}` template vars (resolved by
|
||||
// Grafana from the dashboard's templating list) plus literal pump measurement
|
||||
// names. v.timeRangeStart/Stop/windowPeriod are Grafana-supplied.
|
||||
|
||||
_baseTsPanel({ datasource, id, y, title, targets, overrides = [], defaults = {} }) {
|
||||
return {
|
||||
datasource,
|
||||
fieldConfig: {
|
||||
defaults: { custom: { drawStyle: 'line', lineWidth: 2, fillOpacity: 5, showPoints: 'never' }, ...defaults },
|
||||
overrides,
|
||||
},
|
||||
gridPos: { h: 8, w: 24, x: 0, y },
|
||||
id,
|
||||
options: { legend: { displayMode: 'list', placement: 'bottom' }, tooltip: { mode: 'multi' } },
|
||||
targets,
|
||||
title,
|
||||
type: 'timeseries',
|
||||
// Empty emittedFields: these panels intentionally duplicate child series
|
||||
// and must never be removed by the no-duplication dedup pass.
|
||||
meta: { emittedFields: [], dynamic: 'mgc-pump-fanout' },
|
||||
};
|
||||
}
|
||||
|
||||
// Pump series kept by `_measurement` → one line per pump, legend = pump name.
|
||||
// `field` is exact-matched by default; pass `regex:true` to match a 4-segment
|
||||
// MeasurementContainer key whose childId varies per pump. rotatingMachine
|
||||
// writes its own predictions under childId = node id (e.g.
|
||||
// `flow.predicted.atequipment.<pumpId>`), NOT a fixed `default`, so the
|
||||
// flow/power series must match the position prefix, not an exact key.
|
||||
_perPumpTarget({ measFilter, field, refId, transform = '', regex = false }) {
|
||||
const fieldFilter = regex ? `r._field =~ /${field}/` : `r._field == "${field}"`;
|
||||
return {
|
||||
refId,
|
||||
query:
|
||||
`from(bucket: "\${bucket}")\n` +
|
||||
` |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n` +
|
||||
` |> filter(fn:(r) => (${measFilter}) and ${fieldFilter})\n` +
|
||||
` |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)\n` +
|
||||
transform +
|
||||
` |> keep(columns: ["_time", "_value", "_measurement"])`,
|
||||
};
|
||||
}
|
||||
|
||||
// Group series kept by `_field` → legend = field name, renamed via byName
|
||||
// overrides. `fields` is OR-joined into one query.
|
||||
_groupFieldsTarget({ fields, refId }) {
|
||||
const filter = fields.map((f) => `r._field == "${f}"`).join(' or ');
|
||||
return {
|
||||
refId,
|
||||
query:
|
||||
`from(bucket: "\${bucket}")\n` +
|
||||
` |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n` +
|
||||
` |> filter(fn:(r) => r._measurement == "\${measurement}" and (${filter}))\n` +
|
||||
` |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)\n` +
|
||||
` |> keep(columns: ["_time", "_value", "_field"])`,
|
||||
};
|
||||
}
|
||||
|
||||
_byName(name, properties) {
|
||||
return { matcher: { id: 'byName', options: name }, properties };
|
||||
}
|
||||
|
||||
_pumpControlPanel({ datasource, measFilter, id, y }) {
|
||||
// Two series per pump so an operator can see at a glance whether each pump
|
||||
// actually moved to where the MGC told it:
|
||||
// • realized position — the bare `ctrl` field (getCurrentPosition), solid.
|
||||
// • commanded setpoint — `ctrl.predicted.atequipment.<pumpId>`, the % the
|
||||
// pump computed from the MGC flow command (calcCtrl reverse curve),
|
||||
// drawn dashed. childId varies per pump, so match the position prefix.
|
||||
// Both are already 0..100 %, so they map straight onto a % axis — no scaling.
|
||||
// Each series' `_measurement` is suffixed so the legend distinguishes the
|
||||
// two lines per pump ("Pump A (realized)" vs "Pump A (setpoint)").
|
||||
const label = (name) =>
|
||||
` |> map(fn: (r) => ({ r with _measurement: r._measurement + " (${name})" }))\n`;
|
||||
return this._baseTsPanel({
|
||||
datasource, id, y,
|
||||
title: 'Pump % Control',
|
||||
defaults: { unit: 'percent', min: 0, max: 100 },
|
||||
targets: [
|
||||
this._perPumpTarget({ measFilter, field: 'ctrl', refId: 'A', transform: label('realized') }),
|
||||
this._perPumpTarget({
|
||||
measFilter, field: '^ctrl\\.predicted\\.atequipment\\.', refId: 'B',
|
||||
regex: true, transform: label('setpoint'),
|
||||
}),
|
||||
],
|
||||
overrides: [{
|
||||
matcher: { id: 'byRegexp', options: '.*\\(setpoint\\)' },
|
||||
properties: [{ id: 'custom.lineStyle', value: { fill: 'dash', dash: [6, 6] } }],
|
||||
}],
|
||||
});
|
||||
}
|
||||
|
||||
_pumpFlowPanel({ datasource, measFilter, id, y }) {
|
||||
return this._baseTsPanel({
|
||||
datasource, id, y,
|
||||
title: 'Pump Predicted Flow vs Demand',
|
||||
defaults: { unit: 'm3/h' },
|
||||
targets: [
|
||||
this._perPumpTarget({ measFilter, field: '^flow\\.predicted\\.atequipment\\.', refId: 'A', regex: true }),
|
||||
this._groupFieldsTarget({
|
||||
refId: 'B',
|
||||
fields: ['atEquipment_predicted_flow', 'demandFlow', 'demandPct', 'flowCapacityMin', 'flowCapacityMax'],
|
||||
}),
|
||||
],
|
||||
overrides: [
|
||||
this._byName('atEquipment_predicted_flow', [
|
||||
{ id: 'displayName', value: 'Total flow' },
|
||||
{ id: 'custom.lineWidth', value: 3 },
|
||||
]),
|
||||
this._byName('demandFlow', [
|
||||
{ id: 'displayName', value: 'Flow demand (setpoint)' },
|
||||
{ id: 'custom.lineStyle', value: { fill: 'dash', dash: [6, 6] } },
|
||||
{ id: 'color', value: { mode: 'fixed', fixedColor: 'blue' } },
|
||||
]),
|
||||
this._byName('demandPct', [
|
||||
{ id: 'displayName', value: 'Demand %' },
|
||||
{ id: 'unit', value: 'percent' },
|
||||
{ id: 'custom.axisPlacement', value: 'right' },
|
||||
{ id: 'custom.axisLabel', value: '% control' },
|
||||
{ id: 'color', value: { mode: 'fixed', fixedColor: 'purple' } },
|
||||
]),
|
||||
this._byName('flowCapacityMin', [
|
||||
{ id: 'displayName', value: 'Capacity min' },
|
||||
{ id: 'custom.lineStyle', value: { fill: 'dash', dash: [10, 10] } },
|
||||
{ id: 'custom.fillOpacity', value: 0 },
|
||||
{ id: 'color', value: { mode: 'fixed', fixedColor: 'orange' } },
|
||||
]),
|
||||
this._byName('flowCapacityMax', [
|
||||
{ id: 'displayName', value: 'Capacity max' },
|
||||
{ id: 'custom.lineStyle', value: { fill: 'dash', dash: [10, 10] } },
|
||||
{ id: 'custom.fillOpacity', value: 0 },
|
||||
{ id: 'color', value: { mode: 'fixed', fixedColor: 'red' } },
|
||||
]),
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
_pumpPowerPanel({ datasource, measFilter, id, y }) {
|
||||
return this._baseTsPanel({
|
||||
datasource, id, y,
|
||||
title: 'Pump Predicted Power',
|
||||
defaults: { unit: 'kwatt' },
|
||||
targets: [
|
||||
this._perPumpTarget({ measFilter, field: '^power\\.predicted\\.atequipment\\.', refId: 'A', regex: true }),
|
||||
this._groupFieldsTarget({ refId: 'B', fields: ['atEquipment_predicted_power'] }),
|
||||
],
|
||||
overrides: [
|
||||
this._byName('atEquipment_predicted_power', [
|
||||
{ id: 'displayName', value: 'Total power' },
|
||||
{ id: 'custom.lineWidth', value: 3 },
|
||||
]),
|
||||
],
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
68
test/_output-manifest.md
Normal file
68
test/_output-manifest.md
Normal file
@@ -0,0 +1,68 @@
|
||||
# dashboardAPI output manifest
|
||||
|
||||
Per `.claude/rules/output-coverage.md`: every output on every layer, in every state.
|
||||
|
||||
## Port 0 (process — Grafana upsert messages)
|
||||
|
||||
Emitted by the command handler(s) after a `child.register` or `regenerate-dashboard` message. Shape is the same for both; `meta.trigger` distinguishes them.
|
||||
|
||||
| Key | Source method | Type | States tested | Test file |
|
||||
|---|---|---|---|---|
|
||||
| `topic` | `handlers.emitDashboardsFor` | `'create'` (literal) | populated | `test/basic/slice41-manual-regen.basic.test.js` |
|
||||
| `url` | `source.grafanaUpsertUrl()` | string (configured Grafana endpoint) | populated, default-config | `test/basic/slice34-credentials-and-folder.basic.test.js` |
|
||||
| `method` | `handlers.emitDashboardsFor` | `'POST'` (literal) | populated | `test/basic/slice41-manual-regen.basic.test.js` |
|
||||
| `headers.Accept` | `handlers.emitDashboardsFor` | `'application/json'` (literal) | populated | _via output manifest test below_ |
|
||||
| `headers['Content-Type']` | `handlers.emitDashboardsFor` | `'application/json'` (literal) | populated | _via output manifest test below_ |
|
||||
| `headers.Authorization` | `handlers.emitDashboardsFor` | `'Bearer <token>'` when configured; absent when not | populated, absent (degraded — no token) | `test/basic/slice43-output-manifest.basic.test.js` |
|
||||
| `payload.dashboard` | `source.buildDashboard()` | object (Grafana dashboard JSON) | populated, byte-identical-on-repeat | `test/basic/slice35-graph-perf-and-uid-uniqueness.basic.test.js` |
|
||||
| `payload.overwrite` | `source.buildUpsertRequest()` | `true` (literal) | populated | `test/basic/slice34-credentials-and-folder.basic.test.js` |
|
||||
| `payload.folderUid` | `source.buildUpsertRequest()` | string when configured; absent when empty | populated, absent (degraded — empty config) | `test/basic/slice34-credentials-and-folder.basic.test.js` |
|
||||
| `payload.folderId` | `source.buildUpsertRequest()` | number when explicitly passed; absent otherwise | absent (default), populated (explicit) | `test/basic/slice34-credentials-and-folder.basic.test.js` |
|
||||
| `meta.nodeId` | `handlers.emitDashboardsFor` | string (child node id) | populated | `test/basic/slice43-output-manifest.basic.test.js` |
|
||||
| `meta.softwareType` | `handlers.emitDashboardsFor` | string (child softwareType) | populated | `test/basic/slice43-output-manifest.basic.test.js` |
|
||||
| `meta.uid` | `handlers.emitDashboardsFor` | string (stableUid hash, deterministic) | populated, byte-identical | `test/basic/slice35-graph-perf-and-uid-uniqueness.basic.test.js` |
|
||||
| `meta.title` | `handlers.emitDashboardsFor` | string (child name or id) | populated | `test/basic/slice43-output-manifest.basic.test.js` |
|
||||
| `meta.trigger` | `handlers.emitDashboardsFor` | `'child.register'` or `'manual'` | both states | `test/basic/slice41-manual-regen.basic.test.js` |
|
||||
|
||||
**Degraded-state convention:** missing keys are **absent**, never set to `null`. The `http request` consumer treats absent headers/payload fields as defaults.
|
||||
|
||||
## Port 1 (InfluxDB telemetry)
|
||||
|
||||
dashboardAPI emits **nothing** on Port 1 by design — it has no measurements, no tick loop, no telemetry. Verified by absence: no `formatForInflux` import, no Port 1 wires in `examples/`.
|
||||
|
||||
## Port 2 (registration / control plumbing)
|
||||
|
||||
dashboardAPI is a **sink** for `child.register` messages, not a source — it does not register itself with any parent. Nothing emitted on Port 2.
|
||||
|
||||
## Structured log outputs
|
||||
|
||||
| Event | Level | Triggered by | Fields | Test |
|
||||
|---|---|---|---|---|
|
||||
| `regen-emitted` | info | successful composition (auto or manual) | `event`, `trigger`, `dashboardApiId`, `childId`, `dashboardCount` | `test/basic/slice43-output-manifest.basic.test.js` |
|
||||
| `regen-skipped` | info | diff predicate says subtree unchanged | `event`, `outcome: 'no-diff'`, `trigger: 'child.register'`, `dashboardApiId`, `childId`, `subtreeSize` | `test/basic/slice43-output-manifest.basic.test.js` |
|
||||
| `manual-regen-requested` | info | `regenerate-dashboard` topic received | `event`, `trigger: 'manual'`, `dashboardApiId`, `cachedChildCount` | `test/basic/slice41-manual-regen.basic.test.js` |
|
||||
| `parent-panels-deduped` | debug | no-data-duplication filter removed root panels | `event`, `before`, `after`, `rootTitle` | _covered by composition tests in slice39_ |
|
||||
| `flows:started` | debug | Node-RED runtime emits flows:started | `event: 'flows:started'`, `type`, `diff` (count summary) | _covered by predicate tests in slice36_ |
|
||||
|
||||
## specificClass return shapes
|
||||
|
||||
| Method | Return shape | Populated states | Degraded states | Test |
|
||||
|---|---|---|---|---|
|
||||
| `buildDashboard(opts)` | `{ dashboard, uid, title, softwareType, nodeId, measurementName, bucket }` or `null`; `measurementName` mirrors `outputUtils.formatMsg` (`general.name` \|\| `<softwareType>_<id>`) so the dashboard `_measurement` var matches the telemetry series; `bucket` is the resolved Influx bucket | success (name set + name empty/fallback) | `null` when no template for softwareType | `test/basic/slice43-output-manifest.basic.test.js`, `test/basic/slice46-measurement-name-parity.basic.test.js` |
|
||||
| `generateDashboardsForGraph(root)` | flat pre-order array of `buildDashboard` results (root first, then full descendant subtree); per-parent dedup + links applied at every level; machineGroup roots additionally get per-pump fan-out panels injected (see below) | 0..N children, 3-level tree, diamond, cycle | empty array when root config missing | `test/basic/slice35-graph-perf-and-uid-uniqueness.basic.test.js`, `test/basic/slice44-recursive-discovery.basic.test.js` |
|
||||
| `_injectMachineGroupPumpPanels(parentDash, children)` | mutates an MGC dashboard in place: replaces the static Total Flow/Power panels with 3 timeseries panels (Pump % Control, Pump Predicted Flow vs Demand, Pump Predicted Power) whose queries are generated from the child-pump measurement names. Panels carry `meta.emittedFields: []` so they survive the dedup pass | MGC with ≥1 rotatingMachine child | no-op for non-MGC dashboards or MGC with zero pump children (static totals retained) | `test/basic/slice47-mgc-pump-panels.basic.test.js` |
|
||||
| `subtreeChanged(diff, ids)` | boolean | id-in-diff, no-id-in-diff | null diff → true (cold start) | `test/basic/slice36-diff-predicate.basic.test.js` |
|
||||
| `subtreeIdsFor(myId, child)` | Set\<string\> | myId + every id in the child's full subtree (recurses all levels, cycle-safe) | myId only when child has no children | `test/basic/slice36-diff-predicate.basic.test.js`, `test/basic/slice44-recursive-discovery.basic.test.js` |
|
||||
| `collectEmittedFields(dashboard)` | Set\<string\> | populated dashboard | empty set for `null`/`{}`/`{panels:[]}` | `test/basic/slice37-emitted-fields.basic.test.js` |
|
||||
| `cachedChildSources()` | array of child sources | 0..N cached | empty after construction | `test/basic/slice41-manual-regen.basic.test.js` |
|
||||
|
||||
## Anti-patterns enforced
|
||||
|
||||
- ❌ Emitting `{payload: null}` — `handlers.emitDashboardsFor` always builds `payload: { dashboard, overwrite, ... }`. Verified.
|
||||
- ❌ Mixing absent vs null for optional fields — `folderUid` / `folderId` are **absent** when unconfigured, never `null`. Verified.
|
||||
- ❌ Per-call token stamping — token is set on `headers.Authorization` when configured; absent when not. No empty-string sentinel.
|
||||
- ❌ Tab id over-triggering in diff predicate — predicate only matches against dashboardAPI's own id + child + grandchildren, never tab ids. Verified.
|
||||
|
||||
## Migration plan applied
|
||||
|
||||
This manifest is created together with slice #43 — the new outputs added in slices #34–#42 are documented here. Other EVOLV nodes still need their own manifests; tracked in `IMPROVEMENTS_BACKLOG.md`.
|
||||
102
test/basic/slice39-no-duplication.basic.test.js
Normal file
102
test/basic/slice39-no-duplication.basic.test.js
Normal file
@@ -0,0 +1,102 @@
|
||||
'use strict';
|
||||
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
|
||||
const DashboardApi = require('../../src/specificClass.js');
|
||||
|
||||
function makeChild(id, softwareType) {
|
||||
return {
|
||||
config: {
|
||||
general: { id, name: id },
|
||||
functionality: { softwareType, positionVsParent: 'downstream' },
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function makeRoot(softwareType, children) {
|
||||
const map = new Map();
|
||||
for (const c of children) {
|
||||
map.set(c.config.general.id, {
|
||||
child: c,
|
||||
softwareType: c.config.functionality.softwareType,
|
||||
position: 'downstream',
|
||||
});
|
||||
}
|
||||
return {
|
||||
config: {
|
||||
general: { id: 'root-1', name: 'PS-North' },
|
||||
functionality: { softwareType, positionVsParent: 'atequipment' },
|
||||
},
|
||||
childRegistrationUtils: { registeredChildren: map },
|
||||
};
|
||||
}
|
||||
|
||||
test('pumpingStation template has emittedFields on every non-row panel', () => {
|
||||
const api = new DashboardApi({});
|
||||
const dash = api.loadTemplate('pumpingStation');
|
||||
const annotated = dash.panels.filter((p) => p.type !== 'row' && p?.meta?.emittedFields);
|
||||
const nonRowPanels = dash.panels.filter((p) => p.type !== 'row');
|
||||
assert.equal(annotated.length, nonRowPanels.length,
|
||||
`expected all ${nonRowPanels.length} non-row panels annotated, got ${annotated.length}`);
|
||||
});
|
||||
|
||||
test('child-covered fields remove duplicate parent panels', () => {
|
||||
const api = new DashboardApi({});
|
||||
|
||||
// Parent + 1 child with a fake template that emits 'level' (matches one of
|
||||
// the pumpingStation parent's panels). The parent's "Level" panel should
|
||||
// be removed when the child covers it.
|
||||
const child1 = makeChild('child-1', 'measurement');
|
||||
const root = makeRoot('pumpingStation', [child1]);
|
||||
|
||||
// Pre-count parent panels with the 'level' emitted field.
|
||||
const parentTemplate = api.loadTemplate('pumpingStation');
|
||||
const parentLevelPanels = parentTemplate.panels.filter(
|
||||
(p) => p?.meta?.emittedFields?.includes('level')
|
||||
);
|
||||
assert.ok(parentLevelPanels.length > 0, 'parent has level panels in template');
|
||||
|
||||
// Monkey-patch the child's dashboard to claim it covers 'level'.
|
||||
const origLoad = api.loadTemplate.bind(api);
|
||||
api.loadTemplate = function (type) {
|
||||
const dash = origLoad(type);
|
||||
if (type === 'measurement' && dash) {
|
||||
// Inject emittedFields = ['level'] on first non-row panel.
|
||||
const firstPanel = dash.panels.find((p) => p.type !== 'row');
|
||||
if (firstPanel) (firstPanel.meta ||= {}).emittedFields = ['level'];
|
||||
}
|
||||
return dash;
|
||||
};
|
||||
|
||||
const result = api.generateDashboardsForGraph(root);
|
||||
const rootResult = result[0];
|
||||
const rootLevelPanels = rootResult.dashboard.panels.filter(
|
||||
(p) => p?.meta?.emittedFields?.includes('level')
|
||||
);
|
||||
assert.equal(rootLevelPanels.length, 0,
|
||||
'level panel(s) should be removed from parent when child covers them');
|
||||
});
|
||||
|
||||
test('parent panels are kept when no child covers their fields', () => {
|
||||
const api = new DashboardApi({});
|
||||
const child1 = makeChild('child-1', 'measurement'); // measurement.json has no emittedFields
|
||||
const root = makeRoot('pumpingStation', [child1]);
|
||||
const result = api.generateDashboardsForGraph(root);
|
||||
const rootResult = result[0];
|
||||
const beforeTemplate = api.loadTemplate('pumpingStation');
|
||||
const beforeNonRow = beforeTemplate.panels.filter((p) => p.type !== 'row').length;
|
||||
const afterNonRow = rootResult.dashboard.panels.filter((p) => p.type !== 'row').length;
|
||||
assert.equal(afterNonRow, beforeNonRow,
|
||||
'no panels should be removed when no child declares overlapping fields');
|
||||
});
|
||||
|
||||
test('row panels are never removed (structural)', () => {
|
||||
const api = new DashboardApi({});
|
||||
const child1 = makeChild('child-1', 'measurement');
|
||||
const root = makeRoot('pumpingStation', [child1]);
|
||||
const result = api.generateDashboardsForGraph(root);
|
||||
const rootRows = result[0].dashboard.panels.filter((p) => p.type === 'row');
|
||||
const templateRows = api.loadTemplate('pumpingStation').panels.filter((p) => p.type === 'row');
|
||||
assert.equal(rootRows.length, templateRows.length, 'all row panels preserved');
|
||||
});
|
||||
69
test/basic/slice40-mgc-template.basic.test.js
Normal file
69
test/basic/slice40-mgc-template.basic.test.js
Normal file
@@ -0,0 +1,69 @@
|
||||
'use strict';
|
||||
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
|
||||
const DashboardApi = require('../../src/specificClass.js');
|
||||
|
||||
test('MGC template panels are all group-level (no per-pump fields)', () => {
|
||||
const api = new DashboardApi({});
|
||||
const dash = api.loadTemplate('machineGroup');
|
||||
const PER_PUMP = new Set(['ctrl', 'state', 'runtime', 'pressure.upstream', 'pressure.downstream', 'temperature']);
|
||||
for (const panel of dash.panels || []) {
|
||||
if (panel.type === 'row') continue;
|
||||
const fields = panel?.meta?.emittedFields || [];
|
||||
for (const f of fields) {
|
||||
assert.ok(!PER_PUMP.has(f),
|
||||
`MGC panel "${panel.title}" emits ${f}, which belongs to rotatingMachine (per-pump). Move to children.`);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('MGC group panels are annotated (mode, scaling, abs/rel peak, totals)', () => {
|
||||
const api = new DashboardApi({});
|
||||
const dash = api.loadTemplate('machineGroup');
|
||||
const non = dash.panels.filter((p) => p.type !== 'row');
|
||||
const annotated = non.filter((p) => p?.meta?.emittedFields);
|
||||
assert.equal(annotated.length, non.length, 'every non-row MGC panel annotated');
|
||||
});
|
||||
|
||||
test('MGC timeseries panels carry dashed-bounds overrides for .min/.max', () => {
|
||||
const api = new DashboardApi({});
|
||||
const dash = api.loadTemplate('machineGroup');
|
||||
const ts = dash.panels.filter((p) => p.type === 'timeseries');
|
||||
for (const panel of ts) {
|
||||
const ov = panel?.fieldConfig?.overrides || [];
|
||||
const hasMin = ov.some((o) => o.matcher?.id === 'byRegexp' && /\.min\$/.test(o.matcher?.options || ''));
|
||||
const hasMax = ov.some((o) => o.matcher?.id === 'byRegexp' && /\.max\$/.test(o.matcher?.options || ''));
|
||||
assert.ok(hasMin && hasMax, `MGC ts panel "${panel.title}" missing .min/.max dashed override`);
|
||||
}
|
||||
});
|
||||
|
||||
test('MGC composer dedups parent panels covered by pump children', () => {
|
||||
// If a rotatingMachine child claims to emit `flow.total` (it shouldn't, but
|
||||
// suppose), the parent MGC's "Total Flow" panel would be removed. Verify
|
||||
// the composer applies the same dedup rule to MGC parents.
|
||||
const api = new DashboardApi({});
|
||||
function makeChildSrc(id) {
|
||||
return { config: { general: { id }, functionality: { softwareType: 'machine', positionVsParent: 'downstream' } } };
|
||||
}
|
||||
const child = makeChildSrc('pump-1');
|
||||
const root = {
|
||||
config: { general: { id: 'mgc-1', name: 'MGC' }, functionality: { softwareType: 'machineGroupControl', positionVsParent: 'atequipment' } },
|
||||
childRegistrationUtils: { registeredChildren: new Map([['pump-1', { child, position: 'downstream', softwareType: 'machine' }]]) },
|
||||
};
|
||||
const origLoad = api.loadTemplate.bind(api);
|
||||
api.loadTemplate = function (t) {
|
||||
const dash = origLoad(t);
|
||||
if (t === 'machine') {
|
||||
// Make the pump's template falsely claim it emits flow.total/flow.group
|
||||
const firstPanel = dash.panels.find((p) => p.type !== 'row');
|
||||
if (firstPanel) (firstPanel.meta ||= {}).emittedFields = ['flow.total', 'flow.group'];
|
||||
}
|
||||
return dash;
|
||||
};
|
||||
const results = api.generateDashboardsForGraph(root);
|
||||
const mgcDash = results[0].dashboard;
|
||||
const totalFlowPanel = mgcDash.panels.find((p) => p.title === 'Total Flow');
|
||||
assert.ok(!totalFlowPanel, 'MGC Total Flow panel should be removed when child claims flow.total/flow.group');
|
||||
});
|
||||
75
test/basic/slice41-manual-regen.basic.test.js
Normal file
75
test/basic/slice41-manual-regen.basic.test.js
Normal file
@@ -0,0 +1,75 @@
|
||||
'use strict';
|
||||
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
|
||||
const DashboardApi = require('../../src/specificClass.js');
|
||||
const handlers = require('../../src/commands/handlers.js');
|
||||
|
||||
function makeCtx(sends, nodeId = 'dApi-1') {
|
||||
return {
|
||||
node: { id: nodeId },
|
||||
RED: { nodes: { getNode: () => null } },
|
||||
send: (m) => sends.push(m),
|
||||
logger: null,
|
||||
};
|
||||
}
|
||||
|
||||
function makeChildPayload(id, softwareType = 'measurement') {
|
||||
return {
|
||||
config: {
|
||||
general: { id, name: id },
|
||||
functionality: { softwareType, positionVsParent: 'downstream' },
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
test('recordChild caches child source by id; subsequent ones replace by id', () => {
|
||||
const api = new DashboardApi({});
|
||||
api.recordChild(makeChildPayload('a'));
|
||||
api.recordChild(makeChildPayload('b'));
|
||||
api.recordChild(makeChildPayload('a')); // replace
|
||||
assert.equal(api.cachedChildSources().length, 2);
|
||||
});
|
||||
|
||||
test('regenerate-dashboard with no cached children is a no-op (no msgs emitted)', () => {
|
||||
const api = new DashboardApi({});
|
||||
const sends = [];
|
||||
handlers.regenerateDashboard(api, { topic: 'regenerate-dashboard', payload: {} }, makeCtx(sends));
|
||||
assert.equal(sends.length, 0);
|
||||
});
|
||||
|
||||
test('regenerate-dashboard re-emits for each cached child, bypassing diff', () => {
|
||||
const api = new DashboardApi({});
|
||||
// Pre-populate cache as if two children had registered.
|
||||
api.recordChild(makeChildPayload('m-1'));
|
||||
api.recordChild(makeChildPayload('m-2'));
|
||||
|
||||
// Set a diff that says nothing changed — registerChild would skip, but
|
||||
// regenerateDashboard should ignore the predicate.
|
||||
api.lastFlowsStartedDiff = { added: [], changed: [], removed: [], rewired: [] };
|
||||
|
||||
const sends = [];
|
||||
handlers.regenerateDashboard(api, { topic: 'regenerate-dashboard', payload: {} }, makeCtx(sends));
|
||||
// Each child yields at least one dashboard message (the root for the child's view).
|
||||
assert.ok(sends.length >= 2, `expected ≥2 emitted msgs, got ${sends.length}`);
|
||||
// Every emitted msg carries trigger: 'manual' in meta.
|
||||
for (const m of sends) assert.equal(m.meta?.trigger, 'manual');
|
||||
});
|
||||
|
||||
test('child.register stamps trigger: child.register in emitted msg meta', () => {
|
||||
const api = new DashboardApi({});
|
||||
api.lastFlowsStartedDiff = null; // cold-start → always regen
|
||||
const sends = [];
|
||||
handlers.registerChild(api, { topic: 'child.register', payload: makeChildPayload('m-3') }, makeCtx(sends));
|
||||
assert.ok(sends.length >= 1);
|
||||
for (const m of sends) assert.equal(m.meta?.trigger, 'child.register');
|
||||
});
|
||||
|
||||
test('command registry exposes regenerate-dashboard with regen alias', () => {
|
||||
const registry = require('../../src/commands/index.js');
|
||||
const entry = registry.find((e) => e.topic === 'regenerate-dashboard');
|
||||
assert.ok(entry, 'topic registered');
|
||||
assert.deepEqual(entry.aliases, ['regen']);
|
||||
assert.equal(typeof entry.handler, 'function');
|
||||
});
|
||||
146
test/basic/slice43-output-manifest.basic.test.js
Normal file
146
test/basic/slice43-output-manifest.basic.test.js
Normal file
@@ -0,0 +1,146 @@
|
||||
'use strict';
|
||||
|
||||
// Output-coverage tests per .claude/rules/output-coverage.md and
|
||||
// test/_output-manifest.md. Every output is exercised in both populated
|
||||
// and degraded states.
|
||||
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
|
||||
const DashboardApi = require('../../src/specificClass.js');
|
||||
const handlers = require('../../src/commands/handlers.js');
|
||||
|
||||
function makeChild(id, name = id, softwareType = 'measurement') {
|
||||
return {
|
||||
config: {
|
||||
general: { id, name },
|
||||
functionality: { softwareType, positionVsParent: 'downstream' },
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function makeCtx(nodeId = 'dApi-1') {
|
||||
const sends = [];
|
||||
const logs = [];
|
||||
return {
|
||||
sends,
|
||||
logs,
|
||||
ctx: {
|
||||
node: { id: nodeId },
|
||||
RED: { nodes: { getNode: () => null } },
|
||||
send: (m) => sends.push(m),
|
||||
logger: null,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
// ── Port 0 message shape: populated ────────────────────────────────────
|
||||
test('Port 0 emit has all required keys when token + folderUid configured', () => {
|
||||
const api = new DashboardApi({
|
||||
grafanaConnector: { protocol: 'http', host: 'grafana', port: 3000, bearerToken: 'tok', folderUid: 'rnd-folder' },
|
||||
});
|
||||
api.lastFlowsStartedDiff = null; // cold start
|
||||
const { sends, ctx } = makeCtx();
|
||||
handlers.registerChild(api, { topic: 'child.register', payload: makeChild('m-1', 'FT-001') }, ctx);
|
||||
|
||||
assert.ok(sends.length >= 1);
|
||||
const m = sends[0];
|
||||
assert.equal(m.topic, 'create');
|
||||
assert.equal(m.method, 'POST');
|
||||
assert.equal(m.headers['Accept'], 'application/json');
|
||||
assert.equal(m.headers['Content-Type'], 'application/json');
|
||||
assert.equal(m.headers.Authorization, 'Bearer tok');
|
||||
assert.match(m.url, /^http:\/\/grafana:3000\/api\/dashboards\/db$/);
|
||||
assert.equal(m.payload.overwrite, true);
|
||||
assert.ok(m.payload.dashboard, 'dashboard JSON present');
|
||||
assert.equal(m.payload.folderUid, 'rnd-folder');
|
||||
// meta
|
||||
assert.equal(m.meta.nodeId, 'm-1');
|
||||
assert.equal(m.meta.softwareType, 'measurement');
|
||||
assert.equal(typeof m.meta.uid, 'string');
|
||||
assert.equal(m.meta.title, 'FT-001');
|
||||
assert.equal(m.meta.trigger, 'child.register');
|
||||
});
|
||||
|
||||
// ── Port 0 degraded: token absent, folderUid absent ───────────────────
|
||||
test('Port 0 emit omits Authorization header when no bearerToken configured', () => {
|
||||
const api = new DashboardApi({}); // no creds
|
||||
api.lastFlowsStartedDiff = null;
|
||||
const { sends, ctx } = makeCtx();
|
||||
handlers.registerChild(api, { topic: 'child.register', payload: makeChild('m-2') }, ctx);
|
||||
const m = sends[0];
|
||||
assert.equal(m.headers.Authorization, undefined,
|
||||
'Authorization should be absent (not empty string, not null)');
|
||||
assert.equal(m.payload.folderUid, undefined,
|
||||
'folderUid should be absent when empty');
|
||||
assert.equal('folderId' in m.payload, false,
|
||||
'folderId should also be absent (not 0)');
|
||||
});
|
||||
|
||||
// ── Port 0 degraded: no template for softwareType ─────────────────────
|
||||
test('Port 0 emits no message when child softwareType has no template', () => {
|
||||
const api = new DashboardApi({});
|
||||
api.lastFlowsStartedDiff = null;
|
||||
const { sends, ctx } = makeCtx();
|
||||
// 'nonexistent' has no config/<>.json file
|
||||
handlers.registerChild(api, { topic: 'child.register', payload: makeChild('m-3', 'm-3', 'nonexistent') }, ctx);
|
||||
assert.equal(sends.length, 0, 'no upsert message should be emitted when template missing');
|
||||
});
|
||||
|
||||
// ── Diff-skip path: no emission, logged outcome:no-diff ───────────────
|
||||
test('Diff-skip suppresses Port 0 emission AND records the skip in source.logger', () => {
|
||||
const api = new DashboardApi({});
|
||||
// Set diff so the predicate returns false (no overlap with subtree).
|
||||
api.lastFlowsStartedDiff = { added: ['unrelated'], changed: [], removed: [], rewired: [] };
|
||||
// Stub logger to capture
|
||||
const captured = [];
|
||||
api.logger = { info: (e) => captured.push(e), debug: () => {} };
|
||||
|
||||
const { sends, ctx } = makeCtx('dApi-1');
|
||||
handlers.registerChild(api, { topic: 'child.register', payload: makeChild('m-4') }, ctx);
|
||||
|
||||
assert.equal(sends.length, 0, 'no upsert emitted when subtree unchanged');
|
||||
const skipLog = captured.find((e) => e.event === 'regen-skipped');
|
||||
assert.ok(skipLog, 'skip log emitted');
|
||||
assert.equal(skipLog.outcome, 'no-diff');
|
||||
assert.equal(skipLog.trigger, 'child.register');
|
||||
assert.equal(skipLog.dashboardApiId, 'dApi-1');
|
||||
assert.equal(skipLog.childId, 'm-4');
|
||||
});
|
||||
|
||||
// ── Successful regen logs structured fields per N-4 ───────────────────
|
||||
test('Successful regen logs event=regen-emitted with N-4 fields', () => {
|
||||
const api = new DashboardApi({});
|
||||
api.lastFlowsStartedDiff = null; // cold start → always regen
|
||||
const captured = [];
|
||||
api.logger = { info: (e) => captured.push(e), debug: () => {} };
|
||||
|
||||
const { ctx } = makeCtx('dApi-1');
|
||||
handlers.registerChild(api, { topic: 'child.register', payload: makeChild('m-5') }, ctx);
|
||||
|
||||
const emitLog = captured.find((e) => e.event === 'regen-emitted');
|
||||
assert.ok(emitLog, 'regen-emitted log present');
|
||||
assert.equal(emitLog.trigger, 'child.register');
|
||||
assert.equal(emitLog.dashboardApiId, 'dApi-1');
|
||||
assert.equal(emitLog.childId, 'm-5');
|
||||
assert.equal(typeof emitLog.dashboardCount, 'number');
|
||||
});
|
||||
|
||||
// ── Manual regen logs manual-regen-requested + emits with trigger:manual ─
|
||||
test('Manual regen logs manual-regen-requested and stamps trigger=manual', () => {
|
||||
const api = new DashboardApi({});
|
||||
api.recordChild(makeChild('m-6'));
|
||||
const captured = [];
|
||||
api.logger = { info: (e) => captured.push(e), debug: () => {} };
|
||||
|
||||
const { sends, ctx } = makeCtx();
|
||||
handlers.regenerateDashboard(api, { topic: 'regenerate-dashboard', payload: {} }, ctx);
|
||||
|
||||
const reqLog = captured.find((e) => e.event === 'manual-regen-requested');
|
||||
assert.ok(reqLog, 'manual-regen-requested log present');
|
||||
assert.equal(reqLog.cachedChildCount, 1);
|
||||
|
||||
if (sends.length > 0) {
|
||||
assert.equal(sends[0].meta.trigger, 'manual');
|
||||
}
|
||||
});
|
||||
104
test/basic/slice44-recursive-discovery.basic.test.js
Normal file
104
test/basic/slice44-recursive-discovery.basic.test.js
Normal file
@@ -0,0 +1,104 @@
|
||||
'use strict';
|
||||
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
|
||||
const DashboardApi = require('../../src/specificClass.js');
|
||||
|
||||
// Build a source node with an optional registered-child Map. `children` is an
|
||||
// array of source nodes; each is wrapped in the { child, position, softwareType }
|
||||
// entry shape that childRegistrationUtils.registeredChildren uses at runtime.
|
||||
function makeNode(id, softwareType, children = [], positionVsParent = 'downstream') {
|
||||
const map = new Map();
|
||||
for (const c of children) {
|
||||
map.set(c.config.general.id, {
|
||||
child: c,
|
||||
softwareType: c.config.functionality.softwareType,
|
||||
position: c.config.functionality.positionVsParent || 'downstream',
|
||||
});
|
||||
}
|
||||
return {
|
||||
config: {
|
||||
general: { id, name: id },
|
||||
functionality: { softwareType, positionVsParent },
|
||||
},
|
||||
childRegistrationUtils: { registeredChildren: map },
|
||||
};
|
||||
}
|
||||
|
||||
test('recurses a 3-level tree from a single wired root', () => {
|
||||
const api = new DashboardApi({});
|
||||
// dashboardapi(root) -> machineGroup(child) -> machine(grandchild)
|
||||
const grandchild = makeNode('rm-1', 'machine');
|
||||
const child = makeNode('mgc-1', 'machineGroupControl', [grandchild]);
|
||||
const root = makeNode('ps-1', 'pumpingStation', [child], 'atequipment');
|
||||
|
||||
const dashboards = api.generateDashboardsForGraph(root);
|
||||
const ids = dashboards.map((d) => d.nodeId);
|
||||
|
||||
assert.deepEqual(ids, ['ps-1', 'mgc-1', 'rm-1'], 'pre-order: root, child, grandchild');
|
||||
assert.equal(dashboards[0].nodeId, 'ps-1', 'root composed first');
|
||||
});
|
||||
|
||||
test('each parent links only to its own direct children (per-level links)', () => {
|
||||
const api = new DashboardApi({});
|
||||
const grandchild = makeNode('rm-1', 'machine');
|
||||
const child = makeNode('mgc-1', 'machineGroupControl', [grandchild]);
|
||||
const root = makeNode('ps-1', 'pumpingStation', [child], 'atequipment');
|
||||
|
||||
const dashboards = api.generateDashboardsForGraph(root);
|
||||
const byId = Object.fromEntries(dashboards.map((d) => [d.nodeId, d.dashboard]));
|
||||
|
||||
assert.equal(byId['ps-1'].links.length, 1, 'root links to its one direct child');
|
||||
assert.equal(byId['ps-1'].links[0].title, 'mgc-1');
|
||||
assert.equal(byId['mgc-1'].links.length, 1, 'child links to its one grandchild');
|
||||
assert.equal(byId['mgc-1'].links[0].title, 'rm-1');
|
||||
assert.ok(!byId['rm-1'].links || byId['rm-1'].links.length === 0, 'leaf has no child links');
|
||||
});
|
||||
|
||||
test('cycle protection: a node reachable twice is composed once', () => {
|
||||
const api = new DashboardApi({});
|
||||
const a = makeNode('a', 'pumpingStation', [], 'atequipment');
|
||||
const b = makeNode('b', 'machineGroupControl');
|
||||
// wire a -> b and b -> a (cycle)
|
||||
a.childRegistrationUtils.registeredChildren.set('b', { child: b, softwareType: 'machineGroupControl', position: 'downstream' });
|
||||
b.childRegistrationUtils.registeredChildren.set('a', { child: a, softwareType: 'pumpingStation', position: 'downstream' });
|
||||
|
||||
const dashboards = api.generateDashboardsForGraph(a);
|
||||
const ids = dashboards.map((d) => d.nodeId).sort();
|
||||
assert.deepEqual(ids, ['a', 'b'], 'each node composed exactly once despite the cycle');
|
||||
});
|
||||
|
||||
test('diamond topology: shared descendant composed once', () => {
|
||||
const api = new DashboardApi({});
|
||||
const shared = makeNode('shared', 'machine');
|
||||
const left = makeNode('left', 'machineGroupControl', [shared]);
|
||||
const right = makeNode('right', 'machineGroupControl', [shared]);
|
||||
const root = makeNode('root', 'pumpingStation', [left, right], 'atequipment');
|
||||
|
||||
const dashboards = api.generateDashboardsForGraph(root);
|
||||
const sharedCount = dashboards.filter((d) => d.nodeId === 'shared').length;
|
||||
assert.equal(sharedCount, 1, 'shared grandchild gets a single dashboard');
|
||||
});
|
||||
|
||||
test('subtreeIdsFor recurses the full subtree (great-grandchildren included)', () => {
|
||||
const api = new DashboardApi({});
|
||||
const ggc = makeNode('ggc-1', 'measurement');
|
||||
const gc = makeNode('gc-1', 'machine', [ggc]);
|
||||
const child = makeNode('child-1', 'machineGroupControl', [gc]);
|
||||
|
||||
const ids = api.subtreeIdsFor('dApi-1', child);
|
||||
assert.ok(ids.has('dApi-1') && ids.has('child-1') && ids.has('gc-1') && ids.has('ggc-1'));
|
||||
assert.equal(ids.size, 4, 'dashboardAPI + child + grandchild + great-grandchild');
|
||||
});
|
||||
|
||||
test('includeChildren:false composes only the root (no recursion)', () => {
|
||||
const api = new DashboardApi({});
|
||||
const grandchild = makeNode('rm-1', 'machine');
|
||||
const child = makeNode('mgc-1', 'machineGroupControl', [grandchild]);
|
||||
const root = makeNode('ps-1', 'pumpingStation', [child], 'atequipment');
|
||||
|
||||
const dashboards = api.generateDashboardsForGraph(root, { includeChildren: false });
|
||||
assert.equal(dashboards.length, 1);
|
||||
assert.equal(dashboards[0].nodeId, 'ps-1');
|
||||
});
|
||||
50
test/basic/slice45-template-aliases.basic.test.js
Normal file
50
test/basic/slice45-template-aliases.basic.test.js
Normal file
@@ -0,0 +1,50 @@
|
||||
'use strict';
|
||||
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
|
||||
const DashboardApi = require('../../src/specificClass.js');
|
||||
|
||||
// softwareType (as reported at runtime, lowercased) -> the template that must resolve.
|
||||
const CASES = [
|
||||
['rotatingmachine', 'machine.json'],
|
||||
['machinegroupcontrol', 'machineGroup.json'],
|
||||
['pumpingstation', 'pumpingStation.json'],
|
||||
['valvegroupcontrol', 'valveGroupControl.json'],
|
||||
['diffuser', 'aeration.json'],
|
||||
['measurement', 'measurement.json'],
|
||||
['reactor', 'reactor.json'],
|
||||
['settler', 'settler.json'],
|
||||
['valve', 'valve.json'],
|
||||
['monster', 'monster.json'],
|
||||
];
|
||||
|
||||
for (const [softwareType, file] of CASES) {
|
||||
test(`softwareType '${softwareType}' resolves to ${file}`, () => {
|
||||
const api = new DashboardApi({});
|
||||
const resolved = api._templateFileForSoftwareType(softwareType);
|
||||
assert.ok(resolved, `expected a template path for ${softwareType}`);
|
||||
assert.ok(resolved.endsWith(file), `expected ${file}, got ${resolved}`);
|
||||
});
|
||||
}
|
||||
|
||||
test('resolution is case-insensitive (camelCase softwareType still resolves)', () => {
|
||||
const api = new DashboardApi({});
|
||||
assert.ok(api._templateFileForSoftwareType('rotatingMachine').endsWith('machine.json'));
|
||||
assert.ok(api._templateFileForSoftwareType('machineGroupControl').endsWith('machineGroup.json'));
|
||||
});
|
||||
|
||||
test('rotatingmachine now builds a dashboard (was: no template found)', () => {
|
||||
const api = new DashboardApi({});
|
||||
const built = api.buildDashboard({
|
||||
nodeConfig: { general: { id: 'rm-1', name: 'Pump A' }, functionality: { softwareType: 'rotatingmachine' } },
|
||||
positionVsParent: 'downstream',
|
||||
});
|
||||
assert.ok(built, 'expected a built dashboard, not null');
|
||||
assert.equal(built.softwareType, 'rotatingmachine');
|
||||
});
|
||||
|
||||
test('unknown softwareType still returns null (no template)', () => {
|
||||
const api = new DashboardApi({});
|
||||
assert.equal(api._templateFileForSoftwareType('totally-unknown-type'), null);
|
||||
});
|
||||
62
test/basic/slice46-measurement-name-parity.basic.test.js
Normal file
62
test/basic/slice46-measurement-name-parity.basic.test.js
Normal file
@@ -0,0 +1,62 @@
|
||||
// The dashboard's `_measurement` templating var MUST equal the InfluxDB
|
||||
// measurement name that outputUtils.formatMsg writes telemetry under, or every
|
||||
// panel queries a non-existent series and renders blank.
|
||||
//
|
||||
// outputUtils convention (generalFunctions/src/helper/outputUtils.js):
|
||||
// measurement = config.general.name || `${softwareType}_${config.general.id}`
|
||||
//
|
||||
// buildDashboard must mirror it exactly.
|
||||
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
|
||||
const DashboardApi = require('../../src/specificClass');
|
||||
|
||||
function makeApi() {
|
||||
return new DashboardApi({
|
||||
general: { name: 'dapi', logging: { enabled: false, logLevel: 'error' } },
|
||||
grafanaConnector: { protocol: 'http', host: 'localhost', port: 3000, bearerToken: '' },
|
||||
});
|
||||
}
|
||||
|
||||
function measurementVar(dash) {
|
||||
return dash.dashboard.templating.list.find((v) => v.name === 'measurement').current.value;
|
||||
}
|
||||
|
||||
test('measurement var uses general.name when set (matches outputUtils)', () => {
|
||||
const api = makeApi();
|
||||
const dash = api.buildDashboard({
|
||||
nodeConfig: {
|
||||
general: { id: '248ba213d44df5b9', name: 'pumpingStation' },
|
||||
functionality: { softwareType: 'pumpingstation' },
|
||||
},
|
||||
positionVsParent: 'atequipment',
|
||||
});
|
||||
assert.equal(dash.measurementName, 'pumpingStation');
|
||||
assert.equal(measurementVar(dash), 'pumpingStation');
|
||||
});
|
||||
|
||||
test('measurement var falls back to <softwareType>_<id> when name is empty', () => {
|
||||
const api = makeApi();
|
||||
const dash = api.buildDashboard({
|
||||
nodeConfig: {
|
||||
general: { id: '693ebd559017d39f', name: '' },
|
||||
functionality: { softwareType: 'rotatingmachine' },
|
||||
},
|
||||
positionVsParent: 'atequipment',
|
||||
});
|
||||
assert.equal(dash.measurementName, 'rotatingmachine_693ebd559017d39f');
|
||||
assert.equal(measurementVar(dash), 'rotatingmachine_693ebd559017d39f');
|
||||
});
|
||||
|
||||
test('fallback id segment is the node id, not the title', () => {
|
||||
const api = makeApi();
|
||||
const dash = api.buildDashboard({
|
||||
nodeConfig: {
|
||||
general: { id: 'abc123' },
|
||||
functionality: { softwareType: 'measurement' },
|
||||
},
|
||||
positionVsParent: 'upstream',
|
||||
});
|
||||
assert.equal(dash.measurementName, 'measurement_abc123');
|
||||
});
|
||||
156
test/basic/slice47-mgc-pump-panels.basic.test.js
Normal file
156
test/basic/slice47-mgc-pump-panels.basic.test.js
Normal file
@@ -0,0 +1,156 @@
|
||||
'use strict';
|
||||
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
|
||||
const DashboardApi = require('../../src/specificClass.js');
|
||||
|
||||
// Build an MGC root with N rotatingMachine children, compose the graph, and
|
||||
// return the MGC dashboard (results[0]).
|
||||
function composeMgcWith(pumpDefs) {
|
||||
const api = new DashboardApi({});
|
||||
const entries = pumpDefs.map((p) => [p.id, {
|
||||
child: { config: { general: { id: p.id, name: p.name }, functionality: { softwareType: p.softwareType || 'machine', positionVsParent: 'downstream' } } },
|
||||
position: 'downstream',
|
||||
}]);
|
||||
const root = {
|
||||
config: { general: { id: 'mgc-1', name: 'MGC' }, functionality: { softwareType: 'machineGroupControl', positionVsParent: 'atequipment' } },
|
||||
childRegistrationUtils: { registeredChildren: new Map(entries) },
|
||||
};
|
||||
return { api, dash: api.generateDashboardsForGraph(root)[0].dashboard };
|
||||
}
|
||||
|
||||
const PUMPS = [
|
||||
{ id: 'pump-a', name: 'Pump A' },
|
||||
{ id: 'pump-b', name: 'Pump B' },
|
||||
];
|
||||
|
||||
test('MGC dashboard gains the three pump fan-out panels', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const titles = dash.panels.filter((p) => p.type === 'timeseries').map((p) => p.title);
|
||||
assert.ok(titles.includes('Pump % Control'), 'missing % control panel');
|
||||
assert.ok(titles.includes('Pump Predicted Flow vs Demand'), 'missing flow panel');
|
||||
assert.ok(titles.includes('Pump Predicted Power'), 'missing power panel');
|
||||
});
|
||||
|
||||
test('static group-total panels are replaced by the richer fan-out panels', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const titles = dash.panels.map((p) => p.title);
|
||||
assert.ok(!titles.includes('Total Flow'), 'static Total Flow should be removed');
|
||||
assert.ok(!titles.includes('Total Power'), 'static Total Power should be removed');
|
||||
});
|
||||
|
||||
test('% control query targets every pump measurement; ctrl is already percent (no scaling)', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const panel = dash.panels.find((p) => p.title === 'Pump % Control');
|
||||
const q = panel.targets[0].query;
|
||||
assert.match(q, /r\._measurement == "Pump A"/);
|
||||
assert.match(q, /r\._measurement == "Pump B"/);
|
||||
assert.match(q, /r\._field == "ctrl"/);
|
||||
assert.ok(!/_value \* 100/.test(q), 'ctrl is 0..100 already — must NOT be ×100 scaled');
|
||||
assert.equal(panel.fieldConfig.defaults.unit, 'percent');
|
||||
});
|
||||
|
||||
test('% control plots both realized position and commanded setpoint per pump', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const panel = dash.panels.find((p) => p.title === 'Pump % Control');
|
||||
const realized = panel.targets.find((t) => /r\._field == "ctrl"/.test(t.query));
|
||||
const setpoint = panel.targets.find((t) => /ctrl\\\.predicted\\\.atequipment/.test(t.query));
|
||||
assert.ok(realized, 'missing realized-position (ctrl) series');
|
||||
assert.ok(setpoint, 'missing commanded-setpoint (ctrl.predicted.atequipment) series');
|
||||
// childId varies per pump → setpoint must be a regex (=~) prefix match.
|
||||
assert.match(setpoint.query, /r\._field =~ \/\^ctrl\\\.predicted\\\.atequipment\\\.\//);
|
||||
assert.ok(!/\.default/.test(setpoint.query), 'must not hardcode childId .default');
|
||||
// Legend disambiguation: each series suffixes its _measurement.
|
||||
assert.match(realized.query, /\(realized\)/);
|
||||
assert.match(setpoint.query, /\(setpoint\)/);
|
||||
});
|
||||
|
||||
test('setpoint series is drawn dashed to distinguish it from realized', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const panel = dash.panels.find((p) => p.title === 'Pump % Control');
|
||||
const ov = panel.fieldConfig.overrides.find((o) => /setpoint/.test(o.matcher.options));
|
||||
assert.ok(ov, 'missing dashed override for setpoint series');
|
||||
assert.equal(ov.matcher.id, 'byRegexp');
|
||||
const lineStyle = ov.properties.find((p) => p.id === 'custom.lineStyle')?.value;
|
||||
assert.equal(lineStyle?.fill, 'dash', 'setpoint must be dashed');
|
||||
});
|
||||
|
||||
test('per-pump flow/power match the position prefix (childId varies per pump)', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const flowQ = dash.panels.find((p) => p.title === 'Pump Predicted Flow vs Demand').targets[0].query;
|
||||
const powerQ = dash.panels.find((p) => p.title === 'Pump Predicted Power').targets[0].query;
|
||||
// Regex field match (=~), not an exact `.default` key, so it catches
|
||||
// `flow.predicted.atequipment.<pumpId>` whatever the childId is.
|
||||
assert.match(flowQ, /r\._field =~ \/\^flow\\\.predicted\\\.atequipment\\\.\//);
|
||||
assert.match(powerQ, /r\._field =~ \/\^power\\\.predicted\\\.atequipment\\\.\//);
|
||||
assert.ok(!/\.default/.test(flowQ), 'must not hardcode childId .default');
|
||||
});
|
||||
|
||||
test('measurement name falls back to <softwareType>_<id> when name is unset', () => {
|
||||
const { dash } = composeMgcWith([{ id: 'p9', softwareType: 'rotatingmachine' }]);
|
||||
const panel = dash.panels.find((p) => p.title === 'Pump % Control');
|
||||
assert.match(panel.targets[0].query, /r\._measurement == "rotatingmachine_p9"/);
|
||||
});
|
||||
|
||||
test('flow panel folds in total flow, demand setpoint, demand %, and per-pump flow', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const panel = dash.panels.find((p) => p.title === 'Pump Predicted Flow vs Demand');
|
||||
const queries = panel.targets.map((t) => t.query).join('\n');
|
||||
assert.match(queries, /flow\\\.predicted\\\.atequipment/, 'per-pump flow field');
|
||||
assert.match(queries, /atEquipment_predicted_flow/, 'group total flow field');
|
||||
assert.match(queries, /demandFlow/, 'resolved flow setpoint field');
|
||||
assert.match(queries, /demandPct/, 'demand percent field');
|
||||
});
|
||||
|
||||
test('flow capacity envelope is drawn as dashed min/max lines', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const panel = dash.panels.find((p) => p.title === 'Pump Predicted Flow vs Demand');
|
||||
const byName = Object.fromEntries(
|
||||
panel.fieldConfig.overrides.map((o) => [o.matcher.options, o.properties]));
|
||||
for (const cap of ['flowCapacityMin', 'flowCapacityMax']) {
|
||||
const props = byName[cap];
|
||||
assert.ok(props, `missing override for ${cap}`);
|
||||
const lineStyle = props.find((p) => p.id === 'custom.lineStyle')?.value;
|
||||
assert.equal(lineStyle?.fill, 'dash', `${cap} must be dashed`);
|
||||
}
|
||||
});
|
||||
|
||||
test('demand % is placed on a secondary (right) axis in percent', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const panel = dash.panels.find((p) => p.title === 'Pump Predicted Flow vs Demand');
|
||||
const props = panel.fieldConfig.overrides.find((o) => o.matcher.options === 'demandPct')?.properties || [];
|
||||
assert.equal(props.find((p) => p.id === 'unit')?.value, 'percent');
|
||||
assert.equal(props.find((p) => p.id === 'custom.axisPlacement')?.value, 'right');
|
||||
});
|
||||
|
||||
test('power panel folds total power in with per-pump power', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const panel = dash.panels.find((p) => p.title === 'Pump Predicted Power');
|
||||
const queries = panel.targets.map((t) => t.query).join('\n');
|
||||
assert.match(queries, /power\\\.predicted\\\.atequipment/, 'per-pump power field');
|
||||
assert.match(queries, /atEquipment_predicted_power/, 'group total power field');
|
||||
});
|
||||
|
||||
test('injected panels are exempt from the no-duplication dedup (empty emittedFields)', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const dynamic = dash.panels.filter((p) => p?.meta?.dynamic === 'mgc-pump-fanout');
|
||||
assert.equal(dynamic.length, 3);
|
||||
for (const p of dynamic) assert.deepEqual(p.meta.emittedFields, []);
|
||||
});
|
||||
|
||||
test('a machineGroup with no pump children keeps the static template panels', () => {
|
||||
const { dash } = composeMgcWith([
|
||||
{ id: 'm1', name: 'Meter', softwareType: 'measurement' },
|
||||
]);
|
||||
const titles = dash.panels.map((p) => p.title);
|
||||
assert.ok(titles.includes('Total Flow'), 'static totals must remain when no pumps');
|
||||
assert.ok(!titles.includes('Pump % Control'), 'no fan-out panels without pumps');
|
||||
});
|
||||
|
||||
test('injected panels reuse the dashboard influxdb datasource uid', () => {
|
||||
const { dash } = composeMgcWith(PUMPS);
|
||||
const panel = dash.panels.find((p) => p.title === 'Pump % Control');
|
||||
assert.equal(panel.datasource.type, 'influxdb');
|
||||
assert.equal(panel.datasource.uid, 'cdzg44tv250jkd');
|
||||
});
|
||||
@@ -46,7 +46,8 @@ describe('DashboardApi specificClass', () => {
|
||||
const measurement = templ.find((v) => v.name === 'measurement');
|
||||
const bucket = templ.find((v) => v.name === 'bucket');
|
||||
|
||||
expect(measurement.current.value).toBe('measurement_m-1');
|
||||
// measurement var must mirror outputUtils: general.name when set.
|
||||
expect(measurement.current.value).toBe('PT-1');
|
||||
expect(bucket.current.value).toBe('lvl3');
|
||||
});
|
||||
|
||||
|
||||
Reference in New Issue
Block a user