escalated 0.4.0

data/app/models/escalated/canned_response.rb

@@ -0,0 +1,45 @@
+module Escalated
+  class CannedResponse < ApplicationRecord
+    self.table_name = Escalated.table_name("canned_responses")
+
+    belongs_to :creator,
+               class_name: Escalated.configuration.user_class,
+               foreign_key: :created_by
+
+    validates :title, presence: true
+    validates :body, presence: true
+    validates :shortcode, uniqueness: { case_sensitive: false }, allow_nil: true
+
+    scope :shared, -> { where(is_shared: true) }
+    scope :personal, -> { where(is_shared: false) }
+    scope :for_user, ->(user_id) { where(is_shared: true).or(where(created_by: user_id)) }
+    scope :by_category, ->(category) { where(category: category) }
+    scope :search, ->(term) {
+      where("title LIKE :term OR body LIKE :term OR shortcode LIKE :term",
+            term: "%#{sanitize_sql_like(term)}%")
+    }
+    scope :ordered, -> { order(:title) }
+
+    def shared?
+      is_shared
+    end
+
+    def personal?
+      !is_shared
+    end
+
+    # Render body with variable interpolation
+    # Variables: {{ticket.subject}}, {{ticket.requester_name}}, {{agent.name}}
+    def render(variables = {})
+      rendered = body.dup
+
+      variables.each do |key, value|
+        rendered.gsub!("{{#{key}}}", value.to_s)
+      end
+
+      # Remove any unmatched variables
+      rendered.gsub!(/\{\{[^}]+\}\}/, "")
+      rendered
+    end
+  end
+end

data/app/models/escalated/department.rb

@@ -0,0 +1,43 @@
+module Escalated
+  class Department < ApplicationRecord
+    self.table_name = Escalated.table_name("departments")
+
+    has_many :tickets, class_name: "Escalated::Ticket", dependent: :nullify
+    has_and_belongs_to_many :agents,
+                            join_table: Escalated.table_name("department_agents"),
+                            class_name: Escalated.configuration.user_class,
+                            foreign_key: :department_id,
+                            association_foreign_key: :agent_id
+
+    belongs_to :default_sla_policy,
+               class_name: "Escalated::SlaPolicy",
+               optional: true
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+    validates :slug, presence: true, uniqueness: true
+    validates :email, format: { with: URI::MailTo::EMAIL_REGEXP }, allow_nil: true
+
+    before_validation :generate_slug
+
+    scope :active, -> { where(is_active: true) }
+    scope :ordered, -> { order(:name) }
+
+    def active?
+      is_active
+    end
+
+    def open_ticket_count
+      tickets.by_open.count
+    end
+
+    def agent_count
+      agents.count
+    end
+
+    private
+
+    def generate_slug
+      self.slug = name&.parameterize if slug.blank?
+    end
+  end
+end

data/app/models/escalated/escalated_setting.rb

@@ -0,0 +1,43 @@
+module Escalated
+  class EscalatedSetting < ApplicationRecord
+    self.table_name = Escalated.table_name("settings")
+
+    validates :key, presence: true, uniqueness: true
+
+    # Class-level accessors
+
+    def self.get(key, default = nil)
+      record = find_by(key: key)
+      record ? record.value : default
+    end
+
+    def self.set(key, value)
+      record = find_or_initialize_by(key: key)
+      record.value = value.nil? ? nil : value.to_s
+      record.save!
+      record
+    end
+
+    def self.get_bool(key, default: false)
+      val = get(key)
+      return default if val.nil?
+
+      %w[1 true yes].include?(val.to_s.downcase)
+    end
+
+    def self.get_int(key, default: 0)
+      val = get(key)
+      return default if val.nil?
+
+      Integer(val, exception: false) || default
+    end
+
+    def self.guest_tickets_enabled?
+      get_bool("guest_tickets_enabled", default: true)
+    end
+
+    def self.all_as_hash
+      all.each_with_object({}) { |s, hash| hash[s.key] = s.value }
+    end
+  end
+end

data/app/models/escalated/escalation_rule.rb

@@ -0,0 +1,96 @@
+module Escalated
+  class EscalationRule < ApplicationRecord
+    self.table_name = Escalated.table_name("escalation_rules")
+
+    validates :name, presence: true
+    validates :conditions, presence: true
+    validates :actions, presence: true
+
+    scope :active, -> { where(is_active: true) }
+    scope :ordered, -> { order(priority: :asc, created_at: :asc) }
+
+    # conditions is a JSON column:
+    # {
+    #   "status": ["open", "in_progress"],
+    #   "priority": ["high", "urgent", "critical"],
+    #   "sla_breached": true,
+    #   "unassigned_for_minutes": 30,
+    #   "no_response_for_minutes": 60,
+    #   "department_ids": [1, 2]
+    # }
+    #
+    # actions is a JSON column:
+    # {
+    #   "change_priority": "critical",
+    #   "change_status": "escalated",
+    #   "assign_to_agent_id": 5,
+    #   "assign_to_department_id": 2,
+    #   "send_notification": true,
+    #   "notification_recipients": ["admin@example.com"],
+    #   "add_tags": ["escalated", "urgent"],
+    #   "add_internal_note": "Auto-escalated due to SLA breach"
+    # }
+
+    def matches?(ticket)
+      return false unless is_active
+
+      check_status(ticket) &&
+        check_priority(ticket) &&
+        check_sla_breach(ticket) &&
+        check_unassigned_duration(ticket) &&
+        check_no_response_duration(ticket) &&
+        check_department(ticket)
+    end
+
+    def active?
+      is_active
+    end
+
+    private
+
+    def check_status(ticket)
+      return true unless conditions["status"].present?
+
+      Array(conditions["status"]).include?(ticket.status)
+    end
+
+    def check_priority(ticket)
+      return true unless conditions["priority"].present?
+
+      Array(conditions["priority"]).include?(ticket.priority)
+    end
+
+    def check_sla_breach(ticket)
+      return true unless conditions["sla_breached"]
+
+      ticket.sla_first_response_breached? || ticket.sla_resolution_breached?
+    end
+
+    def check_unassigned_duration(ticket)
+      return true unless conditions["unassigned_for_minutes"].present?
+      return false if ticket.assigned_to.present?
+
+      minutes = conditions["unassigned_for_minutes"].to_i
+      ticket.created_at < minutes.minutes.ago
+    end
+
+    def check_no_response_duration(ticket)
+      return true unless conditions["no_response_for_minutes"].present?
+
+      minutes = conditions["no_response_for_minutes"].to_i
+      last_reply = ticket.replies.public_replies.chronological.last
+
+      if last_reply
+        last_reply.created_at < minutes.minutes.ago
+      else
+        ticket.created_at < minutes.minutes.ago
+      end
+    end
+
+    def check_department(ticket)
+      return true unless conditions["department_ids"].present?
+
+      Array(conditions["department_ids"]).include?(ticket.department_id)
+    end
+  end
+end

data/app/models/escalated/inbound_email.rb

@@ -0,0 +1,60 @@
+module Escalated
+  class InboundEmail < ApplicationRecord
+    self.table_name = Escalated.table_name("inbound_emails")
+
+    belongs_to :ticket, class_name: "Escalated::Ticket", optional: true
+    belongs_to :reply, class_name: "Escalated::Reply", optional: true
+
+    enum :status, {
+      pending: "pending",
+      processed: "processed",
+      failed: "failed",
+      spam: "spam"
+    }
+
+    validates :from_email, presence: true
+    validates :to_email, presence: true
+    validates :subject, presence: true
+    validates :adapter, presence: true
+    validates :message_id, uniqueness: true, allow_nil: true
+
+    scope :unprocessed, -> { where(status: :pending) }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def mark_processed!(ticket:, reply: nil)
+      update!(
+        status: :processed,
+        ticket: ticket,
+        reply: reply,
+        processed_at: Time.current
+      )
+    end
+
+    def mark_failed!(error)
+      update!(
+        status: :failed,
+        error_message: error.to_s,
+        processed_at: Time.current
+      )
+    end
+
+    def mark_spam!
+      update!(
+        status: :spam,
+        processed_at: Time.current
+      )
+    end
+
+    def processed?
+      status == "processed"
+    end
+
+    def duplicate?
+      return false if message_id.blank?
+
+      self.class.where(message_id: message_id)
+        .where.not(id: id)
+        .exists?
+    end
+  end
+end

data/app/models/escalated/macro.rb

@@ -0,0 +1,18 @@
+module Escalated
+  class Macro < ApplicationRecord
+    self.table_name = Escalated.table_name("macros")
+
+    belongs_to :creator,
+               class_name: Escalated.configuration.user_class,
+               foreign_key: :created_by,
+               optional: true
+
+    validates :name, presence: true
+    validates :actions, presence: true
+
+    scope :shared, -> { where(is_shared: true) }
+    scope :personal, -> { where(is_shared: false) }
+    scope :for_agent, ->(user_id) { where(is_shared: true).or(where(created_by: user_id)) }
+    scope :ordered, -> { order(:order, :name) }
+  end
+end

data/app/models/escalated/reply.rb

@@ -0,0 +1,42 @@
+module Escalated
+  class Reply < ApplicationRecord
+    self.table_name = Escalated.table_name("replies")
+
+    belongs_to :ticket, class_name: "Escalated::Ticket"
+    belongs_to :author, polymorphic: true
+    has_many :attachments, as: :attachable, dependent: :destroy, class_name: "Escalated::Attachment"
+
+    validates :body, presence: true
+
+    scope :public_replies, -> { where(is_internal: false) }
+    scope :internal_notes, -> { where(is_internal: true) }
+    scope :system_messages, -> { where(is_system: true) }
+    scope :pinned, -> { where(is_pinned: true) }
+    scope :chronological, -> { order(created_at: :asc) }
+    scope :reverse_chronological, -> { order(created_at: :desc) }
+
+    after_create :touch_ticket
+
+    def public?
+      !is_internal
+    end
+
+    def internal?
+      is_internal
+    end
+
+    def system?
+      is_system
+    end
+
+    def pinned?
+      is_pinned
+    end
+
+    private
+
+    def touch_ticket
+      ticket.touch
+    end
+  end
+end

data/app/models/escalated/satisfaction_rating.rb

@@ -0,0 +1,21 @@
+module Escalated
+  class SatisfactionRating < ApplicationRecord
+    self.table_name = Escalated.table_name("satisfaction_ratings")
+
+    belongs_to :ticket, class_name: "Escalated::Ticket"
+    belongs_to :rated_by, polymorphic: true, optional: true
+
+    validates :rating, presence: true,
+                       numericality: { only_integer: true, greater_than_or_equal_to: 1, less_than_or_equal_to: 5 }
+    validates :comment, length: { maximum: 2000 }, allow_nil: true
+    validates :ticket_id, uniqueness: true
+
+    before_create :set_created_at
+
+    private
+
+    def set_created_at
+      self.created_at ||= Time.current
+    end
+  end
+end

data/app/models/escalated/sla_policy.rb

@@ -0,0 +1,54 @@
+module Escalated
+  class SlaPolicy < ApplicationRecord
+    self.table_name = Escalated.table_name("sla_policies")
+
+    has_many :tickets, class_name: "Escalated::Ticket", dependent: :nullify
+    has_many :departments,
+             class_name: "Escalated::Department",
+             foreign_key: :default_sla_policy_id,
+             dependent: :nullify
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+    validates :first_response_hours, presence: true
+    validates :resolution_hours, presence: true
+
+    scope :active, -> { where(is_active: true) }
+    scope :default_policy, -> { where(is_default: true) }
+    scope :ordered, -> { order(:name) }
+
+    # first_response_hours and resolution_hours are JSON columns
+    # stored as: { "low": 24, "medium": 8, "high": 4, "urgent": 2, "critical": 1 }
+
+    def first_response_hours_for(priority)
+      return nil unless first_response_hours.is_a?(Hash)
+
+      hours = first_response_hours[priority.to_s]
+      hours&.to_f
+    end
+
+    def resolution_hours_for(priority)
+      return nil unless resolution_hours.is_a?(Hash)
+
+      hours = resolution_hours[priority.to_s]
+      hours&.to_f
+    end
+
+    def active?
+      is_active
+    end
+
+    def default?
+      is_default
+    end
+
+    def priority_targets
+      Escalated::Ticket.priorities.keys.map do |priority|
+        {
+          priority: priority,
+          first_response: first_response_hours_for(priority),
+          resolution: resolution_hours_for(priority)
+        }
+      end
+    end
+  end
+end

data/app/models/escalated/tag.rb

@@ -0,0 +1,28 @@
+module Escalated
+  class Tag < ApplicationRecord
+    self.table_name = Escalated.table_name("tags")
+
+    has_and_belongs_to_many :tickets,
+                            join_table: Escalated.table_name("ticket_tags"),
+                            class_name: "Escalated::Ticket"
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+    validates :slug, presence: true, uniqueness: true
+    validates :color, format: { with: /\A#[0-9a-fA-F]{6}\z/, message: "must be a valid hex color" }, allow_nil: true
+
+    before_validation :generate_slug
+
+    scope :ordered, -> { order(:name) }
+    scope :by_name, ->(name) { where("name LIKE ?", "%#{sanitize_sql_like(name)}%") }
+
+    def ticket_count
+      tickets.count
+    end
+
+    private
+
+    def generate_slug
+      self.slug = name&.parameterize if slug.blank?
+    end
+  end
+end

data/app/models/escalated/ticket.rb

@@ -0,0 +1,166 @@
+module Escalated
+  class Ticket < ApplicationRecord
+    self.table_name = Escalated.table_name("tickets")
+
+    belongs_to :requester, polymorphic: true, optional: true
+    belongs_to :assignee,
+               class_name: Escalated.configuration.user_class,
+               optional: true,
+               foreign_key: :assigned_to
+    belongs_to :department, optional: true
+    belongs_to :sla_policy, optional: true
+    has_many :replies, dependent: :destroy
+    has_many :attachments, as: :attachable, dependent: :destroy
+    has_many :activities, class_name: "Escalated::TicketActivity", dependent: :destroy
+    has_and_belongs_to_many :tags,
+                            join_table: Escalated.table_name("ticket_tags"),
+                            class_name: "Escalated::Tag"
+    has_and_belongs_to_many :followers,
+                            join_table: Escalated.table_name("ticket_followers"),
+                            class_name: Escalated.configuration.user_class,
+                            foreign_key: :ticket_id,
+                            association_foreign_key: :user_id
+    has_one :satisfaction_rating, class_name: "Escalated::SatisfactionRating", dependent: :destroy
+    has_many :pinned_notes, -> { where(is_internal: true, is_pinned: true) },
+             class_name: "Escalated::Reply"
+
+    enum :status, {
+      open: 0,
+      in_progress: 1,
+      waiting_on_customer: 2,
+      waiting_on_agent: 3,
+      escalated: 4,
+      resolved: 5,
+      closed: 6,
+      reopened: 7
+    }
+
+    enum :priority, {
+      low: 0,
+      medium: 1,
+      high: 2,
+      urgent: 3,
+      critical: 4
+    }
+
+    validates :subject, presence: true, length: { maximum: 255 }
+    validates :description, presence: true
+    validates :reference, uniqueness: true, allow_nil: true
+
+    before_create :set_reference
+
+    # Scopes
+    scope :by_open, -> { where(status: [:open, :in_progress, :waiting_on_customer, :waiting_on_agent, :escalated, :reopened]) }
+    scope :unassigned, -> { where(assigned_to: nil) }
+    scope :assigned_to, ->(agent_id) { where(assigned_to: agent_id) }
+    scope :breached_sla, -> {
+      where(sla_breached: true)
+        .or(where("sla_first_response_due_at < ? AND first_response_at IS NULL", Time.current))
+        .or(where("sla_resolution_due_at < ? AND resolved_at IS NULL AND status NOT IN (?)", Time.current, [5, 6]))
+    }
+    scope :search, ->(term) {
+      where("#{table_name}.subject LIKE :term OR #{table_name}.description LIKE :term OR #{table_name}.reference LIKE :term",
+            term: "%#{sanitize_sql_like(term)}%")
+    }
+    scope :by_priority, ->(priority) { where(priority: priority) }
+    scope :by_department, ->(department_id) { where(department_id: department_id) }
+    scope :created_between, ->(from, to) { where(created_at: from..to) }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def self.generate_reference
+      prefix = Escalated::EscalatedSetting.get("ticket_reference_prefix", "ESC")
+      timestamp = Time.current.strftime("%y%m")
+      sequence = SecureRandom.alphanumeric(6).upcase
+      "#{prefix}-#{timestamp}-#{sequence}"
+    end
+
+    def open?
+      %w[open in_progress waiting_on_customer waiting_on_agent escalated reopened].include?(status)
+    end
+
+    def sla_first_response_breached?
+      return false unless sla_first_response_due_at
+      return false if first_response_at
+
+      Time.current > sla_first_response_due_at
+    end
+
+    def sla_resolution_breached?
+      return false unless sla_resolution_due_at
+      return false if resolved_at
+
+      Time.current > sla_resolution_due_at
+    end
+
+    def sla_first_response_warning?
+      return false unless sla_first_response_due_at
+      return false if first_response_at
+
+      warning_threshold = sla_first_response_due_at - 1.hour
+      Time.current > warning_threshold && Time.current <= sla_first_response_due_at
+    end
+
+    def sla_resolution_warning?
+      return false unless sla_resolution_due_at
+      return false if resolved_at
+
+      warning_threshold = sla_resolution_due_at - 2.hours
+      Time.current > warning_threshold && Time.current <= sla_resolution_due_at
+    end
+
+    def time_to_first_response
+      return nil unless first_response_at
+
+      first_response_at - created_at
+    end
+
+    def time_to_resolution
+      return nil unless resolved_at
+
+      resolved_at - created_at
+    end
+
+    # Guest ticket helpers
+
+    def guest?
+      requester_type.nil? && guest_token.present?
+    end
+
+    def requester_name
+      return guest_name || "Guest" if guest?
+
+      if requester
+        requester.respond_to?(:name) ? requester.name : requester.to_s
+      else
+        "Unknown"
+      end
+    end
+
+    def requester_email
+      return guest_email || "" if guest?
+
+      requester&.respond_to?(:email) ? requester.email : ""
+    end
+
+    # Follower helpers
+
+    def followed_by?(user_id)
+      followers.where(id: user_id).exists?
+    end
+
+    def follow(user_id)
+      user = Escalated.configuration.user_model.find(user_id)
+      followers << user unless followed_by?(user_id)
+    end
+
+    def unfollow(user_id)
+      followers.delete(Escalated.configuration.user_model.find(user_id))
+    end
+
+    private
+
+    def set_reference
+      self.reference ||= self.class.generate_reference
+    end
+  end
+end

data/app/models/escalated/ticket_activity.rb

@@ -0,0 +1,60 @@
+module Escalated
+  class TicketActivity < ApplicationRecord
+    self.table_name = Escalated.table_name("ticket_activities")
+
+    belongs_to :ticket, class_name: "Escalated::Ticket"
+    belongs_to :causer, polymorphic: true, optional: true
+
+    validates :action, presence: true
+
+    scope :chronological, -> { order(created_at: :asc) }
+    scope :reverse_chronological, -> { order(created_at: :desc) }
+    scope :by_action, ->(action) { where(action: action) }
+    scope :by_causer, ->(causer) { where(causer: causer) }
+    scope :recent, ->(limit = 20) { reverse_chronological.limit(limit) }
+
+    # Known actions:
+    # ticket_created, ticket_updated, status_changed, ticket_assigned,
+    # ticket_unassigned, reply_added, internal_note_added, tags_added,
+    # tags_removed, department_changed, priority_changed, sla_breached,
+    # ticket_escalated, ticket_merged
+
+    def description
+      case action
+      when "ticket_created"
+        "Ticket created"
+      when "ticket_updated"
+        changes = details&.keys&.reject { |k| k == "note" }&.join(", ")
+        "Ticket updated: #{changes}"
+      when "status_changed"
+        "Status changed from #{details['from']} to #{details['to']}"
+      when "ticket_assigned"
+        "Ticket assigned"
+      when "ticket_unassigned"
+        "Ticket unassigned"
+      when "reply_added"
+        "Reply added"
+      when "internal_note_added"
+        "Internal note added"
+      when "tags_added"
+        "Tags added: #{Array(details['tag_names']).join(', ')}"
+      when "tags_removed"
+        "Tags removed: #{Array(details['tag_names']).join(', ')}"
+      when "department_changed"
+        "Department changed"
+      when "priority_changed"
+        "Priority changed from #{details['from']} to #{details['to']}"
+      when "sla_breached"
+        "SLA breached: #{details['breach_type']}"
+      when "ticket_escalated"
+        "Ticket escalated"
+      else
+        action.humanize
+      end
+    end
+
+    def system_activity?
+      causer.nil?
+    end
+  end
+end