escalated 0.4.0

data/lib/escalated/services/notification_service.rb

@@ -0,0 +1,157 @@
+require "net/http"
+require "json"
+require "uri"
+
+module Escalated
+  module Services
+    class NotificationService
+      class << self
+        def dispatch(event, payload = {})
+          send_webhook(event, payload) if webhook_configured?
+          notify_followers(event, payload) if should_notify_followers?(event)
+          instrument_event(event, payload)
+        end
+
+        def send_webhook(event, payload)
+          return unless webhook_configured?
+
+          webhook_payload = build_webhook_payload(event, payload)
+
+          Thread.new do
+            begin
+              uri = URI.parse(Escalated.configuration.webhook_url)
+              http = Net::HTTP.new(uri.host, uri.port)
+              http.use_ssl = uri.scheme == "https"
+              http.open_timeout = 10
+              http.read_timeout = 10
+
+              request = Net::HTTP::Post.new(uri.path)
+              request["Content-Type"] = "application/json"
+              request["User-Agent"] = "Escalated-Webhook/0.1.0"
+              request["X-Escalated-Event"] = event.to_s
+              request["X-Escalated-Signature"] = compute_signature(webhook_payload)
+              request.body = webhook_payload.to_json
+
+              response = http.request(request)
+
+              unless response.is_a?(Net::HTTPSuccess)
+                Rails.logger.warn(
+                  "[Escalated::NotificationService] Webhook returned #{response.code} for event #{event}"
+                )
+              end
+            rescue StandardError => e
+              Rails.logger.error(
+                "[Escalated::NotificationService] Webhook failed for event #{event}: #{e.message}"
+              )
+            end
+          end
+        end
+
+        private
+
+        def webhook_configured?
+          Escalated.configuration.webhook_url.present?
+        end
+
+        def build_webhook_payload(event, payload)
+          data = {
+            event: event.to_s,
+            timestamp: Time.current.iso8601,
+            data: {}
+          }
+
+          if payload[:ticket]
+            ticket = payload[:ticket]
+            data[:data][:ticket] = {
+              id: ticket.respond_to?(:id) ? ticket.id : nil,
+              reference: ticket.respond_to?(:reference) ? ticket.reference : nil,
+              subject: ticket.respond_to?(:subject) ? ticket.subject : nil,
+              status: ticket.respond_to?(:status) ? ticket.status : nil,
+              priority: ticket.respond_to?(:priority) ? ticket.priority : nil
+            }
+          end
+
+          if payload[:reply]
+            reply = payload[:reply]
+            data[:data][:reply] = {
+              id: reply.respond_to?(:id) ? reply.id : nil,
+              is_internal: reply.respond_to?(:is_internal) ? reply.is_internal : nil
+            }
+          end
+
+          if payload[:agent]
+            agent = payload[:agent]
+            data[:data][:agent] = {
+              id: agent.respond_to?(:id) ? agent.id : nil,
+              email: agent.respond_to?(:email) ? agent.email : nil
+            }
+          end
+
+          # Include any extra scalar values
+          payload.each do |key, value|
+            next if [:ticket, :reply, :agent, :rule, :recipients].include?(key)
+            data[:data][key] = value if value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          end
+
+          data
+        end
+
+        def compute_signature(payload)
+          key = Escalated.configuration.hosted_api_key || "escalated-webhook-secret"
+          OpenSSL::HMAC.hexdigest("SHA256", key, payload.to_json)
+        end
+
+        def should_notify_followers?(event)
+          [:reply_added, :status_changed, :ticket_assigned, :priority_changed].include?(event)
+        end
+
+        def notify_followers(event, payload)
+          ticket = payload[:ticket]
+          return unless ticket.respond_to?(:followers)
+
+          reply = payload[:reply]
+          actor = payload[:agent]
+
+          ticket.followers.each do |follower|
+            # Skip the actor (person who performed the action)
+            next if actor && follower.id == actor.id
+            # Skip the reply author
+            next if reply && reply.respond_to?(:author) && reply.author == follower
+            # Skip the assignee (they already get notified separately)
+            next if ticket.respond_to?(:assigned_to) && ticket.assigned_to == follower.id
+            # Skip the requester (they already get notified separately)
+            next if ticket.respond_to?(:requester) && ticket.requester == follower
+
+            if Escalated.configuration.notification_channels.include?(:email)
+              begin
+                case event
+                when :reply_added
+                  Escalated::TicketMailer.reply_received(ticket, reply).deliver_later
+                when :status_changed
+                  Escalated::TicketMailer.status_changed(ticket).deliver_later
+                when :ticket_assigned
+                  Escalated::TicketMailer.ticket_assigned(ticket).deliver_later
+                when :priority_changed
+                  # Priority change notification to followers
+                  Escalated::TicketMailer.status_changed(ticket).deliver_later
+                end
+              rescue StandardError => e
+                Rails.logger.warn(
+                  "[Escalated::NotificationService] Follower notification failed for #{follower.id}: #{e.message}"
+                )
+              end
+            end
+          end
+        rescue StandardError => e
+          Rails.logger.warn(
+            "[Escalated::NotificationService] Follower notification dispatch failed: #{e.message}"
+          )
+        end
+
+        def instrument_event(event, payload)
+          ActiveSupport::Notifications.instrument("escalated.notification.#{event}", payload)
+        end
+      end
+    end
+  end
+end

data/lib/escalated/services/sla_service.rb

@@ -0,0 +1,203 @@
+module Escalated
+  module Services
+    class SlaService
+      class << self
+        def attach_policy(ticket, policy = nil)
+          return unless Escalated.configuration.sla_enabled?
+
+          policy ||= find_policy_for(ticket)
+          return unless policy
+
+          ticket.update!(
+            sla_policy_id: policy.id,
+            sla_first_response_due_at: calculate_due_date(policy.first_response_hours_for(ticket.priority)),
+            sla_resolution_due_at: calculate_due_date(policy.resolution_hours_for(ticket.priority))
+          )
+        end
+
+        def check_breaches
+          return unless Escalated.configuration.sla_enabled?
+
+          breached_tickets = []
+
+          # Check first response breaches
+          Escalated::Ticket
+            .by_open
+            .where(sla_breached: false)
+            .where.not(sla_first_response_due_at: nil)
+            .where(first_response_at: nil)
+            .where("sla_first_response_due_at < ?", Time.current)
+            .find_each do |ticket|
+              mark_breached(ticket, :first_response)
+              breached_tickets << ticket
+            end
+
+          # Check resolution breaches
+          Escalated::Ticket
+            .by_open
+            .where(sla_breached: false)
+            .where.not(sla_resolution_due_at: nil)
+            .where(resolved_at: nil)
+            .where("sla_resolution_due_at < ?", Time.current)
+            .find_each do |ticket|
+              mark_breached(ticket, :resolution)
+              breached_tickets << ticket
+            end
+
+          breached_tickets
+        end
+
+        def check_warnings
+          return unless Escalated.configuration.sla_enabled?
+
+          warning_tickets = []
+
+          # First response warnings (1 hour before breach)
+          Escalated::Ticket
+            .by_open
+            .where(sla_breached: false)
+            .where.not(sla_first_response_due_at: nil)
+            .where(first_response_at: nil)
+            .where("sla_first_response_due_at BETWEEN ? AND ?", Time.current, 1.hour.from_now)
+            .find_each do |ticket|
+              warning_tickets << { ticket: ticket, type: :first_response_warning }
+            end
+
+          # Resolution warnings (2 hours before breach)
+          Escalated::Ticket
+            .by_open
+            .where(sla_breached: false)
+            .where.not(sla_resolution_due_at: nil)
+            .where(resolved_at: nil)
+            .where("sla_resolution_due_at BETWEEN ? AND ?", Time.current, 2.hours.from_now)
+            .find_each do |ticket|
+              warning_tickets << { ticket: ticket, type: :resolution_warning }
+            end
+
+          warning_tickets
+        end
+
+        def calculate_due_date(hours)
+          return nil unless hours
+
+          if Escalated.configuration.business_hours_only?
+            calculate_business_hours_due_date(hours)
+          else
+            Time.current + hours.hours
+          end
+        end
+
+        def recalculate_for_ticket(ticket)
+          return unless ticket.sla_policy
+
+          policy = ticket.sla_policy
+
+          updates = {}
+          unless ticket.first_response_at
+            updates[:sla_first_response_due_at] = calculate_due_date(
+              policy.first_response_hours_for(ticket.priority)
+            )
+          end
+
+          unless ticket.resolved_at
+            updates[:sla_resolution_due_at] = calculate_due_date(
+              policy.resolution_hours_for(ticket.priority)
+            )
+          end
+
+          ticket.update!(updates) if updates.any?
+        end
+
+        def stats
+          return {} unless Escalated.configuration.sla_enabled?
+
+          total = Escalated::Ticket.where.not(sla_policy_id: nil).count
+          breached = Escalated::Ticket.where(sla_breached: true).count
+
+          responded = Escalated::Ticket.where.not(first_response_at: nil, sla_first_response_due_at: nil)
+          on_time_responses = responded.where("first_response_at <= sla_first_response_due_at").count
+
+          resolved = Escalated::Ticket.where.not(resolved_at: nil, sla_resolution_due_at: nil)
+          on_time_resolutions = resolved.where("resolved_at <= sla_resolution_due_at").count
+
+          {
+            total_with_sla: total,
+            total_breached: breached,
+            breach_rate: total > 0 ? (breached.to_f / total * 100).round(1) : 0,
+            first_response_on_time: on_time_responses,
+            first_response_on_time_rate: responded.count > 0 ? (on_time_responses.to_f / responded.count * 100).round(1) : 0,
+            resolution_on_time: on_time_resolutions,
+            resolution_on_time_rate: resolved.count > 0 ? (on_time_resolutions.to_f / resolved.count * 100).round(1) : 0
+          }
+        end
+
+        private
+
+        def find_policy_for(ticket)
+          if ticket.department&.default_sla_policy_id.present?
+            Escalated::SlaPolicy.find_by(id: ticket.department.default_sla_policy_id)
+          else
+            Escalated::SlaPolicy.default_policy.first
+          end
+        end
+
+        def mark_breached(ticket, breach_type)
+          ActiveRecord::Base.transaction do
+            ticket.update!(sla_breached: true)
+
+            ticket.activities.create!(
+              action: "sla_breached",
+              causer: nil,
+              details: { breach_type: breach_type.to_s }
+            )
+          end
+
+          if Escalated.configuration.notification_channels.include?(:email)
+            Escalated::TicketMailer.sla_breach(ticket).deliver_later
+          end
+
+          NotificationService.dispatch(:sla_breached, ticket: ticket, breach_type: breach_type)
+
+          ActiveSupport::Notifications.instrument("escalated.sla.breached", {
+            ticket: ticket,
+            breach_type: breach_type
+          })
+        end
+
+        def calculate_business_hours_due_date(hours)
+          bh = Escalated.configuration.business_hours
+          start_hour = bh[:start] || 9
+          end_hour = bh[:end] || 17
+          working_days = bh[:working_days] || [1, 2, 3, 4, 5]
+          tz = bh[:timezone] || "UTC"
+
+          current_time = Time.current.in_time_zone(tz)
+          remaining_hours = hours.to_f
+
+          while remaining_hours > 0
+            if working_days.include?(current_time.wday)
+              day_start = current_time.change(hour: start_hour, min: 0, sec: 0)
+              day_end = current_time.change(hour: end_hour, min: 0, sec: 0)
+
+              current_time = day_start if current_time < day_start
+
+              if current_time < day_end
+                available_hours = (day_end - current_time) / 3600.0
+
+                if remaining_hours <= available_hours
+                  return current_time + remaining_hours.hours
+                else
+                  remaining_hours -= available_hours
+                end
+              end
+            end
+
+            current_time = (current_time + 1.day).change(hour: start_hour, min: 0, sec: 0)
+          end
+
+          current_time
+        end
+      end
+    end
+  end
+end

data/lib/escalated/services/ticket_service.rb

@@ -0,0 +1,113 @@
+module Escalated
+  module Services
+    class TicketService
+      class << self
+        def create(params)
+          ticket = driver.create_ticket(params)
+
+          if Escalated.configuration.notification_channels.include?(:email)
+            Escalated::TicketMailer.new_ticket(ticket).deliver_later
+          end
+
+          Services::NotificationService.dispatch(:ticket_created, ticket: ticket)
+
+          ticket
+        end
+
+        def update(ticket, params, actor:)
+          driver.update_ticket(ticket, params, actor: actor)
+        end
+
+        def transition_status(ticket, new_status, actor:, note: nil)
+          result = driver.transition_status(ticket, new_status, actor: actor, note: note)
+
+          if Escalated.configuration.notification_channels.include?(:email)
+            Escalated::TicketMailer.status_changed(result).deliver_later
+          end
+
+          if new_status.to_s == "resolved"
+            Escalated::TicketMailer.ticket_resolved(result).deliver_later if Escalated.configuration.notification_channels.include?(:email)
+          end
+
+          Services::NotificationService.dispatch(:status_changed, ticket: result, status: new_status)
+
+          result
+        end
+
+        def assign(ticket, agent, actor:)
+          result = driver.assign_ticket(ticket, agent, actor: actor)
+
+          if Escalated.configuration.notification_channels.include?(:email)
+            Escalated::TicketMailer.ticket_assigned(result).deliver_later
+          end
+
+          Services::NotificationService.dispatch(:ticket_assigned, ticket: result, agent: agent)
+
+          result
+        end
+
+        def unassign(ticket, actor:)
+          driver.unassign_ticket(ticket, actor: actor)
+        end
+
+        def reply(ticket, params)
+          reply = driver.add_reply(ticket, params)
+
+          if !params[:is_internal] && Escalated.configuration.notification_channels.include?(:email)
+            Escalated::TicketMailer.reply_received(ticket, reply).deliver_later
+          end
+
+          Services::NotificationService.dispatch(:reply_added, ticket: ticket, reply: reply)
+
+          reply
+        end
+
+        def find(id)
+          driver.get_ticket(id)
+        end
+
+        def list(filters = {})
+          driver.list_tickets(filters)
+        end
+
+        def add_tags(ticket, tag_ids, actor:)
+          driver.add_tags(ticket, tag_ids, actor: actor)
+        end
+
+        def remove_tags(ticket, tag_ids, actor:)
+          driver.remove_tags(ticket, tag_ids, actor: actor)
+        end
+
+        def change_department(ticket, department, actor:)
+          driver.change_department(ticket, department, actor: actor)
+        end
+
+        def change_priority(ticket, new_priority, actor:)
+          result = driver.change_priority(ticket, new_priority, actor: actor)
+
+          Services::NotificationService.dispatch(:priority_changed, ticket: result, priority: new_priority)
+
+          result
+        end
+
+        def close(ticket, actor:)
+          transition_status(ticket, :closed, actor: actor)
+        end
+
+        def reopen(ticket, actor:)
+          transition_status(ticket, :reopened, actor: actor)
+        end
+
+        def resolve(ticket, actor:)
+          transition_status(ticket, :resolved, actor: actor)
+        end
+
+        private
+
+        def driver
+          Escalated.driver
+        end
+      end
+    end
+  end
+end

data/lib/escalated.rb

@@ -0,0 +1,25 @@
+require "escalated/engine"
+require "escalated/configuration"
+require "escalated/manager"
+
+module Escalated
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def driver
+      Manager.driver
+    end
+
+    def table_name(name)
+      "#{configuration.table_prefix}#{name}"
+    end
+  end
+end

data/lib/generators/escalated/install_generator.rb

@@ -0,0 +1,75 @@
+require "rails/generators"
+require "rails/generators/migration"
+
+module Escalated
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Installs the Escalated support ticket system"
+
+      def self.next_migration_number(dirname)
+        Time.now.strftime("%Y%m%d%H%M%S")
+      end
+
+      def copy_initializer
+        template "initializer.rb", "config/initializers/escalated.rb"
+        say_status :create, "config/initializers/escalated.rb", :green
+      end
+
+      def copy_migrations
+        rake "escalated:install:migrations"
+        say_status :info, "Copied migrations. Run `rails db:migrate` to apply.", :yellow
+      end
+
+      def add_user_concern
+        inject_into_file(
+          "app/models/user.rb",
+          after: "class User < ApplicationRecord\n"
+        ) do
+          <<-RUBY
+  # Escalated support system role methods
+  # Customize these methods to match your authorization system
+  def escalated_agent?
+    # Return true if this user is a support agent
+    respond_to?(:role) && %w[agent admin].include?(role)
+  end
+
+  def escalated_admin?
+    # Return true if this user is a support admin
+    respond_to?(:role) && role == "admin"
+  end
+
+  def self.escalated_agents
+    # Return a scope of all support agents
+    where(role: %w[agent admin])
+  end
+
+          RUBY
+        end
+        say_status :inject, "app/models/user.rb (Escalated role methods)", :green
+      rescue StandardError => e
+        say_status :skip, "Could not inject into User model: #{e.message}", :yellow
+        say "  Add these methods to your User model manually:"
+        say "    escalated_agent? - returns true for support agents"
+        say "    escalated_admin? - returns true for support admins"
+        say "    self.escalated_agents - scope returning all agents"
+      end
+
+      def show_post_install
+        say ""
+        say "Escalated installed successfully!", :green
+        say ""
+        say "Next steps:"
+        say "  1. Run `rails db:migrate`"
+        say "  2. Configure config/initializers/escalated.rb"
+        say "  3. Add escalated_agent? and escalated_admin? methods to your User model"
+        say "  4. Install Vue components: copy from vendor/escalated/resources/js/"
+        say "  5. Set up your Inertia page resolver to include Escalated pages"
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/escalated/templates/initializer.rb

@@ -0,0 +1,89 @@
+Escalated.configure do |config|
+  # ============================================================
+  # Hosting Mode
+  # ============================================================
+  # :self_hosted  - All data in your local database (default)
+  # :synced       - Local database + cloud sync
+  # :cloud        - All data proxied to Escalated Cloud
+  config.mode = :self_hosted
+
+  # ============================================================
+  # User Configuration
+  # ============================================================
+  # Your application's user model class name
+  config.user_class = "User"
+
+  # ============================================================
+  # Database
+  # ============================================================
+  # Prefix for all Escalated database tables
+  config.table_prefix = "escalated_"
+
+  # ============================================================
+  # Routing
+  # ============================================================
+  # URL prefix for Escalated routes (e.g., /support/tickets)
+  config.route_prefix = "support"
+
+  # ============================================================
+  # Authentication & Authorization
+  # ============================================================
+  # Middleware applied to all Escalated routes
+  config.middleware = [:authenticate_user!]
+
+  # Additional middleware for admin routes (nil = same as middleware)
+  config.admin_middleware = nil
+
+  # ============================================================
+  # Ticket Settings
+  # ============================================================
+  # Allow customers to close their own tickets
+  config.allow_customer_close = true
+
+  # Automatically close resolved tickets after N days (nil to disable)
+  config.auto_close_resolved_after_days = 7
+
+  # Default priority for new tickets
+  config.default_priority = :medium
+
+  # ============================================================
+  # Attachments
+  # ============================================================
+  # Maximum number of attachments per ticket/reply
+  config.max_attachments = 5
+
+  # Maximum file size in KB (10 MB default)
+  config.max_attachment_size_kb = 10_240
+
+  # ActiveStorage service to use (:local, :amazon, :google, etc.)
+  config.storage_service = :local
+
+  # ============================================================
+  # SLA Configuration
+  # ============================================================
+  config.sla = {
+    enabled: true,
+    business_hours_only: true,
+    business_hours: {
+      start: 9,
+      end: 17,
+      timezone: "UTC",
+      working_days: [1, 2, 3, 4, 5]  # Monday through Friday
+    }
+  }
+
+  # ============================================================
+  # Notifications
+  # ============================================================
+  # Available channels: :email
+  config.notification_channels = [:email]
+
+  # Webhook URL for external integrations (nil to disable)
+  config.webhook_url = nil
+
+  # ============================================================
+  # Cloud Configuration (only for :synced and :cloud modes)
+  # ============================================================
+  # config.hosted_api_url = "https://cloud.escalated.dev/api/v1"
+  # config.hosted_api_key = ENV["ESCALATED_API_KEY"]
+end