avo 0.5.0.beta3 → 0.5.0.beta8

data/lib/avo/base_resource.rb

@@ -0,0 +1,301 @@
+module Avo
+  class BaseResource
+    extend ActiveSupport::DescendantsTracker
+    extend FieldsCollector
+    extend HasContext
+
+    attr_accessor :view
+    attr_accessor :model
+    attr_accessor :user
+    attr_accessor :params
+
+    class_attribute :id, default: :id
+    class_attribute :title, default: :id
+    class_attribute :search, default: [:id]
+    class_attribute :includes, default: []
+    class_attribute :model_class
+    class_attribute :translation_key
+    class_attribute :default_view_type, default: :table
+    class_attribute :devise_password_optional, default: false
+    class_attribute :actions_loader
+    class_attribute :filters_loader
+    class_attribute :fields
+    class_attribute :grid_loader
+
+    class << self
+      def grid(&block)
+        grid_collector = GridCollector.new
+        grid_collector.instance_eval(&block)
+
+        self.grid_loader = grid_collector
+      end
+
+      def action(action_class)
+        self.actions_loader ||= Avo::Loaders::Loader.new
+
+        self.actions_loader.use action_class
+      end
+
+      def filter(filter_class)
+        self.filters_loader ||= Avo::Loaders::Loader.new
+
+        self.filters_loader.use filter_class
+      end
+    end
+
+    def hydrate(model: nil, view: nil, user: nil, params: nil)
+      @view = view if view.present?
+      @user = user if user.present?
+      @params = params if params.present?
+
+      if model.present?
+        @model = model
+
+        hydrate_model_with_default_values if @view == :new
+      end
+
+      self
+    end
+
+    def get_field_definitions
+      return [] if self.class.fields.blank?
+
+      self.class.fields.map do |field|
+        field.hydrate(resource: self, panel_name: default_panel_name, user: user)
+      end
+    end
+
+    def get_fields(panel: nil, reflection: nil)
+      fields = get_field_definitions.select do |field|
+        field.send("show_on_#{@view.to_s}")
+      end
+      .select do |field|
+        field.visible?
+      end
+      .select do |field|
+        unless field.respond_to?(:foreign_key) &&
+          reflection.present? &&
+          reflection.respond_to?(:foreign_key) &&
+          reflection.foreign_key == field.foreign_key
+          true
+        end
+      end
+
+      if panel.present?
+        fields = fields.select do |field|
+          field.panel_name == panel
+        end
+      end
+
+      fields = fields.map do |field|
+        field.hydrate(model: @model, view: @view, resource: self)
+      end
+
+      fields
+    end
+
+    def get_grid_fields
+      return if self.class.grid_loader.blank?
+
+      self.class.grid_loader.hydrate(model: @model, view: @view, resource: self)
+    end
+
+    def get_filters
+      return [] if self.class.filters_loader.blank?
+
+      self.class.filters_loader.bag
+    end
+
+    def get_actions
+      return [] if self.class.actions_loader.blank?
+
+      self.class.actions_loader.bag
+    end
+
+    def default_panel_name
+      return @params[:related_name].capitalize if @params[:related_name].present?
+
+      case @view
+      when :show
+        I18n.t('avo.resource_details', item: self.name.downcase, title: model_title).upcase_first
+      when :edit
+        I18n.t('avo.update_item', item: self.name.downcase, title: model_title).upcase_first
+      when :new
+        I18n.t('avo.create_new_item', item: self.name.downcase).upcase_first
+      end
+    end
+
+    def panels
+      panels = [
+        {
+          name: default_panel_name,
+          type: :fields,
+          in_panel: true,
+        }
+      ]
+
+      panels
+    end
+
+    def model_class
+      return self.class.model_class if self.class.model_class.present?
+
+      return @model.class if @model.present?
+
+      self.class.name.demodulize.chomp('Resource').safe_constantize
+    end
+
+    def model_title
+      return @model.send title if @model.present?
+
+      name
+    end
+
+    def name
+      return @name if @name.present?
+
+      return I18n.t(@translation_key, count: 1).capitalize if @translation_key
+
+      self.class.name.demodulize.chomp('Resource').titlecase
+    end
+
+    def singular_name
+      name
+    end
+
+    def plural_name
+      return I18n.t(@translation_key, count: 2).capitalize if @translation_key
+
+      name.pluralize
+    end
+
+    def underscore_name
+      return @name if @name.present?
+
+      self.class.name.demodulize.underscore
+    end
+
+    def available_view_types
+      view_types = [:table]
+
+      view_types << :grid if get_grid_fields.present?
+
+      view_types
+    end
+
+    def route_key
+      model_class.model_name.route_key
+    end
+
+    def context
+      self.class.context
+    end
+
+    def query_search(query: '', via_resource_name: , via_resource_id:, user:)
+      # model_class = self.model
+
+      db_query = AuthorizationService.apply_policy(user, model_class)
+
+      if via_resource_name.present?
+        related_model = App.get_resource_by_name(via_resource_name).model
+
+        db_query = related_model.find(via_resource_id).public_send(self.plural_name.downcase)
+      end
+
+      new_query = []
+
+      [self.search].flatten.each_with_index do |search_by, index|
+        new_query.push 'or' if index != 0
+
+        new_query.push "text(#{search_by}) ILIKE '%#{query}%'"
+      end
+
+      db_query.where(new_query.join(' '))
+    end
+
+    def attached_file_fields
+      get_field_definitions.select do |field|
+        [Avo::Fields::FileField, Avo::Fields::FilesField].include? field.class
+      end
+    end
+
+    def fill_model(model, params)
+      # Map the received params to their actual fields
+      fields_by_database_id = self.get_field_definitions.map { |field| [field.database_id(model).to_s, field] }.to_h
+
+      params.each do |key, value|
+        field = fields_by_database_id[key]
+
+        next unless field
+
+        model = field.fill_field model, key, value
+      end
+
+      model
+    end
+
+    def authorization
+      Avo::Services::AuthorizationService.new(user, model)
+    end
+
+    def file_hash
+      content_to_be_hashed = ''
+
+      # resource file hash
+      resource_path = Rails.root.join('app', 'avo', 'resources', "#{name.underscore}.rb").to_s
+      if File.file? resource_path
+        content_to_be_hashed += File.read(resource_path)
+      end
+
+      # policy file hash
+      policy_path = Rails.root.join('app', 'policies', "#{name.underscore}_policy.rb").to_s
+      if File.file? policy_path
+        content_to_be_hashed += File.read(policy_path)
+      end
+
+      Digest::MD5.hexdigest(content_to_be_hashed)
+    end
+
+    def cache_hash(parent_model)
+      if parent_model.present?
+        [self.model, self.file_hash, parent_model]
+      else
+        [self.model, self.file_hash]
+      end
+    end
+
+    # For :new views we're hydrating the model with the values from the resource's default attribute.
+    # We will not overwrite any attributes that come pre-filled in the model.
+    def hydrate_model_with_default_values
+      default_values = get_fields.select do |field|
+        !field.computed
+      end
+      .map do |field|
+        id = field.id
+        value = field.value
+
+        if field.respond_to? :foreign_key
+          id = field.foreign_key.to_sym
+
+          reflection = @model._reflections[@params[:via_relation]]
+
+          if reflection.present? && reflection.foreign_key.present?
+            value = @params[:via_resource_id]
+          end
+        end
+
+        [id, value]
+      end
+      .to_h
+      .select do |id, value|
+        value.present?
+      end
+
+      default_values.each do |id, value|
+        if @model.send(id).nil?
+          @model.send("#{id}=", value)
+        end
+      end
+    end
+  end
+end

data/lib/avo/configuration.rb

@@ -9,8 +9,6 @@ module Avo
     attr_accessor :locale
     attr_accessor :currency
     attr_accessor :default_view_type
-    attr_accessor :hide_resource_overview_component
-    attr_accessor :hide_documentation_link
     attr_accessor :license
     attr_accessor :license_key
     attr_accessor :authorization_methods
@@ -20,6 +18,7 @@ module Avo
     attr_accessor :full_width_container
     attr_accessor :full_width_index_view
     attr_accessor :cache_resources_on_index_view
+    attr_accessor :context
 
     def initialize
       @root_path = '/avo'
@@ -31,8 +30,6 @@ module Avo
       @locale = 'en-US'
       @currency = 'USD'
       @default_view_type = :table
-      @hide_resource_overview_component = false
-      @hide_documentation_link = false
       @license = 'community'
       @license_key = nil
       @current_user = proc {}
@@ -50,6 +47,7 @@ module Avo
       @full_width_container = false
       @full_width_index_view = false
       @cache_resources_on_index_view = Avo::PACKED
+      @context = proc {}
     end
 
     def locale_tag
@@ -71,6 +69,10 @@ module Avo
     def authenticate_with(&block)
       @authenticate = block if block.present?
     end
+
+    def set_context(&block)
+      @context = block if block.present?
+    end
   end
 
   def self.configuration

data/lib/avo/engine.rb

@@ -8,24 +8,25 @@ module Avo
   class Engine < ::Rails::Engine
     isolate_namespace Avo
 
-    initializer 'avo.autoload', before: :set_autoload_paths do |app|
-      {
-        'Avo::Resources': ['app', 'avo', 'resources'],
-        'Avo::Filters': ['app', 'avo', 'filters'],
-        'Avo::Actions': ['app', 'avo', 'actions'],
-      }.each do |namespace, path|
-        next unless Rails.root.join(*path).exist?
-
-        Rails.autoloaders.main.push_dir(Rails.root.join(*path), namespace: namespace.to_s.safe_constantize)
-      end
+    config.after_initialize do
+      # Boot Avo
+      ::Avo::App.boot
     end
 
-    initializer 'avo.init' do |app|
-      avo_root_path = Avo::Engine.root.to_s
+    initializer 'avo.autoload', before: :set_autoload_paths do |app|
+      Rails.autoloaders.main.push_dir(Rails.root.join('app', 'avo', 'filters'))
+      Rails.autoloaders.main.push_dir(Rails.root.join('app', 'avo', 'actions'))
+      Rails.autoloaders.main.push_dir(Rails.root.join('app', 'avo', 'resources'))
+    end
 
-      app.config.middleware.use I18n::JS::Middleware
+    initializer 'avo.init_fields' do |app|
+      # Init the fields
+      ::Avo::App.init_fields
+    end
 
-      if Avo::IN_DEVELOPMENT
+    initializer 'avo.reload_avo_files' do |app|
+      if Avo::IN_DEVELOPMENT && ENV['RELOAD_AVO_FILES']
+        avo_root_path = Avo::Engine.root.to_s
         # Register reloader
         app.reloaders << app.config.file_watcher.new([], {
           Avo::Engine.root.join('lib', 'avo').to_s => ['rb'],
@@ -33,19 +34,15 @@ module Avo
 
         # What to do on file change
         config.to_prepare do
-          Dir.glob(avo_root_path + '/lib/avo/app/**/*.rb'.to_s).each { |c| load c }
+          Dir.glob(avo_root_path + '/lib/avo/**/*.rb'.to_s).each { |c| load c }
           Avo::App.boot
         end
-      else
-        Dir.glob(avo_root_path + '/lib/avo/app/**/*.rb'.to_s).each { |c| require c }
-
-        Avo::App.boot if Avo::PACKED
       end
     end
 
     initializer 'webpacker.proxy' do |app|
       app.config.debug_exception_response_format = :api
-      app.config.logger = ::Logger.new(STDOUT)
+      # app.config.logger = ::Logger.new(STDOUT)
 
       insert_middleware = begin
                             Avo.webpacker.config.dev_server.present?

data/lib/avo/{app/fields → fields}/badge_field.rb

@@ -1,6 +1,6 @@
 module Avo
   module Fields
-    class BadgeField < Field
+    class BadgeField < BaseField
       def initialize(name, **args, &block)
         @defaults = {
           partial_name: 'badge-field',

data/lib/avo/{app/fields/field.rb → fields/base_field.rb}

@@ -1,11 +1,9 @@
-require_relative 'field_extensions/visible_in_different_views'
-require_relative 'field_extensions/has_field_name'
-
 module Avo
   module Fields
-    class Field
-      include Avo::Fields::FieldExtensions::VisibleOnDifferentViews
+    class BaseField
+      extend ActiveSupport::DescendantsTracker
       extend Avo::Fields::FieldExtensions::HasFieldName
+      include Avo::Fields::FieldExtensions::VisibleInDifferentViews
 
       attr_accessor :id
       attr_accessor :name
@@ -26,17 +24,18 @@ module Avo
       attr_accessor :placeholder
       attr_accessor :help
       attr_accessor :default
-      attr_accessor :can_see
+      attr_accessor :visible
       attr_accessor :model
       attr_accessor :resource
       attr_accessor :view
       attr_accessor :user
       attr_accessor :action
-      attr_accessor :grid_position
       attr_accessor :meta
       attr_accessor :panel_name
       attr_accessor :link_to_resource
 
+      class_attribute :field_name_attribute
+
       @meta = {}
 
       def initialize(id, **args, &block)
@@ -66,8 +65,7 @@ module Avo
           placeholder: id.to_s.humanize,
           help: nil,
           default: nil,
-          can_see: nil,
-          grid_position: false,
+          visible: true,
           meta: {},
           panel_name: nil,
         }
@@ -103,27 +101,35 @@ module Avo
         self
       end
 
+      def visible?
+        if visible.present? and visible.respond_to? :call
+          visible.call
+        else
+          visible
+        end
+      end
+
       def value
         # Get model value
-        value = @model.send(id) if model_or_class(@model) == 'model' and @model.respond_to? id
+        final_value = @model.send(id) if model_or_class(@model) == 'model' and @model.respond_to? id
 
         if @view === :new or @action.present?
           if default.present? and default.respond_to? :call
-            value = default.call @model, @resource, @view, self
+            final_value = default.call
           else
-            value = default
+            final_value = default
           end
         end
 
         # Run callback block if present
         if computable and block.present?
-          value = block.call @model, @resource, @view, self
+          final_value = block.call @model, @resource, @view, self
         end
 
         # Run the value through resolver if present
-        value = @format_using.call value if @format_using.present?
+        final_value = @format_using.call final_value if @format_using.present?
 
-        value
+        final_value
       end
 
       def fill_field(model, key, value)
@@ -172,7 +178,7 @@ module Avo
       end
 
       def type
-        self.class.name.demodulize.to_s.underscore
+        self.class.name.demodulize.to_s.underscore.gsub('_field', '')
       end
 
       private