avo 2.46.0 → 3.0.0.pre1

data/app/controllers/avo/associations_controller.rb

@@ -2,18 +2,18 @@ require_dependency "avo/base_controller"
 
 module Avo
   class AssociationsController < BaseController
-    before_action :set_model, only: [:show, :index, :new, :create, :destroy, :order]
-    before_action :hydrate_resource, only: [:show, :index, :new, :create, :destroy, :order]
+    before_action :set_record, only: [:show, :index, :new, :create, :destroy]
+    before_action :hydrate_resource, only: [:show, :index, :new, :create, :destroy]
     before_action :set_related_resource_name
-    before_action :set_related_resource, only: [:show, :index, :new, :create, :destroy, :order]
+    before_action :set_related_resource, only: [:show, :index, :new, :create, :destroy]
     before_action :set_related_authorization
     before_action :set_reflection_field
-    before_action :set_related_model, only: [:show, :order]
-    before_action :hydrate_related_resource, only: [:show, :index, :create, :destroy, :order]
+    before_action :set_related_record, only: [:show]
+    before_action :hydrate_related_resource, only: [:show, :index, :create, :destroy]
     before_action :set_reflection
-    before_action :set_attachment_class, only: [:show, :index, :new, :create, :destroy, :order]
-    before_action :set_attachment_resource, only: [:show, :index, :new, :create, :destroy, :order]
-    before_action :set_attachment_model, only: [:create, :destroy, :order]
+    before_action :set_attachment_class, only: [:show, :index, :new, :create, :destroy]
+    before_action :set_attachment_resource, only: [:show, :index, :new, :create, :destroy]
+    before_action :set_attachment_record, only: [:create, :destroy]
     before_action :authorize_index_action, only: :index
     before_action :authorize_attach_action, only: :new
     before_action :authorize_detach_action, only: :destroy
@@ -21,55 +21,55 @@ module Avo
     def index
       @parent_resource = @resource.dup
       @resource = @related_resource
-      @parent_model = @parent_resource.find_record(params[:id], params: params)
-      @parent_resource.hydrate(model: @parent_model)
-      association_name = BaseResource.valid_association_name(@parent_model, params[:related_name])
-      @query = @related_authorization.apply_policy @parent_model.send(association_name)
+      @parent_record = @parent_resource.find_record(params[:id], params: params)
+      @parent_resource.hydrate(record: @parent_record)
+      association_name = BaseResource.valid_association_name(@parent_record, params[:related_name])
+      @query = @related_authorization.apply_policy @parent_record.send(association_name)
       @association_field = @parent_resource.get_field params[:related_name]
 
       if @association_field.present? && @association_field.scope.present?
-        @query = Avo::Hosts::AssociationScopeHost.new(block: @association_field.scope, query: @query, parent: @parent_model).handle
+        @query = Avo::ExecutionContext.new(target: @association_field.scope, query: @query, parent: @parent_record).handle
       end
 
       super
     end
 
     def show
-      @parent_resource, @parent_model = @resource, @model
+      @parent_resource, @parent_record = @resource, @record
 
-      @resource, @model = @related_resource, @related_model
+      @resource, @record = @related_resource, @related_record
 
       super
     end
 
     def new
-      @resource.hydrate(model: @model)
+      @resource.hydrate(record: @record)
 
-      if @field.present? && !@field.searchable
+      if @field.present? && !@field.is_searchable?
         query = @related_authorization.apply_policy @attachment_class
 
         # Add the association scope to the query scope
         if @field.attach_scope.present?
-          query = Avo::Hosts::AssociationScopeHost.new(block: @field.attach_scope, query: query, parent: @model).handle
+          query = Avo::ExecutionContext.new(target: @field.attach_scope, query: query, parent: @record).handle
         end
 
-        @options = query.all.map do |model|
-          [model.send(@attachment_resource.class.title), model.id]
+        @options = query.all.map do |record|
+          [record.send(@attachment_resource.class.title), record.id]
         end
       end
     end
 
     def create
-      association_name = BaseResource.valid_association_name(@model, params[:related_name])
+      association_name = BaseResource.valid_association_name(@record, params[:related_name])
 
       if reflection_class == "HasManyReflection"
-        @model.send(association_name) << @attachment_model
+        @record.send(association_name) << @attachment_record
       else
-        @model.send("#{association_name}=", @attachment_model)
+        @record.send("#{association_name}=", @attachment_record)
       end
 
       respond_to do |format|
-        if @model.save
+        if @record.save
           format.html { redirect_back fallback_location: resource_view_response_path, notice: t("avo.attachment_class_attached", attachment_class: @related_resource.name) }
         else
           format.html { render :new }
@@ -78,12 +78,12 @@ module Avo
     end
 
     def destroy
-      association_name = BaseResource.valid_association_name(@model, params[:related_name])
+      association_name = BaseResource.valid_association_name(@record, params[:related_name])
 
       if reflection_class == "HasManyReflection"
-        @model.send(association_name).delete @attachment_model
+        @record.send(association_name).delete @attachment_record
       else
-        @model.send("#{association_name}=", nil)
+        @record.send("#{association_name}=", nil)
       end
 
       respond_to do |format|
@@ -91,17 +91,10 @@ module Avo
       end
     end
 
-    def order
-      @parent_resource = @resource.dup
-      @resource, @model = @related_resource, @related_model
-
-      super
-    end
-
     private
 
     def set_reflection
-      @reflection = @model._reflections[params[:related_name].to_s]
+      @reflection = @record._reflections[params[:related_name].to_s]
     end
 
     def set_attachment_class
@@ -109,16 +102,16 @@ module Avo
     end
 
     def set_attachment_resource
-      @attachment_resource = @field.use_resource || (App.get_resource_by_model_name @attachment_class)
+      @attachment_resource = @field.use_resource || (Avo::App.resources.get_resource_by_model_class @attachment_class)
     end
 
-    def set_attachment_model
-      @attachment_model = @related_resource.find_record attachment_id, params: params
+    def set_attachment_record
+      @attachment_record = @related_resource.find_record attachment_id, params: params
     end
 
     def set_reflection_field
       @field = @resource.get_field_definitions.find { |f| f.id == @related_resource_name.to_sym }
-      @field.hydrate(resource: @resource, model: @model, view: :new)
+      @field.hydrate(resource: @resource, record: @record, view: :new)
     rescue
     end
 
@@ -127,7 +120,7 @@ module Avo
     end
 
     def reflection_class
-      reflection = @model._reflections[params[:related_name]]
+      reflection = @record._reflections[params[:related_name]]
 
       klass = reflection.class.name.demodulize.to_s
       klass = reflection.through_reflection.class.name.demodulize.to_s if klass == "ThroughReflection"
@@ -136,7 +129,7 @@ module Avo
     end
 
     def authorize_if_defined(method)
-      @authorization.set_record(@model)
+      @authorization.set_record(@record)
 
       if @authorization.has_method?(method.to_sym)
         @authorization.authorize_action method.to_sym

data/app/controllers/avo/attachments_controller.rb

@@ -4,17 +4,17 @@ module Avo
   class AttachmentsController < ApplicationController
     before_action :set_resource_name, only: [:destroy, :create]
     before_action :set_resource, only: [:destroy, :create]
-    before_action :set_model, only: [:destroy, :create]
+    before_action :set_record, only: [:destroy, :create]
 
     def create
-      blob = ActiveStorage::Blob.create_and_upload! io: params[:file].to_io, filename: params[:filename]
-      association_name = BaseResource.valid_attachment_name(@model, params[:attachment_key])
+      blob = ActiveStorage::Blob.create_and_upload! io: params[:file], filename: params[:filename]
+      association_name = BaseResource.valid_attachment_name(@record, params[:attachment_key])
 
       if association_name.blank?
         raise ActionController::BadRequest.new("Could not find the attachment association for #{params[:attachment_key]} (check the `attachment_key` for this Trix field)")
       end
 
-      @model.send(association_name).attach blob
+      @record.send(association_name).attach blob
 
       render json: {
         url: main_app.url_for(blob),
@@ -23,31 +23,16 @@ module Avo
     end
 
     def destroy
-      if authorized_to :delete
-        attachment = ActiveStorage::Attachment.find(params[:attachment_id])
+      attachment = ActiveStorage::Attachment.find(params[:attachment_id])
+      path = resource_path(record: @record, resource: @resource)
 
-        flash[:notice] = if attachment.present?
-          @destroyed = attachment.destroy
+      if attachment.present?
+        attachment.destroy
 
-          t("avo.attachment_destroyed")
-        else
-          t("avo.failed_to_find_attachment")
-        end
+        redirect_to params[:referrer] || path, notice: t("avo.attachment_destroyed")
       else
-        flash[:notice] = t("avo.not_authorized")
+        redirect_back fallback_location: path, notice: t("avo.failed_to_find_attachment")
       end
-
-      respond_to do |format|
-        format.turbo_stream do
-          render "destroy"
-        end
-      end
-    end
-
-    private
-
-    def authorized_to(action)
-      @resource.authorization.authorize_action("#{action}_#{params[:attachment_name]}?", record: @model, raise_exception: false)
     end
   end
 end

data/app/controllers/avo/base_controller.rb

@@ -8,12 +8,12 @@ module Avo
     before_action :set_resource
     before_action :hydrate_resource
     before_action :set_applied_filters, only: :index
-    before_action :set_model, only: [:show, :edit, :destroy, :update, :order]
-    before_action :set_model_to_fill
+    before_action :set_record, only: [:show, :edit, :destroy, :update, :preview]
+    before_action :set_record_to_fill
     before_action :set_edit_title_and_breadcrumbs, only: [:edit, :update]
-    before_action :fill_model, only: [:create, :update]
+    before_action :fill_record, only: [:create, :update]
     # Don't run base authorizations for associations
-    before_action :authorize_base_action, if: -> { controller_name != "associations" }
+    before_action :authorize_base_action, except: :preview, if: -> { controller_name != "associations" }
     before_action :set_pagy_locale, only: :index
 
     def index
@@ -65,57 +65,73 @@ module Avo
         ).apply_query request, @query, filter_value
       end
 
-      apply_pagination
+      extra_pagy_params = {}
 
-      # Create resources for each model
-      @resources = @models.map do |model|
-        @resource.hydrate(model: model, params: params).dup
+      # Reset open filters when a user navigates to a new page
+      extra_pagy_params[:keep_filters_panel_open] = if params[:keep_filters_panel_open] == "1"
+        "0"
+      end
+
+      safe_call :set_and_apply_scopes
+
+      if Avo.avo_filters_installed? && params[AvoFilters.configuration.param_key].present?
+        # Apply dynamic filters
+        query_builder = AvoFilters::QueryBuilder.new(resource: @resource, params: params, query: @query)
+        @query = @query.ransack(**query_builder.ransack_query)
+      end
+
+      pagy_query = if @query.instance_of?(Ransack::Search)
+        @query.result(distinct: false)
+      else
+        @query
+      end
+
+      @pagy, @records = pagy(pagy_query, items: @index_params[:per_page], link_extra: "data-turbo-frame=\"#{params[:turbo_frame]}\"", size: [1, 2, 2, 1], params: extra_pagy_params)
+
+      # Create resources for each record
+      @resources = @records.map do |record|
+        @resource.hydrate(record: record, params: params).dup
       end
     end
 
     def show
-      @resource.hydrate(model: @model, view: :show, user: _current_user, params: params)
+      @resource.hydrate(record: @record, view: :show, user: _current_user, params: params)
 
       set_actions
 
       @page_title = @resource.default_panel_name.to_s
 
       # If we're accessing this resource via another resource add the parent to the breadcrumbs.
-      if params[:via_resource_class].present? && params[:via_resource_id].present?
-        via_resource = Avo::App.get_resource(params[:via_resource_class]).dup
-        via_model = via_resource.find_record params[:via_resource_id], params: params
-        via_resource.hydrate model: via_model
+      if params[:via_resource_class].present? && params[:via_record_id].present?
+        via_resource = Avo::App.resources.get_resource(params[:via_resource_class]).dup
+        via_record = via_resource.find_record params[:via_record_id], params: params
+        via_resource.hydrate record: via_record
 
         add_breadcrumb via_resource.plural_name, resources_path(resource: via_resource)
-        add_breadcrumb via_resource.model_title, resource_path(model: via_model, resource: via_resource)
+        add_breadcrumb via_resource.record_title, resource_path(record: via_record, resource: via_resource)
       else
         add_breadcrumb @resource.plural_name.humanize, resources_path(resource: @resource)
       end
 
-      add_breadcrumb @resource.model_title
+      add_breadcrumb @resource.record_title
       add_breadcrumb I18n.t("avo.details").upcase_first
     end
 
     def new
-      @model = @resource.model_class.new
-      @resource = @resource.hydrate(model: @model, view: :new, user: _current_user)
-
-      # Handle special cases when creating a new record via a belongs_to relationship
-      if params[:via_belongs_to_resource_class].present?
-        return render turbo_stream: turbo_stream.append('attach_modal', partial: 'avo/base/new_via_belongs_to')
-      end
+      @record = @resource.model_class.new
+      @resource = @resource.hydrate(record: @record, view: :new, user: _current_user)
 
       set_actions
 
       @page_title = @resource.default_panel_name.to_s
 
       if is_associated_record?
-        via_resource = Avo::App.get_resource_by_model_name(params[:via_relation_class]).dup
-        via_model = via_resource.find_record params[:via_resource_id], params: params
-        via_resource.hydrate model: via_model
+        via_resource = Avo::App.resources.get_resource_by_model_class(params[:via_relation_class]).dup
+        via_record = via_resource.find_record params[:via_record_id], params: params
+        via_resource.hydrate record: via_record
 
         add_breadcrumb via_resource.plural_name, resources_path(resource: via_resource)
-        add_breadcrumb via_resource.model_title, resource_path(model: via_model, resource: via_resource)
+        add_breadcrumb via_resource.record_title, resource_path(record: via_record, resource: via_resource)
       end
 
       add_breadcrumb @resource.plural_name.humanize, resources_path(resource: @resource)
@@ -123,38 +139,33 @@ module Avo
     end
 
     def create
-      # model gets instantiated and filled in the fill_model method
-      saved = save_model
-      @resource.hydrate(model: @model, view: :new, user: _current_user)
+      # record gets instantiated and filled in the fill_record method
+      saved = save_record
+      @resource.hydrate(record: @record, view: :new, user: _current_user)
 
       # This means that the record has been created through another parent record and we need to attach it somehow.
-      if params[:via_resource_id].present? && params[:via_belongs_to_resource_class].nil?
-        @reflection = @model._reflections[params[:via_relation]]
+      if params[:via_record_id].present?
+        @reflection = @record._reflections[params[:via_relation]]
         # Figure out what kind of association does the record have with the parent record
 
         # Fills in the required infor for belongs_to and has_many
         # Get the foreign key and set it to the id we received in the params
         if @reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection) || @reflection.is_a?(ActiveRecord::Reflection::HasManyReflection)
-          related_resource = Avo::App.get_resource_by_model_name params[:via_relation_class]
-          related_record = related_resource.find_record params[:via_resource_id], params: params
+          related_resource = Avo::App.resources.get_resource_by_model_class params[:via_relation_class]
+          related_record = related_resource.find_record params[:via_record_id], params: params
 
-          @model.send("#{@reflection.foreign_key}=", related_record.id)
-          @model.save
+          @record.send("#{@reflection.foreign_key}=", related_record.id)
+          @record.save
         end
 
         # For when working with has_one, has_one_through, has_many_through, has_and_belongs_to_many, polymorphic
         if @reflection.is_a? ActiveRecord::Reflection::ThroughReflection
           # find the record
-          via_resource = ::Avo::App.get_resource_by_model_name(params[:via_relation_class]).dup
-          @related_record = via_resource.find_record params[:via_resource_id], params: params
-          association_name = BaseResource.valid_association_name(@model, params[:via_relation])
-
-          if params[:via_association_type] == "has_one"
-            # On has_one scenarios we should switch the @record and @related_record
-            @related_record.send("#{@reflection.parent_reflection.inverse_of.name}=", @model)
-          else
-            @model.send(association_name) << @related_record
-          end
+          via_resource = ::Avo::App.resources.get_resource_by_model_class(params[:via_relation_class]).dup
+          @related_record = via_resource.find_record params[:via_record_id], params: params
+          association_name = BaseResource.valid_association_name(@record, params[:via_relation])
+
+          @record.send(association_name) << @related_record
         end
       end
 
@@ -174,9 +185,9 @@ module Avo
     end
 
     def update
-      # model gets instantiated and filled in the fill_model method
-      saved = save_model
-      @resource = @resource.hydrate(model: @model, view: :edit, user: _current_user)
+      # record gets instantiated and filled in the fill_record method
+      saved = save_record
+      @resource = @resource.hydrate(record: @record, view: :edit, user: _current_user)
       set_actions
 
       if saved
@@ -194,55 +205,38 @@ module Avo
       end
     end
 
-    def order
-      direction = params[:direction].to_sym
+    def preview
+      @resource.hydrate(record: @record, view: :show, user: _current_user, params: params)
 
-      if direction.present?
-        @resource
-          .hydrate(model: @model, params: params)
-          .ordering_host
-          .order direction
-      end
-
-      respond_to do |format|
-        format.html { redirect_to params[:referrer] || resources_path(resource: @resource) }
-      end
+      render layout: params[:turbo_frame].blank?
     end
 
     private
 
-    def save_model
+    def save_record
       perform_action_and_record_errors do
-        save_model_action
+        @record.save!
       end
     end
 
-    def save_model_action
-      @model.save!
-    end
-
     def destroy_model
       perform_action_and_record_errors do
-        destroy_model_action
+        @record.destroy!
       end
     end
 
-    def destroy_model_action
-      @model.destroy!
-    end
-
     def perform_action_and_record_errors(&block)
       begin
         succeeded = block.call
       rescue => exception
-        # In case there's an error somewhere else than the model
+        # In case there's an error somewhere else than the record
         # Example: When you save a license that should create a user for it and creating that user throws and error.
         # Example: When you Try to delete a record and has a foreign key constraint.
         exception_message = exception.message
       end
 
-      # Add the errors from the model
-      @errors = @model.errors.full_messages.reject { |error| exception_message.include? error }.unshift exception_message
+      # Add the errors from the record
+      @errors = @record.errors.full_messages.reject { |error| exception_message.include? error }.unshift exception_message
 
       succeeded
     end
@@ -259,7 +253,7 @@ module Avo
     end
 
     def permitted_params
-      @resource.get_field_definitions.select(&:updatable).map(&:to_permitted_param).concat(extra_params).uniq
+      @resource.get_field_definitions.select(&:updatable).map(&:to_permitted_param).concat extra_params
     end
 
     def extra_params
@@ -300,7 +294,7 @@ module Avo
         @index_params[:per_page] = cookies[:per_page]
       end
 
-      if @parent_model.present?
+      if @parent_record.present?
         @index_params[:per_page] = Avo.configuration.via_per_page
       end
 
@@ -338,7 +332,7 @@ module Avo
       @actions = @resource
         .get_actions
         .map do |action|
-          action[:class].new(model: @model, resource: @resource, view: @view, arguments: action[:arguments])
+          action[:class].new(record: @record, resource: @resource, view: @view, arguments: action[:arguments])
         end
         .select do |action|
           action.visible_in_view(parent_resource: @parent_resource)
@@ -392,45 +386,41 @@ module Avo
     end
 
     def set_edit_title_and_breadcrumbs
-      @resource = @resource.hydrate(model: @model, view: :edit, user: _current_user)
+      @resource = @resource.hydrate(record: @record, view: :edit, user: _current_user)
       @page_title = @resource.default_panel_name.to_s
 
       last_crumb_args = {}
       # If we're accessing this resource via another resource add the parent to the breadcrumbs.
-      if params[:via_resource_class].present? && params[:via_resource_id].present?
-        via_resource = Avo::App.get_resource(params[:via_resource_class]).dup
-        via_model = via_resource.find_record params[:via_resource_id], params: params
-        via_resource.hydrate model: via_model
+      if params[:via_resource_class].present? && params[:via_record_id].present?
+        via_resource = Avo::App.resources.get_resource(params[:via_resource_class]).dup
+        via_record = via_resource.find_record params[:via_record_id], params: params
+        via_resource.hydrate record: via_record
 
         add_breadcrumb via_resource.plural_name, resources_path(resource: @resource)
-        add_breadcrumb via_resource.model_title, resource_path(model: via_model, resource: via_resource)
+        add_breadcrumb via_resource.record_title, resource_path(record: via_record, resource: via_resource)
 
         last_crumb_args = {
           via_resource_class: params[:via_resource_class],
-          via_resource_id: params[:via_resource_id]
+          via_record_id: params[:via_record_id]
         }
       else
         add_breadcrumb @resource.plural_name.humanize, resources_path(resource: @resource)
       end
 
-      add_breadcrumb @resource.model_title, resource_path(model: @resource.model, resource: @resource, **last_crumb_args)
+      add_breadcrumb @resource.record_title, resource_path(record: @resource.record, resource: @resource, **last_crumb_args)
       add_breadcrumb t("avo.edit").humanize
     end
 
     def create_success_action
-      return render "close_modal_and_reload_field" if params[:via_belongs_to_resource_class].present?
-
       respond_to do |format|
         format.html { redirect_to after_create_path, notice: create_success_message}
       end
     end
 
     def create_fail_action
-      flash.now[:error] = create_fail_message
-
       respond_to do |format|
+        flash.now[:error] = create_fail_message
         format.html { render :new, status: :unprocessable_entity }
-        format.turbo_stream { render "create_fail_action" }
       end
     end
 
@@ -445,13 +435,13 @@ module Avo
     def after_create_path
       # If this is an associated record return to the association show page
       if is_associated_record?
-        parent_resource = ::Avo::App.get_resource_by_model_name(params[:via_relation_class]).dup
-        association_name = BaseResource.valid_association_name(@model, params[:via_relation])
+        parent_resource = ::Avo::App.resources.get_resource_by_model_class(params[:via_relation_class]).dup
+        association_name = BaseResource.valid_association_name(@record, params[:via_relation])
 
         return resource_view_path(
-          model: @model.send(association_name),
+          record: @record.send(association_name),
           resource: parent_resource,
-          resource_id: params[:via_resource_id]
+          resource_id: params[:via_record_id]
         )
       end
 
@@ -487,7 +477,7 @@ module Avo
 
     # Needs a different name, otwherwise, in some places, this can be called instead helpers.resource_view_path
     def resource_view_response_path
-      helpers.resource_view_path(model: @model, resource: @resource)
+      helpers.resource_view_path(record: @record, resource: @resource)
     end
 
     def destroy_success_action
@@ -497,10 +487,8 @@ module Avo
     end
 
     def destroy_fail_action
-      flash[:error] = destroy_fail_message
-
       respond_to do |format|
-        format.turbo_stream { render partial: "avo/partials/flash_alerts" }
+        format.html { redirect_back fallback_location: params[:referrer] || resources_path(resource: @resource, turbo_frame: params[:turbo_frame], view_type: params[:view_type]), error: destroy_fail_message }
       end
     end
 
@@ -522,14 +510,14 @@ module Avo
       if @resource.class.send(action) == :index
         resources_path(resource: @resource)
       elsif @resource.class.send(action) == :edit || Avo.configuration.resource_default_view == :edit
-        edit_resource_path(resource: @resource, model: @resource.model)
+        edit_resource_path(resource: @resource, record: @resource.record)
       else
-        resource_path(model: @model, resource: @resource)
+        resource_path(record: @record, resource: @resource)
       end
     end
 
     def is_associated_record?
-      params[:via_relation_class].present? && params[:via_resource_id].present?
+      params[:via_relation_class].present? && params[:via_record_id].present?
     end
 
     # Set pagy locale from params or from avo configuration, if both nil locale = "en"
@@ -537,8 +525,8 @@ module Avo
       @pagy_locale = locale.to_s || Avo.configuration.locale || "en"
     end
 
-    def apply_pagination
-      @pagy, @models = @resource.apply_pagination(index_params: @index_params, query: @query)
+    def safe_call(method)
+      send(method) if respond_to?(method, true)
     end
   end
 end

data/app/controllers/avo/debug_controller.rb

@@ -2,7 +2,19 @@ require_dependency "avo/application_controller"
 
 module Avo
   class DebugController < ApplicationController
-    def index
+    def status
+    end
+
+    def send_to_hq
+      url = "#{ENV["HQ_URL"]}/api/v3/debug_requests"
+      timeout = 10 # seconds
+      license_key = Avo::Services::DebugService.debug_report(request)[:hq_payload][:license_key]
+      body = params[:body]
+      body = {license_key: license_key, body: body, payload: Avo::Services::DebugService.debug_report(request).to_json}.to_json
+
+      HTTParty.post url, body: body, headers: {"Content-Type": "application/json"}, timeout: timeout
+
+      render turbo_stream: turbo_stream.replace(:send_to_hq, plain: "Payload sent to Avo HQ.")
     end
 
     def report
@@ -13,13 +25,13 @@ module Avo
 
       if license.valid?
         flash[:notice] = "avohq.io responded: \"#{license.id.humanize} license is valid\"."
-      elsif license.response['reason'].present?
-        flash[:error] = "avohq.io responded: \"#{license.response['reason']}\"."
+      elsif license.response["reason"].present?
+        flash[:error] = "avohq.io responded: \"#{license.response["reason"]}\"."
       else
-        flash[:error] = license.response['error']
+        flash[:error] = license.response["error"]
       end
 
-      redirect_back fallback_location: avo.avo_private_debug_index_path
+      redirect_back fallback_location: avo.avo_private_status_path
     end
   end
 end