dt-common-device 7.2.1 → 7.2.5

package/dist/device/local/handler/EventHandler.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = void 0;
+const dt_pub_sub_1 = require("dt-pub-sub");
+const dt_audit_library_1 = require("dt-audit-library");
+class EventHandler {
+    constructor() {
+        this.source = "dt-common-device";
+    }
+    async onStateChange(deviceId, state) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent("device.state.set", { deviceId, state }, this.source);
+        const payload = {
+            eventType: "device.state.set",
+            properties: {
+                deviceId,
+                state,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onStatusChange(deviceId, status) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent("device.status.set", { deviceId, status }, this.source);
+        const payload = {
+            eventType: "device.status.set",
+            properties: {
+                deviceId,
+                status,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onBatteryLevelChange(deviceId, batteryLevel) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent("device.battery.set", { deviceId, batteryLevel }, this.source);
+        const payload = {
+            eventType: "device.battery.set",
+            properties: {
+                deviceId,
+                batteryLevel,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+}
+exports.EventHandler = EventHandler;

package/dist/device/local/interface.js

@@ -0,0 +1 @@
+"use strict";

package/dist/device/local/interfaces/IConnection.d.ts

@@ -0,0 +1,26 @@
+export interface IConnection {
+    id?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    isDeleted?: boolean;
+    connectionName: string;
+    connectionRefId: string;
+    propertyId: string;
+    connectionProvider: ConnectionProvider;
+    accessToken?: string;
+    refreshToken?: string;
+    clientId?: string;
+    clientSecret: string;
+    isActive?: boolean;
+    metaData?: any;
+}
+export declare enum ConnectionProvider {
+    Smartthings = "Smartthings",
+    SaltoKS = "SaltoKS",
+    TTLock = "TTLock",
+    Tuya = "Tuya",
+    Schlage = "Schlage",
+    YaleWifi = "YaleWifi",
+    Sensibo = "Sensibo",
+    Devicethread = "Devicethread"
+}

package/dist/device/local/interfaces/IConnection.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionProvider = void 0;
+var ConnectionProvider;
+(function (ConnectionProvider) {
+    ConnectionProvider["Smartthings"] = "Smartthings";
+    ConnectionProvider["SaltoKS"] = "SaltoKS";
+    ConnectionProvider["TTLock"] = "TTLock";
+    ConnectionProvider["Tuya"] = "Tuya";
+    ConnectionProvider["Schlage"] = "Schlage";
+    ConnectionProvider["YaleWifi"] = "YaleWifi";
+    ConnectionProvider["Sensibo"] = "Sensibo";
+    ConnectionProvider["Devicethread"] = "Devicethread";
+})(ConnectionProvider || (exports.ConnectionProvider = ConnectionProvider = {}));

package/dist/device/local/interfaces/IDevice.d.ts

@@ -0,0 +1,68 @@
+export interface IDevice {
+    deviceId: string;
+    propertyId: string;
+    zoneId: string;
+    name: string;
+    hubId: string[];
+    specifications: {
+        manufacturer?: string;
+        model?: string;
+        firmware?: {
+            version?: string;
+            newVersionAvailable?: boolean;
+            newVersion?: string;
+            mandatoryUpdate?: boolean;
+        };
+    };
+    protocol: {
+        location?: {
+            id?: string;
+            name?: string;
+            city?: string;
+        };
+        name?: string;
+        room?: {
+            id?: string;
+            name?: string;
+        };
+        accountId?: string;
+    };
+    connection: {
+        id: string;
+        name: string;
+    };
+    deviceType: {
+        id: string;
+        type: string;
+    };
+    status: IStatus;
+    isActive: {
+        value: boolean;
+        lastUpdated: string;
+    };
+    state?: Record<string, any>;
+    metaData?: Record<string, any>;
+    createdAt?: Date;
+    updatedAt?: Date;
+    hubDeviceDetails?: IDevice[];
+    capabilities?: Record<string, any>;
+}
+export declare class IStatus {
+    online: boolean;
+    liveStatus?: "ONLINE" | "OFFLINE";
+    error?: {
+        type?: string;
+        message?: string;
+        default?: object;
+    };
+    lastUpdated?: string;
+}
+export interface IStatusQuery {
+    deviceIds?: string[];
+    zoneId?: string;
+    propertyId?: string;
+}
+export interface IStatusUpdateRequest {
+    query: IStatusQuery;
+    status: IStatus;
+}

package/dist/device/local/interfaces/IDevice.js

@@ -0,0 +1,10 @@
+"use strict";
+// Interfaces for DeviceService methods
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IStatus = void 0;
+class IStatus {
+    constructor() {
+        this.online = false;
+    }
+}
+exports.IStatus = IStatus;

package/dist/device/local/interfaces/IDtDevice.d.ts

@@ -0,0 +1,16 @@
+export interface IDtDevice {
+    id: string;
+    name: string;
+    type: string;
+    zoneId: string;
+    deviceType: string;
+    deviceId: string;
+    deviceNetworkId: string;
+    propertyId: string;
+    connectionId: string;
+    hubId: string;
+    isBatteryLowAlertSent: boolean;
+    createdAt: string;
+    updatedAt: string;
+    isActive: boolean;
+}

package/dist/device/local/interfaces/IDtDevice.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/device/local/interfaces/IHub.d.ts

@@ -0,0 +1,46 @@
+export interface IHub {
+    deviceId: string;
+    propertyId: string;
+    name: string;
+    hubId?: string[];
+    specifications: {
+        manufacturer?: string;
+        model?: string;
+        firmware?: {
+            version?: string;
+            newVersionAvailable?: boolean;
+            newVersion?: string;
+            mandatoryUpdate?: boolean;
+        };
+    };
+    protocol: {
+        location?: {
+            id?: string;
+            name?: string;
+            city?: string;
+        };
+        name?: string;
+        room?: {
+            id?: string;
+            name?: string;
+        };
+        accountId?: string;
+    };
+    deviceType: {
+        id: string;
+        type: string;
+    };
+    status: {
+        online: boolean;
+        error?: {
+            type?: string;
+            message?: string;
+            default?: object;
+        };
+        lastUpdated?: Date;
+    };
+    state?: object;
+    metaData?: object;
+    createdAt?: Date;
+    updatedAt?: Date;
+}

package/dist/device/local/interfaces/IHub.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/device/local/interfaces/IProperty.d.ts

@@ -0,0 +1,29 @@
+export interface IProperty {
+    id: string;
+    name: string;
+    apartment: string;
+    city: string;
+    country: string;
+    state: string;
+    street: string;
+    zipCode: string;
+    createdBy?: string;
+    isDeleted: boolean;
+    imageURL: string;
+    timezone: string;
+    officialName?: string;
+    sameAsOfficialName?: boolean;
+    phoneNumber?: string;
+    phoneNumberCountryCode?: string;
+    propertyKey?: string;
+    hubNetworkId?: string;
+    isTimeZoneOverridden: boolean;
+    createdAt: string;
+    updatedAt: string;
+    propertyBillingId?: string;
+}
+export interface IPropertySettings {
+    id: string;
+    propertyId: string;
+    settings: Record<string, any>;
+}

package/dist/device/local/interfaces/IProperty.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/device/local/interfaces/ISchedule.d.ts

@@ -0,0 +1,25 @@
+export interface ISchedule {
+    id?: string;
+    name: string;
+    deviceId: string;
+    scheduleId: string | null;
+    state: {
+        targetTemperature?: number;
+        temperatureUnit?: "C" | "F";
+        mode?: "cool" | "heat" | "fan" | "dry" | "auto";
+        swing?: "stopped" | "rangeFull" | "fixedTop" | "fixedMiddleTop" | "fixedMiddle" | "fixedMiddleBottom" | "fixedBottom";
+        fanLevel?: "auto" | "low" | "medium" | "high";
+    };
+    startTime: string;
+    endTime: string;
+    recurringDays: ("Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday")[];
+    createTime?: string;
+    nextTime?: string;
+    nextTimeSecondsFromNow?: number;
+    targetTimeLocal: string;
+    timezone: string;
+    scheduleInheritedFrom: "zone" | "device";
+    zoneId: string;
+    userId: string;
+    status?: "SET" | "UNSET";
+}

package/dist/device/local/interfaces/ISchedule.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/device/local/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IDevice";
+export * from "./IDtDevice";
+export * from "./ISchedule";

package/dist/device/local/interfaces/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IDevice"), exports);
+__exportStar(require("./IDtDevice"), exports);
+__exportStar(require("./ISchedule"), exports);

package/dist/device/local/models/Alert.model.d.ts

@@ -0,0 +1,28 @@
+import mongoose, { Model } from "mongoose";
+import { AlertCategory, AlertSeverity, EntityType, AlertDocument as IAlertDocument, CreateAlertData, UpdateAlertData } from "../../../types/alert.types";
+interface IAlertMethods {
+    markAsRead(updatedBy: string): void;
+    markAsUnread(updatedBy: string): void;
+    activate(updatedBy: string): void;
+    deactivate(updatedBy: string): void;
+    snooze(until: Date, updatedBy: string): void;
+    unsnooze(updatedBy: string): void;
+}
+interface IAlertModel extends Model<IAlertDocument, {}, IAlertMethods> {
+    findByProperty(propertyId: string, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findByCategory(category: AlertCategory, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findBySeverity(severity: AlertSeverity, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findActive(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findUnread(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findSnoozed(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    findExpiredSnooze(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+}
+declare const AlertSchema: mongoose.Schema<IAlertDocument, IAlertModel, IAlertMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IAlertDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IAlertDocument>, {}> & Omit<mongoose.FlatRecord<IAlertDocument> & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, keyof IAlertMethods> & IAlertMethods>;
+export declare const AlertModel: IAlertModel;
+export { AlertSchema };
+export type { IAlertDocument, CreateAlertData, UpdateAlertData, IAlertMethods, IAlertModel, };

package/dist/device/local/models/Alert.model.js

@@ -0,0 +1,222 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertSchema = exports.AlertModel = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const alert_types_1 = require("../../../types/alert.types");
+// Main Alert schema
+const AlertSchema = new mongoose_1.Schema({
+    category: {
+        type: String,
+        enum: Object.values(alert_types_1.AlertCategory),
+        required: true,
+    },
+    propertyId: {
+        type: String,
+        required: true,
+        index: true,
+    },
+    title: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    description: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    entityId: {
+        type: String,
+        index: true,
+    },
+    entityType: {
+        type: String,
+        enum: Object.values(alert_types_1.EntityType),
+        required: true,
+        index: true,
+    },
+    severity: {
+        type: String,
+        enum: Object.values(alert_types_1.AlertSeverity),
+        default: alert_types_1.AlertSeverity.MEDIUM,
+    },
+    isRead: {
+        type: Boolean,
+        default: false,
+        index: true,
+    },
+    isActive: {
+        type: Boolean,
+        default: true,
+        index: true,
+    },
+    isDeleted: {
+        type: Boolean,
+        default: false,
+    },
+    snoozeUntil: {
+        type: Date,
+    },
+    createdBy: {
+        type: String,
+    },
+    updatedBy: {
+        type: String,
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now,
+    },
+    updatedAt: {
+        type: Date,
+        default: Date.now,
+    },
+}, {
+    timestamps: true,
+    collection: "dt_alerts",
+});
+exports.AlertSchema = AlertSchema;
+// Compound indexes to match Prisma schema
+AlertSchema.index({ propertyId: 1, isActive: 1, isRead: 1 });
+AlertSchema.index({ entityId: 1, entityType: 1 });
+AlertSchema.index({ createdAt: 1 });
+// Pre-save middleware to update the updatedAt field
+AlertSchema.pre("save", function (next) {
+    this.updatedAt = new Date();
+    next();
+});
+// Pre-update middleware to update the updatedAt field
+AlertSchema.pre(["updateOne", "findOneAndUpdate", "updateMany"], function (next) {
+    this.set({ updatedAt: new Date() });
+    next();
+});
+// Instance methods
+AlertSchema.methods.markAsRead = function (updatedBy) {
+    this.isRead = true;
+    this.updatedBy = updatedBy;
+};
+AlertSchema.methods.markAsUnread = function (updatedBy) {
+    this.isRead = false;
+    this.updatedBy = updatedBy;
+};
+AlertSchema.methods.activate = function (updatedBy) {
+    this.isActive = true;
+    this.updatedBy = updatedBy;
+};
+AlertSchema.methods.deactivate = function (updatedBy) {
+    this.isActive = false;
+    this.updatedBy = updatedBy;
+};
+AlertSchema.methods.snooze = function (until, updatedBy) {
+    this.snoozeUntil = until;
+    this.updatedBy = updatedBy;
+};
+AlertSchema.methods.unsnooze = function (updatedBy) {
+    this.snoozeUntil = undefined;
+    this.updatedBy = updatedBy;
+};
+// Static methods
+AlertSchema.statics.findByProperty = function (propertyId, includeDeleted = false) {
+    const query = { propertyId };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ createdAt: -1 });
+};
+AlertSchema.statics.findByEntity = function (entityId, entityType, includeDeleted = false) {
+    const query = { entityId, entityType };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ createdAt: -1 });
+};
+AlertSchema.statics.findByCategory = function (category, includeDeleted = false) {
+    const query = { category };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ createdAt: -1 });
+};
+AlertSchema.statics.findBySeverity = function (severity, includeDeleted = false) {
+    const query = { severity };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ severity: -1, createdAt: -1 });
+};
+AlertSchema.statics.findActive = function (includeDeleted = false) {
+    const query = { isActive: true };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ severity: -1, createdAt: -1 });
+};
+AlertSchema.statics.findUnread = function (includeDeleted = false) {
+    const query = { isRead: false };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ severity: -1, createdAt: -1 });
+};
+AlertSchema.statics.findSnoozed = function (includeDeleted = false) {
+    const query = { snoozeUntil: { $exists: true, $ne: null } };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ snoozeUntil: 1 });
+};
+AlertSchema.statics.findExpiredSnooze = function (includeDeleted = false) {
+    const query = {
+        snoozeUntil: { $lt: new Date() },
+        isActive: true,
+    };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ snoozeUntil: 1 });
+};
+// Virtual for snooze status
+AlertSchema.virtual("isSnoozed").get(function () {
+    return this.snoozeUntil && this.snoozeUntil > new Date();
+});
+AlertSchema.virtual("isSnoozeExpired").get(function () {
+    return this.snoozeUntil && this.snoozeUntil <= new Date();
+});
+// Ensure virtuals are serialized
+AlertSchema.set("toJSON", { virtuals: true });
+AlertSchema.set("toObject", { virtuals: true });
+// Create and export the model
+exports.AlertModel = mongoose_1.default.model("Alert", AlertSchema);

package/dist/device/local/models/Issue.model.d.ts

@@ -0,0 +1,28 @@
+import mongoose, { Model } from "mongoose";
+import { EntityType, IssueStatus, IssuePriority, IssueDocument as IIssueDocument, CreateIssueData, UpdateIssueData, AddCommentData } from "../../../types/issue.types";
+interface IIssueMethods {
+    addComment(commentData: AddCommentData): void;
+    updateComment(commentId: string, content: string, userId: string): boolean;
+    removeComment(commentId: string): boolean;
+    resolve(resolvedBy: string): void;
+    reopen(updatedBy: string): void;
+    assign(userId: string, assignedBy: string): void;
+    unassign(unassignedBy: string): void;
+}
+interface IIssueModel extends Model<IIssueDocument, {}, IIssueMethods> {
+    findByProperty(propertyId: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findByAssignee(assignedTo: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findByStatus(status: IssueStatus, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findByPriority(priority: IssuePriority, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findOverdue(includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    findUpcoming(days?: number, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+}
+declare const IssueSchema: mongoose.Schema<IIssueDocument, IIssueModel, IIssueMethods, {}, {}, {}, mongoose.DefaultSchemaOptions, IIssueDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<IIssueDocument>, {}> & Omit<mongoose.FlatRecord<IIssueDocument> & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, keyof IIssueMethods> & IIssueMethods>;
+export declare const IssueModel: IIssueModel;
+export { IssueSchema };
+export type { IIssueDocument, CreateIssueData, UpdateIssueData, AddCommentData, IIssueMethods, IIssueModel, };