barkest_core 1.5.3.0

data/app/helpers/barkest_core/status_helper.rb

@@ -0,0 +1,118 @@
+require 'spawnling'
+
+module BarkestCore
+  ##
+  # This module contains helper methods related to status reporting.
+  #
+  module StatusHelper
+
+    ##
+    # Shows the system status while optionally performing a long running code block.
+    #
+    # Accepted options:
+    #
+    # url_on_completion::
+    #     This is the URL you want to redirect to when the long running code completes.
+    #     If not set, then the completion button will have an empty HREF which means it will simply reload the status page.
+    #     It is therefore highly recommended that you provide this value when using this method.
+    #
+    # completion_button::
+    #     This is the label for the button that becomes visible when the long running code completes.
+    #     Defaults to 'Continue'.
+    #
+    # main_status::
+    #     This is the initial status to report for the system when a long running code block is provided.
+    #
+    # If a code block is provided, this will reset the system status and spawn a thread to run the code block.
+    # Before running the code block, it will acquire a GlobalStatus lock and set the initial status.
+    # When the code block exits, either through error or normal behavior, the GlobalStatus lock will be released.
+    #
+    # It will yield the +status+ object to the code block on a successful lock, or it will yield false to the code
+    # block to let it know that a lock could not be acquired.  You should check for this in your code block and
+    # handle the error as appropriate.
+    #
+    # Example 1:
+    #   def my_action
+    #     Spawling.new do
+    #       GlobalStatus.lock_for do |status|
+    #         if status
+    #           clear_system_status   # reset the log file.
+    #           # Do something that takes a long time.
+    #           ...
+    #         end
+    #       end
+    #     end
+    #     show_system_status(:url_on_completion => my_target_url)
+    #   end
+    #
+    # Example 2:
+    #   def my_action
+    #     show_system_status(:url_on_completion => my_target_url) do |status|
+    #       if status
+    #         # Do something that takes a long time.
+    #         ...
+    #       end
+    #     end
+    #   end
+    #
+    # The benefits of Example 2 is that it handles the thread spawning and status locking for you.
+    #
+    def show_system_status(options = {})
+      options = {
+          url_on_completion: nil,
+          completion_button: 'Continue',
+          main_status: 'System is busy'
+      }.merge(options || {})
+
+      if block_given?
+        clear_system_status
+        Spawnling.new do
+          status = BarkestCore::GlobalStatus.new
+          if status.acquire_lock
+            status.set_message options[:main_status]
+            begin
+              yield status
+            ensure
+              status.release_lock
+            end
+          else
+            yield false
+          end
+        end
+      end
+
+      session[:status_comp_url] = options[:url_on_completion]
+      session[:status_comp_lbl] = options[:completion_button]
+
+      redirect_to status_current_url
+    end
+
+    ##
+    # Clears the system status log file.
+    #
+    # If the file does not exist, it is created as a zero byte file.
+    # This is important for the status checking, since if there is no log file it will report an error.
+    #
+    def clear_system_status
+      unless BarkestCore::GlobalStatus.locked?
+        # open, truncate, and close.
+        File.open(BarkestCore::WorkPath.system_status_file,'w').close
+      end
+    end
+
+    ##
+    # Gets the URL to redirect to when the long running process completes.
+    #
+    def status_redirect_url
+      session[:status_comp_url].to_s
+    end
+
+    ##
+    # Gets the label for the button to show when the long running process completes.
+    #
+    def status_button_label
+      session[:status_comp_lbl].to_s
+    end
+
+  end
+end

data/app/helpers/barkest_core/users_helper.rb

@@ -0,0 +1,32 @@
+module BarkestCore
+  ##
+  # This module adds helper methods related to users in general (not just the current user).
+  #
+  # Based on the tutorial from [www.railstutorial.org](www.railstutorial.org).
+  #
+  module UsersHelper
+
+    ##
+    # Returns the Gravatar for the given user.
+    #
+    # Based on the tutorial from [www.railstutorial.org](www.railstutorial.org).
+    #
+    # The +user+ is the user you want to get the gravatar for.
+    #
+    # Valid options:
+    # *   +size+ The size (in pixels) for the returned gravatar.  The gravatar will be a square image using this
+    #     value as both the width and height.  The default is 80 pixels.
+    # *   +default+ The default image to return when no image is set. This can be nil, :mm, :identicon, :monsterid,
+    #     :wavatar, or :retro.  The default is :identicon.
+    def gravatar_for(user, options = {})
+      options = { size: 80, default: :identicon }.merge(options || {})
+      options[:default] = options[:default].to_s.to_sym unless options[:default].nil? || options[:default].is_a?(Symbol)
+      gravatar_id = Digest::MD5::hexdigest(user.email.downcase)
+      size = options[:size]
+      default = [:mm, :identicon, :monsterid, :wavatar, :retro].include?(options[:default]) ? "&d=#{options[:default]}" : ''
+      gravatar_url = "https://secure.gravatar.com/avatar/#{gravatar_id}?s=#{size}#{default}"
+      image_tag(gravatar_url, alt: user.name, class: 'gravatar', style: "width: #{size}px, height: #{size}px")
+    end
+
+  end
+end

data/app/mailers/application_mailer.rb

@@ -0,0 +1,5 @@
+##
+# Provides a default application mailer that is easy to override if necessary.
+class ApplicationMailer < ::BarkestCore::ApplicationMailerBase
+
+end

data/app/mailers/barkest_core/application_mailer_base.rb

@@ -0,0 +1,30 @@
+module BarkestCore
+  ##
+  # This class defines the default behavior for mailers in this application.
+  #
+  class ApplicationMailerBase < ActionMailer::Base
+
+
+    ##
+    # Gets the default hostname for messages.
+    def self.default_hostname
+      @default_hostname ||= BarkestCore.email_config[:default_hostname]
+    end
+
+    ##
+    # Gets the default sender for messages.
+    def self.default_sender
+      @default_sender ||= BarkestCore.email_config[:default_sender]
+    end
+
+    ##
+    # Gets the default recipient for messages.
+    def self.default_recipient
+      @default_recipient ||= BarkestCore.email_config[:default_recipient]
+    end
+
+    default from: ApplicationMailerBase.default_sender, to: ApplicationMailerBase.default_recipient
+    layout 'mailer'
+
+  end
+end

data/app/mailers/barkest_core/contact_form.rb

@@ -0,0 +1,20 @@
+require_dependency 'barkest_core/application_mailer_base.rb'
+
+module BarkestCore
+  ##
+  # This mailer is used for the generic contact form.
+  class ContactForm < ::BarkestCore::ApplicationMailerBase
+
+    ##
+    # Sends the message from the contact form.
+    def contact(msg)
+      @data = {
+          msg: msg,
+          client_ip: msg.remote_ip,
+          gems: BarkestCore.gem_list(Rails.application.class.parent_name.underscore, 'rails', 'barkest*'),
+      }
+      mail subject: msg.full_subject, reply_to: msg.your_email
+    end
+  end
+
+end

data/app/mailers/barkest_core/user_mailer.rb

@@ -0,0 +1,44 @@
+require_dependency 'barkest_core/application_mailer_base.rb'
+
+module BarkestCore
+  ##
+  # This mailer is used for the account activation, password reset, and invalid password reset messages.
+  #
+  class UserMailer < ::BarkestCore::ApplicationMailerBase
+
+    ##
+    # Sends the activation email to a new user.
+    def account_activation(data = {})
+      @data = {
+          user: nil,
+          client_ip: '0.0.0.0'
+      }.merge(data || {})
+      raise unless data[:user]
+      mail to: data[:user].email, subject: 'Account activation'
+    end
+
+    ##
+    # Sends the password reset email to an existing user.
+    def password_reset(data = {})
+      @data = {
+          user: nil,
+          client_ip: '0.0.0.0'
+      }.merge(data || {})
+      raise unless data[:user]
+      mail to: data[:user].email, subject: 'Password reset request'
+    end
+
+    ##
+    # Sends an invalid password reset attempt message to a user whether they exist or not.
+    def invalid_password_reset(data = {})
+      @data = {
+          email: nil,
+          message: 'This email address is not associated with an existing account.',
+          client_ip: '0.0.0.0'
+      }.merge(data || {})
+      raise unless data[:email]
+      mail to: data[:email], subject: 'Password reset request'
+    end
+
+  end
+end

data/app/models/access_group.rb

@@ -0,0 +1,121 @@
+##
+# Defines the authorization mechanism for the system.
+#
+# Access Groups can contain users and other access groups.  Any member gains access to
+# any resource that allows the parent access group.
+class AccessGroup < ::BarkestCore::DbTable
+
+  include BarkestCore::NamedModel
+
+  # hide the Groups<=>Users relationship association
+  has_many :access_group_user_members, class_name: 'AccessGroupUserMember', foreign_key: 'group_id', dependent: :delete_all
+  private :access_group_user_members, :access_group_user_members=
+
+  # and expose the Users relationship instead.
+  has_many :users, class_name: 'User', through: :access_group_user_members, source: :member
+
+  # hide the Groups<=>Groups relationship association
+  has_many :access_group_group_members, class_name: 'AccessGroupGroupMember', foreign_key: 'group_id', dependent: :delete_all
+  private :access_group_group_members, :access_group_group_members=
+
+  # and expose the group members.
+  has_many :members, class_name: '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
+
+  has_many :ldap_groups, class_name: 'LdapAccessGroup', foreign_key: 'group_id', dependent: :delete_all
+
+  validates :name,
+            presence: true,
+            length: { maximum: 100 },
+            uniqueness: { case_sensitive: false }
+
+  scope :sorted, ->{ order(:name) }
+
+  ##
+  # Gets the LDAP group list as a newline separated string.
+  #
+  # Specify +refresh+ to force the list to be reloaded.
+  #
+  # Specify a +separator+ if your would like to use something other than a newline.
+  def ldap_group_list(refresh = false, separator = "\n")
+    @ldap_group_list = nil if refresh
+    @ldap_group_list ||= ldap_groups(refresh).map{|v| v.name.upcase}.join(separator)
+  end
+
+  ##
+  # Splits a newline separated string into LDAP groups for this group.
+  #
+  # +value+ can be either a newline separated string or an array of strings.
+  def ldap_group_list=(value)
+    # convert string into array.
+    value = value.split("\n") if value.is_a?(String)
+
+    @ldap_group_list = nil
+
+    if value.is_a?(Array) && value.count > 0
+
+      value = value.map{|v| v.to_s.upcase}.uniq
+
+      # remove those missing from the new list.
+      ldap_groups.where.not(name: value).delete_all
+
+      # remove items already existing in the current list.
+      value.delete_if {|v| ldap_groups.where(name: v).count != 0 }
+
+      # add items missing from the current list.
+      value.each do |new_group|
+        ldap_groups << LdapAccessGroup.new(group: self, name: new_group)
+      end
+
+    else
+
+      # clear the list.
+      ldap_groups.delete_all
+    end
+
+    ldap_groups true
+  end
+
+  ##
+  # Determines if this group belongs to the specified group.
+  def belongs_to?(group)
+    group = AccessGroup.get(group) unless group.is_a?(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
+  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
+
+end

data/app/models/access_group_group_member.rb

@@ -0,0 +1,13 @@
+##
+# Defines an access group that belongs to another access group.
+class AccessGroupGroupMember < ::BarkestCore::DbTable
+  belongs_to :group, class_name: 'AccessGroup'
+  belongs_to :member, class_name: '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

data/app/models/access_group_user_member.rb

@@ -0,0 +1,11 @@
+##
+# Defines a user that belongs to an access group.
+class AccessGroupUserMember < ::BarkestCore::DbTable
+
+  belongs_to :group, class_name: 'AccessGroup'
+  belongs_to :member, class_name: 'User'
+
+  validates :group_id, presence: true
+  validates :member_id, presence: true, uniqueness: { scope: :group_id }
+
+end

data/app/models/barkest_core/auth_config.rb

@@ -0,0 +1,95 @@
+module BarkestCore
+
+  ##
+  # Defines the authentication configuration for the system.
+  class AuthConfig
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    attr_accessor :enable_db_auth, :enable_ldap_auth, :ldap_host, :ldap_port, :ldap_base_dn, :ldap_ssl,
+                  :ldap_browse_user, :ldap_browse_password, :ldap_auto_activate, :ldap_system_admin_groups
+
+    validate do
+      errors.add :enable_db_auth, 'must be selected if enable_ldap_auth is not selected' unless enable_ldap_auth? || enable_db_auth?
+    end
+
+    with_options if: :enable_ldap_auth?, presence: true do |cfg|
+      cfg.validates :ldap_host
+      cfg.validates :ldap_port
+      cfg.validates :ldap_base_dn
+      cfg.validates :ldap_browse_user
+      cfg.validates :ldap_browse_password
+      cfg.validates :ldap_system_admin_groups
+    end
+
+    ##
+    # Creates the configuration.
+    def initialize(*args)
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          arg.each do |k,v|
+            if respond_to?(:"#{k}?")
+              send :"#{k}=", ((v === true || v === '1') ? '1' : '0')
+            elsif respond_to?(k)
+              send :"#{k}=", v.to_s
+            end
+          end
+        end
+      end
+    end
+
+    ##
+    # Is DB authentication enabled?
+    def enable_db_auth?
+      enable_db_auth.to_s.to_i != 0
+    end
+
+    ##
+    # Is LDAP authentication enabled?
+    def enable_ldap_auth?
+      enable_ldap_auth.to_s.to_i != 0
+    end
+
+    ##
+    # Is SSL enabled for LDAP authentication?
+    def ldap_ssl?
+      ldap_ssl.to_s.to_i != 0
+    end
+
+    ##
+    # Is automatic activation enabled for LDAP authenticated users?
+    def ldap_auto_activate?
+      ldap_auto_activate.to_s.to_i != 0
+    end
+
+    ##
+    # Converts the configuration to a hash.
+    def to_h
+      {
+          enable_db_auth: enable_db_auth?,
+          enable_ldap_auth: enable_ldap_auth?,
+          ldap_host: ldap_host.to_s,
+          ldap_port: ldap_port.to_s.to_i,
+          ldap_ssl: ldap_ssl?,
+          ldap_base_dn: ldap_base_dn.to_s,
+          ldap_browse_user: ldap_browse_user.to_s,
+          ldap_browse_password: ldap_browse_password.to_s,
+          ldap_auto_activate: ldap_auto_activate?,
+          ldap_system_admin_groups: ldap_system_admin_groups.to_s,
+      }
+    end
+
+    ##
+    # Saves the configuration (encrypted) to the SystemConfig.
+    def save
+      SystemConfig.set :auth, to_h, true
+    end
+
+    ##
+    # Loads the configuration from the SystemConfig.
+    def AuthConfig.load
+      AuthConfig.new(SystemConfig.get(:auth) || {})
+    end
+
+  end
+end