avo 2.46.0 → 3.0.2

data/app/javascript/js/controllers/fields/tags_field_controller.js

@@ -1,127 +0,0 @@
-import { first, isObject, merge } from 'lodash'
-import Tagify from '@yaireo/tagify'
-import URI from 'urijs'
-
-import { suggestionItemTemplate, tagTemplate } from './tags_field_helpers'
-import BaseController from '../base_controller'
-import debouncePromise from '../../helpers/debounce_promise'
-
-export default class extends BaseController {
-  static targets = ['input', 'fakeInput'];
-
-  static values = {
-    whitelistItems: { type: Array, default: [] },
-    disallowedItems: { type: Array, default: [] },
-    enforceSuggestions: { type: Boolean, default: false },
-    closeOnSelect: { type: Boolean, default: false },
-    delimiters: { type: Array, default: [] },
-    suggestionsMaxItems: { type: Number, default: 20 },
-    mode: String,
-    fetchValuesFrom: String,
-  }
-
-  tagify = null;
-
-  searchDebounce = 500
-
-  debouncedFetch = debouncePromise(fetch, this.searchDebounce);
-
-  get suggestionsAreObjects() {
-    return isObject(first(this.whitelistItemsValue)) || this.fetchValuesFromValue
-  }
-
-  get tagifyOptions() {
-    let options = {
-      whitelist: this.whitelistItemsValue,
-      blacklist: this.disallowedItemsValue,
-      enforceWhitelist: this.enforceSuggestionsValue || this.fetchValuesFromValue,
-      delimiters: this.delimitersValue.join('|'),
-      dropdown: {
-        maxItems: this.suggestionsMaxItemsValue,
-        enabled: 0,
-        searchKeys: [this.labelAttributeValue],
-        closeOnSelect: this.closeOnSelectValue,
-      },
-    }
-
-    if (this.modeValue) {
-      options.mode = this.modeValue // null or "select"
-    }
-
-    if (this.suggestionsAreObjects) {
-      options = merge(options, {
-        tagTextProp: 'label',
-        dropdown: {
-          searchKeys: ['label'],
-          mapValueTo: 'value',
-        },
-        templates: {
-          tag: tagTemplate,
-          dropdownItem: suggestionItemTemplate,
-        },
-        originalInputValueFormat: (valuesArr) => valuesArr.map((item) => item.value),
-      })
-    } else {
-      options = merge(options, {
-        originalInputValueFormat: (valuesArr) => valuesArr.map((item) => item.value).join(','),
-      })
-    }
-
-    return options
-  }
-
-  connect() {
-    if (this.hasInputTarget) {
-      this.hideFakeInput()
-      this.showRealInput()
-      this.initTagify()
-    }
-  }
-
-  initTagify() {
-    this.tagify = new Tagify(this.inputTarget, this.tagifyOptions)
-    const that = this
-
-    function onInput(e) {
-      // Create the URL from which to fetch the values
-      const query = e.detail.value
-      const uri = new URI(that.fetchValuesFromValue)
-      uri.addSearch({
-        q: query,
-      })
-
-      // reset current whitelist
-      that.tagify.whitelist = null
-      // show the loader animation
-      that.tagify.loading(true)
-
-      // get new whitelist from a request
-      that.fetchResults(uri.toString())
-        .then((result) => {
-          that.tagify.settings.whitelist = result // add already-existing tags to the new whitelist array
-
-          that.tagify
-            .loading(false)
-            .dropdown.show(e.detail.value) // render the suggestions dropdown.
-        })
-        .catch(() => that.tagify.dropdown.hide())
-    }
-
-    if (this.fetchValuesFromValue) {
-      this.tagify.on('input', onInput)
-    }
-  }
-
-  fetchResults(endpoint) {
-    return this.debouncedFetch(endpoint)
-      .then((response) => response.json())
-  }
-
-  hideFakeInput() {
-    this.fakeInputTarget.classList.add('hidden')
-  }
-
-  showRealInput() {
-    this.inputTarget.classList.remove('hidden')
-  }
-}

data/app/javascript/js/controllers/toggle_panel_controller.js

@@ -1,18 +0,0 @@
-import { Controller } from '@hotwired/stimulus'
-import { useClickOutside } from 'stimulus-use'
-
-export default class extends Controller {
-  static targets = ['panel']
-
-  connect() {
-    useClickOutside(this)
-  }
-
-  clickOutside() {
-    this.panelTarget.classList.add('hidden')
-  }
-
-  togglePanel() {
-    this.panelTarget.classList.toggle('hidden')
-  }
-}

data/app/views/avo/dashboards/cards/_chartkick_card.html.erb

@@ -1,3 +0,0 @@
-<div class="relative flex flex-col <%= @card.chartkick_classes %>">
-  <%= send(@card.chart_type, @card.result_data, **@card.chartkick_options) %>
-</div>

data/app/views/avo/dashboards/cards/_metric_card.html.erb

@@ -1,5 +0,0 @@
-<div class="flex mt-4 items-end">
-  <span class="text-3xl"><%= @card.prefix %></span>
-  <span class="text-5xl"><%= @card.result_data %></span>
-  <span class="text-3xl"><%= @card.suffix %></span>
-</div>

data/app/views/avo/dashboards/cards/chartkick_missing.html.erb

@@ -1,14 +0,0 @@
-<%= render Avo::TurboFrameWrapperComponent.new(params[:turbo_frame]) do %>
-  <div class="w-full h-full flex items-center text-center">
-    <div class="flex-1">
-      Chartkick is missing.
-      <a
-        href="https://docs.avohq.io/2.0/upgrade.html#upgrade-from-2-17-to-2-18"
-        target="_blank"
-      >
-        Manually require it in your
-        <code class="inline">Gemfile</code>
-      </a>.
-    </div>
-  </div>
-<% end %>

data/app/views/avo/dashboards/cards/show.html.erb

@@ -1,3 +0,0 @@
-<%= render Avo::TurboFrameWrapperComponent.new(params[:turbo_frame]) do %>
-  <%= render Avo::CardComponent.new card: @card %>
-<% end %>

data/app/views/avo/dashboards/show.html.erb

@@ -1,38 +0,0 @@
-<%= render Avo::PanelComponent.new(name: @dashboard.name, description: @dashboard.description) do |c| %>
-  <% c.with_bare_content do %>
-    <% if @dashboard.items.present? %>
-      <div class="min-h-24">
-        <%= content_tag(:div, class: "grid gap-4 grid-cols-1 #{@dashboard.classes}") do %>
-          <% @dashboard.items.each do |item| %>
-            <% if item.is_divider? %>
-              <%= render Avo::Dashboards::DividerComponent.new(divider: item) %>
-            <% elsif item.is_card? %>
-              <%= content_tag(:div, class: "relative bg-white rounded shadow-panel space-y-2 #{item.card_classes} overflow-hidden") do %>
-                <turbo-frame id="<%= item.turbo_frame %>"
-                  src="<%= item.frame_url(enforced_range: @range, params: params) %>"
-                  data-card-index="<%= item.index %>"
-                >
-                  <%= render(Avo::LoadingComponent.new(title: item.label)) %>
-                </turbo-frame>
-              <% end %>
-            <% end %>
-          <% end %>
-        <% end %>
-      </div>
-    <% else %>
-      <div class="w-full h-full">
-        <% if Rails.env.development? %>
-          <%= render Avo::PanelComponent.new do |c| %>
-            <% c.with_body do %>
-              <div class="p-6">
-                <%= t 'avo.empty_dashboard_message' %>. <%= link_to 'Docs', 'https://docs.avohq.io/2.0/dashboards.html', target: '_blank' %>
-              </div>
-            <% end %>
-          <% end %>
-        <% end %>
-
-        <%= empty_state message: t('avo.no_cards_present') %>
-      </div>
-    <% end %>
-  <% end %>
-<% end %>

data/app/views/avo/partials/_global_search.html.erb

@@ -1,19 +0,0 @@
-<div data-controller="search" class="relative flex global-search rounded border border-gray-200 sm:min-w-[16rem]">
-  <div class="flex-1 text-gray-500"
-    data-search-target="autocomplete"
-    data-search-resource="global"
-    data-translation-keys='{"no_item_found": "<%= I18n.translate 'avo.no_item_found' %>", "placeholder": "<%= I18n.translate 'avo.search.placeholder' %>", "cancel_button": "<%= I18n.translate 'avo.search.cancel_button' %>"}'
-  >
-  </div>
-  <div class="absolute top-1/2 hidden sm:inline-flex text-gray-400 text-sm leading-5 py-0.5 px-1.5 border border-gray-300 rounded-md cursor-pointer -translate-y-1/2 left-auto right-0 mr-4"
-    data-search-target="button"
-  >
-    <span class="sr-only">Press </span>
-    <kbd class="font-sans">
-      <abbr title="Command" class="no-underline pc:hidden">⌘</abbr>
-      <abbr title="CTRL" class="no-underline mac:hidden">CTRL +&nbsp; </abbr>
-    </kbd>
-    <span class="sr-only"> and </span>
-    <kbd class="font-sans">K</kbd><span class="sr-only"> to search</span>
-  </div>
-</div>

data/app/views/avo/sidebar/_license_warnings.html.erb

@@ -1,6 +0,0 @@
-<% if license[:id] == 'pro' and license[:valid] == false %>
-  <%= render_license_warning title: 'Trial Mode', message: 'You are experiencing paid features that need to be licensed before deploying this site. Enjoy!' %>
-<% end %>
-<% if license[:error].present? && !(Avo.configuration.display_license_request_timeout_error === false && license[:error] === "Request timeout.") %>
-  <%= render_license_warning title: 'Avo HQ Error', message: "#{license[:error]} Checking back every 5 minutes." %>
-<% end %>

data/lib/avo/app.rb

@@ -1,237 +0,0 @@
-module Avo
-  class App
-    include Avo::Concerns::FetchesThings
-
-    class_attribute :resources, default: []
-    class_attribute :dashboards, default: []
-    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 << self
-      def eager_load(entity)
-        paths = Avo::ENTITIES.fetch entity
-
-        return unless paths.present?
-
-        pathname = Rails.root.join(*paths)
-        if pathname.directory?
-          Rails.autoloaders.main.eager_load_dir(pathname.to_s)
-        end
-      end
-
-      def boot
-        init_fields
-
-        self.cache_store = Avo.configuration.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
-      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
-          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)
-      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"
-
-          if class_name.to_s.end_with? "Field"
-            load_field class_name.get_field_name, class_name
-          end
-        end
-      end
-
-      def load_field(method_name, klass)
-        fields.push(
-          name: method_name,
-          class: klass
-        )
-      end
-
-      def check_bad_resources
-        resources.each do |resource|
-          has_model = resource.model_class.present?
-
-          unless has_model
-            possible_model = resource.class.to_s.gsub "Resource", ""
-
-            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
-      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
-
-        resources.map do |resource|
-          if resource.is_a?(Class)
-            resource
-          else
-            resource.to_s.safe_constantize
-          end
-        end
-      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
-      end
-
-      def init_dashboards
-        eager_load :dashboards unless Rails.application.config.eager_load
-
-        self.dashboards = Dashboards::BaseDashboard.descendants
-          .select do |dashboard|
-            dashboard != Dashboards::BaseDashboard
-          end
-          .uniq do |dashboard|
-            dashboard.id
-          end
-      end
-
-      def has_main_menu?
-        return false if Avo::App.license.lacks_with_trial(:menu_editor)
-        return false if Avo.configuration.main_menu.nil?
-
-        true
-      end
-
-      def has_profile_menu?
-        return false if Avo::App.license.lacks_with_trial(:menu_editor)
-        return false if Avo.configuration.profile_menu.nil?
-
-        true
-      end
-
-      def main_menu
-        # Return empty menu if the app doesn't have the profile menu configured
-        return Avo::Menu::Builder.new.build unless has_main_menu?
-
-        Avo::Menu::Builder.parse_menu(&Avo.configuration.main_menu)
-      end
-
-      def profile_menu
-        # Return empty menu if the app doesn't have the profile menu configured
-        return Avo::Menu::Builder.new.build unless has_profile_menu?
-
-        Avo::Menu::Builder.parse_menu(&Avo.configuration.profile_menu)
-      end
-
-      def debug_report(request = nil)
-        payload = {}
-
-        hq = Avo::Licensing::HQ.new(request)
-
-        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
-
-        payload
-      rescue => e
-        e
-      end
-
-      def get_thread_count
-        Thread.list.select {|thread| thread.status == "run"}.count
-      rescue => e
-        e
-      end
-    end
-  end
-end

data/lib/avo/base_card.rb

@@ -1,161 +0,0 @@
-module Avo
-  class BaseCard
-    include Avo::Concerns::VisibleInDashboard
-
-    class_attribute :id
-    class_attribute :label
-    class_attribute :description
-    class_attribute :cols, default: 1
-    class_attribute :rows, default: 1
-    class_attribute :initial_range
-    class_attribute :ranges, default: []
-    class_attribute :refresh_every
-    class_attribute :display_header, default: true
-    # private
-    class_attribute :result_data
-    class_attribute :query_block
-
-    attr_accessor :dashboard
-    attr_accessor :options
-    attr_accessor :arguments
-    attr_accessor :index
-    attr_accessor :params
-
-    delegate :context, to: ::Avo::App
-    delegate :current_user, to: ::Avo::App
-    delegate :view_context, to: ::Avo::App
-    delegate :params, to: ::Avo::App
-    delegate :request, to: ::Avo::App
-
-    class << self
-      def query(&block)
-        self.query_block = block
-      end
-    end
-
-    def initialize(dashboard:, options: {}, arguments: {}, index: 0, cols: nil, rows: nil, label: nil, description: nil, refresh_every: nil, visible: nil)
-      @dashboard = dashboard
-      @options = options
-      @arguments = arguments
-      @index = index
-      @cols = cols
-      @rows = rows
-      @label = label
-      @refresh_every = refresh_every
-      @description = description
-      @visible = visible
-    end
-
-    def label
-      return @label.to_s if @label.present?
-      return self.class.label.to_s if self.class.label.present?
-
-      self.class.id.to_s.humanize
-    end
-
-    def description
-      @description || self.class.description
-    end
-
-    def refresh_every
-      @refresh_every || self.class.refresh_every
-    end
-
-    def turbo_frame
-      "#{dashboard.id}_#{id}"
-    end
-
-    def frame_url(enforced_range: nil, params: {})
-      enforced_range ||= initial_range || ranges.first
-
-      Avo::App.view_context.avo.dashboard_card_path(dashboard.id, id, turbo_frame: turbo_frame, index: index, range: enforced_range, **params.permit!)
-    end
-
-    def card_classes
-      result = ""
-
-      # Writing down the classes so TailwindCSS knows not to purge them
-      classes_for_cols = {
-        1 => " sm:col-span-1",
-        2 => " sm:col-span-2",
-        3 => " sm:col-span-3",
-        4 => " sm:col-span-4",
-        5 => " sm:col-span-5",
-        6 => " sm:col-span-6"
-      }
-
-      classes_for_rows = {
-        1 => " h-36",
-        2 => " h-72",
-        3 => " h-[27rem]",
-        4 => " h-[36rem]",
-        5 => " h-[45rem]",
-        6 => " h-[54rem]"
-      }
-
-      result += classes_for_cols[cols.to_i] if classes_for_cols[cols.to_i].present?
-      result += classes_for_rows[rows.to_i] if classes_for_rows[rows.to_i].present?
-
-      result
-    end
-
-    def type
-      return :metric if is_a?(::Avo::Dashboards::MetricCard)
-      return :chartkick if is_a?(::Avo::Dashboards::ChartkickCard)
-      return :partial if is_a?(::Avo::Dashboards::PartialCard)
-    end
-
-    def compute_result
-      Avo::Hosts::DashboardCard.new(card: self, dashboard: dashboard, params: params, context: context, range: range, options: options)
-        .compute_result
-
-      self
-    end
-
-    def hydrate(dashboard: nil)
-      @dashboard = dashboard if dashboard.present?
-
-      self
-    end
-
-    def range
-      return params[:range] if params.dig(:range).present?
-
-      return initial_range if initial_range.present?
-
-      ranges.first
-    end
-
-    def result(data)
-      self.result_data = data
-
-      self
-    end
-
-    def is_card?
-      true
-    end
-
-    def is_divider?
-      false
-    end
-
-    def visible
-      @visible || self.class.visible
-    end
-
-    def call_block
-      ::Avo::Hosts::CardVisibility.new(block: visible, card: self, parent: dashboard).handle
-    end
-
-    private
-
-    def cols
-      @cols || self.class.cols
-    end
-
-    def rows
-      @rows || self.class.rows
-    end
-  end
-end