rails_base 0.51.0

data/lib/link_decision_helper.rb

@@ -0,0 +1,71 @@
+class LinkDecisionHelper
+  ALLOWED_TYPES = [
+    NAVBAR_LOGGED_IN = :n_logged_in,
+    NAVBAR_LOGGED_OUT = :n_logged_out
+  ]
+
+  DEFAULT_TITLE = 'Default Title'
+  DEFAULT_URL = '/' # root
+
+  class NotOnAllowListError < StandardError; end;
+
+  def self.clear_type!(type:)
+    raise "Unexpected type [#{type}]. Expected #{ALLOWED_TYPES}" unless ALLOWED_TYPES.include?(type)
+    Rails.application.config.public_send("#{type}=", [])
+  end
+
+  def initialize(title:, url:, type:, display: true, default_type: nil, config: nil, _blank: false)
+    raise NotOnAllowListError, "Unexpected type [#{type}]. Expected #{ALLOWED_TYPES}" unless ALLOWED_TYPES.include?(type)
+
+    @config = config
+    @type = type
+    @url = url
+    @title = title
+    @display = display
+    @_blank = _blank
+
+    if default_type && ALLOWED_TYPES.include?(default_type)
+      assign_default!
+    elsif default_type && !ALLOWED_TYPES.include?(default_type)
+      raise NotOnAllowListError, 'unexpected default value'
+    end
+  end
+
+  def assign!(index: -1)
+    config.public_send(@type).insert(index, self)
+  end
+
+  def url
+    get_value(@url)
+  end
+
+  def title
+    get_value(@title)
+  end
+
+  def blank?
+    @_blank
+  end
+
+  def display?(current_user)
+    get_value(@display, current_user)
+  end
+
+  private
+
+  def get_value(thing, *args)
+    thing.is_a?(Proc) ? thing.call(*args) : thing
+  end
+
+  def assign_default!
+    case @type
+    when NAVBAR_LOGGED_IN
+      @url = DEFAULT_URL
+      @title = DEFAULT_TITLE
+    end
+  end
+
+  def config
+    @config ||= Rails.application.config
+  end
+end

data/lib/rails_base.rb

@@ -0,0 +1,50 @@
+require "rails_base/engine"
+
+# explicitly require gems that provide assets
+# when engine loads, this adds assets to Main apps ssets pipeline
+# (Only a problem for lazy loaded non prod ENVs)
+require 'jquery_mask_rails'
+require 'allow_numeric'
+require 'jquery-rails'
+require 'coffee-rails'
+require 'turbolinks'
+require 'popper_js'
+require 'bootstrap'
+require 'sassc-rails'
+require 'switch_user'
+
+require 'rails_base/admin/action_cache'
+require 'rails_base/config'
+
+module RailsBase
+  def self.url_routes
+    Rails.application.routes.url_helpers
+  end
+
+  def self.route_exist?(path)
+    Rails.application.routes.recognize_path(path)
+    true
+  rescue StandardError, ActionController::RoutingError
+    false
+  end
+
+  def self.configure(&block)
+    yield(config) if block_given?
+
+    config.validate_configs!
+  end
+
+  def self.config
+    @config ||= RailsBase::Config.new
+  end
+
+  def self.appearance
+    @appearance ||= config.appearance
+  end
+
+  def self.reset_config!
+    config.reset_config!
+  end
+
+  AdminStruct = Struct.new(:original_attribute, :new_attribute, :user)
+end

data/lib/rails_base/admin/action_cache.rb

@@ -0,0 +1,99 @@
+require 'redis'
+require 'redis-namespace'
+require 'json'
+
+module RailsBase::Admin
+  class ActionCache
+    include Singleton
+
+    KEY_BASE = 'aac_user'
+    LAST_VIEWED_BASE = 'lv'
+    LV_TTL = 150.days
+    TTL_FOR_CACHE = 60.days
+    VALID_TIME_OBJECT = [Time, DateTime, ActiveSupport::TimeWithZone]
+
+    attr_reader :redis
+
+    def initialize
+      url = RailsBase.config.redis.admin_action
+      namespace = RailsBase.config.redis.admin_action_namespace
+      client = Redis.new(url: url)
+      @redis = Redis::Namespace.new(namespace, redis_url: client)
+      @logger = Rails.logger
+    end
+
+    def add_action(user:, msg:, occured:)
+      validate!(user, msg, occured)
+
+      score = occured.to_f
+      @logger.info { "Adding Redis Cache Admin actions for #{key(user)}" }
+
+      redis.zadd(key(user), score, msg)
+      redis.expire(key(user), TTL_FOR_CACHE.to_i)
+    end
+
+    def actions_since(user:, alltime: false, time: nil)
+      score =
+        if alltime
+          0
+        else
+          valid_time!(time)
+          score = time.to_f
+        end
+
+      validate_user!(user)
+      max_score = Time.now.to_f
+      @logger.info { "Retrieving Redis Cache Admin actions for #{key(user)} since #{time}" }
+
+      redis.zrangebyscore(key(user), score, max_score, with_scores: true)
+    end
+
+    def delete_actions_since!(user:, time:)
+      valid_time!(time)
+      validate_user!(user)
+
+      score = time.to_f
+      redis.zremrangebyscore(key(user), 0, score)
+      @logger.info { "Deleted Redis Cache Admin actions for #{key(user)}" }
+      true
+    end
+
+    def update_last_viewed(user:, time: Time.zone.now)
+      valid_time!(time)
+      validate_user!(user)
+
+      redis.set(key_last_viewed(user), time.to_f, ex: LV_TTL)
+    end
+
+    def get_last_viewed(user:)
+      validate_user!(user)
+
+      redis.get(key_last_viewed(user))
+    end
+
+    private
+
+    def validate!(user, msg, occured)
+      raise ArgumentError, 'Expected msg to be a string' unless msg.is_a?(String)
+
+      validate_user!(user)
+      valid_time!(occured)
+    end
+
+    def validate_user!(user)
+      raise ArgumentError, 'Expected user to respond to `id`' unless user.respond_to?('id')
+    end
+
+    def valid_time!(time)
+      raise ArgumentError, "Expected occured to be a #{VALID_TIME_OBJECT.join(' or ')}" unless VALID_TIME_OBJECT.include?(time.class)
+    end
+
+    def key_last_viewed(user)
+      "#{key(user)}:#{LAST_VIEWED_BASE}"
+    end
+
+    def key(user)
+      "#{KEY_BASE}:#{user.id}"
+    end
+  end
+end

data/lib/rails_base/admin/action_helper.rb

@@ -0,0 +1,134 @@
+module RailsBase::Admin
+  class ActionHelper
+    ACTIONS_KEY = "___all_actions_#{(rand*10**10).to_i}___"
+    CONTROLLER_ACTIONS_KEY = "___all_controller_actions__#{(rand*10**10).to_i}___"
+    DEFAULT_ALLOWED_KLASSES = [ApplicationController, RailsBase::ApplicationController, ::SwitchUserController]
+    class << self
+      def allowed_inherited_klasses
+        DEFAULT_ALLOWED_KLASSES + (@allowed_klasses || [])
+      end
+
+      def add_inherited_klasses(klass)
+        @allowed_klasses ||= []
+        @allowed_klasses << klass
+      end
+
+      def clear_inherited_klasses!
+        @allowed_klasses = nil
+      end
+
+      def add(instance)
+        @actions ||= {}
+        @all_actions ||= []
+        @default_actions ||= []
+
+        @all_actions << [instance]
+        @default_actions << [instance]
+
+        controller = instance.controller
+        action = instance.action
+        if controller.nil?
+          @actions[ACTIONS_KEY] ||= []
+          @actions[ACTIONS_KEY] << instance
+          return
+        end
+
+        @actions[controller.to_s] ||= {}
+
+        if action
+           @actions[controller.to_s][action.to_s] ||= []
+           @actions[controller.to_s][action.to_s] <<  instance
+        else
+          @actions[controller.to_s][CONTROLLER_ACTIONS_KEY] ||= []
+          @actions[controller.to_s][CONTROLLER_ACTIONS_KEY] << instance
+        end
+      end
+
+      def actions
+        @actions
+      end
+
+      def reset!
+        @actions = nil
+        @all_actions = nil
+        @default_actions.each { |instance| add(instance) }
+      end
+    end
+
+    class InvalidControllerError < StandardError; end;
+    class InvalidActionError < StandardError; end;
+    class InvalidTitleError < StandardError; end;
+
+    attr_accessor :controller, :action, :proc, :title, :default
+    # controller is the controller class inherited by RailsBase::ApplicationController
+    # action is the method name on the controller
+    # title should be the AdminAction.action
+    # if proc available,
+    # => |session, admin_user, user, title, struct|
+    # => RailsBase::AdminStruct has methods original_attribute and new_attribute
+    # => Expected return
+    # => { admin_user, user, action, original_attribute, new_attribute, change_to }
+    def initialize(controller: nil, action: nil, title: nil, default: false, proc: nil)
+      @controller = controller
+      @action = action
+      @title = title
+      @proc = proc
+      valid_controller!
+      valid_action!
+      valid_title!
+    end
+
+    def add!
+      self.class.add(self)
+    end
+
+    def call(req:, params:, admin_user:, user:, struct: nil)
+      # byebug
+      if proc
+        action_params = proc.call(req, params, admin_user, user, title, struct)
+        return if action_params.nil?
+
+        AdminAction.action(action_params)
+      else
+        default_call(request: request, admin_user: admin_user, user: user, struct: struct)
+      end
+    rescue StandardError => e
+      Rails.logger.error(e.message)
+      Rails.logger.error(e.backtrace)
+      Rails.logger.error("Trapping Error from AdminActionHelper.")
+    end
+
+    private
+
+    def default_call(session:, admin_user:, user:, struct: nil)
+      action_params = {
+        admin_user: admin_user,
+        user: user,
+        action: title,
+        change_from: struct&.original_attribute,
+        change_to: struct&.new_attribute,
+      }
+      AdminAction.action(action_params)
+    end
+
+    def valid_controller!
+      return if self.class.allowed_inherited_klasses.include?(controller.superclass)
+
+      raise InvalidControllerError, "@controller does not inherit #{self.class.allowed_inherited_klasses}"
+    end
+
+    def valid_action!
+      return if action.nil?
+      return if controller.instance_methods.map(&:to_s).include?(action.to_s)
+
+      puts controller.instance_methods
+      raise InvalidActionError, "#{controller} does not respond to #{action}"
+    end
+
+    def valid_title!
+      return unless title.nil? && proc.nil?
+
+      raise InvalidTitleError, "Missing title and proc. 1 or the other needs to be present"
+    end
+  end
+end

data/lib/rails_base/admin/default_index_tile.rb

@@ -0,0 +1,176 @@
+require 'rails_base/admin/index_tile'
+
+# ID Tile
+params = {
+  type: :plain,
+  value: ->(user) { user.id },
+  insert: 0, # optional value default is to push it to the end of the array ORDER MATTERS
+  name: 'user_id', # name to be amended to html id
+  col_name: 'User Id', # Expected to be the column header name
+}
+
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)
+
+# Name Tile
+params = {
+  type: :text,
+  value: ->(user) { user.full_name },
+  insert: 1, # optional value default is to push it to the end of the array ORDER MATTERS
+  name: 'full_name', # name to be amended to html id
+  col_name: 'Full Name', # Expected to be the column header name
+  partial: 'rails_base/shared/admin_modify_name',
+  min_width: 220,
+  disabled: -> (user, admin_user) { !RailsBase.config.admin.name_tile_users.call(admin_user) },
+  disabled_msg: -> (user, admin_user) { 'Your admin user does not have permissions' }
+}
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)
+
+# Active Tile
+params = {
+  type: :toggle,
+  value: ->(user) { user.active },
+  on: 'Active',
+  off: 'Inactive',
+  name: 'active', # name to be amended to html id
+  col_name: 'Active User', # Expected to be the column header name
+  disabled: -> (user, admin_user) { user == admin_user || !RailsBase.config.admin.email_tile_users.call(admin_user) },
+  disabled_msg: -> (user, admin_user) { 'Your admin user does not have permissions' }
+}
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)
+
+# Email Tile
+params = {
+  type: :risky,
+  value: ->(user) { user.email },
+  insert: 2, # optional value default is to push it to the end of the array ORDER MATTERS
+  name: :email, # name to be amended to html id
+  col_name: 'Email', # Expected to be the column header name
+  min_width: 220,
+  disabled: -> (user, admin_user) { !RailsBase.config.admin.email_validate_tile_users.call(admin_user) },
+  disabled_msg: -> (user, admin_user) { 'Your admin user does not have permissions' }
+}
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)
+
+# Email Validated Tile
+params = {
+  type: :toggle,
+  value: ->(user) { user.email_validated },
+  on: 'Valid',
+  off: 'Invalid',
+  name: 'email_validated', # name to be amended to html id
+  col_name: 'Email Validated?', # Expected to be the column header name
+  disabled: -> (user, admin_user) { !RailsBase.config.admin.email_tile_users.call(admin_user) },
+  disabled_msg: -> (user, admin_user) { 'Your admin user does not have permissions' }
+}
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)
+
+# phone_number Tile
+params = {
+  type: :risky,
+  value: ->(user) { user.phone_number },
+  name: :phone_number, # name to be amended to html id
+  col_name: 'Phone Number', # Expected to be the column header name
+  min_width: 180,
+  disabled: -> (user, admin_user) { !RailsBase.config.admin.phone_tile_users.call(admin_user) },
+  disabled_msg: -> (user, admin_user) { 'Your admin user does not have permissions' }
+
+}
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)
+
+# Mfa Enabled Validated Tile
+params = {
+  type: :toggle,
+  value: ->(user) { user.mfa_enabled },
+  on: 'Enabled',
+  off: 'Disabled',
+  name: 'mfa_enabled', # name to be amended to html id
+  col_name: 'MFA Enabled?', # Expected to be the column header name
+  disabled: -> (user, admin_user) { !RailsBase.config.admin.mfa_tile_users.call(admin_user) },
+  disabled_msg: -> (user, admin_user) { 'Your admin user does not have permissions' },
+  min_width: 220,
+}
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)
+
+
+# Admin Type Tile
+params = {
+  type: :selector,
+  value: ->(user) { user.admin },
+  name: 'admin', # name to be amended to html id
+  col_name: 'Admin Type', # Expected to be the column header name
+  selector: -> (user) { RailsBase.config.admin.admin_types },
+  disabled: -> (user, admin_user) { user == admin_user || !RailsBase.config.admin.admin_type_tile_users.call(admin_user) },
+  disabled_msg: -> (user, admin_user) { 'Unable to complete action.' }
+}
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)
+
+
+selector_array = Proc.new do |user|
+  base = [RailsBase.config.user.class::USER_DEFINED_KEY, RailsBase.config.user.class::USER_DEFINED_ZONE[RailsBase.config.user.class::USER_DEFINED_KEY].call(user)]
+  RailsBase.config.user.class::ACTIVE_SUPPORT_MAPPING.each do |k,v|
+    base << [k, v.call]
+  end
+  base
+end
+
+# Users Timezone
+params = {
+  type: :selector,
+  value: ->(user) { user.last_known_timezone || RailsBase.config.user.user_timezone(user) },
+  name: 'last_known_timezone', # name to be amended to html id
+  col_name: 'Timezone', # Expected to be the column header name
+  selector: -> (user) { selector_array.call(user) },
+  disabled: -> (user, admin_user) { RailsBase.config.user.tz_user_defined? || !RailsBase.config.admin.modify_timezone_tile_users.call(admin_user) },
+  disabled_msg: -> (user, admin_user) { RailsBase.config.user.tz_user_defined? ? 'User Defined TZ is enabled in config. Cant change TZ.' : 'Unable to perform action' }
+}
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)
+
+# Last logged in
+params = {
+  type: :plain,
+  value: ->(user) { user.last_sign_in_at&.to_formatted_s(:rfc822) || 'Never' },
+  name: 'logged_in_last', # name to be amended to html id
+  col_name: 'Last Logged In', # Expected to be the column header name
+}
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)
+
+
+# Impersonation Tile
+params = {
+  type: :button,
+  value: ->(_user) { },
+  name: 'impersonate', # name to be amended to html id
+  col_name: 'Impersonate', # Expected to be the column header name
+  method: :post,
+  color: 'warning',
+  disabled: ->(user, admin_user) { !RailsBase.config.admin.impersonate_tile_users.call(admin_user) },
+  disabled_msg: ->(user, admin_user) { 'Your Admin User is not permitted to impersonate Users' },
+  url: ->(user) { RailsBase.url_routes.switch_user_path(scope_identifier: "user_#{user.id}") }
+}
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)
+
+# SSO send Tile
+params = {
+  type: :button,
+  value: ->(_user) { },
+  name: 'sso_send', # name to be amended to html id
+  col_name: 'Send SSO', # Expected to be the column header name
+  method: :post,
+  color: 'warning',
+  disabled: ->(user, admin_user) { !RailsBase.config.admin.sso_tile_users.call(admin_user) },
+  disabled_msg: ->(user, admin_user) { 'Your Admin User is not permitted to send SSO' },
+  url: ->(user) { RailsBase.url_routes.admin_sso_send_path(id: user.id) }
+}
+instance = RailsBase::Admin::IndexTile.new(**params)
+RailsBase::Admin::IndexTile.add(instance)