rails_den 2.0.0

data/app/models/rails_den/chat_channel_read_state.rb

@@ -0,0 +1,100 @@
+module RailsDen
+  class ChatChannelReadState < ApplicationRecord
+    belongs_to :chat_channel,
+               class_name: "RailsDen::ChatChannel"
+
+    belongs_to :reader,
+               polymorphic: true
+
+    belongs_to :last_read_chat_message,
+               class_name: "RailsDen::ChatMessage",
+               optional: true
+
+    validates :reader_id,
+              uniqueness: {
+                scope: %i[
+                  chat_channel_id
+                  reader_type
+                ]
+              }
+
+    validate :last_read_chat_message_belongs_to_channel
+
+    def advance_through!(message)
+      ensure_message_belongs_to_channel!(message)
+
+      with_lock do
+        if last_read_chat_message.nil? || message_after?(message, last_read_chat_message)
+          update!(last_read_chat_message: message)
+        end
+      end
+
+      self
+    end
+
+    def read?(message)
+      ensure_message_belongs_to_channel!(message)
+
+      last_read_chat_message.present? &&
+        !message_after?(message, last_read_chat_message)
+    end
+
+    def unread_messages
+      messages =
+        chat_channel
+          .chat_messages
+          .order(
+            :created_at,
+            :id
+          )
+
+      return messages unless last_read_chat_message
+
+      table = ChatMessage.arel_table
+      marker = last_read_chat_message
+
+      messages.where(
+        table[:created_at]
+          .gt(marker.created_at)
+          .or(
+            table[:created_at]
+              .eq(marker.created_at)
+              .and(
+                table[:id].gt(marker.id)
+              )
+          )
+      )
+    end
+
+    def unread_count
+      unread_messages.count
+    end
+
+    private
+
+    def ensure_message_belongs_to_channel!(message)
+      return if message&.chat_channel_id == chat_channel_id
+
+      raise ArgumentError,
+            "message must belong to the same chat channel"
+    end
+
+    def message_after?(candidate, marker)
+      candidate.created_at > marker.created_at ||
+        (
+          candidate.created_at == marker.created_at &&
+          candidate.id > marker.id
+        )
+    end
+
+    def last_read_chat_message_belongs_to_channel
+      return if last_read_chat_message.blank? || chat_channel.blank?
+      return if last_read_chat_message.chat_channel_id == chat_channel_id
+
+      errors.add(
+        :last_read_chat_message,
+        "must belong to the same chat channel"
+      )
+    end
+  end
+end

data/app/models/rails_den/chat_message.rb

@@ -0,0 +1,37 @@
+module RailsDen
+  class ChatMessage < ApplicationRecord
+    belongs_to :chat_channel,
+               class_name: "RailsDen::ChatChannel",
+               inverse_of: :chat_messages
+
+    belongs_to :author,
+               polymorphic: true
+
+    validates :author,
+              presence: true
+
+    validates :body,
+              presence: true,
+              length: {
+                maximum: 50_000
+              }
+
+    scope :pinned,
+          -> {
+            where(
+              pinned: true
+            )
+          }
+
+    after_commit :broadcast_creation,
+                 on: :create
+
+    private
+
+    def broadcast_creation
+      RailsDen::Chat::Broadcaster.message_created!(
+        self
+      )
+    end
+  end
+end

data/app/models/rails_den/community_read_state.rb

@@ -0,0 +1,52 @@
+module RailsDen
+  class CommunityReadState < ApplicationRecord
+    belongs_to :reader, polymorphic: true
+
+    belongs_to :last_read_post,
+               class_name: "RailsDen::Post",
+               optional: true
+
+    def self.for(reader)
+      find_by(reader: reader)
+    end
+
+    def self.mark_all_read!(reader:)
+      marker =
+        Post
+          .order(
+            "rails_den_posts.created_at DESC",
+            "rails_den_posts.id DESC"
+          )
+          .first
+
+      read_state =
+        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 advance_through!(post)
+      return self if post.nil?
+
+      with_lock do
+        if last_read_post.nil? || post_after?(post, last_read_post)
+          update!(last_read_post: post)
+        end
+      end
+
+      self
+    end
+
+    private
+
+    def post_after?(candidate, marker)
+      candidate.created_at > marker.created_at ||
+        (
+          candidate.created_at == marker.created_at &&
+          candidate.id > marker.id
+        )
+    end
+  end
+end

data/app/models/rails_den/community_sponsorship.rb

@@ -0,0 +1,15 @@
+module RailsDen
+  class CommunitySponsorship < ApplicationRecord
+    def self.inverse_association_name = :community_sponsorships
+
+    include Sponsorship
+
+    private
+
+    def overlap_scope = nil
+
+    def overlap_error_message
+      "Dates overlap an existing community sponsorship"
+    end
+  end
+end

data/app/models/rails_den/member_profile.rb

@@ -0,0 +1,113 @@
+module RailsDen
+  class MemberProfile < ApplicationRecord
+    belongs_to :profile_owner,
+               polymorphic: true
+
+    has_many :profile_field_values,
+             class_name: "RailsDen::ProfileFieldValue",
+             inverse_of: :member_profile,
+             dependent: :destroy
+
+    has_many :profile_fields,
+             through: :profile_field_values,
+             source: :profile_field
+
+    has_one_attached :avatar do |attachable|
+      attachable.variant :small,
+                         resize_to_fill: [ 48, 48 ],
+                         format: :webp
+
+      attachable.variant :medium,
+                         resize_to_fill: [ 96, 96 ],
+                         format: :webp
+
+      attachable.variant :large,
+                         resize_to_fill: [ 192, 192 ],
+                         format: :webp
+    end
+
+    before_validation :disable_current_board_when_presence_hidden
+
+    validates :profile_owner_type,
+              :profile_owner_id,
+              presence: true
+
+    validates :profile_owner_id,
+              uniqueness: {
+                scope: :profile_owner_type
+              }
+
+    validates :bio,
+              length: {
+                maximum: 2_000
+              }
+
+    validates :hide_followed_content,
+              :show_presence,
+              :show_current_board,
+              inclusion: {
+                in: [ true, false ]
+              }
+
+    validates :topics_count,
+              :posts_count,
+              :reputation_points,
+              numericality: {
+                only_integer: true,
+                greater_than_or_equal_to: 0
+              }
+
+    validate :avatar_is_available_and_valid
+
+    class << self
+      def avatar_storage_available?
+        connection.data_source_exists?("active_storage_blobs") &&
+          connection.data_source_exists?("active_storage_attachments") &&
+          connection.data_source_exists?("active_storage_variant_records")
+      rescue ActiveRecord::StatementInvalid
+        false
+      end
+
+      def for_presence!(identity)
+        find_or_create_by!(
+          profile_owner: identity
+        )
+      end
+    end
+
+    private
+
+    def disable_current_board_when_presence_hidden
+      self.show_current_board = false unless show_presence?
+    end
+
+    def avatar_is_available_and_valid
+      return unless self.class.avatar_storage_available?
+      return unless avatar.attached?
+
+      unless avatar.blob.content_type.in?(%w[
+        image/jpeg
+        image/png
+        image/webp
+        image/gif
+      ])
+        errors.add(
+          :avatar,
+          "must be a JPEG, PNG, WebP, or GIF image"
+        )
+      end
+
+      if avatar.blob.byte_size > 5.megabytes
+        errors.add(
+          :avatar,
+          "must be 5 MB or smaller"
+        )
+      end
+    rescue ActiveRecord::StatementInvalid
+      errors.add(
+        :avatar,
+        "storage is not installed; run the Active Storage migrations"
+      )
+    end
+  end
+end

data/app/models/rails_den/mention.rb

@@ -0,0 +1,20 @@
+module RailsDen
+  class Mention < ApplicationRecord
+    belongs_to :post,
+               class_name: "RailsDen::Post",
+               inverse_of: :mentions
+
+    belongs_to :mentioned,
+               polymorphic: true
+
+    validates :mentioned_type,
+              :mentioned_id,
+              :mention_name,
+              presence: true
+
+    validates :mention_name,
+              uniqueness: {
+                scope: :post_id
+              }
+  end
+end

data/app/models/rails_den/moderation_event.rb

@@ -0,0 +1,16 @@
+module RailsDen
+  class ModerationEvent < ApplicationRecord
+    belongs_to :actor, polymorphic: true, optional: true
+    belongs_to :subject, polymorphic: true
+    belongs_to :report, optional: true
+    belongs_to :scope_board, class_name: "RailsDen::Board", optional: true
+
+    validates :action, :actor_label, :subject_label, presence: true
+    validates :dedupe_key, uniqueness: true, allow_nil: true
+
+    serialize :metadata, coder: JSON
+
+    before_update { throw(:abort) }
+    before_destroy { throw(:abort) }
+  end
+end

data/app/models/rails_den/moderation_note.rb

@@ -0,0 +1,11 @@
+module RailsDen
+  class ModerationNote < ApplicationRecord
+    belongs_to :subject, polymorphic: true
+    belongs_to :author, polymorphic: true
+
+    validates :body, presence: true, length: { maximum: 10_000 }
+
+    before_update { throw(:abort) }
+    before_destroy { throw(:abort) }
+  end
+end

data/app/models/rails_den/notification.rb

@@ -0,0 +1,33 @@
+module RailsDen
+  class Notification < ApplicationRecord
+    belongs_to :notification_event,
+               class_name: "RailsDen::NotificationEvent"
+
+    belongs_to :recipient,
+               polymorphic: true
+
+    after_commit :broadcast_notification_change,
+                 on: %i[
+                   create
+                   update
+                   destroy
+                 ]
+
+    private
+
+    def broadcast_notification_change
+      removed_notification_ids =
+        if destroyed?
+          [id]
+        else
+          []
+        end
+
+      RailsDen::Notifications::Broadcaster.call(
+        recipient: recipient,
+        removed_notification_ids:
+          removed_notification_ids
+      )
+    end
+  end
+end

data/app/models/rails_den/notification_event.rb

@@ -0,0 +1,40 @@
+module RailsDen
+  class NotificationEvent < ApplicationRecord
+    EVENT_TYPES = %w[
+      topic_created
+      post_created
+      post_replied
+      post_quoted
+      post_mentioned
+      post_reacted
+      private_message_received
+      badge_awarded
+      trust_level_reached
+      report_created
+      warning_issued
+      restriction_created
+      restriction_expired
+      restriction_lifted
+    ].freeze
+
+    belongs_to :actor, polymorphic: true
+    belongs_to :subject, polymorphic: true
+    belongs_to :target,
+               polymorphic: true,
+               optional: true
+
+    has_many :notifications,
+             class_name: "RailsDen::Notification",
+             foreign_key: :notification_event_id,
+             dependent: :destroy
+
+    validates :event_type,
+              presence: true,
+              inclusion: {
+                in: EVENT_TYPES
+              }
+
+    validates :dedupe_key,
+              presence: true
+  end
+end

data/app/models/rails_den/notification_mute.rb

@@ -0,0 +1,9 @@
+module RailsDen
+  class NotificationMute < ApplicationRecord
+    belongs_to :recipient,
+               polymorphic: true
+
+    belongs_to :notifiable,
+               polymorphic: true
+  end
+end

data/app/models/rails_den/onebox_entry.rb

@@ -0,0 +1,214 @@
+require "digest"
+require "json"
+require "active_support/core_ext/hash/indifferent_access"
+
+module RailsDen
+  class OneboxEntry < ApplicationRecord
+    STATUSES = %w[
+      pending
+      resolved
+      failed
+    ].freeze
+
+    belongs_to :post,
+               class_name: "RailsDen::Post",
+               inverse_of: :onebox_entries
+
+    before_validation :normalize_source_url
+    before_validation :set_url_digest
+
+    validates :source_url,
+              presence: true
+
+    validates :url_digest,
+              presence: true,
+              format: {
+                with: /\A[0-9a-f]{64}\z/
+              },
+              uniqueness: {
+                scope: :post_id
+              }
+
+    validates :position,
+              presence: true,
+              numericality: {
+                only_integer: true,
+                greater_than_or_equal_to: 0
+              },
+              uniqueness: {
+                scope: :post_id
+              }
+
+    validates :status,
+              presence: true,
+              inclusion: {
+                in: STATUSES
+              }
+
+    validates :provider_name,
+              :kind,
+              :resolved_at,
+              presence: true,
+              if: :resolved?
+
+    validate :source_url_is_web_url
+
+    def pending?
+      status == "pending"
+    end
+
+    def resolved?
+      status == "resolved"
+    end
+
+    def failed?
+      status == "failed"
+    end
+
+    def metadata
+      raw = self[:metadata].to_s
+
+      return {}.with_indifferent_access if raw.empty?
+
+      parsed =
+        JSON.parse(raw)
+
+      unless parsed.is_a?(Hash)
+        return {}.with_indifferent_access
+      end
+
+      parsed.with_indifferent_access
+    rescue JSON::ParserError
+      {}.with_indifferent_access
+    end
+
+    def metadata=(value)
+      hash =
+        if value.respond_to?(:to_h)
+          value.to_h
+        else
+          {}
+        end
+
+      self[:metadata] =
+        JSON.generate(hash)
+    end
+
+    def apply_result!(
+      result,
+      expires_at: nil
+    )
+      unless result.is_a?(
+        RailsDen::Onebox::Result
+      )
+        raise ArgumentError,
+              "result must be a RailsDen::Onebox::Result"
+      end
+
+      assign_attributes(
+        canonical_url: result.canonical_url,
+        kind: result.kind.to_s,
+        provider_name: result.provider_name,
+        provider_url: result.provider_url,
+        title: result.title,
+        description: result.description,
+        author_name: result.author_name,
+        author_url: result.author_url,
+        site_name: result.site_name,
+        image_url: result.image_url,
+        thumbnail_url: result.thumbnail_url,
+        embed_url: result.embed_url,
+        width: result.width,
+        height: result.height,
+        published_at:
+          result.published_at&.to_s,
+        metadata: result.metadata,
+        status: "resolved",
+        resolved_at: Time.current,
+        expires_at: expires_at,
+        last_error: nil
+      )
+
+      save!
+    end
+
+    def mark_failed!(error)
+      message =
+        if error.respond_to?(:message)
+          error.message
+        else
+          error.to_s
+        end
+
+      update!(
+        status: "failed",
+        last_error: message.to_s[0, 2_000]
+      )
+    end
+
+    def mark_pending!
+      update!(
+        status: "pending",
+        last_error: nil
+      )
+    end
+
+    def result
+      return unless resolved?
+
+      RailsDen::Onebox::Result.new(
+        url: source_url,
+        canonical_url: canonical_url,
+        kind: kind,
+        provider_name: provider_name,
+        provider_url: provider_url,
+        title: title,
+        description: description,
+        author_name: author_name,
+        author_url: author_url,
+        site_name: site_name,
+        image_url: image_url,
+        thumbnail_url: thumbnail_url,
+        embed_url: embed_url,
+        width: width,
+        height: height,
+        published_at: published_at,
+        metadata: metadata
+      )
+    end
+
+    def expired?
+      expires_at.present? &&
+        expires_at <= Time.current
+    end
+
+    private
+
+    def normalize_source_url
+      self.source_url =
+        source_url.to_s.strip
+    end
+
+    def set_url_digest
+      self.url_digest =
+        if source_url.present?
+          Digest::SHA256.hexdigest(
+            source_url
+          )
+        end
+    end
+
+    def source_url_is_web_url
+      return if source_url.blank?
+
+      unless RailsDen::Onebox::Url.web?(
+        source_url
+      )
+        errors.add(
+          :source_url,
+          "must be an HTTP or HTTPS URL"
+        )
+      end
+    end
+  end
+end