barkest_core 1.5.3.0

data/app/controllers/system_update_controller.rb

@@ -0,0 +1,164 @@
+require 'net/ssh'
+require 'barkest_ssh'
+require 'rubygems'
+
+##
+# An automatic update controller.
+#
+# This is performed via an SSH shell to the host to login as the configured user and then
+# performing the various steps necessary to update the app from GIT, update the database, and precompile
+# the assets.  When that is all finished, it notifies Passenger to reload the application.
+#
+# The status is tracked using the SystemStatusController.
+#
+class SystemUpdateController < ApplicationController
+
+  before_action :require_admin
+
+  ##
+  # Perform a system update.
+  #
+  def new
+    cfg = BarkestCore::SelfUpdateConfig.load
+
+    if cfg.valid? || Rails.env.test?
+
+      @file_path = Rails.root.to_s
+      @app_root_url = root_path
+
+      show_system_status(
+          main_status: 'Updating application',
+          url_on_completion: system_update_url
+      ) do |status|
+        if status
+          unless Rails.env.test?
+            begin
+              File.open(BarkestCore::WorkPath.system_status_file, 'wt') do |f|
+                @status_log = f
+
+                log_header 'Creating session'
+
+                begin
+                  BarkestSsh::SecureShell.new(
+                      host: cfg.host,
+                      user: cfg.user,
+                      password: cfg.password,
+                      port: cfg.port
+                  ) do |shell|
+
+                    log_data "Session has been created.\n"
+
+                    tmp_data = shell.exec('which ruby')
+                    log_data "[WARNING: Global ruby]\n" if tmp_data == '/usr/bin/ruby' || tmp_data == '/usr/local/bin/ruby'
+                    log_data "Ruby Path: #{tmp_data}\n"
+
+                    tmp_data = shell.exec('ruby -v')
+                    tmp_v = /^ruby ([0-9]+\.[0-9]+)\..*$/.match(tmp_data)[1].to_s.to_f
+                    log_data "[WARNING: Ruby less than 2.2.0]\n" if tmp_v < 2.2
+                    log_data "Ruby Version: #{tmp_data}\n"
+
+                    shell.exec "cd \"#{@file_path}\""
+
+                    if Rails.env.production?
+
+                      rtlog = Proc.new do |data, _|
+                        log_data data
+                        nil
+                      end
+
+                      send(:before_update, shell) if respond_to?(:before_update)
+                      log_header 'Resetting app files'
+                      shell.exec('git reset --hard origin/master',              &rtlog)
+                      shell.exec('git clean -fd',                               &rtlog)
+
+                      send(:before_file_update, shell) if respond_to?(:before_file_update)
+                      log_header 'Updating app files'
+                      shell.exec('git pull origin master',                      &rtlog)
+                      # Ensure bin files are executable.
+                      # Files stored by git from WSL don't seem to always get the exec bit stored.
+                      shell.exec('chmod +x bin/*',                              &rtlog)
+
+                      send(:before_bundle, shell) if respond_to?(:before_bundle)
+                      log_header 'Bundling gems'
+                      shell.exec('bundle install --deployment',                 &rtlog)
+
+                      send(:before_db_update, shell) if respond_to?(:before_db_update)
+                      log_header 'Updating database'
+                      %w(db:create db:migrate).each do |cmd|
+                        cmd = "bundle exec rake #{cmd} RAILS_ENV=production"
+                        shell.exec(cmd,                                         &rtlog)
+                      end
+
+                      send(:before_db_seed, shell) if respond_to?(:before_db_seed)
+                      log_header 'Seeding database'
+                      cmd = 'db:seed'
+                      cmd = "bundle exec rake #{cmd} RAILS_ENV=production"
+                      shell.exec(cmd,                                           &rtlog)
+                      send(:after_db_seed, shell) if respond_to?(:after_db_seed)
+
+                      log_header 'Generating assets'
+                      cmd = "bundle exec rake assets:precompile RAILS_ENV=production RAILS_GROUPS=assets RAILS_RELATIVE_URL_ROOT=\"#{@app_root_url}\""
+                      shell.exec(cmd,                                           &rtlog)
+                      send(:after_asset_gen, shell) if respond_to?(:after_asset_gen)
+
+                      log_header 'Running automatic configuration'
+                      cmd = "bundle exec rails generate barkest:install --force"
+                      shell.exec(cmd,                                           &rtlog)
+                      send(:after_config, shell) if respond_to?(:after_config)
+
+                      log_header 'Restarting app'
+                      cmd = "bundle exec passenger-config restart-app \"#{@file_path}\""
+                      shell.exec(cmd,                                           &rtlog)
+                      send(:after_update, shell) if respond_to?(:after_update)
+
+                    else
+                      log_data "Skipping actual update for non-production.\n"
+                    end
+                  end
+
+                  log_data "\nUpdate process is complete.\n"
+                rescue Net::SSH::AuthenticationFailed => _
+                  log_data "Failed to login to the session.\nPlease verify the update credentials in your configuration.\nUpdate is aborting.\n"
+                rescue StandardError => error
+                  log_data "An unexpected error occurred.\n#{error}\nUpdate is aborting.\nManual application update may be required to restore functionality.\n"
+                rescue => error
+                  log_data "A really unexpected error has occurred.\n#{error}\nUpdate is aborting.\nManual application update may be required to restore functionality.\n"
+                end
+              end
+            ensure
+              @status_log = nil
+            end
+          end
+        end
+      end
+    else
+      flash[:danger] = 'The "Self Update Settings" need to be configured before a system update can be performed.'
+      redirect_to system_config_self_update_url
+    end
+
+  end
+
+  ##
+  # Shows current information about the app.
+  #
+  def index
+    app_gem_name = Rails.application.class.parent_name.underscore
+    @additional = BarkestCore.gem_list(app_gem_name, true)
+  end
+
+  private
+
+  def require_admin
+    authorize! true
+  end
+
+  def log_header(label)
+    @status_log.write "\n" + ('=' * 20) + label.center(24) + ('=' * 20) + "\n"
+    @status_log.flush
+  end
+
+  def log_data(data)
+    @status_log.write data
+    @status_log.flush
+  end
+end

data/app/controllers/test_access_controller.rb

@@ -0,0 +1,44 @@
+##
+# A controller used specifically to test authentication and authorization.
+class TestAccessController < ApplicationController
+
+  before_action :valid_user
+
+  ##
+  # Tests an action that doesn't require a user to be logged in.
+  def allow_anon
+  end
+
+  ##
+  # Tests an action that requires a user to be logged in.
+  def require_user
+  end
+
+  ##
+  # Tests an action that requires a user that is an administrator to be logged in.
+  def require_admin
+  end
+
+  ##
+  # Tests an action that requires a user that is a member of one of the groups to be logged in.
+  #
+  # The valid groups are 'group 1', 'group 2', and 'group 3'.
+  def require_group_x
+  end
+
+  private
+
+  def valid_user
+    case action_name.to_sym
+      when :require_user
+        authorize!
+      when :require_admin
+        authorize! true
+      when :require_group_x
+        authorize! 'group 1', 'group 2', 'group 3'
+      else
+        true
+    end
+  end
+
+end

data/app/controllers/test_report_controller.rb

@@ -0,0 +1,75 @@
+class TestReportController < ApplicationController
+
+  class SampleObject
+    include ActiveModel::Model
+
+    attr_accessor :code, :name, :email, :date_of_birth, :hire_date, :pay_rate, :hours
+  end
+
+  private_constant :SampleObject
+
+  before_action :require_admin
+  before_action :load_sample_data
+
+  def index
+
+  end
+
+  # Test result: "Code,Name,Email,Date of Birth,Hire Date,Pay Rate,Hours\nSMIJOH,John Smith,j.smith@example.com,1980-01-01 00:00:00 UTC,2010-05-01 00:00:00 UTC,15.5,2260\n"
+  def csv
+    render formats: [ :csv ]
+  end
+
+  def xlsx
+    render formats: [ :xlsx ]
+  end
+
+  def pdf
+    render formats: [ :pdf ]
+  end
+
+  private
+
+  def require_admin
+    authorize! true
+  end
+
+  def load_sample_data
+    @data = []
+
+    if Rails.env.development? && params[:one].blank?
+      while @data.length < 100
+        fn = Faker::Name.first_name
+        ln = Faker::Name.last_name
+        code = ln[0...3] + fn[0...3]
+        bd = Faker::Date.between(65.years.ago, 19.years.ago).to_time
+        hd = Faker::Date.between(bd + 18.years, 6.months.ago).to_time
+        pr = (Random.rand(5600) + 900).to_f / 100
+        hr = (Random.rand(2000) + 1000)
+
+        @data << SampleObject.new(
+            code: code.upcase,
+            name: "#{fn} #{ln}",
+            email: "#{code.downcase}@example.com",
+            date_of_birth: bd,
+            hire_date: hd,
+            pay_rate: pr,
+            hours: hr
+        )
+      end
+    else
+      @data << SampleObject.new(
+          code: 'SMIJOH',
+          name: 'John Smith',
+          email: 'j.smith@example.com',
+          date_of_birth: Time.utc(1980, 1, 1),
+          hire_date: Time.utc(2010, 5, 1),
+          pay_rate: 15.50,
+          hours: 2260
+      )
+    end
+
+    @data.sort!{|a,b| a.code <=> b.code}
+  end
+
+end

data/app/controllers/users_controller.rb

@@ -0,0 +1,218 @@
+##
+# This is a user management controller.
+#
+# This includes all the actions necessary to create, list, edit, disable, and destroy users.
+#
+class UsersController < ApplicationController
+
+  before_action :not_logged_in,   only: [ :new, :create ]
+  before_action :logged_in_user,  except: [:new, :create]
+  before_action :load_user,       except: [:index, :new, :create]
+  before_action :correct_user,    only: [:edit, :update]
+  before_action :admin_user,      only: [:destroy, :disable, :disable_confirm, :enable]
+  before_action :not_current,     only: [:destroy, :disable, :disable_confirm, :enable]
+  before_action :not_anon,        only: [:edit, :update, :destroy, :disable, :disable_confirm, :enable]
+  before_action :not_ldap,        only: [:edit, :update]
+  before_action :index_filter,    only: [:index]
+  before_action :show_filter,     only: [:show]
+
+  ##
+  # Shows a list of all users.
+  #
+  # Admin users are shown all users including disabled and inactive.
+  # Other users only see the enabled users.
+  #
+  def index
+    @users = (current_user.system_admin? ? User.known.sorted : User.known.enabled.sorted).paginate(page: params[:page])
+  end
+
+  ##
+  # Shows a specific user profile.
+  #
+  def show
+
+  end
+
+  ##
+  # Shows the signup form for a new user.
+  #
+  def new
+    @user = User.new
+  end
+
+  ##
+  # Creates a new user account after verifying the user is not a robot.
+  #
+  def create
+    @user = User.new(user_params)
+    if @user.valid? && verify_recaptcha_challenge(@user)
+      if @user.save
+        @user.send_activation_email request.remote_ip
+        flash[:safe_info] = 'Your account has been created, but needs to be activated before you can use it.<br/>Please check your email to activate your account.'
+        redirect_to root_url and return
+      end
+    end
+    render 'new'
+  end
+
+  ##
+  # Shows a form to edit the user profile.
+  #
+  def edit
+
+  end
+
+  ##
+  # Updates a user profile.
+  #
+  def update
+    if @user.update_attributes(user_params)
+      flash[:success] = 'Your profile has been updated.'
+      redirect_to @user
+    else
+      render 'edit'
+    end
+  end
+
+  ##
+  # Destroys a user account that has been disabled for at least 15 days
+  # as long as the requesting user is an admin.
+  #
+  def destroy
+    if @user.enabled?
+      flash[:danger] = 'Cannot delete an enabled user.'
+    elsif @user.disabled_at.blank? || @user.disabled_at > 15.days.ago
+      flash[:danger] = 'Cannot delete a user within 15 days of being disabled.'
+    else
+      @user.destroy
+      flash[:success] = "User #{@user.name} has been deleted."
+    end
+    redirect_to users_path
+  end
+
+  ##
+  # Shows a form requesting a reason to disable a user and allowing
+  # the administrator a chance to cancel the action.
+  #
+  def disable_confirm
+    load_disable_user
+    unless @disable.user.enabled?
+      flash[:warning] = "User #{@disable.user.name} is already disabled."
+      redirect_to users_path
+    end
+  end
+
+  ##
+  # Disables a user account as long as the requesting user is an administrator
+  # and provides a reason the account is being disabled.
+  #
+  def disable
+    load_disable_user
+
+    if @disable.valid?
+      if @disable.user.disable(current_user, @disable.reason)
+        flash[:success] = "User #{@disable.user.name} has been disabled."
+        redirect_to users_path and return
+      else
+        @disable.errors.add(:user, 'was unable to be updated')
+      end
+    end
+
+    render 'disable_confirm'
+  end
+
+  ##
+  # Enables a previosly disabled user as long as the requesting user is an
+  # administrator.
+  #
+  def enable
+    if @user.enabled?
+      flash[:warning] = "User #{@user.name} is already enabled."
+      redirect_to users_path and return
+    end
+
+    if @user.enable
+      flash[:success] = "User #{@user.name} has been enabled."
+    else
+      flash[:danger] = "Failed to enable user #{@user.name}."
+    end
+
+    redirect_to users_path
+  end
+
+  private
+
+  # ensure we have an @user variable to work with.
+  def load_user
+    if system_admin?
+      @user = User.find_by(id: params[:id])
+    else
+      @user = User.where(id: params[:id], enabled: true, activated: true).first
+    end
+    @user ||= User.new(name: 'Invalid User', email: 'invalid-email')
+  end
+
+  def load_disable_user
+    @disable = DisableUser.new(params[:disable_user] ? disable_user_params : {})
+    @disable.user = @user
+  end
+
+  def user_params
+    params.require(:user).permit(:name, :email, :password, :password_confirmation)
+  end
+
+  def disable_user_params
+    params.require(:disable_user).permit(:reason)
+  end
+
+  def not_logged_in
+    if logged_in?
+      flash[:danger] = 'You are already logged in.'
+      redirect_to root_url
+    end
+  end
+
+  def logged_in_user
+    unless logged_in?
+      flash[:danger] = 'Please log in.'
+      store_location_and_redirect_to login_url
+    end
+  end
+
+  def correct_user
+    # the current user can edit their details, so can an admin.
+    redirect_to(root_url) unless current_user?(@user) || system_admin?
+  end
+
+  def admin_user
+    redirect_to(root_url) unless system_admin?
+  end
+
+  def not_anon
+    # anon user cannot be edited.
+    redirect_to(root_url) if @user.anonymous?
+  end
+
+  def not_ldap
+    if @user.ldap?
+      flash[:danger] = 'LDAP accounts cannot be edited.'
+      redirect_to @user
+    end
+  end
+
+  def not_current
+    if current_user?(@user)
+      flash[:warning] = 'You cannot perform this operation on yourself.'
+      redirect_to users_path
+    end
+  end
+
+  def index_filter
+    admin_user if BarkestCore.lock_down_users
+  end
+
+  def show_filter
+    correct_user if BarkestCore.lock_down_users
+  end
+
+end