avo 2.44.0 → 3.0.2

data/lib/avo/services/authorization_service.rb

@@ -6,109 +6,19 @@ module Avo
       attr_accessor :policy_class
 
       class << self
-        def client
-          client = Avo.configuration.authorization_client
-
-          client = nil if Avo::App.license.lacks(:authorization)
-
-          klass = case client
-          when nil
-            nil_client
-          when :pundit
-            pundit_client
-          else
-            if client.is_a?(String)
-              client.safe_constantize
-            else
-              client
-            end
-          end
-
-          klass.new
-        end
-
-        def authorize(user, record, action, policy_class: nil, **args)
-          return true if skip_authorization
-
-          client.authorize user, record, action, policy_class: policy_class
-
+        def authorize(*args, **kwargs)
           true
-        rescue NoPolicyError => error
-          # By default, Avo allows anything if you don't have a policy present.
-          return true unless Avo.configuration.raise_error_on_missing_policy
-
-          raise error
-        rescue => error
-          if args[:raise_exception] == false
-            false
-          else
-            raise error
-          end
         end
 
-        def authorize_action(user, record, action, policy_class: nil, **args)
-          action = Avo.configuration.authorization_methods.stringify_keys[action.to_s] || action
-
-          # If no action passed we should raise error if the user wants that.
-          # If not, just allow it.
-          if action.nil?
-            raise NoPolicyError.new "Policy method is missing" if Avo.configuration.raise_error_on_missing_policy
-
-            return true
-          end
-
-          # Add the question mark if it's missing
-          action = "#{action}?" unless action.end_with? "?"
-          authorize(user, record, action, policy_class: policy_class, **args)
-        end
-
-        def apply_policy(user, model, policy_class: nil)
-          return model if skip_authorization
-
-          client.apply_policy(user, model, policy_class: policy_class)
-        rescue NoPolicyError => error
-          return model unless Avo.configuration.raise_error_on_missing_policy
-
-          raise error
-        end
-
-        def skip_authorization
-          Avo::App.license.lacks_with_trial :authorization
-        end
-
-        def defined_methods(user, record, policy_class: nil, **args)
-          return client.policy!(user, record).methods if policy_class.nil?
-
-          # I'm aware this will not raise a Pundit error.
-          # Should the policy not exist, it will however raise an uninitialized constant error, which is probably what we want when specifying a custom policy
-          policy_class.new(user, record).methods
-        rescue NoPolicyError => error
-          return [] unless Avo.configuration.raise_error_on_missing_policy
-
-          raise error
-        rescue => error
-          if args[:raise_exception] == false
-            []
-          else
-            raise error
-          end
-        end
-
-        def pundit_client
-          raise Avo::MissingGemError.new("Please add `gem 'pundit'` to your Gemfile.") unless defined?(Pundit)
-
-          Avo::Services::AuthorizationClients::PunditClient
-        end
-
-        def nil_client
-          Avo::Services::AuthorizationClients::NilClient
+        def apply_policy(user, query)
+          query
         end
       end
 
       def initialize(user = nil, record = nil, policy_class: nil)
         @user = user
         @record = record
-        @policy_class = policy_class || self.class.client.policy(user, record)&.class
+        @policy_class = NilPolicy
       end
 
       def set_record(record)
@@ -117,28 +27,19 @@ module Avo
         self
       end
 
-      def authorize_action(action, **args)
-        self.class.authorize_action(user, args[:record] || record, action, policy_class: policy_class, **args)
+      def apply_policy(query)
+        query
       end
 
-      def apply_policy(model)
-        self.class.apply_policy(user, model, policy_class: policy_class)
+      def authorize_action(*args)
+        true
       end
 
-      def defined_methods(model, **args)
-        self.class.defined_methods(user, model, policy_class: policy_class, **args)
+      def has_method?(*args, **kwargs)
+        false
       end
 
-      def has_method?(method, **args)
-        method = "#{method}?" unless method.to_s.end_with? "?"
-        defined_methods(args[:record] || record, **args).include? method.to_sym
-      end
-
-      # Check the received method to see if the user overrode it in their config and then checks if it's present on the policy.
-      def has_action_method?(method, **args)
-        method = Avo.configuration.authorization_methods.stringify_keys[method.to_s] || method
-
-        has_method? method, **args
+      class NilPolicy
       end
     end
   end

data/lib/avo/services/debug_service.rb

@@ -0,0 +1,93 @@
+class Avo::Services::DebugService
+  class << self
+    def debug_report(request = nil)
+      payload = {}
+
+      hq = Avo::Licensing::HQ.new(request)
+
+      payload[:license_id] = Avo::Current&.license&.id
+      payload[:license_valid] = Avo::Current&.license&.valid?
+      payload[:license_payload] = Avo::Current&.license&.payload
+      payload[:license_response] = Avo::Current&.license&.response
+      payload[:hq_payload] = hq&.payload
+      payload[:thread_count] = get_thread_count
+      payload[:license_abilities] = Avo::Current&.license&.abilities
+      payload[:cache_store] = Avo.cache_store&.class&.to_s
+      payload[:avo_metadata] = avo_metadata
+      payload[:app_timezone] = Time.current.zone
+      payload[:cache_key] = Avo::Licensing::HQ.cache_key
+      payload[:cache_key_contents] = hq&.cached_response
+      payload[:plugins] = Avo.plugin_manager
+
+      payload
+    rescue => e
+      e
+    end
+
+    def get_thread_count
+      Thread.list.count { |thread| thread.status == "run" }
+    rescue => e
+      e
+    end
+
+    def avo_metadata
+      resources = Avo.resource_manager.all
+      dashboards = defined?(Avo::Dashboards) ? Avo::Dashboards.dashboard_manager.all : []
+      # field_definitions = resources.map(&:get_field_definitions)
+      # fields_count = field_definitions.map(&:count).sum
+      # fields_per_resource = sprintf("%0.01f", fields_count / (resources.count + 0.0))
+
+      # field_types = {}
+      # custom_fields_count = 0
+      # field_definitions.each do |fields|
+      #   fields.each do |field|
+      #     field_types[field.type] ||= 0
+      #     field_types[field.type] += 1
+
+      #     custom_fields_count += 1 if field.custom?
+      #   end
+      # end
+
+      {
+        resources_count: resources.count,
+        dashboards_count: dashboards.count,
+        # fields_count: fields_count,
+        # fields_per_resource: fields_per_resource,
+        # custom_fields_count: custom_fields_count,
+        # field_types: field_types,
+        # **other_metadata(:actions), # TODO: this is fetching actions without hydration
+        # **other_metadata(:filters),
+        main_menu_present: Avo.configuration.main_menu.present?,
+        profile_menu_present: Avo.configuration.profile_menu.present?,
+        cache_store: Avo.cache_store&.class&.to_s,
+        **config_metadata
+      }
+    # rescue => error
+    #   {
+    #     error: error.message
+    #   }
+    end
+
+    def other_metadata(type = :actions)
+      resources = Avo.resource_manager.all
+
+      types = resources.map(&:"get_#{type}")
+      type_count = types.flatten.uniq.count
+      type_per_resource = sprintf("%0.01f", types.map(&:count).sum / (resources.count + 0.0))
+
+      {
+        "#{type}_count": type_count,
+        "#{type}_per_resource": type_per_resource
+      }
+    end
+
+    def config_metadata
+      {
+        config: {
+          root_path: Avo.configuration.root_path,
+          app_name: Avo.configuration.app_name
+        }
+      }
+    end
+  end
+end

data/lib/avo/services/encryption_service.rb

@@ -1,32 +1,28 @@
 module Avo
   module Services
     class EncryptionService
-      attr_reader :message
-      attr_reader :purpose
-      attr_reader :crypt
-
       class << self
-        def encrypt(message:, purpose:)
-          new(message: message, purpose: purpose).encrypt
+        def encrypt(...)
+          new(...).encrypt
         end
 
-        def decrypt(message:, purpose:)
-          new(message: message, purpose: purpose).decrypt
+        def decrypt(...)
+          new(...).decrypt
         end
       end
 
-      def initialize(message:, purpose:)
+      def initialize(message:, purpose:, **kwargs)
         @message = message
         @purpose = purpose
-        @crypt = ActiveSupport::MessageEncryptor.new(encryption_key)
+        @crypt = ActiveSupport::MessageEncryptor.new(encryption_key, **kwargs)
       end
 
       def encrypt
-        crypt.encrypt_and_sign(message, purpose: purpose)
+        @crypt.encrypt_and_sign(@message, purpose: @purpose)
       end
 
       def decrypt
-        crypt.decrypt_and_verify(message, purpose: purpose)
+        @crypt.decrypt_and_verify(@message, purpose: @purpose)
       end
 
       private

data/lib/avo/services/telemetry_service.rb

@@ -0,0 +1,85 @@
+class Avo::Services::TelemetryService
+  class << self
+    def telemetry_info
+      {
+        # 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,
+        app_name: app_name,
+        avo_metadata: avo_metadata,
+      }
+    end
+
+    def app_name
+      Rails.application.class.to_s.split("::").first
+    rescue
+      nil
+    end
+
+    def avo_metadata
+      resources = Avo.resource_manager.all
+      dashboards = Avo::Current.app.dashboard_manager.all
+      field_definitions = resources.map(&:get_field_definitions)
+      fields_count = field_definitions.map(&:count).sum
+      fields_per_resource = sprintf("%0.01f", fields_count / (resources.count + 0.0))
+
+      field_types = {}
+      custom_fields_count = 0
+      field_definitions.each do |fields|
+        fields.each do |field|
+          field_types[field.type] ||= 0
+          field_types[field.type] += 1
+
+          custom_fields_count += 1 if field.custom?
+        end
+      end
+
+      {
+        resources_count: resources.count,
+        dashboards_count: dashboards.count,
+        fields_count: fields_count,
+        fields_per_resource: fields_per_resource,
+        custom_fields_count: custom_fields_count,
+        field_types: field_types,
+        **other_metadata(:actions),
+        **other_metadata(:filters),
+        main_menu_present: Avo.configuration.main_menu.present?,
+        profile_menu_present: Avo.configuration.profile_menu.present?,
+        cache_store: Avo.cache_store&.class&.to_s,
+        **config_metadata
+      }
+    # rescue => error
+    #   {
+    #     error: error.message
+    #   }
+    end
+
+    def other_metadata(type = :actions)
+      resources = Avo.resource_manager.all
+
+      types = resources.map(&:"get_#{type}")
+      type_count = types.flatten.uniq.count
+      type_per_resource = sprintf("%0.01f", types.map(&:count).sum / (resources.count + 0.0))
+
+      {
+        "#{type}_count": type_count,
+        "#{type}_per_resource": type_per_resource
+      }
+    end
+
+    def config_metadata
+      {
+        config: {
+          root_path: Avo.configuration.root_path,
+          app_name: Avo.configuration.app_name
+        }
+      }
+    end
+  end
+end