sunrise-cms 1.0.3 → 1.1.1

data/app/controllers/sunrise/activities_controller.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 module Sunrise
   class ActivitiesController < Sunrise::ApplicationController
     include Sunrise::Utils::SearchWrapper
-    
-    authorize_resource :class => false
-    
+
+    authorize_resource class: false
+
     def index
       per_page = Sunrise::Config.activities_per_page
       cur_page = (params[:page] || 1).to_i
       offset = (cur_page - 1) * per_page
-      
+
       @events = Sunrise.activities
       @events = @events.limit(per_page).offset(offset)
 
       respond_with(@events) do |format|
-        format.html { render :layout => params[:time].blank? }
+        format.html { render layout: params[:time].blank? }
       end
     end
   end

data/app/controllers/sunrise/application_controller.rb

@@ -1,27 +1,27 @@
+# frozen_string_literal: true
+
 module Sunrise
   class ApplicationController < ::ApplicationController
     include ::PublicActivity::StoreController
 
-    prepend_before_filter :authenticate_user!
+    prepend_before_action :authenticate_user!
     check_authorization
-    
+
     respond_to :html
-    
+
     protected
-          
-      def current_ability
-        @current_ability ||= ::Ability.new(current_user, :sunrise)
-      end
-      
-      rescue_from ::CanCan::AccessDenied do |exception|
-        Rails.logger.debug "Access denied on #{exception.action} #{exception.subject.inspect}, context: #{current_ability.context}, user: #{current_user.try(:id)}"
-        
-        flash[:failure] = I18n.t(:access_denied, :scope => [:flash, :users])
-              
-        respond_to do |format|
-          format.html { redirect_to(user_signed_in? ? main_app.root_path : new_session_path(:user)) }
-          format.any  { head :unauthorized }
-        end
+
+    def current_ability
+      @current_ability ||= ::Ability.new(current_user, :sunrise)
+    end
+
+    rescue_from ::CanCan::AccessDenied do |_exception|
+      flash[:failure] = I18n.t(:access_denied, scope: [:flash, :users])
+
+      respond_to do |format|
+        format.html { redirect_to(user_signed_in? ? main_app.root_path : new_session_path(:user)) }
+        format.any  { head :unauthorized }
       end
+    end
   end
 end

data/app/controllers/sunrise/dashboard_controller.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module Sunrise
   class DashboardController < Sunrise::ApplicationController
     include Sunrise::Utils::SearchWrapper
-    
-    authorize_resource :class => false
-    
-    def index
-    end
+
+    authorize_resource class: false
+
+    def index; end
   end
 end

data/app/controllers/sunrise/manager_controller.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 module Sunrise
   class ManagerController < Sunrise::ApplicationController
     include Sunrise::Utils::SearchWrapper
-    
-    before_filter :build_record, :only => [:new, :create]
-    before_filter :find_record, :only => [:show, :edit, :update, :destroy]
-    before_filter :authorize_resource
-    
+
+    before_action :build_record, only: %i[new create]
+    before_action :find_record, only: %i[show edit update destroy]
+    before_action :authorize_resource
+
     helper :all
     helper_method :abstract_model, :apply_scope, :scoped_index_path
-    
-    respond_to *Sunrise::Config.navigational_formats
-    respond_to :xml, :csv, :xlsx, :only => [:export]
-    
+
+    respond_to(*Sunrise::Config.navigational_formats)
+    respond_to :xml, :csv, :xlsx, only: %i[export]
+
     def index
       @records = abstract_model.apply_scopes(params)
 
@@ -19,148 +21,187 @@ module Sunrise
         format.html { render_with_scope(abstract_model.current_list) }
       end
     end
-    
+
     def show
       respond_with(@record) do |format|
-        format.html { render_with_scope } 
+        format.html { render_with_scope }
       end
     end
-    
+
     def new
-      @record.attributes = abstract_model.model_params
+      @record.assign_attributes(abstract_model.model_params)
+
       respond_with(@record) do |format|
-        format.html { render_with_scope } 
+        format.html { render_with_scope }
       end
     end
-    
+
     def create
       @record.update_attributes(model_params)
-      respond_with(@record, :location => redirect_after_update(@record))
+      respond_with(@record, location: redirect_after_update(@record))
     end
-    
+
     def edit
       respond_with(@record) do |format|
-        format.html { render_with_scope } 
+        format.html { render_with_scope }
       end
     end
-    
+
     def update
       @record.update_attributes(model_params)
-      respond_with(@record, :location => redirect_after_update(@record))
+      respond_with(@record, location: redirect_after_update(@record))
     end
-    
+
     def destroy
       @record.destroy
-      respond_with(@record, :location => scoped_index_path)
+      respond_with(@record, location: scoped_index_path)
     end
-    
+
     def export
       @records = abstract_model.apply_scopes(params, false)
-      
+
+      respond_to do |format|
+        format.xml  { render xml: @records }
+        format.json { render json: @records }
+        format.csv  { render abstract_model.export_options.merge(csv: @records) }
+
+        format.xlsx { render abstract_model.export_options.merge(xlsx: @records) } if defined?(Mime::XLSX)
+      end
+    end
+
+    def import
+      return render plain: 'Unacceptable', status: 422 unless import_possible?
+
+      @files = import_process_uploaded_files
+
       respond_to do |format|
-        format.xml  { render :xml => @records }
-        format.json { render :json => @records }
-        format.csv  { render abstract_model.export_options.merge(:csv => @records) }
-        
-        if defined?(Mime::XLSX)
-          format.xlsx { render abstract_model.export_options.merge(:xlsx => @records) }
+        format.html { redirect_to scoped_index_path }
+        format.json do
+          render json: { files: @files }
         end
       end
     end
-    
+
     def sort
       abstract_model.update_sort(params)
 
       respond_to do |format|
         format.html { redirect_to redirect_after_update }
-        format.json { render :json => params }
+        format.json { render json: params }
       end
     end
-    
+
     def mass_destroy
       abstract_model.destroy_all(params)
-      
+
       respond_to do |format|
         format.html { redirect_to redirect_after_update }
-        format.json { render :json => params }
+        format.json { render json: params }
       end
     end
-    
+
     protected
-    
-      def find_model
-        @abstract_model = Utils.get_model(params[:model_name], params)
-        raise ActionController::RoutingError.new("Sunrise model #{params[:model_name]} not found") if @abstract_model.nil?
-        @abstract_model
-      end
-      
-      def abstract_model
-        @abstract_model ||= find_model
-      end
-      
-      def build_record
-        @record = abstract_model.build_record
-      end
-      
-      def find_record
-        @record = abstract_model.model.find(params[:id])
-      end
-      
-      # Render a view for the specified scope. Turned off by default.
-      # Accepts just :controller as option.
-      def render_with_scope(scope = nil, action = self.action_name, path = self.controller_path)
-        templates = [ [path, action] ]
-        templates << [path, scope, action] if scope
-        
-        if Sunrise::Config.scoped_views?
-          templates << [path, abstract_model.plural, scope, action]
-        end
-        
-        templates.reverse.each do |keys|
-          name = File.join(*keys.compact.map(&:to_s))
-          return render(:template => name) if template_exists?(name)
-        end
+
+    def import_process_uploaded_files
+      raw_files = params['files']
+      return [] if raw_files.blank?
+
+      raw_files.each_with_object([]) do |file, obj|
+        results = abstract_model.model.public_send(:sunrise_import, file)
+        results = render_imported_results(results, file)
+
+        obj << { name: file.original_filename, records: results }
       end
-      
-      def apply_scope(scope, path = self.controller_path)
-        templates = [ [path, scope] ]
-        templates << [ path, abstract_model.current_list, scope ]
-        
-        if Sunrise::Config.scoped_views?
-          templates << [ path, abstract_model.plural, scope ]
-          templates << [ path, abstract_model.plural, abstract_model.current_list, scope ]
-        end
-        
-        templates.reverse.each do |keys|
-          name = File.join(*keys.compact.map(&:to_s))
-          return name if template_exists?(name, nil, true)
-        end
-        
-        # not found ... try render first
-        templates.first.join('/')
+    end
+
+    def render_imported_results(results, file)
+      return results unless import_custom_render?
+
+      abstract_model.model.send(:sunrise_import_results_renderer, results, file)
+    end
+
+    def import_possible?
+      abstract_model.model.methods.include?(:sunrise_import)
+    end
+
+    def import_custom_render?
+      abstract_model.model.methods.include?(:sunrise_import_results_renderer)
+    end
+
+    def find_model
+      @abstract_model = Utils.get_model(params[:model_name], params)
+      if @abstract_model.nil?
+        raise ActionController::RoutingError, "Sunrise model #{params[:model_name]} not found"
       end
-      
-      def authorize_resource
-        authorize!(action_name.to_sym, @record || abstract_model.model, :context => :sunrise)
+
+      @abstract_model
+    end
+
+    def abstract_model
+      @abstract_model ||= find_model
+    end
+
+    def build_record
+      @record = abstract_model.build_record
+    end
+
+    def find_record
+      @record = abstract_model.model.find(params[:id])
+    end
+
+    # Render a view for the specified scope. Turned off by default.
+    # Accepts just :controller as option.
+    def render_with_scope(scope = nil, action = action_name, path = controller_path)
+      templates = [[path, action]]
+      templates << [path, scope, action] if scope
+
+      templates << [path, abstract_model.plural, scope, action] if Sunrise::Config.scoped_views?
+
+      templates.reverse.each do |keys|
+        name = File.join(*keys.compact.map(&:to_s))
+        return render(template: name) if template_exists?(name)
       end
-      
-      def scoped_index_path(options = {})
-        options = options.merge(abstract_model.parent_hash)
-        query = Rack::Utils.parse_query(cookies[:params])
-        
-        index_path(query.merge(options))
+    end
+
+    def apply_scope(scope, path = controller_path)
+      templates = [[path, scope]]
+      templates << [path, abstract_model.current_list, scope]
+
+      if Sunrise::Config.scoped_views?
+        templates << [path, abstract_model.plural, scope]
+        templates << [path, abstract_model.plural, abstract_model.current_list, scope]
       end
-      
-      def redirect_after_update(record = nil)
-        if abstract_model.without_index?
-          index_path(:model_name => abstract_model.plural)
-        else
-          scoped_index_path
-        end
+
+      templates.reverse.each do |keys|
+        name = File.join(*keys.compact.map(&:to_s))
+        return name if template_exists?(name, nil, true)
       end
 
-      def model_params
-        abstract_model.permit_attributes(params, current_user)
+      # not found ... try render first
+      templates.first.join('/')
+    end
+
+    def authorize_resource
+      authorize!(action_name.to_sym, @record || abstract_model.model, context: :sunrise)
+    end
+
+    def scoped_index_path(options = {})
+      options = options.merge(abstract_model.parent_hash)
+      query = Rack::Utils.parse_query(cookies[:params])
+
+      index_path(query.merge(options))
+    end
+
+    def redirect_after_update(_record = nil)
+      if abstract_model.without_index?
+        index_path(model_name: abstract_model.plural)
+      else
+        scoped_index_path
       end
+    end
+
+    def model_params
+      abstract_model.permit_attributes(params, current_user)
+    end
   end
 end

data/app/controllers/sunrise/settings_controller.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module Sunrise
   class SettingsController < Sunrise::ApplicationController
-    authorize_resource :class => false
-    
+    authorize_resource class: false
+
     def edit
       @settings = Settings.get_all
       respond_with(@settings)
     end
-    
+
     def update
       Settings.update_attributes(params[:settings])
       redirect_to root_path

data/app/helpers/sunrise/activities_helper.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module Sunrise
   module ActivitiesHelper
-
     # For generating time tags calculated using jquery.timeago
     def timeago_tag(time, options = {})
-      options[:class] ||= "timeago"
-      content_tag(:abbr, time.to_s, options.merge(:title => time.getutc.iso8601)) if time
+      options[:class] ||= 'timeago'
+      content_tag(:abbr, time.to_s, options.merge(title: time.getutc.iso8601)) if time
     end
 
     def activity_icon_tag(key, options = {})
@@ -12,8 +13,8 @@ module Sunrise
       image = image_path("sunrise/icons/#{icon}.svg")
 
       options = {
-        :class => "mega-icon",
-        :style => "background-image: url(#{image});"
+        class: 'mega-icon',
+        style: "background-image: url(#{image});"
       }.merge(options)
 
       content_tag(:div, nil, options)
@@ -27,10 +28,10 @@ module Sunrise
       model_name = object_type.downcase
 
       if object
-        link_to(model_name, edit_path(:model_name => model_name.pluralize, :id => object.id))
+        link_to(model_name, edit_path(model_name: model_name.pluralize, id: object.id))
       else
         "a #{model_name} which does not exist anymore"
       end
     end
   end
-end
+end