avo 2.3.1.pre.4 → 2.4.0

data/lib/avo/licensing/h_q.rb

@@ -2,41 +2,76 @@ module Avo
   module Licensing
     class HQ
       attr_accessor :current_request
+      attr_accessor :cache_store
 
       ENDPOINT = "https://avohq.io/api/v1/licenses/check".freeze unless const_defined?(:ENDPOINT)
-      CACHE_KEY = "avo.hq.response".freeze unless const_defined?(:CACHE_KEY)
       REQUEST_TIMEOUT = 5 unless const_defined?(:REQUEST_TIMEOUT) # seconds
+      CACHE_TIME = 3600 unless const_defined?(:CACHE_TIME) # seconds
 
-      def initialize(current_request)
+      class << self
+        def cache_key
+          "avo.hq-#{Avo::VERSION.parameterize}.response"
+        end
+      end
+
+      def initialize(current_request = nil)
         @current_request = current_request
         @cache_store = Avo::App.cache_store
       end
 
       def response
+        expire_cache_if_overdue
+
         make_request
       end
 
+      # Some cache stores don't auto-expire their keys and payloads so we need to do it for them
+      def expire_cache_if_overdue
+        return unless cached_response.present?
+        return unless cached_response['fetched_at'].present?
+
+        allowed_time = 1.hour
+        parsed_time = Time.parse(cached_response['fetched_at'].to_s)
+        time_has_passed = parsed_time < Time.now - allowed_time
+
+        clear_response if time_has_passed
+      end
+
       def fresh_response
-        make_request(fresh: true)
+        clear_response
+
+        make_request
+      end
+
+      def clear_response
+        cache_store.delete self.class.cache_key
       end
 
       def payload
-        {
+        result = {
           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,
+          ip: current_request&.ip,
+          host: current_request&.host,
+          port: current_request&.port,
           app_name: app_name
         }
+
+        metadata = avo_metadata
+        if metadata[:resources_count] != 0
+          result[:avo_metadata] = metadata
+        end
+
+        result
       end
 
       def avo_metadata
         resources = App.resources
+        dashboards = App.dashboards
         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))
@@ -54,21 +89,28 @@ module Avo
 
         {
           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::App.main_menu.present?,
-          profile_menu_present: Avo::App.profile_menu.present?,
+          main_menu_present: Avo.configuration.main_menu.present?,
+          profile_menu_present: Avo.configuration.profile_menu.present?,
         }
+      rescue
+        {}
+      end
+
+      def cached_response
+        cache_store.read self.class.cache_key
       end
 
       private
 
-      def make_request(fresh: false)
-        return cached_response if has_cached_response && !fresh
+      def make_request
+        return cached_response if has_cached_response
 
         begin
           perform_and_cache_request
@@ -94,17 +136,19 @@ module Avo
 
         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
+        if hq_response.code == 200
+          cache_response response: hq_response.parsed_response
+        end
       end
 
-      def cache_response(time, response)
+      def cache_response(response: nil, time: CACHE_TIME)
         response.merge!(
           expiry: time,
           fetched_at: Time.now,
           **payload
         ).stringify_keys!
 
-        @cache_store.write(CACHE_KEY, response, expires_in: time)
+        cache_store.write(self.class.cache_key, response, expires_in: time)
 
         response
       end
@@ -135,15 +179,11 @@ module Avo
       end
 
       def cache_and_return_error(error, exception_message = "")
-        cache_response 5.minutes.to_i, {error: error, exception_message: exception_message}.stringify_keys
+        cache_response response: {error: error, exception_message: exception_message}.stringify_keys, time: 5.minutes.to_i
       end
 
       def has_cached_response
-        @cache_store.exist? CACHE_KEY
-      end
-
-      def cached_response
-        @cache_store.read CACHE_KEY
+        cache_store.exist? self.class.cache_key
       end
     end
   end

data/lib/avo/version.rb

@@ -1,3 +1,3 @@
 module Avo
-  VERSION = "2.3.1.pre.4" unless const_defined?(:VERSION)
+  VERSION = "2.4.0" unless const_defined?(:VERSION)
 end

data/lib/generators/avo/templates/initializer/avo.tt

@@ -42,6 +42,7 @@ Avo.configure do |config|
   # config.per_page_steps = [12, 24, 48, 72]
   # config.via_per_page = 8
   # config.default_view_type = :table
+  # config.hide_layout_when_printing = false
   # config.id_links_to_resource = false
   # config.full_width_container = false
   # config.full_width_index_view = false

data/lib/tasks/avo_tasks.rake

@@ -2,3 +2,33 @@
 # task :avo do
 #   # Task goes here
 # end
+
+desc 'Installs Avo assets and bundles them for when you want to use the GitHub repo in your app'
+task 'avo:build-assets' do
+  enabled = true
+
+  if enabled
+    puts "Starting avo:build-assets"
+    path = locate_gem 'avo'
+
+    Dir.chdir(path) do
+      system 'yarn'
+      system 'yarn prod:build'
+    end
+
+    puts "Done"
+  else
+    puts "Not starting avo:build-assets"
+  end
+end
+
+# From
+# https://stackoverflow.com/questions/9322078/programmatically-determine-gems-path-using-bundler
+def locate_gem(name)
+  spec = Bundler.load.specs.find{|s| s.name == name }
+  raise GemNotFound, "Could not find gem '#{name}' in the current bundle." unless spec
+  if spec.name == 'bundler'
+    return File.expand_path('../../../', __FILE__)
+  end
+  spec.full_gem_path
+end

data/public/avo-assets/avo.css

@@ -5482,6 +5482,7 @@ span.CodeMirror-selectedtext {
 .CodeMirror {
   height: var(--height) !important;
   min-height: auto;
+  padding: 0;
 }
 
 /* overlay CodeMirror fullscreen & Preview on small screens */
@@ -7507,6 +7508,10 @@ progress[value]::-moz-progress-bar{
   font-weight:500
 }
 
+.font-normal{
+  font-weight:400
+}
+
 .font-bold{
   font-weight:700
 }
@@ -8526,6 +8531,12 @@ trix-editor {
   padding-top:1rem
 }
 
+@media print{
+  .print\:hidden{
+    display:none
+  }
+}
+
 @media (min-width: 495px){
   .xs\:grid-cols-2{
     grid-template-columns:repeat(2, minmax(0, 1fr))