matter-history
Version:
Matterbridge history module
465 lines • 13.2 kB
TypeScript
/**
* This file contains the class History.
*
* @file history.ts
* @author Luca Liguori
* @date 2023-09-01
* @version 2.7.8
*
* Copyright 2023, 2024 Luca Liguori.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License. * *
*/
import { AnsiLogger } from 'node-ansi-logger';
export interface OptionalHistoryParams {
enableDebug?: boolean;
enableAutopilot?: boolean;
enableConfigData?: boolean;
historySize?: number;
fileName?: string;
filePath?: string;
timerMinutes?: number;
edge?: boolean;
}
export interface HistoryParams {
enableDebug: boolean;
enableAutopilot: boolean;
enableConfigData: boolean;
historySize: number;
fileName: string;
filePath: string;
timerMinutes: number;
}
export interface Entry extends ImmediateEntry, AveragedEntry {
time: number;
setRefTime?: number;
immediate?: number;
}
export interface ImmediateEntry {
time: number;
status?: number;
motion?: number;
contact?: number;
leak?: number;
smoke?: number;
action?: number;
currentposition?: number;
targetposition?: number;
positionstate?: number;
obstructiondetected?: number;
}
export interface AveragedEntry {
time: number;
consumption?: number;
power?: number;
voltage?: number;
current?: number;
temperature?: number;
lux?: number;
humidity?: number;
pressure?: number;
airquality?: number;
voc?: number;
co?: number;
co2?: number;
formaldehyd?: number;
pm10?: number;
pm25?: number;
lqi?: number;
}
export interface HistoryLog {
firstEntry: number;
lastEntry: number;
memorySize: number;
initialTime: number;
timeOffset: number;
resetTotal: number;
lastEvent: number;
timesOpened: number;
fileVersion: string;
historyVersion: string;
lastValues: Entry;
history: Entry[];
extra: any;
}
export interface Signature {
tag: number;
length: number;
factor: number;
precision: number;
bitmask: number;
entryName: keyof Entry;
}
export interface Tag {
tag: number;
length: number;
factor: number;
precision: number;
entryName: keyof Entry;
}
export declare const enum WeatherTrend {
BLANK = 0,
SUN = 1,
CLOUDS_SUN = 3,
RAIN = 5,
RAIN_WIND = 12
}
export declare const enum Sensitivity {
HIGH = 0,
MEDIUM = 4,
LOW = 7
}
export declare const enum TemperatureDisplayUnits {
CELSIUS = 0,
FAHRENHEIT = 1
}
export interface TlvConfigData {
field: number;
length: number;
name: string;
data: Buffer;
updated: boolean;
value: boolean | number | string;
}
export interface TlvConfigDataField {
field: number;
type: number;
name: string;
}
export declare class History {
protected log: AnsiLogger;
protected name: string;
protected optionalParams?: OptionalHistoryParams | undefined;
protected params: HistoryParams;
protected eveEpoch: number;
protected initialTime: number;
protected timeOffset: number;
protected memorySize: number;
protected firstEntry: number;
protected currentEntry: number;
protected lastEntry: number;
protected fileVersion: string;
protected historyVersion: string;
protected resetTotal: number;
protected lastEvent: number;
protected timesOpened: number;
protected configData: Buffer;
protected tlvConfigDataGet: TlvConfigData[];
protected tlvConfigDataSet: TlvConfigData[];
protected firmwareData: Buffer<ArrayBuffer>;
protected historyLoaded: boolean;
protected historyDebug: boolean;
protected historyError: boolean;
protected historyClosed: boolean;
protected setRefTime: boolean;
protected historyWriting: boolean;
protected forceReloadHistoryStatus: boolean;
protected forceReloadHistoryRequest: boolean;
protected deviceOnline: boolean;
protected addResetTotal: boolean;
protected addLastEvent: boolean;
protected addTimesOpened: boolean;
protected addStatusFault: boolean;
protected statusFault: number;
protected addStatusActive: boolean;
protected statusActive: boolean;
protected addFakeSwitch: boolean;
protected signature: Buffer;
protected sigTable: Signature[];
protected tags: Tag[];
protected tagsMap: Map<number, Tag>;
protected entryNameMap: Map<keyof Entry, Tag>;
protected historyLog: HistoryLog;
protected writingTimeout: NodeJS.Timeout | undefined;
protected historyFile: string;
protected queueTimeout: NodeJS.Timeout | undefined;
protected queuedEntries: Entry[];
protected toAverageEntries: AveragedEntry[];
protected lastValuesEntry: Entry;
protected immediateKeys: Array<keyof Entry>;
protected averagedKeys: Array<keyof Entry>;
protected lastValueKeys: Array<keyof Entry>;
protected averageTimer: NodeJS.Timeout | null;
constructor(log: AnsiLogger, name: string, optionalParams?: OptionalHistoryParams | undefined);
close(): Promise<void>;
/**
* Get the initial time of the history.
*
* initialTime rappresents the number of seconds since Unix Epoch of the first entry of the history.
* Even if the first entry is no more in the memory this is always the initialTime.
* When passed to History is initialTime-epoch_sec=referenceTime
*
* 1970 2001 2023 now
* ¦-----------------------------initialTime------------------------¦-----------¦
* ¦--------eveEpoch------------------¦--------referenceTime--------¦-entryTime-¦
*
*
* @return initialTime
*/
getInitialTime(): number;
/**
* Get the offset time of the history.
*
* @return timeOffset
*/
getTimeOffset(): number;
/**
* Get the first entry of the history.
*
* @return firstEntry
*/
getFirstEntry(): number;
/**
* Get the last entry of the history.
*
* @return lastEntry
*/
getLastEntry(): number;
/**
* Set the availability of the device.
*
* @param online State of the device.
*/
setDeviceOnline(online: boolean): void;
/**
* Get lastEvent attribute of history.
*
* @return lastEvent
*/
getLastEvent(): number;
/**
* Set lastEvent attribute of history.
*
* @return lastEvent updated
*/
setLastEvent(): void;
/**
* Get timesOpened attribute of history.
*
* @return timesOpened
*/
getTimesOpened(): number;
/**
* Get timesOpened attribute of history.
*
* @return timesOpened incremented
*/
addToTimesOpened(): number;
/**
* Get the address of an entry into the circular memory
*
* @param entryNumber Entry to get the address of.
* @return The address requested
*/
protected getEntryAddress(entryNumber: number): number;
/**
* Get an entry
*
* @param entryNumber Entry number to get
* @return The entry requested
*/
protected getEntry(entryNumber: number): Entry;
/**
* Set an entry
*
* @param entryNumber Entry number to set
* @param entry Entry to set at entryNumber
*/
protected setEntry(entryNumber: number, entry: Entry): void;
private tlvConfigDataFields;
private tlvDataToValue;
encodeConfigData(tlvConfigData: TlvConfigData[]): Buffer;
decodeConfigData(buffer: Buffer, tlvConfigData?: TlvConfigData[]): string;
configDataToString(tlvConfigData: TlvConfigData[]): string;
setMaxMinTemperature(maxTemperature: number, minTemperature: number): void;
/**
* Encode HistoryStatus
*
* @param buffer The Buffer to decode
* @return The string of decoded Buffer
*/
decodeHistoryStatus(buffer: Buffer): string;
/**
* Encode HistoryStatus
*
* @return The encoded Buffer
*/
encodeHistoryStatus(): Buffer;
/**
* Log the HistoryStatus Buffer to string
*
* @param buffer Buffer of historyStatus to log
* @return The log string of historyStatus
*/
historyStatusToString(buffer: Buffer): string;
/**
* Decode a Buffer into a HistoryEntry
*
* @param buffer The Buffer to decode
* @return The string rappresenting the decoded buffer
*/
decodeHistoryEntry(buffer: Buffer): string;
/**
* Encode a given HistoryEntry
*
* @param entryNumber Entry number to encode
* @return The encoded buffer
*/
encodeHistoryEntry(entryNumber: number): Buffer;
/**
* Log to a string a given HistoryEntry buffer
*
* @param buffer Entry buffer to log
* @return The log string of the given entry buffer
*/
historyEntryToString(buffer: Buffer): string;
historyEntriesToString(buffer: Buffer): string;
decodeHistorySetTime(buffer: Buffer): string;
encodeHistorySetTime(seconds?: number): Buffer;
historySetTimeToString(buffer: Buffer): string;
decodeHistoryRequest(buffer: Buffer): string;
encodeHistoryRequest(entryNumber: number): Buffer;
historyRequestToString(buffer: Buffer): string;
signatureToString(): string;
/**
* Add an entry to the history. History will choose to add immediates or averaged entries to the history.
*
* @param entry * { time: [seconds since unix()], ... }
*
* status: 0-OFF / 1-ON
*
* power: number
*
* motion: 0-no motion / 1-motion detected
*
* contact: 0-contact closed / 1-contact opened
*
* leak: 0-no leak / 1-leak detected
*
* smoke: 0-no smoke / 1-smoke detected
*
* temperature: number
*
* humidity: number
*
* pressure: number
*
* lux: number
*/
addEntry(entry: Entry): void;
/**
* Add an entry to average by the callback timer.
*
* @param entry Entry to add.
*/
protected addAveragedEntry(entry: Entry): void;
/**
* Add an immediate entry.
*
* @param entry Entry to add.
*/
protected addImmediateEntry(entry: Entry): void;
/**
* Start the callback timer to average the entries.
*
* @param runNow If true call also immediately the callback
*/
private averageTimerStart;
/**
* Timer callback to average the entries.
*/
private averageTimerCallback;
/**
* Log the history class to the logger.
*
* @param logEntries If true also log all the history entries
*/
logHistory(logEntries?: boolean): void;
/**
* Read asyncronously the history from disk.
*/
readHistoryFile(callback?: (success: boolean) => void): void;
/**
* Write asyncronously the history to disk.
*/
writeHistoryFile(): void;
/**
* Stringify an entry with appropriate value for time and bitmask.
*
* @param entry Entry object to stingify
*/
protected entryStringify(entry: object): string;
/**
* Return a string rappresenting the time passed:
*
* 0-60 seconds
*
* 0-60 minutes
*
* 0-24 hours
*
* when more then 24 hours returns the number of days
*
* @param seconds number of seconds
*
* @return The string rappresenting the time passed
*/
diffToString(seconds: number): string;
/**
* Return the date string from seconds in 'DD-MM-YYYY HH:mm:ss' format.
*
* @param seconds number of seconds
*
* @return The date string
*/
secsToDateString(seconds: number): string;
/**
* Return the date string rappresented by seconds since epoch.
*
* @param secondsSinceEpoch number of seconds since epoch
*
* @return The date string
*/
secsToDateStringSinceEveEpoch(secondsSinceEpoch: number): string;
/**
* Return the actual unix seconds.
*
* @return The unix seconds of now
*/
now(): number;
/**
* Clamp a number to min and max.
*
* @param number - The number to clamp
* @param min - Min value
* @param max - Max value
*
* @return The clamped number
*
*/
clamp(number: number, min: number, max: number): number;
/**
* Round a number to the specified precision
*
* @param number - The number to round
* @param precision - The number of decimals
*
* @return The rounded number
*
*/
round(number: number, precision: number): number;
getFakeLevel(minLevel: number, maxLevel: number, round?: number): number;
private secondsSinceMidnight;
private secondsSinceNoon;
}
//# sourceMappingURL=history.d.ts.map