avo 2.49.0 → 3.0.0.beta1

data/app/controllers/avo/application_controller.rb

@@ -6,16 +6,18 @@ module Avo
       Avo::ApplicationController.include Pundit
     end
 
+    include Avo::InitializesAvo
     include Avo::ApplicationHelper
     include Avo::UrlHelpers
     include Avo::Concerns::Breadcrumbs
+    include Pagy::Backend
 
     protect_from_forgery with: :exception
     around_action :set_avo_locale
     around_action :set_force_locale, if: -> { params[:force_locale].present? }
     before_action :set_default_locale, if: -> { params[:set_locale].present? }
     before_action :init_app
-    before_action :check_avo_license
+    before_action :set_active_storage_current_host
     before_action :set_resource_name
     before_action :_authenticate!
     before_action :set_authorization
@@ -27,15 +29,9 @@ module Avo
     rescue_from Avo::NotAuthorizedError, with: :render_unauthorized
     rescue_from ActiveRecord::RecordInvalid, with: :exception_logger
 
-    helper_method :_current_user, :resources_path, :resource_path, :new_resource_path, :edit_resource_path, :resource_attach_path, :resource_detach_path, :related_resources_path, :turbo_frame_request?, :resource_view_path
+    helper_method :_current_user, :resources_path, :resource_path, :new_resource_path, :edit_resource_path, :resource_attach_path, :resource_detach_path, :related_resources_path, :turbo_frame_request?, :resource_view_path, :preview_resource_path
     add_flash_types :info, :warning, :success, :error
 
-    def init_app
-      Avo::App.init request: request, context: context, current_user: _current_user, view_context: view_context, params: params
-
-      @license = Avo::App.license
-    end
-
     def exception_logger(exception)
       respond_to do |format|
         format.html { raise exception }
@@ -49,49 +45,6 @@ module Avo
       end
     end
 
-    def render(*args)
-      raise Avo::LicenseVerificationTemperedError, "License verification mechanism tempered with." unless method(:check_avo_license).source_location.first.match?(/.*\/app\/controllers\/avo\/application_controller\.rb/)
-
-      if params[:controller] == "avo/search" && params[:action] == "index"
-        raise Avo::LicenseVerificationTemperedError, "License verification mechanism tempered with." unless method(:index).source_location.first.match?(/.*\/app\/controllers\/avo\/search_controller\.rb/)
-      end
-
-      if params[:controller] == "avo/dashboards" && params[:action] == "show"
-        raise Avo::LicenseVerificationTemperedError, "License verification mechanism tempered with." unless method(:show).source_location.first.match?(/.*\/app\/controllers\/avo\/dashboards_controller\.rb/)
-      end
-
-      if params[:controller] == "avo/dashboards" && params[:action] == "card"
-        raise Avo::LicenseVerificationTemperedError, "License verification mechanism tempered with." unless method(:card).source_location.first.match?(/.*\/app\/controllers\/avo\/dashboards_controller\.rb/)
-      end
-
-      super(*args)
-    end
-
-    def check_avo_license
-      # Check to see if the path is a custom tool
-      if on_custom_tool_page
-        if @license.lacks(:custom_tools) || @license.invalid?
-          message = "Your license is invalid or doesn't support custom tools."
-        end
-      end
-
-      # Check to see if the path is a dashboard
-      if on_dashboards_path
-        if @license.lacks(:dashboards) || @license.invalid?
-          message = "Your license is invalid or doesn't support dashboards."
-        end
-      end
-
-      if message.present?
-        if Rails.env.development? || Rails.env.test?
-          @custom_tools_alert_visible = message
-        elsif @license.lacks_with_trial(:custom_tools)
-          # Raise error in non-development environments.
-          raise Avo::LicenseInvalidError, message
-        end
-      end
-    end
-
     def _current_user
       instance_eval(&Avo.configuration.current_user)
     end
@@ -108,6 +61,49 @@ module Avo
 
     private
 
+    # Get the pluralized resource name for this request
+    # Ex: projects, teams, users
+    def resource_name
+      return params[:resource_name] if params[:resource_name].present?
+
+      return controller_name if controller_name.present?
+
+      begin
+        request.path
+          .match(/\/?#{Avo.root_path.delete('/')}\/resources\/([a-z1-9\-_]*)\/?/mi)
+          .captures
+          .first
+      rescue
+      end
+    end
+
+    def related_resource_name
+      params[:related_name]
+    end
+
+    # Gets the Avo resource for this request based on the request from the `resource_name` "param"
+    # Ex: Avo::Resources::Project, Avo::Resources::Team, Avo::Resources::User
+    def resource
+      resource = Avo.resource_manager.get_resource @resource_name.to_s.camelize.singularize
+
+      return resource if resource.present?
+
+      Avo.resource_manager.get_resource_by_controller_name @resource_name
+    end
+
+    def related_resource
+      # Find the field from the parent resource
+      field = @resource.get_field params[:related_name]
+
+      return field.use_resource if field&.use_resource.present?
+
+      reflection = @record._reflections[params[:related_name]]
+
+      reflected_model = reflection.klass
+
+      Avo.resource_manager.get_resource_by_model_class reflected_model
+    end
+
     def set_resource_name
       @resource_name = resource_name
     end
@@ -119,15 +115,28 @@ module Avo
     def set_resource
       raise ActionController::RoutingError.new "No route matches" if resource.nil?
 
-      @resource = resource.hydrate(params: params)
+      @resource = resource.new(view: action_name.to_sym, user: _current_user, params: params)
+
+      set_authorization
     end
 
     def set_related_resource
-      @related_resource = related_resource.hydrate(params: params)
+      @related_resource = related_resource.new(params: params, view: action_name.to_sym, user: _current_user, record: @related_record)
     end
 
-    def set_model
-      @model = @resource.find_record(params[:id], query: model_find_scope, params: params)
+    def set_record
+      @record = @resource.find_record(params[:id], query: model_find_scope, params: params)
+      @resource.hydrate(record: @record)
+    end
+
+    def set_related_record
+      association_name = BaseResource.valid_association_name(@record, params[:related_name])
+      @related_record = if @field.is_a? Avo::Fields::HasOneField
+        @record.send association_name
+      else
+        @related_resource.find_record params[:related_id], query: eager_load_files(@related_resource, @record.send(association_name)), params: params
+      end
+      @related_resource.hydrate(record: @related_record)
     end
 
     def model_find_scope
@@ -135,50 +144,49 @@ module Avo
     end
 
     def model_scope
+      # abort @resource.inspect
       @resource.class.find_scope
     end
 
-    def set_related_model
-      association_name = BaseResource.valid_association_name(@model, params[:related_name])
-      @related_model = if @field.is_a? Avo::Fields::HasOneField
-        @model.send association_name
-      else
-        @related_resource.find_record params[:related_id], query: eager_load_files(@related_resource, @model.send(association_name)), params: params
-      end
-    end
-
     def set_view
       @view = action_name.to_sym
     end
 
-    def set_model_to_fill
-      @model_to_fill = @resource.model_class.new if @view == :create
-      @model_to_fill = @model if @view == :update
+    def set_record_to_fill
+      @record_to_fill = @resource.model_class.new if @view == :create
+      @record_to_fill = @record if @view == :update
 
-      # If resource.model is nil, most likely the user is creating a new record.
-      # In that case, to access resource.model in visible and readonly blocks we hydrate the resource with a new model.
-      @resource.hydrate(model: @model_to_fill) if @resource.model.nil?
+      # If resource.record is nil, most likely the user is creating a new record.
+      # In that case, to access resource.record in visible and readonly blocks we hydrate the resource with a new record.
+      # TODO: commented this
+      @resource.hydrate(record: @record_to_fill) if @resource.record.nil?
     end
 
-    def fill_model
-      # We have to skip filling the the model if this is an attach action
-      is_attach_action = params[model_param_key].blank? && params[:related_name].present? && params[:fields].present?
+    def fill_record
+      # We have to skip filling the the record if this is an attach action
+      return if is_attach_action?
 
-      unless is_attach_action
-        @model = @resource.fill_model(@model_to_fill, cast_nullable(model_params), extra_params: extra_params)
-      end
+      @record = @resource.fill_record(@record_to_fill, cast_nullable(model_params), extra_params: extra_params)
+      assign_default_value_to_disabled_fields if @view == :create
     end
 
-    def hydrate_resource
-      @resource.hydrate(view: action_name.to_sym, user: _current_user, model: @model)
+    def is_attach_action?
+      params[model_param_key].blank? && params[:related_name].present? && params[:fields].present?
     end
 
-    def hydrate_related_resource
-      @related_resource.hydrate(view: action_name.to_sym, user: _current_user, model: @related_model)
+    def assign_default_value_to_disabled_fields
+      @resource.get_field_definitions.select do |field|
+        field.is_disabled? && field.visible? && !field.computed
+      end.each do |field|
+        # Get the default value from the field default definition
+        # If there is no default value specified on the resource, get the value from the record (DB, Callbacks, etc.)
+        default_value = field.default || @record.send(field.id)
+        field.fill_field @record, field.id, default_value, params
+      end
     end
 
     def authorize_base_action
-      class_to_authorize = @model || @resource.model_class
+      class_to_authorize = @record || @resource.model_class
 
       authorize_action class_to_authorize
     end
@@ -190,49 +198,6 @@ module Avo
       @authorization.set_record(class_to_authorize).authorize_action action_to_authorize.to_sym
     end
 
-    # Get the pluralized resource name for this request
-    # Ex: projects, teams, users
-    def resource_name
-      return params[:resource_name] if params[:resource_name].present?
-
-      return controller_name if controller_name.present?
-
-      begin
-        request.path
-          .match(/\/?#{Avo::App.root_path.delete('/')}\/resources\/([a-z1-9\-_]*)\/?/mi)
-          .captures
-          .first
-      rescue
-      end
-    end
-
-    def related_resource_name
-      params[:related_name]
-    end
-
-    # Gets the Avo resource for this request based on the request from the `resource_name` "param"
-    # Ex: Avo::Resources::Project, Avo::Resources::Team, Avo::Resources::User
-    def resource
-      resource = App.get_resource @resource_name.to_s.camelize.singularize
-
-      return resource if resource.present?
-
-      App.get_resource_by_controller_name @resource_name
-    end
-
-    def related_resource
-      # Find the field from the parent resource
-      field = @resource.get_field params[:related_name]
-
-      return field.use_resource if field&.use_resource.present?
-
-      reflection = @model._reflections[params[:related_name]]
-
-      reflected_model = reflection.klass
-
-      App.get_resource_by_model_name reflected_model
-    end
-
     def eager_load_files(resource, query)
       # Get the non-computed file fields and try to eager load them
       attachment_fields = resource
@@ -263,7 +228,7 @@ module Avo
       instance_eval(&Avo.configuration.authenticate)
     end
 
-    def render_unauthorized(_exception)
+    def render_unauthorized(exception)
       flash[:notice] = t "avo.not_authorized"
 
       redirect_url = if request.referrer.blank? || (request.referrer == request.url)
@@ -278,8 +243,8 @@ module Avo
     def set_authorization
       # We need to set @resource_name for the #resource method to work properly
       set_resource_name
-      @authorization = if resource
-        resource.authorization(user: _current_user)
+      @authorization = if @resource
+        @resource.authorization(user: _current_user)
       else
         Services::AuthorizationService.new _current_user
       end
@@ -301,30 +266,6 @@ module Avo
       instance_eval(&Avo.configuration.initial_breadcrumbs) if Avo.configuration.initial_breadcrumbs.present?
     end
 
-    def on_root_path
-      [Avo.configuration.root_path, "#{Avo.configuration.root_path}/"].include?(request.original_fullpath)
-    end
-
-    def on_resources_path
-      request.original_url.match?(/.*#{Avo.configuration.root_path}\/resources\/.*/)
-    end
-
-    def on_api_path
-      request.original_url.match?(/.*#{Avo.configuration.root_path}\/avo_api\/.*/)
-    end
-
-    def on_dashboards_path
-      request.original_url.match?(/.*#{Avo.configuration.root_path}\/dashboards\/.*/)
-    end
-
-    def on_debug_path
-      request.original_url.match?(/.*#{Avo.configuration.root_path}\/avo_private\/debug.*/)
-    end
-
-    def on_custom_tool_page
-      !(on_root_path || on_resources_path || on_api_path || on_dashboards_path || on_debug_path)
-    end
-
     def model_param_key
       @resource.form_scope
     end
@@ -360,5 +301,18 @@ module Avo
       value = cookies["#{Avo::COOKIES_KEY}.sidebar.open"]
       @sidebar_open = value.blank? || value == "1"
     end
+
+    # Set the current host for ActiveStorage
+    def set_active_storage_current_host
+      if defined?(ActiveStorage::Current)
+        if Rails::VERSION::MAJOR === 6
+          ActiveStorage::Current.host = request.base_url
+        elsif Rails::VERSION::MAJOR === 7
+          ActiveStorage::Current.url_options = {protocol: request.protocol, host: request.host, port: request.port}
+        end
+      end
+    rescue => exception
+      Avo.logger.debug "Failed to set ActiveStorage::Current.url_options, #{exception.inspect}"
+    end
   end
 end

data/app/controllers/avo/associations_controller.rb

@@ -2,18 +2,16 @@ 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 :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 :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 +19,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|
+          [@attachment_resource.new(record: record).record_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 +76,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).destroy @attachment_record
       else
-        @model.send("#{association_name}=", nil)
+        @record.send("#{association_name}=", nil)
       end
 
       respond_to do |format|
@@ -91,17 +89,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 +100,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.resource_manager.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 +118,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 +127,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
@@ -158,8 +149,8 @@ module Avo
     private
 
     def set_related_authorization
-      @related_authorization = if related_resource
-        related_resource.authorization(user: _current_user)
+      @related_authorization = if @related_resource.present?
+        @related_resource.authorization(user: _current_user)
       else
         Services::AuthorizationService.new _current_user
       end

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])
+      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),
@@ -47,7 +47,7 @@ module Avo
     private
 
     def authorized_to(action)
-      @resource.authorization.authorize_action("#{action}_#{params[:attachment_name]}?", record: @model, raise_exception: false)
+      @resource.authorization.authorize_action("#{action}_#{params[:attachment_name]}?", record: @record, raise_exception: false)
     end
   end
 end