barkest_core 1.5.3.0

data/lib/barkest_core/extensions/time_extensions.rb

@@ -0,0 +1,164 @@
+# Time is much easier to work with when you discard the time zones.
+# The only place the local time matters at all is when displaying to the user on reports.
+# Everywhere else, use UTC.  The default behavior should be UTC.
+
+require 'time'
+
+
+Time.class_eval do
+
+  ##
+  # Parses a time string into UTC time.
+  #
+  # Supports either M/D/Y H:M:S or Y-M-D H:M:S format.
+  #
+  # If a timezone is provided, it will be taken into account and the UTC equivalent will be returned.
+  def self.utc_parse(s)
+    raise ArgumentError, 'expected a time value to be provided' if s.blank?
+
+    # If it's already a time, return the UTC variant.
+    return s.utc if s.is_a?(Time)
+    # If it can be converted to a time, and is not a string, convert and return the UTC variant.
+    return s.to_time.utc if s.respond_to?(:to_time) && !s.is_a?(String)
+    # If it is not a string, turn it into a string and parse that.
+    return utc_parse(s.to_s) unless s.is_a?(String)
+
+    dt,tm,tz,ex = s.split(' ')
+
+    # Time only?
+    if dt.include?(':')
+      ex = tz
+      tz = tm
+      tm = dt
+      dt = '1900-01-01'
+    end
+
+    yr,mon,day =
+        if dt.include?('/')
+          # M/D/Y
+          _m,_d,_y = dt.split('/')
+          _y ||= Time.now.utc.year
+          [ _y, _m, _d ]
+        elsif dt.include?('-')
+          # Y-M-D
+          dt.split('-')
+
+          # Because we may be interacting with Spectrum users, accept these formats as well.
+        elsif (/^\d{4}$/).match(dt)
+          # MMDD
+          [ Time.now.utc.year, dt[0...2], dt[2...4] ]
+        elsif (/^\d{6}(\d{2})?$/).match(dt)
+          # MMDDYY(YY)
+          [ dt[4..-1], dt[0...2], dt[2...4] ]
+
+        elsif (/^\d+(am|pm)?$/i).match(dt) && (0..24).include?(dt.to_i)
+          # a single integer parsing to a valid hour, possibly with an AM/PM specifier
+          ex = tz
+          tz = tm
+          tm = dt
+          [ 1900, 1, 1 ]
+
+        else
+          # Unsupported format.
+          []
+        end.map { |i| i.to_i }
+
+    raise ArgumentError, 'year is missing' unless yr
+    raise ArgumentError, 'month is missing' unless mon
+    raise ArgumentError, 'day is missing' unless day
+
+    yr += 2000 if yr < 40
+    yr += 1900 if yr < 100
+
+    mon = 1 unless mon
+    day = 1 unless day
+
+    if tm
+      # allow AM/PM specifier to be attached to time.
+      if %w(AM PM).include?(tm[-2..-1].to_s.upcase)
+        ex = tz
+        tz = tm[-2..-1]
+      end
+    end
+
+    hr,min,sec = tm ? tm.split(':') : []
+    hr = hr ? hr.to_i : 0
+    min = min ? min.to_i : 0
+    sec = sec ? sec.to_f : 0.0
+
+    if %w(AM PM).include?(tz.to_s.upcase)
+      raise ArgumentError, 'hour must be between 1 and 12 for 12-hour formats' unless (1..12).include?(hr)
+
+      tz = tz.to_s.upcase
+
+      if tz == 'AM'
+        hr = 0 if hr == 12    # only need to modify midnight.
+      else
+        hr += 12 unless hr == 12  # modify everything except noon.
+      end
+
+      # grab the next item from the original string.
+      tz = ex
+    end
+
+    if hr == 24 && min == 0 && sec == 0
+      tmp_date = Time.utc(yr,mon,day)
+      raise ArgumentError, 'time component overflow' unless tmp_date.year == yr && tmp_date.month == mon && tmp_date.day == day
+      tmp_date = (tmp_date + 1.day).to_time.utc
+      yr = tmp_date.year
+      mon = tmp_date.month
+      day = tmp_date.day
+      hr = 0
+    end
+
+    tz = nil if %w(UTC).include?(tz.to_s.upcase)
+
+    result =
+      if tz
+        bits = (/^([+-])(\d{1,2}):?(\d{2})$/).match(tz)
+        raise ArgumentError, '"+HH:MM" or "-HH:MM" expected for utc_offset' unless bits
+        tz = "#{bits[1]}#{bits[2].rjust(2,'0')}:#{bits[3]}"
+        Time.new(yr, mon, day, hr, min, sec, tz)
+      else
+        Time.utc(yr, mon, day, hr, min, sec)
+      end
+
+    raise ArgumentError, 'time component overflow' unless result.year == yr && result.month == mon && result.day == day && result.hour == hr && result.min == min && result.sec.to_i == sec.to_i
+
+    result.utc
+  end
+
+
+  ##
+  # Gets the date component of the time.
+  def date
+    return utc.date unless utc?
+    Time.utc(year, month, day)
+  end
+
+  ##
+  # Discards time zone information and makes
+  #
+  # The current time zone offset is discarded.
+  # For instance, '2016-12-19 19:00:00 -05:00' becomes '2016-12-19 19:00:00 +00:00'
+  def as_utc
+    Time.utc(year, month, day, hour, min, sec)
+  end
+
+end
+
+Date.class_eval do
+  # :nodoc:
+  alias :barkest_core_original_to_time :to_time
+
+  ##
+  # Returns the date in UTC format.
+  #
+  # Time portion will always be 00:00:00 UTC.
+  # Dates shouldn't be TZ specific.
+  def to_time
+    Time.utc(year, month, day)
+  end
+
+end
+

data/lib/barkest_core/handlers/csv_handler.rb

@@ -0,0 +1,30 @@
+require 'csv'
+
+module BarkestCore
+
+  ##
+  # Handles CSV views.
+  module CsvHandler
+    # :enddoc:
+
+    class CsvGenerator
+      def self.generate
+        file = CSV.generate do |csv|
+          yield csv
+        end
+        file.html_safe
+      end
+    end
+
+    class Handler
+      def self.call (template)
+        %{
+          BarkestCore::CsvHandler::CsvGenerator.generate do |csv|
+            #{template.source}
+          end
+        }
+      end
+    end
+  end
+
+end

data/lib/barkest_core/version.rb

@@ -0,0 +1,3 @@
+module BarkestCore
+  VERSION = '1.5.3.0'
+end

data/lib/barkest_core.rb

@@ -0,0 +1,324 @@
+require 'barkest_core/engine'
+require 'fileutils'
+require 'time'
+
+module BarkestCore
+
+  ##
+  # Cache of the application root path for use within the engine.
+  mattr_accessor :app_root
+
+  ##
+  # Determines the accessibility of /users (index) and /users/1 (show) actions.
+  #
+  # Set to true to deny access to the users' list and user profiles for non-admin users.
+  # Set to false to allow access to the users' list for all logged-in users.
+  mattr_accessor :lock_down_users
+
+  ##
+  # Gets the database configuration for the auth models.
+  #
+  # The +barkest_core+ database must be defined in +database.yml+.
+  # This will either be an explicit +barkest_core+ section or a normal environment section (ie - +production+).
+  # However other databases can be defined via the SystemConfig model.
+  #
+  # The +database.yml+ file is checked first, followed by SystemConfig.
+  # If neither of those defines the specific database, then we fall back on +database.yml+ to load
+  # the global configuration for the environment.
+  #
+  # For instance, if you want the configuration for :mydb in the :development environment:
+  # * Check in +database.yml+ for "mydb_development".
+  # * Check in +database.yml+ for "mydb".
+  # * Check in SystemConfig for "mydb" (unless "mydb" == "barkest_core").
+  # * Check in +database.yml+ for "development".
+  # * Fall back on default connection used by ActiveRecord::Base.
+  #
+  # Returned hash will have symbol keys.
+  def self.db_config(other = nil, env = nil, convert_extra = true)
+    if other
+      @db_configs ||= {}
+
+      other = other.to_sym
+      env = (env || Rails.env).to_sym
+      key = :"#{other}_#{env}"
+
+      @db_configs[key] ||=
+        begin
+          avail = avail_db_configs
+
+          # for any db connection other than the core connection, check
+          # in the system config table as well.
+          syscfg = (other == :barkest_core) ? nil : SystemConfig.get(other)
+          defcfg = (other == :barkest_core) ? avail[env] : db_config_defaults(other)
+
+          # Preference
+          (
+              avail[key] ||                         # 1: barkest_core_development
+              avail[other] ||                       # 2: barkest_core
+              syscfg ||                             # 3: SystemConfig: barkest_core
+              defcfg ||                             # 4: YAML[env] or defaults depending on db name
+              ActiveRecord::Base.connection_config  # 5: default connection (hopefully never gets used)
+          ).merge(defcfg.select do |k,_|
+            [ # reset name, type, and label for extra values.
+                :extra_1_name, :extra_1_type, :extra_1_label,
+                :extra_2_name, :extra_2_type, :extra_2_label,
+                :extra_3_name, :extra_3_type, :extra_3_label,
+                :extra_4_name, :extra_4_type, :extra_4_label,
+                :extra_5_name, :extra_5_type, :extra_5_label
+            ].include?(k)
+          end)
+        end
+            .symbolize_keys
+
+      if convert_extra
+        @db_configs[:"#{key}_converted"] ||= BarkestCore::DatabaseConfig.new(@db_configs[key]).to_h(true)
+      else
+        @db_configs[key]
+      end
+    elsif env
+      db_config(:barkest_core, env, convert_extra)
+    else
+      @db_config ||= db_config(:barkest_core, Rails.env, false)
+    end
+  end
+
+  ##
+  # Determines if the configuration for the specified database is stored in the global configuration file.
+  def self.db_config_is_file_based?(db_name)
+    avail = avail_db_configs.keys
+    avail.include?(:"#{db_name}_#{Rails.env}") || avail.include?(:"#{db_name}")
+  end
+
+  ##
+  # Sets the defaults for a database configuration.
+  def self.register_db_config_defaults(db_name, defaults)
+    # reset the config cache.
+    @db_configs = nil
+
+    db_name = db_name.to_s
+    return false if db_name.blank?
+    return false if db_name == 'barkest_core'
+
+    # set the defaults.
+    @db_config_defaults ||= {}
+    @db_config_defaults[db_name.to_sym] = defaults
+
+    true
+  end
+
+  ##
+  # Gets the email configuration for the application.
+  #
+  # Email settings are stored under the :email key within SystemConfig.
+  #
+  # Returned keys will be symbols.
+  def self.email_config
+    @email_config ||= email_config_defaults(nil).merge( (SystemConfig.get(:email) || {}).symbolize_keys )
+  end
+
+  ##
+  # Provides the defaults to be returned by email_config when settings are missing.
+  def self.email_config_defaults(new_defaults = {})
+    @email_config_defaults = nil if new_defaults
+    @email_config_defaults ||=
+        {
+            config_mode: :none,
+            default_sender: 'support@barkerest.com',
+            default_recipient: 'support@barkerest.com',
+            default_hostname: 'localhost',
+        }.merge((new_defaults || {}).symbolize_keys)
+  end
+
+  ##
+  # Gets the authorization configuration.
+  #
+  # Basically this does two things.
+  # 1) It will enable/disable internal database authentication.
+  # 2) It will enable/disable ldap authentication.
+  #
+  # If ldap authentication is not configured then internal database authentication
+  # is forcibly enabled.  Both modes can be active simultaneously.
+  #
+  # Auth settings are stored under the :auth key within SystemConfig.
+  #
+  # Returned keys will be symbols.
+  def self.auth_config
+    @auth_config ||=
+        begin
+          cfg = auth_config_defaults(nil).symbolize_keys.merge( (SystemConfig.get(:auth) || {}).symbolize_keys )
+
+          cfg[:enable_db_auth] = true unless cfg[:enable_ldap_auth]
+
+          cfg
+        end
+  end
+
+  ##
+  # Provides the defaults to be provided by auth_config when settings are missing.
+  def self.auth_config_defaults(new_defaults = {})
+    @auth_config_defaults = nil if new_defaults
+    @auth_config_defaults ||=
+        {
+            enable_db_auth: true,
+            enable_ldap_auth: false,
+        }.merge((new_defaults || {}).symbolize_keys)
+  end
+
+  # :nodoc:
+  def self.config
+    BarkestCore::Engine.config
+  end
+
+  ##
+  # Tells the hosting service (Passenger) that we want to restart the application.
+  def self.request_restart
+    FileUtils.touch restart_file
+  end
+
+  ##
+  # Determines if the application is still waiting on a restart to take place.
+  def self.restart_pending?
+    return false unless File.exist?(restart_file)
+
+    request_time = File.mtime(restart_file)
+
+    request_time > start_time
+  end
+
+  ##
+  # Gets a list of key gems with their versions.
+  #
+  # This is useful for informational displays such as brief application version diplays.
+  #
+  # Supply one or more patterns for gem names.  If you supply none, then the default
+  # pattern list is used.
+  def self.gem_list(*patterns)
+    ret = []
+
+    if patterns.blank?
+      patterns = key_gem_patterns
+    elsif patterns.first.is_a?(TrueClass)
+      patterns = key_gem_patterns + patterns[1..-1]
+    elsif patterns.last.is_a?(TrueClass)
+      patterns = patterns[0...-1] + key_gem_patterns
+    end
+
+    patterns = patterns.flatten.inject([]) { |memo,v| memo << v unless memo.include?(v); memo }
+
+    Gem::Specification.to_a.sort{|a,b| a.name <=> b.name}.each do |gem|
+      patterns.each do |pat|
+        if pat.is_a?(String) && gem.name == pat
+          ret << [ gem.name, gem.version.to_s ]
+        elsif pat.is_a?(Regexp) && pat.match(gem.name)
+          ret << [ gem.name, gem.version.to_s ]
+        end
+      end
+    end
+
+    ret
+  end
+
+  ##
+  # Adds a key gem pattern to the default gem_list results.
+  def self.add_key_gem_pattern(pattern)
+    pattern = pattern.to_s.downcase
+    unless pattern.blank?
+      key_gem_patterns << pattern unless key_gem_patterns.include?(pattern)
+    end
+    key_gem_patterns.include? pattern
+  end
+
+  ##
+  # Registers a partial view to build up the anonymous header menu.
+  def self.register_anon_menu(partial_path)
+    unless partial_path.blank?
+      anon_menu_registry << partial_path unless anon_menu_registry.include?(partial_path)
+    end
+  end
+
+  ##
+  # Registers a partial view to build up the authenticated header menu.
+  def self.register_auth_menu(partial_path)
+    unless partial_path.blank?
+      auth_menu_registry << partial_path unless auth_menu_registry.include?(partial_path)
+    end
+  end
+
+  ##
+  # Registers a partial view to build up the footer menu.
+  def self.register_footer_menu(partial_path)
+    unless partial_path.blank?
+      footer_menu_registry << partial_path unless footer_menu_registry.include?(partial_path)
+    end
+  end
+
+  ##
+  # Registers a path to be processed by the custom seeds.rb file.
+  def self.register_db_seed_path(seed_path)
+    unless seed_path.blank?
+      db_seed_path_registry << partial_path unless db_seed_path_registry.include?(seed_path)
+    end
+  end
+
+  ##
+  # Gets the root path of the BarkestCore gem.
+  def self.gem_root_path
+    @gem_root_path ||= File.expand_path('../..', __FILE__)
+  end
+
+  private
+
+  def self.anon_menu_registry
+    @anon_menu_registry ||= [ 'layouts/menu_anon' ]
+  end
+
+  def self.auth_menu_registry
+    @auth_menu_registry ||= [ 'layouts/menu_auth' ]
+  end
+
+  def self.footer_menu_registry
+    @footer_menu_registry ||= [ 'layouts/menu_footer' ]
+  end
+
+  def self.db_seed_path_registry
+    @db_seed_path_registry ||= [ 'db/seeds/*.rb' ]
+  end
+
+  def self.key_gem_patterns
+    @key_gem_patterns ||= [ 'rails', /^barkest/ ]
+  end
+
+  def self.db_config_defaults(db_name)
+    @db_config_defaults ||= {}
+    @db_config_defaults[db_name.to_sym] || {}
+  end
+
+  def self.avail_db_configs
+    @avail_db_configs ||=
+        begin
+          db_yml = "#{self.app_root}/config/database.yml"
+          if File.exist?(db_yml)
+            YAML.load_file(db_yml).symbolize_keys
+          else
+            ActiveRecord::Base.configurations.to_h.symbolize_keys
+          end
+        end
+  end
+
+  def self.restart_file
+    @restart_file ||= "#{self.app_root}/tmp/restart.txt"
+  end
+
+  def self.start_time
+    @start_time ||= Time.now
+  end
+
+  # make sure @start_time gets set...
+  start_time
+
+end
+
+# Preload the concerns and process the extensions.
+Dir.glob(File.expand_path('../barkest_core/{concerns,extensions,handlers}/*.rb', __FILE__)).each do |lib_code|
+  require lib_code
+end