dt-common-device/dist/events/BaseEventHandler.js

A secure and robust device management library for IoT applications

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.BaseEventHandler = void 0;
const config_1 = require("../config/config");
const Device_service_1 = require("../entities/device/local/services/Device.service");
const typedi_1 = __importDefault(require("typedi"));
const IAuditProperties_1 = require("../audit/IAuditProperties");
const audit_1 = require("../audit");
const constants_1 = require("../constants");
class BaseEventHandler {
    constructor(supportedEventTypes, priority = 100) {
        this.supportedEventTypes = supportedEventTypes;
        this.priority = priority;
        this.logger = (0, config_1.getConfig)().LOGGER;
        // Use dependency injection instead of creating new instance
        this.localDeviceService = typedi_1.default.get(Device_service_1.LocalDeviceService);
    }
    /**
     * Handle a single event - to be implemented by specific handlers
     */
    async handleEvent(event) {
        try {
            await this.beforeEvent(event);
            await this.onEvent(event);
        }
        catch (error) {
            this.logger.error(`${this.constructor.name}: Error during event processing`, {
                eventName: event.eventName,
                deviceId: event.deviceId,
                error,
            });
            throw error;
        }
        finally {
            await this.afterEvent(event.deviceId, event, {
                resource: IAuditProperties_1.Resource.DEVICE,
                source: constants_1.Source.CLOUD_EVENT,
                propertyId: event.data.propertyId || "",
                deviceId: event.deviceId,
            }, {}, event.eventName);
        }
    }
    async beforeEvent(event) {
        this.logger.info("[DT | CDL]:[BaseEventHandler]: Before event - Handle Before Event");
    }
    async afterEvent(deviceId, event, auditBody, actionPayload, eventType) {
        await (0, audit_1.pushAudit)({
            auditType: eventType || constants_1.DT_EVENT_TYPES.DEVICE.STATE.CHANGED,
            auditData: {
                ...event.data,
                ...auditBody,
                deviceId,
                actionPayload,
                connectionProvider: event.connectionProvider,
            },
        });
        this.logger.info("[DT | CDL]:[BaseEventHandler]: After event - Event processing completed");
    }
    /**
     * Handle multiple events - default implementation processes them sequentially
     */
    async handleEvents(events) {
        try {
            this.logger.info(`Processing ${events.length} events with ${this.constructor.name}`);
            for (const event of events) {
                if (this.canHandle(event.eventName || "unknown")) {
                    await this.handleEvent(event);
                }
                else {
                    this.logger.warn(`Event type ${event.eventName} not supported by ${this.constructor.name}`);
                }
            }
        }
        catch (error) {
            this.logger.error(`${this.constructor.name}: handleEvents Error`, error);
        }
    }
    async onStateChange(deviceId, state, auditProperties, eventType) {
        try {
            await this.localDeviceService.setState(deviceId, state, auditProperties, eventType);
        }
        catch (error) {
            this.logger.error(`[DT | CDL]:[BaseEventHandler]: Error during state change: ${error.message || error.toString()}`);
        }
    }
    /**
     * Check if this handler can process the given event type
     */
    canHandle(eventType) {
        return this.supportedEventTypes.includes(eventType);
    }
    /**
     * Get the priority of this handler
     */
    getPriority() {
        return this.priority;
    }
    /**
     * Get the event types this handler can process
     */
    getSupportedEventTypes() {
        return this.supportedEventTypes;
    }
    /**
     * Common validation method
     */
    validateEvent(event) {
        if (!event) {
            this.logger.error("Event is null or undefined");
            return false;
        }
        if (!event.eventName) {
            this.logger.error("Event name is missing");
            return false;
        }
        return true;
    }
    /**
     * Common error handling method
     */
    async handleError(error, context) {
        this.logger.error(`${this.constructor.name}: ${context} Error`, error);
    }
}
exports.BaseEventHandler = BaseEventHandler;