dt-common-device 13.0.3 → 13.0.7

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

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

@@ -0,0 +1,260 @@
+"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.IssueSchema = exports.IssueModel = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const issue_types_1 = require("../../../types/issue.types");
+// Comment sub-schema
+const CommentSchema = new mongoose_1.Schema({
+    id: { type: String, required: true },
+    userId: { type: String, required: true },
+    content: { type: String, required: true },
+    createdAt: { type: Date, default: Date.now },
+    updatedAt: { type: Date },
+}, { _id: false });
+// Main Issue schema
+const IssueSchema = new mongoose_1.Schema({
+    category: {
+        type: String,
+        enum: Object.values(issue_types_1.IssuesCategory),
+        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(issue_types_1.EntityType),
+        required: true,
+        index: true,
+    },
+    status: {
+        type: String,
+        enum: Object.values(issue_types_1.IssueStatus),
+        default: issue_types_1.IssueStatus.PENDING,
+        index: true,
+    },
+    priority: {
+        type: String,
+        enum: Object.values(issue_types_1.IssuePriority),
+        default: issue_types_1.IssuePriority.MEDIUM,
+    },
+    assignedTo: {
+        type: String,
+        index: true,
+    },
+    createdBy: {
+        type: String,
+        required: true,
+    },
+    updatedBy: {
+        type: String,
+    },
+    isDeleted: {
+        type: Boolean,
+        default: false,
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now,
+    },
+    updatedAt: {
+        type: Date,
+        default: Date.now,
+    },
+    resolvedAt: {
+        type: Date,
+    },
+    dueDate: {
+        type: Date,
+    },
+    comments: {
+        type: [CommentSchema],
+        default: [],
+    },
+}, {
+    timestamps: true,
+    collection: "dt_issues",
+});
+exports.IssueSchema = IssueSchema;
+IssueSchema.index({ propertyId: 1, status: 1 });
+IssueSchema.index({ assignedTo: 1, status: 1 });
+IssueSchema.index({ entityId: 1, entityType: 1 });
+// Pre-save middleware to update the updatedAt field
+IssueSchema.pre("save", function (next) {
+    this.updatedAt = new Date();
+    next();
+});
+// Pre-update middleware to update the updatedAt field
+IssueSchema.pre(["updateOne", "findOneAndUpdate", "updateMany"], function (next) {
+    this.set({ updatedAt: new Date() });
+    next();
+});
+// Instance methods
+IssueSchema.methods.addComment = function (commentData) {
+    const comment = {
+        id: new mongoose_1.default.Types.ObjectId().toString(),
+        userId: commentData.userId,
+        content: commentData.content,
+        createdAt: new Date(),
+    };
+    if (!this.comments) {
+        this.comments = [];
+    }
+    this.comments.push(comment);
+};
+IssueSchema.methods.updateComment = function (commentId, content, userId) {
+    if (!this.comments)
+        return false;
+    const comment = this.comments.find((c) => c.id === commentId);
+    if (comment) {
+        comment.content = content;
+        comment.updatedAt = new Date();
+        return true;
+    }
+    return false;
+};
+IssueSchema.methods.removeComment = function (commentId) {
+    if (!this.comments)
+        return false;
+    const initialLength = this.comments.length;
+    this.comments = this.comments.filter((c) => c.id !== commentId);
+    return this.comments.length < initialLength;
+};
+IssueSchema.methods.resolve = function (resolvedBy) {
+    this.status = issue_types_1.IssueStatus.RESOLVED;
+    this.resolvedAt = new Date();
+    this.updatedBy = resolvedBy;
+};
+IssueSchema.methods.reopen = function (updatedBy) {
+    this.status = issue_types_1.IssueStatus.PENDING;
+    this.resolvedAt = undefined;
+    this.updatedBy = updatedBy;
+};
+IssueSchema.methods.assign = function (userId, assignedBy) {
+    this.assignedTo = userId;
+    this.updatedBy = assignedBy;
+};
+IssueSchema.methods.unassign = function (unassignedBy) {
+    this.assignedTo = undefined;
+    this.updatedBy = unassignedBy;
+};
+// Static methods
+IssueSchema.statics.findByProperty = function (propertyId, includeDeleted = false) {
+    const query = { propertyId };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ createdAt: -1 });
+};
+IssueSchema.statics.findByAssignee = function (assignedTo, includeDeleted = false) {
+    const query = { assignedTo };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ priority: -1, createdAt: -1 });
+};
+IssueSchema.statics.findByEntity = function (entityId, entityType, includeDeleted = false) {
+    const query = { entityId, entityType };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ createdAt: -1 });
+};
+IssueSchema.statics.findByStatus = function (status, includeDeleted = false) {
+    const query = { status };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ priority: -1, createdAt: -1 });
+};
+IssueSchema.statics.findByPriority = function (priority, includeDeleted = false) {
+    const query = { priority };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ createdAt: -1 });
+};
+IssueSchema.statics.findOverdue = function (includeDeleted = false) {
+    const query = {
+        dueDate: { $lt: new Date() },
+        status: {
+            $nin: [issue_types_1.IssueStatus.RESOLVED, issue_types_1.IssueStatus.CLOSED, issue_types_1.IssueStatus.CANCELLED],
+        },
+    };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ dueDate: 1 });
+};
+IssueSchema.statics.findUpcoming = function (days = 7, includeDeleted = false) {
+    const futureDate = new Date();
+    futureDate.setDate(futureDate.getDate() + days);
+    const query = {
+        dueDate: { $gte: new Date(), $lte: futureDate },
+        status: {
+            $nin: [issue_types_1.IssueStatus.RESOLVED, issue_types_1.IssueStatus.CLOSED, issue_types_1.IssueStatus.CANCELLED],
+        },
+    };
+    if (!includeDeleted) {
+        query.isDeleted = false;
+    }
+    return this.find(query).sort({ dueDate: 1 });
+};
+// Virtual for soft delete
+IssueSchema.virtual("isActive").get(function () {
+    return !this.isDeleted;
+});
+// Ensure virtuals are serialized
+IssueSchema.set("toJSON", { virtuals: true });
+IssueSchema.set("toObject", { virtuals: true });
+// Create and export the model
+exports.IssueModel = mongoose_1.default.model("Issue", IssueSchema);

package/dist/device/local/repository/Alert.repository.d.ts

@@ -0,0 +1,106 @@
+import { IAlertDocument } from "../models/Alert.model";
+import { CreateAlertData, UpdateAlertData, AlertCategory, AlertSeverity, EntityType } from "../../../types/alert.types";
+export declare class AlertRepository {
+    /**
+     * Create a new alert
+     */
+    create(alertData: CreateAlertData): Promise<IAlertDocument>;
+    /**
+     * Find alert by ID
+     */
+    findById(id: string, includeDeleted?: boolean): Promise<IAlertDocument | null>;
+    /**
+     * Find all alerts with filters
+     */
+    findAll(filters?: {
+        propertyId?: string;
+        category?: AlertCategory;
+        severity?: AlertSeverity;
+        entityType?: EntityType;
+        entityId?: string;
+        isActive?: boolean;
+        isRead?: boolean;
+        includeDeleted?: boolean;
+        limit?: number;
+        skip?: number;
+        sort?: {
+            [key: string]: 1 | -1;
+        };
+    }): Promise<IAlertDocument[]>;
+    /**
+     * Update an alert
+     */
+    update(id: string, updateData: UpdateAlertData): Promise<IAlertDocument | null>;
+    /**
+     * Soft delete an alert
+     */
+    softDelete(id: string, deletedBy: string): Promise<boolean>;
+    /**
+     * Permanently delete an alert
+     */
+    hardDelete(id: string): Promise<boolean>;
+    /**
+     * Count alerts with filters
+     */
+    count(filters?: {
+        propertyId?: string;
+        category?: AlertCategory;
+        severity?: AlertSeverity;
+        entityType?: EntityType;
+        entityId?: string;
+        isActive?: boolean;
+        isRead?: boolean;
+        includeDeleted?: boolean;
+    }): Promise<number>;
+    /**
+     * Find alerts by property
+     */
+    findByProperty(propertyId: string, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find alerts by entity
+     */
+    findByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find alerts by category
+     */
+    findByCategory(category: AlertCategory, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find alerts by severity
+     */
+    findBySeverity(severity: AlertSeverity, includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find active alerts
+     */
+    findActive(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find unread alerts
+     */
+    findUnread(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find snoozed alerts
+     */
+    findSnoozed(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Find expired snooze alerts
+     */
+    findExpiredSnooze(includeDeleted?: boolean): Promise<IAlertDocument[]>;
+    /**
+     * Get alert statistics
+     */
+    getStatistics(propertyId?: string): Promise<{
+        total: number;
+        active: number;
+        unread: number;
+        snoozed: number;
+        bySeverity: Record<AlertSeverity, number>;
+        byCategory: Record<AlertCategory, number>;
+    }>;
+    /**
+     * Bulk update alerts
+     */
+    bulkUpdate(ids: string[], updateData: Partial<UpdateAlertData>): Promise<number>;
+    /**
+     * Bulk soft delete alerts
+     */
+    bulkSoftDelete(ids: string[], deletedBy: string): Promise<number>;
+}