jav 2.55.4

data/app/controllers/jav/base_controller.rb

@@ -0,0 +1,521 @@
+require_dependency "jav/application_controller"
+
+module Jav
+  class BaseController < ApplicationController
+    include Jav::Concerns::FiltersSessionHandler
+
+    before_action :set_resource_name
+    before_action :set_resource
+    before_action :hydrate_resource
+    before_action :set_applied_filters, only: :index
+    before_action :set_model, only: %i[show edit destroy update order]
+    before_action :set_model_to_fill
+    before_action :set_edit_title_and_breadcrumbs, only: %i[edit update]
+    before_action :fill_model, only: %i[create update]
+    # Don't run base authorizations for associations
+    before_action :authorize_base_action, if: -> { controller_name != "associations" }
+    before_action :set_pagy_locale, only: :index
+
+    def index
+      @page_title = @resource.plural_name.humanize
+      add_breadcrumb @resource.plural_name.humanize
+
+      set_index_params
+      set_filters
+      set_actions
+
+      # If we don't get a query object predefined from a child controller like associations, just spin one up
+      @query = @resource.class.query_scope unless defined? @query
+
+      # Remove default_scope for index view if no parent_resource present
+      @query = @query.unscoped if @resource.unscoped_queries_on_index && @parent_resource.blank?
+
+      # Eager load the associations
+      @query = @query.includes(*@resource.includes) if @resource.includes.present?
+
+      # Eager load the active storage attachments
+      @query = eager_load_files(@resource, @query)
+
+      # Sort the items
+      if @index_params[:sort_by].present?
+        @query = @query.unscope(:order) unless @index_params[:sort_by].eql? :created_at
+
+        sanitized_sort_direction = @index_params[:sort_direction].presence_in(%w[asc desc])
+
+        # Check if the sortable field option is actually a proc and we need to do a custom sort
+        sort_by = @index_params[:sort_by].to_sym
+        field = @resource.get_field(sort_by)
+        @query = if field&.sortable.is_a?(Proc)
+                   field.sortable.call(@query, sanitized_sort_direction)
+                 elsif field.present? && sanitized_sort_direction
+                   @query.order("#{@resource.model_class.table_name}.#{sort_by} #{sanitized_sort_direction}")
+                 # Transform Model to ActiveRecord::Relation because Jav expects one.
+                 else
+                   @query.where("1=1")
+                 end
+      end
+
+      # Apply filters to the current query
+      filters_to_be_applied.each do |filter_class, filter_value|
+        @query = filter_class.safe_constantize.new(
+          arguments: @resource.get_filter_arguments(filter_class)
+        ).apply_query request, @query, filter_value
+      end
+
+      apply_pagination
+
+      # Create resources for each model
+      @resources = @models.map do |model|
+        @resource.hydrate(model: model, params: params).dup
+      end
+    end
+
+    def show
+      @resource.hydrate(model: @model, view: :show, user: _current_user, params: params)
+
+      set_actions
+
+      @page_title = @resource.default_panel_name.to_s
+
+      # If we're accessing this resource via another resource add the parent to the breadcrumbs.
+      if params[:via_resource_class].present? && params[:via_resource_id].present?
+        via_resource = Jav::App.get_resource(params[:via_resource_class]).dup
+        via_model = via_resource.find_record params[:via_resource_id], params: params
+        via_resource.hydrate model: via_model
+
+        add_breadcrumb via_resource.plural_name, resources_path(resource: via_resource)
+        add_breadcrumb via_resource.model_title, resource_path(model: via_model, resource: via_resource)
+      else
+        add_breadcrumb @resource.plural_name.humanize, resources_path(resource: @resource)
+      end
+
+      add_breadcrumb @resource.model_title
+      add_breadcrumb I18n.t("jav.details").upcase_first
+    end
+
+    def new
+      @model = @resource.model_class.new
+      @resource = @resource.hydrate(model: @model, view: :new, user: _current_user)
+
+      # Handle special cases when creating a new record via a belongs_to relationship
+      return render turbo_stream: turbo_stream.append('attach_modal', partial: 'jav/base/new_via_belongs_to') if params[:via_belongs_to_resource_class].present?
+
+      set_actions
+
+      @page_title = @resource.default_panel_name.to_s
+
+      if is_associated_record?
+        via_resource = Jav::App.get_resource_by_model_name(params[:via_relation_class]).dup
+        via_model = via_resource.find_record params[:via_resource_id], params: params
+        via_resource.hydrate model: via_model
+
+        add_breadcrumb via_resource.plural_name, resources_path(resource: via_resource)
+        add_breadcrumb via_resource.model_title, resource_path(model: via_model, resource: via_resource)
+      end
+
+      add_breadcrumb @resource.plural_name.humanize, resources_path(resource: @resource)
+      add_breadcrumb t("jav.new").humanize
+    end
+
+    def edit
+      set_actions
+    end
+
+    def create
+      # model gets instantiated and filled in the fill_model method
+      saved = save_model
+      @resource.hydrate(model: @model, view: :new, user: _current_user)
+
+      # This means that the record has been created through another parent record and we need to attach it somehow.
+      if params[:via_resource_id].present? && params[:via_belongs_to_resource_class].nil?
+        @reflection = @model.class.reflect_on_association(params[:via_relation])
+        # Figure out what kind of association does the record have with the parent record
+
+        # Fills in the required infor for belongs_to and has_many
+        # Get the foreign key and set it to the id we received in the params
+        if @reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection) || @reflection.is_a?(ActiveRecord::Reflection::HasManyReflection)
+          related_resource = Jav::App.get_resource_by_model_name params[:via_relation_class]
+          related_record = related_resource.find_record params[:via_resource_id], params: params
+
+          @model.send(:"#{@reflection.foreign_key}=", related_record.id)
+          @model.save
+        end
+
+        # For when working with has_one, has_one_through, has_many_through, has_and_belongs_to_many, polymorphic
+        if @reflection.is_a?(ActiveRecord::Reflection::ThroughReflection) || @reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+          # find the record
+          via_resource = ::Jav::App.get_resource_by_model_name(params[:via_relation_class]).dup
+          @related_record = via_resource.find_record params[:via_resource_id], params: params
+          association_name = BaseResource.valid_association_name(@model, params[:via_relation])
+
+          if params[:via_association_type] == "has_one"
+            # On has_one scenarios we should switch the @record and @related_record
+            @related_record.send(:"#{@reflection.parent_reflection.inverse_of.name}=", @model)
+          else
+            @model.send(association_name) << @related_record
+          end
+        end
+      end
+
+      add_breadcrumb @resource.plural_name.humanize, resources_path(resource: @resource)
+      add_breadcrumb t("jav.new").humanize
+      set_actions
+
+      if saved
+        create_success_action
+      else
+        create_fail_action
+      end
+    end
+
+    def update
+      # model gets instantiated and filled in the fill_model method
+      saved = save_model
+      @resource = @resource.hydrate(model: @model, view: :edit, user: _current_user)
+      set_actions
+
+      if saved
+        update_success_action
+      else
+        update_fail_action
+      end
+    end
+
+    def destroy
+      if destroy_model
+        destroy_success_action
+      else
+        destroy_fail_action
+      end
+    end
+
+    def order
+      direction = params[:direction].to_sym
+
+      if direction.present?
+        @resource
+          .hydrate(model: @model, params: params)
+          .ordering_host
+          .order direction
+      end
+
+      respond_to do |format|
+        format.html { redirect_to params[:referrer] || resources_path(resource: @resource) }
+      end
+    end
+
+    private
+
+    def save_model
+      perform_action_and_record_errors do
+        save_model_action
+      end
+    end
+
+    def save_model_action
+      @model.save!
+    end
+
+    def destroy_model
+      perform_action_and_record_errors do
+        destroy_model_action
+      end
+    end
+
+    def destroy_model_action
+      @model.destroy!
+    end
+
+    def perform_action_and_record_errors(&block)
+      begin
+        succeeded = yield
+      rescue StandardError => exception
+        # In case there's an error somewhere else than the model
+        # Example: When you save a license that should create a user for it and creating that user throws and error.
+        # Example: When you Try to delete a record and has a foreign key constraint.
+        exception_message = exception.message
+      end
+
+      # Add the errors from the model
+      @errors = @model.errors.full_messages.reject { |error| exception_message.include? error }.unshift exception_message
+
+      succeeded
+    end
+
+    def model_params
+      request_params = params.require(model_param_key).permit(permitted_params)
+
+      if @resource.devise_password_optional && request_params[:password].blank? && request_params[:password_confirmation].blank?
+        request_params.delete(:password_confirmation)
+        request_params.delete(:password)
+      end
+
+      request_params
+    end
+
+    def permitted_params
+      @resource.get_field_definitions.select(&:updatable).map(&:to_permitted_param).concat(extra_params).uniq
+    end
+
+    def extra_params
+      @resource.class.extra_params || []
+    end
+
+    def cast_nullable(params)
+      fields = @resource.get_field_definitions
+
+      nullable_fields = fields.filter(&:nullable).to_h do |field|
+        [field.id, field.null_values]
+      end
+
+      params.each do |key, value|
+        nullable_values = nullable_fields[key.to_sym]
+
+        params[key] = nil if nullable_values.present? && value.in?(nullable_values)
+      end
+
+      params
+    end
+
+    def set_index_params
+      @index_params = {}
+
+      # Pagination
+      @index_params[:page] = params[:page] || 1
+      @index_params[:per_page] = Jav.configuration.per_page
+
+      @index_params[:per_page] = cookies[:per_page] if cookies[:per_page].present?
+
+      @index_params[:per_page] = Jav.configuration.via_per_page if @parent_model.present?
+
+      if params[:per_page].present?
+        @index_params[:per_page] = params[:per_page]
+        cookies[:per_page] = params[:per_page]
+      end
+
+      # Sorting
+      if params[:sort_by].present?
+        @index_params[:sort_by] = params[:sort_by]
+      elsif @resource.model_class.present? && @resource.model_class.column_names.include?("created_at")
+        @index_params[:sort_by] = :created_at
+      end
+
+      @index_params[:sort_direction] = params[:sort_direction] || :desc
+
+      # View types
+      @index_params[:view_type] = params[:view_type] || @resource.default_view_type || Jav.configuration.default_view_type
+      @index_params[:available_view_types] = @resource.available_view_types
+    end
+
+    def set_filters
+      @filters = @resource.get_filters.map do |filter|
+        filter[:class].new arguments: filter[:arguments]
+      end
+      @filters = @filters.select do |filter|
+        filter.visible_in_view(resource: @resource, parent_resource: @parent_resource)
+      end
+    end
+
+    def set_actions
+      @actions = @resource.get_actions.map do |action|
+        action[:class].new(model: @model, resource: @resource, view: @view, arguments: action[:arguments])
+      end
+      @actions = @actions.select do |action|
+        action.visible_in_view(parent_resource: @parent_resource)
+      end
+    end
+
+    def set_applied_filters
+      reset_filters if params[:reset_filter]
+
+      @applied_filters = Jav::Filters::BaseFilter.decode_filters(fetch_filters)
+
+      # Some filters react to others and will have to be merged into this
+      @applied_filters = @applied_filters.merge reactive_filters
+    rescue StandardError
+      @applied_filters = {}
+    end
+
+    def reactive_filters
+      filter_reactions = {}
+
+      # Go through all filters
+      @resource.get_filters.select do |filter|
+        filter[:class].instance_methods(false).include? :react
+      end
+      .each do |filter|
+        # Run the react method if it's present
+        reaction = filter[:class].new(arguments: filter[:arguments]).react
+
+        next if reaction.nil?
+
+        filter_reactions[filter[:class].to_s] = reaction
+      end
+
+      filter_reactions
+    end
+
+    # Get the default state of the filters and override with the user applied filters
+    def filters_to_be_applied
+      filter_defaults = {}
+
+      @resource.get_filters.each do |filter|
+        filter = filter[:class].new arguments: filter[:arguments]
+
+        filter_defaults[filter.class.to_s] = filter.default unless filter.default.nil?
+      end
+
+      filter_defaults.merge(@applied_filters)
+    end
+
+    def set_edit_title_and_breadcrumbs
+      @resource = @resource.hydrate(model: @model, view: :edit, user: _current_user)
+      @page_title = @resource.default_panel_name.to_s
+
+      last_crumb_args = {}
+      # If we're accessing this resource via another resource add the parent to the breadcrumbs.
+      if params[:via_resource_class].present? && params[:via_resource_id].present?
+        via_resource = Jav::App.get_resource(params[:via_resource_class]).dup
+        via_model = via_resource.find_record params[:via_resource_id], params: params
+        via_resource.hydrate model: via_model
+
+        add_breadcrumb via_resource.plural_name, resources_path(resource: via_resource)
+        add_breadcrumb via_resource.model_title, resource_path(model: via_model, resource: via_resource, active_tab_name: params[:active_tab_name])
+
+        last_crumb_args = {
+          via_resource_class: params[:via_resource_class],
+          via_resource_id: params[:via_resource_id]
+        }
+      else
+        add_breadcrumb @resource.plural_name.humanize, resources_path(resource: @resource)
+      end
+
+      add_breadcrumb @resource.model_title, resource_path(model: @resource.model, resource: @resource, **last_crumb_args)
+      add_breadcrumb t("jav.edit").humanize
+    end
+
+    def create_success_action
+      return render "close_modal_and_reload_field" if params[:via_belongs_to_resource_class].present?
+
+      respond_to do |format|
+        format.html { redirect_to after_create_path, notice: create_success_message }
+      end
+    end
+
+    def create_fail_action
+      flash.now[:error] = create_fail_message
+
+      respond_to do |format|
+        format.html { render :new, status: :unprocessable_entity }
+        format.turbo_stream { render "create_fail_action" }
+      end
+    end
+
+    def create_success_message
+      "#{@resource.name} #{t('jav.was_successfully_created')}."
+    end
+
+    def create_fail_message
+      t "jav.you_missed_something_check_form"
+    end
+
+    def after_create_path
+      # If this is an associated record return to the association show page
+      if is_associated_record?
+        parent_resource = ::Jav::App.get_resource_by_model_name(params[:via_relation_class]).dup
+        association_name = BaseResource.valid_association_name(@model, params[:via_relation])
+
+        return resource_view_path(
+          model: @model.send(association_name),
+          resource: parent_resource,
+          resource_id: params[:via_resource_id]
+        )
+      end
+
+      redirect_path_from_resource_option(:after_create_path) || resource_view_response_path
+    end
+
+    def update_success_action
+      respond_to do |format|
+        format.html { redirect_to after_update_path, notice: update_success_message }
+      end
+    end
+
+    def update_fail_action
+      respond_to do |format|
+        flash.now[:error] = update_fail_message
+        format.html { render :edit, status: :unprocessable_entity }
+      end
+    end
+
+    def update_success_message
+      "#{@resource.name} #{t('jav.was_successfully_updated')}."
+    end
+
+    def update_fail_message
+      t "jav.you_missed_something_check_form"
+    end
+
+    def after_update_path
+      return params[:referrer] if params[:referrer].present?
+
+      redirect_path_from_resource_option(:after_update_path) || resource_view_response_path
+    end
+
+    # Needs a different name, otwherwise, in some places, this can be called instead helpers.resource_view_path
+    def resource_view_response_path
+      helpers.resource_view_path(model: @model, resource: @resource)
+    end
+
+    def destroy_success_action
+      respond_to do |format|
+        format.html { redirect_to after_destroy_path, notice: destroy_success_message }
+      end
+    end
+
+    def destroy_fail_action
+      flash.now[:error] = destroy_fail_message
+
+      respond_to do |format|
+        format.turbo_stream { render partial: "jav/partials/flash_alerts" }
+      end
+    end
+
+    def destroy_success_message
+      t("jav.resource_destroyed", attachment_class: @attachment_class)
+    end
+
+    def destroy_fail_message
+      @errors.present? ? @errors.join(". ") : t("jav.failed")
+    end
+
+    def after_destroy_path
+      params[:referrer] || resources_path(resource: @resource, turbo_frame: params[:turbo_frame], view_type: params[:view_type])
+    end
+
+    def redirect_path_from_resource_option(action = :after_update_path)
+      return nil if @resource.class.send(action).blank?
+
+      if @resource.class.send(action) == :index
+        resources_path(resource: @resource)
+      elsif @resource.class.send(action) == :edit || Jav.configuration.resource_default_view == :edit
+        edit_resource_path(resource: @resource, model: @resource.model)
+      else
+        resource_path(model: @model, resource: @resource)
+      end
+    end
+
+    def is_associated_record?
+      params[:via_relation_class].present? && params[:via_resource_id].present?
+    end
+
+    # Set pagy locale from params or from jav configuration, if both nil locale = "en"
+    def set_pagy_locale
+      @pagy_locale = locale.to_s || Jav.configuration.locale || "en"
+    end
+
+    def apply_pagination
+      @pagy, @models = @resource.apply_pagination(index_params: @index_params, query: @query)
+    end
+  end
+end

data/app/controllers/jav/dashboards/cards_controller.rb

@@ -0,0 +1,37 @@
+require_dependency "jav/application_controller"
+
+module Jav
+  module Dashboards
+    class CardsController < ApplicationController
+      before_action :set_dashboard
+      before_action :set_card
+      before_action :detect_chartkick
+
+      def show
+        render(:chartkick_missing) unless @chartkick_installed
+      end
+
+      private
+
+      def set_dashboard
+        @dashboard = Jav::App.get_dashboard_by_id params[:dashboard_id]
+
+        raise ActionController::RoutingError, "Not Found" if @dashboard.nil? || @dashboard.is_hidden?
+      end
+
+      def set_card
+        @card = @dashboard.item_at_index(params[:index].to_i).tap do |card|
+          card.hydrate(dashboard: @dashboard)
+        end
+      end
+
+      def detect_chartkick
+        @chartkick_installed = if @card.class.ancestors.map(&:to_s).include?("Jav::Dashboards::ChartkickCard")
+                                 defined?(Chartkick)
+                               else
+                                 true
+                               end
+      end
+    end
+  end
+end

data/app/controllers/jav/dashboards_controller.rb

@@ -0,0 +1,22 @@
+require_dependency "jav/application_controller"
+
+module Jav
+  class DashboardsController < ApplicationController
+    before_action :set_dashboard, only: :show
+
+    def show
+      @page_title = @dashboard.name
+    end
+
+    private
+
+    def set_dashboard
+      @dashboard = Jav::App.get_dashboard_by_id params[:id]
+
+      authorized = Jav::Hosts::BaseHost.new(block: @dashboard.authorize).handle
+      raise Jav::NotAuthorizedError, "Not Authorized" unless authorized
+
+      raise ActionController::RoutingError, "Not Found" if @dashboard.nil? || @dashboard.is_hidden?
+    end
+  end
+end

data/app/controllers/jav/debug_controller.rb

@@ -0,0 +1,23 @@
+require_dependency "jav/application_controller"
+
+module Jav
+  class DebugController < ApplicationController
+    def index; end
+
+    def report; end
+
+    def refresh_license
+      license = Licensing::LicenseManager.refresh_license request
+
+      if license.valid?
+        flash[:notice] = "javhq.io responded: \"#{license.id.humanize} license is valid\"."
+      elsif license.response['reason'].present?
+        flash[:error] = "javhq.io responded: \"#{license.response['reason']}\"."
+      else
+        flash[:error] = license.response['error']
+      end
+
+      redirect_back fallback_location: jav.jav_private_debug_index_path
+    end
+  end
+end

data/app/controllers/jav/home_controller.rb

@@ -0,0 +1,24 @@
+require_dependency "jav/application_controller"
+
+module Jav
+  class HomeController < ApplicationController
+    def index
+      if Jav.configuration.home_path.present?
+        # If the home_path is a block run it, if not, just use it
+        computed_path = if Jav.configuration.home_path.respond_to? :call
+                          instance_exec(&Jav.configuration.home_path)
+                        else
+                          Jav.configuration.home_path
+                        end
+
+        redirect_to computed_path
+      elsif !Rails.env.development?
+        @page_title = "Get started"
+        resource = Jav::App.resources.min_by(&:model_key)
+        redirect_to resources_path(resource: resource)
+      end
+    end
+
+    def failed_to_load; end
+  end
+end

data/app/controllers/jav/private_controller.rb

@@ -0,0 +1,9 @@
+require_dependency "jav/application_controller"
+
+module Jav
+  class PrivateController < ApplicationController
+    def design
+      @page_title = "Design [Private]"
+    end
+  end
+end

data/app/controllers/jav/reorder_controller.rb

@@ -0,0 +1,25 @@
+require_dependency "jav/application_controller"
+
+module Jav
+  class ReorderController < ApplicationController
+    before_action :set_resource_name
+    before_action :set_resource
+    before_action :hydrate_resource
+    before_action :set_model
+
+    def order
+      direction = params[:direction].to_sym
+
+      if direction.present?
+        @resource
+          .hydrate(model: @model, params: params)
+          .ordering_host
+          .order direction
+      end
+
+      respond_to do |format|
+        format.html { redirect_to params[:referrer] || resources_path(resource: @resource) }
+      end
+    end
+  end
+end

data/app/controllers/jav/resources_controller.rb

@@ -0,0 +1,6 @@
+require_dependency "jav/base_controller"
+
+module Jav
+  class ResourcesController < BaseController
+  end
+end