payservedb 8.1.6 → 8.1.8

package/index.js

@@ -221,6 +221,14 @@ const models = {
     FacilityBillingPrice: require("./src/models/facilityBillingPrices"),
     FacilityInvoicePayment: require("./src/models/facilityInvoicePayment"),
     CommunicationUserOpt: require("./src/models/communication_user_opt"),
+    Agent: require("./src/models/agents"),
+    AgentPerformance: require("./src/models/agent_performance"),
+    CustomerTicket: require("./src/models/customer_tickets"),
+    CustomerSurvey: require("./src/models/customer_surveys"),
+    KnowledgeBase: require("./src/models/knowledge_base"),
+    KnowledgeBaseRating: require("./src/models/knowledge_base_rating"),
+    AgentNotification: require("./src/models/agent_notifications"),
+    TicketCategory: require("./src/models/tickets_category"),
 };
 
 // Function to get models dynamically from a specific database connection

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payservedb",
-  "version": "8.1.6",
+  "version": "8.1.8",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/models/account.js

@@ -13,7 +13,6 @@ const accountSchema = new mongoose.Schema({
     },
     contractId: {
         type: mongoose.Schema.Types.ObjectId,
-        required: true,
         unique: true,
         default: null,
     },

package/src/models/agent_notifications.js

@@ -0,0 +1,53 @@
+const mongoose = require('mongoose');
+
+const notificationSchema = new mongoose.Schema({
+  user_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true,
+    index: true
+  },
+  type: {
+    type: String,
+    enum: ['ticket_escalated', 'agent_tagged', 'ticket_overdue', 'ticket_assigned', 'ticket_resolved'],
+    required: true
+  },
+  title: {
+    type: String,
+    required: true
+  },
+  message: {
+    type: String,
+    required: true
+  },
+  ticket_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'CustomerTicket'
+  },
+  ticket_number: {
+    type: String
+  },
+  link: {
+    type: String,
+    required: true
+  },
+  is_read: {
+    type: Boolean,
+    default: false
+  },
+  created_at: {
+    type: Date,
+    default: Date.now,
+    index: true
+  },
+  read_at: {
+    type: Date
+  },
+  metadata: {
+    type: mongoose.Schema.Types.Mixed
+  }
+});
+
+notificationSchema.index({ user_id: 1, is_read: 1, created_at: -1 });
+
+module.exports = mongoose.models.AgentNotification || mongoose.model('AgentNotification', notificationSchema);

package/src/models/agent_performance.js

@@ -0,0 +1,127 @@
+const mongoose = require('mongoose');
+
+const agentPerformanceSchema = new mongoose.Schema({
+  agent_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Agent',
+    required: true
+  },
+  period_start: {
+    type: Date,
+    required: true
+  },
+  period_end: {
+    type: Date,
+    required: true
+  },
+  period_type: {
+    type: String,
+    enum: ['daily', 'weekly', 'monthly', 'quarterly', 'yearly'],
+    default: 'daily'
+  },
+  tickets_handled: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  tickets_resolved: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  tickets_closed: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  avg_response_time: {
+    type: Number,
+    default: 0,
+    min: 0,
+    comment: 'Average response time in minutes'
+  },
+  avg_resolution_time: {
+    type: Number,
+    default: 0,
+    min: 0,
+    comment: 'Average resolution time in minutes'
+  },
+  avg_first_response_time: {
+    type: Number,
+    default: 0,
+    min: 0,
+    comment: 'Average first response time in minutes'
+  },
+  sla_compliance_rate: {
+    type: Number,
+    default: 0,
+    min: 0,
+    max: 100,
+    comment: 'SLA compliance percentage'
+  },
+  sla_breaches: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  average_rating: {
+    type: Number,
+    default: 0,
+    min: 0,
+    max: 5
+  },
+  total_ratings: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  positive_ratings: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  negative_ratings: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  customer_satisfaction_score: {
+    type: Number,
+    default: 0,
+    min: 0,
+    max: 100
+  },
+  total_handle_time: {
+    type: Number,
+    default: 0,
+    min: 0,
+    comment: 'Total handle time in minutes'
+  },
+  active_time: {
+    type: Number,
+    default: 0,
+    min: 0,
+    comment: 'Total active time in minutes'
+  },
+  idle_time: {
+    type: Number,
+    default: 0,
+    min: 0,
+    comment: 'Total idle time in minutes'
+  },
+  created_at: {
+    type: Date,
+    default: Date.now
+  },
+  updated_at: {
+    type: Date,
+    default: Date.now
+  }
+}, {
+  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }
+});
+
+agentPerformanceSchema.index({ agent_id: 1, period_start: 1, period_end: 1 });
+agentPerformanceSchema.index({ period_type: 1, period_start: -1 });
+
+module.exports = mongoose.model('AgentPerformance', agentPerformanceSchema);

package/src/models/agents.js

@@ -0,0 +1,109 @@
+const mongoose = require('mongoose');
+
+// For multitenancy, agents should be on the main database
+// Get or create main database connection
+const getMainConnection = () => {
+  // If there's already a main connection, use it
+  if (mongoose.connections.length > 0 && mongoose.connections[0].name) {
+    return mongoose.connections[0];
+  }
+  // Otherwise use the default connection
+  return mongoose.connection;
+};
+
+const agentSchema = new mongoose.Schema({
+  user_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  agent_id: {
+    type: String,
+    required: true,
+    unique: true,
+    trim: true
+  },
+  name: {
+    type: String,
+    trim: true
+  },
+  email: {
+    type: String,
+    trim: true
+  },
+  phone: {
+    type: String,
+    trim: true
+  },
+  id_number: {
+    type: String,
+    trim: true
+  },
+  role: {
+    type: String,
+    enum: ['call_center_agent', 'agent', 'team_leader', 'team_lead', 'technician', 'supervisor', 'manager'],
+    default: 'call_center_agent'
+  },
+  department: {
+    type: String,
+    trim: true
+  },
+  team_id: {
+    type: String,
+    trim: true
+  },
+  facility_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Facility'
+  },
+  status: {
+    type: String,
+    enum: ['active', 'inactive', 'on_break', 'offline'],
+    default: 'active'
+  },
+  is_available: {
+    type: Boolean,
+    default: false
+  },
+  skills: [{
+    type: String,
+    trim: true
+  }],
+  languages: [{
+    type: String,
+    trim: true
+  }],
+  max_concurrent_tickets: {
+    type: Number,
+    default: 5,
+    min: 1
+  },
+  current_ticket_count: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  created_at: {
+    type: Date,
+    default: Date.now
+  },
+  updated_at: {
+    type: Date,
+    default: Date.now
+  }
+}, {
+  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }
+});
+
+// Static method to generate agent ID
+agentSchema.statics.generateAgentId = function() {
+  const randomNum = Math.floor(100000 + Math.random() * 900000); // 6 digit number
+  return `PS25${randomNum}`;
+};
+
+agentSchema.index({ user_id: 1 });
+agentSchema.index({ agent_id: 1 });
+agentSchema.index({ status: 1, is_available: 1 });
+agentSchema.index({ team_id: 1 });
+
+module.exports = mongoose.model('Agent', agentSchema);

package/src/models/customer_surveys.js

@@ -0,0 +1,139 @@
+const mongoose = require('mongoose');
+
+const customerSurveySchema = new mongoose.Schema({
+  survey_id: {
+    type: String,
+    required: true,
+    unique: true,
+    trim: true
+  },
+  facility_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Facility',
+    required: true
+  },
+  customer_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Customer',
+    required: true
+  },
+  ticket_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'CustomerTicket'
+  },
+  agent_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Agent'
+  },
+  survey_type: {
+    type: String,
+    enum: ['post_ticket', 'periodic', 'nps', 'csat', 'ces'],
+    default: 'post_ticket'
+  },
+  status: {
+    type: String,
+    enum: ['pending', 'completed', 'expired'],
+    default: 'pending'
+  },
+  overall_satisfaction: {
+    type: Number,
+    min: 1,
+    max: 5
+  },
+  agent_performance_rating: {
+    type: Number,
+    min: 1,
+    max: 5
+  },
+  response_time_rating: {
+    type: Number,
+    min: 1,
+    max: 5
+  },
+  resolution_quality_rating: {
+    type: Number,
+    min: 1,
+    max: 5
+  },
+  communication_rating: {
+    type: Number,
+    min: 1,
+    max: 5
+  },
+  nps_score: {
+    type: Number,
+    min: 0,
+    max: 10,
+    comment: 'Net Promoter Score - How likely to recommend (0-10)'
+  },
+  csat_score: {
+    type: Number,
+    min: 1,
+    max: 5,
+    comment: 'Customer Satisfaction Score'
+  },
+  ces_score: {
+    type: Number,
+    min: 1,
+    max: 7,
+    comment: 'Customer Effort Score - How easy was it (1-7)'
+  },
+  comments: {
+    type: String,
+    trim: true
+  },
+  feedback_text: {
+    type: String,
+    trim: true
+  },
+  improvement_suggestions: {
+    type: String,
+    trim: true
+  },
+  questions: [{
+    question_id: String,
+    question_text: String,
+    answer_type: {
+      type: String,
+      enum: ['rating', 'text', 'multiple_choice', 'yes_no']
+    },
+    answer: mongoose.Schema.Types.Mixed
+  }],
+  sent_at: {
+    type: Date,
+    default: Date.now
+  },
+  completed_at: {
+    type: Date
+  },
+  expires_at: {
+    type: Date
+  },
+  reminder_sent: {
+    type: Boolean,
+    default: false
+  },
+  reminder_sent_at: {
+    type: Date
+  },
+  created_at: {
+    type: Date,
+    default: Date.now
+  },
+  updated_at: {
+    type: Date,
+    default: Date.now
+  }
+}, {
+  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }
+});
+
+customerSurveySchema.index({ survey_id: 1 });
+customerSurveySchema.index({ facility_id: 1, status: 1 });
+customerSurveySchema.index({ customer_id: 1, created_at: -1 });
+customerSurveySchema.index({ ticket_id: 1 });
+customerSurveySchema.index({ agent_id: 1, completed_at: -1 });
+customerSurveySchema.index({ survey_type: 1, status: 1 });
+customerSurveySchema.index({ expires_at: 1 });
+
+module.exports = mongoose.model('CustomerSurvey', customerSurveySchema);

package/src/models/customer_tickets.js

@@ -0,0 +1,154 @@
+const mongoose = require('mongoose');
+
+const customerTicketSchema = new mongoose.Schema({
+  ticket_number: {
+    type: String,
+    required: true,
+    unique: true,
+    trim: true
+  },
+  facility_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Facility',
+    required: true
+  },
+  customer_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Customer',
+    required: true
+  },
+  unit_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Unit'
+  },
+  assigned_agent_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  },
+  created_by_agent_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  title: {
+    type: String,
+    required: true,
+    trim: true,
+    maxlength: 255
+  },
+  description: {
+    type: String,
+    required: true
+  },
+  status: {
+    type: String,
+    enum: ['open', 'in_progress', 'pending_customer', 'escalated', 'resolved', 'closed', 'reopened'],
+    default: 'open'
+  },
+  category_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'TicketCategory',
+    required: true
+  },
+  source: {
+    type: String,
+    enum: ['portal', 'email', 'phone', 'chat', 'in_person', 'mobile_app'],
+    default: 'portal'
+  },
+  sla_status: {
+    type: String,
+    enum: ['within_sla', 'approaching_breach', 'breached'],
+    default: 'within_sla'
+  },
+  sla_due_date: {
+    type: Date
+  },
+  first_response_time: {
+    type: Number,
+    comment: 'Time to first response in minutes'
+  },
+  resolution_time: {
+    type: Number,
+    comment: 'Time to resolution in minutes'
+  },
+  customer_rating: {
+    type: Number,
+    min: 1,
+    max: 5
+  },
+  customer_feedback: {
+    type: String,
+    trim: true
+  },
+  tags: [{
+    type: String,
+    trim: true
+  }],
+  attachments: [{
+    filename: String,
+    file_path: String,
+    file_size: Number,
+    mime_type: String,
+    uploaded_at: {
+      type: Date,
+      default: Date.now
+    }
+  }],
+  interactions: [{
+    agent_id: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User'
+    },
+    message: String,
+    is_internal_note: {
+      type: Boolean,
+      default: false
+    },
+    tagged_agents: [{
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User'
+    }],
+    created_at: {
+      type: Date,
+      default: Date.now
+    }
+  }],
+  reopened_count: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  last_reopened_at: {
+    type: Date
+  },
+  resolved_at: {
+    type: Date
+  },
+  resolved_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  },
+  closed_at: {
+    type: Date
+  },
+  created_at: {
+    type: Date,
+    default: Date.now
+  },
+  updated_at: {
+    type: Date,
+    default: Date.now
+  }
+}, {
+  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }
+});
+
+customerTicketSchema.index({ ticket_number: 1 });
+customerTicketSchema.index({ facility_id: 1, status: 1 });
+customerTicketSchema.index({ customer_id: 1, created_at: -1 });
+customerTicketSchema.index({ assigned_agent_id: 1, status: 1 });
+customerTicketSchema.index({ status: 1, sla_status: 1 });
+customerTicketSchema.index({ category_id: 1, created_at: -1 });
+customerTicketSchema.index({ sla_status: 1, sla_due_date: 1 });
+
+module.exports = mongoose.model('CustomerTicket', customerTicketSchema);

package/src/models/knowledge_base.js

@@ -0,0 +1,109 @@
+const mongoose = require('mongoose');
+
+const knowledgeBaseSchema = new mongoose.Schema({
+  title: {
+    type: String,
+    required: true,
+    trim: true,
+    maxlength: 255
+  },
+  content: {
+    type: String,
+    required: true
+  },
+  summary: {
+    type: String,
+    trim: true,
+    maxlength: 500
+  },
+  category_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'TicketCategory',
+    required: true
+  },
+  tags: [{
+    type: String,
+    trim: true
+  }],
+  status: {
+    type: String,
+    enum: ['draft', 'published', 'archived'],
+    default: 'draft'
+  },
+  visibility: {
+    type: String,
+    enum: ['internal', 'public'],
+    default: 'internal'
+  },
+  is_featured: {
+    type: Boolean,
+    default: false
+  },
+  author_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  created_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  updated_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  },
+  views_count: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  helpful_count: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  not_helpful_count: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+  attachments: [{
+    filename: String,
+    file_path: String,
+    file_size: Number,
+    mime_type: String,
+    uploaded_at: {
+      type: Date,
+      default: Date.now
+    }
+  }],
+  related_articles: [{
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'KnowledgeBase'
+  }],
+  created_at: {
+    type: Date,
+    default: Date.now
+  },
+  updated_at: {
+    type: Date,
+    default: Date.now
+  },
+  published_at: {
+    type: Date
+  },
+  archived_at: {
+    type: Date
+  }
+}, {
+  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }
+});
+
+knowledgeBaseSchema.index({ title: 'text', content: 'text', summary: 'text', tags: 'text' });
+knowledgeBaseSchema.index({ category_id: 1, status: 1 });
+knowledgeBaseSchema.index({ status: 1, is_featured: 1 });
+knowledgeBaseSchema.index({ author_id: 1, created_at: -1 });
+knowledgeBaseSchema.index({ views_count: -1 });
+
+module.exports = mongoose.model('KnowledgeBase', knowledgeBaseSchema);

package/src/models/knowledge_base_rating.js

@@ -0,0 +1,44 @@
+const mongoose = require('mongoose');
+
+const knowledgeBaseRatingSchema = new mongoose.Schema({
+  article_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'KnowledgeBase',
+    required: true
+  },
+  agent_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  helpful: {
+    type: Boolean,
+    required: true
+  },
+  feedback: {
+    type: String,
+    trim: true,
+    maxlength: 1000
+  },
+  ticket_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'CustomerTicket',
+    comment: 'Optional reference to ticket where this article was used'
+  },
+  created_at: {
+    type: Date,
+    default: Date.now
+  },
+  updated_at: {
+    type: Date,
+    default: Date.now
+  }
+}, {
+  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }
+});
+
+knowledgeBaseRatingSchema.index({ article_id: 1, agent_id: 1 }, { unique: true });
+knowledgeBaseRatingSchema.index({ article_id: 1, helpful: 1 });
+knowledgeBaseRatingSchema.index({ agent_id: 1, created_at: -1 });
+
+module.exports = mongoose.model('KnowledgeBaseRating', knowledgeBaseRatingSchema);

package/src/models/tickets_category.js

@@ -0,0 +1,61 @@
+const mongoose = require('mongoose');
+
+const ticketCategorySchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: true,
+    trim: true,
+    unique: true,
+    maxlength: 100
+  },
+  description: {
+    type: String,
+    trim: true,
+    maxlength: 500
+  },
+  priority: {
+    type: String,
+    required: true,
+    enum: ['low', 'medium', 'high', 'urgent', 'critical'],
+    default: 'medium'
+  },
+  sla_hours: {
+    type: Number,
+    required: true,
+    min: 1
+  },
+  color: {
+    type: String,
+    default: '#3b82f6',
+    trim: true
+  },
+  is_active: {
+    type: Boolean,
+    default: true
+  },
+  created_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true
+  },
+  updated_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  },
+  created_at: {
+    type: Date,
+    default: Date.now
+  },
+  updated_at: {
+    type: Date,
+    default: Date.now
+  }
+}, {
+  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }
+});
+
+ticketCategorySchema.index({ name: 1 });
+ticketCategorySchema.index({ priority: 1 });
+ticketCategorySchema.index({ is_active: 1 });
+
+module.exports = mongoose.model('TicketCategory', ticketCategorySchema);

package/src/models/user.js

@@ -25,7 +25,7 @@ const userSchema = new mongoose.Schema({
    type: {
         type: String,
         required: [true, 'Type is required'],
-        enum: ['Company', 'Project Manager', 'Universal', 'Core', 'Resident', 'Landlord', 'Supplier'],
+        enum: ['Company', 'Project Manager', 'Universal', 'Core', 'Resident', 'Landlord', 'Supplier', 'Customer_Support'],
     },
     department: {
         type: mongoose.Schema.Types.ObjectId,