fae-railsz 2.1.0

data/app/controllers/concerns/fae/application_controller_concern.rb

@@ -0,0 +1 @@
+module Fae::ApplicationControllerConcern; end

data/app/controllers/concerns/fae/asset_cloner.rb

@@ -0,0 +1,46 @@
+module Fae
+  class AssetCloner
+    NoFileForOriginalResource  = Class.new(StandardError)
+    UnknownStorage             = Class.new(StandardError)
+
+    attr_reader :original_resource, :resource, :mount_point
+
+    def initialize(original_resource, resource, mount_point)
+      @mount_point       = mount_point.to_sym
+      @original_resource = original_resource
+      @resource          = resource
+    end
+
+    def set_file
+      if have_file?
+        case original_resource_mounter.send(:storage).class.name
+        when 'CarrierWave::Storage::File'
+          set_file_for_local_storage
+        when 'CarrierWave::Storage::Fog', 'CarrierWave::Storage::AWS'
+          set_file_for_remote_storage
+        else
+          raise UnknownStorage
+        end
+      else
+        raise NoFileForOriginalResource
+      end
+    end
+
+    def have_file?
+      original_resource_mounter.file.present? || original_resource_mounter.url
+    end
+
+    def set_file_for_remote_storage
+      resource.send(:"remote_#{mount_point.to_s}_url=", original_resource_mounter.url)
+    end
+
+    def set_file_for_local_storage
+      resource.send(:"#{mount_point.to_s}=", ::File.open(original_resource_mounter.file.file))
+    end
+
+    def original_resource_mounter
+      original_resource.send(mount_point)
+    end
+
+  end
+end

data/app/controllers/concerns/fae/cloneable.rb

@@ -0,0 +1,136 @@
+module Fae
+  module Cloneable
+    extend ActiveSupport::Concern
+
+    private
+
+    def create_from_existing(id)
+      @item = @klass.find(id)
+      @cloned_item = @item.dup
+      update_cloned_attributes(@cloned_item)
+      @cloned_item.on_prod = false if @item.respond_to?(:on_prod)
+
+      if @cloned_item.save
+        update_cloneable_associations
+        redirect_to @index_path + '/' + @cloned_item.id.to_s + '/edit'
+      else
+        build_assets
+        flash[:alert] = @cloned_item.errors.full_messages
+        render action: 'edit'
+      end
+    end
+
+    # array of symbols used for setting up associations on cloned object
+    def associations_for_cloning
+      []
+    end
+
+    # array of symbols used for cloning only specific attributes
+    def attributes_for_cloning
+      @klass.column_names
+    end
+
+    def update_cloned_attributes(item)
+      attribute_names = attributes_for_cloning.map(&:to_s) - ['id']
+      item.attributes.each do |attribute, value|
+        if attribute_names.include? attribute
+          rename_unique_attribute(item, attribute, value) if attr_is_unique?(item, attribute)
+        else
+          item.send("#{attribute}=", nil)
+        end
+      end
+    end
+
+    # set cloneable attributes and associations
+    def update_cloneable_associations
+      associations_for_cloning.each do |association|
+        type = @klass.reflect_on_association(association)
+        through_record = type.through_reflection
+
+        if through_record.present?
+          clone_join_relationships(through_record.plural_name)
+        else
+          clone_has_one_relationship(association,type) if type.macro == :has_one
+          clone_has_many_relationships(association) if type.macro == :has_many
+        end
+      end
+    end
+
+    def clone_has_one_relationship(association,type)
+      old_record = @item.send(association)
+
+      if old_record.present?
+        new_record = old_record.dup
+        if ['::Fae::Image','::Fae::File'].include?(type.options[:class_name])
+          new_record.send("#{type.options[:as]}_id" + '=', @cloned_item.id) if new_record.send("#{type.options[:as]}_id").present?
+          new_record.send("#{type.options[:as]}_type" + '=', @cloned_item.class.name) if new_record.send("#{type.options[:as]}_type").present?
+          Fae::AssetCloner.new(old_record, new_record, :asset).set_file if old_record.asset.present? && old_record.asset.url.present?
+          new_record.save
+        else
+          new_record.send("#{@klass_singular}_id" + '=', @cloned_item.id) if new_record.send("#{@klass_singular}_id").present?
+        end
+        new_record.attributes.each do |attribute, value|
+          rename_unique_attribute(new_record, attribute, value) if attr_is_unique?(new_record, attribute.first)
+        end
+      end
+    end
+
+    def clone_has_many_relationships(association)
+      if @item.send(association).present?
+        @item.send(association).reverse.each do |record|
+          new_record = association.to_s.classify.constantize.find_by_id(record.id).dup
+          new_record.send("#{@klass_singular}_id" + '=', @cloned_item.id) if new_record.send("#{@klass_singular}_id").present?
+          # check if associations have unique attributes
+          new_record.attributes.each do |attribute, value|
+            rename_unique_attribute(new_record, attribute, value) if attr_is_unique?(new_record, attribute.first)
+          end
+
+          @cloned_item.send(association) << new_record
+        end
+      end
+    end
+
+    def clone_join_relationships(object)
+      if @item.send(object.to_sym).present?
+        @item.send(object.to_sym).reverse.each do |record|
+          copied_join = object.classify.constantize.find_by_id(record.id).dup
+          copied_join.send("#{@klass_singular}_id" + '=', @cloned_item.id)
+          @cloned_item.send(object.to_sym) << copied_join
+        end
+      end
+    end
+
+    def rename_unique_attribute(item, attribute, value)
+      index = 2
+      symbol = attribute.to_sym
+      value = unique_name(item, attribute, value, index.to_s)
+
+      begin
+        record = item.class.where(symbol => value)
+        unless record.empty?
+          new_index = index + 1
+          value = value.chomp(index.to_s) + new_index.to_s
+          index = new_index
+        end
+      end while record.present?
+
+      item[symbol] = value
+    end
+
+    def attr_is_unique?(item, attribute)
+      item.class.validators_on(attribute.to_sym).map(&:class).include? ActiveRecord::Validations::UniquenessValidator
+    end
+
+    def unique_name(item, attribute, value, suffix)
+      item.class.validators_on(attribute.to_sym).each do |validator|
+        if validator.class.name.include?('LengthValidator') && validator.options[:maximum].present?
+          max_length = validator.options[:maximum] - (suffix.length + 1)
+          value = value[0...max_length]
+          break
+        end
+      end
+
+      "#{value}-#{suffix}"
+    end
+  end
+end

data/app/controllers/fae/application_controller.rb

@@ -0,0 +1,123 @@
+module Fae
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    include Fae::ApplicationControllerConcern
+
+    helper Fae::ViewHelper
+    helper Fae::FormHelper
+    helper Fae::NestedFormHelper
+    helper Fae::FaeHelper
+
+    before_action :check_disabled_environment
+    before_action :first_user_redirect
+    before_action :authenticate_user!
+    before_action :build_nav
+    before_action :set_option
+    before_action :detect_cancellation
+    before_action :set_change_user
+    before_action :set_locale
+
+    private
+
+    def set_locale
+      I18n.locale = :en
+    end
+
+    def check_disabled_environment
+      disabled_envs = Fae.disabled_environments.map { |e| e.to_s }
+      return unless disabled_envs.include? Rails.env.to_s
+      render template: 'fae/pages/disabled_environment.html.slim', layout: 'fae/error.html.slim'
+    end
+
+    def super_admin_only
+      redirect_to fae.root_path, flash: { error: t('fae.unauthorized_error') } unless current_user.super_admin?
+    end
+
+    def admin_only
+      redirect_to fae.root_path, flash: { error: t('fae.unauthorized_error') } unless current_user.super_admin? || current_user.admin?
+    end
+
+    def show_404
+      render template: 'fae/pages/error404.html.slim', layout: 'fae/error.html.slim', status: :not_found
+    end
+
+    def set_option
+      @option = Fae::Option.instance
+    end
+
+    def detect_cancellation
+      flash.now[:warning] = 'Your changes were not saved.' if params[:cancelled].present? && params[:cancelled]== "true"
+    end
+
+    def build_nav
+      return unless current_user
+
+      # shameless green: if we continue to cache specific parts of Fae we should either:
+      # - create support methods to DRY this conditional logic
+      # - explore using `expires_in: 0` as a way to ignore caching
+      if Fae.use_cache
+        @fae_navigation = Rails.cache.fetch("fae_navigation_#{current_user.role.id}") do
+          Fae::Navigation.new(current_user)
+        end
+      else
+        @fae_navigation = Fae::Navigation.new(current_user)
+      end
+
+      raise_define_structure_error unless @fae_navigation.respond_to? :structure
+
+      @fae_topnav_items = @fae_navigation.items
+      @fae_sidenav_items = @fae_navigation.side_nav(request.path)
+    end
+
+    # redirect to login after sign out
+    def after_sign_out_path_for(resource_or_scope)
+      fae.new_user_session_path
+    end
+
+    # redirect to requested page after sign in
+    def after_sign_in_path_for(resource)
+      request.env['omniauth.origin'] || stored_location_for(resource) || fae.root_path
+    end
+
+    def first_user_redirect
+      redirect_to fae.first_user_path if Fae::User.live_super_admins.blank?
+    end
+
+    def set_change_user
+      Fae::Change.current_user = current_user.id if current_user.present?
+    end
+
+    def raise_define_structure_error
+      raise 'Fae::Navigation#structure is not defined, please define it in `app/models/concerns/fae/navigation_concern.rb`'
+    end
+
+    def all_models
+      if Fae.use_cache
+        Rails.cache.fetch('fae_all_models') do
+          load_and_filter_models
+        end
+      else
+        load_and_filter_models
+      end
+    end
+
+    def load_and_filter_models
+      # load of all models since Rails caches activerecord queries.
+      Rails.application.eager_load!
+      ActiveRecord::Base.descendants.map.reject { |m| m.name['Fae::'] || !m.instance_methods.include?(:fae_display_field) || Fae.dashboard_exclusions.include?(m.name) || !authorize_model(m) }
+    end
+
+    def authorize_model(model)
+      return false if current_user.blank? || current_user.role.blank? || current_user.role.name.blank?
+
+      users_role           = current_user.role.name.downcase
+      tableized_model      = model.name.tableize
+      role_group_for_model = Fae::Authorization.access_map[tableized_model]
+
+      return true if role_group_for_model.blank? || (role_group_for_model.present? && role_group_for_model.include?(users_role))
+      false
+    end
+
+  end
+end

data/app/controllers/fae/base_controller.rb

@@ -0,0 +1,117 @@
+module Fae
+  class BaseController < ApplicationController
+    include Fae::Cloneable
+
+    before_action :set_class_variables
+    before_action :set_item, only: [:edit, :update, :destroy]
+    before_action :authorize_user
+
+    helper FormHelper
+
+    def index
+      if use_pagination
+        @items = @klass.for_fae_index.page(params[:page])
+      else
+        @items = @klass.for_fae_index
+      end
+      respond_to do |format|
+        format.html
+        format.csv { send_data @items.to_csv, filename: @items.name.parameterize + "." + Time.now.to_s(:filename) + '.csv'  }
+      end
+    end
+
+    def new
+      @item = @klass.new
+      build_assets
+    end
+
+    def edit
+      build_assets
+    end
+
+    def create
+      return create_from_existing(params[:from_existing]) if params[:from_existing].present?
+
+      @item = @klass.new(item_params)
+
+      if @item.save
+        redirect_to @index_path, notice: t('fae.save_notice')
+      else
+        build_assets
+        flash[:alert] = t('fae.save_error')
+        render action: 'new'
+      end
+    end
+
+    def update
+      if @item.update(item_params)
+        redirect_to @index_path, notice: t('fae.save_notice')
+      else
+        build_assets
+        flash[:alert] = t('fae.save_error')
+        render action: 'edit'
+      end
+    end
+
+    def destroy
+      if @item.destroy
+        redirect_to @index_path, notice: t('fae.delete_notice')
+      else
+        redirect_to @index_path, flash: { error: t('fae.delete_error') }
+      end
+    end
+
+    def filter
+      if use_pagination
+        @items = @klass.filter(params).fae_sort(params).page(params[:page])
+      else
+        @items = @klass.filter(params).fae_sort(params)
+      end
+
+      render :index, layout: false
+    end
+
+    def show
+      # show action is hidden by default, override as needed
+      show_404
+    end
+
+  private
+
+    def set_class_variables(class_name = nil)
+      klass_base = params[:controller].split('/').last
+      @klass_name = class_name || klass_base               # used in form views
+      @klass = klass_base.classify.constantize             # used as class reference in this controller
+      @klass_singular = klass_base.singularize             # used in index views
+      @klass_humanized = @klass_name.singularize.humanize  # used in index views
+      @index_path = '/' + params[:controller]              # used in form_header partial
+      @new_path = @index_path + '/new'                     # used in index_header partial
+    end
+
+    # use callbacks to share common setup or constraints between actions.
+    def set_item
+      @item = @klass.find(params[:id])
+    end
+
+    # only allow trusted parameters, override to white-list
+    def item_params
+      params.require(@klass_singular).permit!
+    end
+
+    # if model has images or files, build them here for nesting
+    def build_assets
+    end
+
+    def authorize_user
+      roles_for_controller = Fae::Authorization.access_map[params[:controller].gsub('admin/','')]
+      return if current_user.super_admin? || roles_for_controller.blank?
+      return show_404 unless roles_for_controller.include?(current_user.role.name)
+    end
+
+    # allows this controller to use pagination
+    def use_pagination
+      false
+    end
+
+  end
+end

data/app/controllers/fae/files_controller.rb

@@ -0,0 +1,26 @@
+module Fae
+  class FilesController < ApplicationController
+    # ajax delete action
+    #
+    # post 'files/:id/delete_file' => 'files#delete_file', as: :delete_file
+    # here we just remove the asset from the attached file model, because if we deleted
+    # the model itself, re-uploading a new one would break.
+    def delete_file
+      file = Fae::File.find_by_id(params[:id])
+      file.remove_asset = true
+      file.save
+      render body: nil
+    end
+
+    private
+
+    # allow mass assignment
+    def file_params
+      if params[:file].present?
+        params.require(:file).permit!
+      else
+        nil
+      end
+    end
+  end
+end