escalated 0.4.0

data/lib/escalated/services/assignment_service.rb

@@ -0,0 +1,85 @@
+module Escalated
+  module Services
+    class AssignmentService
+      class << self
+        def assign(ticket, agent, actor:)
+          TicketService.assign(ticket, agent, actor: actor)
+        end
+
+        def unassign(ticket, actor:)
+          TicketService.unassign(ticket, actor: actor)
+        end
+
+        def auto_assign(ticket)
+          return nil unless ticket.department.present?
+
+          agent = next_available_agent(ticket.department)
+          return nil unless agent
+
+          TicketService.assign(ticket, agent, actor: nil)
+          agent
+        end
+
+        def round_robin(department)
+          agents = department.agents.to_a
+          return nil if agents.empty?
+
+          # Find the agent with the fewest open tickets in this department
+          agent_loads = agents.map do |agent|
+            open_count = Escalated::Ticket
+              .by_open
+              .assigned_to(agent.id)
+              .where(department_id: department.id)
+              .count
+
+            { agent: agent, count: open_count }
+          end
+
+          # Sort by ticket count, then by last assignment time for tie-breaking
+          agent_loads.sort_by { |a| a[:count] }.first[:agent]
+        end
+
+        def reassign(ticket, new_agent, actor:)
+          old_agent_id = ticket.assigned_to
+          result = TicketService.assign(ticket, new_agent, actor: actor)
+
+          ActiveSupport::Notifications.instrument("escalated.ticket.reassigned", {
+            ticket: result,
+            from_agent_id: old_agent_id,
+            to_agent_id: new_agent.id
+          })
+
+          result
+        end
+
+        def bulk_assign(ticket_ids, agent, actor:)
+          tickets = Escalated::Ticket.where(id: ticket_ids)
+          results = []
+
+          tickets.each do |ticket|
+            results << TicketService.assign(ticket, agent, actor: actor)
+          end
+
+          results
+        end
+
+        def bulk_unassign(ticket_ids, actor:)
+          tickets = Escalated::Ticket.where(id: ticket_ids)
+          results = []
+
+          tickets.each do |ticket|
+            results << TicketService.unassign(ticket, actor: actor)
+          end
+
+          results
+        end
+
+        private
+
+        def next_available_agent(department)
+          round_robin(department)
+        end
+      end
+    end
+  end
+end

data/lib/escalated/services/attachment_service.rb

@@ -0,0 +1,110 @@
+module Escalated
+  module Services
+    class AttachmentService
+      class TooManyAttachmentsError < StandardError; end
+      class FileTooLargeError < StandardError; end
+      class InvalidFileTypeError < StandardError; end
+
+      ALLOWED_CONTENT_TYPES = %w[
+        image/jpeg
+        image/png
+        image/gif
+        image/webp
+        image/svg+xml
+        application/pdf
+        application/msword
+        application/vnd.openxmlformats-officedocument.wordprocessingml.document
+        application/vnd.ms-excel
+        application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+        text/plain
+        text/csv
+        application/zip
+        application/x-zip-compressed
+      ].freeze
+
+      class << self
+        def attach(attachable, files)
+          files = Array(files)
+
+          validate_count(attachable, files.size)
+
+          attachments = []
+
+          files.each do |file|
+            validate_size(file)
+            validate_type(file)
+
+            attachment = attachable.attachments.create!(
+              filename: file.original_filename,
+              content_type: file.content_type,
+              byte_size: file.size
+            )
+
+            attachment.file.attach(file)
+            attachments << attachment
+          end
+
+          attachments
+        end
+
+        def detach(attachment)
+          attachment.file.purge if attachment.file.attached?
+          attachment.destroy!
+        end
+
+        def purge_orphaned
+          # Remove attachments whose attachable has been deleted
+          Escalated::Attachment.where(attachable_type: nil).or(
+            Escalated::Attachment.where(attachable_id: nil)
+          ).find_each do |attachment|
+            detach(attachment)
+          end
+        end
+
+        def url_for(attachment, expires_in: 5.minutes)
+          return nil unless attachment.file.attached?
+
+          if Escalated.configuration.storage_service == :local
+            Rails.application.routes.url_helpers.rails_blob_path(
+              attachment.file,
+              only_path: true
+            )
+          else
+            attachment.file.url(expires_in: expires_in)
+          end
+        end
+
+        private
+
+        def validate_count(attachable, new_count)
+          existing_count = attachable.attachments.count
+          max = Escalated.configuration.max_attachments
+
+          if existing_count + new_count > max
+            raise TooManyAttachmentsError,
+                  "Maximum #{max} attachments allowed. Currently has #{existing_count}, " \
+                  "trying to add #{new_count}."
+          end
+        end
+
+        def validate_size(file)
+          max_bytes = Escalated.configuration.max_attachment_size_kb * 1024
+
+          if file.size > max_bytes
+            raise FileTooLargeError,
+                  "File '#{file.original_filename}' is #{(file.size / 1024.0).round(1)} KB. " \
+                  "Maximum allowed is #{Escalated.configuration.max_attachment_size_kb} KB."
+          end
+        end
+
+        def validate_type(file)
+          unless ALLOWED_CONTENT_TYPES.include?(file.content_type)
+            raise InvalidFileTypeError,
+                  "File type '#{file.content_type}' is not allowed. " \
+                  "Allowed types: #{ALLOWED_CONTENT_TYPES.join(', ')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/escalated/services/escalation_service.rb

@@ -0,0 +1,159 @@
+module Escalated
+  module Services
+    class EscalationService
+      class << self
+        def evaluate_all
+          rules = Escalated::EscalationRule.active.ordered
+          tickets = Escalated::Ticket.by_open
+          escalated_tickets = []
+
+          tickets.find_each do |ticket|
+            rules.each do |rule|
+              if rule.matches?(ticket)
+                execute_actions(ticket, rule)
+                escalated_tickets << { ticket: ticket, rule: rule }
+                break # Only apply the first matching rule per ticket
+              end
+            end
+          end
+
+          escalated_tickets
+        end
+
+        def evaluate_ticket(ticket)
+          rules = Escalated::EscalationRule.active.ordered
+
+          rules.each do |rule|
+            if rule.matches?(ticket)
+              execute_actions(ticket, rule)
+              return rule
+            end
+          end
+
+          nil
+        end
+
+        def execute_actions(ticket, rule)
+          actions = rule.actions
+          return unless actions.is_a?(Hash)
+
+          ActiveRecord::Base.transaction do
+            change_priority_action(ticket, actions["change_priority"]) if actions["change_priority"]
+            change_status_action(ticket, actions["change_status"]) if actions["change_status"]
+            assign_agent_action(ticket, actions["assign_to_agent_id"]) if actions["assign_to_agent_id"]
+            assign_department_action(ticket, actions["assign_to_department_id"]) if actions["assign_to_department_id"]
+            add_tags_action(ticket, actions["add_tags"]) if actions["add_tags"]
+            add_note_action(ticket, actions["add_internal_note"]) if actions["add_internal_note"]
+
+            log_escalation(ticket, rule)
+          end
+
+          if actions["send_notification"]
+            send_escalation_notification(ticket, rule, actions["notification_recipients"])
+          end
+
+          ActiveSupport::Notifications.instrument("escalated.ticket.escalated", {
+            ticket: ticket,
+            rule: rule
+          })
+        end
+
+        private
+
+        def change_priority_action(ticket, new_priority)
+          old_priority = ticket.priority
+          ticket.update!(priority: new_priority)
+
+          ticket.activities.create!(
+            action: "priority_changed",
+            causer: nil,
+            details: { from: old_priority, to: new_priority, reason: "escalation_rule" }
+          )
+        end
+
+        def change_status_action(ticket, new_status)
+          old_status = ticket.status
+          ticket.update!(status: new_status)
+
+          ticket.activities.create!(
+            action: "status_changed",
+            causer: nil,
+            details: { from: old_status, to: new_status, reason: "escalation_rule" }
+          )
+        end
+
+        def assign_agent_action(ticket, agent_id)
+          agent = Escalated.configuration.user_model.find_by(id: agent_id)
+          return unless agent
+
+          old_assignee = ticket.assigned_to
+          ticket.update!(assigned_to: agent.id)
+
+          ticket.activities.create!(
+            action: "ticket_assigned",
+            causer: nil,
+            details: { from_agent_id: old_assignee, to_agent_id: agent.id, reason: "escalation_rule" }
+          )
+        end
+
+        def assign_department_action(ticket, department_id)
+          department = Escalated::Department.find_by(id: department_id)
+          return unless department
+
+          old_department = ticket.department_id
+          ticket.update!(department_id: department.id)
+
+          ticket.activities.create!(
+            action: "department_changed",
+            causer: nil,
+            details: { from_department_id: old_department, to_department_id: department.id, reason: "escalation_rule" }
+          )
+        end
+
+        def add_tags_action(ticket, tag_names)
+          return unless tag_names.is_a?(Array)
+
+          tag_names.each do |name|
+            tag = Escalated::Tag.find_or_create_by!(name: name) do |t|
+              t.slug = name.parameterize
+            end
+            ticket.tags << tag unless ticket.tags.include?(tag)
+          end
+        end
+
+        def add_note_action(ticket, note_body)
+          ticket.replies.create!(
+            body: note_body,
+            author: nil,
+            is_internal: true,
+            is_system: true
+          )
+        end
+
+        def log_escalation(ticket, rule)
+          ticket.activities.create!(
+            action: "ticket_escalated",
+            causer: nil,
+            details: {
+              rule_id: rule.id,
+              rule_name: rule.name,
+              actions_applied: rule.actions.keys
+            }
+          )
+        end
+
+        def send_escalation_notification(ticket, rule, recipients)
+          if Escalated.configuration.notification_channels.include?(:email)
+            Escalated::TicketMailer.ticket_escalated(ticket, rule).deliver_later
+          end
+
+          NotificationService.dispatch(:ticket_escalated, {
+            ticket: ticket,
+            rule: rule,
+            recipients: recipients
+          })
+        end
+      end
+    end
+  end
+end

data/lib/escalated/services/inbound_email_service.rb

@@ -0,0 +1,255 @@
+module Escalated
+  module Services
+    class InboundEmailService
+      ALLOWED_TAGS = %w[p br b strong i em u a ul ol li h1 h2 h3 h4 h5 h6 blockquote pre code table thead tbody tr th td img hr div span sub sup].freeze
+
+      BLOCKED_EXTENSIONS = %w[
+        exe bat cmd com msi scr pif vbs vbe
+        js jse wsf wsh ps1 psm1 psd1 reg
+        cpl hta inf lnk sct shb sys drv
+        php phtml php3 php4 php5 phar
+        sh bash csh ksh pl py rb
+        dll so dylib
+      ].freeze
+
+      class << self
+        # Process an inbound email message and create/reply to a ticket.
+        #
+        # @param message [Escalated::Mail::InboundMessage] the parsed email message
+        # @param adapter_name [String] the name of the adapter that parsed this message
+        # @return [Escalated::InboundEmail] the inbound email record
+        def process(message, adapter_name: "unknown")
+          unless Escalated.configuration.inbound_email_enabled
+            Rails.logger.info("[Escalated::InboundEmailService] Inbound email is disabled, skipping")
+            return nil
+          end
+
+          unless message.valid?
+            Rails.logger.warn("[Escalated::InboundEmailService] Invalid message: missing required fields")
+            return nil
+          end
+
+          # Create the inbound email record for tracking
+          inbound_email = create_inbound_record(message, adapter_name)
+
+          # Check for duplicate by message_id
+          if inbound_email.duplicate?
+            Rails.logger.info("[Escalated::InboundEmailService] Duplicate message_id: #{message.message_id}")
+            inbound_email.mark_failed!("Duplicate message_id: #{message.message_id}")
+            return inbound_email
+          end
+
+          begin
+            ActiveRecord::Base.transaction do
+              ticket, reply = resolve_and_process(message)
+              inbound_email.mark_processed!(ticket: ticket, reply: reply)
+            end
+          rescue StandardError => e
+            Rails.logger.error(
+              "[Escalated::InboundEmailService] Failed to process message: #{e.message}\n#{e.backtrace&.first(5)&.join("\n")}"
+            )
+            inbound_email.mark_failed!(e.message)
+          end
+
+          inbound_email
+        end
+
+        private
+
+        # Create the inbound email tracking record.
+        def create_inbound_record(message, adapter_name)
+          Escalated::InboundEmail.create!(
+            message_id: message.message_id,
+            from_email: message.from_email,
+            from_name: message.from_name,
+            to_email: message.to_email,
+            subject: message.subject,
+            body_text: message.body_text,
+            body_html: sanitize_html(message.body_html),
+            raw_headers: message.raw_headers_string,
+            adapter: adapter_name,
+            status: :pending
+          )
+        end
+
+        # Determine whether this is a reply to an existing ticket or a new ticket,
+        # then process accordingly.
+        #
+        # @return [Array(Ticket, Reply|nil)] the ticket and optional reply
+        def resolve_and_process(message)
+          # Try to find an existing ticket by subject reference
+          ticket = find_existing_ticket(message)
+
+          if ticket
+            reply = add_reply_to_ticket(ticket, message)
+            [ticket, reply]
+          else
+            ticket = create_new_ticket(message)
+            [ticket, nil]
+          end
+        end
+
+        # Search for an existing ticket using:
+        # 1. Subject line reference tag (e.g., [ESC-2602-ABC123])
+        # 2. In-Reply-To / References headers matching previous message IDs
+        #
+        # @return [Escalated::Ticket, nil]
+        def find_existing_ticket(message)
+          # Strategy 1: Look for ticket reference in subject
+          reference = message.ticket_reference
+          if reference.present?
+            ticket = Escalated::Ticket.find_by(reference: reference)
+            return ticket if ticket
+          end
+
+          # Strategy 2: Look up by In-Reply-To matching a previous inbound email
+          if message.in_reply_to.present?
+            previous = Escalated::InboundEmail.find_by(message_id: message.in_reply_to)
+            return previous.ticket if previous&.ticket
+          end
+
+          # Strategy 3: Look up by References header
+          if message.references.present?
+            message.references.reverse_each do |ref|
+              previous = Escalated::InboundEmail.find_by(message_id: ref)
+              return previous.ticket if previous&.ticket
+            end
+          end
+
+          nil
+        end
+
+        # Add a reply to an existing ticket.
+        # Look up the user by email; if not found, treat as guest reply.
+        #
+        # @return [Escalated::Reply]
+        def add_reply_to_ticket(ticket, message)
+          author = find_user_by_email(message.from_email)
+          body = get_sanitized_body(message)
+
+          if body.blank?
+            body = "(empty reply from #{message.from_email})"
+          end
+
+          reply = Services::TicketService.reply(ticket, {
+            body: body,
+            author: author,
+            is_internal: false,
+            is_system: false
+          })
+
+          Rails.logger.info(
+            "[Escalated::InboundEmailService] Added reply to ticket #{ticket.reference} from #{message.from_email}"
+          )
+
+          reply
+        end
+
+        # Create a new ticket from the inbound email.
+        # Look up the user by email; if not found, create as guest ticket.
+        #
+        # @return [Escalated::Ticket]
+        def create_new_ticket(message)
+          user = find_user_by_email(message.from_email)
+          subject = message.clean_subject.presence || message.subject
+          description = get_sanitized_body(message)
+
+          if description.blank?
+            description = "(no content)"
+          end
+
+          if user
+            # Authenticated user ticket
+            ticket = Services::TicketService.create(
+              subject: subject,
+              description: description,
+              priority: Escalated.configuration.default_priority,
+              requester: user,
+              metadata: { channel: "email", original_message_id: message.message_id }
+            )
+          else
+            # Guest ticket (follows guest/tickets_controller.rb pattern)
+            guest_token = SecureRandom.hex(32)
+
+            ticket = Escalated::Ticket.create!(
+              requester: nil,
+              guest_name: message.from_name || message.from_email,
+              guest_email: message.from_email,
+              guest_token: guest_token,
+              subject: subject,
+              description: description,
+              priority: Escalated.configuration.default_priority,
+              metadata: { channel: "email", original_message_id: message.message_id }
+            )
+
+            # Dispatch notifications manually since we bypassed TicketService.create
+            Services::NotificationService.dispatch(:ticket_created, ticket: ticket)
+          end
+
+          Rails.logger.info(
+            "[Escalated::InboundEmailService] Created ticket #{ticket.reference} from #{message.from_email}" \
+            "#{user ? '' : ' (guest)'}"
+          )
+
+          ticket
+        end
+
+        def sanitize_html(html)
+          return html if html.blank?
+
+          # Use Rails' built-in sanitizer if available
+          if defined?(ActionView::Base)
+            ActionView::Base.safe_list_sanitizer.new.sanitize(
+              html,
+              tags: ALLOWED_TAGS,
+              attributes: %w[href src alt title class style id]
+            )
+          else
+            # Fallback: strip all tags except allowed
+            clean = html.dup
+            # Remove script tags and their content
+            clean.gsub!(/<script\b[^>]*>.*?<\/script>/mi, '')
+            # Remove event handlers
+            clean.gsub!(/\s+on\w+\s*=\s*["'][^"']*["']/i, '')
+            clean.gsub!(/\s+on\w+\s*=\s*\S+/i, '')
+            # Remove javascript: protocol
+            clean.gsub!(/\b(href|src|action)\s*=\s*["']?\s*javascript\s*:/i, '\1="')
+            # Remove dangerous data: URLs
+            clean.gsub!(/\b(href|src|action)\s*=\s*["']?\s*data\s*:(?!image\/)/i, '\1="')
+            clean
+          end
+        end
+
+        def get_sanitized_body(message)
+          if message.body_text.present?
+            message.body_text
+          elsif message.body_html.present?
+            sanitize_html(message.body_html) || ''
+          else
+            ''
+          end
+        end
+
+        # Look up a user in the host application by email.
+        #
+        # @param email [String]
+        # @return [User, nil]
+        def find_user_by_email(email)
+          return nil if email.blank?
+
+          user_class = Escalated.configuration.user_model
+          if user_class.respond_to?(:find_by)
+            user_class.find_by(email: email.downcase.strip)
+          else
+            nil
+          end
+        rescue StandardError => e
+          Rails.logger.warn(
+            "[Escalated::InboundEmailService] Failed to look up user by email: #{e.message}"
+          )
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/escalated/services/macro_service.rb

@@ -0,0 +1,49 @@
+module Escalated
+  module Services
+    class MacroService
+      class << self
+        def apply(macro, ticket, actor:)
+          actions = macro.actions || []
+
+          actions.each do |action|
+            action = action.with_indifferent_access if action.respond_to?(:with_indifferent_access)
+            type = action["type"] || action[:type]
+            value = action["value"] || action[:value]
+
+            case type.to_s
+            when "status"
+              TicketService.transition_status(ticket, value, actor: actor)
+            when "priority"
+              TicketService.change_priority(ticket, value, actor: actor)
+            when "assign"
+              agent = Escalated.configuration.user_model.find(value)
+              AssignmentService.assign(ticket, agent, actor: actor)
+            when "tags"
+              tag_ids = Array(value)
+              TicketService.add_tags(ticket, tag_ids, actor: actor)
+            when "department"
+              department = Escalated::Department.find(value)
+              TicketService.change_department(ticket, department, actor: actor)
+            when "reply"
+              TicketService.reply(ticket, {
+                body: value.to_s,
+                author: actor,
+                is_internal: false
+              })
+            when "note"
+              TicketService.reply(ticket, {
+                body: value.to_s,
+                author: actor,
+                is_internal: true
+              })
+            end
+
+            ticket.reload
+          end
+
+          ticket
+        end
+      end
+    end
+  end
+end