escalated 0.4.0

data/app/controllers/escalated/admin/escalation_rules_controller.rb

@@ -0,0 +1,121 @@
+module Escalated
+  module Admin
+    class EscalationRulesController < Escalated::ApplicationController
+      before_action :require_admin!
+      before_action :set_rule, only: [:show, :edit, :update, :destroy]
+
+      def index
+        rules = Escalated::EscalationRule.ordered
+
+        render inertia: "Escalated/Admin/EscalationRules/Index", props: {
+          escalation_rules: rules.map { |r| rule_json(r) }
+        }
+      end
+
+      def new
+        render inertia: "Escalated/Admin/EscalationRules/Form", props: {
+          escalation_rule: nil,
+          departments: Escalated::Department.active.ordered.map { |d| { id: d.id, name: d.name } },
+          agents: agent_list,
+          statuses: Escalated::Ticket.statuses.keys,
+          priorities: Escalated::Ticket.priorities.keys
+        }
+      end
+
+      def create
+        rule = Escalated::EscalationRule.new(rule_params)
+
+        if rule.save
+          redirect_to admin_escalation_rule_path(rule), notice: "Escalation rule created."
+        else
+          redirect_back fallback_location: new_admin_escalation_rule_path,
+                        alert: rule.errors.full_messages.join(", ")
+        end
+      end
+
+      def show
+        render inertia: "Escalated/Admin/EscalationRules/Show", props: {
+          escalation_rule: rule_json(@rule)
+        }
+      end
+
+      def edit
+        render inertia: "Escalated/Admin/EscalationRules/Form", props: {
+          escalation_rule: rule_json(@rule),
+          departments: Escalated::Department.active.ordered.map { |d| { id: d.id, name: d.name } },
+          agents: agent_list,
+          statuses: Escalated::Ticket.statuses.keys,
+          priorities: Escalated::Ticket.priorities.keys
+        }
+      end
+
+      def update
+        if @rule.update(rule_params)
+          redirect_to admin_escalation_rule_path(@rule), notice: "Escalation rule updated."
+        else
+          redirect_back fallback_location: edit_admin_escalation_rule_path(@rule),
+                        alert: @rule.errors.full_messages.join(", ")
+        end
+      end
+
+      def destroy
+        @rule.destroy!
+        redirect_to admin_escalation_rules_path, notice: "Escalation rule deleted."
+      end
+
+      private
+
+      def set_rule
+        @rule = Escalated::EscalationRule.find(params[:id])
+      end
+
+      def rule_params
+        params.require(:escalation_rule).permit(
+          :name, :description, :is_active, :priority,
+          conditions: {},
+          actions: {}
+        )
+      end
+
+      def rule_json(rule)
+        {
+          id: rule.id,
+          name: rule.name,
+          description: rule.description,
+          is_active: rule.is_active,
+          priority: rule.priority,
+          conditions: rule.conditions,
+          actions: rule.actions,
+          created_at: rule.created_at&.iso8601,
+          updated_at: rule.updated_at&.iso8601
+        }
+      end
+
+      def agent_list
+        if Escalated.configuration.user_model.respond_to?(:escalated_agents)
+          Escalated.configuration.user_model.escalated_agents.map { |a|
+            { id: a.id, name: a.respond_to?(:name) ? a.name : a.email, email: a.email }
+          }
+        else
+          []
+        end
+      end
+
+      def admin_escalation_rule_path(rule)
+        escalated.admin_escalation_rule_path(rule)
+      end
+
+      def new_admin_escalation_rule_path
+        escalated.new_admin_escalation_rule_path
+      end
+
+      def edit_admin_escalation_rule_path(rule)
+        escalated.edit_admin_escalation_rule_path(rule)
+      end
+
+      def admin_escalation_rules_path
+        escalated.admin_escalation_rules_path
+      end
+    end
+  end
+end

data/app/controllers/escalated/admin/macros_controller.rb

@@ -0,0 +1,73 @@
+module Escalated
+  module Admin
+    class MacrosController < Escalated::ApplicationController
+      before_action :require_admin!
+      before_action :set_macro, only: [:update, :destroy]
+
+      def index
+        macros = Escalated::Macro.ordered
+
+        render inertia: "Escalated/Admin/Macros/Index", props: {
+          macros: macros.map { |m| macro_json(m) }
+        }
+      end
+
+      def create
+        macro = Escalated::Macro.new(macro_params)
+        macro.created_by = escalated_current_user.id
+
+        if macro.save
+          redirect_to admin_macros_path, notice: "Macro created."
+        else
+          redirect_back fallback_location: admin_macros_path,
+                        alert: macro.errors.full_messages.join(", ")
+        end
+      end
+
+      def update
+        if @macro.update(macro_params)
+          redirect_to admin_macros_path, notice: "Macro updated."
+        else
+          redirect_back fallback_location: admin_macros_path,
+                        alert: @macro.errors.full_messages.join(", ")
+        end
+      end
+
+      def destroy
+        @macro.destroy!
+        redirect_to admin_macros_path, notice: "Macro deleted."
+      end
+
+      private
+
+      def set_macro
+        @macro = Escalated::Macro.find(params[:id])
+      end
+
+      def macro_params
+        params.require(:macro).permit(:name, :description, :is_shared, :order, actions: [:type, :value])
+      end
+
+      def macro_json(macro)
+        {
+          id: macro.id,
+          name: macro.name,
+          description: macro.description,
+          actions: macro.actions,
+          is_shared: macro.is_shared,
+          order: macro.order,
+          creator: macro.creator ? {
+            id: macro.creator.id,
+            name: macro.creator.respond_to?(:name) ? macro.creator.name : macro.creator.email
+          } : nil,
+          created_at: macro.created_at&.iso8601,
+          updated_at: macro.updated_at&.iso8601
+        }
+      end
+
+      def admin_macros_path
+        escalated.admin_macros_path
+      end
+    end
+  end
+end

data/app/controllers/escalated/admin/reports_controller.rb

@@ -0,0 +1,152 @@
+module Escalated
+  module Admin
+    class ReportsController < Escalated::ApplicationController
+      before_action :require_admin!
+
+      def index
+        period_start = parse_date(params[:from]) || 30.days.ago.beginning_of_day
+        period_end = parse_date(params[:to]) || Time.current.end_of_day
+
+        tickets_in_period = Escalated::Ticket.where(created_at: period_start..period_end)
+
+        stats = {
+          overview: {
+            total_created: tickets_in_period.count,
+            total_resolved: tickets_in_period.where.not(resolved_at: nil).count,
+            total_closed: tickets_in_period.where(status: :closed).count,
+            currently_open: Escalated::Ticket.by_open.count,
+            currently_unassigned: Escalated::Ticket.by_open.unassigned.count
+          },
+          by_status: Escalated::Ticket.statuses.keys.each_with_object({}) { |status, hash|
+            hash[status] = Escalated::Ticket.where(status: status).count
+          },
+          by_priority: Escalated::Ticket.priorities.keys.each_with_object({}) { |priority, hash|
+            hash[priority] = tickets_in_period.where(priority: priority).count
+          },
+          by_department: Escalated::Department.ordered.map { |dept|
+            {
+              id: dept.id,
+              name: dept.name,
+              total: tickets_in_period.where(department_id: dept.id).count,
+              open: Escalated::Ticket.by_open.where(department_id: dept.id).count
+            }
+          },
+          sla: Services::SlaService.stats,
+          performance: {
+            avg_first_response_hours: calculate_avg(:first_response, period_start, period_end),
+            avg_resolution_hours: calculate_avg(:resolution, period_start, period_end),
+            tickets_per_day: tickets_in_period.count.to_f / [(period_end - period_start) / 1.day, 1].max
+          },
+          trends: calculate_daily_trends(period_start, period_end),
+          top_agents: calculate_top_agents(period_start, period_end),
+          csat: calculate_csat_stats(period_start, period_end)
+        }
+
+        render inertia: "Escalated/Admin/Reports/Index", props: {
+          stats: stats,
+          filters: {
+            from: period_start.iso8601,
+            to: period_end.iso8601
+          }
+        }
+      end
+
+      private
+
+      def parse_date(value)
+        return nil unless value.present?
+
+        Time.zone.parse(value)
+      rescue ArgumentError
+        nil
+      end
+
+      def calculate_avg(type, from, to)
+        scope = Escalated::Ticket.where(created_at: from..to)
+
+        case type
+        when :first_response
+          tickets = scope.where.not(first_response_at: nil)
+          return 0 if tickets.empty?
+
+          total = tickets.sum { |t| (t.first_response_at - t.created_at).to_f }
+          (total / tickets.count / 3600.0).round(1)
+        when :resolution
+          tickets = scope.where.not(resolved_at: nil)
+          return 0 if tickets.empty?
+
+          total = tickets.sum { |t| (t.resolved_at - t.created_at).to_f }
+          (total / tickets.count / 3600.0).round(1)
+        end
+      end
+
+      def calculate_daily_trends(from, to)
+        days = ((to - from) / 1.day).ceil
+        days = [days, 90].min # Cap at 90 days
+
+        (0...days).map do |i|
+          day_start = from + i.days
+          day_end = day_start + 1.day
+
+          {
+            date: day_start.strftime("%Y-%m-%d"),
+            created: Escalated::Ticket.where(created_at: day_start..day_end).count,
+            resolved: Escalated::Ticket.where(resolved_at: day_start..day_end).count,
+            closed: Escalated::Ticket.where(closed_at: day_start..day_end).count
+          }
+        end
+      end
+
+      def calculate_top_agents(from, to)
+        resolved_counts = Escalated::Ticket
+          .where(resolved_at: from..to)
+          .where.not(assigned_to: nil)
+          .group(:assigned_to)
+          .count
+          .sort_by { |_, count| -count }
+          .first(10)
+
+        resolved_counts.map do |agent_id, count|
+          agent = Escalated.configuration.user_model.find_by(id: agent_id)
+          next unless agent
+
+          {
+            id: agent.id,
+            name: agent.respond_to?(:name) ? agent.name : agent.email,
+            resolved_count: count,
+            avg_resolution_hours: calculate_agent_avg_resolution(agent_id, from, to)
+          }
+        end.compact
+      end
+
+      def calculate_csat_stats(from, to)
+        ratings = Escalated::SatisfactionRating.where(created_at: from..to)
+
+        total = ratings.count
+        return { average: 0, total: 0, breakdown: {} } if total.zero?
+
+        average = (ratings.average(:rating).to_f).round(2)
+        breakdown = (1..5).each_with_object({}) do |star, hash|
+          hash[star] = ratings.where(rating: star).count
+        end
+
+        {
+          average: average,
+          total: total,
+          breakdown: breakdown
+        }
+      end
+
+      def calculate_agent_avg_resolution(agent_id, from, to)
+        tickets = Escalated::Ticket
+          .where(assigned_to: agent_id, resolved_at: from..to)
+          .where.not(resolved_at: nil)
+
+        return 0 if tickets.empty?
+
+        total = tickets.sum { |t| (t.resolved_at - t.created_at).to_f }
+        (total / tickets.count / 3600.0).round(1)
+      end
+    end
+  end
+end

data/app/controllers/escalated/admin/settings_controller.rb

@@ -0,0 +1,111 @@
+module Escalated
+  module Admin
+    class SettingsController < Escalated::ApplicationController
+      before_action :require_admin!
+
+      SENSITIVE_KEYS = %w[mailgun_signing_key postmark_inbound_token imap_password].freeze
+
+      def index
+        settings = Escalated::EscalatedSetting.all_as_hash
+        SENSITIVE_KEYS.each do |key|
+          settings[key] = mask_secret(settings[key]) if settings.key?(key)
+        end
+
+        render inertia: "Escalated/Admin/Settings", props: {
+          settings: settings
+        }
+      end
+
+      def update
+        # Boolean settings
+        %w[guest_tickets_enabled allow_customer_close inbound_email_enabled].each do |key|
+          value = params[key].in?(%w[1 true on]) ? "1" : "0"
+          Escalated::EscalatedSetting.set(key, value)
+        end
+
+        # Integer settings
+        %w[auto_close_resolved_after_days max_attachments_per_reply max_attachment_size_kb].each do |key|
+          raw = params[key]
+          next unless raw.present?
+
+          int_val = raw.to_i
+          Escalated::EscalatedSetting.set(key, [0, int_val].max.to_s) if int_val >= 0
+        end
+
+        # String settings
+        prefix = params[:ticket_reference_prefix].to_s.strip
+        if prefix.present? && prefix.match?(/\A[a-zA-Z0-9]+\z/) && prefix.length <= 10
+          Escalated::EscalatedSetting.set("ticket_reference_prefix", prefix)
+        end
+
+        # Inbound email settings
+        update_inbound_email_settings
+
+        redirect_to escalated.admin_settings_path, notice: "Settings updated successfully."
+      end
+
+      private
+
+      def update_inbound_email_settings
+        # Adapter selection (mailgun, postmark, ses, imap)
+        adapter = params[:inbound_email_adapter].to_s.strip.downcase
+        if adapter.present? && %w[mailgun postmark ses imap].include?(adapter)
+          Escalated::EscalatedSetting.set("inbound_email_adapter", adapter)
+        end
+
+        # Inbound email address
+        address = params[:inbound_email_address].to_s.strip
+        if address.present? && address.match?(/\A[^@\s]+@[^@\s]+\z/)
+          Escalated::EscalatedSetting.set("inbound_email_address", address)
+        elsif params.key?(:inbound_email_address) && address.blank?
+          Escalated::EscalatedSetting.set("inbound_email_address", "")
+        end
+
+        # Adapter-specific string settings (only save if present, skip masked values)
+        %w[
+          mailgun_signing_key postmark_inbound_token
+          ses_region ses_topic_arn
+          imap_host imap_username imap_password imap_mailbox
+        ].each do |key|
+          next unless params.key?(key)
+
+          raw = params[key].to_s.strip
+          next if SENSITIVE_KEYS.include?(key) && masked_value?(raw)
+
+          Escalated::EscalatedSetting.set(key, raw)
+        end
+
+        # IMAP port (integer)
+        if params[:imap_port].present?
+          port = params[:imap_port].to_i
+          Escalated::EscalatedSetting.set("imap_port", port.to_s) if port > 0 && port <= 65535
+        end
+
+        # IMAP encryption (ssl, tls, starttls, none)
+        encryption = params[:imap_encryption].to_s.strip.downcase
+        if encryption.present? && %w[ssl tls starttls none].include?(encryption)
+          Escalated::EscalatedSetting.set("imap_encryption", encryption)
+        end
+      end
+
+      def mask_secret(value)
+        return '' if value.blank?
+
+        len = value.length
+        return '*' * len if len <= 6
+
+        value[0, 3] + '*' * [len - 3, 12].min
+      end
+
+      def masked_value?(value)
+        return false if value.blank?
+
+        value.match?(/\A.{0,3}\*{3,}\z/)
+      end
+
+      def admin_settings_path
+        "/#{Escalated.configuration.route_prefix}/admin/settings"
+      end
+    end
+  end
+end

data/app/controllers/escalated/admin/sla_policies_controller.rb

@@ -0,0 +1,109 @@
+module Escalated
+  module Admin
+    class SlaPoliciesController < Escalated::ApplicationController
+      before_action :require_admin!
+      before_action :set_sla_policy, only: [:show, :edit, :update, :destroy]
+
+      def index
+        policies = Escalated::SlaPolicy.ordered
+
+        render inertia: "Escalated/Admin/SlaPolicies/Index", props: {
+          sla_policies: policies.map { |p| sla_policy_json(p) }
+        }
+      end
+
+      def new
+        render inertia: "Escalated/Admin/SlaPolicies/Form", props: {
+          sla_policy: nil,
+          priorities: Escalated::Ticket.priorities.keys
+        }
+      end
+
+      def create
+        policy = Escalated::SlaPolicy.new(sla_policy_params)
+
+        if policy.save
+          redirect_to admin_sla_policy_path(policy), notice: "SLA Policy created."
+        else
+          redirect_back fallback_location: new_admin_sla_policy_path,
+                        alert: policy.errors.full_messages.join(", ")
+        end
+      end
+
+      def show
+        render inertia: "Escalated/Admin/SlaPolicies/Show", props: {
+          sla_policy: sla_policy_json(@sla_policy),
+          targets: @sla_policy.priority_targets,
+          department_count: @sla_policy.departments.count,
+          ticket_count: @sla_policy.tickets.count
+        }
+      end
+
+      def edit
+        render inertia: "Escalated/Admin/SlaPolicies/Form", props: {
+          sla_policy: sla_policy_json(@sla_policy),
+          priorities: Escalated::Ticket.priorities.keys
+        }
+      end
+
+      def update
+        if @sla_policy.update(sla_policy_params)
+          redirect_to admin_sla_policy_path(@sla_policy), notice: "SLA Policy updated."
+        else
+          redirect_back fallback_location: edit_admin_sla_policy_path(@sla_policy),
+                        alert: @sla_policy.errors.full_messages.join(", ")
+        end
+      end
+
+      def destroy
+        @sla_policy.destroy!
+        redirect_to admin_sla_policies_path, notice: "SLA Policy deleted."
+      end
+
+      private
+
+      def set_sla_policy
+        @sla_policy = Escalated::SlaPolicy.find(params[:id])
+      end
+
+      def sla_policy_params
+        params.require(:sla_policy).permit(
+          :name, :description, :is_active, :is_default,
+          first_response_hours: {},
+          resolution_hours: {}
+        )
+      end
+
+      def sla_policy_json(policy)
+        {
+          id: policy.id,
+          name: policy.name,
+          description: policy.description,
+          is_active: policy.is_active,
+          is_default: policy.is_default,
+          first_response_hours: policy.first_response_hours,
+          resolution_hours: policy.resolution_hours,
+          targets: policy.priority_targets,
+          created_at: policy.created_at&.iso8601,
+          updated_at: policy.updated_at&.iso8601
+        }
+      end
+
+      def admin_sla_policy_path(policy)
+        escalated.admin_sla_policy_path(policy)
+      end
+
+      def new_admin_sla_policy_path
+        escalated.new_admin_sla_policy_path
+      end
+
+      def edit_admin_sla_policy_path(policy)
+        escalated.edit_admin_sla_policy_path(policy)
+      end
+
+      def admin_sla_policies_path
+        escalated.admin_sla_policies_path
+      end
+    end
+  end
+end

data/app/controllers/escalated/admin/tags_controller.rb

@@ -0,0 +1,67 @@
+module Escalated
+  module Admin
+    class TagsController < Escalated::ApplicationController
+      before_action :require_admin!
+      before_action :set_tag, only: [:update, :destroy]
+
+      def index
+        tags = Escalated::Tag.ordered
+
+        render inertia: "Escalated/Admin/Tags/Index", props: {
+          tags: tags.map { |t| tag_json(t) }
+        }
+      end
+
+      def create
+        tag = Escalated::Tag.new(tag_params)
+
+        if tag.save
+          redirect_to admin_tags_path, notice: "Tag created."
+        else
+          redirect_back fallback_location: admin_tags_path,
+                        alert: tag.errors.full_messages.join(", ")
+        end
+      end
+
+      def update
+        if @tag.update(tag_params)
+          redirect_to admin_tags_path, notice: "Tag updated."
+        else
+          redirect_back fallback_location: admin_tags_path,
+                        alert: @tag.errors.full_messages.join(", ")
+        end
+      end
+
+      def destroy
+        @tag.destroy!
+        redirect_to admin_tags_path, notice: "Tag deleted."
+      end
+
+      private
+
+      def set_tag
+        @tag = Escalated::Tag.find(params[:id])
+      end
+
+      def tag_params
+        params.require(:tag).permit(:name, :color, :description)
+      end
+
+      def tag_json(tag)
+        {
+          id: tag.id,
+          name: tag.name,
+          slug: tag.slug,
+          color: tag.color,
+          description: tag.description,
+          ticket_count: tag.ticket_count,
+          created_at: tag.created_at&.iso8601
+        }
+      end
+
+      def admin_tags_path
+        escalated.admin_tags_path
+      end
+    end
+  end
+end