dt-common-device 2.0.7 → 3.0.0

package/dist/issues/Issue.model.d.ts

@@ -0,0 +1,28 @@
+import mongoose, { Model } from "mongoose";
+import { EntityType, IssueStatus, IssuePriority, IssueDocument as IIssueDocument, CreateIssueData, UpdateIssueData, AddCommentData } from "./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/issues/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("./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/issues/Issue.repository.d.ts

@@ -0,0 +1,113 @@
+import { IIssueDocument } from "./Issue.model";
+import { CreateIssueData, UpdateIssueData, IssueStatus, IssuePriority, IssuesCategory, EntityType } from "./issue.types";
+export declare class IssueRepository {
+    /**
+     * Create a new issue
+     */
+    create(issueData: CreateIssueData): Promise<IIssueDocument>;
+    /**
+     * Find issue by ID
+     */
+    findById(id: string, includeDeleted?: boolean): Promise<IIssueDocument | null>;
+    /**
+     * Find all issues with filters
+     */
+    findAll(filters?: {
+        propertyId?: string;
+        assignedTo?: string;
+        status?: IssueStatus;
+        priority?: IssuePriority;
+        category?: IssuesCategory;
+        entityType?: EntityType;
+        entityId?: string;
+        includeDeleted?: boolean;
+        limit?: number;
+        skip?: number;
+        sort?: {
+            [key: string]: 1 | -1;
+        };
+    }): Promise<IIssueDocument[]>;
+    /**
+     * Update an issue
+     */
+    update(id: string, updateData: UpdateIssueData): Promise<IIssueDocument | null>;
+    /**
+     * Soft delete an issue
+     */
+    softDelete(id: string, deletedBy: string): Promise<boolean>;
+    /**
+     * Permanently delete an issue
+     */
+    hardDelete(id: string): Promise<boolean>;
+    /**
+     * Count issues with filters
+     */
+    count(filters?: {
+        propertyId?: string;
+        assignedTo?: string;
+        status?: IssueStatus;
+        priority?: IssuePriority;
+        category?: IssuesCategory;
+        entityType?: EntityType;
+        entityId?: string;
+        includeDeleted?: boolean;
+    }): Promise<number>;
+    /**
+     * Find issues by property
+     */
+    findByProperty(propertyId: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Find issues by assignee
+     */
+    findByAssignee(assignedTo: string, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Find issues by entity
+     */
+    findByEntity(entityId: string, entityType: EntityType, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Find issues by status
+     */
+    findByStatus(status: IssueStatus, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Find issues by priority
+     */
+    findByPriority(priority: IssuePriority, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Find overdue issues
+     */
+    findOverdue(includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Find upcoming issues
+     */
+    findUpcoming(days?: number, includeDeleted?: boolean): Promise<IIssueDocument[]>;
+    /**
+     * Search issues by text
+     */
+    search(searchTerm: string, filters?: {
+        propertyId?: string;
+        includeDeleted?: boolean;
+        limit?: number;
+        skip?: number;
+    }): Promise<IIssueDocument[]>;
+    /**
+     * Get issue statistics
+     */
+    getStatistics(propertyId?: string): Promise<{
+        total: number;
+        pending: number;
+        inProgress: number;
+        resolved: number;
+        closed: number;
+        overdue: number;
+        byPriority: Record<IssuePriority, number>;
+        byCategory: Record<IssuesCategory, number>;
+    }>;
+    /**
+     * Bulk update issues
+     */
+    bulkUpdate(ids: string[], updateData: Partial<UpdateIssueData>): Promise<number>;
+    /**
+     * Bulk soft delete issues
+     */
+    bulkSoftDelete(ids: string[], deletedBy: string): Promise<number>;
+}