avo 0.5.0.beta4 → 0.5.0.beta5

data/lib/avo/app/filter.rb

@@ -1,23 +0,0 @@
-module Avo
-  class Filter
-    attr_accessor :name
-    attr_accessor :component
-    attr_accessor :default
-
-    def initialize
-      @name ||= 'Filter'
-      @component ||= 'boolean-filter'
-      @default ||= ''
-    end
-
-    def apply_query(request, query, value)
-      value.symbolize_keys! if value.is_a? Hash
-
-      self.apply(request, query, value)
-    end
-
-    def id
-      self.class.name.underscore.gsub('/', '_')
-    end
-  end
-end

data/lib/avo/app/filters/boolean_filter.rb

@@ -1,13 +0,0 @@
-require_relative '../filter'
-
-module Avo
-  module Filters
-    class BooleanFilter < Avo::Filter
-      def initialize
-        @component ||= 'boolean-filter'
-
-        super
-      end
-    end
-  end
-end

data/lib/avo/app/filters/select_filter.rb

@@ -1,13 +0,0 @@
-require_relative '../filter'
-
-module Avo
-  module Filters
-    class SelectFilter < Avo::Filter
-      def initialize
-        @component ||= 'select-filter'
-
-        super
-      end
-    end
-  end
-end

data/lib/avo/app/licensing/community_license.rb

@@ -1,4 +0,0 @@
-module Avo
-  class CommunityLicense < License
-  end
-end

data/lib/avo/app/licensing/hq.rb

@@ -1,86 +0,0 @@
-module Avo
-  class HQ
-    attr_accessor :current_request
-
-    ENDPOINT = 'https://avohq.io/api/v1/licenses/check' unless const_defined?(:ENDPOINT)
-    CACHE_KEY = 'avo.hq.response' unless const_defined?(:CACHE_KEY)
-    REQUEST_TIMEOUT = 5 unless const_defined?(:REQUEST_TIMEOUT) # seconds
-
-    def initialize(current_request)
-      @current_request = current_request
-      @cache_store = Avo::App.cache_store
-    end
-
-    def response
-      @hq_response or request
-    end
-
-    private
-      def request
-        return cached_response if has_cached_response
-
-        begin
-          perform_and_cache_request
-        rescue HTTParty::Error => exception
-          cache_and_return_error 'HTTP client error.', exception.message
-        rescue Net::OpenTimeout => exception
-          cache_and_return_error 'Request timeout.', exception.message
-        rescue SocketError => exception
-          cache_and_return_error 'Connection error.', exception.message
-        end
-      end
-
-      def perform_and_cache_request
-        hq_response = perform_request
-
-        return cache_and_return_error 'Avo HQ Internal server error.', hq_response.body if hq_response.code == 500
-
-        cache_response 1.hour.to_i, hq_response.parsed_response if hq_response.code == 200
-      end
-
-      def cache_response(time, response)
-        response.merge!(
-          expiry: time,
-          **payload,
-        ).stringify_keys!
-
-        @cache_store.write(CACHE_KEY, response, expires_in: time)
-
-        @hq_response = response
-
-        response
-      end
-
-      def perform_request
-        puts 'Performing request to avohq.io API to check license availability.'.inspect if Rails.env.development?
-
-        HTTParty.post ENDPOINT, body: payload.to_json, headers: { 'Content-type': 'application/json' }, timeout: REQUEST_TIMEOUT
-      end
-
-      def payload
-        {
-          license: Avo.configuration.license,
-          license_key: Avo.configuration.license_key,
-          avo_version: Avo::VERSION,
-          rails_version: Rails::VERSION::STRING,
-          ruby_version: RUBY_VERSION,
-          environment: Rails.env,
-          ip: current_request.ip,
-          host: current_request.host,
-          port: current_request.port,
-        }
-      end
-
-      def cache_and_return_error(error, exception_message = '')
-        cache_response 5.minutes.to_i, { error: error, exception_message: exception_message }.stringify_keys
-      end
-
-      def has_cached_response
-        @cache_store.exist? CACHE_KEY
-      end
-
-      def cached_response
-        @cache_store.read CACHE_KEY
-      end
-  end
-end

data/lib/avo/app/licensing/license.rb

@@ -1,48 +0,0 @@
-module Avo
-  class License
-    attr_accessor :id
-    attr_accessor :response
-    attr_accessor :valid
-
-    def initialize(response)
-      @response = response
-      @id = response['id']
-      @valid = response['valid']
-    end
-
-    def valid?
-      valid
-    end
-
-    def invalid?
-      !valid?
-    end
-
-    def pro?
-      id == 'pro'
-    end
-
-    def error
-      @response['error']
-    end
-
-    def properties
-      @response.slice('valid', 'id', 'error').symbolize_keys
-    end
-
-    def abilities
-      []
-    end
-
-    def can(ability)
-      abilities.include? ability
-    end
-
-    def cant(ability)
-      !can ability
-    end
-
-    alias_method :has, :can
-    alias_method :lacks, :cant
-  end
-end

data/lib/avo/app/licensing/license_manager.rb

@@ -1,25 +0,0 @@
-require_relative 'license'
-require_relative 'community_license'
-require_relative 'pro_license'
-require_relative 'null_license'
-
-module Avo
-  class LicenseManager
-    def initialize(hq_response)
-      @hq_response = hq_response
-    end
-
-    def license
-      return NullLicense.new if Rails.env.test? and ENV['RUN_WITH_NULL_LICENSE'] == '1'
-
-      case @hq_response['id']
-      when 'community'
-        CommunityLicense.new @hq_response
-      when 'pro'
-        ProLicense.new @hq_response
-      else
-        NullLicense.new @hq_response
-      end
-    end
-  end
-end

data/lib/avo/app/licensing/null_license.rb

@@ -1,12 +0,0 @@
-module Avo
-  class NullLicense < License
-    def initialize(response = nil)
-      response ||= {
-        id: 'community',
-        valid: true,
-      }
-
-      super(response)
-    end
-  end
-end

data/lib/avo/app/licensing/pro_license.rb

@@ -1,9 +0,0 @@
-module Avo
-  class ProLicense < License
-    def abilities
-      [
-        :authorization,
-      ]
-    end
-  end
-end

data/lib/avo/app/resource.rb

@@ -1,299 +0,0 @@
-require_relative 'resource_grid_fields'
-require_relative 'fields/field'
-
-module Avo
-  module Resources
-    class Resource
-      attr_writer :name
-
-      attr_accessor :id
-      attr_accessor :title
-      attr_accessor :search
-      attr_accessor :includes
-      attr_accessor :translation_key
-      attr_accessor :default_view_type
-      attr_accessor :devise_password_optional
-      attr_accessor :view
-      attr_accessor :model
-      attr_accessor :user
-      attr_accessor :fields_loader
-      attr_accessor :grid_loader
-      attr_accessor :actions_loader
-      attr_accessor :filters_loader
-      attr_accessor :params
-
-      alias :field :fields_loader
-      alias :f :field
-      alias :g :grid_loader
-      alias :action :actions_loader
-      alias :a :action
-      alias :filter :filters_loader
-
-      def initialize(request = nil)
-        @id = :id
-        @title = 'Resource'
-        @search = []
-        @includes = []
-        @translation_key = nil
-        @default_view_type = :table
-        @devise_password_optional = false
-
-        configure
-        boot_fields request
-      end
-
-      def boot_fields(request)
-        @fields_loader = Avo::FieldsLoader.new
-        fields request
-
-        @grid_loader = Avo::FieldsLoader.new
-        grid request if self.respond_to? :grid
-
-        @actions_loader = Avo::ActionsLoader.new
-        actions request if self.respond_to? :actions
-
-        @filters_loader = Avo::ActionsLoader.new
-        filters request if self.respond_to? :filters
-      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_fields(panel: nil, view_type: :table, reflection: nil)
-        case view_type.to_sym
-        when :table
-          fields = get_field_definitions.select do |field|
-            field.send("show_on_#{@view.to_s}")
-          end
-          .select do |field|
-            field.can_see.present? ? field.can_see.call : true
-          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
-        when :grid
-          fields = @grid_loader.bag
-        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_field_definitions
-        @fields_loader.bag.map do |field|
-          field.hydrate(resource: self, panel_name: default_panel_name, user: user)
-        end
-      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 @model.class if @model.present?
-
-        self.class.name.demodulize.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.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
-        get_fields(view_type: :grid).length > 0 ? [:grid, :table] : [:table]
-      end
-
-      def get_filters
-        @filters_loader.bag
-      end
-
-      def get_actions
-        @actions_loader.bag
-      end
-
-      def route_key
-        model_class.model_name.route_key
-      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
-        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
-end