barkest_core 1.5.3.0

data/app/helpers/barkest_core/html_helper.rb

@@ -0,0 +1,70 @@
+module BarkestCore
+  ##
+  # This module contains some helper functions to make generating common HTML elements easier.
+  module HtmlHelper
+
+    ##
+    # Creates a glyph icon using the specified +name+ and +size+.
+    #
+    # The +size+ can be nil, :small, :smaller, :big, or :bigger.
+    # The default size is nil.
+    def glyph(name, size = nil)
+      size = size.to_s.downcase
+      if %w(small smaller big bigger).include?(size)
+        size = ' glyph-' + size
+      else
+        size = ''
+      end
+      "<i class=\"glyphicon glyphicon-#{h name}#{size}\"></i>".html_safe
+    end
+
+    ##
+    # Creates a check glyph icon if the +bool_val+ is true.
+    #
+    # The +size+ can be nil, :small, :smaller, :big, or :bigger.
+    # The default +size+ is :small.
+    def check_if(bool_val, size = :small)
+      glyph(:ok, size) if bool_val
+    end
+
+    ##
+    # Creates a panel with the specified title.
+    #
+    # Valid options:
+    #  *  +type+ can be +primary+, +success+, +info+, +warning+, or +danger+.   Default: primary
+    #  *  +size+ can be any value from 1..12.   Default: 6
+    #  *  +offset+ can be any value from 0..12.   Default: 3
+    #  *  +open_body+ can be true or false.  If true, the body division is opened (and closed) by this helper.   Default: true
+    #
+    # Provide a block to render content within the panel.
+    def panel(title, options = { }, &block)
+      options = {
+          type: 'primary',
+          size: 6,
+          offset: 3,
+          open_body: true
+      }.merge(options || {})
+
+      options[:type] = options[:type].to_s.downcase
+      options[:type] = 'primary' unless %w(primary success info warning danger).include?(options[:type])
+      options[:size] = 6 unless (1..12).include?(options[:size])
+      options[:offset] = 3 unless (0..12).include?(options[:offset])
+
+      ret = "<div class=\"col-md-#{options[:size]} col-md-offset-#{options[:offset]}\"><div class=\"panel panel-#{options[:type]}\"><div class=\"panel-heading\"><h4 class=\"panel-title\">#{h title}</h4></div>"
+      ret += '<div class="panel-body">' if options[:open_body]
+
+      if block_given?
+        content = capture { block.call }
+        ret += h content.to_s
+      end
+
+      ret += '</div>' if options[:open_body]
+      ret += '</div></div>'
+
+      ret.html_safe
+    end
+
+
+  end
+
+end

data/app/helpers/barkest_core/misc_helper.rb

@@ -0,0 +1,68 @@
+module BarkestCore
+  ##
+  # Contains some miscellaneous helper methods.
+  module MiscHelper
+
+    ##
+    # Formats a date in M/D/YYYY format.
+    #
+    # The +date+ can be either a string already in the correct format, or a Date/Time object.
+    # If +date+ is blank or nil, then nil will be returned.
+    #
+    def fmt_date(date)
+      return nil if date.blank?
+      return nil unless (date.is_a?(String) || date.is_a?(Date) || date.is_a?(Time))
+      unless date.is_a?(String)
+        date = date.to_s(:date4)
+      end
+      m,d,y = date.split('/')
+      "#{m.to_i}/#{d.to_i}/#{y.to_i}"
+    end
+
+    ##
+    # Formats a number to the specified number of decimal places.
+    #
+    # The +value+ can be either any valid numeric expression that can be converted to a float.
+    #
+    def fixed(value, places = 2)
+      value = value.to_s.to_f unless value.is_a?(Float)
+      sprintf("%0.#{places}f", value.round(places))
+    end
+
+    ##
+    # Splits a name into First, Middle, and Last parts.
+    #
+    # Returns an array containing [ First, Middle, Last ]
+    # Any part that is missing will be nil.
+    #
+    #   'John Doe'          => [ 'John', nil, 'Doe' ]
+    #   'Doe, John'         => [ 'John', nil, 'Doe' ]
+    #   'John A. Doe'       => [ 'John', 'A.', 'Doe' ]
+    #   'Doe, John A.'      => [ 'John', 'A.', 'Doe' ]
+    #   'John A. Doe Jr.'   => [ 'John', 'A.', 'Doe Jr.' ]
+    #   'Doe Jr., John A.'  => [ 'John', 'A.', 'Doe Jr.' ]
+    #
+    # Since it doesn't check very hard, there are some known bugs as well.
+    #
+    #   'John Doe Jr.'      => [ 'John', 'Doe', 'Jr.' ]
+    #   'John Doe, Jr.'     => [ 'Jr.', nil, 'John Doe' ]
+    #   'Doe, John A., Jr.' => [ 'John', 'A., Jr.', 'Doe' ]
+    #
+    # It should work in most cases.
+    #
+    def split_name(name)
+      name ||= ''
+      if name.include?(',')
+        last,first = name.split(',', 2)
+        first,middle = first.to_s.strip.split(' ', 2)
+      else
+        first,middle,last = name.split(' ', 3)
+        if middle && !last
+          middle,last = last,middle
+        end
+      end
+      [ first.to_s.strip, middle.to_s.strip, last.to_s.strip ]
+    end
+
+  end
+end

data/app/helpers/barkest_core/pdf_helper.rb

@@ -0,0 +1,180 @@
+require 'prawn-rails/document'
+require 'prawn/measurement_extensions'
+require 'prawn/font'
+
+module BarkestCore
+  ##
+  # This module defines the method that makes PDF generation just a bit easier.
+  #
+  module PdfHelper
+
+    ##
+    # Creates a PDF document with the specified options.
+    #
+    # The document will be setup with configured margins, a 100x100 grid, and one embedded font (ArhivoNarrow).
+    # Once the document is configured, the +pdf+ will be yielded to the block provided to generate the content.
+    #
+    # Accepted options:
+    #
+    # page_layout::
+    #     Specify the page layout. This can be either :portrait or :landscape.  Defaults to :portrait.
+    #
+    # page_size::
+    #     Specify the page size.  This defaults to 'LETTER'. See {Prawn PDF Manual}[http://prawnpdf.org/manual.pdf#page=91] for more information.
+    #
+    # margin::
+    #     Specify the margin size.  This can be either a single value or an array of values.  Internally it always
+    #     gets converted to an array of values.  If you only specify a single value, it will be filled out as the
+    #     margin for all four edges.  Alternatively, you can set :top_margin, :right_margin, :left_margin, and
+    #     :bottom_margin individually.
+    #
+    # top_margin::
+    #     Specify the top margin size.  Defaults to 0.5 in.
+    #
+    # right_margin::
+    #     Specify the right margin size.  Defaults to 0.5 in.
+    #
+    # left_margin::
+    #     Specify the left margin size.  Defaults to 0.5 in.
+    #
+    # bottom_margin::
+    #     Specify the bottom margin size.  Defaults to 0.5 in.
+    #
+    # print_scaling::
+    #     Allows you to specify the default print scaling in the print dialog.  Defaults to :none.
+    #     See the {Prawn PDF Manual}[http://prawnpdf.org/manual.pdf#page=95] for more information.
+    #
+    # font_name::
+    #     Specify the default font for the document.  Can be one of 'Helvetica', 'Times-Roman', 'Courier', or
+    #     'ArchivoNarrow'.  Defaults to 'Helvetica'.
+    #
+    # font_size::
+    #     Specify the default font size for the document.  Defaults to 10 pt.
+    #
+    # skip_footer::
+    #     Set to true to skip footer generation.  Otherwise, once you finish generating content, a footer will
+    #     be attached to every page automatically.
+    #
+    # footer_left::
+    #     Set the left footer text.  Defaults to the current user name and time.
+    #
+    # footer_center::
+    #     Set the center footer text.  Defaults to the request path.
+    #
+    # footer_right::
+    #     Set the right footer text.  Defaults to "Page # of #".
+    #
+    # footer_hr::
+    #     Set to true to draw a horizontal rule above the footer, or false to omit the horizontal rule.
+    #     Defaults to true.
+    #
+    # footer_color::
+    #     Set the color of the footer text.  Defaults to '000000' (black).
+    #
+    def pdf_doc(options = {})
+
+      # our default values merged with the configured values and then the options provided.
+      options = {
+          page_layout: :portrait,
+          page_size: 'LETTER',
+          margin: [ 0.5.in, 0.5.in, 0.55.in, 0.5.in ],
+          print_scaling: :none,
+          font_name: 'Helvetica',
+          font_size: 10.0
+      }.merge(PrawnRails.config.to_h).merge(options || {})
+
+      # build the info
+      options[:info] ||= {}
+      options[:info].merge!({
+                                Title: options.delete(:title) ||  "#{controller_name}##{action_name}",
+                                Creator: options.delete(:creator) || Rails.application.app_company,
+                                Producer: options.delete(:producer) || Rails.application.app_info,
+                                CreationDate: options.delete(:creation_date) || Time.now
+                            })
+
+      # build the margin array
+      options[:margin] ||= []
+      options[:margin] = [ options[:margin] ] * 4 unless options[:margin].is_a?(Array)
+
+      # top margin defaults to 0.5".
+      options[:margin][0] = options[:top_margin] if options[:top_margin]
+      options[:margin][0] = 0.5.in unless options[:margin][0]
+
+      # right margin defaults to top margin.
+      options[:margin][1] = options[:right_margin] if options[:right_margin]
+      options[:margin][1] = options[:margin][0] unless options[:margin][1]
+
+      # bottom margin defaults to top margin.
+      options[:margin][2] = options[:bottom_margin] if options[:bottom_margin]
+      options[:margin][2] = options[:margin][0] unless options[:margin][2]
+
+      # left margin defaults to right margin.
+      options[:margin][3] = options[:left_margin] if options[:left_margin]
+      options[:margin][3] = options[:margin][1] unless options[:margin][3]
+
+      font_name = options[:font_name] || 'Helvetica'
+      font_size = options[:font_size] || 10.0
+
+      skip_footer = options[:skip_footer].nil? ? false : options[:skip_footer]
+
+      footer_left = options[:footer_left].nil? ? "#{current_user.name} - #{Time.zone.now.strftime('%Y-%m-%d %H:%M:%S')}" : options[:footer_left].to_s
+      footer_center = options[:footer_center].nil? ? request.fullpath : options[:footer_center].to_s
+      footer_right = options[:footer_right].nil? ? nil : options[:footer_right].to_s
+      footer_hr = options[:footer_hr].nil? ? true : options[:footer_hr]
+      footer_color = options[:footer_color].nil? ? '000000' : options[:footer_color].to_s
+
+      # remove some options that are custom.
+      options.except!(
+          :title, :creator, :producer, :creation_date,
+          :top_margin, :bottom_margin, :left_margin, :right_margin,
+          :font_name, :font_size,
+          :skip_footer
+      )
+
+      left_edge = options[:margin][3]
+      right_edge = options[:margin][1]
+      bottom_edge = options[:margin][2]
+
+      pdf = PrawnRails::Document.new(options)
+
+      # ArchivoNarrow gives us another sans font that has tighter letter spacing, and it is also a freely available font requiring no licensing.
+      pdf.font_families['ArchivoNarrow'] = {
+          bold:         { file: pdf.asset_font_path('barkest_core/ArchivoNarrow-Bold.ttf') },
+          italic:       { file: pdf.asset_font_path('barkest_core/ArchivoNarrow-Italic.ttf') },
+          bold_italic:  { file: pdf.asset_font_path('barkest_core/ArchivoNarrow-BoldItalic.ttf') },
+          normal:       { file: pdf.asset_font_path('barkest_core/ArchivoNarrow-Regular.ttf') },
+      }
+
+      # set the default font and size
+      pdf.font font_name, size: font_size
+
+      # nice fine grid layout.
+      pdf.define_grid columns: 100, rows: 100, gutter: 2.5
+
+      yield pdf if block_given?
+
+      unless skip_footer
+        pdf.font font_name, size: 8.0 do
+          (1..pdf.page_count).each do |pg|
+            pdf.go_to_page pg
+            pdf.canvas do
+              width = pdf.bounds.right - right_edge - left_edge
+              if footer_hr
+                pdf.stroke_color '000000'
+                pdf.stroke { pdf.horizontal_line left_edge, pdf.bounds.right - right_edge, at: bottom_edge }
+              end
+              pos = [ left_edge, bottom_edge - 3 ]
+              pdf.bounding_box(pos, width: width, height: 12) { pdf.text pdf.footer_values[0] || footer_left, align: :left, color: footer_color }
+              pdf.bounding_box(pos, width: width, height: 12) { pdf.text pdf.footer_values[1] || footer_center, align: :center, color: footer_color }
+              pdf.bounding_box(pos, width: width, height: 12) { pdf.text pdf.footer_values[2] || (footer_right || "Page #{pg} of #{pdf.page_count}"), align: :right, color: footer_color }
+            end
+          end
+        end
+      end
+
+      pdf.render
+
+    end
+  end
+
+end

data/app/helpers/barkest_core/recaptcha_helper.rb

@@ -0,0 +1,115 @@
+module BarkestCore
+  ##
+  # This module makes it easy to work with Google's recaptcha service.
+  #
+  # Simply add +recaptcha_public_key+ and +recaptch_private_key+ to your
+  # +secrets.yml+ configuration file, or provide +RECAPTCHA_PUBLIC_KEY+
+  # and +RECAPTCHA_PRIVATE_KEY+ environment variables.
+  module RecaptchaHelper
+
+    private
+
+    def load_recaptcha_keys
+      tmp = ENV['RECAPTCHA_PUBLIC_KEY'].to_s
+      @recaptcha_site_key = tmp.blank? ? Rails.application.secrets[:recaptcha_public_key].to_s : tmp
+      tmp = ENV['RECAPTCHA_PRIVATE_KEY'].to_s
+      @recaptcha_secret_key = tmp.blank? ? Rails.application.secrets[:recaptcha_private_key].to_s : tmp
+    end
+
+    def recaptcha_site_key
+      load_recaptcha_keys unless @recaptcha_site_key
+      @recaptcha_site_key
+    end
+
+    def recaptcha_secret_key
+      load_recaptcha_keys unless @recaptcha_secret_key
+      @recaptcha_secret_key
+    end
+
+    def recaptcha_disabled?
+      Rails.env.test? || recaptcha_site_key.blank? || recaptcha_secret_key.blank?
+    end
+
+    public
+
+    ##
+    # Adds the recaptcha challenge to a form.
+    #
+    # This will include the recaptcha API from Google automatically and inserts a +<br>+ sequence after the challenge
+    # if +include_break+ is set to true (the default).
+    def add_recaptcha_challenge(include_break = true)
+      unless recaptcha_disabled?
+        "<div class=\"g-recaptcha\" data-sitekey=\"#{h recaptcha_site_key}\"></div>\n<script src=\"https://www.google.com/recaptcha/api.js\"></script>#{include_break ? '<br>' : ''}".html_safe
+      end
+    end
+
+    ##
+    # Verifies the response from a recaptcha challenge in a controller.
+    #
+    # It will return true if the recaptcha challenge passed.  It always returns true in the 'test' environment.
+    #
+    # If a +model+ is provided, then an error will be added to the model if the challenge fails.
+    # Because this is handled outside of the model (since it's based on the request and not the model),
+    # you should first check if the model is valid and then verify the recaptcha challenge to ensure you
+    # don't lose the recaptcha error message.
+    #
+    #   if model.valid? && verify_recaptcha_challenge(model)
+    #     model.save
+    #     redirect_to :show, id: model
+    #   else
+    #     render 'edit'
+    #   end
+    #
+    def verify_recaptcha_challenge(model = nil)
+
+      # always true in tests.
+      return true if recaptcha_disabled?
+
+      # model must respond to the 'errors' message and the result of that must respond to 'add'
+      if !model || !model.respond_to?('errors') || !model.send('errors').respond_to?('add')
+        model = nil
+      end
+
+      begin
+        recaptcha = nil
+
+        http = Net::HTTP
+
+        remote_ip = (request.respond_to?('remote_ip') && request.send('remote_ip')) || (env && env['REMOTE_ADDR'])
+        verify_hash = {
+            secret: recaptcha_secret_key,
+            remoteip: remote_ip,
+            response: params['g-recaptcha-response']
+        }
+
+        Timeout::timeout(5) do
+          uri = URI.parse('https://www.google.com/recaptcha/api/siteverify')
+          http_instance = http.new(uri.host, uri.port)
+          if uri.port == 443
+            http_instance.use_ssl = true
+            http_instance.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+          request = Net::HTTP::Post.new(uri.request_uri)
+          request.set_form_data(verify_hash)
+          recaptcha = http_instance.request(request)
+        end
+        answer = JSON.parse(recaptcha.body)
+
+        if answer['success'].to_s.downcase == 'true'
+          return true
+        else
+          if model
+            model.errors.add(:base, 'Recaptcha verification failed.')
+          end
+          return false
+        end
+
+      rescue Timeout::Error
+        if model
+          model.errors.add(:base, 'Recaptcha unreachable.')
+        end
+      end
+    end
+
+  end
+end

data/app/helpers/barkest_core/sessions_helper.rb

@@ -0,0 +1,94 @@
+module BarkestCore
+  ##
+  # This module adds +log_in+, +log_out+, +current_user+, and other session related helper methods.
+  #
+  # Based on the tutorial from [www.railstutorial.org](www.railstutorial.org).
+  module SessionsHelper
+
+    ##
+    # Logs in the given user.
+    def log_in(user)
+      session[:user_id] = user.id
+    end
+
+    ##
+    # Logs out any currently logged in user.
+    def log_out
+      forget current_user
+      session.delete(:user_id)
+      @current_user = nil
+    end
+
+    ##
+    # Gets the current user.
+    def current_user
+      if (user_id = session[:user_id])
+        @current_user ||= User.find_by(id: user_id)
+      elsif (user_id = cookies.signed[:user_id])
+        user = User.find_by(id: user_id)
+        if user && user.authenticated?(:remember, cookies[:remember_token])
+          log_in user
+          @current_user = user
+        end
+      end
+    end
+
+    ##
+    # Is the specified user the current user?
+    def current_user?(user)
+      user == current_user
+    end
+
+    ##
+    # Is the current user a system administrator?
+    def system_admin?
+      current_user && current_user.system_admin?
+    end
+
+    ##
+    # Is a user currently logged in?
+    def logged_in?
+      !current_user.nil?
+    end
+
+    ##
+    # Stores the user id to the permanent cookies to keep the user logged in.
+    def remember(user)
+      user.remember
+      cookies.permanent.signed[:user_id] = user.id
+      cookies.permanent[:remember_token] = user.remember_token
+    end
+
+    ##
+    # Removes the user from the permanent cookies.
+    def forget(user)
+      user.forget
+      cookies.delete(:user_id)
+      cookies.delete(:remember_token)
+    end
+
+    ##
+    # A helper redirect method primarily used after logon to redirect to the page that requested a logon.
+    #
+    # There may be other uses, but logon is the most likely use case.
+    def redirect_back_or(default)
+      redirect_to(session[:forwarding_url] || default)
+      session.delete(:forwarding_url)
+    end
+
+    ##
+    # Stores the current request URL to the session for use with +redirect_back_or+.
+    #
+    def store_location
+      session[:forwarding_url] = request.url if request.get?
+    end
+
+    ##
+    # Stores the current request URL to the session and redirects to the specified URL.
+    def store_location_and_redirect_to(url)
+      store_location
+      redirect_to url
+    end
+
+  end
+end