bp3-core 0.1.2

data/lib/bp3/core/cookies.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Bp3
+  module Core
+    module Cookies
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :current_visitor
+
+        before_action :check_visitor_cookie
+      end
+
+      VISITOR_COOKIE_NAME_PREFIX = '_bp3_visitor'
+      DO_NOT_TRACK_VALUE = 'do_not_track'
+
+      private
+
+      def do_not_track
+        return @do_not_track unless @do_not_track.nil? # could be set to true or false already
+
+        cookie_value = cookies[new_visitor_cookie_name]
+        @do_not_track = cookie_value == DO_NOT_TRACK_VALUE
+        reset_session if @do_not_track
+        @do_not_track
+      end
+
+      def set_do_not_track
+        # this replaces the signed temporary cookie with an unsigned, permanent cookie
+        cookies.permanent[new_visitor_cookie_name] = DO_NOT_TRACK_VALUE
+      end
+
+      def start_tracking
+        return unless do_not_track
+
+        cookies.delete(visitor_cookie_name)
+        @do_not_track = false
+        check_visitor_cookie
+      end
+
+      def check_visitor_cookie
+        switch_old_to_new
+        check_new_visitor_cookie
+      end
+
+      def switch_old_to_new
+        cookie_value = cookies.signed[visitor_cookie_name]
+        return if cookie_value.blank?
+
+        _sites_site_id, _tenant_id, identification = cookie_value&.split('/')
+
+        message = "check_visitor_cookie: switching to new visitor_cookie for #{identification}"
+        Rails.logger.debug message
+        cookies.delete(visitor_cookie_name)
+        cookies.signed[new_visitor_cookie_name] = {
+          value: identification,
+          expires: 365.days.from_now
+        }
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def check_old_visitor_cookie
+        cookie_value = cookies.signed[visitor_cookie_name]
+        return if cookie_value.blank? && do_not_track
+
+        sites_site_id, tenant_id, identification = cookie_value&.split('/')
+        if sites_site_id && sites_site_id != GRS.current_site.id
+          Rails.logger.warn { "check_visitor_cookie: site mismatch! (#{sites_site_id} and #{GRS.current_site.id}" }
+        end
+        if tenant_id && tenant_id != GRS.current_tenant.id
+          Rails.logger.warn { "check_visitor_cookie: tenant mismatch! (#{tenant_id} and #{GRS.current_tenant.id}" }
+        end
+        visitor = Users::Visitor.find_by(sites_site_id:, tenant_id:, identification:)
+        if visitor.nil?
+          visitor = create_visitor
+          message = "check_visitor_cookie: create_visitor #{visitor.id} and create #{visitor_cookie_name} cookie"
+          Rails.logger.debug message
+          cookies.signed[visitor_cookie_name] = {
+            value: visitor.scoped_identification,
+            expires: 365.days.from_now
+          }
+        end
+        @current_visitor = GlobalRequestState.current_visitor = visitor
+        Rails.logger.debug do
+          "check_visitor_cookie: cookie[#{visitor_cookie_name}]=#{cookies.signed[visitor_cookie_name]}"
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def check_new_visitor_cookie
+        cookie_value = cookies.signed[new_visitor_cookie_name]
+        return if cookie_value.blank? && do_not_track
+
+        identification = cookie_value
+        sites_site_id = GRS.current_site_id
+        tenant_id = GRS.current_tenant_id
+        visitor = Users::Visitor.find_by(sites_site_id:, tenant_id:, identification:)
+        if visitor.nil?
+          visitor = create_visitor
+          message = "check_visitor_cookie: create_visitor #{visitor.id} and create #{new_visitor_cookie_name} cookie"
+          Rails.logger.debug message
+          cookies.signed[new_visitor_cookie_name] = {
+            value: visitor.identification,
+            expires: 365.days.from_now
+          }
+        end
+        @current_visitor = GlobalRequestState.current_visitor = visitor
+        Rails.logger.debug do
+          "check_visitor_cookie: cookie[#{new_visitor_cookie_name}]=#{cookies.signed[new_visitor_cookie_name]}"
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def visitor_cookie_name
+        @visitor_cookie_name ||= "#{VISITOR_COOKIE_NAME_PREFIX}_#{cookie_site_id}_#{cookie_tenant_id}"
+      end
+
+      def new_visitor_cookie_name
+        VISITOR_COOKIE_NAME_PREFIX
+      end
+
+      def create_visitor
+        Users::Visitor.create!(sites_site: GRS.current_site,
+                               tenant: GRS.current_tenant,
+                               workspaces_workspace: GRS.current_workspace,
+                               identification: SecureRandom.uuid)
+      end
+
+      def cookie_site_id
+        GRS.current_site.id[0..7]
+      end
+
+      def cookie_tenant_id
+        GRS.current_tenant.id[0..7]
+      end
+    end
+  end
+end

data/lib/bp3/core/displayable.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'action_view/record_identifier'
+require 'active_support/parameter_filter'
+
+module Bp3
+  module Core
+    module Displayable
+      extend ActiveSupport::Concern
+
+      def to_dom_id
+        ActionView::RecordIdentifier.dom_id(self)
+      end
+
+      def display_name
+        admin_display_name
+      end
+
+      def admin_display_name
+        "#{self.class.name.split('::').last} #{id}"
+      end
+
+      def filtered_attributes
+        filter_object_fields if respond_to?(:object)
+        filter_attributes
+      end
+
+      def i18n_key
+        self.class.i18n_key
+      end
+
+      private
+
+      def version_filter_mask
+        '[FILTERED][DC]'
+      end
+
+      def filter_attributes
+        filter.filter(attributes)
+      end
+
+      def filter_object_fields
+        self.object = filter.filter(object) if object.present?
+        return if object_changes.blank?
+
+        filtered_object_changes = filter.filter(object_changes)
+        filtered_object_changes.each_key do |key|
+          if filtered_object_changes[key] == version_filter_mask
+            filtered_object_changes[key] =
+              mark_changes_as_filtered(key)
+          end
+        end
+        self.object_changes = filtered_object_changes
+      end
+
+      def filter
+        return @filter if @filter
+
+        filters = Rails.application.config.filter_parameters
+        @filter = ActiveSupport::ParameterFilter.new(filters, mask: version_filter_mask)
+      end
+
+      def mark_changes_as_filtered(key)
+        change = object_changes[key]
+        change[0] = version_filter_mask if change[0].present?
+        change[1] = version_filter_mask if change[1].present?
+        change
+      end
+
+      class_methods do
+        def i18n_key
+          name.downcase.gsub('::', '/')
+        end
+      end
+    end
+  end
+end

data/lib/bp3/core/feature_flags.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Bp3
+  module Core
+    module FeatureFlags
+      extend ActiveSupport::Concern
+
+      def efcfon?(flag, ref: nil, default: nil)
+        ef = efon(flag, ref:, default: nil)
+        cf = cfon(flag, ref:, default: nil)
+
+        if ef.nil? && cf.nil?
+          default || false
+        elsif ef.nil?
+          cf
+        elsif cf.nil?
+          ef
+        else
+          cf || ef
+        end
+      end
+
+      def efon(flag, ref: nil, default: nil)
+        Feature::Enabler.on(flag, enablable: ref, default:)
+      end
+
+      def efon?(flag, ref: nil, default: nil)
+        efon(flag, ref:, default:) || default || false
+      end
+
+      def cfon(flag, ref: nil, default: nil)
+        return default if ref.nil?
+
+        ref.configs&.[](flag)
+      end
+
+      def cfon?(flag, ref: nil, default: nil)
+        cfon(flag, ref:, default:) || default || false
+      end
+    end
+  end
+end

data/lib/bp3/core/ransackable.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Bp3
+  # Bp3::Ransackable provides class methods expected by models that use ransack
+  module Core
+    module Ransackable
+      extend ActiveSupport::Concern
+
+      mattr_accessor :attribute_exceptions, default: []
+      mattr_accessor :association_exceptions, default: []
+
+      class_methods do
+        def ransackable_fields(auth_object = nil)
+          fields =
+            ransackable_attributes(auth_object) +
+            ransackable_associations(auth_object) +
+            ransackable_scopes(auth_object)
+          fields.map(&:to_sym).uniq
+        end
+
+        def ransackable_attributes(_auth_object = nil)
+          except = attribute_exceptions.map(&:to_s)
+          column_names.map(&:to_s) - except
+        end
+
+        def ransackable_associations(_auth_object = nil)
+          except = association_exceptions.map(&:to_s)
+          reflect_on_all_associations.map(&:name).map(&:to_s) - except
+        end
+
+        def ransackable_scopes(_auth_object = nil)
+          []
+        end
+
+        def ransortable_attributes(auth_object = nil)
+          ransackable_attributes(auth_object)
+        end
+
+        private
+
+        def attribute_exceptions
+          Bp3::Core::Ransackable.attribute_exceptions
+        end
+
+        def association_exceptions
+          Bp3::Core::Ransackable.association_exceptions
+        end
+      end
+    end
+  end
+end

data/lib/bp3/core/rqid.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Bp3
+  module Core
+    module Rqid
+      extend ActiveSupport::Concern
+
+      mattr_accessor :global_request_state_class_name, :global_request_state_method
+
+      def self.global_request_state_class
+        @@global_request_state_class ||= global_request_state_class_name.constantize # rubocop:disable Style/ClassVars
+      end
+
+      included do
+        before_create :set_rqid
+
+        # CAUTION: these are defined as belongs_to, therefore returning one record. However, it is possible
+        # that multiple such records exist
+        belongs_to :original_request, class_name: 'Inbound::Request',
+                                      foreign_key: :rqid, primary_key: :rqid, optional: true
+        belongs_to :original_response, class_name: 'Inbound::Response',
+                                       foreign_key: :rqid, primary_key: :rqid, optional: true
+        belongs_to :original_visit, class_name: 'Visit',
+                                    foreign_key: :rqid, primary_key: :rqid, optional: true
+      end
+
+      private
+
+      def set_rqid
+        return if rqid
+
+        self.rqid = rqid_from_global_state
+      end
+
+      def rqid_from_global_state
+        Bp3::Core::Rqid.global_request_state_class.send(Bp3::Core::Rqid.global_request_state_method)
+      end
+    end
+  end
+end

data/lib/bp3/core/settings.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Bp3
+  module Core
+    module Settings
+      extend ActiveSupport::Concern
+
+      def create_request_record_is_on?
+        efcfon?(:create_request_record, ref: current_site, default: true)
+      end
+
+      def multi_tenant_is_on?
+        efcfon?('multi-tenant', ref: current_site, default: false)
+      end
+    end
+  end
+end

data/lib/bp3/core/sqnr.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Bp3
+  module Core
+    module Sqnr
+      extend ActiveSupport::Concern
+
+      included do
+        scope :sqnr, -> { order(sqnr: :asc) }
+        scope :rnqs, -> { order(sqnr: :desc) }
+      end
+
+      class_methods do
+        def use_sqnr_for_ordering
+          self.implicit_order_column = :sqnr
+        end
+      end
+    end
+  end
+end

data/lib/bp3/core/tenantable.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Bp3
+  module Core
+    module Tenantable
+      extend ActiveSupport::Concern
+
+      included do
+        # call connection to make sure the db meta data has been loaded
+        ignore_notifications_string = (ENV['IGNORE_NOTIFICATIONS'] || '').strip
+        connection if ignore_notifications_string.empty?
+      end
+
+      private
+
+      def set_sites_site_id
+        return if sites_site_id || sites_site
+
+        self.sites_site_id = GlobalRequestState.either_site_id
+      end
+
+      def set_tenant_id
+        return if tenant_id || tenant
+
+        self.tenant_id = GlobalRequestState.either_tenant_id
+      end
+
+      def tenant_matches_site
+        tid = tenant_id || tenant&.id
+        return if tid.nil?
+
+        tenant ||= Tenant.find(tid)
+        return if (sites_site_id || sites_site&.id) == tenant.sites_site_id
+
+        errors.add(:tenant, :must_match_site)
+      end
+
+      def set_workspaces_workspace_id
+        return if workspaces_workspace_id || workspaces_workspace
+
+        self.workspaces_workspace_id = GlobalRequestState.either_workspace_id
+      end
+
+      def workspaces_workspace_matches_site
+        wid = workspaces_workspace_id || workspaces_workspace&.id
+        return if wid.nil?
+
+        workspaces_workspace ||= Workspaces::Workspace.find(wid)
+        return if (sites_site_id || sites_site&.id) == workspaces_workspace.sites_site_id
+
+        errors.add(:workspaces_workspace, :must_match_site)
+      end
+
+      # rubocop:disable: Metrics/BlockLength
+      class_methods do
+        def configure_tenancy(tenancy_configuration = {})
+          @tenancy_configuration = default_configuration.merge(tenancy_configuration)
+          may_belong_to_site
+          may_belong_to_tenant
+          may_belong_to_workspace
+        rescue ActiveRecord::StatementInvalid, PG::UndefinedTable => e
+          Rails.logger.error { "ERROR in configure_tenancy: #{e.message}" }
+          # log_exception(e) # infinite loop
+        end
+
+        def may_belong_to_site
+          column = columns.detect { |c| c.name == 'sites_site_id' }
+          return if column.nil?
+
+          @tenancy_configuration[:belongs_to_site] = true
+          optional = column.null
+          belongs_to(:sites_site, class_name: 'Sites::Site', optional:)
+          alias_method :site, :sites_site
+          alias_method :site=, :sites_site=
+
+          before_validation :set_sites_site_id
+
+          default_scope lambda {
+            site = GlobalRequestState.either_site
+            site = nil if GlobalRequestState.current_root
+            where(sites_site_id: site.id) if site
+          }
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def may_belong_to_tenant
+          column = columns.detect { |c| c.name == 'tenant_id' }
+          return if column.nil?
+
+          @tenancy_configuration[:belongs_to_tenant] = true
+          optional = column.null
+          belongs_to(:tenant, optional:)
+
+          before_validation :set_tenant_id
+
+          validate :tenant_matches_site
+
+          default_scope lambda {
+            site = GlobalRequestState.either_site
+            site = nil if GlobalRequestState.current_root
+            tenant = GlobalRequestState.either_tenant
+            tenant = nil if GlobalRequestState.either_admin
+            if site && tenant # for non admins (i.e. users)
+              where(sites_site_id: site.id, tenant_id: tenant.id)
+            elsif site # for site admins
+              where(sites_site_id: site.id)
+            elsif tenant
+              raise RuntimeError # where(tenant_id: tenant.id)
+            end
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def may_belong_to_workspace
+          column = columns.detect { |c| c.name == 'workspaces_workspace_id' }
+          return if column.nil?
+
+          @tenancy_configuration[:belongs_to_workspace] = true
+          optional = column.null
+          belongs_to(:workspaces_workspace, class_name: 'Workspaces::Workspace', optional:)
+          alias_method :workspace, :workspaces_workspace
+          alias_method :workspace=, :workspaces_workspace=
+
+          before_validation :set_workspaces_workspace_id
+
+          validate :workspaces_workspace_matches_site
+        end
+
+        def default_configuration
+          {
+            site_presence: :db,
+            tenant_presence: :db,
+            workspace_presence: :db,
+            site_source: :either_site,
+            tenant_source: :either_tenant,
+            workspace_source: :either_workspace
+          }
+        end
+      end
+      # rubocop:disable: Metrics/BlockLength
+    end
+  end
+end

data/lib/bp3/core/test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Bp3
+  module Core
+    # Bp3::Core::Test provides a convenience class for testing Bp3::Core
+    class Test
+      # to test Ransackable
+      include Ransackable
+
+      def self.column_names
+        %i[id name]
+      end
+
+      def self.reflect_on_all_associations
+        []
+      end
+
+      # to test Cookies
+      # first define this:
+      def self.before_action(_method_name); end
+      # then include Cookies
+      include Cookies
+
+      # to test Displayable
+      include Displayable
+
+      # to test FeatureFlags
+      include FeatureFlags
+
+      # to test Rqid
+      # first define this:
+      def self.before_create(_method_name); end
+      def self.belongs_to(_association, **options); end
+      def self.scope(_scope_name, _lambda); end
+      # then include Rqid
+      include Rqid
+
+      # to test Sqnr
+      include Sqnr
+
+      # to test Tenantable
+      # first define this:
+      def self.connection; end
+      # then include Tenantable
+      include Tenantable
+    end
+  end
+end

data/lib/bp3/core/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bp3
+  module Core
+    VERSION = '0.1.2'
+  end
+end

data/lib/bp3/core.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/module/attribute_accessors'
+
+require_relative 'core/actions'
+require_relative 'core/cookies'
+require_relative 'core/displayable'
+require_relative 'core/feature_flags'
+require_relative 'core/ransackable'
+require_relative 'core/settings'
+require_relative 'core/tenantable'
+require_relative 'core/rqid'
+require_relative 'core/sqnr'
+require_relative 'core/version'
+
+module Bp3
+  module Core
+  end
+end

data/lib/bp3-core.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bp3/core'

data/sig/bp3/core.rbs

@@ -0,0 +1,6 @@
+module Bp3
+  module Core
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end