dt-common-device 11.2.1 → 12.0.0

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

@@ -1,260 +0,0 @@
-"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

@@ -1,106 +0,0 @@
-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>;
-}