rails_den 2.0.0

data/app/models/rails_den/badge_award.rb

@@ -0,0 +1,87 @@
+module RailsDen
+  class BadgeAward < ApplicationRecord
+    AWARD_KINDS = %w[
+      manual
+      automatic
+    ].freeze
+
+    belongs_to :badge,
+               class_name: "RailsDen::Badge",
+               inverse_of: :badge_awards
+
+    belongs_to :recipient,
+               polymorphic: true
+
+    belongs_to :awarded_by,
+               polymorphic: true,
+               optional: true
+
+    validates :award_kind,
+              presence: true,
+              inclusion: {
+                in: AWARD_KINDS
+              }
+
+    validates :badge_id,
+              uniqueness: {
+                scope: %i[
+                  recipient_type
+                  recipient_id
+                ]
+              }
+
+    validate :award_kind_matches_badge
+    validate :awarder_matches_award_kind
+
+    after_commit :emit_notification_event,
+                 on: :create
+
+    def manual?
+      award_kind == "manual"
+    end
+
+    def automatic?
+      award_kind == "automatic"
+    end
+
+    private
+
+    def award_kind_matches_badge
+      return unless badge
+      return if award_kind.blank?
+      return if award_kind == badge.award_mode
+
+      errors.add(
+        :award_kind,
+        "must match the badge award mode"
+      )
+    end
+
+    def awarder_matches_award_kind
+      case award_kind
+      when "manual"
+        if awarded_by.nil?
+          errors.add(
+            :awarded_by,
+            "must be present for a manual award"
+          )
+        end
+      when "automatic"
+        if awarded_by.present?
+          errors.add(
+            :awarded_by,
+            "must be blank for an automatic award"
+          )
+        end
+      end
+    end
+
+    def emit_notification_event
+      return unless RailsDen::Gamification.enabled?
+
+      RailsDen::NotificationEvents::Emitter.call(
+        badge_award: self
+      )
+    end
+  end
+end

data/app/models/rails_den/board.rb

@@ -0,0 +1,129 @@
+module RailsDen
+  class Board < ApplicationRecord
+    include RailsDen::Sluggable
+
+    slug_uniqueness_scope :category_id
+
+    belongs_to :category
+
+    has_many :topics,
+             dependent: :restrict_with_error
+
+    has_many :board_read_states,
+             class_name: "RailsDen::BoardReadState",
+             dependent: :restrict_with_error
+
+    has_many :board_follows,
+             class_name: "RailsDen::BoardFollow",
+             inverse_of: :board,
+             dependent: :restrict_with_error
+
+    has_many :board_role_assignments,
+             class_name: "RailsDen::BoardRoleAssignment",
+             inverse_of: :board,
+             dependent: :destroy
+
+    has_many :board_role_permissions,
+             class_name: "RailsDen::BoardRolePermission",
+             inverse_of: :board,
+             dependent: :destroy
+
+    has_many :board_role_requirements,
+             class_name: "RailsDen::BoardRoleRequirement",
+             inverse_of: :board,
+             dependent: :destroy
+
+    has_many :board_sponsorships,
+             class_name: "RailsDen::BoardSponsorship",
+             inverse_of: :board,
+             dependent: :restrict_with_error
+
+    enum :visibility,
+         {
+           public: "public",
+           private: "private"
+         },
+         prefix: true
+
+    validates :title,
+              presence: true
+
+    validates :slug,
+              presence: true,
+              uniqueness: {
+                scope: :category_id
+              },
+              format: {
+                with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/,
+                message: "must contain only lowercase letters, numbers, and hyphens"
+              }
+
+    validates :position,
+              numericality: {
+                only_integer: true,
+                greater_than_or_equal_to: 0
+              }
+
+    scope :ordered, -> { order(:position, :id) }
+
+    after_commit :enqueue_member_profile_stats_refreshes,
+                 on: :update,
+                 if: -> {
+                   previous_changes.key?("enabled") ||
+                     previous_changes.key?("visibility")
+                 }
+
+    def read_state_for(reader)
+      board_read_states.find_by(
+        reader: reader
+      )
+    end
+
+    def mark_read!(reader:)
+      marker =
+        Post
+          .joins(:topic)
+          .where(
+            rails_den_topics: {
+              board_id: id
+            }
+          )
+          .order(
+            "rails_den_posts.created_at DESC",
+            "rails_den_posts.id DESC"
+          )
+          .first
+
+      read_state =
+        board_read_states.create_or_find_by!(
+          reader: reader
+        ) do |new_read_state|
+          new_read_state.last_read_post = marker
+        end
+
+      read_state.advance_through!(marker)
+    end
+
+    def self.model_name
+      @model_name ||= ActiveModel::Name.new(
+        self,
+        nil,
+        "RailsDen::Board"
+      )
+    end
+
+    private
+
+    def enqueue_member_profile_stats_refreshes
+      MemberProfileStatsRefreshJob.enqueue_for_authors(topics)
+
+      MemberProfileStatsRefreshJob.enqueue_for_authors(
+        Post.joins(:topic).where(
+          rails_den_topics: {
+            board_id: id
+          }
+        )
+      )
+    end
+  end
+end

data/app/models/rails_den/board_follow.rb

@@ -0,0 +1,18 @@
+module RailsDen
+  class BoardFollow < ApplicationRecord
+    belongs_to :board,
+               class_name: "RailsDen::Board",
+               inverse_of: :board_follows
+
+    belongs_to :follower,
+               polymorphic: true
+
+    validates :follower_id,
+              uniqueness: {
+                scope: %i[
+                  board_id
+                  follower_type
+                ]
+              }
+  end
+end

data/app/models/rails_den/board_read_state.rb

@@ -0,0 +1,60 @@
+module RailsDen
+  class BoardReadState < ApplicationRecord
+    belongs_to :board
+    belongs_to :reader, polymorphic: true
+
+    belongs_to :last_read_post,
+               class_name: "RailsDen::Post",
+               optional: true
+
+    validate :last_read_post_belongs_to_board
+
+    def advance_through!(post)
+      return self if post.nil?
+
+      ensure_post_belongs_to_board!(post)
+
+      with_lock do
+        if last_read_post.nil? || post_after?(post, last_read_post)
+          update!(last_read_post: post)
+        end
+      end
+
+      self
+    end
+
+    def covers?(post)
+      ensure_post_belongs_to_board!(post)
+
+      last_read_post.present? &&
+        !post_after?(post, last_read_post)
+    end
+
+    private
+
+    def ensure_post_belongs_to_board!(post)
+      return if post.topic.board_id == board_id
+
+      raise ArgumentError,
+            "post must belong to the same board"
+    end
+
+    def post_after?(candidate, marker)
+      candidate.created_at > marker.created_at ||
+        (
+          candidate.created_at == marker.created_at &&
+          candidate.id > marker.id
+        )
+    end
+
+    def last_read_post_belongs_to_board
+      return if last_read_post.blank? || board.blank?
+      return if last_read_post.topic.board == board
+
+      errors.add(
+        :last_read_post,
+        "must belong to the same board"
+      )
+    end
+  end
+end

data/app/models/rails_den/board_role_assignment.rb

@@ -0,0 +1,45 @@
+module RailsDen
+  class BoardRoleAssignment < ApplicationRecord
+    NON_ASSIGNABLE_ROLE_KEYS = %w[
+      guest
+      member
+      administrator
+    ].freeze
+
+    belongs_to :board,
+               class_name: "RailsDen::Board",
+               inverse_of: :board_role_assignments
+
+    belongs_to :role,
+               class_name: "RailsDen::Role",
+               inverse_of: :board_role_assignments
+
+    belongs_to :user,
+               polymorphic: true
+
+    validates :role_id,
+              uniqueness: {
+                scope: %i[
+                  board_id
+                  user_type
+                  user_id
+                ]
+              }
+
+    validate :role_can_be_board_scoped
+
+    private
+
+    def role_can_be_board_scoped
+      return unless role
+      return unless role.key.in?(
+        NON_ASSIGNABLE_ROLE_KEYS
+      )
+
+      errors.add(
+        :role,
+        "#{role.key} cannot be assigned at board scope"
+      )
+    end
+  end
+end

data/app/models/rails_den/board_role_permission.rb

@@ -0,0 +1,31 @@
+module RailsDen
+  class BoardRolePermission < ApplicationRecord
+    belongs_to :board,
+               class_name: "RailsDen::Board",
+               inverse_of: :board_role_permissions
+
+    belongs_to :role,
+               class_name: "RailsDen::Role",
+               inverse_of: :board_role_permissions
+
+    validates :capability,
+              presence: true,
+              inclusion: {
+                in: RailsDen::RolePermission::BOARD_CAPABILITIES
+              },
+              uniqueness: {
+                scope: %i[
+                  board_id
+                  role_id
+                ]
+              }
+
+    validates :allowed,
+              inclusion: {
+                in: [
+                  true,
+                  false
+                ]
+              }
+  end
+end

data/app/models/rails_den/board_role_requirement.rb

@@ -0,0 +1,16 @@
+module RailsDen
+  class BoardRoleRequirement < ApplicationRecord
+    belongs_to :board,
+               class_name: "RailsDen::Board",
+               inverse_of: :board_role_requirements
+
+    belongs_to :role,
+               class_name: "RailsDen::Role",
+               inverse_of: :board_role_requirements
+
+    validates :role_id,
+              uniqueness: {
+                scope: :board_id
+              }
+  end
+end

data/app/models/rails_den/board_sponsorship.rb

@@ -0,0 +1,21 @@
+module RailsDen
+  class BoardSponsorship < ApplicationRecord
+    def self.inverse_association_name = :board_sponsorships
+
+    include Sponsorship
+
+    belongs_to :board,
+               class_name: "RailsDen::Board",
+               inverse_of: :board_sponsorships
+
+    private
+
+    def overlap_scope
+      { board_id: board_id }
+    end
+
+    def overlap_error_message
+      "Dates overlap an existing sponsorship for this board"
+    end
+  end
+end

data/app/models/rails_den/bookmark.rb

@@ -0,0 +1,31 @@
+module RailsDen
+  class Bookmark < ApplicationRecord
+    belongs_to :bookmarker, polymorphic: true
+    belongs_to :bookmarkable, polymorphic: true
+
+    validates :bookmarkable_type,
+              inclusion: {
+                in: %w[RailsDen::Topic RailsDen::Post],
+                message: "must be a topic or post"
+              }
+
+    validates :bookmarkable_id,
+              uniqueness: {
+                scope: %i[bookmarker_type bookmarker_id bookmarkable_type]
+              }
+
+    validates :note,
+              length: {
+                maximum: 2_000
+              },
+              allow_nil: true
+
+    before_validation :normalize_note
+
+    private
+
+    def normalize_note
+      self.note = note.to_s.strip.presence
+    end
+  end
+end

data/app/models/rails_den/category.rb

@@ -0,0 +1,81 @@
+module RailsDen
+  class Category < ApplicationRecord
+    include RailsDen::Sluggable
+
+    has_many :boards,
+             dependent: :restrict_with_error
+
+    has_many :category_role_requirements,
+             class_name: "RailsDen::CategoryRoleRequirement",
+             inverse_of: :category,
+             dependent: :destroy
+
+    has_many :category_sponsorships,
+             class_name: "RailsDen::CategorySponsorship",
+             inverse_of: :category,
+             dependent: :restrict_with_error
+
+    enum :visibility,
+         {
+           public: "public",
+           private: "private"
+         },
+         prefix: true
+
+    validates :title,
+              presence: true
+
+    validates :slug,
+              presence: true,
+              uniqueness: true,
+              format: {
+                with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/,
+                message: "must contain only lowercase letters, numbers, and hyphens"
+              }
+
+    validates :position,
+              numericality: {
+                only_integer: true,
+                greater_than_or_equal_to: 0
+              }
+
+    scope :ordered, -> { order(:position, :id) }
+
+    after_commit :enqueue_member_profile_stats_refreshes,
+                 on: :update,
+                 if: -> {
+                   previous_changes.key?("enabled") ||
+                     previous_changes.key?("visibility")
+                 }
+
+    def self.model_name
+      @model_name ||= ActiveModel::Name.new(
+        self,
+        nil,
+        "RailsDen::Category"
+      )
+    end
+
+    private
+
+    def enqueue_member_profile_stats_refreshes
+      affected_topics = Topic.joins(:board).where(
+        rails_den_boards: {
+          category_id: id
+        }
+      )
+
+      MemberProfileStatsRefreshJob.enqueue_for_authors(
+        affected_topics
+      )
+
+      MemberProfileStatsRefreshJob.enqueue_for_authors(
+        Post.joins(topic: :board).where(
+          rails_den_boards: {
+            category_id: id
+          }
+        )
+      )
+    end
+  end
+end

data/app/models/rails_den/category_role_requirement.rb

@@ -0,0 +1,16 @@
+module RailsDen
+  class CategoryRoleRequirement < ApplicationRecord
+    belongs_to :category,
+               class_name: "RailsDen::Category",
+               inverse_of: :category_role_requirements
+
+    belongs_to :role,
+               class_name: "RailsDen::Role",
+               inverse_of: :category_role_requirements
+
+    validates :role_id,
+              uniqueness: {
+                scope: :category_id
+              }
+  end
+end

data/app/models/rails_den/category_sponsorship.rb

@@ -0,0 +1,21 @@
+module RailsDen
+  class CategorySponsorship < ApplicationRecord
+    def self.inverse_association_name = :category_sponsorships
+
+    include Sponsorship
+
+    belongs_to :category,
+               class_name: "RailsDen::Category",
+               inverse_of: :category_sponsorships
+
+    private
+
+    def overlap_scope
+      { category_id: category_id }
+    end
+
+    def overlap_error_message
+      "Dates overlap an existing sponsorship for this category"
+    end
+  end
+end

data/app/models/rails_den/chat_channel.rb

@@ -0,0 +1,44 @@
+module RailsDen
+  class ChatChannel < ApplicationRecord
+    include RailsDen::Sluggable
+
+    belongs_to :created_by,
+               polymorphic: true
+
+    has_many :chat_channel_memberships,
+             class_name: "RailsDen::ChatChannelMembership",
+             inverse_of: :chat_channel,
+             dependent: :destroy
+
+    has_many :chat_messages,
+             class_name: "RailsDen::ChatMessage",
+             inverse_of: :chat_channel,
+             dependent: :destroy
+
+    has_many :chat_channel_read_states,
+             class_name: "RailsDen::ChatChannelReadState",
+             inverse_of: :chat_channel,
+             dependent: :destroy
+
+    enum :visibility,
+         {
+           public: "public",
+           private: "private"
+         },
+         prefix: true
+
+    validates :title,
+              presence: true
+
+    validates :slug,
+              presence: true,
+              uniqueness: true,
+              format: {
+                with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/,
+                message: "must contain only lowercase letters, numbers, and hyphens"
+              }
+
+    validates :created_by,
+              presence: true
+  end
+end

data/app/models/rails_den/chat_channel_membership.rb

@@ -0,0 +1,21 @@
+module RailsDen
+  class ChatChannelMembership < ApplicationRecord
+    belongs_to :chat_channel,
+               class_name: "RailsDen::ChatChannel",
+               inverse_of: :chat_channel_memberships
+
+    belongs_to :member,
+               polymorphic: true
+
+    validates :member,
+              presence: true
+
+    validates :member_id,
+              uniqueness: {
+                scope: %i[
+                  chat_channel_id
+                  member_type
+                ]
+              }
+  end
+end