dt-common-device 3.0.9 → 3.0.11

package/src/index.ts

@@ -1,43 +0,0 @@
-// Main entry point for dt-common-device
-
-// CONSTANTS EXPORTS
-export * from "./constants";
-
-// DEVICE EXPORTS
-export {
-  CloudDevice,
-  CloudDeviceService,
-  DeviceFactory,
-} from "./device/cloud/entities";
-export {
-  LocalDeviceService,
-  LocalHubService,
-  LocalScheduleService,
-} from "./device/local/services";
-export * from "./device/local/interfaces";
-export * from "./device/cloud/interfaces";
-
-// CONNECTION EXPORTS
-export * from "./connection";
-
-// PROPERTY EXPORTS
-export * from "./property";
-
-// EVENTS EXPORTS
-export * from "./events";
-export * from "./events/interfaces";
-
-// ALERTS EXPORTS
-export * from "./alerts";
-
-// ISSUES EXPORTS
-export * from "./issues";
-
-// REDIS EXPORTS
-export * from "./utils";
-
-// QUEUE EXPORTS
-export * from "./queue";
-
-// CONFIG EXPORTS
-export { initialize, getConfig, shutdown } from "./config/config";

package/src/issues/Issue.model.ts

@@ -1,350 +0,0 @@
-import mongoose, { Schema, Model } from "mongoose";
-import {
-  IssuesCategory,
-  EntityType,
-  IssueStatus,
-  IssuePriority,
-  IssueComment,
-  IssueDocument as IIssueDocument,
-  CreateIssueData,
-  UpdateIssueData,
-  AddCommentData,
-} from "./issue.types";
-
-// Comment sub-schema
-const CommentSchema = new Schema<IssueComment>(
-  {
-    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 }
-);
-
-// Interface for instance methods
-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 for static methods
-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[]>;
-}
-
-// Main Issue schema
-const IssueSchema = new Schema<IIssueDocument, IIssueModel, IIssueMethods>(
-  {
-    category: {
-      type: String,
-      enum: Object.values(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(EntityType),
-      required: true,
-      index: true,
-    },
-    status: {
-      type: String,
-      enum: Object.values(IssueStatus),
-      default: IssueStatus.PENDING,
-      index: true,
-    },
-    priority: {
-      type: String,
-      enum: Object.values(IssuePriority),
-      default: 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",
-  }
-);
-
-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: AddCommentData): void {
-  const comment: IssueComment = {
-    id: new mongoose.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: string,
-  content: string,
-  userId: string
-): boolean {
-  if (!this.comments) return false;
-
-  const comment = this.comments.find((c: IssueComment) => c.id === commentId);
-  if (comment) {
-    comment.content = content;
-    comment.updatedAt = new Date();
-    return true;
-  }
-  return false;
-};
-
-IssueSchema.methods.removeComment = function (commentId: string): boolean {
-  if (!this.comments) return false;
-
-  const initialLength = this.comments.length;
-  this.comments = this.comments.filter((c: IssueComment) => c.id !== commentId);
-  return this.comments.length < initialLength;
-};
-
-IssueSchema.methods.resolve = function (resolvedBy: string): void {
-  this.status = IssueStatus.RESOLVED;
-  this.resolvedAt = new Date();
-  this.updatedBy = resolvedBy;
-};
-
-IssueSchema.methods.reopen = function (updatedBy: string): void {
-  this.status = IssueStatus.PENDING;
-  this.resolvedAt = undefined;
-  this.updatedBy = updatedBy;
-};
-
-IssueSchema.methods.assign = function (
-  userId: string,
-  assignedBy: string
-): void {
-  this.assignedTo = userId;
-  this.updatedBy = assignedBy;
-};
-
-IssueSchema.methods.unassign = function (unassignedBy: string): void {
-  this.assignedTo = undefined;
-  this.updatedBy = unassignedBy;
-};
-
-// Static methods
-IssueSchema.statics.findByProperty = function (
-  propertyId: string,
-  includeDeleted = false
-) {
-  const query: any = { propertyId };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ createdAt: -1 });
-};
-
-IssueSchema.statics.findByAssignee = function (
-  assignedTo: string,
-  includeDeleted = false
-) {
-  const query: any = { assignedTo };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ priority: -1, createdAt: -1 });
-};
-
-IssueSchema.statics.findByEntity = function (
-  entityId: string,
-  entityType: EntityType,
-  includeDeleted = false
-) {
-  const query: any = { entityId, entityType };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ createdAt: -1 });
-};
-
-IssueSchema.statics.findByStatus = function (
-  status: IssueStatus,
-  includeDeleted = false
-) {
-  const query: any = { status };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ priority: -1, createdAt: -1 });
-};
-
-IssueSchema.statics.findByPriority = function (
-  priority: IssuePriority,
-  includeDeleted = false
-) {
-  const query: any = { priority };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ createdAt: -1 });
-};
-
-IssueSchema.statics.findOverdue = function (includeDeleted = false) {
-  const query: any = {
-    dueDate: { $lt: new Date() },
-    status: {
-      $nin: [IssueStatus.RESOLVED, IssueStatus.CLOSED, IssueStatus.CANCELLED],
-    },
-  };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ dueDate: 1 });
-};
-
-IssueSchema.statics.findUpcoming = function (
-  days: number = 7,
-  includeDeleted = false
-) {
-  const futureDate = new Date();
-  futureDate.setDate(futureDate.getDate() + days);
-
-  const query: any = {
-    dueDate: { $gte: new Date(), $lte: futureDate },
-    status: {
-      $nin: [IssueStatus.RESOLVED, IssueStatus.CLOSED, 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
-export const IssueModel = mongoose.model<IIssueDocument, IIssueModel>(
-  "Issue",
-  IssueSchema
-);
-
-// Export the schema for potential reuse
-export { IssueSchema };
-
-// Export types for external use
-export type {
-  IIssueDocument,
-  CreateIssueData,
-  UpdateIssueData,
-  AddCommentData,
-  IIssueMethods,
-  IIssueModel,
-};