effective_resources 0.9.5 → 0.10.0

data/app/controllers/concerns/effective/crud_controller/actions.rb

@@ -0,0 +1,289 @@
+module Effective
+  module CrudController
+    module Actions
+
+      def index
+        Rails.logger.info 'Processed by Effective::CrudController#index'
+
+        EffectiveResources.authorize!(self, :index, resource_klass)
+        @page_title ||= resource_plural_name.titleize
+
+        self.resources ||= resource_scope.all
+
+        if (datatable = resource_datatable_class).present?
+          @datatable ||= datatable.new(resource_datatable_attributes)
+          @datatable.view = view_context
+        end
+
+        run_callbacks(:resource_render)
+      end
+
+      def new
+        Rails.logger.info 'Processed by Effective::CrudController#new'
+
+        self.resource ||= resource_scope.new
+
+        self.resource.assign_attributes(
+          params.to_unsafe_h.except(:controller, :action, :id).select { |k, v| resource.respond_to?("#{k}=") }
+        )
+
+        if params[:duplicate_id]
+          duplicate = resource_scope.find(params[:duplicate_id])
+          EffectiveResources.authorize!(self, :show, duplicate)
+
+          self.resource = duplicate_resource(duplicate)
+          raise "expected duplicate_resource to return an unsaved new #{resource_klass} resource" unless resource.kind_of?(resource_klass) && resource.new_record?
+
+          if (message = flash[:success].to_s).present?
+            flash.delete(:success)
+            flash.now[:success] = "#{message.chomp('.')}. Adding another #{resource_name.titleize} based on previous."
+          end
+        end
+
+        EffectiveResources.authorize!(self, :new, resource)
+        @page_title ||= "New #{resource_name.titleize}"
+
+        run_callbacks(:resource_render)
+      end
+
+      def create
+        Rails.logger.info 'Processed by Effective::CrudController#create'
+
+        self.resource ||= resource_scope.new
+        action = commit_action[:action]
+
+        resource.assign_attributes(send(resource_params_method_name))
+        resource.created_by = current_user if resource.respond_to?(:created_by=)
+
+        EffectiveResources.authorize!(self, (action == :save ? :create : action), resource)
+        @page_title ||= "New #{resource_name.titleize}"
+
+        respond_to do |format|
+          if save_resource(resource, action)
+            request.format = :html if specific_redirect_path?
+
+            format.html do
+              flash[:success] ||= resource_flash(:success, resource, action)
+              redirect_to(resource_redirect_path)
+            end
+
+            format.js do
+              flash.now[:success] ||= resource_flash(:success, resource, action)
+              reload_resource # create.js.erb
+            end
+          else
+            flash.delete(:success)
+            flash.now[:danger] ||= resource_flash(:danger, resource, action)
+
+            run_callbacks(:resource_render)
+
+            format.html { render :new }
+            format.js {} # create.js.erb
+          end
+        end
+      end
+
+      def show
+        Rails.logger.info 'Processed by Effective::CrudController#show'
+
+        self.resource ||= resource_scope.find(params[:id])
+
+        EffectiveResources.authorize!(self, :show, resource)
+        @page_title ||= resource.to_s
+
+        run_callbacks(:resource_render)
+      end
+
+      def edit
+        Rails.logger.info 'Processed by Effective::CrudController#edit'
+
+        self.resource ||= resource_scope.find(params[:id])
+
+        EffectiveResources.authorize!(self, :edit, resource)
+        @page_title ||= "Edit #{resource}"
+
+        run_callbacks(:resource_render)
+      end
+
+      def update
+        Rails.logger.info 'Processed by Effective::CrudController#update'
+
+        self.resource ||= resource_scope.find(params[:id])
+        action = commit_action[:action]
+
+        EffectiveResources.authorize!(self, (action == :save ? :update : action), resource)
+        @page_title ||= "Edit #{resource}"
+
+        resource.assign_attributes(send(resource_params_method_name))
+        resource.current_user = current_user if resource.respond_to?(:current_user=)
+
+        respond_to do |format|
+          if save_resource(resource, action)
+            request.format = :html if specific_redirect_path?
+
+            format.html do
+              flash[:success] ||= resource_flash(:success, resource, action)
+              redirect_to(resource_redirect_path)
+            end
+
+            format.js do
+              flash.now[:success] ||= resource_flash(:success, resource, action)
+              reload_resource # update.js.erb
+            end
+          else
+            flash.delete(:success)
+            flash.now[:danger] ||= resource_flash(:danger, resource, action)
+
+            run_callbacks(:resource_render)
+
+            format.html { render :edit }
+            format.js { } # update.js.erb
+          end
+        end
+      end
+
+      def destroy
+        Rails.logger.info 'Processed by Effective::CrudController#destroy'
+
+        self.resource = resource_scope.find(params[:id])
+        action = :destroy
+
+        EffectiveResources.authorize!(self, action, resource)
+        @page_title ||= "Destroy #{resource}"
+
+        respond_to do |format|
+          if save_resource(resource, action)
+            request.format = :html if specific_redirect_path?(action)
+
+            format.html do
+              flash[:success] ||= resource_flash(:success, resource, action)
+              redirect_to(resource_redirect_path(action))
+            end
+
+            format.js do
+              flash.now[:success] ||= resource_flash(:success, resource, action)
+              # destroy.js.erb
+            end
+          else
+            flash.delete(:success)
+            request.format = :html  # Don't run destroy.js.erb
+
+            format.html do
+              flash[:danger] = (flash.now[:danger].presence || resource_flash(:danger, resource, action))
+              redirect_to(resource_redirect_path(action))
+            end
+          end
+        end
+      end
+
+      def member_action(action)
+        Rails.logger.info "Processed by Effective::CrudController#member_action"
+
+        self.resource ||= resource_scope.find(params[:id])
+
+        EffectiveResources.authorize!(self, action, resource)
+        @page_title ||= "#{action.to_s.titleize} #{resource}"
+
+        if request.get?
+          run_callbacks(:resource_render); return
+        end
+
+        to_assign = (send(resource_params_method_name) rescue {})
+        resource.assign_attributes(to_assign) if to_assign.present? && to_assign.permitted?
+
+        resource.current_user = current_user if resource.respond_to?(:current_user=)
+
+        respond_to do |format|
+          if save_resource(resource, action)
+            request.format = :html if specific_redirect_path?(action)
+
+            format.html do
+              flash[:success] ||= resource_flash(:success, resource, action)
+              redirect_to(resource_redirect_path(action))
+            end
+
+            format.js do
+              flash.now[:success] ||= resource_flash(:success, resource, action)
+              reload_resource
+              render_member_action(action)
+            end
+          else
+            flash.delete(:success)
+            flash.now[:danger] ||= resource_flash(:danger, resource, action)
+
+            run_callbacks(:resource_render)
+
+            format.html do
+              if resource_edit_path && (referer_redirect_path || '').end_with?(resource_edit_path)
+                @page_title ||= "Edit #{resource}"
+                render :edit
+              elsif resource_new_path && (referer_redirect_path || '').end_with?(resource_new_path)
+                @page_title ||= "New #{resource_name.titleize}"
+                render :new
+              elsif resource_show_path && (referer_redirect_path || '').end_with?(resource_show_path)
+                @page_title ||= resource_name.titleize
+                render :show
+              else
+                @page_title ||= resource.to_s
+                flash[:danger] = flash.now[:danger]
+                redirect_to(referer_redirect_path || resource_redirect_path(action))
+              end
+            end
+
+            format.js { render_member_action(action) }
+          end
+        end
+      end
+
+      def collection_action(action)
+        Rails.logger.info 'Processed by Effective::CrudController#collection_action'
+
+        action = action.to_s.gsub('bulk_', '').to_sym
+
+        if params[:ids].present?
+          self.resources ||= resource_scope.where(id: params[:ids])
+        end
+
+        if effective_resource.scope?(action)
+          self.resources ||= resource_scope.public_send(action)
+        end
+
+        self.resources ||= resource_scope.all
+
+        EffectiveResources.authorize!(self, action, resource_klass)
+        @page_title ||= "#{action.to_s.titleize} #{resource_plural_name.titleize}"
+
+        if request.get?
+          run_callbacks(:resource_render); return
+        end
+
+        raise "expected all #{resource_name} objects to respond to #{action}!" if resources.to_a.present? && !resources.all? { |resource| resource.respond_to?("#{action}!") }
+
+        successes = 0
+
+        # No attributes are assigned or saved. We purely call action! on the resource
+
+        ActiveRecord::Base.transaction do
+          successes = resources.select do |resource|
+            begin
+              resource.public_send("#{action}!") if EffectiveResources.authorized?(self, action, resource)
+            rescue => e
+              false
+            end
+          end.length
+        end
+
+        render json: { status: 200, message: "Successfully #{action_verb(action)} #{successes} / #{resources.length} selected #{resource_plural_name}" }
+      end
+    end
+
+    private
+
+    # Which member javascript view to render: #{action}.js or effective_resources member_action.js
+    def render_member_action(action)
+      view = lookup_context.template_exists?(action, _prefixes) ? action : :member_action
+      render(view, locals: { action: action })
+    end
+
+  end
+end

data/app/controllers/concerns/effective/crud_controller/dsl.rb

@@ -0,0 +1,81 @@
+module Effective
+  module CrudController
+    module Dsl
+
+      # https://github.com/rails/rails/blob/v5.1.4/actionpack/lib/abstract_controller/callbacks.rb
+      def before_render(*names, &blk)
+        _insert_callbacks(names, blk) { |name, options| set_callback(:resource_render, :before, name, options) }
+      end
+
+      def after_save(*names, &blk)
+        _insert_callbacks(names, blk) { |name, options| set_callback(:resource_save, :after, name, options) }
+      end
+
+      def after_error(*names, &blk)
+        _insert_callbacks(names, blk) { |name, options| set_callback(:resource_error, :after, name, options) }
+      end
+
+      # This controls the form submit options of effective_submit
+      # Takes precidence over any 'on' dsl commands
+      #
+      # Effective::Resource will populate this with all crud actions
+      # And you can control the details with this DSL:
+      #
+      # submit :approve, 'Save and Approve', unless: -> { resource.approved? }, redirect: :show
+      #
+      # submit :toggle, 'Blacklist', if: -> { sync? }, class: 'btn btn-primary'
+      # submit :toggle, 'Whitelist', if: -> { !sync? }, class: 'btn btn-primary'
+      # submit :save, 'Save', success: -> { "#{resource} was saved okay!" }
+      def submit(action, label = nil, args = {})
+        _insert_submit(action, label, args)
+      end
+
+      # This controls the resource buttons section of the page
+      # Takes precidence over any on commands
+      #
+      # Effective::Resource will populate this with all member_actions
+      #
+      # button :approve, 'Approve', unless: -> { resource.approved? }, redirect: :show
+      # button :decline, false
+      def button(action, label = nil, args = {})
+        _insert_button(action, label, args)
+      end
+
+      # This is a way of defining the redirect, flash etc of any action without tweaking defaults
+      # submit and buttons options will be merged ontop of these
+      def on(action, args = {})
+        _insert_on(action, args)
+      end
+
+      # page_title 'My Title', only: [:new]
+      def page_title(label = nil, opts = {}, &block)
+        opts = label if label.kind_of?(Hash)
+        raise 'expected a label or block' unless (label || block_given?)
+
+        instance_exec do
+          before_action(opts) { @page_title ||= (block_given? ? instance_exec(&block) : label).to_s }
+        end
+      end
+
+      # resource_scope -> { current_user.things }
+      # resource_scope -> { Thing.active.where(user: current_user) }
+      # resource_scope do
+      #   { user_id: current_user.id }
+      # end
+      # Nested controllers? sure
+      # resource_scope -> { User.find(params[:user_id]).things }
+
+      # Return value should be:
+      # a Relation: Thing.where(user: current_user)
+      # a Hash: { user_id: current_user.id }
+      def resource_scope(obj = nil, opts = {}, &block)
+        raise 'expected a proc or block' unless (obj.respond_to?(:call) || block_given?)
+
+        instance_exec do
+          before_action(opts) { @_effective_resource_scope ||= instance_exec(&(block_given? ? block : obj)) }
+        end
+      end
+
+    end
+  end
+end

data/app/controllers/concerns/effective/crud_controller/paths.rb

@@ -0,0 +1,87 @@
+module Effective
+  module CrudController
+    module Paths
+
+      def resource_redirect_path(action = nil)
+        submit = commit_action(action)
+        redirect = submit[:redirect].respond_to?(:call) ? instance_exec(&submit[:redirect]) : submit[:redirect]
+
+        commit_action_redirect = case redirect
+          when :index     ; resource_index_path
+          when :edit      ; resource_edit_path
+          when :show      ; resource_show_path
+          when :new       ; resource_new_path
+          when :duplicate ; resource_duplicate_path
+          when :back      ; referer_redirect_path
+          when :save      ; [resource_edit_path, resource_show_path].compact.first
+          when Symbol     ; resource_action_path(submit[:action])
+          when String     ; redirect
+          else            ; nil
+        end
+
+        return commit_action_redirect if commit_action_redirect.present?
+
+        if action == :destroy
+          return [referer_redirect_path, resource_index_path, root_path].compact.first
+        end
+
+        case params[:commit].to_s
+        when 'Save'
+          [resource_edit_path, resource_show_path, resource_index_path]
+        when 'Save and Add New', 'Add New'
+          [resource_new_path, resource_index_path]
+        when 'Duplicate'
+          [resource_duplicate_path, resource_index_path]
+        when 'Continue', 'Save and Continue'
+          [resource_index_path]
+        else
+          [referer_redirect_path, resource_edit_path, resource_show_path, resource_index_path]
+        end.compact.first.presence || root_path
+      end
+
+      def referer_redirect_path
+        url = request.referer.to_s
+
+        return if (resource && resource.respond_to?(:destroyed?) && resource.destroyed? && url.include?("/#{resource.to_param}"))
+        return if url.include?('duplicate_id=')
+        return unless (Rails.application.routes.recognize_path(URI(url).path) rescue false)
+
+        url
+      end
+
+      def specific_redirect_path?(action = nil)
+        submit = commit_action(action)
+        (submit[:redirect].respond_to?(:call) ? instance_exec(&submit[:redirect]) : submit[:redirect]).present?
+      end
+
+      def resource_index_path
+        effective_resource.action_path(:index)
+      end
+
+      def resource_new_path
+        effective_resource.action_path(:new)
+      end
+
+      def resource_duplicate_path
+        effective_resource.action_path(:new, duplicate_id: resource.id)
+      end
+
+      def resource_edit_path
+        effective_resource.action_path(:edit, resource)
+      end
+
+      def resource_show_path
+        effective_resource.action_path(:show, resource)
+      end
+
+      def resource_destroy_path
+        effective_resource.action_path(:destroy, resource)
+      end
+
+      def resource_action_path(action)
+        effective_resource.action_path(action.to_sym, resource)
+      end
+
+    end
+  end
+end