1 contributor
module.exports = function(RED) {
function Z2MZG204ZVHomeBusNode(config) {
RED.nodes.createNode(this, config);
var node = this;
node.adapterId = "z2m-zg-204zv";
node.sourceTopic = "zigbee2mqtt/ZG-204ZV/#";
node.subscriptionStarted = false;
node.startTimer = null;
node.legacyRoom = normalizeToken(config.mqttRoom);
node.legacySensor = normalizeToken(config.mqttSensor);
node.legacyBus = normalizeToken(config.mqttBus);
node.publishCache = Object.create(null);
node.retainedCache = Object.create(null);
node.seenOptionalCapabilities = Object.create(null);
node.detectedDevices = Object.create(null);
node.stats = {
processed_inputs: 0,
devices_detected: 0,
home_messages: 0,
last_messages: 0,
meta_messages: 0,
home_availability_messages: 0,
operational_messages: 0,
invalid_messages: 0,
invalid_topics: 0,
invalid_payloads: 0,
unmapped_messages: 0,
adapter_exceptions: 0,
errors: 0,
dlq: 0
};
node.statsPublishEvery = 25;
node.batteryLowThreshold = Number(config.batteryLowThreshold);
if (!Number.isFinite(node.batteryLowThreshold)) node.batteryLowThreshold = 20;
node.batteryType = normalizeToken(config.batteryType).toLowerCase() || "alkaline";
var CAPABILITY_MAPPINGS = [
{
sourceSystem: "zigbee2mqtt",
sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",
sourceFields: ["presence", "occupancy"],
targetBus: "home",
targetCapability: "motion",
core: true,
stream: "value",
payloadProfile: "scalar",
dataType: "boolean",
historianMode: "event",
historianEnabled: true,
applies: function(payload) {
return readNumber(payload, "fading_time") === 0;
},
read: function(payload) {
return readBool(payload, this.sourceFields);
}
},
{
sourceSystem: "zigbee2mqtt",
sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",
sourceFields: ["presence", "occupancy"],
targetBus: "home",
targetCapability: "presence",
core: true,
stream: "value",
payloadProfile: "scalar",
dataType: "boolean",
historianMode: "state",
historianEnabled: true,
applies: function(payload) {
var fadingTime = readNumber(payload, "fading_time");
return fadingTime === undefined || fadingTime !== 0;
},
read: function(payload) {
return readBool(payload, this.sourceFields);
}
},
{
sourceSystem: "zigbee2mqtt",
sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",
sourceFields: ["temperature"],
targetBus: "home",
targetCapability: "temperature",
core: true,
stream: "value",
payloadProfile: "scalar",
dataType: "number",
unit: "C",
precision: 0.1,
historianMode: "sample",
historianEnabled: true,
read: function(payload) {
return readNumber(payload, this.sourceFields[0]);
}
},
{
sourceSystem: "zigbee2mqtt",
sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",
sourceFields: ["humidity"],
targetBus: "home",
targetCapability: "humidity",
core: true,
stream: "value",
payloadProfile: "scalar",
dataType: "number",
unit: "%",
precision: 1,
historianMode: "sample",
historianEnabled: true,
read: function(payload) {
return readNumber(payload, this.sourceFields[0]);
}
},
{
sourceSystem: "zigbee2mqtt",
sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",
sourceFields: ["illuminance"],
targetBus: "home",
targetCapability: "illuminance",
core: true,
stream: "value",
payloadProfile: "scalar",
dataType: "number",
unit: "lx",
precision: 1,
historianMode: "sample",
historianEnabled: true,
read: function(payload) {
return readNumber(payload, this.sourceFields[0]);
}
},
{
sourceSystem: "zigbee2mqtt",
sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",
sourceFields: ["battery"],
targetBus: "home",
targetCapability: "battery",
core: true,
stream: "value",
payloadProfile: "scalar",
dataType: "number",
unit: "%",
precision: 1,
historianMode: "sample",
historianEnabled: true,
read: function(payload) {
var value = readNumber(payload, this.sourceFields[0]);
if (value === undefined) return undefined;
return translateBatteryLevel(value);
}
},
{
sourceSystem: "zigbee2mqtt",
sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",
sourceFields: ["battery_low", "batteryLow", "battery"],
targetBus: "home",
targetCapability: "battery_low",
core: true,
stream: "value",
payloadProfile: "scalar",
dataType: "boolean",
historianMode: "state",
historianEnabled: true,
read: function(payload) {
var raw = readBool(payload, this.sourceFields.slice(0, 2));
if (raw !== undefined) return raw;
var battery = translateBatteryLevel(readNumber(payload, this.sourceFields[2]));
if (battery === undefined) return undefined;
return battery <= node.batteryLowThreshold;
}
},
{
sourceSystem: "zigbee2mqtt",
sourceTopicMatch: "zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>",
sourceFields: ["tamper", "tampered", "tamper_alarm", "alarm_tamper"],
targetBus: "home",
targetCapability: "tamper",
core: false,
stream: "value",
payloadProfile: "scalar",
dataType: "boolean",
historianMode: "state",
historianEnabled: true,
read: function(payload) {
return readBool(payload, this.sourceFields);
}
}
];
function normalizeToken(value) {
if (value === undefined || value === null) return "";
return String(value).trim();
}
function transliterate(value) {
var s = normalizeToken(value);
if (!s) return "";
if (typeof s.normalize === "function") {
s = s.normalize("NFKD").replace(/[\u0300-\u036f]/g, "");
}
return s;
}
function toKebabCase(value, fallback) {
var s = transliterate(value).toLowerCase().replace(/[^a-z0-9]+/g, "-");
s = s.replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
return s || fallback || "";
}
function clamp(n, min, max) {
return Math.max(min, Math.min(max, n));
}
var ALKALINE_BATTERY_CURVE = [
{ pct: 100, voltage: 1.60 },
{ pct: 90, voltage: 1.55 },
{ pct: 80, voltage: 1.50 },
{ pct: 70, voltage: 1.46 },
{ pct: 60, voltage: 1.42 },
{ pct: 50, voltage: 1.36 },
{ pct: 40, voltage: 1.30 },
{ pct: 30, voltage: 1.25 },
{ pct: 20, voltage: 1.20 },
{ pct: 10, voltage: 1.10 },
{ pct: 0, voltage: 0.90 }
];
var NIMH_BATTERY_CURVE = [
{ pct: 100, voltage: 1.40 },
{ pct: 95, voltage: 1.33 },
{ pct: 90, voltage: 1.28 },
{ pct: 85, voltage: 1.24 },
{ pct: 80, voltage: 1.20 },
{ pct: 75, voltage: 1.19 },
{ pct: 70, voltage: 1.18 },
{ pct: 60, voltage: 1.17 },
{ pct: 50, voltage: 1.16 },
{ pct: 40, voltage: 1.15 },
{ pct: 30, voltage: 1.13 },
{ pct: 20, voltage: 1.11 },
{ pct: 10, voltage: 1.07 },
{ pct: 0, voltage: 1.00 }
];
function interpolateCurve(points, inputKey, outputKey, inputValue) {
if (!Array.isArray(points) || points.length === 0) return undefined;
if (inputValue >= points[0][inputKey]) return points[0][outputKey];
for (var i = 1; i < points.length; i++) {
var upper = points[i - 1];
var lower = points[i];
var upperInput = upper[inputKey];
var lowerInput = lower[inputKey];
if (inputValue >= lowerInput) {
var range = upperInput - lowerInput;
if (range <= 0) return lower[outputKey];
var ratio = (inputValue - lowerInput) / range;
return lower[outputKey] + ratio * (upper[outputKey] - lower[outputKey]);
}
}
return points[points.length - 1][outputKey];
}
function translateBatteryLevel(rawValue) {
if (rawValue === undefined) return undefined;
var raw = clamp(Math.round(Number(rawValue)), 0, 100);
if (node.batteryType !== "nimh") return raw;
// Reinterpret the reported percentage on an alkaline discharge curve,
// then project the equivalent cell voltage onto a flatter NiMH curve.
var estimatedVoltage = interpolateCurve(ALKALINE_BATTERY_CURVE, "pct", "voltage", raw);
var nimhPct = interpolateCurve(NIMH_BATTERY_CURVE, "voltage", "pct", estimatedVoltage);
return clamp(Math.round(nimhPct), 0, 100);
}
function topicTokens(topic) {
if (typeof topic !== "string") return [];
return topic.split("/").map(function(token) { return token.trim(); }).filter(function(token) { return !!token; });
}
function asBool(value) {
if (typeof value === "boolean") return value;
if (typeof value === "number") return value !== 0;
if (typeof value === "string") {
var v = value.trim().toLowerCase();
if (v === "true" || v === "1" || v === "on" || v === "yes" || v === "online") return true;
if (v === "false" || v === "0" || v === "off" || v === "no" || v === "offline") return false;
}
return null;
}
function pickFirst(obj, keys) {
if (!obj || typeof obj !== "object") return undefined;
for (var i = 0; i < keys.length; i++) {
if (Object.prototype.hasOwnProperty.call(obj, keys[i])) return obj[keys[i]];
}
return undefined;
}
function pickPath(obj, path) {
if (!obj || typeof obj !== "object") return undefined;
var parts = path.split(".");
var current = obj;
for (var i = 0; i < parts.length; i++) {
if (!current || typeof current !== "object" || !Object.prototype.hasOwnProperty.call(current, parts[i])) return undefined;
current = current[parts[i]];
}
return current;
}
function pickFirstPath(obj, paths) {
for (var i = 0; i < paths.length; i++) {
var value = pickPath(obj, paths[i]);
if (value !== undefined && value !== null && normalizeToken(value) !== "") return value;
}
return undefined;
}
function readBool(payload, fields) {
var raw = asBool(pickFirst(payload, fields));
return raw === null ? undefined : raw;
}
function readNumber(payload, field) {
if (!payload || typeof payload !== "object") return undefined;
var value = payload[field];
if (typeof value !== "number" || !isFinite(value)) return undefined;
return Number(value);
}
function toIsoTimestamp(value) {
if (value === undefined || value === null) return "";
if (value instanceof Date && !isNaN(value.getTime())) return value.toISOString();
if (typeof value === "number" && isFinite(value)) {
var ms = value < 100000000000 ? value * 1000 : value;
var dateFromNumber = new Date(ms);
return isNaN(dateFromNumber.getTime()) ? "" : dateFromNumber.toISOString();
}
if (typeof value === "string") {
var trimmed = value.trim();
if (!trimmed) return "";
if (/^\d+$/.test(trimmed)) return toIsoTimestamp(Number(trimmed));
var dateFromString = new Date(trimmed);
return isNaN(dateFromString.getTime()) ? "" : dateFromString.toISOString();
}
return "";
}
function canonicalSourceTopic(topic) {
var t = normalizeToken(topic);
if (!t) return "";
if (/\/availability$/i.test(t)) return t.replace(/\/availability$/i, "");
return t;
}
function inferFromTopic(topic) {
var tokens = topicTokens(topic);
var result = {
deviceType: "",
site: "",
location: "",
deviceId: "",
friendlyName: "",
isAvailabilityTopic: false
};
if (tokens.length >= 2 && tokens[0].toLowerCase() === "zigbee2mqtt") {
result.deviceType = tokens[1];
if (tokens.length >= 6 && tokens[5].toLowerCase() === "availability") {
result.site = tokens[2];
result.location = tokens[3];
result.deviceId = tokens[4];
result.friendlyName = tokens.slice(1, 5).join("/");
result.isAvailabilityTopic = true;
return result;
}
if (tokens.length >= 5 && tokens[4].toLowerCase() !== "availability") {
result.site = tokens[2];
result.location = tokens[3];
result.deviceId = tokens[4];
result.friendlyName = tokens.slice(1, 5).join("/");
return result;
}
if (tokens.length >= 5 && tokens[4].toLowerCase() === "availability") {
result.location = tokens[2];
result.deviceId = tokens[3];
result.friendlyName = tokens.slice(1, 4).join("/");
result.isAvailabilityTopic = true;
return result;
}
if (tokens.length >= 4) {
result.location = tokens[2];
result.deviceId = tokens[3];
result.friendlyName = tokens.slice(1, 4).join("/");
return result;
}
result.friendlyName = tokens.slice(1).join("/");
result.deviceId = tokens[1];
result.isAvailabilityTopic = tokens.length >= 3 && tokens[tokens.length - 1].toLowerCase() === "availability";
return result;
}
if (tokens.length >= 5 && tokens[1].toLowerCase() === "home") {
result.site = tokens[0];
result.location = tokens[2];
result.deviceId = tokens[4];
result.isAvailabilityTopic = tokens.length >= 6 && tokens[5].toLowerCase() === "availability";
return result;
}
if (tokens.length >= 4) {
result.site = tokens[0];
result.location = tokens[2];
result.deviceId = tokens[3];
} else if (tokens.length >= 2) {
result.location = tokens[tokens.length - 2];
result.deviceId = tokens[tokens.length - 1];
} else if (tokens.length === 1) {
result.deviceId = tokens[0];
}
return result;
}
function resolveIdentity(msg, payload) {
var safeMsg = (msg && typeof msg === "object") ? msg : {};
var inferred = inferFromTopic(safeMsg.topic);
var siteRaw = inferred.site
|| normalizeToken(pickFirst(payload, ["site", "homeSite"]))
|| normalizeToken(pickFirst(safeMsg, ["site", "homeSite"]))
|| "";
var locationRaw = inferred.location
|| normalizeToken(pickFirst(payload, ["location", "room", "homeLocation", "mqttRoom"]))
|| normalizeToken(pickFirst(safeMsg, ["location", "room", "homeLocation", "mqttRoom"]))
|| node.legacyRoom
|| "";
var deviceRaw = inferred.deviceId
|| normalizeToken(pickFirst(payload, ["deviceId", "device_id", "sensor", "mqttSensor", "friendly_name", "friendlyName", "name", "device"]))
|| normalizeToken(pickFirst(safeMsg, ["deviceId", "device_id", "sensor", "mqttSensor"]))
|| node.legacySensor
|| inferred.friendlyName
|| inferred.deviceType;
var displayName = normalizeToken(pickFirst(payload, ["display_name", "displayName", "friendly_name", "friendlyName", "name"]))
|| normalizeToken(pickFirst(safeMsg, ["display_name", "displayName", "friendly_name", "friendlyName", "name"]))
|| inferred.friendlyName
|| deviceRaw
|| "ZG-204ZV";
var sourceRef = normalizeToken(pickFirstPath(payload, ["source_ref", "sourceRef", "ieee_address", "ieeeAddr", "device.ieee_address", "device.ieeeAddr"]))
|| normalizeToken(pickFirstPath(safeMsg, ["source_ref", "sourceRef", "ieee_address", "ieeeAddr", "device.ieee_address", "device.ieeeAddr"]))
|| canonicalSourceTopic(safeMsg.topic)
|| inferred.friendlyName
|| inferred.deviceType
|| deviceRaw
|| "z2m-zg-204zv";
return {
site: toKebabCase(siteRaw, "unknown"),
location: toKebabCase(locationRaw, "unknown"),
deviceId: toKebabCase(deviceRaw, toKebabCase(inferred.deviceType, "zg-204zv")),
displayName: displayName,
sourceRef: sourceRef,
sourceTopic: canonicalSourceTopic(safeMsg.topic),
isAvailabilityTopic: inferred.isAvailabilityTopic
};
}
function noteDevice(identity) {
if (!identity) return;
var key = identity.site + "/" + identity.location + "/" + identity.deviceId;
if (node.detectedDevices[key]) return;
node.detectedDevices[key] = true;
node.stats.devices_detected += 1;
}
function validateInboundTopic(topic) {
var rawTopic = normalizeToken(topic);
if (!rawTopic) {
return {
valid: false,
reason: "Topic must be a non-empty string"
};
}
var tokens = rawTopic.split("/").map(function(token) {
return token.trim();
});
if (tokens.length < 5) {
return {
valid: false,
reason: "Topic must match zigbee2mqtt/ZG-204ZV/<site>/<location>/<device_id>[/availability]"
};
}
if (tokens[0].toLowerCase() !== "zigbee2mqtt" || tokens[1].toLowerCase() !== "zg-204zv") {
return {
valid: false,
reason: "Topic must start with zigbee2mqtt/ZG-204ZV"
};
}
if (!tokens[2] || !tokens[3] || !tokens[4]) {
return {
valid: false,
reason: "Topic must contain non-empty site, location and device_id segments"
};
}
if (tokens.length === 5) {
return {
valid: true,
isAvailabilityTopic: false
};
}
if (tokens.length === 6 && tokens[5].toLowerCase() === "availability") {
return {
valid: true,
isAvailabilityTopic: true
};
}
return {
valid: false,
reason: "Topic must not contain extra segments beyond an optional /availability suffix"
};
}
function translatedMessageCount() {
return node.stats.home_messages + node.stats.last_messages + node.stats.meta_messages + node.stats.home_availability_messages;
}
function updateNodeStatus(fill, shape, suffix) {
var parts = [
"dev " + node.stats.devices_detected,
"in " + node.stats.processed_inputs,
"tr " + translatedMessageCount()
];
if (node.stats.operational_messages > 0) parts.push("op " + node.stats.operational_messages);
if (node.stats.errors > 0) parts.push("err " + node.stats.errors);
if (node.stats.invalid_topics > 0) parts.push("topic " + node.stats.invalid_topics);
if (node.stats.invalid_messages > 0) parts.push("msg " + node.stats.invalid_messages);
if (node.stats.invalid_payloads > 0) parts.push("payload " + node.stats.invalid_payloads);
if (node.stats.unmapped_messages > 0) parts.push("unmapped " + node.stats.unmapped_messages);
if (node.stats.adapter_exceptions > 0) parts.push("exc " + node.stats.adapter_exceptions);
if (node.stats.dlq > 0) parts.push("dlq " + node.stats.dlq);
if (suffix) parts.push(suffix);
node.status({
fill: fill,
shape: shape,
text: parts.join(" | ")
});
}
function buildHomeTopic(identity, mapping, stream) {
return identity.site + "/" + mapping.targetBus + "/" + identity.location + "/" + mapping.targetCapability + "/" + identity.deviceId + "/" + stream;
}
function buildSysTopic(site, stream) {
return site + "/sys/adapter/" + node.adapterId + "/" + stream;
}
function makePublishMsg(topic, payload, retain) {
return {
topic: topic,
payload: payload,
qos: 1,
retain: !!retain
};
}
function makeSubscribeMsg(topic) {
return {
action: "subscribe",
topic: [{
topic: topic,
qos: 2,
rh: 0,
rap: true
}]
};
}
function signature(value) {
return JSON.stringify(value);
}
function shouldPublishLiveValue(cacheKey, payload) {
var sig = signature(payload);
if (node.publishCache[cacheKey] === sig) return false;
node.publishCache[cacheKey] = sig;
return true;
}
function shouldPublishRetained(cacheKey, payload) {
var sig = signature(payload);
if (node.retainedCache[cacheKey] === sig) return false;
node.retainedCache[cacheKey] = sig;
return true;
}
function humanizeCapability(capability) {
return capability.replace(/_/g, " ").replace(/\b[a-z]/g, function(ch) { return ch.toUpperCase(); });
}
function resolveObservation(msg, payloadObject) {
var safeMsg = (msg && typeof msg === "object") ? msg : {};
var observedAtRaw = pickFirstPath(payloadObject, [
"observed_at",
"observedAt",
"timestamp",
"time",
"ts",
"last_seen",
"lastSeen",
"device.last_seen",
"device.lastSeen"
]) || pickFirstPath(safeMsg, [
"observed_at",
"observedAt",
"timestamp",
"time",
"ts"
]);
var observedAt = toIsoTimestamp(observedAtRaw);
if (observedAt) {
return {
observedAt: observedAt,
quality: "good"
};
}
return {
observedAt: new Date().toISOString(),
quality: "estimated"
};
}
function buildMetaPayload(identity, mapping) {
var payload = {
schema_ref: "mqbus.home.v1",
payload_profile: mapping.payloadProfile,
stream_payload_profiles: {
value: "scalar",
last: "envelope"
},
data_type: mapping.dataType,
adapter_id: node.adapterId,
source: mapping.sourceSystem,
source_ref: identity.sourceRef,
source_topic: identity.sourceTopic,
display_name: identity.displayName + " " + humanizeCapability(mapping.targetCapability),
tags: [mapping.sourceSystem, "zg-204zv", mapping.targetBus],
historian: {
enabled: !!mapping.historianEnabled,
mode: mapping.historianMode
}
};
if (mapping.unit) payload.unit = mapping.unit;
if (mapping.precision !== undefined) payload.precision = mapping.precision;
return payload;
}
function buildLastPayload(value, observation) {
var payload = {
value: value,
observed_at: observation.observedAt
};
if (observation.quality && observation.quality !== "good") payload.quality = observation.quality;
return payload;
}
function noteMessage(kind) {
if (!Object.prototype.hasOwnProperty.call(node.stats, kind)) return;
node.stats[kind] += 1;
}
function noteErrorKind(code) {
if (code === "invalid_message") {
noteMessage("invalid_messages");
} else if (code === "invalid_topic") {
noteMessage("invalid_topics");
} else if (code === "payload_not_object" || code === "invalid_availability_payload") {
noteMessage("invalid_payloads");
} else if (code === "no_mapped_fields") {
noteMessage("unmapped_messages");
} else if (code === "adapter_exception") {
noteMessage("adapter_exceptions");
}
}
function summarizeForLog(value) {
if (value === undefined) return "undefined";
if (value === null) return "null";
if (typeof value === "string") {
return value.length > 180 ? value.slice(0, 177) + "..." : value;
}
try {
var serialized = JSON.stringify(value);
if (serialized.length > 180) return serialized.slice(0, 177) + "...";
return serialized;
} catch (err) {
return String(value);
}
}
function logIssue(level, code, reason, msg, rawPayload) {
var parts = [
"[" + node.adapterId + "]",
code + ":",
reason
];
var sourceTopic = msg && typeof msg === "object" ? normalizeToken(msg.topic) : "";
if (sourceTopic) parts.push("topic=" + sourceTopic);
if (rawPayload !== undefined) parts.push("payload=" + summarizeForLog(rawPayload));
var text = parts.join(" ");
if (level === "error") {
node.error(text, msg);
return;
}
node.warn(text);
}
function enqueueHomeMeta(messages, identity, mapping) {
var topic = buildHomeTopic(identity, mapping, "meta");
var payload = buildMetaPayload(identity, mapping);
if (!shouldPublishRetained("meta:" + topic, payload)) return;
messages.push(makePublishMsg(topic, payload, true));
noteMessage("meta_messages");
}
function enqueueHomeAvailability(messages, identity, mapping, online) {
var topic = buildHomeTopic(identity, mapping, "availability");
var payload = online ? "online" : "offline";
if (!shouldPublishRetained("availability:" + topic, payload)) return;
messages.push(makePublishMsg(topic, payload, true));
noteMessage("home_availability_messages");
}
function enqueueHomeLast(messages, identity, mapping, value, observation) {
var topic = buildHomeTopic(identity, mapping, "last");
var payload = buildLastPayload(value, observation);
if (!shouldPublishRetained("last:" + topic, payload)) return;
messages.push(makePublishMsg(topic, payload, true));
noteMessage("last_messages");
}
function enqueueHomeValue(messages, identity, mapping, value) {
var topic = buildHomeTopic(identity, mapping, "value");
if (!shouldPublishLiveValue("value:" + topic, value)) return;
messages.push(makePublishMsg(topic, value, false));
noteMessage("home_messages");
}
function enqueueAdapterAvailability(messages, site, online) {
var topic = buildSysTopic(site, "availability");
var payload = online ? "online" : "offline";
if (!shouldPublishRetained("sys:availability:" + topic, payload)) return;
messages.push(makePublishMsg(topic, payload, true));
noteMessage("operational_messages");
}
function enqueueAdapterStats(messages, site, force) {
if (!force && node.stats.processed_inputs !== 1 && (node.stats.processed_inputs % node.statsPublishEvery) !== 0) return;
var topic = buildSysTopic(site, "stats");
var payload = {
processed_inputs: node.stats.processed_inputs,
devices_detected: node.stats.devices_detected,
translated_messages: translatedMessageCount(),
home_messages: node.stats.home_messages,
last_messages: node.stats.last_messages,
meta_messages: node.stats.meta_messages,
home_availability_messages: node.stats.home_availability_messages,
operational_messages: node.stats.operational_messages,
invalid_messages: node.stats.invalid_messages,
invalid_topics: node.stats.invalid_topics,
invalid_payloads: node.stats.invalid_payloads,
unmapped_messages: node.stats.unmapped_messages,
adapter_exceptions: node.stats.adapter_exceptions,
errors: node.stats.errors,
dlq: node.stats.dlq
};
messages.push(makePublishMsg(topic, payload, true));
noteMessage("operational_messages");
}
function enqueueError(messages, site, code, reason, sourceTopic) {
var payload = {
code: code,
reason: reason,
source_topic: normalizeToken(sourceTopic),
adapter_id: node.adapterId
};
messages.push(makePublishMsg(buildSysTopic(site, "error"), payload, false));
noteErrorKind(code);
noteMessage("errors");
noteMessage("operational_messages");
}
function enqueueDlq(messages, site, code, sourceTopic, rawPayload) {
var payload = {
code: code,
source_topic: normalizeToken(sourceTopic),
payload: rawPayload
};
messages.push(makePublishMsg(buildSysTopic(site, "dlq"), payload, false));
noteMessage("dlq");
noteMessage("operational_messages");
}
function activeMappings(payloadObject) {
var result = [];
for (var i = 0; i < CAPABILITY_MAPPINGS.length; i++) {
var mapping = CAPABILITY_MAPPINGS[i];
if (typeof mapping.applies === "function" && !mapping.applies(payloadObject)) continue;
var value = payloadObject ? mapping.read(payloadObject) : undefined;
var seen = mapping.core || node.seenOptionalCapabilities[mapping.targetCapability];
if (value !== undefined) node.seenOptionalCapabilities[mapping.targetCapability] = true;
if (mapping.core || seen || value !== undefined) {
result.push({
mapping: mapping,
hasValue: value !== undefined,
value: value
});
}
}
return result;
}
function resolveOnlineState(payloadObject, availabilityValue) {
if (availabilityValue !== null && availabilityValue !== undefined) return !!availabilityValue;
if (!payloadObject) return true;
var active = true;
if (typeof payloadObject.availability === "string") active = payloadObject.availability.trim().toLowerCase() !== "offline";
if (typeof payloadObject.online === "boolean") active = payloadObject.online;
return active;
}
function flush(send, done, controlMessages, publishMessages, error) {
send([
publishMessages.length ? publishMessages : null,
controlMessages.length ? controlMessages : null
]);
if (done) done(error);
}
function startSubscriptions() {
if (node.subscriptionStarted) return;
node.subscriptionStarted = true;
node.send([null, makeSubscribeMsg(node.sourceTopic)]);
updateNodeStatus("grey", "dot", "subscribed");
}
node.on("input", function(msg, send, done) {
send = send || function() { node.send.apply(node, arguments); };
node.stats.processed_inputs += 1;
try {
var controlMessages = [];
if (!msg || typeof msg !== "object") {
var invalidMessages = [];
var invalidSite = resolveIdentity({}, null).site;
enqueueAdapterAvailability(invalidMessages, invalidSite, true);
enqueueError(invalidMessages, invalidSite, "invalid_message", "Input must be an object", "");
enqueueDlq(invalidMessages, invalidSite, "invalid_message", "", null);
enqueueAdapterStats(invalidMessages, invalidSite, true);
logIssue("warn", "invalid_message", "Input must be an object", null, msg);
updateNodeStatus("yellow", "ring", "bad msg");
flush(send, done, controlMessages, invalidMessages);
return;
}
var payload = msg.payload;
var payloadObject = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
var identity = resolveIdentity(msg, payloadObject);
var observation = resolveObservation(msg, payloadObject);
var messages = [];
var topicValidation = validateInboundTopic(msg.topic);
var availabilityValue = null;
enqueueAdapterAvailability(messages, identity.site, true);
if (!topicValidation.valid) {
enqueueError(messages, identity.site, "invalid_topic", topicValidation.reason, msg.topic);
enqueueDlq(messages, identity.site, "invalid_topic", msg.topic, payload);
enqueueAdapterStats(messages, identity.site, true);
logIssue("warn", "invalid_topic", topicValidation.reason, msg, payload);
updateNodeStatus("yellow", "ring", "bad topic");
flush(send, done, controlMessages, messages);
return;
}
identity.isAvailabilityTopic = topicValidation.isAvailabilityTopic;
noteDevice(identity);
var isAvailabilityTopic = topicValidation.isAvailabilityTopic;
if (isAvailabilityTopic) {
availabilityValue = asBool(payload);
if (availabilityValue === null) {
enqueueError(messages, identity.site, "invalid_availability_payload", "Availability payload must be online/offline or boolean", msg.topic);
enqueueDlq(messages, identity.site, "invalid_availability_payload", msg.topic, payload);
enqueueAdapterStats(messages, identity.site, true);
logIssue("warn", "invalid_availability_payload", "Availability payload must be online/offline or boolean", msg, payload);
updateNodeStatus("yellow", "ring", "invalid availability");
flush(send, done, controlMessages, messages);
return;
}
} else if (!payloadObject) {
enqueueError(messages, identity.site, "payload_not_object", "Telemetry payload must be an object", msg.topic);
enqueueDlq(messages, identity.site, "payload_not_object", msg.topic, payload);
enqueueAdapterStats(messages, identity.site, true);
logIssue("warn", "payload_not_object", "Telemetry payload must be an object", msg, payload);
updateNodeStatus("yellow", "ring", "payload not object");
flush(send, done, controlMessages, messages);
return;
}
var online = resolveOnlineState(payloadObject, availabilityValue);
var mappings = activeMappings(payloadObject);
var hasMappedValue = false;
for (var i = 0; i < mappings.length; i++) {
if (mappings[i].hasValue) {
hasMappedValue = true;
break;
}
}
var hasAvailabilityField = isAvailabilityTopic || (payloadObject && (typeof payloadObject.availability === "string" || typeof payloadObject.online === "boolean"));
if (!hasMappedValue && !hasAvailabilityField) {
enqueueError(messages, identity.site, "no_mapped_fields", "Payload did not contain any supported ZG-204ZV fields", msg.topic);
enqueueDlq(messages, identity.site, "no_mapped_fields", msg.topic, payloadObject);
logIssue("warn", "no_mapped_fields", "Payload did not contain any supported ZG-204ZV fields", msg, payloadObject);
}
for (var i = 0; i < mappings.length; i++) {
enqueueHomeMeta(messages, identity, mappings[i].mapping);
enqueueHomeAvailability(messages, identity, mappings[i].mapping, online);
if (mappings[i].hasValue) {
enqueueHomeLast(messages, identity, mappings[i].mapping, mappings[i].value, observation);
enqueueHomeValue(messages, identity, mappings[i].mapping, mappings[i].value);
}
}
enqueueAdapterStats(messages, identity.site, false);
if (!hasMappedValue && !hasAvailabilityField) {
updateNodeStatus("yellow", "ring", "unmapped");
} else {
updateNodeStatus(online ? "green" : "yellow", online ? "dot" : "ring", online ? null : "offline");
}
flush(send, done, controlMessages, messages);
} catch (err) {
var errorPayload = msg && msg.payload && typeof msg.payload === "object" && !Array.isArray(msg.payload) ? msg.payload : null;
var errorIdentity = resolveIdentity(msg, errorPayload);
noteDevice(errorIdentity);
var errorMessages = [];
enqueueAdapterAvailability(errorMessages, errorIdentity.site, true);
enqueueError(errorMessages, errorIdentity.site, "adapter_exception", err.message, msg && msg.topic);
enqueueAdapterStats(errorMessages, errorIdentity.site, true);
logIssue("error", "adapter_exception", err.message, msg, msg && msg.payload);
updateNodeStatus("red", "ring", "error");
flush(send, done, [], errorMessages, err);
}
});
node.on("close", function() {
if (node.startTimer) {
clearTimeout(node.startTimer);
node.startTimer = null;
}
});
node.startTimer = setTimeout(startSubscriptions, 250);
updateNodeStatus("grey", "ring", "waiting");
}
RED.nodes.registerType("z2m-zg-204zv-homebus", Z2MZG204ZVHomeBusNode);
};