jav 2.55.4

data/app/controllers/jav/application_controller.rb

@@ -0,0 +1,323 @@
+module Jav
+  class ApplicationController < ::ActionController::Base
+    if defined?(Pundit::Authorization)
+      Jav::ApplicationController.include Pundit::Authorization
+    elsif defined?(Pundit)
+      Jav::ApplicationController.include Pundit
+    end
+
+    include Jav::ApplicationHelper
+    include Jav::UrlHelpers
+    include Jav::Concerns::Breadcrumbs
+
+    protect_from_forgery with: :exception
+    around_action :set_jav_locale
+    around_action :set_force_locale, if: -> { params[:force_locale].present? }
+    before_action :set_default_locale, if: -> { params[:set_locale].present? }
+    before_action :init_app
+    before_action :set_resource_name
+    before_action :_authenticate!
+    before_action :set_authorization
+    before_action :set_container_classes
+    before_action :add_initial_breadcrumbs
+    before_action :set_view
+    before_action :set_sidebar_open
+
+    rescue_from ActiveRecord::RecordInvalid, with: :exception_logger
+
+    helper_method :_current_user, :resources_path, :resource_path, :new_resource_path, :edit_resource_path, :resource_attach_path, :resource_detach_path, :related_resources_path, :turbo_frame_request?, :resource_view_path
+    add_flash_types :info, :warning, :success, :error
+
+    def init_app
+      Jav::App.init request: request, context: context, current_user: _current_user, view_context: view_context, params: params
+
+      @license = Jav::App.license
+    end
+
+    def exception_logger(exception)
+      respond_to do |format|
+        format.html { raise exception }
+        format.json do
+          render json: {
+            errors: exception.respond_to?(:record) && exception.record.present? ? exception.record.errors : [],
+            message: exception.message,
+            traces: exception.backtrace
+          }, status: ActionDispatch::ExceptionWrapper.status_code_for_exception(exception.class.name)
+        end
+      end
+    end
+
+    # 因为没做任何操作，可以直接注释，如果对render 有额外的处理可以在子类重写
+    # def render(*args)
+
+    #   super
+    # end
+
+    def check_jav_license
+      true
+    end
+
+    def _current_user
+      instance_eval(&Jav.configuration.current_user)
+    end
+
+    def context
+      instance_eval(&Jav.configuration.context)
+    end
+
+    # This is coming from Turbo::Frames::FrameRequest module.
+    # Exposing it as public method
+    # def turbo_frame_request?
+    #   super
+    # end
+    # use module#public to exposing it as public method
+    public :turbo_frame_request?
+
+    private
+
+    def set_resource_name
+      @resource_name = resource_name
+    end
+
+    def set_related_resource_name
+      @related_resource_name = related_resource_name
+    end
+
+    def set_resource
+      raise ActionController::RoutingError, "No route matches" if resource.nil?
+
+      @resource = resource.hydrate(params: params)
+    end
+
+    def set_related_resource
+      @related_resource = related_resource.hydrate(params: params)
+    end
+
+    def set_model
+      @model = @resource.find_record(params[:id], query: model_find_scope, params: params)
+    end
+
+    def model_find_scope
+      eager_load_files(@resource, model_scope)
+    end
+
+    def model_scope
+      @resource.class.find_scope
+    end
+
+    def set_related_model
+      association_name = BaseResource.valid_association_name(@model, params[:related_name])
+      @related_model = if @field.is_a? Jav::Fields::HasOneField
+                         @model.send association_name
+                       else
+                         @related_resource.find_record params[:related_id], query: eager_load_files(@related_resource, @model.send(association_name)), params: params
+                       end
+    end
+
+    def set_view
+      @view = action_name.to_sym
+    end
+
+    def set_model_to_fill
+      @model_to_fill = @resource.model_class.new if @view == :create
+      @model_to_fill = @model if @view == :update
+
+      # If resource.model is nil, most likely the user is creating a new record.
+      # In that case, to access resource.model in visible and readonly blocks we hydrate the resource with a new model.
+      @resource.hydrate(model: @model_to_fill) if @resource.model.nil?
+    end
+
+    def fill_model
+      # We have to skip filling the the model if this is an attach action
+      is_attach_action = params[model_param_key].blank? && params[:related_name].present? && params[:fields].present?
+
+      return if is_attach_action
+
+      @model = @resource.fill_model(@model_to_fill, cast_nullable(model_params), extra_params: extra_params)
+    end
+
+    def hydrate_resource
+      @resource.hydrate(view: action_name.to_sym, user: _current_user, model: @model)
+    end
+
+    def hydrate_related_resource
+      @related_resource.hydrate(view: action_name.to_sym, user: _current_user, model: @related_model)
+    end
+
+    def authorize_base_action
+      class_to_authorize = @model || @resource.model_class
+
+      authorize_action class_to_authorize
+    end
+
+    def authorize_action(class_to_authorize, action = nil)
+      # Use the provided action or figure it out from the request
+      action_to_authorize = action || action_name
+
+      @authorization.set_record(class_to_authorize).authorize_action action_to_authorize.to_sym
+    end
+
+    # Get the pluralized resource name for this request
+    # Ex: projects, teams, users
+    def resource_name
+      return params[:resource_name] if params[:resource_name].present?
+
+      return controller_name if controller_name.present?
+
+      begin
+        request.path
+               .match(%r{/?#{Jav::App.root_path.delete('/')}/resources/([a-z1-9\-_]*)/?}mi)
+               .captures
+               .first
+      rescue StandardError => e
+        Rails.logger.error "method-resource_name: #{e.message}"
+      end
+    end
+
+    def related_resource_name
+      params[:related_name]
+    end
+
+    # Gets the Jav resource for this request based on the request from the `resource_name` "param"
+    # Ex: Jav::Resources::Project, Jav::Resources::Team, Jav::Resources::User
+    def resource
+      resource = App.get_resource @resource_name.to_s.camelize.singularize
+
+      return resource if resource.present?
+
+      App.get_resource_by_controller_name @resource_name
+    end
+
+    def related_resource
+      # Find the field from the parent resource
+      field = @resource.get_field params[:related_name]
+
+      return field.use_resource if field&.use_resource.present?
+
+      reflection = @model.class.reflect_on_association(params[:related_name])
+
+      reflected_model = reflection.klass
+
+      App.get_resource_by_model_name reflected_model
+    end
+
+    def eager_load_files(resource, query)
+      # Get the non-computed file fields and try to eager load them
+      attachment_fields = resource
+                          .attachment_fields
+                          .reject(&:computed)
+
+      # Jav::Fields::FileField or Jav::Fields::FilesField
+      attachment_fields.presence&.map do |field|
+        # attachment = case field.class.to_s
+        #              when "Jav::Fields::FilesField"
+        #                "attachments"
+        #              else
+        #                "attachment"
+        #              end
+        attachment = field.instance_of?(::Jav::Fields::FileField) ? "attachments" : "attachment"
+        query.includes "#{field.id}_#{attachment}": :blob
+      end
+
+      query
+    end
+
+    def _authenticate!
+      instance_eval(&Jav.configuration.authenticate)
+    end
+
+    def render_unauthorized(_exception)
+      flash[:notice] = t "jav.not_authorized"
+
+      redirect_url = if request.referer.blank? || (request.referer == request.url)
+                       root_url
+                     else
+                       request.referer
+                     end
+
+      redirect_to(redirect_url)
+    end
+
+    def set_authorization
+      # We need to set @resource_name for the #resource method to work properly
+      set_resource_name
+      @authorization = if resource
+                         resource.authorization(user: _current_user)
+                       else
+                         Services::AuthorizationService.new _current_user
+                       end
+    end
+
+    def set_container_classes
+      contain = true
+
+      contain = false if Jav.configuration.full_width_container || (Jav.configuration.full_width_index_view && action_name.to_sym == :index && self.class.superclass.to_s == "Jav::ResourcesController")
+
+      @container_classes = contain ? "2xl:container 2xl:mx-auto" : ""
+    end
+
+    def add_initial_breadcrumbs
+      instance_eval(&Jav.configuration.initial_breadcrumbs) if Jav.configuration.initial_breadcrumbs.present?
+    end
+
+    def on_root_path
+      [Jav.configuration.root_path, "#{Jav.configuration.root_path}/"].include?(request.original_fullpath)
+    end
+
+    def on_resources_path
+      request.original_url.match?(%r{.*#{Jav.configuration.root_path}/resources/.*})
+    end
+
+    def on_api_path
+      request.original_url.match?(%r{.*#{Jav.configuration.root_path}/jav_api/.*})
+    end
+
+    def on_dashboards_path
+      request.original_url.match?(%r{.*#{Jav.configuration.root_path}/dashboards/.*})
+    end
+
+    def on_debug_path
+      request.original_url.match?(%r{.*#{Jav.configuration.root_path}/jav_private/debug.*})
+    end
+
+    def on_custom_tool_page
+      !(on_root_path || on_resources_path || on_api_path || on_dashboards_path || on_debug_path)
+    end
+
+    def model_param_key
+      @resource.form_scope
+    end
+
+    # Sets the locale set in jav.rb initializer
+    def set_jav_locale(&action)
+      locale = Jav.configuration.locale || I18n.default_locale
+      I18n.with_locale(locale, &action)
+    end
+
+    # Enable the user to change the default locale with the `?set_locale=pt-BR` param
+    def set_default_locale
+      locale = params[:set_locale] || I18n.default_locale
+
+      I18n.default_locale = locale
+    end
+
+    # Temporary set the locale and reverting at the end of the request.
+    def set_force_locale(&action)
+      locale = params[:force_locale] || I18n.default_locale
+      I18n.with_locale(locale, &action)
+    end
+
+    def default_url_options
+      if params[:force_locale].present?
+        { **super, force_locale: params[:force_locale] }
+      else
+        super
+      end
+    end
+
+    def set_sidebar_open
+      value = cookies["#{Jav::COOKIES_KEY}.sidebar.open"]
+      @sidebar_open = value.blank? || value == "1"
+    end
+  end
+end

data/app/controllers/jav/associations_controller.rb

@@ -0,0 +1,172 @@
+require_dependency "jav/base_controller"
+
+module Jav
+  class AssociationsController < BaseController
+    before_action :set_model, only: %i[show index new create destroy order]
+    before_action :hydrate_resource, only: %i[show index new create destroy order]
+    before_action :set_related_resource_name
+    before_action :set_related_resource, only: %i[show index new create destroy order]
+    before_action :set_related_authorization
+    before_action :set_reflection_field
+    before_action :set_related_model, only: %i[show order]
+    before_action :hydrate_related_resource, only: %i[show index create destroy order]
+    before_action :set_reflection
+    before_action :set_attachment_class, only: %i[show index new create destroy order]
+    before_action :set_attachment_resource, only: %i[show index new create destroy order]
+    before_action :set_attachment_model, only: %i[create destroy order]
+    before_action :authorize_index_action, only: :index
+    before_action :authorize_attach_action, only: :new
+    before_action :authorize_detach_action, only: :destroy
+
+    def index
+      @parent_resource = @resource.dup
+      @resource = @related_resource
+      @parent_model = @parent_resource.find_record(params[:id], params: params)
+      @parent_resource.hydrate(model: @parent_model)
+      association_name = BaseResource.valid_association_name(@parent_model, params[:related_name])
+      @query = @related_authorization.apply_policy @parent_model.send(association_name)
+      @association_field = @parent_resource.get_field params[:related_name]
+
+      @query = Jav::Hosts::AssociationScopeHost.new(block: @association_field.scope, query: @query, parent: @parent_model).handle if @association_field.present? && @association_field.scope.present?
+
+      super
+    end
+
+    def show
+      @parent_resource = @resource
+      @parent_model = @model
+
+      @resource = @related_resource
+      @model = @related_model
+
+      super
+    end
+
+    def new
+      @resource.hydrate(model: @model)
+
+      return unless @field.present? && !@field.searchable
+
+      query = @related_authorization.apply_policy @attachment_class
+
+      # Add the association scope to the query scope
+      query = Jav::Hosts::AssociationScopeHost.new(block: @field.attach_scope, query: query, parent: @model).handle if @field.attach_scope.present?
+
+      @options = query.all.map do |model|
+        val = @attachment_resource.class.title.is_a?(Proc) ? Jav::ExecutionContext.new(target: @attachment_resource.class.title, resource: @attachment_resource, record: model).handle : model.send(@attachment_resource.class.title)
+        [val, model.id]
+      end
+    end
+
+    def create
+      association_name = BaseResource.valid_association_name(@model, params[:related_name])
+
+      if has_many_reflection?
+        @model.send(association_name) << @attachment_model
+      else
+        @model.send(:"#{association_name}=", @attachment_model)
+      end
+
+      respond_to do |format|
+        if @model.save
+          format.html { redirect_back fallback_location: resource_view_response_path, notice: t("jav.attachment_class_attached", attachment_class: @related_resource.name) }
+        else
+          format.html { render :new }
+        end
+      end
+    end
+
+    def destroy
+      association_name = BaseResource.valid_association_name(@model, params[:related_name])
+
+      if has_many_reflection?
+        @model.send(association_name).delete @attachment_model
+      else
+        @model.send(:"#{association_name}=", nil)
+      end
+
+      respond_to do |format|
+        format.html { redirect_to params[:referrer] || resource_view_response_path, notice: t("jav.attachment_class_detached", attachment_class: @attachment_class) }
+      end
+    end
+
+    def order
+      @parent_resource = @resource.dup
+      @resource = @related_resource
+      @model = @related_model
+
+      super
+    end
+
+    private
+
+    def set_reflection
+      @reflection = @model.class.reflect_on_association(params[:related_name])
+    end
+
+    def set_attachment_class
+      @attachment_class = @reflection.klass
+    end
+
+    def set_attachment_resource
+      @attachment_resource = @field.use_resource || (App.get_resource_by_model_name @attachment_class)
+    end
+
+    def set_attachment_model
+      @attachment_model = @related_resource.find_record attachment_id, params: params
+    end
+
+    def set_reflection_field
+      @field = @resource.get_field_definitions.find { |f| f.id == @related_resource_name.to_sym }
+      @field.hydrate(resource: @resource, model: @model, view: :new)
+    rescue StandardError
+    end
+
+    def attachment_id
+      params[:related_id] || params.require(:fields).permit(:related_id)[:related_id]
+    end
+
+    def reflection_class
+      if @reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+        @reflection.through_reflection.class
+      else
+        @reflection.class
+      end
+    end
+
+    def authorize_if_defined(method)
+      @authorization.set_record(@model)
+
+      return unless @authorization.has_method?(method.to_sym)
+
+      @authorization.authorize_action method.to_sym
+    end
+
+    def authorize_index_action
+      authorize_if_defined "view_#{@field.id}?"
+    end
+
+    def authorize_attach_action
+      authorize_if_defined "attach_#{@field.id}?"
+    end
+
+    def authorize_detach_action
+      authorize_if_defined "detach_#{@field.id}?"
+    end
+
+    def set_related_authorization
+      @related_authorization = if related_resource
+                                 related_resource.authorization(user: _current_user)
+                               else
+                                 Services::AuthorizationService.new _current_user
+                               end
+    end
+
+    def has_many_reflection?
+      reflection_class.in? [
+        ActiveRecord::Reflection::HasManyReflection,
+        ActiveRecord::Reflection::HasAndBelongsToManyReflection
+      ]
+    end
+  end
+end

data/app/controllers/jav/attachments_controller.rb

@@ -0,0 +1,61 @@
+require_dependency "jav/application_controller"
+
+module Jav
+  class AttachmentsController < ApplicationController
+    before_action :set_resource_name, only: %i[destroy create]
+    before_action :set_resource, only: %i[destroy create]
+    before_action :set_model, only: %i[destroy create]
+
+    def create
+      blob = ActiveStorage::Blob.create_and_upload! io: params[:file].to_io, filename: params[:filename]
+      association_name = BaseResource.valid_attachment_name(@model, params[:attachment_key])
+
+      raise ActionController::BadRequest, "Could not find the attachment association for #{params[:attachment_key]} (check the `attachment_key` for this Trix field)" if association_name.blank?
+
+      @model.send(association_name).attach blob
+      url = if blob.representable?
+              ori_variant = @model.attachment_reflections[association_name]&.named_variants&.fetch(:ori, nil)
+              if ori_variant
+                main_app.rails_blob_path(blob.representation(ori_variant.transformations))
+              else
+                main_app.rails_blob_path(blob.representation(resize_to_limit: [1024, 1024], saver: { subsample_mode: "on", strip: true, interlace: true, quality: 85 }))
+              end
+            else
+              main_app.rails_blob_path(blob)
+            end
+
+      render json: {
+        previewable: blob.representable?,
+        url: url,
+        href: main_app.url_for(blob)
+      }
+    end
+
+    def destroy
+      if authorized_to :delete
+        attachment = ActiveStorage::Attachment.find(params[:attachment_id])
+
+        flash.now[:notice] = if attachment.present?
+                               @destroyed = attachment.destroy
+                               t("jav.attachment_destroyed")
+                             else
+                               t("jav.failed_to_find_attachment")
+                             end
+      else
+        flash.now[:notice] = t("jav.not_authorized")
+      end
+
+      respond_to do |format|
+        format.turbo_stream do
+          render "destroy"
+        end
+      end
+    end
+
+    private
+
+    def authorized_to(action)
+      @resource.authorization.authorize_action("#{action}_#{params[:attachment_name]}?", record: @model, raise_exception: false)
+    end
+  end
+end