jav 2.55.4

data/lib/jav/app.rb

@@ -0,0 +1,228 @@
+module Jav
+  class App
+    include Jav::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 = Jav::ENTITIES.fetch entity
+
+        return if paths.blank?
+
+        pathname = Rails.root.join(*paths)
+        return unless pathname.directory?
+
+        Rails.autoloaders.main.eager_load_dir(pathname.to_s)
+      end
+
+      def boot
+        init_fields
+
+        self.cache_store = Jav.configuration.cache_store
+      end
+
+      # Generate a dynamic root path using the URIService
+      def root_path(paths: [], query: {}, **args)
+        Jav::Services::URIService.parse(view_context.jav.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 = {}
+        self.translation_enabled = true
+
+        # 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 StandardError => exception
+          Rails.logger.debug { "[Jav] Failed to set ActiveStorage::Current.url_options, #{exception.inspect}" }
+        end
+
+        check_bad_resources
+        init_resources
+        init_dashboards
+      end
+
+      # This method will find all fields available in the Jav::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:
+      #
+      # Jav::Fields::TextField -> text
+      # Jav::Fields::DateTimeField -> date_time
+      def init_fields
+        Jav::Fields::BaseField.descendants.each do |class_name|
+          next if class_name.to_s == "BaseField"
+
+          load_field class_name.field_name, class_name if class_name.to_s.end_with? "Field"
+        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?
+
+          next if has_model
+
+          possible_model = resource.class.to_s.gsub "Resource", ""
+
+          Jav::App.error_messages.push({
+                                         url: "https://docs.javhq.io/2.0/resources.html#custom-model-class",
+                                         target: "_blank",
+                                         message: "#{resource.class} 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
+
+      # 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 Jav initializer.
+      # config.resources = [
+      #   "UserResource",
+      #   "FishResource",
+      # ]
+      def fetch_resources
+        resources = if Jav.configuration.resources.nil?
+                      BaseResource.descendants
+                    else
+                      Jav.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
+                         .reject do |resource|
+          # Remove the BaseResource. We only need the descendants
+          resource == BaseResource
+          # On invalid resource configuration the resource classes get duplicated in `ObjectSpace`
+          # We need to de-duplicate them
+        end
+        self.resources = resources.uniq(&:name)
+        self.resources = resources.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
+                                                   .reject do |dashboard|
+          dashboard == Dashboards::BaseDashboard
+        end.uniq(&:id)
+      end
+
+      def has_main_menu?
+        return false if Jav.configuration.main_menu.nil?
+
+        true
+      end
+
+      def has_profile_menu?
+        return false if Jav.configuration.profile_menu.nil?
+
+        true
+      end
+
+      def main_menu
+        # Return empty menu if the app doesn't have the profile menu configured
+        return Jav::Menu::Builder.new.build unless has_main_menu?
+
+        Jav::Menu::Builder.parse_menu(&Jav.configuration.main_menu)
+      end
+
+      def profile_menu
+        # Return empty menu if the app doesn't have the profile menu configured
+        return Jav::Menu::Builder.new.build unless has_profile_menu?
+
+        Jav::Menu::Builder.parse_menu(&Jav.configuration.profile_menu)
+      end
+
+      def debug_report(request = nil)
+        payload = {}
+
+        hq = Jav::Licensing::HQ.new(request)
+
+        payload[:license_id] = Jav::App.license&.id
+        payload[:license_valid] = Jav::App.license&.valid?
+        payload[:license_payload] = Jav::App.license&.payload
+        payload[:license_response] = Jav::App.license&.response
+        payload[:hq_payload] = hq&.payload
+        payload[:thread_count] = get_thread_count
+        payload[:license_abilities] = Jav::App.license&.abilities
+        payload[:cache_store] = cache_store&.class&.to_s
+        payload[:jav_metadata] = hq&.jav_metadata
+        payload[:app_timezone] = Time.current.zone
+        payload[:cache_key] = Jav::Licensing::HQ.cache_key
+        payload[:cache_key_contents] = hq&.cached_response
+
+        payload
+      rescue StandardError => e
+        e
+      end
+
+      def get_thread_count
+        Thread.list.count { |thread| thread.status == "run" }
+      rescue StandardError => e
+        e
+      end
+    end
+  end
+end

data/lib/jav/base_action.rb

@@ -0,0 +1,222 @@
+module Jav
+  class BaseAction
+    include Jav::Concerns::HasFields
+    include Jav::Concerns::HasActionStimulusControllers
+
+    class_attribute :name, default: nil
+    class_attribute :message
+    class_attribute :confirm_button_label
+    class_attribute :cancel_button_label
+    class_attribute :no_confirmation, default: false
+    class_attribute :standalone, default: false
+    class_attribute :visible
+    class_attribute :may_download_file, default: false
+    class_attribute :turbo
+
+    attr_accessor :view, :response, :model, :resource, :user
+    attr_reader :arguments
+
+    delegate :context, to: ::Jav::App
+    delegate :current_user, to: ::Jav::App
+    delegate :params, to: ::Jav::App
+    delegate :view_context, to: ::Jav::App
+    delegate :jav, to: :view_context
+    delegate :main_app, to: :view_context
+
+    class << self
+      delegate :context, to: ::Jav::App
+
+      def form_data_attributes
+        # We can't respond with a file download from Turbo se we disable it on the form
+        if may_download_file
+          { turbo: turbo || false, remote: false }
+        else
+          { turbo: turbo, turbo_frame: :_top }.compact
+        end
+      end
+
+      # We can't respond with a file download from Turbo se we disable close the modal manually after a while (it's a hack, we know)
+      def submit_button_data_attributes
+        attributes = { action_target: "submit" }
+
+        attributes[:action] = "click->modal#delayedClose" if may_download_file
+
+        attributes
+      end
+    end
+
+    def action_name
+      return name if name.present?
+
+      self.class.to_s.demodulize.underscore.humanize(keep_id_suffix: true)
+    end
+
+    def initialize(model: nil, resource: nil, user: nil, view: nil, arguments: {})
+      @model = model
+      @resource = resource
+      @user = user
+      @view = view
+      @arguments = arguments
+
+      self.class.message ||= I18n.t("jav.are_you_sure_you_want_to_run_this_option")
+      self.class.confirm_button_label ||= I18n.t("jav.run")
+      self.class.cancel_button_label ||= I18n.t("jav.cancel")
+
+      @response ||= {}
+      @response[:messages] = []
+    end
+
+    def get_message
+      if self.class.message.respond_to? :call
+        Jav::Hosts::ResourceRecordHost.new(block: self.class.message, record: @model, resource: @resource).handle
+      else
+        self.class.message
+      end
+    end
+
+    def handle_action(**args)
+      models, fields, current_user, resource = args.values_at(:models, :fields, :current_user, :resource)
+      # Fetching the field definitions and not the actual fields (get_fields) because they will break if the user uses a `visible` block and adds a condition using the `params` variable. The params are different in the show method and the handle method.
+      action_fields = get_field_definitions.index_by(&:id)
+
+      # For some fields, like belongs_to, the id and database_id differ (user vs user_id).
+      # That's why we need to fetch the database_id for when we process the action.
+      action_fields_by_database_id = action_fields.to_h do |_, value|
+        [value.database_id.to_sym, value]
+      end
+
+      if fields.present?
+        processed_fields = fields.to_unsafe_h.map do |name, value|
+          field = action_fields_by_database_id[name.to_sym]
+
+          next if field.blank?
+
+          [name, field.resolve_attribute(value)]
+        end
+
+        processed_fields = processed_fields.compact_blank.to_h
+      else
+        processed_fields = {}
+      end
+
+      args = {
+        fields: processed_fields.with_indifferent_access,
+        current_user: current_user,
+        resource: resource
+      }
+
+      args[:models] = models unless standalone
+
+      handle(**args)
+
+      self
+    end
+
+    def visible_in_view(parent_resource: nil)
+      if visible.blank?
+        # Hide on the :new view by default
+        return false if view == :new
+
+        # Show on all other views
+        return true
+      end
+
+      # Run the visible block if available
+      Jav::Hosts::VisibilityHost.new(
+        block: visible,
+        params: params,
+        parent_resource: parent_resource,
+        resource: @resource,
+        view: @view,
+        arguments: arguments
+      ).handle
+    end
+
+    def param_id
+      self.class.to_s
+    end
+
+    def succeed(text)
+      add_message text, :success
+
+      self
+    end
+
+    def fail(text)
+      Rails.logger.warn "DEPRECATION WARNING: Action fail method is deprecated in favor of error method and will be removed from Jav version 3.0.0"
+
+      error text
+    end
+
+    def error(text)
+      add_message text, :error
+
+      self
+    end
+
+    def inform(text)
+      add_message text, :info
+
+      self
+    end
+
+    def warn(text)
+      add_message text, :warning
+
+      self
+    end
+
+    def keep_modal_open
+      response[:keep_modal_open] = true
+
+      self
+    end
+
+    # Add a placeholder silent message from when a user wants to do a redirect action or something similar
+    def silent
+      add_message nil, :silent
+
+      self
+    end
+
+    def redirect_to(path = nil, **args, &block)
+      response[:type] = :redirect
+      response[:redirect_args] = args
+      response[:path] = (block.presence || path)
+
+      self
+    end
+
+    def reload
+      response[:type] = :reload
+
+      self
+    end
+
+    def download(path, filename)
+      response[:type] = :download
+      response[:path] = path
+      response[:filename] = filename
+
+      self
+    end
+
+    # We're overriding this method to hydrate with the proper resource attribute.
+    def hydrate_fields(model: nil, view: nil)
+      fields.map do |field|
+        field.hydrate(model: @model, view: @view, resource: resource)
+      end
+
+      self
+    end
+
+    private
+
+    def add_message(body, type = :info)
+      response[:messages] << {
+        type: type,
+        body: body
+      }
+    end
+  end
+end

data/lib/jav/base_card.rb

@@ -0,0 +1,161 @@
+module Jav
+  class BaseCard
+    include Jav::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, :options, :arguments, :index, :params
+
+    delegate :context, to: ::Jav::App
+    delegate :current_user, to: ::Jav::App
+    delegate :view_context, to: ::Jav::App
+    delegate :params, to: ::Jav::App
+    delegate :request, to: ::Jav::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
+
+      Jav::App.view_context.jav.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?(::Jav::Dashboards::MetricCard)
+      return :chartkick if is_a?(::Jav::Dashboards::ChartkickCard)
+
+      :partial if is_a?(::Jav::Dashboards::PartialCard)
+    end
+
+    def compute_result
+      Jav::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
+      ::Jav::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