incline 0.1.5

data/app/models/incline/access_group.rb

@@ -0,0 +1,121 @@
+require_relative './access_group_group_member'
+require_relative './access_group_user_member'
+
+module Incline
+  class AccessGroup < ActiveRecord::Base
+
+    # hide the Groups<=>Users relationship association
+    has_many :access_group_user_members, class_name: 'Incline::AccessGroupUserMember', foreign_key: 'group_id', dependent: :delete_all
+    private :access_group_user_members, :access_group_user_members=
+
+    # and expose the users instead.
+    has_many :users, class_name: 'Incline::User', through: :access_group_user_members, source: :member
+
+    # hide the Groups<=>Groups relationship association
+    has_many :access_group_group_members, class_name: 'Incline::AccessGroupGroupMember', foreign_key: 'group_id', dependent: :delete_all
+    private :access_group_group_members, :access_group_group_members=
+
+    # and expose the groups instead.
+    has_many :groups, class_name: 'Incline::AccessGroup', through: :access_group_group_members, source: :member
+
+    ##
+    # Gets a list of memberships for this group.  (Read-only)
+    def memberships(refresh = false)
+      @memberships = nil if refresh
+      @memberships ||= AccessGroupGroupMember.where(member_id: id).includes(:group).map{|v| v.group}.to_a.freeze
+    end
+
+    ##
+    # Gets a list of all of the member users for this group.  (Read-only)
+    def members(refresh = false)
+      @members = nil if refresh
+      @members ||= safe_members.sort{|a,b| a.to_s <=> b.to_s}
+    end
+
+    validates :name,
+              presence: true,
+              length: { maximum: 100 },
+              uniqueness: { case_sensitive: false }
+
+    scope :sorted, ->{ order(:name) }
+
+    ##
+    # Determines if this group belongs to the specified group.
+    def belongs_to?(group)
+      group = AccessGroup.get(group) unless group.is_a?(::Incline::AccessGroup)
+      return false unless group
+      safe_belongs_to?(group)
+    end
+
+    ##
+    # Gets a list of all the groups this group provides effective membership to.
+    def effective_groups
+      ret = [ self ]
+      memberships.each do |m|
+        unless ret.include?(m)  # prevent infinite recursion
+          tmp = m.effective_groups
+          tmp.each do |g|
+            ret << g unless ret.include?(g)
+          end
+        end
+      end
+      ret.sort{|a,b| a.name <=> b.name}
+    end
+
+    ##
+    # Gets the user IDs for the members of this group.
+    def user_ids
+      users.pluck(:id)
+    end
+
+    ##
+    # Gets the group IDs for the members of this group.
+    def group_ids
+      groups.pluck(:id)
+    end
+
+    ##
+    # Sets the user IDs for the members of this group.
+    def user_ids=(values)
+      values ||= []
+      values = [ values ] unless values.is_a?(::Array)
+      values = values.reject{|v| v.blank?}.map{|v| v.to_i}
+      self.users = Incline::User.where(id: values).to_a
+    end
+
+    ##
+    # Sets the group IDs for the members of this group.
+    def group_ids=(values)
+      values ||= []
+      values = [ values ] unless values.is_a?(::Array)
+      values = values.reject{|v| v.blank?}.map{|v| v.to_i}
+      self.groups = Incline::AccessGroup.where(id: values).to_a
+    end
+
+    protected
+
+    def safe_belongs_to?(group, already_tried = [])
+      return true if self == group
+      already_tried << self
+      memberships.each do |parent|
+        unless already_tried.include?(parent)
+          return true if parent.safe_belongs_to?(group, already_tried)
+        end
+      end
+      false
+    end
+
+    def safe_members(already_tried = [])
+      return [] if already_tried.include?(self)
+      already_tried << self
+      ret = users.to_a
+      groups.each do |g|
+        g.send(:safe_members, already_tried).each do |u|
+          ret << u unless ret.include?(u)
+        end
+      end
+      ret
+    end
+
+  end
+end

data/app/models/incline/access_group_group_member.rb

@@ -0,0 +1,12 @@
+module Incline
+  class AccessGroupGroupMember < ActiveRecord::Base
+    belongs_to :group, class_name: 'Incline::AccessGroup'
+    belongs_to :member, class_name: 'Incline::AccessGroup'
+
+    validates :group_id, presence: true
+    validates :member_id, presence: true, uniqueness: { scope: :group_id }
+
+    # member_id should not equal group_id or cause infinite recursion.
+    # these two issues are addressed in the AccessGroup model.
+  end
+end

data/app/models/incline/access_group_user_member.rb

@@ -0,0 +1,10 @@
+module Incline
+  class AccessGroupUserMember < ActiveRecord::Base
+
+    belongs_to :group, class_name: 'Incline::AccessGroup'
+    belongs_to :member, class_name: 'Incline::User'
+
+    validates :group_id, presence: true
+    validates :member_id, presence: true, uniqueness: { scope: :group_id }
+  end
+end

data/app/models/incline/action_group.rb

@@ -0,0 +1,12 @@
+require_relative './access_group'
+
+module Incline
+  class ActionGroup < ActiveRecord::Base
+    belongs_to :action_security
+    belongs_to :access_group
+
+    validates :action_security, presence: true
+    validates :access_group, presence: true, uniqueness: { scope: :action_security }
+
+  end
+end

data/app/models/incline/action_security.rb

@@ -0,0 +1,222 @@
+require_relative './action_group'
+
+module Incline
+  class ActionSecurity < ActiveRecord::Base
+
+    SHORT_PERMITTED_FILTERS = {
+        '- Editable -' => 'users|custom',
+        'Admins' => 'admins',
+        'Anon' => 'anon',
+        'Custom' => 'custom',
+        'Everyone' => 'everyone',
+        'Users' => 'users'
+    }.freeze
+
+    has_many :action_groups
+    private :action_groups, :action_groups=
+
+    has_many :groups, through: :action_groups, class_name: 'Incline::AccessGroup', source: :access_group
+
+    validates :controller_name, presence: true, length: { maximum: 200 }
+    validates :action_name, presence: true, length: { maximum: 200 }, uniqueness: { scope: :controller_name, case_sensitive: false }
+    validates :path, presence: true
+
+    before_save :downcase_names
+
+    scope :visible, ->{ where(visible: true) }
+
+    ##
+    # Updates the flags based on the controller configuration.
+    def update_flags
+      self.allow_anon = self.require_anon = self.require_admin = self.unknown_controller = self.non_standard = false
+
+      self.unknown_controller = true
+      klass =
+          begin
+            (controller_name + '_controller').classify.constantize
+          rescue NameError
+             nil
+          end
+
+      unless klass
+        options =
+            if controller_name.include?('/')
+              ns = controller_name.rpartition('/')[0]
+              ctrl = controller_name.rpartition('/')[2]
+              options = [
+                  "#{ns}/app/controllers/#{ns}/#{ctrl}_controller",
+                  "app/controllers/#{ns}/#{ctrl}_controller",
+                  "#{ns}/app/controllers/#{ctrl}_controller",
+                  "#{ns}/#{ctrl}_controller"
+              ]
+            else
+              options = [
+                  "app/controllers/#{controller_name}_controller",
+                  "#{controller_name}_controller"
+              ]
+            end
+
+        while (file = options.shift)
+          begin
+            require file
+            klass = (controller_name + '_controller').classify.constantize
+            break
+          rescue LoadError, NameError
+            # just preventing the error from bubbling up.
+          end
+        end
+      end
+
+      if klass
+        self.unknown_controller = false
+        if klass.require_admin_for?(action_name)
+          self.require_admin = true
+        elsif klass.require_anon_for?(action_name)
+          self.require_anon = true
+        elsif klass.allow_anon_for?(action_name)
+          self.allow_anon = true
+        end
+
+        # if the authentication methods are overridden, set a flag to alert the user that standard security may not be honored.
+        unless klass.instance_method(:valid_user?).owner == Incline::Extensions::ActionControllerBase &&
+            klass.instance_method(:authorize!).owner == Incline::Extensions::ActionControllerBase
+          self.non_standard = true
+        end
+
+      end
+
+    end
+
+    ##
+    # Determines if the action allows custom security settings.
+    def allow_custom?
+      !(require_admin? || require_anon? || allow_anon?)
+    end
+
+    ##
+    # Generates a list of security items related to all of the current routes in the application.
+    #
+    # If "refresh" is true, the list will be rebuilt.
+    # If "update_flags" is true, the individual controllers will be loaded to regenerate the flags for the security.
+    #
+    # The returned list can be indexed two ways.  The normal way with a numeric index and also by specifying the
+    # controller_name and action_name.
+    #
+    #     Incline::ActionSecurity.valid_items[0]
+    #     Incline::ActionSecurity.valid_items['incline/welcome','home']
+    #
+    def self.valid_items(refresh = false, update_flags = true)
+      @valid_items = nil if refresh
+      @valid_items ||=
+          begin
+            Incline::ActionSecurity.update_all(visible: false)
+
+            ret = Incline
+                      .route_list
+                      .reject{|r| r[:action] == 'api'}
+                      .map do |r|
+              item = ActionSecurity.find_or_initialize_by(controller_name: r[:controller], action_name: r[:action])
+              item.path = "#{r[:path]} [#{r[:verb]}]"
+              item.visible = true
+              item.update_flags if update_flags
+              item.save!
+              item
+            end
+                      .sort{|a,b| a.controller_name == b.controller_name ? a.action_name <=> b.action_name : a.controller_name <=> b.controller_name}
+
+            def ret.[](*args)
+              if args.length == 2
+                controller = args[0].to_s
+                action = args[1].to_s
+                find{|item| item.controller_name == controller && item.action_name == action}
+              else
+                super(*args)
+              end
+            end
+
+            ret.freeze
+          end
+    end
+
+    ##
+    # Gets a string describing who is permitted to execute the action.
+    def permitted(refresh = false)
+      @permitted = nil if refresh
+      @permitted ||=
+          if require_admin?
+            'Administrators Only'
+          elsif require_anon?
+            'Anonymous Only'
+          elsif allow_anon?
+            'Everyone'
+          elsif groups.any?
+            names = groups.pluck(:name).map{|v| "\"#{v}\""}
+            'Members of ' +
+                if names.count == 1
+                  names.first
+                elsif names.count == 2
+                  names.join(' or ')
+                else
+                  names[0...-1].join(', ') + ', or ' + names.last
+                end
+          else
+            'All Users'
+          end +
+              if non_standard
+                ' (Non-Standard)'
+              else
+                ''
+              end
+    end
+
+    ##
+    # Gets a short string describing who is permitted to execute the action.
+    def short_permitted
+      if require_admin?
+        'Admins'
+      elsif require_anon?
+        'Anon'
+      elsif allow_anon?
+        'Everyone'
+      elsif groups.any?
+        'Custom'
+      else
+        'Users'
+      end +
+          if non_standard
+            '*'
+          else
+            ''
+          end
+    end
+
+    ##
+    # Description of action.
+    def to_s
+      @to_s ||= "#{controller_name}:#{action_name} [#{permitted}]"
+    end
+
+    ##
+    # Gets the group IDs accepted by this action.
+    def group_ids
+      groups.pluck(:id)
+    end
+
+    ##
+    # Sets the group IDs accepted by this action.
+    def group_ids=(values)
+      values ||= []
+      values = [ values ] unless values.is_a?(::Array)
+      values = values.reject{|v| v.blank?}.map{|v| v.to_i}
+      self.groups = Incline::AccessGroup.where(id: values).to_a
+    end
+
+    private
+
+    def downcase_names
+      controller_name.downcase!
+      action_name.downcase!
+    end
+
+  end
+end

data/app/models/incline/contact_message.rb

@@ -0,0 +1,37 @@
+module Incline
+  ##
+  # Defines the message generated by the generic contact form.
+  class ContactMessage
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    attr_accessor :your_name, :your_email, :related_to, :subject, :body, :remote_ip, :recaptcha
+
+    validates :your_name, presence: true
+    validates :your_email, presence: true, 'incline/email' => true
+    validates :related_to, presence: true
+    validates :subject, presence: true, if: :need_subject?
+    validates :body, presence: true
+    validates :recaptcha, presence: true, 'incline/recaptcha' => true
+
+    ##
+    # Gets the full subject for the message.
+    def full_subject
+      return related_to if subject.blank?
+      "#{related_to}: #{subject}"
+    end
+
+    ##
+    # Sends the message.
+    def send_message
+      Incline::ContactForm.contact(self).deliver_now
+    end
+
+    private
+
+    def need_subject?
+      related_to.to_s.downcase == 'other'
+    end
+
+  end
+end

data/app/models/incline/disable_info.rb

@@ -0,0 +1,20 @@
+module Incline
+  ##
+  # This model is used to disable a user with a reason for the disabling.
+  class DisableInfo
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    attr_accessor :reason, :user
+
+    validates :reason, presence: true
+    validate do
+      if user && user.is_a?(::Incline::User)
+        errors.add(:user, 'must be enabled') unless user.enabled?
+      else
+        errors.add(:user, 'must be provided')
+      end
+    end
+
+  end
+end

data/app/models/incline/password_reset.rb

@@ -0,0 +1,14 @@
+module Incline
+  class PasswordReset
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    attr_accessor :password
+    attr_accessor :recaptcha
+
+    validates :password, presence: true, length: { minimum: 8 }, confirmation: true
+    validates :password_confirmation, presence: true
+    validates :recaptcha, presence: true, 'incline/recaptcha' => true
+
+  end
+end

data/app/models/incline/password_reset_request.rb

@@ -0,0 +1,14 @@
+
+module Incline
+  class PasswordResetRequest
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    attr_accessor :email
+    attr_accessor :recaptcha
+
+    validates :email, presence: true, 'incline/email' => true
+    validates :recaptcha, presence: true, 'incline/recaptcha' => true
+  end
+
+end