avo 2.46.0 → 3.0.0.pre1

data/config/master.key

@@ -0,0 +1 @@
+2aeb23d82b909d9c6b5abb62f7058c2a

data/config/routes.rb

@@ -4,11 +4,11 @@ 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"
+  mount AvoFilters::Engine, at: "/avo_filters" if defined?(AvoFilters)
+  mount AvoDashboards::Engine, at: "/dashboards" if defined?(AvoDashboards::Engine)
+  mount AvoPro::Engine, at: "/avo_pro" if defined?(AvoPro)
 
-  resources :dashboards do
-    resources :cards, controller: "dashboards/cards"
-  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"
@@ -16,11 +16,6 @@ Avo::Engine.routes.draw do
     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
@@ -28,8 +23,8 @@ Avo::Engine.routes.draw do
     delete "/:resource_name/:id/active_storage_attachments/:attachment_name/:attachment_id", to: "attachments#destroy"
 
     # Actions
-    get "/:resource_name(/:id)/actions/(:action_id)", to: "actions#show"
-    post "/:resource_name(/:id)/actions/(:action_id)", to: "actions#handle"
+    get "/:resource_name(/:id)/actions/:action_id", to: "actions#show"
+    post "/:resource_name(/:id)/actions/:action_id", to: "actions#handle"
 
     # Generate resource routes as below:
     # resources :posts
@@ -44,7 +39,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) }
@@ -32,7 +38,7 @@ FactoryBot.define do
   factory :project do
     name { Faker::App.name }
     status { ['closed', :rejected, :failed, 'loading', :running, :waiting].sample }
-    stage { ["Discovery", "Idea", "Done", "On hold", "Cancelled", "Drafting"].sample }
+    stage { ["Discovery", "Idea", "Done", "On hold", "Cancelled"].sample }
     budget { Faker::Number.decimal(l_digits: 4) }
     country { Faker::Address.country_code }
     description { Faker::Markdown.sandwich(sentences: 5) }
@@ -42,20 +48,6 @@ FactoryBot.define do
     progress { Faker::Number.between(from: 0, to: 100) }
   end
 
-  trait :with_files do
-    after(:create) do |project|
-      ["watch.jpg", "dummy-video.mp4"].each do |filename|
-        file = Rails.root.join("db", "seed_files", filename)
-        project.files.attach(io: file.open, filename: filename)
-      end
-
-      ["dummy-file.txt", "dummy-audio.mp3"].each do |filename|
-        file = Avo::Engine.root.join("spec", "dummy", filename)
-        project.files.attach(io: file.open, filename: filename)
-      end
-    end
-  end
-
   factory :comment do
     body { Faker::Lorem.paragraphs(number: rand(4...10)).join(" ") }
     posted_at { Time.now - rand(10...365).days }
@@ -104,8 +96,6 @@ FactoryBot.define do
   factory :city do
     name { Faker::Address.city }
     population { rand(10000..999000) }
-    latitude { Faker::Address.latitude }
-    longitude { Faker::Address.longitude }
     is_capital { [true, false].sample }
     features { Faker::Address.community }
     metadata { Faker::Address.community }
@@ -113,7 +103,6 @@ FactoryBot.define do
     description { Faker::Address.community }
     status { ["open", "closed"].sample }
     tiny_description { Faker::Address.community }
-    city_center_area { [[[10.0, 11.2], [10.5, 11.9], [10.8, 12.0], [10.0, 11.2]]].to_json }
   end
 
   factory :product do

data/lib/avo/action_model.rb

@@ -0,0 +1,20 @@
+module Avo
+  class ActionModel
+    include ActiveModel::Model
+
+    # This class augments a model the action form declaration.
+    def initialize(attributes = {})
+      set_attr_accessors attributes
+
+      super(attributes)
+    end
+
+    private
+
+    def set_attr_accessors(attributes)
+      attributes.each do |k, v|
+        self.class.class_eval { attr_accessor k }
+      end
+    end
+  end
+end

data/lib/avo/app.rb

@@ -1,20 +1,19 @@
 module Avo
   class App
-    include Avo::Concerns::FetchesThings
-
-    class_attribute :resources, default: []
-    class_attribute :dashboards, default: []
+    class_attribute :field_manager
     class_attribute :cache_store, default: nil
-    class_attribute :fields, default: []
-    class_attribute :request, default: nil
-    class_attribute :context, default: nil
-    class_attribute :license, default: nil
-    class_attribute :current_user, default: nil
-    class_attribute :root_path, default: nil
-    class_attribute :view_context, default: nil
-    class_attribute :params, default: {}
-    class_attribute :translation_enabled, default: false
-    class_attribute :error_messages
+    class_attribute :logger
+
+    include ActiveModel::Model
+
+    attr_accessor :request, :context, :current_user, :view_context
+    attr_accessor :cache_store
+    attr_accessor :resource_manager
+    attr_accessor :dashboard_manager
+    attr_accessor :tool_manager
+    attr_accessor :error_manager
+
+    delegate :params, to: :request
 
     class << self
       def eager_load(entity)
@@ -29,151 +28,79 @@ module Avo
       end
 
       def boot
+        init_logger
         init_fields
-
-        self.cache_store = Avo.configuration.cache_store
+        init_cache_store
       end
 
-      # Generate a dynamic root path using the URIService
-      def root_path(paths: [], query: {}, **args)
-        Avo::Services::URIService.parse(view_context.avo.root_url.to_s)
-          .append_paths(paths)
-          .append_query(query)
-          .to_s
+      def init_cache_store
+        # The cache store should be set when the app boots up.
+        if Rails.cache.instance_of?(ActiveSupport::Cache::NullStore)
+          self.cache_store ||= ActiveSupport::Cache::MemoryStore.new
+        else
+          self.cache_store = Rails.cache
+        end
       end
 
-      def init(request:, context:, current_user:, view_context:, params:)
-        self.error_messages = []
-        self.context = context
-        self.current_user = current_user
-        self.params = params
-        self.request = request
-        self.view_context = view_context
-
-        self.license = Licensing::LicenseManager.new(Licensing::HQ.new(request).response).license
-        self.translation_enabled = license.has(:localization)
-
-        # Set the current host for ActiveStorage
-        begin
-          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
+      def init_logger
+        file_logger = ActiveSupport::Logger.new(Rails.root.join("log", "avo.log"))
+
+        file_logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+        file_logger.formatter = proc do |severity, time, progname, msg|
+          "[Avo] #{time}: #{msg}\n".tap do |i|
+            puts i
           end
-        rescue => exception
-          Rails.logger.debug "[Avo] Failed to set ActiveStorage::Current.url_options, #{exception.inspect}"
         end
 
-        check_bad_resources
-        init_resources
-        init_dashboards if license.has_with_trial(:dashboards)
+        self.logger = file_logger
       end
 
-      # This method will find all fields available in the Avo::Fields namespace and add them to the fields class_variable array
-      # so later we can instantiate them on our resources.
-      #
-      # If the field has their `def_method` set up it will follow that convention, if not it will snake_case the name:
-      #
-      # Avo::Fields::TextField -> text
-      # Avo::Fields::DateTimeField -> date_time
       def init_fields
-        Avo::Fields::BaseField.descendants.each do |class_name|
-          next if class_name.to_s == "BaseField"
+        self.field_manager = Avo::Fields::FieldManager.build
+      end
 
-          if class_name.to_s.end_with? "Field"
-            load_field class_name.get_field_name, class_name
-          end
-        end
+      def fields
+        field_manager
       end
 
-      def load_field(method_name, klass)
-        fields.push(
-          name: method_name,
-          class: klass
-        )
+      def build(request:, context:, current_user:, view_context:)
+        @app || new(request: request, context: context, current_user: current_user, view_context: view_context)
       end
 
-      def check_bad_resources
-        resources.each do |resource|
-          has_model = resource.model_class.present?
+      def license
+        Current.license
+      end
 
-          unless has_model
-            possible_model = resource.class.to_s.gsub "Resource", ""
+      def instance
+        Current.app
+      end
 
-            Avo::App.error_messages.push({
-              url: "https://docs.avohq.io/2.0/resources.html#custom-model-class",
-              target: "_blank",
-              message: "#{resource.class.to_s} does not have a valid model assigned. It failed to find the #{possible_model} model. \n\r Please create that model or assign one using self.model_class = YOUR_MODEL"
-            })
-          end
-        end
+      def resources
+        Current.app.resource_manager
       end
 
-      # Fetches the resources available to the application.
-      # We have two ways of doing that.
-      #
-      # 1. Through eager loading.
-      # We automatically eager load the resources directory and fetch the descendants from the scanned files.
-      # This is the simple way to get started.
-      #
-      # 2. Manually, declared by the user.
-      # We have this option to load the resources because when they are loaded automatically through eager loading,
-      # those Resource classes and their methods may trigger loading other classes. And that may disrupt Rails booting process.
-      # Ex: AdminResource may use self.model_class = User. That will trigger Ruby to load the User class and itself load
-      # other classes in a chain reaction.
-      # The scenario that comes up most often is when Rails boots, the routes are being computed which eager loads the resource files.
-      # At that boot time some migration might have not been run yet, but Rails tries to access them through model associations,
-      # and they are not available.
-      #
-      # To enable this feature add a `resources` array config in your Avo initializer.
-      # config.resources = [
-      #   "UserResource",
-      #   "FishResource",
-      # ]
-      def fetch_resources
-        resources = if Avo.configuration.resources.nil?
-          BaseResource.descendants
-        else
-          Avo.configuration.resources
-        end
+      def dashboards
+        Current.app.dashboard_manager
+      end
 
-        resources.map do |resource|
-          if resource.is_a?(Class)
-            resource
-          else
-            resource.to_s.safe_constantize
-          end
-        end
+      def tools
+        Current.app.tool_manager
       end
 
-      def init_resources
-        self.resources = fetch_resources
-          .select do |resource|
-            # Remove the BaseResource. We only need the descendants
-            resource != BaseResource
-          end
-          .uniq do |klass|
-            # On invalid resource configuration the resource classes get duplicated in `ObjectSpace`
-            # We need to de-duplicate them
-            klass.name
-          end
-          .map do |resource|
-            resource.new if resource.is_a? Class
-          end
+      def errors
+        Current.app.error_manager
       end
 
-      def init_dashboards
-        eager_load :dashboards unless Rails.application.config.eager_load
+      # Renerate a dynamic root path using the URIService
+      def root_path(paths: [], query: {}, **args)
+        Avo::Services::URIService.parse(Avo::Current.view_context.avo.root_url.to_s)
+          .append_paths(paths)
+          .append_query(query)
+          .to_s
+      end
 
-        self.dashboards = Dashboards::BaseDashboard.descendants
-          .select do |dashboard|
-            dashboard != Dashboards::BaseDashboard
-          end
-          .uniq do |dashboard|
-            dashboard.id
-          end
+      def mount_path
+        Avo::Engine.routes.find_script_name({})
       end
 
       def has_main_menu?
@@ -191,47 +118,48 @@ module Avo
       end
 
       def main_menu
+        return unless Avo.plugin_manager.installed?(:avo_menu)
+
         # Return empty menu if the app doesn't have the profile menu configured
-        return Avo::Menu::Builder.new.build unless has_main_menu?
+        return AvoMenu::Builder.new.build unless has_main_menu?
 
-        Avo::Menu::Builder.parse_menu(&Avo.configuration.main_menu)
+        AvoMenu::Builder.parse_menu(&Avo.configuration.main_menu)
       end
 
       def profile_menu
+        return unless Avo.plugin_manager.installed?(:avo_menu)
+
         # Return empty menu if the app doesn't have the profile menu configured
-        return Avo::Menu::Builder.new.build unless has_profile_menu?
+        return AvoMenu::Builder.new.build unless has_profile_menu?
 
-        Avo::Menu::Builder.parse_menu(&Avo.configuration.profile_menu)
+        AvoMenu::Builder.parse_menu(&Avo.configuration.profile_menu)
       end
+    end
 
-      def debug_report(request = nil)
-        payload = {}
-
-        hq = Avo::Licensing::HQ.new(request)
+    def init
+      self.error_manager = Avo::ErrorManager.build
+      self.resource_manager = Avo::Resources::ResourceManager.build
+      self.tool_manager = Avo::Tools::ToolManager.build
+    end
 
-        payload[:license_id] = Avo::App&.license&.id
-        payload[:license_valid] = Avo::App&.license&.valid?
-        payload[:license_payload] = Avo::App&.license&.payload
-        payload[:license_response] = Avo::App&.license&.response
-        payload[:hq_payload] = hq&.payload
-        payload[:thread_count] = get_thread_count
-        payload[:license_abilities] = Avo::App&.license&.abilities
-        payload[:cache_store] = self.cache_store&.class&.to_s
-        payload[:avo_metadata] = hq&.avo_metadata
-        payload[:app_timezone] = Time.current.zone
-        payload[:cache_key] = Avo::Licensing::HQ.cache_key
-        payload[:cache_key_contents] = hq&.cached_response
+    # Renerate a dynamic root path using the URIService
+    def root_path(paths: [], query: {}, **args)
+      Avo::Services::URIService.parse(view_context.avo.root_url.to_s)
+        .append_paths(paths)
+        .append_query(query)
+        .to_s
+    end
 
-        payload
-      rescue => e
-        e
-      end
+    def mount_path
+      Avo::Engine.routes.find_script_name({})
+    end
 
-      def get_thread_count
-        Thread.list.select {|thread| thread.status == "run"}.count
-      rescue => e
-        e
-      end
+    def app_status
+      Current.license.valid?
     end
   end
+
+  def self.logger
+    Avo::App.logger
+  end
 end

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,53 +1,54 @@
 module Avo
   class BaseAction
-    include Avo::Concerns::HasFields
-    include Avo::Concerns::HasActionStimulusControllers
+    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 :record
+    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
 
-    attr_accessor :view
     attr_accessor :response
-    attr_accessor :model
+    attr_accessor :record
     attr_accessor :resource
     attr_accessor :user
     attr_reader :arguments
 
-    delegate :context, to: ::Avo::App
-    delegate :current_user, to: ::Avo::App
-    delegate :params, to: ::Avo::App
-    delegate :view_context, to: ::Avo::App
+    delegate :view, to: :class
+    # TODO: find a differnet way to delegate this to the uninitialized Current variable
+    delegate :context, to: Avo::Current
+    delegate :current_user, to: Avo::Current
+    delegate :params, to: Avo::Current
+    delegate :view_context, to: Avo::Current
     delegate :avo, to: :view_context
     delegate :main_app, to: :view_context
 
     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
         if may_download_file
-          {turbo: turbo || false, remote: false}
+          {turbo: false, remote: false, action_target: :form}
         else
-          {turbo: turbo, turbo_frame: :_top}.compact
+          {turbo_frame: :_top, action_target: :form}
         end
       end
 
       # We can't respond with a file download from Turbo se we disable close the modal manually after a while (it's a hack, we know)
       def submit_button_data_attributes
-        attributes = { action_target: "submit" }
-
         if may_download_file
-          attributes[:action] = "click->modal#delayedClose"
+          {action: "click->modal#delayedClose"}
+        else
+          {}
         end
-
-        attributes
       end
     end
 
@@ -57,11 +58,11 @@ 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: {})
-      @model = model
-      @resource = resource
-      @user = user
-      @view = view
+    def initialize(record: nil, resource: nil, user: nil, view: nil, arguments: {})
+      self.class.record = record if record.present?
+      self.class.resource = resource if resource.present?
+      self.class.user = user if user.present?
+      self.class.view = view if view.present?
       @arguments = arguments
 
       self.class.message ||= I18n.t("avo.are_you_sure_you_want_to_run_this_option")
@@ -73,11 +74,13 @@ module Avo
     end
 
     def get_message
-      if self.class.message.respond_to? :call
-        Avo::Hosts::ResourceRecordHost.new(block: self.class.message, record: @model, resource: @resource).handle
-      else
-        self.class.message
-      end
+      Avo::ExecutionContext.new(target: self.class.message, record: self.class.record, resource: self.class.resource).handle
+    end
+
+    def get_attributes_for_action
+      get_fields.map do |field|
+        [field.id, field.value || field.default]
+      end.to_h
     end
 
     def handle_action(**args)
@@ -128,18 +131,18 @@ module Avo
       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: @resource,
-        view: @view,
+        resource: self.class.resource,
+        view: self.class.view,
         arguments: arguments
       ).handle
     end
 
     def param_id
-      self.class.to_s
+      self.class.to_s.demodulize.underscore.tr "/", "_"
     end
 
     def succeed(text)
@@ -185,9 +188,8 @@ module Avo
       self
     end
 
-    def redirect_to(path = nil, **args, &block)
+    def redirect_to(path = nil, &block)
       response[:type] = :redirect
-      response[:redirect_args] = args
       response[:path] = if block.present?
         block
       else
@@ -212,9 +214,9 @@ module Avo
     end
 
     # We're overriding this method to hydrate with the proper resource attribute.
-    def hydrate_fields(model: nil, view: nil)
+    def hydrate_fields
       fields.map do |field|
-        field.hydrate(model: @model, view: @view, resource: resource)
+        field.hydrate(record: @record, view: @view, resource: resource)
       end
 
       self