iobroker.time-tracker 0.2.0

package/build/main.js

@@ -0,0 +1,986 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_crypto = require("node:crypto");
+var fs = __toESM(require("node:fs"));
+var path = __toESM(require("node:path"));
+var utils = __toESM(require("@iobroker/adapter-core"));
+var import_database = require("./lib/db/database");
+var import_seed = require("./lib/db/seed");
+var import_absences = require("./lib/db/repositories/absences");
+var import_entries = require("./lib/db/repositories/entries");
+var import_holidays = require("./lib/db/repositories/holidays");
+var import_payouts = require("./lib/db/repositories/payouts");
+var import_rules = require("./lib/db/repositories/rules");
+var import_settings = require("./lib/db/repositories/settings");
+var import_users = require("./lib/db/repositories/users");
+var import_automations = require("./lib/db/repositories/automations");
+var import_terminals = require("./lib/db/repositories/terminals");
+var import_rfid = require("./lib/db/repositories/rfid");
+var import_triggers = require("./lib/db/repositories/triggers");
+var import_aggregation = require("./lib/services/aggregation");
+var import_auth = require("./lib/services/auth");
+var import_sessionSecret = require("./lib/services/sessionSecret");
+var import_closing = require("./lib/services/closing");
+var import_backup = require("./lib/services/backup");
+var import_sync = require("./lib/services/sync");
+var import_states = require("./lib/adapter/states");
+var import_presence = require("./lib/adapter/presence");
+var import_commands = require("./lib/adapter/commands");
+var import_triggers2 = require("./lib/adapter/triggers");
+var import_automation = require("./lib/adapter/automation");
+var import_messages = require("./lib/adapter/messages");
+var import_api = require("./lib/web/api");
+var import_server = require("./lib/web/server");
+var import_time = require("./lib/util/time");
+var import_static = require("./lib/web/static");
+const SUPPORTED_COUNTRIES = ["CH", "DE", "AT"];
+const SESSION_PURGE_MINUTES = 30;
+const STATE_REFRESH_MINUTES = 5;
+const BACKUP_MAX_AGE_HOURS = 20;
+const AUTOMATION_CHECK_MINUTES = 1;
+const TAG_SECRET_FILE_NAME = "tag-secret";
+const FIGURES_EVENT_TYPES = ["punch", "terminal.punch", "rfid.scan", "entry.update", "entry.delete", "absence.change"];
+class TimeTracker extends utils.Adapter {
+  db = null;
+  webServer = null;
+  services = null;
+  /** Bus of the API; `null` until the API is created */
+  events = null;
+  /** Last value seen per watched trigger state: only a change fires a rule */
+  triggerValues = /* @__PURE__ */ new Map();
+  /** Trigger states the adapter currently subscribes to */
+  triggerStates = /* @__PURE__ */ new Set();
+  /** Pending refresh of the figures after a change through the API */
+  stateRefreshTimer = void 0;
+  constructor(options = {}) {
+    super({
+      ...options,
+      name: "time-tracker"
+    });
+    this.on("ready", this.onReady.bind(this));
+    this.on("stateChange", this.onStateChange.bind(this));
+    this.on("message", this.onMessage.bind(this));
+    this.on("unload", this.onUnload.bind(this));
+  }
+  /** Database file: configured path or `<adapter instance data dir>/time-tracker.sqlite`. */
+  databaseFile() {
+    var _a;
+    const configured = ((_a = this.config.dbPath) != null ? _a : "").trim();
+    if (configured) {
+      return path.resolve(configured);
+    }
+    const dir = utils.getAbsoluteInstanceDataDir(this);
+    fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, "time-tracker.sqlite");
+  }
+  /** Configured holiday country, falling back to Switzerland. */
+  holidayCountry() {
+    var _a;
+    const configured = ((_a = this.config.holidayCountry) != null ? _a : "").toUpperCase();
+    return SUPPORTED_COUNTRIES.includes(configured) ? configured : "CH";
+  }
+  /**
+   * Is called when databases are connected and adapter received configuration.
+   */
+  async onReady() {
+    var _a;
+    try {
+      await this.setState("info.connection", false, true);
+      const file = this.databaseFile();
+      let applied = null;
+      try {
+        applied = (0, import_backup.applyPendingRestore)(file);
+        if (applied) {
+          this.log.info(
+            `restored the database from ${applied.restored.name}: ${applied.restored.users} users, ${applied.restored.entries} punches, previous file ${(_a = applied.previous) != null ? _a : "(none)"}`
+          );
+        }
+      } catch (error) {
+        this.log.error(`the queued restore was refused: ${error.message}`);
+      }
+      this.db = (0, import_database.openAndMigrate)(file, (message) => this.log.debug(message));
+      if (applied) {
+        (0, import_backup.recordRestore)(this.db, applied.restored, applied.actorId);
+      }
+      const year = (/* @__PURE__ */ new Date()).getUTCFullYear();
+      const country = this.holidayCountry();
+      const result = (0, import_seed.seed)(this.db, { holidayCountry: country, holidayYears: [year, year + 1] });
+      this.log.info(
+        `database ready at ${file} (${result.permissions} permissions, ${result.holidays} holidays added for ${country})`
+      );
+      this.ensureAdministrator(this.db);
+      this.applyConfiguration((0, import_settings.createSettingsRepository)(this.db));
+      await this.startApi();
+      await this.subscribeCommands();
+      await this.refreshTriggerSubscriptions();
+      this.runAutomationRules();
+      this.setInterval(() => this.runAutomationRules(), AUTOMATION_CHECK_MINUTES * 60 * 1e3);
+      await this.publishInstanceInfo();
+      await this.refreshStates();
+      this.setInterval(
+        () => {
+          void this.publishInstanceInfo();
+          void this.refreshStates();
+        },
+        STATE_REFRESH_MINUTES * 60 * 1e3
+      );
+      await this.runScheduledBackup();
+      this.setInterval(() => void this.runScheduledBackup(), 60 * 60 * 1e3);
+      await this.setState("info.connection", true, true);
+    } catch (error) {
+      const message = error.message;
+      this.log.error(`Startup failed: ${message}`);
+      await this.setState("info.lastError", message, true);
+    }
+  }
+  /**
+   * Creates the first administrator when the instance has none.
+   *
+   * The account is created with `must_change_pw = 1`, so the start password opens the door exactly once.
+   * Login and password can be configured; without a configured password a random one is generated and written
+   * to the log, because there is no other way to hand it to the operator.
+   *
+   * @param db - open database handle
+   */
+  ensureAdministrator(db) {
+    var _a, _b;
+    const users = (0, import_users.createUsersRepository)(db);
+    const administrators = users.list().filter((user) => users.roles(user.id).includes("admin"));
+    if (administrators.length > 0) {
+      return;
+    }
+    const login = ((_a = this.config.adminLogin) != null ? _a : "").trim() || "admin";
+    const configured = ((_b = this.config.adminPassword) != null ? _b : "").trim();
+    const password = configured || `Zf-${(0, import_node_crypto.randomBytes)(9).toString("base64url")}-7`;
+    try {
+      users.create({
+        login,
+        displayName: login,
+        passwordHash: (0, import_auth.hashPassword)(password),
+        mustChangePw: true,
+        timezone: this.config.timezone || "Europe/Berlin",
+        roleKeys: ["admin"],
+        now: Math.floor(Date.now() / 1e3)
+      });
+    } catch (error) {
+      this.log.warn(`the administrator "${login}" could not be created: ${error.message}`);
+      return;
+    }
+    if (configured) {
+      this.log.info(
+        `administrator "${login}" created with the configured start password - it has to be changed at the first login`
+      );
+    } else {
+      this.log.warn(
+        `administrator "${login}" created with the start password "${password}" - change it at the first login`
+      );
+    }
+  }
+  /**
+   * Copies the instance configuration into the stored settings and publishes the instance information.
+   *
+   * The ioBroker admin UI is where an operator configures the instance, so a configured value wins over what
+   * is stored in the database; `PUT /api/settings` stays for the keys the admin UI does not offer. Empty
+   * fields are ignored, so clearing a field never wipes a stored setting.
+   *
+   * @param settings - instance settings
+   */
+  applyConfiguration(settings) {
+    var _a, _b;
+    const text = (value) => (value == null ? void 0 : value.trim()) ? value.trim() : null;
+    const number = (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : null;
+    const flag = (value) => value === void 0 ? null : value ? "1" : "0";
+    const mapped = [
+      ["holiday_country", (_b = (_a = text(this.config.holidayCountry)) == null ? void 0 : _a.toUpperCase()) != null ? _b : null],
+      ["timezone", text(this.config.timezone)],
+      ["default_language", text(this.config.defaultLanguage)],
+      ["edit_window_days", number(this.config.editWindowDays)],
+      ["quick_round_minutes", number(this.config.quickRoundMinutes)],
+      ["session_ttl_minutes", number(this.config.sessionTtlMinutes)],
+      ["backup_retention_days", number(this.config.backupRetentionDays)],
+      ["absence_calc_until_today", flag(this.config.absenceCalcUntilToday)],
+      ["absence_deduct_worktime", flag(this.config.absenceDeductWorktime)]
+    ];
+    const now = Math.floor(Date.now() / 1e3);
+    for (const [key, value] of mapped) {
+      if (value !== null && settings.get(key) !== value) {
+        settings.set(key, value, null, now);
+      }
+    }
+  }
+  /**
+   * Publishes version, database size and schema version as states (specification 5.1).
+   *
+   * The objects are created by `createInfoStates`, so this runs after the command states were set up.
+   */
+  async publishInstanceInfo() {
+    var _a;
+    await this.setState("info.version", (_a = this.version) != null ? _a : "0.0.0", true);
+    const file = this.db ? this.databaseFile() : "";
+    await this.setState("info.dbSizeBytes", file && fs.existsSync(file) ? fs.statSync(file).size : 0, true);
+    if (this.db) {
+      await this.setState("info.schemaVersion", String((0, import_database.currentSchemaVersion)(this.db)), true);
+    }
+  }
+  /**
+   * Secret used to sign CSRF tokens. A value from the instance settings wins; without one the adapter generates a
+   * secret on the first start and stores it next to the database, so a restart keeps the CSRF tokens of clients
+   * that are already open valid.
+   */
+  sessionSecret() {
+    var _a;
+    const resolved = (0, import_sessionSecret.resolveSessionSecret)({
+      configured: this.config.sessionSecret,
+      file: path.join(path.dirname(this.databaseFile()), import_sessionSecret.SECRET_FILE_NAME)
+    });
+    if (resolved.source === "configured") {
+      this.log.debug("session secret taken from the instance settings");
+    } else if (resolved.source === "stored") {
+      this.log.debug(`session secret taken from ${resolved.file}`);
+    } else if (resolved.file) {
+      this.log.info(
+        `no session secret configured - generated one and stored it at ${resolved.file}, so sessions and CSRF tokens survive restarts`
+      );
+    } else {
+      this.log.warn(
+        `no session secret configured and it could not be stored (${(_a = resolved.error) != null ? _a : "unknown"}) - a temporary one is used, so all sessions end with the next restart`
+      );
+    }
+    return resolved.secret;
+  }
+  /**
+   * Secret that signs the badge/NFC links.
+   *
+   * A value from the instance settings wins. Without one a secret is generated on the first start and stored next
+   * to the database — otherwise a fresh installation could not create a badge at all and the administration would
+   * only report “not configured”.
+   */
+  tagSecret() {
+    var _a;
+    const resolved = (0, import_sessionSecret.resolveSessionSecret)({
+      configured: this.config.hmacSecret,
+      file: path.join(path.dirname(this.databaseFile()), TAG_SECRET_FILE_NAME)
+    });
+    if (resolved.source === "configured") {
+      this.log.debug("badge link secret taken from the instance settings");
+    } else if (resolved.source === "stored") {
+      this.log.debug(`badge link secret taken from ${resolved.file}`);
+    } else if (resolved.file) {
+      this.log.info(
+        `no badge link secret configured - generated one and stored it at ${resolved.file}, so badges stay valid across restarts`
+      );
+    } else {
+      this.log.warn(
+        `no badge link secret configured and it could not be stored (${(_a = resolved.error) != null ? _a : "unknown"}) - a temporary one is used, so badges stop working with the next restart`
+      );
+    }
+    return resolved.secret;
+  }
+  /**
+   * Builds the services and starts the HTTP server on the configured port.
+   *
+   * Binding can fail (port in use); that must never stop the adapter, so the failure is only logged.
+   */
+  async startApi() {
+    var _a;
+    const db = this.db;
+    if (!db) {
+      return;
+    }
+    const users = (0, import_users.createUsersRepository)(db);
+    const entries = (0, import_entries.createEntriesRepository)(db);
+    const absences = (0, import_absences.createAbsencesRepository)(db);
+    const holidays = (0, import_holidays.createHolidaysRepository)(db);
+    const rules = (0, import_rules.createRulesRepository)(db);
+    const payouts = (0, import_payouts.createPayoutsRepository)(db);
+    const terminals = (0, import_terminals.createTerminalsRepository)(db);
+    const rfid = (0, import_rfid.createRfidRepository)(db);
+    const settings = (0, import_settings.createSettingsRepository)(db);
+    const auth = (0, import_auth.createAuthService)({
+      db,
+      users,
+      settings,
+      secret: this.sessionSecret(),
+      defaultTtlMinutes: this.config.sessionTtlMinutes || 720
+    });
+    const aggregation = (0, import_aggregation.createAggregationService)({
+      db,
+      users,
+      entries,
+      absences,
+      holidays,
+      rules,
+      settings
+    });
+    const triggers = (0, import_triggers.createTriggersRepository)(db);
+    const automations = (0, import_automations.createAutomationsRepository)(db);
+    const sync = (0, import_sync.createSyncService)({ db, entries, users, aggregation });
+    const closing = (0, import_closing.createClosingService)({ db, aggregation, payouts });
+    const backup = (0, import_backup.createBackupService)({
+      db,
+      dir: path.join(path.dirname(this.databaseFile()), "backups"),
+      retentionDays: Math.max(0, Number((_a = this.config.backupRetentionDays) != null ? _a : 30) || 0)
+    });
+    const api = (0, import_api.createApi)({
+      db,
+      auth,
+      users,
+      entries,
+      absences,
+      holidays,
+      rules,
+      payouts,
+      terminals,
+      rfid,
+      triggers,
+      automations,
+      aggregation,
+      sync,
+      settings,
+      backup,
+      kioskEnabled: this.config.kioskEnabled === true,
+      // a reverse proxy in front is the normal case for HTTPS; without the switch the forwarded
+      // headers are ignored, so a client cannot choose its own address or the HTTPS flag
+      trustProxy: this.config.trustProxy === true,
+      hmacSecret: this.tagSecret(),
+      version: this.version,
+      // a saved trigger rule changes the states the adapter has to watch
+      onTriggerRulesChanged: () => void this.refreshTriggerSubscriptions()
+    });
+    this.services = {
+      users,
+      entries,
+      absences,
+      settings,
+      aggregation,
+      sync,
+      closing,
+      backup,
+      triggers,
+      automations
+    };
+    this.events = api.events;
+    api.events.subscribe((event) => {
+      void this.publishEventState(event);
+      if (FIGURES_EVENT_TYPES.includes(event.type)) {
+        this.scheduleStateRefresh();
+      }
+    });
+    this.log.debug(`API routes: ${api.routes().length}`);
+    const webDir = path.join(__dirname, "..", "www");
+    const staticFiles = fs.existsSync(path.join(webDir, "index.html")) ? (0, import_static.createStaticHandler)({ root: webDir }) : void 0;
+    this.log.info(
+      staticFiles ? `web interface found at ${webDir}` : `no web interface at ${webDir} - only the API (and the terminal) is available`
+    );
+    try {
+      this.webServer = await (0, import_server.startWebServer)({
+        router: api.router,
+        port: this.config.port || 8092,
+        bind: this.config.bind || "127.0.0.1",
+        staticFiles,
+        // an uploaded backup is bigger than the default limit; the route carries the same bound
+        maxBodyBytes: import_api.MAX_BACKUP_UPLOAD_BYTES,
+        // live events for the PWA and the terminal: `/api/stream?token=...`
+        stream: {
+          auth,
+          events: api.events,
+          version: this.version,
+          timers: {
+            // the adapter's own timer functions: they are cleared with the adapter on unload
+            setInterval: (handler, milliseconds) => this.setInterval(handler, milliseconds),
+            clearInterval: (handle) => this.clearInterval(handle)
+          }
+        },
+        log: {
+          info: (message) => this.log.info(message),
+          warn: (message) => this.log.warn(message),
+          error: (message) => this.log.error(message)
+        }
+      });
+    } catch (error) {
+      this.log.error(
+        `API could not be started on port ${this.config.port}: ${error.message} - the web interface and the terminal stay unavailable`
+      );
+      this.webServer = null;
+      return;
+    }
+    this.setInterval(
+      () => {
+        try {
+          const removed = auth.purge();
+          if (removed > 0) {
+            this.log.debug(`removed ${removed} expired session(s)`);
+          }
+        } catch (error) {
+          this.log.warn(`session cleanup failed: ${error.message}`);
+        }
+      },
+      SESSION_PURGE_MINUTES * 60 * 1e3
+    );
+  }
+  /**
+   * Creates the command states and subscribes to them.
+   */
+  async subscribeCommands() {
+    try {
+      await (0, import_states.createCommandStates)(this);
+      await (0, import_states.createInfoStates)(this);
+      await (0, import_states.createCompanyStates)(this);
+      await (0, import_states.createEventStates)(this);
+      await this.subscribeStatesAsync("commands.*");
+      await this.subscribeStatesAsync(`users.*.${import_presence.PRESENCE_SUFFIX}`);
+      this.log.debug("command states ready");
+    } catch (error) {
+      this.log.warn(`command states could not be created: ${error.message}`);
+    }
+  }
+  /**
+   * Writes a backup unless a recent one exists.
+   *
+   * The check runs hourly and once at start: a nightly backup therefore happens within an hour at the latest,
+   * and an instance that was down for days does not write a burst of copies.
+   */
+  async runScheduledBackup() {
+    var _a, _b;
+    const backup = (_a = this.services) == null ? void 0 : _a.backup;
+    if (!backup) {
+      return;
+    }
+    try {
+      const newest = backup.list()[0];
+      const ageHours = newest ? (Date.now() / 1e3 - newest.createdAt) / 3600 : Number.POSITIVE_INFINITY;
+      if (ageHours < BACKUP_MAX_AGE_HOURS) {
+        this.log.debug(`backup ${(_b = newest == null ? void 0 : newest.name) != null ? _b : ""} is ${ageHours.toFixed(1)} h old, nothing to do`);
+        return;
+      }
+      const created = backup.create({ actorId: null, reason: "scheduled" });
+      this.log.info(
+        `backup ${created.backup.name} written (${created.backup.sizeBytes} bytes, ${created.backup.users} employees, ${created.backup.entries} punches), ${created.removed.length} old file(s) removed`
+      );
+      await this.announceBackup(created.backup.name, created.backup.createdAt);
+    } catch (error) {
+      this.log.warn(`backup failed: ${error.message}`);
+    }
+  }
+  /**
+   * Publishes the instant of a written backup.
+   *
+   * @param name - file name of the backup
+   * @param createdAt - instant the backup belongs to
+   */
+  async announceBackup(name, createdAt) {
+    var _a;
+    await this.setState("info.lastBackup", createdAt, true);
+    (_a = this.events) == null ? void 0 : _a.publish({
+      type: "backup.create",
+      atUtc: createdAt,
+      userId: null,
+      data: { backup: name }
+    });
+  }
+  /**
+   * Applies a write on the presence state of an employee.
+   *
+   * `users.<id>.present` is the writable twin of `users.<id>.hasOpenEntry`: `true` opens an entry, `false` closes
+   * it. Afterwards the figures of all employees are republished, so a dashboard sees the new state right away.
+   *
+   * @param id - state id without the instance prefix
+   * @param value - value written by the user or a script
+   */
+  async runPresence(id, value) {
+    const services = this.services;
+    if (!services) {
+      return;
+    }
+    try {
+      const result = (0, import_presence.handlePresenceState)(
+        {
+          entries: services.entries,
+          users: services.users,
+          aggregation: services.aggregation
+        },
+        id,
+        value
+      );
+      if (result.ok) {
+        this.log.info(`presence ${id}: ${result.message}`);
+      } else {
+        this.log.warn(`presence ${id}: ${result.message}`);
+      }
+      await this.refreshStates();
+    } catch (error) {
+      this.log.error(`Error in runPresence for ${id}: ${error.message}`);
+    }
+  }
+  /**
+   * Publishes the figures of all employees.
+   */
+  async refreshStates() {
+    const services = this.services;
+    if (!services) {
+      return;
+    }
+    try {
+      const snapshots = await (0, import_states.publishAllUserStates)({
+        port: this,
+        aggregation: services.aggregation,
+        users: services.users,
+        sync: services.sync
+      });
+      this.log.debug(`published ${snapshots.length} employee state(s)`);
+      await (0, import_states.publishCompanySnapshot)(this, (0, import_states.readCompanySnapshot)(snapshots));
+    } catch (error) {
+      this.log.warn(`states could not be published: ${error.message}`);
+    }
+  }
+  /**
+   * Runs a command state and reports the outcome.
+   *
+   * @param id - state id without the instance prefix
+   * @param value - value written by the user or a script
+   */
+  async runCommand(id, value) {
+    var _a;
+    const services = this.services;
+    const db = this.db;
+    if (!services || !db) {
+      return;
+    }
+    try {
+      const result = (0, import_commands.handleCommand)(
+        {
+          db,
+          entries: services.entries,
+          users: services.users,
+          settings: services.settings,
+          aggregation: services.aggregation,
+          closing: services.closing,
+          backup: services.backup
+        },
+        id,
+        value
+      );
+      this.log.info(`command ${id}: ${result.message}`);
+      if (id === import_states.COMMAND_IDS.closeMonth) {
+        (_a = this.events) == null ? void 0 : _a.publish({
+          type: "month.close",
+          atUtc: Math.floor(Date.now() / 1e3),
+          userId: null,
+          data: { period: String(value != null ? value : "") }
+        });
+      }
+      if (id === import_states.COMMAND_IDS.backup && result.ok) {
+        const newest = services.backup.list()[0];
+        if (newest) {
+          await this.announceBackup(newest.name, newest.createdAt);
+        }
+      }
+    } catch (error) {
+      this.log.warn(`command ${id} failed: ${error.message}`);
+    }
+    if (id === import_states.COMMAND_IDS.punch || id === import_states.COMMAND_IDS.quickPunch || id === import_states.COMMAND_IDS.backup) {
+      await this.setState(id, false, true);
+    }
+    await this.refreshStates();
+  }
+  /**
+   * Watches exactly the states the active trigger rules name.
+   *
+   * Runs at startup and whenever the administration saves the rules, so an added, changed or removed rule takes
+   * effect without a restart. A state that no rule names any more is dropped from the watch list.
+   */
+  async refreshTriggerSubscriptions() {
+    const services = this.services;
+    if (!services) {
+      return;
+    }
+    let rules = [];
+    try {
+      rules = services.triggers.list();
+    } catch (error) {
+      this.log.warn(`trigger rules could not be read: ${error.message}`);
+      return;
+    }
+    const wanted = new Set(rules.map((rule) => rule.sourceState));
+    for (const id of [...this.triggerStates]) {
+      if (wanted.has(id)) {
+        continue;
+      }
+      try {
+        await this.unsubscribeForeignStatesAsync(id);
+      } catch (error) {
+        this.log.debug(`trigger state ${id} could not be released: ${error.message}`);
+      }
+      this.triggerStates.delete(id);
+      this.triggerValues.delete(id);
+    }
+    for (const id of wanted) {
+      if (this.triggerStates.has(id)) {
+        continue;
+      }
+      try {
+        await this.subscribeForeignStatesAsync(id);
+        this.triggerStates.add(id);
+      } catch (error) {
+        this.log.warn(`trigger state ${id} could not be watched: ${error.message}`);
+      }
+    }
+    this.log.debug(`watching ${this.triggerStates.size} trigger state(s) for ${rules.length} active rule(s)`);
+  }
+  /**
+   * Applies a write on a state that trigger rules watch.
+   *
+   * Such a state belongs to another adapter, so its `ack` says nothing about whether the value was set by a
+   * script or by the device. What counts is that the value **changed**: a reader that repeats itself, a
+   * dashboard that refreshes or a script that writes the same value twice does not punch twice. Together with
+   * the cooldown of a rule even a rapidly blinking state stays harmless.
+   *
+   * @param id - full state id
+   * @param state - state object of the write
+   * @returns true when the state belongs to a rule and was handled here
+   */
+  handleTriggerState(id, state) {
+    var _a;
+    const services = this.services;
+    if (!services) {
+      return false;
+    }
+    const previous = (_a = this.triggerValues.get(id)) != null ? _a : null;
+    this.triggerValues.set(id, (0, import_triggers2.triggerText)(state.val));
+    const rules = services.triggers.list().filter((rule) => rule.sourceState === id);
+    if (rules.length === 0) {
+      return false;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    for (const rule of rules) {
+      const decision = (0, import_triggers2.evaluateTrigger)(rule, { value: state.val, previous, now }, services.users);
+      if (!decision.fire || decision.userId === null) {
+        this.log.debug(`trigger ${rule.id} (${rule.sourceState}) did not fire: ${decision.reason}`);
+        continue;
+      }
+      this.runTrigger(rule, decision.userId);
+    }
+    return true;
+  }
+  /**
+   * Runs the action of a rule that fired.
+   *
+   * The punch goes through the same path as the command state and a presence change through the same handler as
+   * the `users.<id>.present` state, so direction, rounding, notes and the recalculation behave identically.
+   *
+   * @param rule - rule that fired
+   * @param userId - employee the action applies to
+   */
+  runTrigger(rule, userId) {
+    void (async () => {
+      const services = this.services;
+      if (!services) {
+        return;
+      }
+      try {
+        const result = rule.action === "present" || rule.action === "absent" ? (0, import_presence.handlePresenceState)(
+          { entries: services.entries, users: services.users, aggregation: services.aggregation },
+          `users.${userId}.${import_presence.PRESENCE_SUFFIX}`,
+          rule.action === "present"
+        ) : (0, import_commands.punchEmployee)(
+          {
+            entries: services.entries,
+            users: services.users,
+            settings: services.settings,
+            aggregation: services.aggregation
+          },
+          { userId, quick: rule.action === "quickPunch", note: `trigger.${rule.id}` }
+        );
+        this.log.info(`trigger ${rule.id} (${rule.sourceState}) \u2192 ${result.message}`);
+        services.triggers.markFired({ id: rule.id });
+        await this.refreshStates();
+      } catch (error) {
+        this.log.warn(`trigger ${rule.id} failed: ${error.message}`);
+      }
+    })();
+  }
+  /**
+   * Stops the HTTP server.
+   */
+  async stopApi() {
+    const server = this.webServer;
+    this.webServer = null;
+    if (server) {
+      await server.close();
+      this.log.debug("API stopped");
+    }
+  }
+  /**
+   * Is called when adapter shuts down - callback has to be called under any circumstances!
+   *
+   * @param callback - Callback function
+   */
+  onUnload(callback) {
+    try {
+      void this.stopApi().catch((error) => this.log.warn(`stopping the API failed: ${error.message}`)).finally(() => {
+        var _a;
+        (_a = this.db) == null ? void 0 : _a.close();
+        this.db = null;
+        callback();
+      });
+    } catch (error) {
+      this.log.error(`Error during unloading: ${error.message}`);
+      callback();
+    }
+  }
+  /**
+   * Runs the automation rules that are due.
+   *
+   * A rule acts at most once per employee and period — the local date, or the ISO week for a weekly rule;
+   * `automation_runs` holds that decision, so a restart
+   * cannot punch twice. The run is noted **before** the action (a double punch would be worse than a missed
+   * reminder) and taken back when the action fails, so the next minute retries it.
+   */
+  runAutomationRules() {
+    var _a;
+    const services = this.services;
+    if (!services) {
+      return;
+    }
+    let rules = [];
+    try {
+      rules = services.automations.list();
+    } catch (error) {
+      this.log.warn(`automation rules could not be read: ${error.message}`);
+      return;
+    }
+    if (rules.length === 0) {
+      return;
+    }
+    const nowUtc = Math.floor(Date.now() / 1e3);
+    let acted = false;
+    for (const rule of rules) {
+      const candidates = rule.userId === null ? services.users.list() : [services.users.findById(rule.userId)].filter((user) => user !== null);
+      for (const user of candidates) {
+        if (!user.isActive) {
+          continue;
+        }
+        const local = (0, import_time.localDateTime)(nowUtc, user.timezone);
+        const period = (0, import_automation.runPeriod)(rule.repeat, local.date);
+        if (services.automations.hasRun({ ruleId: rule.id, userId: user.id, period })) {
+          continue;
+        }
+        const punches = services.entries.listByDate(user.id, local.date).map((entry) => ({ tsUtc: entry.tsUtc, direction: entry.direction }));
+        const block = (0, import_automation.workBlock)(punches, nowUtc);
+        const decision = (0, import_automation.evaluateAutomation)(rule, {
+          localDate: local.date,
+          weekday: (0, import_automation.isoWeekday)(local.date),
+          minuteOfDay: local.minutes,
+          hasOpenEntry: block.hasOpenEntry,
+          blockMinutes: block.blockMinutes,
+          alreadyRan: false
+        });
+        if (!decision.fire) {
+          this.log.debug(`automation ${rule.id} (${user.displayName}): ${decision.reason}`);
+          continue;
+        }
+        const action = this.automationAction(rule, block.blockMinutes);
+        if (!services.automations.recordRun({
+          ruleId: rule.id,
+          userId: user.id,
+          period,
+          action,
+          now: nowUtc
+        })) {
+          continue;
+        }
+        try {
+          if (rule.kind === "clockOut" || rule.kind === "clockIn") {
+            const result = (0, import_commands.punchEmployee)(
+              {
+                entries: services.entries,
+                users: services.users,
+                settings: services.settings,
+                aggregation: services.aggregation
+              },
+              { userId: user.id, note: `auto.${rule.kind}`, now: nowUtc }
+            );
+            this.log.info(`automation ${rule.id} for ${user.displayName}: ${result.message}`);
+          } else {
+            this.log.info(`automation ${rule.id} for ${user.displayName}: ${action}`);
+          }
+          acted = true;
+          (_a = this.events) == null ? void 0 : _a.publish({
+            type: `automation.${rule.kind}`,
+            atUtc: nowUtc,
+            userId: user.id,
+            data: { ruleId: rule.id, action, reason: decision.reason }
+          });
+        } catch (error) {
+          services.automations.forgetRun({ ruleId: rule.id, userId: user.id, period });
+          this.log.warn(`automation ${rule.id} for ${user.displayName} failed: ${error.message}`);
+        }
+      }
+    }
+    if (acted) {
+      this.scheduleStateRefresh();
+    }
+  }
+  /**
+   * Short description of what a rule did (the log entry of `automation_runs`).
+   *
+   * @param rule - rule that fired
+   * @param blockMinutes - length of the running work block, `null` when the employee is not clocked in
+   * @returns text for the log
+   */
+  automationAction(rule, blockMinutes) {
+    if (rule.kind === "clockOut") {
+      return "clocked out";
+    }
+    if (rule.kind === "clockIn") {
+      return "clocked in";
+    }
+    if (rule.kind === "breakReminder") {
+      return `reminded after ${blockMinutes != null ? blockMinutes : 0} min without a break`;
+    }
+    return "reported a missing punch";
+  }
+  /**
+   * Republishes the figures shortly after data changed.
+   *
+   * A punch from the web app, the terminal or a badge arrives through the API of this very process, so without
+   * this the states would only change with the five minute timer. One action often produces several events, so
+   * the refresh is collected for a moment instead of running once per event.
+   */
+  scheduleStateRefresh() {
+    if (this.stateRefreshTimer) {
+      return;
+    }
+    this.stateRefreshTimer = this.setTimeout(() => {
+      this.stateRefreshTimer = void 0;
+      void this.refreshStates();
+    }, 1e3);
+  }
+  /**
+   * Publishes the newest event of the instance into the state tree.
+   *
+   * A notification adapter, a dashboard or a Blockly script then only has to watch `events.*` instead of
+   * following the live stream of the web app.
+   *
+   * @param event - event published by the API
+   */
+  async publishEventState(event) {
+    var _a, _b;
+    const services = this.services;
+    if (!services) {
+      return;
+    }
+    try {
+      const data = (_a = event.data) != null ? _a : {};
+      const user = event.userId === null || event.userId === void 0 ? null : services.users.findById(event.userId);
+      await (0, import_states.publishEventSnapshot)(this, {
+        type: event.type,
+        atUtc: event.atUtc,
+        userName: (_b = user == null ? void 0 : user.displayName) != null ? _b : "",
+        direction: typeof data.direction === "string" ? data.direction : "",
+        source: typeof data.source === "string" ? data.source : ""
+      });
+    } catch (error) {
+      this.log.debug(`event state could not be published: ${error.message}`);
+    }
+  }
+  /**
+   * Is called when another adapter sends a message (`sendTo`).
+   *
+   * @param obj - message object of the adapter framework
+   */
+  onMessage(obj) {
+    void (async () => {
+      const services = this.services;
+      if (!services) {
+        return;
+      }
+      try {
+        const answer = await (0, import_messages.handleMessage)(
+          {
+            users: services.users,
+            entries: services.entries,
+            absences: services.absences,
+            settings: services.settings,
+            aggregation: services.aggregation,
+            sync: services.sync,
+            backup: services.backup,
+            version: this.version
+          },
+          obj.command,
+          obj.message
+        );
+        this.log.info(`message ${obj.command}: ${answer.message}`);
+        if (obj.callback) {
+          this.sendTo(obj.from, obj.command, answer, obj.callback);
+        }
+        await this.refreshStates();
+      } catch (error) {
+        const message = error.message;
+        this.log.warn(`message ${obj.command} failed: ${message}`);
+        if (obj.callback) {
+          this.sendTo(obj.from, obj.command, { ok: false, message }, obj.callback);
+        }
+      }
+    })();
+  }
+  /**
+   * Is called if a subscribed state changes
+   *
+   * @param id - State ID
+   * @param state - State object
+   */
+  onStateChange(id, state) {
+    try {
+      if (!state) {
+        return;
+      }
+      if (this.handleTriggerState(id, state)) {
+        return;
+      }
+      if (state.ack) {
+        return;
+      }
+      const prefix = `${this.namespace}.`;
+      const localId = id.startsWith(prefix) ? id.slice(prefix.length) : id;
+      if (localId.startsWith("commands.")) {
+        void this.runCommand(localId, state.val);
+        return;
+      }
+      if ((0, import_presence.parsePresenceStateId)(localId) !== null) {
+        void this.runPresence(localId, state.val);
+        return;
+      }
+      this.log.debug(`Ignored state change: ${localId} = ${state.val}`);
+    } catch (error) {
+      this.log.error(`Error in onStateChange for ${id}: ${error.message}`);
+    }
+  }
+}
+if (require.main !== module) {
+  module.exports = (options) => new TimeTracker(options);
+} else {
+  (() => new TimeTracker())();
+}
+//# sourceMappingURL=main.js.map