has_helpers 5.0.2

data/app/models/has_helpers/organization_link.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+class HasHelpers::OrganizationLink < ::ActiveRecord::Base
+  self.table_name = :organization_links
+
+  autoset :organization_id
+  autoset :created_by_id, :user_id, before: :validation
+  autoset :updated_by_id, :user_id, before: :validation, overwrite: true
+
+  attr_accessor :placeholder
+
+  ###### callbacks ######
+  before_validation :normalization
+
+  ###### variables ######
+
+  ###### associations ######
+
+  ###### externals ######
+  belongs_to :organization, class_name: "::HasHelpers::Organization"
+  belongs_to :resource, class_name: "HasHelpers::Resource", optional: true
+  belongs_to :link_type, class_name: "::HasHelpers::LinkType"
+  belongs_to :created_by, class_name: "::HasHelpers::User"
+  belongs_to :updated_by, class_name: "::HasHelpers::User"
+
+  has_owner :organization
+
+  ###### normalizations ######
+
+  ###### validations #######
+  has_validated_attributes url: { format: :url, maximum_length: 255 },
+                           name: { format: :name, maximum_length: 31 },
+                           icon: { format: :name, maximum_length: 31 }
+
+  validates :name, :link_type, presence: true
+
+  scope :side_links, -> { where(link_type_id: ::HasHelpers::LinkType::SIDE_NAV.id).order(:weight) }
+  scope :tab_links, ->(resource) { where(link_type_id: ::HasHelpers::LinkType::RESOURCE_TAB.id, resource_id: resource).order(:weight) }
+
+  ###### instance methods ######
+
+  def available_resources
+    HasHelpers::Resource.where(
+      resource_type_id: "HasHelpers::ResourceType::::Base",
+      application_id: ::HasHelpers::Application.current_application.id
+    )
+  end
+
+  # overrided on agencies initializer to use webhook placeholders
+  def placeholders
+    [{ name: "Id", value: "id" }]
+  end
+
+  def teams
+    []
+  end
+
+  def has_access?(user)
+    persisted? && (try("team").blank? || try("team").users.include?(user) || user.is_super_user?)
+  end
+
+  def url_value
+    if placeholder.present?
+      self.url += self.url.end_with?("/") ? "{{#{placeholder}}}" : "/{{#{placeholder}}}"
+    end
+  end
+
+  def replaced_placeholder_url(base_resource)
+    return url if resource.blank?
+    view = Mustache.new
+    view.template = url.gsub(/{{(?<control_char>[\/#!\^]?)\s*(?<key>.+?)\s*}}/) { "{{#{ $~[:control_char] } #{ normalize_key($~[:key]) } }}" }
+    view.template.tags.map do |name|
+      value = base_resource.try(name.to_sym)
+      view[name.to_sym] = value
+    end
+    view.render
+  end
+
+  protected
+
+  def normalization
+    if self.url.present?
+      self.url = "http://" + self.url unless self.url.include?("http://") || self.url.include?("https://")
+    end
+  end
+
+  private
+
+  def normalize_key(key)
+    key.to_s.despace.underscore
+  end
+end

data/app/models/has_helpers/organization_methods.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module HasHelpers::OrganizationMethods
+  # Including apps' organization models can use this to set common settings
+  # for organization photos.
+  PHOTO_OPTIONS = {
+    as: :logo,
+    bucket: "hqadmin-#{ ::HasUtils::Env.current_environment }", # TODO: upgrade paperclip to 6 and you can use  -> { "#{::HasHelpers::Application::HQADMIN.name}-#{ ::HasUtils::Env.current_environment }" },
+    styles: { thumbnail: "34x34#", medium: "80x80#", large: "120x120#", white: "120x120#" },
+    convert_options: { white: "-fuzz 5% -transparent white -colorize 90% -negate" }
+  }.freeze
+
+  def self.included(base)
+    base.class_eval do
+      attr_accessor :extra_attributes
+
+      belongs_to :time_zone
+      has_many :users,                  dependent: :destroy
+      has_many :organization_links,     dependent: :destroy, class_name: "HasHelpers::OrganizationLink"
+      has_many :organization_resources, dependent: :destroy, class_name: "::HasHelpers::OrganizationResource"
+
+      accepts_nested_attributes_for :organization_resources
+      accepts_nested_attributes_for :organization_links, allow_destroy: true, reject_if: proc { |a| a.slice("X", "id", "name").values.all?(&:blank?) }
+
+      before_validation :normalize
+
+      has_validated_attributes name: { format: :name },
+                               domain: { format: :domain }
+      validates :name,         presence: true, uniqueness: true
+      validates :domain,       presence: true, uniqueness: true
+      validates :time_zone_id, presence: true, inclusion: { in: proc { ::TimeZone.pluck(:id) } }
+
+      def organization
+        self
+      end
+
+      def organization_id
+        id
+      end
+
+      def contact_details # Used for PDF footers
+        # Override to provide details such as contact information.
+        # Return details in grouped within a hash. Note that group names are currently not used other than as hash keys.
+        #
+        # Example:
+        #   {
+        #     Contact: {
+        #       website: websites.primary.url.to_service(name),
+        #       address: addresses.primary,
+        #     }
+        #   }
+        {}
+      end
+
+      private
+
+      def normalize
+        self.domain = domain.downcase if domain
+      end
+    end
+  end
+end

data/app/models/has_helpers/organization_option.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HasHelpers
+  class OrganizationOption < ApplicationRecord
+    self.table_name = :organization_options
+
+    ###### callbacks #######
+    autoset :organization_id
+    autoset :created_by_id, :user_id, before: :validation
+    autoset :updated_by_id, :user_id, before: :validation, overwrite: true
+
+    ###### variables #######
+
+    ###### associations #######
+    belongs_to :organization, class_name: "::HasHelpers::Organization"
+    belongs_to :option,                                                 optional: true
+    belongs_to :created_by,   class_name: "::HasHelpers::User"
+    belongs_to :updated_by,   class_name: "::HasHelpers::User"
+
+    ###### externals ######
+
+    ###### normalizations ######
+
+    ###### scopes #######
+
+    ###### class methods ######
+
+    ###### instance methods ######
+  end
+end

data/app/models/has_helpers/organization_resource.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class OrganizationResource < ApplicationRecord
+    self.table_name = :organization_resources
+    belongs_to :resource,              class_name: "HasHelpers::Resource"
+    belongs_to :organization_resource, class_name: "HasHelpers::OrganizationResource", optional: true
+    belongs_to :resource_group,                                                        optional: true
+    has_many :organization_resources,  class_name: "HasHelpers::OrganizationResource", dependent: :destroy, inverse_of: :organization_resource
+
+    ###### scopes ######
+    scope :for_app_id, ->(application_id) {
+      joins(:resource).where(resources: { application_id: application_id }).order("in_order ASC")
+    }
+
+    accepts_nested_attributes_for :resource_group
+
+    def is_grouped_by_resource=(val)
+      @is_grouped_by_resource = val.to_bool
+      case @is_grouped_by_resource
+      when true
+        self.resource_group = nil
+      else
+        self.organization_resource_id = nil
+      end
+      @is_grouped_by_resource # rubocop:disable Lint/Void
+    end
+
+    def is_grouped_by_resource
+      if @is_grouped_by_resource.nil?
+        @is_grouped_by_resource = !!self.organization_resource_id || (self.resource_group_id && false)
+      else
+        @is_grouped_by_resource
+      end
+    end
+
+    def parent_resource=(parent_resource_id)
+      self.organization_resource = parent_resource_id.present? ? ::HasHelpers::OrganizationResource.find_or_create_by(organization_id: organization_id, resource_id: parent_resource_id) : nil
+    end
+
+    def parent_resource
+      @parent_resource ||= organization_resource_id && organization_resource.resource
+    end
+  end
+end

data/app/models/has_helpers/pending_db_operation.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class PendingDBOperation < HasHelpers::MasterRecord
+    self.table_name = "pending_db_operations"
+    scope :recent, -> { where("enqueued_at IS NULL OR enqueued_at > ?", 1.hour.ago) }
+    scope :with_id, ->(id) { where(foreign_key_value: id) }
+    scope :with_relation, ->(relation) { where(relation_name: relation) }
+
+    def self.mark_op_as_queued(id)
+      where(id: id).update_all("enqueued_at = now() at time zone 'utc'")
+    end
+
+    # This method clears the enqueued_at field, so the op will get picked up for
+    # processing later. The Worker can use this if it decides not to
+    # process an Op. Without calling this, that op would never get processed;
+    # this lets the MasterWorker re-enqueue this op later.
+
+    def self.defer_processing(id)
+      where(id: id).update_all(enqueued_at: nil)
+    end
+
+    def defer_processing
+      self.class.defer_processing(id)
+    end
+
+    def execute(connection: self.class.connection)
+      connection.execute("SELECT run_one_db_operation(#{id})")
+    end
+  end
+end

data/app/models/has_helpers/recently_viewed.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class HasHelpers::RecentlyViewed < ActiveRecord::Base
+  self.table_name = "recently_vieweds"
+
+  belongs_to :organization, class_name: "::HasHelpers::Organization"
+
+  before_create :create_block
+  after_save :limit_last
+
+  scope :by_user_id, -> (user_id, org_id) { where(created_by_id: user_id, organization_id: org_id) }
+  default_scope -> { order(created_at: :desc) }
+
+  def create_block
+    associated_object_foreign_key = owner.class.base_class.name.demodulize.foreign_key
+    updated_count = ::HasHelpers::RecentlyViewed.where(created_by_id: created_by_id).where(associated_object_foreign_key => owner.id).update_all(updated_at: Time.zone.now)
+
+    throw(:abort) if updated_count != 0
+  end
+
+  def limit_last
+    related_recently_vieweds = ::HasHelpers::RecentlyViewed.where(created_by_id: created_by_id).where.not(owner.class.base_class.name.demodulize.foreign_key => nil)
+
+    # For STI models scope the RecentlyViewed records to the specific owner type. This is done by simply adding an inner join.
+    if owner.class.base_class != owner.class
+      related_recently_vieweds = related_recently_vieweds.
+                                 joins(owner.class.base_class.name.demodulize.underscore.to_sym).
+                                 where(owner.class.base_class.name.demodulize.tableize => { type: owner.class.name })
+    end
+
+    # Delete the least recently updated records to bring the total number down to the maximum allowed.
+    related_recently_vieweds.order("updated_at DESC").offset(::HasHelpers::HISTORY_MAX).each(&:delete)
+  end
+end

data/app/models/has_helpers/reindex_queue.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class ReindexQueue
+    def self.redis
+      RedisConf.current
+    end
+
+    def initialize(index_name)
+      @index_name = index_name
+    end
+
+    def push(record_id, key = nil, routing_key: nil)
+      data = { record_id: record_id, key: key, routing_key: routing_key }.to_json
+      self.class.redis.with { |redis| redis.lpush(redis_key, data) }
+    end
+
+    def reserve(limit: 1000)
+      reserved_records = []
+      self.class.redis.with do |redis|
+        limit.times do
+          data = redis.rpop(redis_key)
+          reserved_records << JSON.parse(data, symbolize_names: true) if data
+        end
+      end
+      reserved_records
+    end
+
+    def clear
+      self.class.redis.with { |redis| redis.del(redis_key) }
+    end
+
+    def length
+      self.class.redis.with { |redis| redis.llen(redis_key) }
+    end
+
+    private
+
+    def redis_key
+      "has_helpers:reindex_queue:#{@index_name}"
+    end
+  end
+end

data/app/models/has_helpers/resource.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class Resource < ApplicationRecord
+    self.table_name = :resources
+
+    belongs_to :resource_type,  class_name: "::HasHelpers::ResourceType"
+    belongs_to :application,    class_name: "::HasHelpers::Application"
+    belongs_to :parent,         class_name: "::HasHelpers::Resource", optional: true
+    belongs_to :field_resource, class_name: "::HasHelpers::Resource", optional: true
+
+    has_many :restrictions, dependent: :destroy
+    has_many :nested_resources, class_name: "::HasHelpers::Resource", inverse_of: :parent, foreign_key: :parent_id, dependent: :destroy
+    has_many :organization_resources, dependent: :destroy
+
+    has_many :card_definition_resources,     class_name: "HasHelpers::Cards::CardDefinitionResource", inverse_of: :resource, dependent: :destroy
+    has_many :card_fields_as_field_resource, class_name: "HasHelpers::Cards::CardField", foreign_key: :field_id, inverse_of: :field_resource, dependent: :nullify
+    has_many :role_resource_cards,           class_name: "HasHelpers::Cards::RoleResourceCard", inverse_of: :resource, dependent: :destroy
+
+    validates :resource_type, :name, presence: true
+
+    scope :not_fields, -> { where.not(resource_type_id: [::HasHelpers::ResourceType::FIELD.id, ::HasHelpers::ResourceType::REQUIRED_FIELD.id]) }
+    scope :fields, -> { where(resource_type_id: [::HasHelpers::ResourceType::FIELD.id, ::HasHelpers::ResourceType::REQUIRED_FIELD.id]) }
+    scope :sorted_by_formatted_name, -> { sort_by(&:formatted_name) }
+
+    def klass(safe: false)
+      @klass ||= safe ? name.safe_constantize : name.constantize
+    end
+
+    def resources
+      nested_resources
+    end
+
+    def formatted_name
+      (alias_name || name).demodulize.titleize.pluralize
+    end
+  end
+end

data/app/models/has_helpers/resource_group.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class ResourceGroup < ApplicationRecord
+    self.table_name = :resource_groups
+
+    has_many :organization_resources, dependent: :destroy
+
+    validates :name, length: { maximum: 31 }
+
+    def search_group_resource_array
+      organization_resources.map(&:name)
+    end
+  end
+end

data/app/models/has_helpers/restriction.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class Restriction < ApplicationRecord
+    self.table_name = :restrictions
+
+    belongs_to :resource
+    belongs_to :role
+    belongs_to :organization, class_name: "::HasHelpers::Organization"
+
+    has_many :restriction_operations, dependent: :destroy
+
+    validates :resource, :role, :created_by_id, :updated_by_id, :organization_id, presence: true
+  end
+end

data/app/models/has_helpers/restriction_operation.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class RestrictionOperation < ApplicationRecord
+    self.table_name = :restriction_operations
+
+    belongs_to :restriction
+    belongs_to :organization, class_name: "::HasHelpers::Organization"
+    belongs_to :operation, class_name: "Option", primary_key: :id
+
+    validates :restriction_id, uniqueness: { scope: :operation_id }
+  end
+end

data/app/models/has_helpers/role.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class Role < ApplicationRecord
+    self.table_name = :roles
+
+    has_many :user_roles, dependent: :destroy
+    has_many :users, through: :user_roles
+    has_many :restrictions, dependent: :destroy
+
+    has_many :role_resource_cards, class_name: "HasHelpers::Cards::RoleResourceCard", inverse_of: :role, dependent: :destroy
+
+    belongs_to :organization, class_name: "::HasHelpers::Organization"
+
+    validates :name, :organization_id, :created_by_id, :updated_by_id, presence: true
+    validates :name, uniqueness: { scope: [:organization_id] }
+
+    has_favorites
+  end
+end

data/app/models/has_helpers/service_trust/audit_log.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module ServiceTrust
+    class AuditLog < HasHelpers::ApplicationRecord
+      self.table_name = "service_trust_audit_logs"
+
+      validates :issuer, :audience, :outcome, :occurred_at, presence: true
+      validates :direction, inclusion: { in: %w[inbound outbound] }, allow_nil: false
+
+      class WriteJob < HasUtils::GoodJob::BaseWorker
+        queue_as :default
+
+        def perform(attributes)
+          HasHelpers::ServiceTrust::AuditLog.create!(attributes)
+        end
+      end
+    end
+  end
+end

data/app/models/has_helpers/service_trust/key.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module ServiceTrust
+    class Key < HasHelpers::ApplicationRecord
+      self.table_name = "service_trust_keys"
+
+      ENCRYPTION_ACTIVE = respond_to?(:encrypts)
+
+      if ENCRYPTION_ACTIVE
+        encrypts :private_key_pem
+      elsif defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+        Rails.logger.warn(
+          "[HasHelpers::ServiceTrust] private_key_pem is stored UNENCRYPTED " \
+          "because ActiveRecord::Encryption is unavailable (Rails < 7). " \
+          "Treat the service_trust_keys table as sensitive."
+        )
+      end
+
+      scope :for_env, ->(env) { where(environment: env.to_s) }
+      scope :active_for_env, ->(env) { for_env(env).where(active: true, retired_at: nil) }
+      scope :verifiable_for_env, lambda { |env|
+        for_env(env).where("retired_at IS NULL OR retired_at > ?", Time.current)
+      }
+
+      validates :kid, :environment, :private_key_pem, :public_key_pem, :algorithm, presence: true
+      validate :single_active_key_per_environment
+
+      def self.encryption_active?
+        ENCRYPTION_ACTIVE
+      end
+
+      def to_openssl
+        OpenSSL::PKey.read(private_key_pem)
+      end
+
+      def public_key
+        OpenSSL::PKey.read(public_key_pem)
+      end
+
+      def persisted_backing?
+        persisted?
+      end
+
+      private
+
+      def single_active_key_per_environment
+        return unless active? && retired_at.nil? && environment.present?
+
+        relation = self.class.active_for_env(environment)
+        relation = relation.where.not(id: id) if id.present?
+        errors.add(:active, "already exists for environment") if relation.exists?
+      end
+    end
+  end
+end

data/app/models/has_helpers/stat.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class Stat < ApplicationRecord
+    self.table_name = :stats
+
+    # DEPRECATION WARNING: The behavior of the `:interval` type will be changing in Rails 7.0
+    # to return an `ActiveSupport::Duration` object. If you'd like to keep
+    # the old behavior, you can add this line to HasHelpers::Stat model -> attribute :duration, :string
+    # If you'd like the new behavior today, you can add this line -> attribute :duration, :interval
+    attribute :duration, :interval
+  end
+end

data/app/models/has_helpers/user.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class User < ApplicationRecord
+    self.table_name = :users
+
+    has_many :user_organizations, dependent: :destroy, class_name: "::HasHelpers::UserOrganization"
+    has_many :organizations, class_name: "::HasHelpers::Organization", through: :user_organizations
+
+    def organization
+      user_organizations.find { |uo| uo.is_primary == true }&.organization
+    end
+
+    def organization_id
+      user_organizations.find { |uo| uo.is_primary == true }&.organization_id
+    end
+  end
+end