avo 2.43.0 → 3.0.2

data/config/routes.rb

@@ -4,23 +4,19 @@ Avo::Engine.routes.draw do
   get "resources", to: redirect(Avo.configuration.root_path)
   get "dashboards", to: redirect(Avo.configuration.root_path)
 
-  post "/rails/active_storage/direct_uploads", to: "/active_storage/direct_uploads#create"
-
-  resources :dashboards do
-    resources :cards, controller: "dashboards/cards"
+  # Mount Avo engines routes by default but leave it configurable in case the user wants to nest these under a scope.
+  if Avo.configuration.mount_avo_engines
+    instance_exec(&Avo.mount_engines)
   end
 
+  post "/rails/active_storage/direct_uploads", to: "/active_storage/direct_uploads#create"
+
   scope "avo_api", as: "avo_api" do
     get "/search", to: "search#index"
     get "/:resource_name/search", to: "search#show"
     post "/resources/:resource_name/:id/attachments/", to: "attachments#create"
   end
 
-  # Records ordering
-  scope "reorder", as: "reorder" do
-    patch "/:resource_name/:id", to: "reorder#order", as: "order"
-  end
-
   get "failed_to_load", to: "home#failed_to_load"
 
   scope "resources", as: "resources" do
@@ -44,7 +40,8 @@ Avo::Engine.routes.draw do
   end
 
   scope "/avo_private", as: "avo_private" do
-    get "/debug", to: "debug#index", as: "debug_index"
+    get "/status", to: "debug#status", as: "status"
+    post "/status/send_to_hq", to: "debug#send_to_hq", as: "send_to_hq"
     get "/debug/report", to: "debug#report", as: "debug_report"
     post "/debug/refresh_license", to: "debug#refresh_license"
   end

data/db/factories.rb

@@ -9,6 +9,12 @@ FactoryBot.define do
     custom_css { ".header {\n  color: red;\n}" }
   end
 
+  trait :with_post do
+    after(:create) do |user|
+      create(:post, user_id: user.id)
+    end
+  end
+
   factory :team do
     name { Faker::Company.name }
     description { Faker::Lorem.paragraph(sentence_count: 4) }

data/lib/avo/asset_manager.rb

@@ -0,0 +1,30 @@
+module Avo
+  class AssetManager
+    include ActionView::Helpers::AssetTagHelper
+
+    attr_reader :stylesheets
+    attr_reader :javascripts
+
+    def initialize
+      @stylesheets = []
+      @javascripts = []
+    end
+
+    def reset
+      @stylesheets = []
+      @javascripts = []
+    end
+
+    def add_stylesheet(path)
+      @stylesheets.push path
+    end
+
+    def add_javascript(path)
+      @javascripts.push path
+    end
+  end
+
+  def self.asset_manager
+    @manager ||= AssetManager.new
+  end
+end

data/lib/avo/base_action.rb

@@ -1,37 +1,38 @@
 module Avo
   class BaseAction
-    include Avo::Concerns::HasFields
+    include Avo::Concerns::HasItems
 
     class_attribute :name, default: nil
     class_attribute :message
     class_attribute :confirm_button_label
     class_attribute :cancel_button_label
     class_attribute :no_confirmation, default: false
-    class_attribute :model
-    class_attribute :view
-    class_attribute :user
-    class_attribute :resource
     class_attribute :standalone, default: false
     class_attribute :visible
     class_attribute :may_download_file, default: false
     class_attribute :turbo
+    class_attribute :authorize, default: true
 
+    attr_accessor :view
     attr_accessor :response
-    attr_accessor :model
+    attr_accessor :record
     attr_accessor :resource
     attr_accessor :user
     attr_reader :arguments
 
-    delegate :view, to: :class
-    delegate :context, to: ::Avo::App
-    delegate :current_user, to: ::Avo::App
-    delegate :params, to: ::Avo::App
-    delegate :view_context, to: ::Avo::App
+    # TODO: find a differnet way to delegate this to the uninitialized Current variable
+    delegate :context, to: Avo::Current
+    def current_user
+      Avo::Current.user
+    end
+    delegate :params, to: Avo::Current
+    delegate :view_context, to: Avo::Current
     delegate :avo, to: :view_context
     delegate :main_app, to: :view_context
+    delegate :to_param, to: :class
 
     class << self
-      delegate :context, to: ::Avo::App
+      delegate :context, to: ::Avo::Current
 
       def form_data_attributes
         # We can't respond with a file download from Turbo se we disable it on the form
@@ -50,6 +51,23 @@ module Avo
           {}
         end
       end
+
+      def to_param
+        to_s
+      end
+
+      def link_arguments(resource:, **args)
+        path = Avo::Services::URIService.parse(resource.record.present? ? resource.record_path : resource.records_path)
+          .append_paths("actions")
+          .append_query(action_id: to_param, **args)
+          .to_s
+
+        data = {
+          turbo_frame: "actions_show",
+        }
+
+        [path, data]
+      end
     end
 
     def action_name
@@ -58,114 +76,101 @@ module Avo
       self.class.to_s.demodulize.underscore.humanize(keep_id_suffix: true)
     end
 
-    def initialize(model: nil, resource: nil, user: nil, view: nil, arguments: {})
-      self.class.model = model
-      self.class.resource = resource
-      self.class.user = user
-      self.class.view = view
-      @arguments = arguments
+    def initialize(record: nil, resource: nil, user: nil, view: nil, arguments: {})
+      @record = record
+      @resource = resource
+      @user = user
+      @view = Avo::ViewInquirer.new(view)
+      @arguments = Avo::ExecutionContext.new(
+        target: arguments,
+        resource: resource,
+        record: record
+      ).handle.with_indifferent_access
 
       self.class.message ||= I18n.t("avo.are_you_sure_you_want_to_run_this_option")
       self.class.confirm_button_label ||= I18n.t("avo.run")
       self.class.cancel_button_label ||= I18n.t("avo.cancel")
 
+      self.items_holder = Avo::Resources::Items::Holder.new
+      fields
+
       @response ||= {}
       @response[:messages] = []
     end
 
-    def get_message
-      if self.class.message.respond_to? :call
-        Avo::Hosts::ResourceRecordHost.new(block: self.class.message, record: self.class.model, resource: self.class.resource).handle
-      else
-        self.class.message
-      end
+    # Blank method
+    def fields
     end
 
-    def get_attributes_for_action
-      get_fields.map do |field|
-        default_value = if field.default.respond_to? :call
-          Avo::Hosts::ResourceViewRecordHost.new(block: field.default, record: self.class.model, view: view, resource: self.class.resource).handle
-        else
-          field.default
-        end
-        [field.id, field.value || default_value]
-      end.to_h
+    def get_message
+      Avo::ExecutionContext.new(target: self.class.message, record: @record, resource: @resource).handle
     end
 
     def handle_action(**args)
-      models, fields, current_user, resource = args.values_at(:models, :fields, :current_user, :resource)
-      # Fetching the field definitions and not the actual fields (get_fields) because they will break if the user uses a `visible` block and adds a condition using the `params` variable. The params are different in the show method and the handle method.
-      action_fields = get_field_definitions.map { |field| [field.id, field] }.to_h
-
-      # For some fields, like belongs_to, the id and database_id differ (user vs user_id).
-      # That's why we need to fetch the database_id for when we process the action.
-      action_fields_by_database_id = action_fields.map do |id, value|
-        [value.database_id.to_sym, value]
-      end.to_h
-
-      if fields.present?
-        processed_fields = fields.to_unsafe_h.map do |name, value|
+      processed_fields = if args[:fields].present?
+        # Fetching the field definitions and not the actual fields (get_fields) because they will break if the user uses a `visible` block and adds a condition using the `params` variable. The params are different in the show method and the handle method.
+        action_fields = get_field_definitions.map do |field|
+          field.hydrate(resource: @resource)
+
+          [field.id, field]
+        end.to_h
+
+        # For some fields, like belongs_to, the id and database_id differ (user vs user_id).
+        # That's why we need to fetch the database_id for when we process the action.
+        action_fields_by_database_id = action_fields.map do |id, value|
+          [value.database_id.to_sym, value]
+        end.to_h
+
+        args[:fields].to_unsafe_h.map do |name, value|
           field = action_fields_by_database_id[name.to_sym]
 
           next if field.blank?
 
           [name, field.resolve_attribute(value)]
-        end
-
-        processed_fields = processed_fields.reject(&:blank?).to_h
+        end.reject(&:blank?).to_h
       else
-        processed_fields = {}
+        {}
       end
 
-      args = {
+      handle(
         fields: processed_fields.with_indifferent_access,
-        current_user: current_user,
-        resource: resource
-      }
-
-      args[:models] = models unless standalone
-
-      handle(**args)
+        current_user: args[:current_user],
+        resource: args[:resource],
+        records: args[:query],
+        query: args[:query]
+      )
 
       self
     end
 
     def visible_in_view(parent_resource: nil)
+      return false unless authorized?
+
       if visible.blank?
         # Hide on the :new view by default
-        return false if view == :new
+        return false if view.new?
 
         # Show on all other views
         return true
       end
 
       # Run the visible block if available
-      Avo::Hosts::VisibilityHost.new(
-        block: visible,
+      Avo::ExecutionContext.new(
+        target: visible,
         params: params,
         parent_resource: parent_resource,
-        resource: self.class.resource,
-        view: self.class.view,
+        resource: @resource,
+        view: @view,
         arguments: arguments
       ).handle
     end
 
-    def param_id
-      self.class.to_s
-    end
-
     def succeed(text)
       add_message text, :success
 
       self
     end
 
-    def fail(text)
-      Rails.logger.warn "DEPRECATION WARNING: Action fail method is deprecated in favor of error method and will be removed from Avo version 3.0.0"
-
-      error text
-    end
-
     def error(text)
       add_message text, :error
 
@@ -197,10 +202,9 @@ module Avo
       self
     end
 
-    def redirect_to(path = nil, allow_other_host: nil, status: nil, &block)
+    def redirect_to(path = nil, **args, &block)
       response[:type] = :redirect
-      response[:allow_other_host] = allow_other_host
-      response[:status] = status
+      response[:redirect_args] = args
       response[:path] = if block.present?
         block
       else
@@ -224,13 +228,11 @@ module Avo
       self
     end
 
-    # We're overriding this method to hydrate with the proper resource attribute.
-    def hydrate_fields(model: nil, view: nil)
-      fields.map do |field|
-        field.hydrate(model: @model, view: @view, resource: resource)
-      end
-
-      self
+    def authorized?
+      Avo::ExecutionContext.new(
+        target: authorize,
+        action: self
+      ).handle
     end
 
     private