escalated 0.4.0

data/app/controllers/escalated/guest/tickets_controller.rb

@@ -0,0 +1,231 @@
+module Escalated
+  module Guest
+    class TicketsController < ActionController::Base
+      protect_from_forgery with: :exception
+
+      before_action :ensure_guest_tickets_enabled
+      before_action :set_ticket_by_token, only: [:show, :reply, :rate]
+      before_action :set_inertia_shared_data
+
+      def create
+        render inertia: "Escalated/Guest/Create", props: {
+          departments: Escalated::Department.active.ordered.map { |d|
+            { id: d.id, name: d.name }
+          },
+          priorities: Escalated::Ticket.priorities.keys,
+          default_priority: Escalated.configuration.default_priority.to_s
+        }
+      end
+
+      def store
+        errors = validate_guest_params
+        if errors.any?
+          render inertia: "Escalated/Guest/Create", props: {
+            errors: errors,
+            old: guest_ticket_params.to_h,
+            departments: Escalated::Department.active.ordered.map { |d|
+              { id: d.id, name: d.name }
+            },
+            priorities: Escalated::Ticket.priorities.keys,
+            default_priority: Escalated.configuration.default_priority.to_s
+          }
+          return
+        end
+
+        guest_token = SecureRandom.hex(32) # 64-character hex string
+
+        ticket = Escalated::Ticket.create!(
+          requester: nil,
+          guest_name: guest_ticket_params[:name],
+          guest_email: guest_ticket_params[:email],
+          guest_token: guest_token,
+          subject: guest_ticket_params[:subject],
+          description: guest_ticket_params[:description],
+          priority: guest_ticket_params[:priority] || Escalated.configuration.default_priority,
+          department_id: guest_ticket_params[:department_id].presence
+        )
+
+        if guest_ticket_params[:attachments].present?
+          Services::AttachmentService.attach(ticket, guest_ticket_params[:attachments])
+        end
+
+        redirect_to "#{escalated_mount_path}/guest/#{guest_token}", notice: "Ticket created successfully."
+      rescue Services::AttachmentService::TooManyAttachmentsError,
+             Services::AttachmentService::FileTooLargeError,
+             Services::AttachmentService::InvalidFileTypeError => e
+        redirect_back fallback_location: "#{escalated_mount_path}/guest/create", alert: e.message
+      end
+
+      def show
+        replies = @ticket.replies
+          .where(is_internal: false, is_system: false)
+          .order(created_at: :asc)
+          .includes(:author, :attachments)
+
+        render inertia: "Escalated/Guest/Show", props: {
+          ticket: guest_ticket_json(@ticket),
+          replies: replies.map { |r| guest_reply_json(r) },
+          token: params[:token],
+          can_reply: @ticket.open?
+        }
+      end
+
+      def reply
+        unless @ticket.open?
+          redirect_to "#{escalated_mount_path}/guest/#{params[:token]}", alert: "This ticket is closed."
+          return
+        end
+
+        body = params[:body].to_s.strip
+        if body.blank?
+          redirect_to "#{escalated_mount_path}/guest/#{params[:token]}"
+          return
+        end
+
+        reply = Escalated::Reply.create!(
+          ticket: @ticket,
+          author: nil,
+          body: body,
+          is_internal: false,
+          is_system: false
+        )
+
+        # Update ticket status if waiting on customer
+        if @ticket.waiting_on_customer?
+          @ticket.update!(status: :open)
+        end
+
+        if params[:attachments].present?
+          Services::AttachmentService.attach(reply, params[:attachments])
+        end
+
+        redirect_to "#{escalated_mount_path}/guest/#{params[:token]}", notice: "Reply sent."
+      rescue Services::AttachmentService::TooManyAttachmentsError,
+             Services::AttachmentService::FileTooLargeError,
+             Services::AttachmentService::InvalidFileTypeError => e
+        redirect_to "#{escalated_mount_path}/guest/#{params[:token]}", alert: e.message
+      end
+
+      def rate
+        unless %w[resolved closed].include?(@ticket.status)
+          redirect_to "#{escalated_mount_path}/guest/#{params[:token]}",
+                      alert: "You can only rate resolved or closed tickets."
+          return
+        end
+
+        if @ticket.satisfaction_rating.present?
+          redirect_to "#{escalated_mount_path}/guest/#{params[:token]}",
+                      alert: "This ticket has already been rated."
+          return
+        end
+
+        rating = Escalated::SatisfactionRating.new(
+          ticket: @ticket,
+          rating: params[:rating].to_i,
+          comment: params[:comment]
+        )
+
+        if rating.save
+          redirect_to "#{escalated_mount_path}/guest/#{params[:token]}",
+                      notice: "Thank you for your feedback!"
+        else
+          redirect_to "#{escalated_mount_path}/guest/#{params[:token]}",
+                      alert: rating.errors.full_messages.join(", ")
+        end
+      end
+
+      private
+
+      def ensure_guest_tickets_enabled
+        unless Escalated::EscalatedSetting.guest_tickets_enabled?
+          render plain: "Guest tickets are not enabled.", status: :not_found
+        end
+      end
+
+      def set_ticket_by_token
+        @ticket = Escalated::Ticket.find_by!(guest_token: params[:token])
+      rescue ActiveRecord::RecordNotFound
+        render plain: "Ticket not found.", status: :not_found
+      end
+
+      def set_inertia_shared_data
+        inertia_share(
+          escalated: {
+            route_prefix: Escalated.configuration.route_prefix,
+            guest_tickets_enabled: Escalated::EscalatedSetting.guest_tickets_enabled?
+          },
+          flash: {
+            success: flash[:success],
+            error: flash[:error],
+            notice: flash[:notice],
+            alert: flash[:alert]
+          }
+        )
+      end
+
+      def guest_ticket_params
+        params.permit(:name, :email, :subject, :description, :priority, :department_id, attachments: [])
+      end
+
+      def validate_guest_params
+        errors = {}
+        errors[:name] = "Name is required." if guest_ticket_params[:name].blank?
+        errors[:email] = "Email is required." if guest_ticket_params[:email].blank?
+        errors[:subject] = "Subject is required." if guest_ticket_params[:subject].blank?
+        errors[:description] = "Description is required." if guest_ticket_params[:description].blank?
+        errors
+      end
+
+      def escalated_mount_path
+        "/#{Escalated.configuration.route_prefix}"
+      end
+
+      def guest_ticket_json(ticket)
+        {
+          id: ticket.id,
+          reference: ticket.reference,
+          subject: ticket.subject,
+          description: ticket.description,
+          status: ticket.status,
+          priority: ticket.priority,
+          is_guest: ticket.guest?,
+          guest_name: ticket.guest_name,
+          guest_email: ticket.guest_email,
+          requester_name: ticket.requester_name,
+          requester_email: ticket.requester_email,
+          department: ticket.department ? { id: ticket.department.id, name: ticket.department.name } : nil,
+          created_at: ticket.created_at&.iso8601,
+          updated_at: ticket.updated_at&.iso8601,
+          satisfaction_rating: ticket.satisfaction_rating ? {
+            id: ticket.satisfaction_rating.id,
+            rating: ticket.satisfaction_rating.rating,
+            comment: ticket.satisfaction_rating.comment,
+            created_at: ticket.satisfaction_rating.created_at&.iso8601
+          } : nil
+        }
+      end
+
+      def guest_reply_json(reply)
+        author_name = if reply.author
+                        reply.author.respond_to?(:name) ? reply.author.name : reply.author&.email
+                      else
+                        @ticket.guest_name || "Guest"
+                      end
+
+        {
+          id: reply.id,
+          body: reply.body,
+          author: {
+            name: author_name,
+            is_agent: reply.author.respond_to?(:escalated_agent?) ? reply.author.escalated_agent? : false
+          },
+          attachments: reply.attachments.map { |a|
+            { id: a.id, filename: a.filename, size: a.human_size }
+          },
+          created_at: reply.created_at&.iso8601,
+          is_system: reply.is_system
+        }
+      end
+    end
+  end
+end

data/app/controllers/escalated/inbound_controller.rb

@@ -0,0 +1,79 @@
+module Escalated
+  class InboundController < ActionController::Base
+    skip_before_action :verify_authenticity_token
+
+    before_action :ensure_inbound_enabled
+
+    def webhook
+      adapter = resolve_adapter(params[:adapter])
+
+      unless adapter
+        render json: { error: "Unknown adapter: #{params[:adapter]}" }, status: :bad_request
+        return
+      end
+
+      # Verify request authenticity (signature, token, etc.)
+      unless adapter.verify_request(request)
+        Rails.logger.warn(
+          "[Escalated::InboundController] Webhook verification failed for adapter: #{params[:adapter]}"
+        )
+        render json: { error: "Verification failed" }, status: :unauthorized
+        return
+      end
+
+      # Parse the request into an InboundMessage
+      message = adapter.parse_request(request)
+
+      # SES subscription confirmations return nil — acknowledge silently
+      unless message
+        render json: { status: "ok" }, status: :ok
+        return
+      end
+
+      # Process the inbound email
+      inbound_email = Services::InboundEmailService.process(
+        message,
+        adapter_name: adapter.adapter_name
+      )
+
+      if inbound_email&.processed?
+        render json: {
+          status: "processed",
+          ticket_id: inbound_email.ticket_id,
+          reply_id: inbound_email.reply_id
+        }, status: :ok
+      elsif inbound_email&.failed?
+        render json: {
+          status: "failed",
+          error: inbound_email.error_message
+        }, status: :unprocessable_entity
+      else
+        render json: { status: "ok" }, status: :ok
+      end
+    rescue StandardError => e
+      Rails.logger.error(
+        "[Escalated::InboundController] Unexpected error: #{e.message}\n#{e.backtrace&.first(5)&.join("\n")}"
+      )
+      render json: { error: "Internal error" }, status: :internal_server_error
+    end
+
+    private
+
+    def ensure_inbound_enabled
+      unless Escalated.configuration.inbound_email_enabled
+        render json: { error: "Inbound email is disabled" }, status: :not_found
+      end
+    end
+
+    ADAPTER_MAP = {
+      "mailgun" => -> { Escalated::Mail::Adapters::MailgunAdapter.new },
+      "postmark" => -> { Escalated::Mail::Adapters::PostmarkAdapter.new },
+      "ses" => -> { Escalated::Mail::Adapters::SesAdapter.new }
+    }.freeze
+
+    def resolve_adapter(adapter_name)
+      factory = ADAPTER_MAP[adapter_name.to_s.downcase]
+      factory&.call
+    end
+  end
+end

data/app/jobs/escalated/check_sla_job.rb

@@ -0,0 +1,36 @@
+module Escalated
+  class CheckSlaJob < ActiveJob::Base
+    queue_as :escalated
+
+    def perform
+      return unless Escalated.configuration.sla_enabled?
+
+      Rails.logger.info("[Escalated::CheckSlaJob] Checking SLA breaches...")
+
+      breached = Services::SlaService.check_breaches
+      warnings = Services::SlaService.check_warnings
+
+      Rails.logger.info(
+        "[Escalated::CheckSlaJob] Found #{breached.size} breaches and #{warnings.size} warnings"
+      )
+
+      # Send warning notifications
+      warnings.each do |warning|
+        ticket = warning[:ticket]
+        type = warning[:type]
+
+        ActiveSupport::Notifications.instrument("escalated.sla.warning", {
+          ticket: ticket,
+          warning_type: type
+        })
+      end
+
+      # Check if any breached tickets should be escalated
+      breached.each do |ticket|
+        Services::EscalationService.evaluate_ticket(ticket)
+      end
+
+      { breaches: breached.size, warnings: warnings.size }
+    end
+  end
+end

data/app/jobs/escalated/close_resolved_job.rb

@@ -0,0 +1,51 @@
+module Escalated
+  class CloseResolvedJob < ActiveJob::Base
+    queue_as :escalated
+
+    def perform
+      days = Escalated.configuration.auto_close_resolved_after_days
+      return if days.nil? || days <= 0
+
+      cutoff = days.days.ago
+
+      tickets = Escalated::Ticket
+        .where(status: :resolved)
+        .where("resolved_at < ?", cutoff)
+
+      count = 0
+
+      tickets.find_each do |ticket|
+        ActiveRecord::Base.transaction do
+          ticket.update!(status: :closed, closed_at: Time.current)
+
+          ticket.activities.create!(
+            action: "status_changed",
+            causer: nil,
+            details: {
+              from: "resolved",
+              to: "closed",
+              reason: "auto_closed",
+              note: "Automatically closed after #{days} days in resolved status"
+            }
+          )
+
+          ticket.replies.create!(
+            body: "This ticket was automatically closed after #{days} days in resolved status. " \
+                  "If you need further assistance, please reopen or create a new ticket.",
+            author: nil,
+            is_internal: false,
+            is_system: true
+          )
+        end
+
+        count += 1
+      end
+
+      Rails.logger.info(
+        "[Escalated::CloseResolvedJob] Auto-closed #{count} tickets resolved before #{cutoff}"
+      )
+
+      { closed_count: count }
+    end
+  end
+end

data/app/jobs/escalated/evaluate_escalations_job.rb

@@ -0,0 +1,24 @@
+module Escalated
+  class EvaluateEscalationsJob < ActiveJob::Base
+    queue_as :escalated
+
+    def perform
+      Rails.logger.info("[Escalated::EvaluateEscalationsJob] Evaluating escalation rules...")
+
+      results = Services::EscalationService.evaluate_all
+
+      Rails.logger.info(
+        "[Escalated::EvaluateEscalationsJob] Escalated #{results.size} tickets"
+      )
+
+      results.each do |result|
+        Rails.logger.info(
+          "[Escalated::EvaluateEscalationsJob] Ticket #{result[:ticket].reference} " \
+          "matched rule '#{result[:rule].name}'"
+        )
+      end
+
+      { escalated_count: results.size }
+    end
+  end
+end

data/app/jobs/escalated/poll_imap_job.rb

@@ -0,0 +1,74 @@
+module Escalated
+  class PollImapJob < ActiveJob::Base
+    queue_as :escalated
+
+    # Poll the configured IMAP mailbox for unread messages and process them
+    # as inbound emails.
+    #
+    # This job should be scheduled periodically (e.g., every 2-5 minutes)
+    # via a cron scheduler like `whenever`, `sidekiq-cron`, or `good_job`.
+    #
+    # Example with sidekiq-cron:
+    #   Sidekiq::Cron::Job.create(
+    #     name: "Poll IMAP for inbound emails",
+    #     cron: "*/5 * * * *",
+    #     class: "Escalated::PollImapJob"
+    #   )
+    def perform
+      unless Escalated.configuration.inbound_email_enabled
+        Rails.logger.debug("[Escalated::PollImapJob] Inbound email is disabled, skipping")
+        return
+      end
+
+      unless Escalated.configuration.inbound_email_adapter.to_s == "imap"
+        Rails.logger.debug("[Escalated::PollImapJob] IMAP adapter not configured, skipping")
+        return
+      end
+
+      unless imap_configured?
+        Rails.logger.warn("[Escalated::PollImapJob] IMAP credentials not configured")
+        return
+      end
+
+      Rails.logger.info("[Escalated::PollImapJob] Polling IMAP mailbox...")
+
+      adapter = Escalated::Mail::Adapters::ImapAdapter.new
+      messages = adapter.fetch_messages
+
+      Rails.logger.info("[Escalated::PollImapJob] Found #{messages.size} unread messages")
+
+      processed = 0
+      failed = 0
+
+      messages.each do |message|
+        result = Services::InboundEmailService.process(message, adapter_name: "imap")
+
+        if result&.processed?
+          processed += 1
+        else
+          failed += 1
+        end
+      rescue StandardError => e
+        failed += 1
+        Rails.logger.error(
+          "[Escalated::PollImapJob] Failed to process message from #{message.from_email}: #{e.message}"
+        )
+      end
+
+      Rails.logger.info(
+        "[Escalated::PollImapJob] Completed: #{processed} processed, #{failed} failed out of #{messages.size} total"
+      )
+
+      { total: messages.size, processed: processed, failed: failed }
+    end
+
+    private
+
+    def imap_configured?
+      config = Escalated.configuration
+      config.imap_host.present? &&
+        config.imap_username.present? &&
+        config.imap_password.present?
+    end
+  end
+end

data/app/jobs/escalated/purge_activities_job.rb

@@ -0,0 +1,24 @@
+module Escalated
+  class PurgeActivitiesJob < ActiveJob::Base
+    queue_as :escalated_low
+
+    RETENTION_DAYS = 180
+
+    def perform(retention_days: RETENTION_DAYS)
+      cutoff = retention_days.days.ago
+
+      # Only purge activities for closed tickets
+      count = Escalated::TicketActivity
+        .joins(:ticket)
+        .where(escalated_tickets: { status: :closed })
+        .where("#{Escalated.table_name('ticket_activities')}.created_at < ?", cutoff)
+        .delete_all
+
+      Rails.logger.info(
+        "[Escalated::PurgeActivitiesJob] Purged #{count} activities older than #{retention_days} days"
+      )
+
+      { purged_count: count }
+    end
+  end
+end

data/app/mailers/escalated/application_mailer.rb

@@ -0,0 +1,6 @@
+module Escalated
+  class ApplicationMailer < ActionMailer::Base
+    default from: -> { Escalated.configuration.respond_to?(:mailer_from) ? Escalated.configuration.mailer_from : "support@example.com" }
+    layout "mailer"
+  end
+end

data/app/mailers/escalated/ticket_mailer.rb

@@ -0,0 +1,93 @@
+module Escalated
+  class TicketMailer < ApplicationMailer
+    def new_ticket(ticket)
+      @ticket = ticket
+      @requester = ticket.requester
+
+      mail(
+        to: @requester.email,
+        subject: "[#{ticket.reference}] Ticket Created: #{ticket.subject}"
+      )
+    end
+
+    def reply_received(ticket, reply)
+      @ticket = ticket
+      @reply = reply
+
+      # Notify the requester if an agent replied, or notify the assignee if the customer replied
+      recipient = if reply.author == ticket.requester
+                    ticket.assignee&.email
+                  else
+                    ticket.requester.email
+                  end
+
+      return unless recipient
+
+      mail(
+        to: recipient,
+        subject: "Re: [#{ticket.reference}] #{ticket.subject}"
+      )
+    end
+
+    def ticket_assigned(ticket)
+      @ticket = ticket
+      @assignee = ticket.assignee
+
+      return unless @assignee&.email
+
+      mail(
+        to: @assignee.email,
+        subject: "[#{ticket.reference}] Ticket Assigned: #{ticket.subject}"
+      )
+    end
+
+    def status_changed(ticket)
+      @ticket = ticket
+
+      mail(
+        to: ticket.requester.email,
+        subject: "[#{ticket.reference}] Status Updated: #{ticket.status.humanize}"
+      )
+    end
+
+    def sla_breach(ticket)
+      @ticket = ticket
+
+      recipients = []
+      recipients << ticket.assignee.email if ticket.assignee&.email
+      recipients << ticket.department&.email if ticket.department&.email
+
+      return if recipients.empty?
+
+      mail(
+        to: recipients.compact.uniq,
+        subject: "[SLA BREACH] [#{ticket.reference}] #{ticket.subject}"
+      )
+    end
+
+    def ticket_escalated(ticket, rule)
+      @ticket = ticket
+      @rule = rule
+
+      recipients = Array(rule.actions["notification_recipients"])
+      recipients << ticket.assignee&.email if ticket.assignee
+      recipients << ticket.department&.email if ticket.department
+
+      return if recipients.compact.empty?
+
+      mail(
+        to: recipients.compact.uniq,
+        subject: "[ESCALATED] [#{ticket.reference}] #{ticket.subject}"
+      )
+    end
+
+    def ticket_resolved(ticket)
+      @ticket = ticket
+
+      mail(
+        to: ticket.requester.email,
+        subject: "[#{ticket.reference}] Ticket Resolved: #{ticket.subject}"
+      )
+    end
+  end
+end

data/app/models/escalated/application_record.rb

@@ -0,0 +1,5 @@
+module Escalated
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/escalated/attachment.rb

@@ -0,0 +1,46 @@
+module Escalated
+  class Attachment < ApplicationRecord
+    self.table_name = Escalated.table_name("attachments")
+
+    belongs_to :attachable, polymorphic: true
+
+    has_one_attached :file
+
+    validates :filename, presence: true
+    validates :content_type, presence: true
+    validates :byte_size, presence: true,
+              numericality: {
+                less_than_or_equal_to: -> { Escalated.configuration.max_attachment_size_kb * 1024 }
+              }
+
+    before_validation :set_metadata_from_file, if: -> { file.attached? && filename.blank? }
+
+    scope :images, -> { where("content_type LIKE ?", "image/%") }
+    scope :documents, -> { where.not("content_type LIKE ?", "image/%") }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def image?
+      content_type&.start_with?("image/")
+    end
+
+    def human_size
+      if byte_size < 1024
+        "#{byte_size} B"
+      elsif byte_size < 1_048_576
+        "#{(byte_size / 1024.0).round(1)} KB"
+      else
+        "#{(byte_size / 1_048_576.0).round(1)} MB"
+      end
+    end
+
+    private
+
+    def set_metadata_from_file
+      return unless file.attached?
+
+      self.filename = file.filename.to_s
+      self.content_type = file.content_type
+      self.byte_size = file.byte_size
+    end
+  end
+end