escalated 0.4.0

data/db/migrate/012_create_escalated_inbound_emails.rb

@@ -0,0 +1,30 @@
+class CreateEscalatedInboundEmails < ActiveRecord::Migration[7.0]
+  def change
+    create_table Escalated.table_name("inbound_emails") do |t|
+      t.string :message_id
+      t.string :from_email, null: false
+      t.string :from_name
+      t.string :to_email, null: false
+      t.string :subject, null: false
+      t.text :body_text
+      t.text :body_html
+      t.text :raw_headers
+
+      t.references :ticket, foreign_key: { to_table: Escalated.table_name("tickets") }, null: true
+      t.references :reply, foreign_key: { to_table: Escalated.table_name("replies") }, null: true
+
+      t.string :status, default: "pending", null: false
+      t.string :adapter, null: false
+      t.text :error_message
+
+      t.datetime :processed_at
+
+      t.timestamps
+    end
+
+    add_index Escalated.table_name("inbound_emails"), :message_id, unique: true
+    add_index Escalated.table_name("inbound_emails"), :from_email
+    add_index Escalated.table_name("inbound_emails"), :status
+    add_index Escalated.table_name("inbound_emails"), :processed_at
+  end
+end

data/db/migrate/013_create_escalated_macros.rb

@@ -0,0 +1,18 @@
+class CreateEscalatedMacros < ActiveRecord::Migration[7.0]
+  def change
+    create_table Escalated.table_name("macros") do |t|
+      t.string :name, null: false
+      t.string :description
+      t.json :actions, null: false
+      t.bigint :created_by
+      t.boolean :is_shared, default: true, null: false
+      t.integer :order, default: 0, null: false
+
+      t.timestamps
+    end
+
+    add_index Escalated.table_name("macros"), :created_by
+    add_index Escalated.table_name("macros"), :is_shared
+    add_index Escalated.table_name("macros"), :order
+  end
+end

data/db/migrate/014_create_escalated_ticket_followers.rb

@@ -0,0 +1,18 @@
+class CreateEscalatedTicketFollowers < ActiveRecord::Migration[7.0]
+  def change
+    create_table Escalated.table_name("ticket_followers"), id: false do |t|
+      t.bigint :ticket_id, null: false
+      t.bigint :user_id, null: false
+
+      t.timestamps
+    end
+
+    add_index Escalated.table_name("ticket_followers"),
+              [:ticket_id, :user_id],
+              unique: true,
+              name: "idx_escalated_ticket_followers_unique"
+    add_foreign_key Escalated.table_name("ticket_followers"),
+                    Escalated.table_name("tickets"),
+                    column: :ticket_id
+  end
+end

data/db/migrate/015_create_escalated_satisfaction_ratings.rb

@@ -0,0 +1,21 @@
+class CreateEscalatedSatisfactionRatings < ActiveRecord::Migration[7.0]
+  def change
+    create_table Escalated.table_name("satisfaction_ratings") do |t|
+      t.references :ticket, null: false, foreign_key: { to_table: Escalated.table_name("tickets") }
+      t.integer :rating, null: false
+      t.text :comment
+
+      # Polymorphic rated_by (nullable for guest ratings)
+      t.string :rated_by_type
+      t.bigint :rated_by_id
+
+      t.datetime :created_at
+    end
+
+    add_index Escalated.table_name("satisfaction_ratings"), [:rated_by_type, :rated_by_id]
+    add_index Escalated.table_name("satisfaction_ratings"),
+              :ticket_id,
+              unique: true,
+              name: "idx_escalated_satisfaction_ratings_ticket"
+  end
+end

data/db/migrate/016_add_is_pinned_to_escalated_replies.rb

@@ -0,0 +1,6 @@
+class AddIsPinnedToEscalatedReplies < ActiveRecord::Migration[7.0]
+  def change
+    add_column Escalated.table_name("replies"), :is_pinned, :boolean, default: false, null: false
+    add_index Escalated.table_name("replies"), :is_pinned
+  end
+end

data/lib/escalated/configuration.rb

@@ -0,0 +1,111 @@
+module Escalated
+  class Configuration
+    attr_accessor :mode,
+                  :user_class,
+                  :table_prefix,
+                  :route_prefix,
+                  :middleware,
+                  :admin_middleware,
+                  :hosted_api_url,
+                  :hosted_api_key,
+                  :allow_customer_close,
+                  :auto_close_resolved_after_days,
+                  :max_attachments,
+                  :max_attachment_size_kb,
+                  :default_priority,
+                  :sla,
+                  :notification_channels,
+                  :webhook_url,
+                  :storage_service,
+                  # Inbound email settings
+                  :inbound_email_enabled,
+                  :inbound_email_adapter,
+                  :inbound_email_address,
+                  # Mailgun
+                  :mailgun_signing_key,
+                  # Postmark
+                  :postmark_inbound_token,
+                  # AWS SES
+                  :ses_region,
+                  :ses_topic_arn,
+                  # IMAP
+                  :imap_host,
+                  :imap_port,
+                  :imap_encryption,
+                  :imap_username,
+                  :imap_password,
+                  :imap_mailbox
+
+    def initialize
+      @mode = :self_hosted
+      @user_class = "User"
+      @table_prefix = "escalated_"
+      @route_prefix = "support"
+      @middleware = [:authenticate_user!]
+      @admin_middleware = nil
+      @hosted_api_url = nil
+      @hosted_api_key = nil
+      @allow_customer_close = true
+      @auto_close_resolved_after_days = 7
+      @max_attachments = 5
+      @max_attachment_size_kb = 10_240
+      @default_priority = :medium
+      @sla = {
+        enabled: true,
+        business_hours_only: true,
+        business_hours: {
+          start: 9,
+          end: 17,
+          timezone: "UTC",
+          working_days: [1, 2, 3, 4, 5]
+        }
+      }
+      @notification_channels = [:email]
+      @webhook_url = nil
+      @storage_service = :local
+
+      # Inbound email defaults
+      @inbound_email_enabled = false
+      @inbound_email_adapter = nil  # :mailgun, :postmark, :ses, :imap
+      @inbound_email_address = nil  # e.g., "support@yourdomain.com"
+      @mailgun_signing_key = nil
+      @postmark_inbound_token = nil
+      @ses_region = nil
+      @ses_topic_arn = nil
+      @imap_host = nil
+      @imap_port = 993
+      @imap_encryption = :ssl
+      @imap_username = nil
+      @imap_password = nil
+      @imap_mailbox = "INBOX"
+    end
+
+    def self_hosted?
+      mode == :self_hosted
+    end
+
+    def synced?
+      mode == :synced
+    end
+
+    def cloud?
+      mode == :cloud
+    end
+
+    def sla_enabled?
+      sla[:enabled] == true
+    end
+
+    def business_hours_only?
+      sla[:business_hours_only] == true
+    end
+
+    def business_hours
+      sla[:business_hours] || {}
+    end
+
+    def user_model
+      user_class.constantize
+    end
+  end
+end

data/lib/escalated/drivers/cloud_driver.rb

@@ -0,0 +1,134 @@
+require "escalated/drivers/hosted_api_client"
+
+module Escalated
+  module Drivers
+    class CloudDriver
+      def create_ticket(params)
+        response = client.post("/tickets", {
+          subject: params[:subject],
+          description: params[:description],
+          priority: params[:priority] || Escalated.configuration.default_priority,
+          requester_email: params[:requester]&.email,
+          department_id: params[:department_id],
+          tag_ids: params[:tag_ids],
+          metadata: params[:metadata]
+        })
+
+        build_ticket_from_response(response)
+      end
+
+      def update_ticket(ticket, params, actor:)
+        reference = ticket.is_a?(String) ? ticket : ticket.reference
+
+        response = client.patch("/tickets/#{reference}", {
+          subject: params[:subject],
+          description: params[:description],
+          metadata: params[:metadata]
+        })
+
+        build_ticket_from_response(response)
+      end
+
+      def transition_status(ticket, new_status, actor:, note: nil)
+        reference = ticket.is_a?(String) ? ticket : ticket.reference
+
+        response = client.post("/tickets/#{reference}/status", {
+          status: new_status,
+          note: note
+        })
+
+        build_ticket_from_response(response)
+      end
+
+      def assign_ticket(ticket, agent, actor:)
+        reference = ticket.is_a?(String) ? ticket : ticket.reference
+
+        response = client.post("/tickets/#{reference}/assign", {
+          agent_email: agent.email
+        })
+
+        build_ticket_from_response(response)
+      end
+
+      def unassign_ticket(ticket, actor:)
+        reference = ticket.is_a?(String) ? ticket : ticket.reference
+
+        response = client.post("/tickets/#{reference}/unassign")
+        build_ticket_from_response(response)
+      end
+
+      def add_reply(ticket, params)
+        reference = ticket.is_a?(String) ? ticket : ticket.reference
+
+        response = client.post("/tickets/#{reference}/replies", {
+          body: params[:body],
+          author_email: params[:author]&.email,
+          is_internal: params[:is_internal] || false
+        })
+
+        OpenStruct.new(response)
+      end
+
+      def get_ticket(id)
+        response = client.get("/tickets/#{id}")
+        build_ticket_from_response(response)
+      end
+
+      def list_tickets(filters = {})
+        response = client.get("/tickets", filters)
+        response.map { |data| build_ticket_from_response(data) }
+      end
+
+      def add_tags(ticket, tag_ids, actor:)
+        reference = ticket.is_a?(String) ? ticket : ticket.reference
+
+        response = client.post("/tickets/#{reference}/tags", {
+          tag_ids: tag_ids
+        })
+
+        build_ticket_from_response(response)
+      end
+
+      def remove_tags(ticket, tag_ids, actor:)
+        reference = ticket.is_a?(String) ? ticket : ticket.reference
+
+        response = client.delete("/tickets/#{reference}/tags", {
+          tag_ids: tag_ids
+        })
+
+        build_ticket_from_response(response)
+      end
+
+      def change_department(ticket, department, actor:)
+        reference = ticket.is_a?(String) ? ticket : ticket.reference
+
+        response = client.post("/tickets/#{reference}/department", {
+          department_id: department.id
+        })
+
+        build_ticket_from_response(response)
+      end
+
+      def change_priority(ticket, new_priority, actor:)
+        reference = ticket.is_a?(String) ? ticket : ticket.reference
+
+        response = client.post("/tickets/#{reference}/priority", {
+          priority: new_priority
+        })
+
+        build_ticket_from_response(response)
+      end
+
+      private
+
+      def client
+        @client ||= HostedApiClient.new
+      end
+
+      def build_ticket_from_response(data)
+        data = data.deep_symbolize_keys if data.respond_to?(:deep_symbolize_keys)
+        OpenStruct.new(data)
+      end
+    end
+  end
+end

data/lib/escalated/drivers/hosted_api_client.rb

@@ -0,0 +1,166 @@
+require "net/http"
+require "json"
+require "uri"
+
+module Escalated
+  module Drivers
+    class HostedApiClient
+      class ApiError < StandardError
+        attr_reader :status, :body
+
+        def initialize(message, status: nil, body: nil)
+          @status = status
+          @body = body
+          super(message)
+        end
+      end
+
+      class ConnectionError < ApiError; end
+      class AuthenticationError < ApiError; end
+      class RateLimitError < ApiError; end
+      class ServerError < ApiError; end
+
+      TIMEOUT = 30
+      MAX_RETRIES = 3
+      RETRY_DELAY = 1
+
+      def initialize(api_url: nil, api_key: nil)
+        @api_url = api_url || Escalated.configuration.hosted_api_url
+        @api_key = api_key || Escalated.configuration.hosted_api_key
+
+        raise ArgumentError, "Escalated hosted_api_url is required for cloud/synced mode" if @api_url.blank?
+        raise ArgumentError, "Escalated hosted_api_key is required for cloud/synced mode" if @api_key.blank?
+      end
+
+      # Class method for fire-and-forget sync operations
+      def self.emit(action, payload)
+        new.emit(action, payload)
+      end
+
+      def emit(action, payload)
+        post("/sync/#{action}", payload)
+      rescue StandardError => e
+        Rails.logger.error("[Escalated::HostedApiClient] Emit failed: #{e.message}")
+        raise
+      end
+
+      def get(path, params = {})
+        uri = build_uri(path, params)
+        request = Net::HTTP::Get.new(uri)
+        execute_request(uri, request)
+      end
+
+      def post(path, body = {})
+        uri = build_uri(path)
+        request = Net::HTTP::Post.new(uri)
+        request.body = body.to_json
+        execute_request(uri, request)
+      end
+
+      def patch(path, body = {})
+        uri = build_uri(path)
+        request = Net::HTTP::Patch.new(uri)
+        request.body = body.to_json
+        execute_request(uri, request)
+      end
+
+      def put(path, body = {})
+        uri = build_uri(path)
+        request = Net::HTTP::Put.new(uri)
+        request.body = body.to_json
+        execute_request(uri, request)
+      end
+
+      def delete(path, body = {})
+        uri = build_uri(path)
+        request = Net::HTTP::Delete.new(uri)
+        request.body = body.to_json if body.present?
+        execute_request(uri, request)
+      end
+
+      private
+
+      def build_uri(path, params = {})
+        url = "#{@api_url.chomp('/')}#{path}"
+        uri = URI.parse(url)
+
+        if params.present?
+          query = params.compact.map { |k, v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join("&")
+          uri.query = query
+        end
+
+        uri
+      end
+
+      def execute_request(uri, request, retries: 0)
+        apply_headers(request)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = TIMEOUT
+        http.read_timeout = TIMEOUT
+
+        response = http.request(request)
+        handle_response(response)
+      rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED, Errno::ECONNRESET => e
+        if retries < MAX_RETRIES
+          sleep(RETRY_DELAY * (retries + 1))
+          execute_request(uri, request, retries: retries + 1)
+        else
+          raise ConnectionError.new(
+            "Failed to connect to Escalated API after #{MAX_RETRIES} retries: #{e.message}"
+          )
+        end
+      end
+
+      def apply_headers(request)
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json"
+        request["Authorization"] = "Bearer #{@api_key}"
+        request["User-Agent"] = "Escalated-Rails/#{Escalated::VERSION rescue '0.1.0'}"
+        request["X-Escalated-Source"] = "rails-engine"
+      end
+
+      def handle_response(response)
+        body = parse_body(response.body)
+
+        case response.code.to_i
+        when 200..299
+          body
+        when 401
+          raise AuthenticationError.new(
+            "Authentication failed. Check your Escalated API key.",
+            status: 401, body: body
+          )
+        when 429
+          raise RateLimitError.new(
+            "Rate limit exceeded. Retry after #{response['Retry-After'] || '60'} seconds.",
+            status: 429, body: body
+          )
+        when 400..499
+          raise ApiError.new(
+            "Client error: #{body['message'] || response.message}",
+            status: response.code.to_i, body: body
+          )
+        when 500..599
+          raise ServerError.new(
+            "Server error: #{body['message'] || response.message}",
+            status: response.code.to_i, body: body
+          )
+        else
+          raise ApiError.new(
+            "Unexpected response: #{response.code} #{response.message}",
+            status: response.code.to_i, body: body
+          )
+        end
+      end
+
+      def parse_body(raw)
+        return {} if raw.blank?
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        { "raw" => raw }
+      end
+    end
+  end
+end