rails_base 0.51.0

data/app/helpers/rails_base/application_helper.rb

@@ -0,0 +1,26 @@
+module RailsBase::ApplicationHelper
+
+  TIMEZONE_OFFSET_COOKIE = "_#{Rails.application.class.parent_name}_timeoffset"
+  TIMEZONE_SESSION_NAME = TIMEZONE_THREAD_NAME = :tz_info
+
+  def browser
+    @browser ||= Browser.new(request.user_agent)
+  end
+
+  def is_mobile?
+    browser.mobile?
+  end
+
+  def is_safari?
+    browser.safari?
+  end
+
+  def mfa_fallback?
+    is_mobile? # && is_safari?
+  end
+
+  def admin_reset_session!
+    session.delete(RailsBase::Authentication::Constants::ADMIN_REMEMBER_REASON)
+    session.delete(RailsBase::Authentication::Constants::ADMIN_REMEMBER_USERID_KEY)
+  end
+end

data/app/helpers/rails_base/capture_reference_helper.rb

@@ -0,0 +1,57 @@
+module RailsBase
+  module CaptureReferenceHelper
+    CAPTURE_CONTROLLER_PATH = :referer_controller_path
+    CAPTURE_ACTION_NAME = :referer_action_name
+    CAPTURE_REFERRED_PATH = :referer_referred_path
+
+    def authenticate_user!
+      # only if request is a get and not authenticated
+      capture_reference if request.method == 'GET' && !warden.authenticated?
+      super()
+    end
+
+    def capture_reference
+      return unless use_capture_reference?
+
+      session[CAPTURE_CONTROLLER_PATH] = controller_path
+      session[CAPTURE_ACTION_NAME] = action_name
+      session[CAPTURE_REFERRED_PATH] = request.path
+    end
+
+    def capture_clear_reference_from_sesssion!
+      session[CAPTURE_CONTROLLER_PATH] = nil
+      session[CAPTURE_ACTION_NAME] = nil
+      session[CAPTURE_REFERRED_PATH] = nil
+    end
+
+    def use_capture_reference?
+      return false if skip_capture_reference?
+
+      RailsBase.config.login_behavior.fallback_to_referred
+    end
+
+    def skip_capture_reference!
+      @__skip_capture_reference = true
+    end
+
+    def skip_capture_reference?
+      @__skip_capture_reference.presence
+    end
+
+    def reference_redirect
+      { controller: session[CAPTURE_CONTROLLER_PATH], action: session[CAPTURE_ACTION_NAME], path: session[CAPTURE_REFERRED_PATH] }
+    end
+
+    def capture_and_clear_reference_redirect!
+      temp = reference_redirect
+      capture_clear_reference_from_sesssion!
+      temp[:path]
+    end
+
+    def redirect_from_reference
+      return nil unless use_capture_reference?
+
+      capture_and_clear_reference_redirect!
+    end
+  end
+end

data/app/helpers/rails_base/mfa_auth_helper.rb

@@ -0,0 +1,2 @@
+module RailsBase::MfaAuthHelper
+end

data/app/helpers/rails_base/secondary_authentication_helper.rb

@@ -0,0 +1,2 @@
+module RailsBase::SecondaryAuthenticationHelper
+end

data/app/helpers/rails_base/user_field_validators.rb

@@ -0,0 +1,108 @@
+module RailsBase::UserFieldValidators
+	# allows us to use standard functionality of logging shit
+	def self.included klass
+    klass.class_eval do
+      include RailsBase::ServiceLogging
+    end
+  end
+
+  def validate_complement?(user_params:)
+		status = { status: true, errors: {} }
+  	if user_params[:first_name]
+	  	validator = validate_name?(name: user_params[:first_name])
+	  	unless validator[:status]
+	  		status[:status] = false
+	  		status[:errors][:first_name] = "First Name validation: #{validator[:msg]}"
+	  	end
+  	end
+
+  	if user_params[:last_name]
+	  	validator = validate_name?(name: user_params[:last_name])
+	  	unless validator[:status]
+	  		status[:status] = false
+	  		status[:errors][:last_name] = "Last Name validation: #{validator[:msg]}"
+	  	end
+  	end
+
+  	if user_params[:password] && user_params[:password_confirmation]
+  		validator = validate_password?(password: user_params[:password], password_confirmation: user_params[:password_confirmation])
+  		unless validator[:status]
+  			status[:status] = false
+  			status[:errors][:password] = "Password validation: #{validator[:msg]}"
+  		end
+  	end
+  	status
+  end
+
+  def validate_full_name?(first_name:, last_name:)
+    status = { status: true, errors: {} }
+    if first_name
+      validator = validate_name?(name: first_name)
+      unless validator[:status]
+        status[:status] = false
+        status[:errors][:first_name] = "First Name validation: #{validator[:msg]}"
+      end
+    end
+
+    if last_name
+      validator = validate_name?(name: last_name)
+      unless validator[:status]
+        status[:status] = false
+        status[:errors][:last_name] = "Last Name validation: #{validator[:msg]}"
+      end
+    end
+    status
+  end
+
+  def validate_name?(name:)
+  	unacceptable_chars = name.tr("a-zA-Z '",'')
+  	if unacceptable_chars.length > 0
+			log(level: :warn, msg: "name #{name} contains unacceptable_chars [#{unacceptable_chars}]")
+			return { status: false, msg: "Value can not contain #{unacceptable_chars}" }
+  	end
+
+    if name.length > RailsBase::Authentication::Constants::MAX_NAME
+      log(level: :warn, msg: "name #{name} contains too many characters. Max allowed is #{RailsBase::Authentication::Constants::MAX_NAME}")
+      return { status: false, msg: "Too many characters. Max allowed is #{RailsBase::Authentication::Constants::MAX_NAME}" }
+    end
+
+    if name.length < RailsBase::Authentication::Constants::MIN_NAME
+      log(level: :warn, msg: "name #{name} contains too few characters. MIN allowed is #{RailsBase::Authentication::Constants::MIN_NAME}")
+      return { status: false, msg: "Too few characters. Max allowed is #{RailsBase::Authentication::Constants::MIN_NAME}" }
+    end
+		{ status: true }
+  end
+
+	def validate_password?(password:, password_confirmation:)
+		if password != password_confirmation
+			log(level: :warn, msg: 'User password inputs do not match. Must retry flow')
+			return { status: false, msg: 'Passwords do not match. Retry password flow' }
+		end
+
+		if password.length < RailsBase::Authentication::Constants::MP_MIN_LENGTH
+			log(level: :warn, msg: RailsBase::Authentication::Constants::MP_REQ_MESSAGE)
+			return { status: false, msg: RailsBase::Authentication::Constants::MP_REQ_MESSAGE }
+		end
+
+		number_count = password.scan(/\d/).join('').length
+		char_count = password.scan(/[a-zA-Z]/).join('').length
+		unacceptable_chars = password.scan(/\W/).join('')
+
+		if char_count < RailsBase::Authentication::Constants::MP_MIN_ALPHA
+			log(level: :warn, msg: "User password does not have enough numbers. Req: #{RailsBase::Authentication::Constants::MP_MIN_ALPHA}. Given: #{char_count}")
+			return { status: false, msg: "Password must contain at least #{RailsBase::Authentication::Constants::MP_MIN_ALPHA} characters [a-z,A-Z]" }
+		end
+
+		if number_count < RailsBase::Authentication::Constants::MP_MIN_NUMS
+			log(level: :warn, msg: "User password does not have enough numbers. Req: #{RailsBase::Authentication::Constants::MP_MIN_NUMS}. Given: #{number_count}")
+			return { status: false, msg: "Password must contain at least #{RailsBase::Authentication::Constants::MP_MIN_NUMS} numbers [0-9]" }
+		end
+
+		if unacceptable_chars.length > 0
+			log(level: :warn, msg: "User password contains unacceptable_chars. Received: #{unacceptable_chars}")
+			return { status: false, msg: "Unaccepted characters received. Characters must be in [0-9a-zA-Z] exclusively. Received #{unacceptable_chars}" }
+		end
+
+		{ status: true }
+	end
+end

data/app/helpers/rails_base/user_settings_helper.rb

@@ -0,0 +1,22 @@
+module RailsBase::UserSettingsHelper
+  CONFIRM_PASSWORD_FLOW = {
+    password_flow: 'rails_base/user_settings/modify_password_update_password',
+    destroy_user: 'rails_base/user_settings/confirm_destroy_user'
+  }
+
+  DATUM_LENGTH = 36
+  DATUM_TTL = 30.seconds
+  DATUM_REASON = :confirm_password
+
+
+  def datum
+    params = {
+      user: current_user,
+      max_use: 1,
+      reason: DATUM_REASON,
+      ttl: DATUM_TTL,
+      length: DATUM_LENGTH,
+    }
+    ShortLivedData.create_data_key(params)
+  end
+end

data/app/jobs/rails_base/application_job.rb

@@ -0,0 +1,10 @@
+module RailsBase
+  class ApplicationJob < ActiveJob::Base
+
+    # Automatically retry jobs that encountered a deadlock
+    # retry_on ActiveRecord::Deadlocked
+
+    # Most jobs are safe to ignore if the underlying records are no longer available
+    # discard_on ActiveJob::DeserializationError
+  end
+end

data/app/jobs/twilio_job.rb

@@ -0,0 +1,9 @@
+require 'twilio_helper'
+
+class TwilioJob < RailsBase::ApplicationJob
+  queue_as RailsBase.config.mfa.active_job_queue
+
+  def perform(message:, to:)
+    TwilioHelper.send_sms(message: message, to: to)
+  end
+end

data/app/mailers/rails_base/application_mailer.rb

@@ -0,0 +1,9 @@
+class RailsBase::ApplicationMailer < ActionMailer::Base
+  default from: 'from@example.com'
+  layout 'mailer'
+
+  CONTACT_URL = [
+      RailsBase.config.app.base_url,
+      RailsBase.config.app.base_port,
+    ].compact.join(':')
+end

data/app/mailers/rails_base/email_verification_mailer.rb

@@ -0,0 +1,22 @@
+class RailsBase::EmailVerificationMailer < RailsBase::ApplicationMailer
+	default from: Rails.configuration.mail_from
+
+	def email_verification(user:, url:)
+	  @user = user
+	  @sso_url_for_user = url
+	  mail(to: @user.email, subject: "Welcome to #{Rails.application.class.parent_name}")
+	end
+
+	def forgot_password(user:, url:)
+	  @user = user
+	  @sso_url_for_user = url
+	  mail(to: @user.email, subject: "#{Rails.application.class.parent_name}: Forgot Password")
+	end
+
+	def event(user:, event:, msg: nil)
+	  @user = user
+	  @event = event
+	  @msg = msg
+	  mail(to: @user.email, subject: "#{Rails.application.class.parent_name}: #{event}")
+	end
+end

data/app/mailers/rails_base/event_mailer.rb

@@ -0,0 +1,16 @@
+class RailsBase::EventMailer < RailsBase::ApplicationMailer
+  default from: Rails.configuration.mail_from
+
+  def send_sso(user:, message:)
+    @user = user
+    @message = message
+    mail(to: user.email, subject: "#{Rails.application.class.parent_name}: SSO login", template_name: 'event')
+    # event(user: user, event: 'SSO login', message: message)
+  end
+
+  def event(user:, event:, message:)
+    @user = user
+    @message = message
+    mail(to: @user.email, subject: "#{Rails.application.class.parent_name}: #{event}", template_name: 'event')
+  end
+end

data/app/models/admin_action.rb

@@ -0,0 +1,119 @@
+# == Schema Information
+#
+# Table name: admin_actions
+#
+#  id            :bigint           not null, primary key
+#  admin_user_id :bigint           not null
+#  user_id       :bigint
+#  action        :string(255)      not null
+#  change_from   :string(255)
+#  change_to     :string(255)
+#  long_action   :text(65535)
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#
+class AdminAction < RailsBase::ApplicationRecord
+  DEFAULT_PAGE_COUNT = 5
+  DEFAULT_PAGE_COUNT_SELECT_RANGE = (0..50).select { |x| x%5 == 0 && x != 0 }
+  DEFAULT_PAGE_RANGE = 2
+
+
+  class << self
+    include ActionView::Helpers::DateHelper
+    def action(admin_user:, action:, user: nil, original_attribute: nil, new_attribute: nil, long_action: nil)
+      params = { admin_user_id: admin_user.id, action: action }
+      params[:user_id] = user.id if user
+      params[:change_from] = original_attribute.to_s unless original_attribute.nil?
+      params[:change_to] = new_attribute.to_s unless new_attribute.nil?
+      params[:long_action] = long_action unless long_action.nil?
+      begin
+        instance = AdminAction.create!(params)
+        ship_to_cache!(instance: instance, user: user, created_at: Time.zone.now) if user
+        instance
+      rescue StandardError => e
+        Rails.logger.error(e.message)
+        Rails.logger.error("Unable to save admin action [#{action}]: [#{params}]")
+        nil
+      end
+    end
+
+    def repopulate_cache!(max_items: 1000)
+      objects = order(created_at: :desc).where.not(user_id: nil).limit(max_items)
+      count = 0
+      objects.in_batches(of: 500) do |group|
+        group.each do |instance|
+          count += 1
+          user = instance.user
+          msg = instance.readable(with_occurred: false)
+          RailsBase::Admin::ActionCache.instance.add_action(user: user, msg: msg, occured: instance.created_at)
+        end
+      end
+      count
+    end
+
+    def get_cache_items(user:, time: Time.zone.now, use_lv: false, alltime: false, delete: false, update_lv: false)
+      if use_lv
+        Rails.logger.warn { "Using Last Viewed admin actions for user #{user.id}" }
+        temp = RailsBase::Admin::ActionCache.instance.get_last_viewed(user: user)
+        time = temp.nil? ? time : (Time.at(temp) rescue time)
+      end
+
+      objects = RailsBase::Admin::ActionCache.instance.actions_since(user: user, time: time, alltime: alltime)
+
+      admin_messages = objects.map do |object|
+        msg = object[0]
+        in_words = distance_of_time_in_words(Time.zone.now, object[1], include_seconds: true)
+        [msg, "~ #{in_words.humanize} ago"]
+      end
+
+      if delete
+        Rails.logger.warn { "Deleting admin actions for user #{user.id}" }
+        RailsBase::Admin::ActionCache.instance.delete_actions_since!(user: user, time: time)
+      end
+
+      if update_lv
+        Rails.logger.warn { "Udating Last Viewed admin actions for user #{user.id}" }
+        RailsBase::Admin::ActionCache.instance.update_last_viewed(user: user, time: time)
+      end
+
+      admin_messages
+    end
+
+    def ship_to_cache!(instance:, user:, created_at: nil)
+      msg = instance.readable(with_occurred: false)
+      RailsBase::Admin::ActionCache.instance.add_action(user: user, msg: msg, occured: instance.created_at)
+    end
+
+    def paginate_records(page:, user_id: nil, admin_id: nil, count_on_page: DEFAULT_PAGE_COUNT, count: false)
+      params = {}
+      params[:user_id] = user_id if user_id && user_id.positive?
+      params[:admin_user_id] = admin_id if admin_id && admin_id.positive?
+      offset = (page - 1) * count_on_page
+      if count
+        where(params).count
+      else
+        where(params).order(created_at: :desc).offset(offset).limit(count_on_page)
+      end
+    end
+  end
+
+  def admin_user
+    @admin_user ||= User.find admin_user_id
+  end
+
+  def user
+    @user ||= user_id ? User.find(user_id) : nil
+  end
+
+  def readable(long: false, with_occurred: true)
+    msg = "[#{admin_user.full_name}(#{admin_user_id})]: #{ long ? long_action : action}."
+    msg += " Changed from [#{change_from}]." unless change_from.nil?
+    msg += " Changed to [#{change_to}]." unless change_to.nil?
+    msg += " Occured at #{created_at}." if with_occurred
+    msg
+  end
+
+  private
+
+end
+

data/app/models/rails_base/application_record.rb

@@ -0,0 +1,22 @@
+module RailsBase
+  class ApplicationRecord < ::ApplicationRecord
+    self.abstract_class = true
+
+    def self._magically_defined_time_objects
+      columns.each do |column|
+        next unless [:datetime].include?(column.type)
+
+        # This is actually pretty cool. If you set the thrad corectly, you can
+        define_method("#{column.name}") do
+          thread_tz = Thread.current[RailsBase::ApplicationController::TIMEZONE_THREAD_NAME]
+          return super() if thread_tz.nil?
+          time = self[column.name].in_time_zone(thread_tz) rescue self[column.name]
+
+          Rails.logger.debug { "#{self.class.name}.#{column.name} intercepted :datetime [#{self[column.name]}] and returned [#{time}] - tz[#{thread_tz}]" }
+
+          time
+        end
+      end
+    end
+  end
+end