escalated 0.4.0

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

@@ -0,0 +1,330 @@
+module Escalated
+  module Agent
+    class TicketsController < Escalated::ApplicationController
+      before_action :require_agent!
+      before_action :set_ticket, only: [:show, :update, :reply, :note, :assign, :status, :priority, :tags, :department, :apply_macro, :follow, :presence, :pin]
+
+      def index
+        scope = Escalated::Ticket.all.recent
+
+        scope = scope.where(status: params[:status]) if params[:status].present?
+        scope = scope.where(priority: params[:priority]) if params[:priority].present?
+        scope = scope.assigned_to(params[:assigned_to]) if params[:assigned_to].present?
+        scope = scope.where(department_id: params[:department_id]) if params[:department_id].present?
+        scope = scope.unassigned if params[:unassigned] == "true"
+        scope = scope.breached_sla if params[:sla_breached] == "true"
+        scope = scope.search(params[:search]) if params[:search].present?
+
+        # Following filter: tickets the current user follows
+        if params[:following] == "true"
+          followed_ticket_ids = Escalated::Ticket
+            .joins("INNER JOIN #{Escalated.table_name('ticket_followers')} ON #{Escalated.table_name('ticket_followers')}.ticket_id = #{Escalated.table_name('tickets')}.id")
+            .where("#{Escalated.table_name('ticket_followers')}.user_id = ?", escalated_current_user.id)
+            .pluck(:id)
+          scope = scope.where(id: followed_ticket_ids)
+        end
+
+        result = paginate(scope)
+
+        render inertia: "Escalated/Agent/TicketIndex", props: {
+          tickets: result[:data].includes(:requester, :department, :assignee, :tags).map { |t| ticket_list_json(t) },
+          meta: result[:meta],
+          filters: {
+            status: params[:status],
+            priority: params[:priority],
+            assigned_to: params[:assigned_to],
+            department_id: params[:department_id],
+            unassigned: params[:unassigned],
+            sla_breached: params[:sla_breached],
+            search: params[:search],
+            following: params[:following]
+          },
+          departments: Escalated::Department.active.ordered.map { |d| { id: d.id, name: d.name } },
+          agents: agent_list,
+          tags: Escalated::Tag.ordered.map { |t| { id: t.id, name: t.name, color: t.color } },
+          statuses: Escalated::Ticket.statuses.keys,
+          priorities: Escalated::Ticket.priorities.keys
+        }
+      end
+
+      def show
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        replies = @ticket.replies.chronological.includes(:author, :attachments)
+        activities = @ticket.activities.reverse_chronological.limit(50)
+
+        render inertia: "Escalated/Agent/TicketShow", props: {
+          ticket: ticket_detail_json(@ticket),
+          replies: replies.map { |r| reply_json(r) },
+          activities: activities.map { |a| activity_json(a) },
+          departments: Escalated::Department.active.ordered.map { |d| { id: d.id, name: d.name } },
+          agents: agent_list,
+          tags: Escalated::Tag.ordered.map { |t| { id: t.id, name: t.name, color: t.color } },
+          canned_responses: Escalated::CannedResponse.for_user(escalated_current_user.id).ordered.map { |c|
+            { id: c.id, title: c.title, body: c.body, shortcode: c.shortcode }
+          },
+          macros: Escalated::Macro.for_agent(escalated_current_user.id).ordered.map { |m|
+            { id: m.id, name: m.name, description: m.description, actions: m.actions }
+          },
+          is_following: @ticket.followed_by?(escalated_current_user.id),
+          followers_count: @ticket.followers.count,
+          statuses: Escalated::Ticket.statuses.keys,
+          priorities: Escalated::Ticket.priorities.keys
+        }
+      end
+
+      def update
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        Services::TicketService.update(@ticket, update_params, actor: escalated_current_user)
+        redirect_to agent_ticket_path(@ticket), notice: "Ticket updated."
+      end
+
+      def reply
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        reply = Services::TicketService.reply(@ticket, {
+          body: params[:body],
+          author: escalated_current_user,
+          is_internal: false
+        })
+
+        if params[:attachments].present?
+          Services::AttachmentService.attach(reply, params[:attachments])
+        end
+
+        redirect_to agent_ticket_path(@ticket), notice: "Reply sent."
+      end
+
+      def note
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        Services::TicketService.reply(@ticket, {
+          body: params[:body],
+          author: escalated_current_user,
+          is_internal: true
+        })
+
+        redirect_to agent_ticket_path(@ticket), notice: "Internal note added."
+      end
+
+      def assign
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        if params[:agent_id].present?
+          agent = Escalated.configuration.user_model.find(params[:agent_id])
+          Services::AssignmentService.assign(@ticket, agent, actor: escalated_current_user)
+          redirect_to agent_ticket_path(@ticket), notice: "Ticket assigned to #{agent.respond_to?(:name) ? agent.name : agent.email}."
+        else
+          Services::AssignmentService.unassign(@ticket, actor: escalated_current_user)
+          redirect_to agent_ticket_path(@ticket), notice: "Ticket unassigned."
+        end
+      end
+
+      def status
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        Services::TicketService.transition_status(
+          @ticket,
+          params[:status],
+          actor: escalated_current_user,
+          note: params[:note]
+        )
+
+        redirect_to agent_ticket_path(@ticket), notice: "Status updated to #{params[:status].humanize}."
+      end
+
+      def priority
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        Services::TicketService.change_priority(@ticket, params[:priority], actor: escalated_current_user)
+        redirect_to agent_ticket_path(@ticket), notice: "Priority updated to #{params[:priority]}."
+      end
+
+      def tags
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        if params[:add_tag_ids].present?
+          Services::TicketService.add_tags(@ticket, params[:add_tag_ids], actor: escalated_current_user)
+        end
+
+        if params[:remove_tag_ids].present?
+          Services::TicketService.remove_tags(@ticket, params[:remove_tag_ids], actor: escalated_current_user)
+        end
+
+        redirect_to agent_ticket_path(@ticket), notice: "Tags updated."
+      end
+
+      def department
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        dept = Escalated::Department.find(params[:department_id])
+        Services::TicketService.change_department(@ticket, dept, actor: escalated_current_user)
+        redirect_to agent_ticket_path(@ticket), notice: "Department changed to #{dept.name}."
+      end
+
+      def apply_macro
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        macro = Escalated::Macro.for_agent(escalated_current_user.id).find(params[:macro_id])
+        Services::MacroService.apply(macro, @ticket, actor: escalated_current_user)
+
+        redirect_to agent_ticket_path(@ticket), notice: "Macro \"#{macro.name}\" applied."
+      end
+
+      def follow
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        if @ticket.followed_by?(escalated_current_user.id)
+          @ticket.unfollow(escalated_current_user.id)
+          redirect_to agent_ticket_path(@ticket), notice: "Unfollowed ticket."
+        else
+          @ticket.follow(escalated_current_user.id)
+          redirect_to agent_ticket_path(@ticket), notice: "Following ticket."
+        end
+      end
+
+      def presence
+        user_id = escalated_current_user.id
+        user_name = escalated_current_user.respond_to?(:name) ? escalated_current_user.name : escalated_current_user.email
+        cache_key = "escalated.presence.#{@ticket.id}.#{user_id}"
+
+        Rails.cache.write(cache_key, { id: user_id, name: user_name }, expires_in: 30.seconds)
+
+        # Track active user IDs for this ticket
+        list_key = "escalated.presence_list.#{@ticket.id}"
+        active_ids = Rails.cache.read(list_key) || []
+        active_ids << user_id unless active_ids.include?(user_id)
+        Rails.cache.write(list_key, active_ids, expires_in: 2.minutes)
+
+        # Collect viewers (exclude current user)
+        viewers = []
+        active_ids.each do |uid|
+          next if uid == user_id
+
+          viewer = Rails.cache.read("escalated.presence.#{@ticket.id}.#{uid}")
+          viewers << viewer if viewer
+        end
+
+        render json: { viewers: viewers }
+      end
+
+      def pin
+        reply = @ticket.replies.find(params[:reply_id])
+
+        unless reply.is_internal
+          redirect_to agent_ticket_path(@ticket), alert: "Only internal notes can be pinned."
+          return
+        end
+
+        reply.update!(is_pinned: !reply.is_pinned)
+
+        redirect_to agent_ticket_path(@ticket),
+                    notice: reply.is_pinned ? "Note pinned." : "Note unpinned."
+      end
+
+      private
+
+      def set_ticket
+        @ticket = Escalated::Ticket.find_by!(reference: params[:id])
+      rescue ActiveRecord::RecordNotFound
+        @ticket = Escalated::Ticket.find(params[:id])
+      end
+
+      def update_params
+        params.require(:ticket).permit(:subject, :description)
+      end
+
+      def agent_ticket_path(ticket)
+        escalated.agent_ticket_path(ticket)
+      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 ticket_list_json(ticket)
+        {
+          id: ticket.id,
+          reference: ticket.reference,
+          subject: ticket.subject,
+          status: ticket.status,
+          priority: ticket.priority,
+          requester: {
+            name: ticket.requester.respond_to?(:name) ? ticket.requester.name : ticket.requester&.email
+          },
+          assignee: ticket.assignee ? {
+            id: ticket.assignee.id,
+            name: ticket.assignee.respond_to?(:name) ? ticket.assignee.name : ticket.assignee.email
+          } : nil,
+          department: ticket.department ? { id: ticket.department.id, name: ticket.department.name } : nil,
+          tags: ticket.tags.map { |t| { id: t.id, name: t.name, color: t.color } },
+          sla_breached: ticket.sla_breached,
+          created_at: ticket.created_at&.iso8601,
+          updated_at: ticket.updated_at&.iso8601
+        }
+      end
+
+      def ticket_detail_json(ticket)
+        ticket_list_json(ticket).merge(
+          description: ticket.description,
+          metadata: ticket.metadata,
+          sla_policy: ticket.sla_policy ? { id: ticket.sla_policy.id, name: ticket.sla_policy.name } : nil,
+          sla_first_response_due_at: ticket.sla_first_response_due_at&.iso8601,
+          sla_resolution_due_at: ticket.sla_resolution_due_at&.iso8601,
+          first_response_at: ticket.first_response_at&.iso8601,
+          resolved_at: ticket.resolved_at&.iso8601,
+          closed_at: ticket.closed_at&.iso8601,
+          reply_count: ticket.replies.count,
+          attachment_count: ticket.attachments.count,
+          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,
+          pinned_notes: ticket.pinned_notes.includes(:author).map { |n| reply_json(n) }
+        )
+      end
+
+      def reply_json(reply)
+        {
+          id: reply.id,
+          body: reply.body,
+          is_internal: reply.is_internal,
+          is_internal_note: reply.is_internal,
+          is_system: reply.is_system,
+          is_pinned: reply.respond_to?(:is_pinned) ? reply.is_pinned : false,
+          author: reply.author ? {
+            id: reply.author.id,
+            name: reply.author.respond_to?(:name) ? reply.author.name : reply.author.email,
+            is_agent: reply.author.respond_to?(:escalated_agent?) ? reply.author.escalated_agent? : false
+          } : { name: "System", is_agent: true },
+          attachments: reply.attachments.map { |a|
+            { id: a.id, filename: a.filename, size: a.human_size, content_type: a.content_type }
+          },
+          created_at: reply.created_at&.iso8601
+        }
+      end
+
+      def activity_json(activity)
+        {
+          id: activity.id,
+          action: activity.action,
+          description: activity.description,
+          causer: activity.causer ? {
+            name: activity.causer.respond_to?(:name) ? activity.causer.name : activity.causer.email
+          } : nil,
+          details: activity.details,
+          created_at: activity.created_at&.iso8601
+        }
+      end
+    end
+  end
+end

data/app/controllers/escalated/application_controller.rb

@@ -0,0 +1,110 @@
+module Escalated
+  class ApplicationController < ActionController::Base
+    include Pundit::Authorization
+
+    protect_from_forgery with: :exception
+
+    before_action :apply_middleware
+    before_action :set_inertia_shared_data
+
+    rescue_from Pundit::NotAuthorizedError, with: :user_not_authorized
+    rescue_from ActiveRecord::RecordNotFound, with: :not_found
+    rescue_from ActiveRecord::RecordInvalid, with: :unprocessable_entity
+
+    private
+
+    def apply_middleware
+      Escalated.configuration.middleware.each do |middleware_method|
+        send(middleware_method) if respond_to?(middleware_method, true)
+      end
+    end
+
+    def set_inertia_shared_data
+      inertia_share(
+        current_user: current_user_data,
+        escalated: {
+          route_prefix: Escalated.configuration.route_prefix,
+          allow_customer_close: Escalated.configuration.allow_customer_close,
+          max_attachments: Escalated.configuration.max_attachments,
+          max_attachment_size_kb: Escalated.configuration.max_attachment_size_kb,
+          guest_tickets_enabled: Escalated::EscalatedSetting.guest_tickets_enabled?
+        },
+        flash: {
+          success: flash[:success],
+          error: flash[:error],
+          notice: flash[:notice],
+          alert: flash[:alert]
+        }
+      )
+    end
+
+    def current_user_data
+      return nil unless respond_to?(:current_user) && current_user
+
+      {
+        id: current_user.id,
+        name: current_user.respond_to?(:name) ? current_user.name : current_user.email,
+        email: current_user.email,
+        is_agent: current_user.respond_to?(:escalated_agent?) ? current_user.escalated_agent? : false,
+        is_admin: current_user.respond_to?(:escalated_admin?) ? current_user.escalated_admin? : false
+      }
+    end
+
+    def escalated_current_user
+      return nil unless respond_to?(:current_user)
+
+      current_user
+    end
+
+    def require_agent!
+      unless current_user_data&.dig(:is_agent) || current_user_data&.dig(:is_admin)
+        redirect_to main_app.root_path, alert: "Access denied."
+      end
+    end
+
+    def require_admin!
+      unless current_user_data&.dig(:is_admin)
+        redirect_to main_app.root_path, alert: "Access denied."
+      end
+    end
+
+    def user_not_authorized
+      render inertia: "Escalated/Error", props: {
+        status: 403,
+        message: "You are not authorized to perform this action."
+      }, status: :forbidden
+    end
+
+    def not_found
+      render inertia: "Escalated/Error", props: {
+        status: 404,
+        message: "The requested resource was not found."
+      }, status: :not_found
+    end
+
+    def unprocessable_entity(exception)
+      redirect_back(
+        fallback_location: main_app.root_path,
+        alert: exception.record.errors.full_messages.join(", ")
+      )
+    end
+
+    def paginate(scope, per_page: 25)
+      page = (params[:page] || 1).to_i
+      per = (params[:per_page] || per_page).to_i
+
+      total = scope.count
+      records = scope.offset((page - 1) * per).limit(per)
+
+      {
+        data: records,
+        meta: {
+          current_page: page,
+          per_page: per,
+          total: total,
+          total_pages: (total.to_f / per).ceil
+        }
+      }
+    end
+  end
+end

data/app/controllers/escalated/customer/satisfaction_ratings_controller.rb

@@ -0,0 +1,44 @@
+module Escalated
+  module Customer
+    class SatisfactionRatingsController < Escalated::ApplicationController
+      before_action :set_ticket
+
+      def create
+        unless %w[resolved closed].include?(@ticket.status)
+          redirect_back fallback_location: escalated.customer_ticket_path(@ticket),
+                        alert: "You can only rate resolved or closed tickets."
+          return
+        end
+
+        if @ticket.satisfaction_rating.present?
+          redirect_back fallback_location: escalated.customer_ticket_path(@ticket),
+                        alert: "This ticket has already been rated."
+          return
+        end
+
+        rating = Escalated::SatisfactionRating.new(
+          ticket: @ticket,
+          rating: params[:rating].to_i,
+          comment: params[:comment],
+          rated_by: escalated_current_user
+        )
+
+        if rating.save
+          redirect_back fallback_location: escalated.customer_ticket_path(@ticket),
+                        notice: "Thank you for your feedback!"
+        else
+          redirect_back fallback_location: escalated.customer_ticket_path(@ticket),
+                        alert: rating.errors.full_messages.join(", ")
+        end
+      end
+
+      private
+
+      def set_ticket
+        @ticket = Escalated::Ticket.find_by!(reference: params[:id])
+      rescue ActiveRecord::RecordNotFound
+        @ticket = Escalated::Ticket.find(params[:id])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+module Escalated
+  module Customer
+    class TicketsController < Escalated::ApplicationController
+      before_action :set_ticket, only: [:show, :reply, :close, :reopen]
+
+      def index
+        scope = Escalated::Ticket.where(
+          requester: escalated_current_user
+        ).recent
+
+        scope = scope.where(status: params[:status]) if params[:status].present?
+        scope = scope.search(params[:search]) if params[:search].present?
+
+        result = paginate(scope)
+
+        render inertia: "Escalated/Customer/Index", props: {
+          tickets: result[:data].map { |t| ticket_json(t) },
+          meta: result[:meta],
+          filters: {
+            status: params[:status],
+            search: params[:search]
+          }
+        }
+      end
+
+      def create
+        render inertia: "Escalated/Customer/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
+        ticket = Services::TicketService.create(
+          subject: ticket_params[:subject],
+          description: ticket_params[:description],
+          priority: ticket_params[:priority] || Escalated.configuration.default_priority,
+          department_id: ticket_params[:department_id],
+          requester: escalated_current_user,
+          metadata: {}
+        )
+
+        if ticket_params[:attachments].present?
+          Services::AttachmentService.attach(ticket, ticket_params[:attachments])
+        end
+
+        redirect_to customer_ticket_path(ticket), notice: "Ticket created successfully."
+      rescue Services::AttachmentService::TooManyAttachmentsError,
+             Services::AttachmentService::FileTooLargeError,
+             Services::AttachmentService::InvalidFileTypeError => e
+        redirect_back fallback_location: new_customer_ticket_path, alert: e.message
+      end
+
+      def show
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        replies = @ticket.replies
+          .public_replies
+          .chronological
+          .includes(:author, :attachments)
+
+        render inertia: "Escalated/Customer/Show", props: {
+          ticket: ticket_json(@ticket),
+          replies: replies.map { |r| reply_json(r) },
+          can_close: Escalated.configuration.allow_customer_close && @ticket.open?,
+          can_reopen: %w[resolved closed].include?(@ticket.status)
+        }
+      end
+
+      def reply
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        reply = Services::TicketService.reply(@ticket, {
+          body: params[:body],
+          author: escalated_current_user,
+          is_internal: false
+        })
+
+        if params[:attachments].present?
+          Services::AttachmentService.attach(reply, params[:attachments])
+        end
+
+        redirect_to customer_ticket_path(@ticket), notice: "Reply sent."
+      rescue Services::AttachmentService::TooManyAttachmentsError,
+             Services::AttachmentService::FileTooLargeError,
+             Services::AttachmentService::InvalidFileTypeError => e
+        redirect_to customer_ticket_path(@ticket), alert: e.message
+      end
+
+      def close
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        unless Escalated.configuration.allow_customer_close
+          redirect_to customer_ticket_path(@ticket), alert: "Customers cannot close tickets."
+          return
+        end
+
+        Services::TicketService.close(@ticket, actor: escalated_current_user)
+        redirect_to customer_ticket_path(@ticket), notice: "Ticket closed."
+      end
+
+      def reopen
+        authorize @ticket, policy_class: Escalated::TicketPolicy
+
+        Services::TicketService.reopen(@ticket, actor: escalated_current_user)
+        redirect_to customer_ticket_path(@ticket), notice: "Ticket reopened."
+      end
+
+      private
+
+      def set_ticket
+        @ticket = Escalated::Ticket.find(params[:id])
+      end
+
+      def ticket_params
+        params.require(:ticket).permit(:subject, :description, :priority, :department_id, attachments: [])
+      end
+
+      def ticket_json(ticket)
+        {
+          id: ticket.id,
+          reference: ticket.reference,
+          subject: ticket.subject,
+          description: ticket.description,
+          status: ticket.status,
+          priority: ticket.priority,
+          department: ticket.department ? { id: ticket.department.id, name: ticket.department.name } : nil,
+          created_at: ticket.created_at&.iso8601,
+          updated_at: ticket.updated_at&.iso8601,
+          resolved_at: ticket.resolved_at&.iso8601,
+          reply_count: ticket.replies.public_replies.count,
+          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 reply_json(reply)
+        {
+          id: reply.id,
+          body: reply.body,
+          author: {
+            name: reply.author.respond_to?(:name) ? reply.author.name : reply.author&.email,
+            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, url: Services::AttachmentService.url_for(a) }
+          },
+          created_at: reply.created_at&.iso8601,
+          is_system: reply.is_system
+        }
+      end
+
+      def customer_ticket_path(ticket)
+        escalated.customer_ticket_path(ticket)
+      end
+
+      def new_customer_ticket_path
+        escalated.new_customer_ticket_path
+      end
+    end
+  end
+end