269 lines
10 KiB
JavaScript
269 lines
10 KiB
JavaScript
const log = Java.type('org.slf4j.LoggerFactory').getLogger('js.utils.watch');
|
|
log.info('Load watch module');
|
|
|
|
class Watch {
|
|
|
|
#watchObjects = new Object();
|
|
#watchItems = new Object();
|
|
|
|
#timers = new timer.Timer();
|
|
|
|
constructor() {
|
|
log.info('Initialization of watch helper class');
|
|
}
|
|
|
|
add(params) {
|
|
// Generate watchUUID
|
|
let watchUUID = utils.randomUUID();
|
|
|
|
// Validate config for watchObject
|
|
if (!this.validateWatchConfig(params)) {
|
|
console.warn(`Failed to add watch object because no valid config was provided`);
|
|
return;
|
|
}
|
|
|
|
if (!this.#watchItems.hasOwnProperty(params['item'])) {
|
|
this.#createWatchRule(params['item']);
|
|
} else {
|
|
log.debug(`Watch rule for item ${params['item']} already existing`)
|
|
}
|
|
|
|
|
|
// Set default values if no config provided
|
|
let operator = (params['operator'] !== undefined) ? params['operator'] : '==';
|
|
|
|
// Create watch object and return UUID
|
|
log.info(`Add watch object for item ${params['item']} with state ${params['targetState']} and operator ${operator} with UUID ${watchUUID}`);
|
|
this.#watchObjects[watchUUID] = {
|
|
item: params['item'],
|
|
targetState: params['targetState'],
|
|
operator: operator,
|
|
alertFunc: params['alertFunc'],
|
|
alertDelay: (params['alertDelay'] !== undefined) ? params['alertDelay'] : 0,
|
|
alertRepeat: (params['alertRepeat'] !== undefined) ? params['alertRepeat'] : 0,
|
|
initialAlertFunc: (params['initialAlertFunc'] !== undefined) ? params['initialAlertFunc'] : '',
|
|
endAlertFunc: (params['endAlertFunc'] !== undefined) ? params['endAlertFunc'] : '',
|
|
hysteresis: (params['hysteresis'] !== undefined) ? lib.convertValue(params['hysteresis']) : '',
|
|
alert: false
|
|
}
|
|
|
|
// Check if watchObject is already triggered by currentState
|
|
this.#checkAlertState(watchUUID);
|
|
|
|
// return id of watchObject
|
|
return watchUUID;
|
|
}
|
|
|
|
delete(watchUUID) {
|
|
// Get itemName
|
|
let watchItemName = this.#watchObjects[watchUUID].item;
|
|
|
|
log.info(`Delete watch object for item ${watchItemName} with watchUUID ${watchUUID}`);
|
|
|
|
// End repeatAlertTimer if existing
|
|
this.#timers.cancel('repeatAlarm ' + watchUUID);
|
|
|
|
// End startAlertTimer if existing
|
|
this.#timers.cancel('startAlert ' + watchUUID);
|
|
|
|
delete this.#watchObjects[watchUUID];
|
|
|
|
// Delete watch rule if no more watchObjects for respective item are present
|
|
if (Object.keys(this.#watchObjects).length == 0) {
|
|
log.debug(`Remove openHAB watch rule for item ${watchItemName}`);
|
|
rules.removeRule(this.#watchItems[watchItemName]);
|
|
}
|
|
}
|
|
|
|
deleteAll() {
|
|
for (let watchUUID of Object.keys(this.#watchObjects)) {
|
|
this.delete(watchUUID);
|
|
}
|
|
}
|
|
|
|
isAlert(watchUUID) {
|
|
log.debug('Check if there is a running alert for watchObject ' + watchUUID);
|
|
if (watchUUID in this.#watchObjects) {
|
|
console.error(this.#watchObjects[watchUUID].alert);
|
|
return this.#watchObjects[watchUUID].alert;
|
|
}
|
|
}
|
|
|
|
isDelayed(watchUUID) {
|
|
log.debug('Check if startAlert for watchObject ' + watchUUID + 'is delayed');
|
|
if (watchUUID in this.#watchObjects) {
|
|
return this.#timers.isActive('startAlert ' + watchUUID);;
|
|
}
|
|
}
|
|
|
|
validateWatchConfig(params) {
|
|
|
|
if (params['item'] === undefined) {
|
|
log.error('No item set');
|
|
return false;
|
|
}
|
|
if (params['targetState'] === undefined) {
|
|
log.error('No targetState set');
|
|
return false;
|
|
}
|
|
if (params['alertFunc'] === undefined) {
|
|
log.error('No alertFunc set');
|
|
return false;
|
|
}
|
|
|
|
// return true if config is valid
|
|
return true
|
|
}
|
|
|
|
#applyHysteresis(currentState, targetState, hysteresis) {
|
|
log.info(`Applying hysteresis with: ${currentState}, ${targetState}, ${hysteresis}`);
|
|
let delta = Math.abs(targetState - currentState);
|
|
log.info(delta);
|
|
|
|
if (delta < hysteresis) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#checkAlertState(watchUUID) {
|
|
// Get itemName
|
|
let watchItemName = this.#watchObjects[watchUUID].item;
|
|
|
|
log.debug(`Check if item ${watchItemName} is in alert state for watchObject ${watchUUID}`)
|
|
|
|
// Convert currentState for comparison
|
|
let currentState = lib.convertValue(items[watchItemName].state);
|
|
|
|
// Do comparison
|
|
if (lib.compare(currentState, this.#watchObjects[watchUUID].targetState, this.#watchObjects[watchUUID].operator)) { // Comparison successful
|
|
log.info(`State ${currentState} is ${this.#watchObjects[watchUUID].operator} ${this.#watchObjects[watchUUID].targetState} triggered by ${watchUUID} (${watchItemName})`);
|
|
if (this.#watchObjects[watchUUID].alert == true) { // Comparison successful and alert is already active
|
|
this.#rescheduleAlert(watchUUID);
|
|
} else { // Comparison successful and alert is not active
|
|
// Start alert
|
|
this.#startAlert(watchUUID);
|
|
}
|
|
} else if (this.#watchObjects[watchUUID].alert == true) { // Comparison failed but alert is active
|
|
// Skip if currentState fails hysteresis test
|
|
if (this.#watchObjects[watchUUID].hysteresis != '' && !this.#applyHysteresis(currentState, this.#watchObjects[watchUUID].targetState, this.#watchObjects[watchUUID].hysteresis)) {
|
|
log.info('CurrentState is still in boundaries provided by hysteresis value');
|
|
return;
|
|
}
|
|
// End alert
|
|
this.#endAlert(watchUUID);
|
|
}
|
|
}
|
|
|
|
#createWatchRule(item) {
|
|
// Create openHAB rule
|
|
log.info(`Create openHAB watch rule for item ${item}`);
|
|
|
|
let watchRuleID = String(utils.randomUUID());
|
|
rules.JSRule({
|
|
id: watchRuleID,
|
|
name: item + ' watch rule',
|
|
triggers: [triggers.ItemStateChangeTrigger(item)],
|
|
tags: ['Watch'],
|
|
execute: (event) => { this.#processItemEvent(event) },
|
|
});
|
|
this.#watchItems[item] = watchRuleID;
|
|
}
|
|
|
|
#endAlert(watchUUID) {
|
|
// Get itemName
|
|
let watchItemName = this.#watchObjects[watchUUID].item;
|
|
|
|
log.info(`End alert for watchObject ${watchUUID} (${watchItemName}) triggered`);
|
|
this.#watchObjects[watchUUID].alert = false;
|
|
|
|
// Run end alert function if existing
|
|
if (this.#watchObjects[watchUUID].endAlertFunc != '') {
|
|
log.info(`Run end alert function for watchObject ${watchUUID}`);
|
|
this.#watchObjects[watchUUID].endAlertFunc();
|
|
}
|
|
|
|
// End repeatAlertTimer if existing
|
|
this.#timers.cancel('repeatAlarm ' + watchUUID);
|
|
|
|
// End startAlertTimer if startAlert started timer with delay
|
|
this.#timers.cancel('startAlert ' + watchUUID);
|
|
}
|
|
|
|
#processItemEvent(event) {
|
|
// Skip if function is triggered without openHAB event
|
|
if (event.eventType == 'manual') {
|
|
console.warn(`ProcessItemEvent triggered without openHAB event`);
|
|
return;
|
|
}
|
|
|
|
log.info(`Processing state ${event.newState} for ${event.itemName}`);
|
|
|
|
for (const [id, watchObject] of Object.entries(this.#watchObjects)) {
|
|
if (watchObject.item == event.itemName) {
|
|
this.#checkAlertState(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
#rescheduleAlert(watchUUID) {
|
|
log.info(`Subsequent alert for ${watchUUID}`);
|
|
}
|
|
|
|
#startAlert(watchUUID) {
|
|
// Get itemName
|
|
let watchItemName = this.#watchObjects[watchUUID].item;
|
|
|
|
log.info(`Initial alert for watchObject ${watchUUID} (${watchItemName}) triggered`);
|
|
|
|
// Set alertFunc as inital alert function if no initialAlertFunc is set
|
|
let initialAlertFunc = this.#watchObjects[watchUUID].alertFunc;
|
|
if (this.#watchObjects[watchUUID].initialAlertFunc != '') {
|
|
initialAlertFunc = this.#watchObjects[watchUUID].initialAlertFunc;
|
|
}
|
|
|
|
let alertDelay = this.#watchObjects[watchUUID].alertDelay;
|
|
let alertRepeat = this.#watchObjects[watchUUID].alertRepeat;
|
|
let alertDelayAbsolute = 0;
|
|
|
|
// Set alert state
|
|
this.#watchObjects[watchUUID].alert = true;
|
|
|
|
// Execute initial alert function or create timer to run initial alert rule if required
|
|
if (alertDelay == '') {
|
|
log.info(`Run initial alert function for watchObject ${watchUUID} (${watchItemName})`);
|
|
initialAlertFunc();
|
|
} else {
|
|
log.info(`Shedule initial alert function for watchObject ${watchUUID} (${watchItemName}) with delay setting ${alertDelay}`);
|
|
|
|
let alertDelayZDT = time.toZDT(alertDelay);
|
|
alertDelayAbsolute = (alertDelayZDT.getMillisFromNow() / 1000);
|
|
|
|
this.#timers.create('startAlert ' + watchUUID,
|
|
alertDelayZDT,
|
|
() => {
|
|
log.info('Run initial alert function for watchObject ' + watchUUID);
|
|
initialAlertFunc();
|
|
}
|
|
);
|
|
}
|
|
|
|
// Create timer to run repeat alert rule if required
|
|
if (alertRepeat != '') {
|
|
log.info(`Shedule repeat alert function for watchObject ${watchUUID} (${watchItemName}) with repeat setting ${alertRepeat}`);
|
|
this.#timers.create('repeatAlarm ' + watchUUID,
|
|
time.toZDT(alertRepeat).plusSeconds(alertDelayAbsolute),
|
|
() => {
|
|
log.info('Run repeat alert function for watchObject ' + watchUUID);
|
|
this.#watchObjects[watchUUID].alertFunc();
|
|
this.#watchObjects[watchUUID].repeatAlertTimer.reschedule(time.toZDT(alertRepeat));
|
|
}
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
Watch,
|
|
}; |