rails_base 0.51.0

data/lib/rails_base/admin/index_tile.rb

@@ -0,0 +1,186 @@
+require RailsBase::Engine.root.join('app', 'helpers', 'rails_base', 'admin_helper.rb')
+
+module RailsBase::Admin
+  class IndexTile
+    include RailsBase::AdminHelper
+    attr_accessor :type, :name, :value, :col_name, :insert, :on, :off, :disabled, :disabled_msg, :selector, :partial , :link , :min_width , :url, :method , :color
+    MODIFY_TYPES = [
+      RISKY = { type: :risky },
+      TOGGLE = { type: :toggle, expects: { on: 'String', off: 'String' } },
+      SELECTOR = { type: :selector, expects: { selector: 'Proc' } },
+      TEXT = { type: :text, expects: { partial: 'String' } },
+      BUTTON = { type: :button, expects: { url: 'Proc', method: 'Symbol', color: 'String' } },
+      PLAIN = { type: :plain },
+    ]
+
+    VALID_METHODS = [:get, :post, :delete, :patch, :put]
+    # Input params
+      # type: Symbol
+      # => values: MODIFY_TYPES.map{|s| s[:type]}
+      # => what: This is the type of index self will be
+      #
+      # name: Symbol
+      # => values: <Anything>
+      # => what:  Used as the `id` for html. when risky, expected it is a key in RailsBase::AdminController::SECOND_MODAL_MAPPING
+      #
+      # value: Proc
+      # => values: Proc that takes a user as an argument ex: ->(current_user) { user.full_name }
+      # => what: Value returned from proc will be value displayed table grid
+      #
+      # display: Proc
+      # => values: Proc that takes a user as an argument ex: ->(current_user) { user.full_name }
+      # => what: Boolean returned from proc will allow the element to be changeable
+      #
+      # col_name: String
+      # => values: Short String
+      # => what: Value for the Column header
+      #
+      # insert: Integer
+      # => values: Expected to be an integer
+      # => what: Column number in the admin view index table
+      #
+      # on: String
+      # => values: 1 word for a toggle switch
+      # => what: When toggle is on, this is displayed
+      #
+      # off: String
+      # => values: 1 word for a toggle switch
+      # => what: When toggle is off, this is displayed
+      #
+      # partial: String
+      # => values: Path to partial
+      # => what: Partial that will get loaded. At present, only for TEXT type
+      #
+      # url: Proc
+      # => values: Given a user, Proc that dynamically assigns url based on the user
+      # => what: ->(user) { Rails.application.url_routes.root_path }
+      #
+      # min_width: Integer
+      # => values: nil || > 0
+      # => what: Min width for the given table column. When nil passed, none will be set
+      #
+      # method: Symbol
+      # => values: [:get, :post, :delete, :patch, :put]
+      # => what: Min width for the given table column. When nil passed, none will be set. Used for Button
+      #
+      # method: String
+      # => values: [:get, :post, :delete, :patch, :put]
+      # => what: Min width for the given table column. When nil passed, none will be set. Used for Button
+      #
+      # selector: Array
+      # => values: [:get, :post, :delete, :patch, :put]
+      # => what: Min width for the given table column. When nil passed, none will be set. Used for Button
+      #
+      # selected: String
+      # => values: [:get, :post, :delete, :patch, :put]
+      # => what: Min width for the given table column. When nil passed, none will be set. Used for Button
+
+    def self.add(instance)
+      @default ||= []
+      @default.insert(instance.insert, instance)
+    end
+
+    def self.defaults
+      @default
+    end
+
+    def initialize(type:, name:, value:, col_name:, disabled: nil, disabled_msg: nil, insert: nil, on: nil, off: nil, selector: [], partial: nil, url: nil, min_width: nil, method: nil, color: 'warning')
+      @type = type
+      @name = name
+      @value = value
+      @col_name = col_name
+      @insert = insert.is_a?(Integer) ? insert : -1
+      @on = on
+      @off = off
+      @partial = partial
+      @min_width = min_width&.to_i rescue nil
+      @disabled = disabled
+      @disabled_msg = disabled_msg
+      @selector = selector
+      @method = method
+      @url = url
+      @color = color
+
+      validate!
+      validate_expects!
+      validate_risky!
+      validate_method!
+      validate_disabled!
+      validate_disabled_msg!
+    end
+
+    def description
+      "#{type} for #{name}"
+    end
+
+    def is_toggle?
+      type == TOGGLE[:type]
+    end
+
+    def is_selector?
+      type == SELECTOR[:type]
+    end
+
+    def is_risky?
+      type == RISKY[:type]
+    end
+
+    def is_text?
+      type == TEXT[:type]
+    end
+
+    def is_button?
+      type == BUTTON[:type]
+    end
+
+    private
+
+    def validate!
+      types = MODIFY_TYPES.map{|s| s[:type]}
+      raise ArgumentError, "Expected type to be in [#{types}]" unless types.include? type
+      raise ArgumentError, "Expected value to be a proc" unless value.is_a? Proc
+    end
+
+    def validate_disabled!
+      return if disabled.nil?
+      return if disabled.is_a?(Proc)
+
+      raise ArgumentError, 'Expected disabled to be a Proc'
+    end
+
+    def validate_disabled_msg!
+      return if disabled.nil?
+      return unless disabled_msg.nil?
+
+      raise ArgumentError, 'Expected `disabled_msg` to be present'
+    end
+
+    def validate_expects!
+      type_object = MODIFY_TYPES.find { |s| s[:type] == type }
+
+      return if type_object[:expects].nil?
+
+      type_object[:expects].each do |k, v|
+        val = public_send(k)
+        raise ArgumentError, "Expected [#{val}] to be a #{v.constantize}" unless val.is_a? v.constantize
+      end
+    end
+
+    def validate_risky!
+      return unless is_risky?
+      return if SECOND_MODAL_MAPPING.keys.include?(name)
+
+      keys = SECOND_MODAL_MAPPING.keys
+      msg = "Unable to use name #{name}. Expected to be defined in #{keys}" \
+        "RailsBase::AdminController::SECOND_MODAL_MAPPING"
+      raise ArgumentError, msg
+    end
+
+
+    def validate_method!
+      return if method.nil?
+
+      raise ArgumentError, "Unexpected method. Received: #{method}. Expected [#{VALID_METHODS}]" unless VALID_METHODS.include? method
+    end
+  end
+end

data/lib/rails_base/config.rb

@@ -0,0 +1,52 @@
+require 'rails_base/configuration/admin'
+require 'rails_base/configuration/mfa'
+require 'rails_base/configuration/authentication'
+require 'rails_base/configuration/redis'
+require 'rails_base/configuration/owner'
+require 'rails_base/configuration/mailer'
+require 'rails_base/configuration/exceptions_app'
+require 'rails_base/configuration/app'
+require 'rails_base/configuration/appearance'
+require 'rails_base/configuration/user'
+require 'rails_base/configuration/login_behavior'
+require 'rails_base/configuration/active_job'
+
+module RailsBase
+  class Config
+    VARIABLES = {
+      admin: nil,
+      mfa: nil,
+      auth: :authentication,
+      redis: nil,
+      owner: nil,
+      mailer: nil,
+      exceptions_app: nil,
+      app: nil,
+      appearance: nil,
+      user: nil,
+      active_job: nil,
+      login_behavior: nil
+    }
+    attr_reader *VARIABLES.keys
+
+    def initialize
+      VARIABLES.each do |variable, override|
+        klass_name = (override || variable).to_s.camelize
+        klass = "RailsBase::Configuration::#{klass_name}".constantize
+        instance_variable_set(:"@#{variable}", klass.new)
+      end
+    end
+
+    def validate_configs!
+      VARIABLES.keys.each do |var|
+        send(var).validate!
+      end
+    end
+
+    def reset_config!
+      VARIABLES.keys.each do |var|
+        send(var).assign_default_values!
+      end
+    end
+  end
+end

data/lib/rails_base/configuration/active_job.rb

@@ -0,0 +1,38 @@
+module RailsBase
+  module Configuration
+    class ActiveJob < Base
+      ACTIVE_JOB_PROC = Proc.new do |val, instance|
+        if val.is_a?(Symbol)
+          begin
+            ::ActiveJob::QueueAdapters.lookup(val)
+            Rails.configuration.active_job.queue_adapter = val.to_sym
+          rescue StandardError => e
+            raise ArgumentError, "config.app.active_job_adapter=#{val} is not a defined active job"
+          end
+        end
+      end
+
+      DEFAULT_VALUES = {
+        enable_ui: {
+          type: :boolean,
+          default: true,
+          description: 'All ActiveJob UI. To be used downstream'
+        },
+        view_ui: {
+          type: :proc,
+          default: ->(user) { user.at_least_owner? },
+          dependents: [ -> (i) { i.enable_ui? }],
+          description: 'All users to view ActiveJob UI. To be used downstream'
+        },
+        adapter: {
+          type: :symbol_class,
+          default: ENV['USE_SIDEKIQ']=='true' ? :sidekiq : :inline,
+          on_assignment: ACTIVE_JOB_PROC,
+          description: 'Active job adapter. This expects a symbol or a class that inherits from ActiveJob::QueueAdapters'
+        },
+      }
+
+      attr_accessor *DEFAULT_VALUES.keys
+    end
+  end
+end

data/lib/rails_base/configuration/admin.rb

@@ -0,0 +1,231 @@
+require 'rails_base/configuration/base'
+require 'rails_base/admin/index_tile'
+require 'rails_base/admin/default_index_tile'
+require RailsBase::Engine.root.join('app', 'models', 'rails_base', 'user_constants.rb')
+
+module RailsBase
+  module Configuration
+    class Admin < Base
+
+      include RailsBase::UserConstants
+
+      ADMIN_TYPE_PROC = Proc.new do |hash|
+        RailsBase.config.admin.admin_types.map do |type|
+          {
+            filter: "Admin Type: #{type}",
+            proc: ->(user, admin_user) { user.public_send("admin_#{type}?") },
+            id: "#{hash[:id]}_#{type}",
+          }
+        end
+      end
+
+      DEFAULT_ADMIN_TYPE = {
+        filter: '',
+        id: "admin",
+        proc: ->(_user, _admin_user) { },
+        replace:  ADMIN_TYPE_PROC,
+      }
+
+      DEFAULT_ADMIN_SELF = {
+        filter: 'My User',
+        id: 'my_admin_user',
+        proc: ->(user, admin_user) { user == admin_user }
+      }
+
+      DEFAULT_ADMIN_ACTIVE = {
+        filter: 'Active Users',
+        id: 'active_users',
+        proc: ->(user, admin_user) { user.active? }
+      }
+
+      DEFAULT_EMAIL_VALIDATED = {
+        filter: 'Email Validated',
+        id: 'email_validated',
+        proc: ->(user, admin_user) { user.email_validated? }
+      }
+
+      DEFAULT_MFA_ENABLED = {
+        filter: 'MFA Enabled',
+        id: 'mfa_enabled',
+        proc: ->(user, admin_user) { user.mfa_enabled? }
+      }
+
+      DEFAULT_PAGE_FILTER = [DEFAULT_ADMIN_TYPE, DEFAULT_ADMIN_SELF, DEFAULT_ADMIN_ACTIVE, DEFAULT_EMAIL_VALIDATED, DEFAULT_MFA_ENABLED].flatten
+      DEFAULT_VALUES = {
+        enable: {
+          type: :boolean,
+          default: true,
+          description: 'Enable Admin capabilities'
+        },
+        admin_types: {
+          type: :array,
+          klass_type: [Symbol],
+          default: ADMIN_ENUMS,
+          on_assignment: ->(val, instance) { instance._assert_admin_type },
+          description: 'List of admin types. Assignment order is important. Note: :none gets prepended as this is default. Note: :owner, gets appended to this array as the last, highest priority',
+          decipher: ->(thing) { thing },
+        },
+        default_admin_type: {
+          type: :values,
+          expect_values: ->(instance) { instance.admin_types },
+          default: ADMIN_ROLE_NONE,
+          description: 'Starting value for new users. Dependent on `admin_types` values',
+          decipher: ->(thing) { thing },
+        },
+        enable_history: {
+          type: :boolean,
+          default: true,
+          dependents: [ -> (i) { i.enable? } ],
+          description: 'Enable Users to view history'
+        },
+        view_admin_page: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_view_only? },
+          dependents: [ -> (i) { i.enable? } ],
+          description: 'Users that can view admin index'
+        },
+        enable_history_by_user: {
+          type: :proc,
+          default: ->(user) { true },
+          dependents: [ -> (i) { i.enable_history? }, -> (i) { i.enable? } ],
+          description: 'Users that can view history page',
+        },
+        enable_actions: {
+          type: :boolean,
+          default: true,
+          dependents: [ -> (i) { i.enable? } ],
+          description: 'Enable history of admin actions',
+        },
+        admin_page_tiles: {
+          type: :array,
+          klass_type: [RailsBase::Admin::IndexTile],
+          default: RailsBase::Admin::IndexTile.defaults,
+          decipher: ->(thing) { thing.description },
+          description: 'List of tiles on admin page',
+        },
+        # Next value is dependent on admin_types. Must be defined after
+        admin_page_filter: {
+          type: :array,
+          # klass_type: [Array],
+          on_assignment: ->(val, instance) { instance._admin_type_replace_proc },
+          default: DEFAULT_PAGE_FILTER,
+          description: 'List of filters on admin page.',
+          decipher: ->(thing) { thing[:filter] },
+        },
+        enable_sso_tile: {
+          type: :boolean,
+          default: true,
+          dependents: [ -> (i) { i.enable? } ],
+          description: 'Display SSO tile on admin page',
+        },
+        sso_tile_users: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_super? },
+          dependents: [ -> (i) { i.enable_sso_tile? } ],
+          description: 'List of users that can use SSO on admin page',
+        },
+        impersonate_tile_users: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_super? },
+          description: 'List of users that can use impersonation on admin page',
+        },
+        admin_type_tile_users: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_owner? },
+          description: 'List of users that can change other users admin',
+        },
+        mfa_tile_users: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_super? },
+          description: 'List of users that can change MFA on admin page',
+        },
+        phone_tile_users: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_super? },
+          description: 'List of users that can change users phone number on admin page',
+        },
+        email_tile_users: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_super? },
+          description: 'List of users that can change users email on admin page',
+        },
+        email_validate_tile_users: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_super? },
+          description: 'List of users that can change email validated on admin page',
+        },
+        name_tile_users: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_super? },
+          description: 'List of users that can change users name on admin page',
+        },
+        active_tile_users: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_super? },
+          description: 'List of users that can change active on admin page',
+        },
+        modify_timezone_tile_users: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_super? },
+          description: 'List of users that can change the timezone for a given user',
+        },
+        config_page: {
+          type: :proc,
+          default: ->(user) { user.active && user.at_least_super? },
+          description: 'List of users that can view the configuration page',
+        },
+        admin_velocity_max: {
+          type: :integer,
+          default: ENV.fetch('ADMIN_VELOCITY_MAX', 20).to_i,
+          description: 'Max number of risky changes an admin can make in a given window',
+        },
+        admin_velocity_max_in_frame: {
+          type: :duration,
+          default: ENV.fetch('ADMIN_VELOCITY_MAX_IN_FRAME', 1).to_i.hours,
+          description: 'Sliding window for admin_velocity_max',
+
+        },
+        admin_velocity_frame: {
+          type: :duration,
+          default: ENV.fetch('ADMIN_VELOCITY_FRAME', 5).to_i.hours,
+          description: 'Debug purposes. How long to keep admin_velocity_max attempts',
+        },
+      }
+
+      attr_accessor *DEFAULT_VALUES.keys
+
+      def _assert_admin_type
+        admin_types.delete(ADMIN_ROLE_OWNER)
+        admin_types.delete(ADMIN_ROLE_NONE)
+        admin_types << ADMIN_ROLE_OWNER
+        admin_types.prepend ADMIN_ROLE_NONE
+        convenience_methods
+      end
+
+      def _admin_type_replace_proc
+        admin_page_filter.each_with_index do |value, index|
+          next unless value[:replace].present?
+
+          admin_page_filter[index] = ADMIN_TYPE_PROC.call(value)
+        end
+        admin_page_filter.flatten!
+      end
+
+      private
+
+      def convenience_methods
+        # defines instance methods like
+        # user.at_least_super?
+        # user.at_least_owner?
+        # user.admin_super!
+        # user.admin_owner!
+        # User.admin_owner
+        # User.admin_owners
+        # This is 100% dependent upon keeping `admin_types` in order of precedence
+        admin_types.each do |type|
+          ::User._def_admin_convenience_method!(admin_method: type)
+        end
+      end
+    end
+  end
+end