dt-common-device 1.3.0 → 2.0.0

package/dist/device/local/entities/IssueBuilder.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueBuilder = void 0;
+const issue_types_1 = require("../../../types/issue.types");
+/**
+ * IssueBuilder - A builder pattern implementation for constructing CreateIssueData objects
+ *
+ * This builder provides a fluent interface for creating issue data with proper validation
+ * and default values. It follows the Builder pattern which is a standard design pattern
+ * in TypeScript for constructing complex objects.
+ *
+ * Usage example:
+ * const issueData = new IssueBuilder()
+ *   .setCategory(IssuesCategory.OPERATIONS)
+ *   .setPropertyId("prop123")
+ *   .setTitle("Device Maintenance Required")
+ *   .setDescription("Device requires scheduled maintenance")
+ *   .setEntityId("device456")
+ *   .setEntityType(EntityType.DEVICE)
+ *   .setPriority(IssuePriority.HIGH)
+ *   .setAssignedTo("tech789")
+ *   .setCreatedBy("user123")
+ *   .setDueDate(new Date("2024-01-15"))
+ *   .build();
+ */
+class IssueBuilder {
+    constructor() {
+        this.data = {};
+    }
+    /**
+     * Sets the issue category
+     */
+    setCategory(category) {
+        this.data.category = category;
+        return this;
+    }
+    /**
+     * Sets the property ID
+     */
+    setPropertyId(propertyId) {
+        if (!propertyId || propertyId.trim() === "") {
+            throw new Error("Property ID is required and cannot be empty");
+        }
+        this.data.propertyId = propertyId;
+        return this;
+    }
+    /**
+     * Sets the issue title
+     */
+    setTitle(title) {
+        if (!title || title.trim() === "") {
+            throw new Error("Title is required and cannot be empty");
+        }
+        this.data.title = title.trim();
+        return this;
+    }
+    /**
+     * Sets the issue description
+     */
+    setDescription(description) {
+        if (!description || description.trim() === "") {
+            throw new Error("Description is required and cannot be empty");
+        }
+        this.data.description = description.trim();
+        return this;
+    }
+    /**
+     * Sets the entity ID (optional)
+     */
+    setEntityId(entityId) {
+        if (entityId !== undefined) {
+            this.data.entityId = entityId.trim() || undefined;
+        }
+        return this;
+    }
+    /**
+     * Sets the entity type
+     */
+    setEntityType(entityType) {
+        this.data.entityType = entityType;
+        return this;
+    }
+    /**
+     * Sets the issue priority (optional, defaults to MEDIUM)
+     */
+    setPriority(priority) {
+        if (priority !== undefined) {
+            this.data.priority = priority;
+        }
+        return this;
+    }
+    /**
+     * Sets the user assigned to the issue (optional)
+     */
+    setAssignedTo(assignedTo) {
+        if (assignedTo !== undefined) {
+            this.data.assignedTo = assignedTo.trim() || undefined;
+        }
+        return this;
+    }
+    /**
+     * Sets the user who created the issue (required)
+     */
+    setCreatedBy(createdBy) {
+        if (!createdBy || createdBy.trim() === "") {
+            throw new Error("Created by user is required and cannot be empty");
+        }
+        this.data.createdBy = createdBy.trim();
+        return this;
+    }
+    /**
+     * Sets the due date (optional)
+     */
+    setDueDate(dueDate) {
+        if (dueDate !== undefined) {
+            this.data.dueDate = dueDate;
+        }
+        return this;
+    }
+    /**
+     * Validates that all required fields are present
+     */
+    validate() {
+        const requiredFields = ["category", "propertyId", "title", "description", "entityType", "createdBy"];
+        const missingFields = requiredFields.filter(field => !this.data[field]);
+        if (missingFields.length > 0) {
+            throw new Error(`Missing required fields: ${missingFields.join(", ")}`);
+        }
+    }
+    /**
+     * Builds and returns the CreateIssueData object
+     * @throws Error if required fields are missing
+     */
+    build() {
+        this.validate();
+        // Set default priority if not provided
+        if (!this.data.priority) {
+            this.data.priority = issue_types_1.IssuePriority.MEDIUM;
+        }
+        return this.data;
+    }
+    /**
+     * Resets the builder to its initial state
+     */
+    reset() {
+        this.data = {};
+        return this;
+    }
+    /**
+     * Creates a new builder instance with predefined values for common issue types
+     */
+    static createReadinessIssue() {
+        return new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.READINESS)
+            .setPriority(issue_types_1.IssuePriority.MEDIUM);
+    }
+    static createOperationsIssue() {
+        return new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+            .setPriority(issue_types_1.IssuePriority.HIGH);
+    }
+    static createSecurityIssue() {
+        return new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.SECURITY)
+            .setPriority(issue_types_1.IssuePriority.CRITICAL);
+    }
+    static createEnergyIssue() {
+        return new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.ENERGY)
+            .setPriority(issue_types_1.IssuePriority.LOW);
+    }
+    /**
+     * Creates a device-specific issue builder
+     */
+    static createDeviceIssue(deviceId, propertyId) {
+        return new IssueBuilder()
+            .setEntityType(issue_types_1.EntityType.DEVICE)
+            .setEntityId(deviceId)
+            .setPropertyId(propertyId);
+    }
+    /**
+     * Creates a hub-specific issue builder
+     */
+    static createHubIssue(hubId, propertyId) {
+        return new IssueBuilder()
+            .setEntityType(issue_types_1.EntityType.HUB)
+            .setEntityId(hubId)
+            .setPropertyId(propertyId);
+    }
+    /**
+     * Creates a user-specific issue builder
+     */
+    static createUserIssue(userId, propertyId) {
+        return new IssueBuilder()
+            .setEntityType(issue_types_1.EntityType.USER)
+            .setEntityId(userId)
+            .setPropertyId(propertyId);
+    }
+    /**
+     * Creates a property-specific issue builder
+     */
+    static createPropertyIssue(propertyId) {
+        return new IssueBuilder()
+            .setEntityType(issue_types_1.EntityType.PROPERTY)
+            .setEntityId(propertyId)
+            .setPropertyId(propertyId);
+    }
+    /**
+     * Creates a maintenance issue builder
+     */
+    static createMaintenanceIssue(propertyId, entityId, entityType) {
+        const builder = new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.READINESS)
+            .setPropertyId(propertyId)
+            .setPriority(issue_types_1.IssuePriority.MEDIUM);
+        if (entityId)
+            builder.setEntityId(entityId);
+        if (entityType)
+            builder.setEntityType(entityType);
+        return builder;
+    }
+    /**
+     * Creates an urgent issue builder
+     */
+    static createUrgentIssue(propertyId, entityId, entityType) {
+        const builder = new IssueBuilder()
+            .setCategory(issue_types_1.IssuesCategory.OPERATIONS)
+            .setPropertyId(propertyId)
+            .setPriority(issue_types_1.IssuePriority.URGENT);
+        if (entityId)
+            builder.setEntityId(entityId);
+        if (entityType)
+            builder.setEntityType(entityType);
+        return builder;
+    }
+}
+exports.IssueBuilder = IssueBuilder;

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

@@ -0,0 +1,2 @@
+export { AlertBuilder } from "./AlertBuilder";
+export { IssueBuilder } from "./IssueBuilder";

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueBuilder = exports.AlertBuilder = void 0;
+var AlertBuilder_1 = require("./AlertBuilder");
+Object.defineProperty(exports, "AlertBuilder", { enumerable: true, get: function () { return AlertBuilder_1.AlertBuilder; } });
+var IssueBuilder_1 = require("./IssueBuilder");
+Object.defineProperty(exports, "IssueBuilder", { enumerable: true, get: function () { return IssueBuilder_1.IssueBuilder; } });

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

@@ -35,18 +35,19 @@ export interface IDevice {
         id: string;
         type: string;
     };
-    status: {
-        online: boolean;
-        error?: {
-            type?: string;
-            message?: string;
-            default?: object;
-        };
-        lastUpdated?: string;
-    };
+    status: INewStatus;
     state?: object;
     metaData?: object;
     createdAt?: Date;
     updatedAt?: Date;
     hubDeviceDetails?: IDevice[];
 }
+export declare class INewStatus {
+    online: boolean;
+    error?: {
+        type?: string;
+        message?: string;
+        default?: object;
+    };
+    lastUpdated?: string;
+}

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

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

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, };