fae-railsz 2.1.0

data/app/models/fae/file.rb

@@ -0,0 +1,24 @@
+require 'file_size_validator'
+
+module Fae
+  class File < ActiveRecord::Base
+
+    include Fae::BaseModelConcern
+    include Fae::FileConcern
+    include Fae::AssetsValidatable
+
+    mount_uploader :asset, Fae::FileUploader
+
+    validates :asset,
+      file_size: {
+        maximum: Fae.max_file_upload_size.megabytes.to_i
+      }
+
+    belongs_to :fileable, polymorphic: true, touch: true, optional: true
+
+    def readonly?
+      false
+    end
+
+  end
+end

data/app/models/fae/image.rb

@@ -0,0 +1,33 @@
+require 'file_size_validator'
+
+module Fae
+  class Image < ActiveRecord::Base
+
+    include Fae::BaseModelConcern
+    include Fae::ImageConcern
+    include Fae::AssetsValidatable
+
+    attr_accessor :redirect
+    mount_uploader :asset, Fae::ImageUploader
+
+    after_save :recreate_versions
+
+    validates :asset,
+      file_size: {
+        maximum: Fae.max_image_upload_size.megabytes.to_i
+      }
+
+    belongs_to :imageable, polymorphic: true, touch: true, optional: true
+
+    def readonly?
+      false
+    end
+
+    private
+
+    def recreate_versions
+      asset.recreate_versions! if Fae.recreate_versions && asset.present?
+    end
+
+  end
+end

data/app/models/fae/navigation.rb

@@ -0,0 +1,132 @@
+module Fae
+  class Navigation
+    include Rails.application.routes.url_helpers
+    include Fae::NavigationConcern
+
+    attr_accessor :current_path, :coordinates, :current_user, :items
+
+    def initialize(current_user)
+      @current_user = current_user
+      @items = recursive_authorization(structure)
+    end
+
+    def side_nav(current_path)
+      @current_path = current_path
+      # set the coors based on current path
+      @coordinates = []
+      find_current_hash(@items)
+
+      @items[@coordinates.first][:subitems][@coordinates.second][:subitems] if @coordinates.length > 2
+    end
+
+    def search(query)
+      find_items_by_text(@items, query, [])
+    end
+
+    private
+
+    def current_section
+      @current_path.gsub(/\/new$|\/\d+\/edit/, '')
+    end
+
+    def find_current_hash(array_of_items)
+      @coordinates.push(0)
+
+      array_of_items.each do |item|
+        return item if item[:path] == current_section
+
+        if item[:subitems].present?
+          current_sidenav = find_current_hash(item[:subitems])
+          return current_sidenav if current_sidenav.present?
+        end
+
+        increment_coordinates
+      end
+      # if nothing is returned, remove last coor and return nil
+      @coordinates.pop
+      nil
+    end
+
+    def increment_coordinates
+      last_item = @coordinates.pop
+      @coordinates.push(last_item + 1)
+    end
+
+    def find_items_by_text(items, query, results)
+      items.each do |item|
+        if item[:text].present? && item[:text].downcase.include?(query.downcase)
+          results << { text: item[:text], nested_path: item[:nested_path] }
+        end
+        if item[:subitems].present?
+          results = find_items_by_text(item[:subitems], query, results)
+        end
+      end
+      results
+    end
+
+    def item(text, options={})
+      hash = { text: text }
+      hash.merge! options
+      hash[:nested_path] = nested_path(hash)
+      hash[:path] ||= '#'
+      # prefer `subitems` over `sublinks` for new DSL but still need to support old structure in v1
+      hash[:sublinks] = hash[:subitems] if hash[:subitems].present?
+
+      # authorize link with current user
+      unless can_view_path(hash[:nested_path])
+        hash[:path] = '#'
+        hash[:nested_path] = '#'
+      end
+
+      hash
+    end
+
+    def can_view_path(path)
+      return true if path.blank?
+
+      can_view = true
+      item_controllers = path.split(/\/\d+\//)
+      item_controllers.each do |item_controller|
+        item_controller = item_controller.gsub(/#{fae.root_path}|\/new$|edit$/, '')
+        can_view = !Fae::Authorization.access_map[item_controller] || Fae::Authorization.access_map[item_controller].include?(@current_user.role.name)
+      end
+
+      can_view
+    end
+
+    def fae
+      Fae::Engine.routes.url_helpers
+    end
+
+    def nested_path(hash)
+      return hash[:path] if hash[:path]
+
+      path_from_subitems hash
+    end
+
+    def path_from_subitems(hash)
+      return '#' unless hash[:subitems] && hash[:subitems].is_a?(Array)
+
+      first_subitem = hash[:subitems].first
+
+      if first_subitem.present?
+        return first_subitem[:path] if first_subitem.present? && first_subitem[:path] != '#'
+
+        path_from_subitems hash[:subitems].first
+      end
+    end
+
+    def recursive_authorization(items)
+      rejected_indexes = []
+      items.each_with_index do |item, i|
+        recursive_authorization(item[:subitems]) if item[:subitems].present?
+        # flag for removal if there isn't active links in the item or subitems
+        rejected_indexes << i if item[:nested_path] == '#' && item[:subitems].blank?
+      end
+      # remove flagged items in separate loop
+      # removing them inline will skip the next item in the loop
+      items.delete_if.with_index { |_, index| rejected_indexes.include? index }
+    end
+
+  end
+end

data/app/models/fae/option.rb

@@ -0,0 +1,38 @@
+module Fae
+  class Option < ActiveRecord::Base
+
+    include Fae::BaseModelConcern
+    include Fae::OptionConcern
+
+    validates_inclusion_of :singleton_guard, :in => [0]
+    validates_presence_of :title, :time_zone, :live_url
+
+    has_one :logo, -> { where(attached_as: 'logo' ) },
+      as: :imageable,
+      class_name: 'Fae::Image',
+      dependent: :destroy
+    accepts_nested_attributes_for :logo, allow_destroy: true
+
+    has_one :favicon, -> { where(attached_as: 'favicon' ) },
+      as: :imageable,
+      class_name: 'Fae::Image',
+      dependent: :destroy
+    accepts_nested_attributes_for :favicon, allow_destroy: true
+
+    def fae_tracker_blacklist
+      'all'
+    end
+
+    def self.instance
+      instance = first
+
+      if instance.blank?
+        instance = Option.new({title: 'My Fae Admin', time_zone: 'Pacific Time (US & Canada)', live_url: 'http://www.wearefine.com'})
+        instance.singleton_guard = 0
+        instance.save!
+      end
+
+      instance
+    end
+  end
+end

data/app/models/fae/role.rb

@@ -0,0 +1,18 @@
+module Fae
+  class Role < ActiveRecord::Base
+
+    include Fae::BaseModelConcern
+    include Fae::RoleConcern
+
+    has_many :users
+
+    acts_as_list add_new_at: :bottom
+    default_scope { order(Arel.sql('-position DESC')) }
+
+    scope :public_roles, -> {where.not(name: 'super admin')}
+
+    def fae_tracker_blacklist
+      'all'
+    end
+  end
+end

data/app/models/fae/static_page.rb

@@ -0,0 +1,109 @@
+module Fae
+  class StaticPage < ActiveRecord::Base
+
+    include Fae::BaseModelConcern
+    include Fae::StaticPageConcern
+
+    validates :title, presence: true
+
+    @singleton_is_setup = false
+
+    def self.instance
+      setup_dynamic_singleton
+      row = includes(fae_fields.keys).references(fae_fields.keys).find_by_slug(@slug)
+      row = create(title: @slug.titleize, slug: @slug) if row.blank?
+      row
+    end
+
+    def self.fae_fields
+      {}
+    end
+
+    def fae_display_field
+      title
+    end
+
+    def as_json(options={})
+      self.class.fae_fields.keys.map do |field|
+        [field, field_json(field)]
+      end.to_h
+    end
+
+  private
+
+    def self.setup_dynamic_singleton
+      return if @singleton_is_setup
+
+      fae_fields.each do |name, value|
+        type = value.is_a?(Hash) ? value[:type] : value
+        languages = value.try(:[], :languages)
+
+        if languages.present?
+          languages.each do |lang|
+            # Save with suffix for form fields
+            define_association("#{name}_#{lang}", type)
+            define_validations("#{name}_#{lang}", type, value[:validates]) if supports_validation(type, value)
+          end
+          # Save with lookup to have default language return in front-end use (don't need to worry about validations here)
+          default_language = Rails.application.config.i18n.default_locale || languages.first
+          define_association(name, type, "#{name}_#{default_language}")
+        else
+          # Normal content_blocks
+          define_association(name, type)
+          define_validations(name, type, value[:validates]) if supports_validation(type, value)
+        end
+      end
+
+      @singleton_is_setup = true
+    end
+
+    def self.define_association(name, type, locale_name = nil)
+      locale_name ||= name
+
+      send :has_one, name.to_sym, -> { where(attached_as: locale_name.to_s)}, as: poly_sym(type), class_name: type.to_s, dependent: :destroy
+      send :accepts_nested_attributes_for, name, allow_destroy: true
+      send :define_method, :"#{name}_content", -> { send(name.to_sym).try(:content) }
+    end
+
+    def self.define_validations(name, type, validations)
+      unique_method_name = "is_#{self.name.underscore}_#{name.to_s}?".to_sym
+      slug = @slug
+      validations[:if] = unique_method_name
+      type.validates(:content, validations)
+      type.send(:define_method, unique_method_name) do
+        contentable.slug == slug && attached_as == name.to_s if contentable.present?
+      end
+    end
+
+    def self.supports_validation(type, value)
+      # validations are only supported on Fae::TextField and Fae::TextArea
+      poly_sym(type) == :contentable && value.try(:[], :validates).present?
+    end
+
+    def self.poly_sym(assoc)
+      case assoc.name
+      when 'Fae::TextField', 'Fae::TextArea'
+        return :contentable
+      when 'Fae::Image'
+        return :imageable
+      when 'Fae::File'
+        return :fileable
+      end
+    end
+
+    def field_json(assoc)
+      assoc_obj = self.send(assoc)
+      case assoc_obj.class.name
+      when 'Fae::TextField', 'Fae::TextArea'
+        return assoc_obj.content
+      when 'Fae::Image', 'Fae::File'
+        assoc_json = assoc_obj.as_json
+        assoc_json['asset'] = assoc_obj.asset.as_json
+        return assoc_json
+      else
+        return assoc_obj.as_json
+      end
+    end
+
+  end
+end

data/app/models/fae/text_area.rb

@@ -0,0 +1,14 @@
+module Fae
+  class TextArea < ActiveRecord::Base
+
+    include Fae::BaseModelConcern
+    include Fae::TextAreaConcern
+    include Fae::PageValidatable
+
+    belongs_to :contentable, polymorphic: true, touch: true
+
+    def readonly?
+      false
+    end
+  end
+end

data/app/models/fae/text_field.rb

@@ -0,0 +1,14 @@
+module Fae
+  class TextField < ActiveRecord::Base
+
+    include Fae::BaseModelConcern
+    include Fae::TextFieldConcern
+    include Fae::PageValidatable
+
+    belongs_to :contentable, polymorphic: true, touch: true
+
+    def readonly?
+      false
+    end
+  end
+end

data/app/models/fae/user.rb

@@ -0,0 +1,67 @@
+module Fae
+  class User < ActiveRecord::Base
+
+    include Fae::BaseModelConcern
+    include Fae::UserConcern
+
+    # Include default devise modules. Others available are:
+    # :registerable, :confirmable, :lockable, :timeoutable and :omniauthable
+    devise :recoverable, :rememberable, :trackable
+
+    belongs_to :role
+
+    validates :first_name, presence: true
+    validates :email,
+      presence: true,
+      uniqueness: { message: 'That email address is already in use. Give another one a go.' },
+      format: {
+        with: /^\s*(([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})[\s\/,;]*)+$/i,
+        message: 'is invalid',
+        multiline: true
+      }
+    # validates :password,
+    #   presence: { on: :create },
+    #   confirmation: { message: "does not match Password"},
+    #   length: { minimum: 8, allow_blank: true }
+    validates :role_id, presence: true
+
+    default_scope { order(:first_name, :last_name) }
+
+    scope :public_users, -> { joins(:role).where.not('fae_roles.name = ?', 'super admin') }
+    scope :live_super_admins, -> { joins(:role).where(active: true, fae_roles: { name: 'super admin' }) }
+
+    def super_admin?
+      role.name == 'super admin'
+    end
+
+    def admin?
+      role.name == 'admin'
+    end
+
+    def user?
+      role.name == 'user'
+    end
+
+    def super_admin_or_admin?
+      super_admin? || admin?
+    end
+
+    def full_name
+      "#{first_name} #{last_name}"
+    end
+
+    # Called by Devise to see if an user can currently be signed in
+    def active_for_authentication?
+      active? && super
+    end
+
+    # Called by Devise to get the proper error message when an user cannot be signed in
+    def inactive_message
+      !active? ? :inactive : super
+    end
+
+    def fae_tracker_blacklist
+      [:reset_password_token, :reset_password_sent_at, :remember_created_at, :sign_in_count, :current_sign_in_at, :last_sign_in_at, :current_sign_in_ip, :last_sign_in_ip, :confirmation_token, :confirmed_at, :confirmation_sent_at, :unconfirmed_email, :failed_attempts, :unlock_token, :locked_at]
+    end
+  end
+end