collavre 0.1.0

data/app/mailers/collavre/invitation_mailer.rb

@@ -0,0 +1,16 @@
+module Collavre
+  class InvitationMailer < ApplicationMailer
+    helper Collavre::Engine.routes.url_helpers
+
+    def invite
+      @invitation = params[:invitation]
+      email = mail to: @invitation.email, subject: I18n.t("collavre.invitation_mailer.invite.subject")
+      Collavre::Email.create!(
+        email: @invitation.email,
+        subject: email.subject,
+        body: extract_body(email),
+        event: :invitation
+      )
+    end
+  end
+end

data/app/mailers/collavre/passwords_mailer.rb

@@ -0,0 +1,10 @@
+module Collavre
+  class PasswordsMailer < ApplicationMailer
+    helper Collavre::Engine.routes.url_helpers
+
+    def reset(user)
+      @user = user
+      mail subject: "Reset your password", to: user.email
+    end
+  end
+end

data/app/models/collavre/activity_log.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Collavre
+  class ActivityLog < ApplicationRecord
+    self.table_name = "activity_logs"
+
+    belongs_to :creative, class_name: "Collavre::Creative", optional: true
+    belongs_to :user, class_name: Collavre.configuration.user_class_name, optional: true
+    belongs_to :comment, class_name: "Collavre::Comment", optional: true
+
+    validates :activity, presence: true
+  end
+end

data/app/models/collavre/application_record.rb

@@ -0,0 +1,5 @@
+module Collavre
+  class ApplicationRecord < ::ApplicationRecord
+    self.abstract_class = true
+  end
+end

data/app/models/collavre/calendar_event.rb

@@ -0,0 +1,20 @@
+module Collavre
+  class CalendarEvent < ApplicationRecord
+    self.table_name = "calendar_events"
+
+    belongs_to :user, class_name: Collavre.configuration.user_class_name
+    belongs_to :creative, class_name: "Collavre::Creative", optional: true
+
+    validates :google_event_id, :start_time, :end_time, presence: true
+
+    after_commit :delete_google_event, on: :destroy
+
+    private
+
+    def delete_google_event
+      GoogleCalendarService.new(user: user).delete_event(google_event_id)
+    rescue StandardError => e
+      Rails.logger.error("Failed to delete Google event #{google_event_id}: #{e.message}")
+    end
+  end
+end

data/app/models/collavre/comment.rb

@@ -0,0 +1,307 @@
+module Collavre
+  class Comment < ApplicationRecord
+    self.table_name = "comments"
+
+    # Use non-namespaced partial path for backward compatibility
+    def to_partial_path
+      "comments/comment"
+    end
+
+    belongs_to :creative, class_name: "Collavre::Creative"
+    belongs_to :user, class_name: Collavre.configuration.user_class_name, optional: true
+    belongs_to :approver, class_name: Collavre.configuration.user_class_name, optional: true
+    belongs_to :action_executed_by, class_name: Collavre.configuration.user_class_name, optional: true
+    belongs_to :topic, class_name: "Collavre::Topic", optional: true
+    has_many :activity_logs, class_name: "Collavre::ActivityLog", dependent: :destroy
+    has_many :comment_reactions, class_name: "Collavre::CommentReaction", dependent: :destroy
+
+
+    has_many_attached :images, dependent: :purge_later
+
+    before_validation :use_origin_creative
+    before_validation :assign_default_user, on: :create
+    before_save :apply_link_previews, if: :should_apply_link_previews?
+
+    validates :content, presence: true, unless: -> { images.attached? }
+    validate :creative_must_be_origin_creative
+    validate :images_must_be_images
+
+    after_create_commit :broadcast_create, :notify_write_users, :notify_mentions, :broadcast_badges
+    after_update_commit :broadcast_update
+    after_destroy_commit :broadcast_destroy, :broadcast_badges
+
+    # public for db migration
+    def creative_snippet
+      creative.creative_snippet
+    end
+
+    def can_be_approved_by?(user)
+      approval_status(user) == :ok
+    end
+
+    def approval_status(user)
+      return :not_allowed unless user
+
+      if action.blank?
+        return :not_allowed unless approver_id == user&.id
+        return :missing_action
+      end
+
+      begin
+        payload = JSON.parse(action)
+      rescue JSON::ParserError
+        return :invalid_action_format
+      end
+      return :invalid_action_format unless payload.is_a?(Hash)
+
+      actions = Array(payload["actions"])
+      actions = [ payload ] if actions.empty?
+
+      requires_admin = actions.any? do |item|
+        next false unless item.is_a?(Hash)
+        action_type = item["action"] || item["type"]
+        action_type == "approve_tool"
+      end
+
+      if requires_admin && SystemSetting.mcp_tool_approval_required?
+        return user.system_admin? ? :ok : :admin_required
+      end
+
+      return :missing_approver if approver_id.blank?
+      return :not_allowed unless approver_id == user&.id
+
+      :ok
+    end
+
+    private
+
+    def create_inbox_item(owner, key, params = {})
+      origin = creative&.effective_origin
+      metadata = params.to_h.stringify_keys
+      metadata["comment_id"] = id
+      metadata["creative_id"] = origin&.id
+
+      InboxItem.create!(
+        owner: owner,
+        message_key: key,
+        message_params: metadata,
+        comment: self,
+        creative: origin,
+        link: Collavre::Engine.routes.url_helpers.creative_comment_url(
+          creative,
+          self,
+          Rails.application.config.action_mailer.default_url_options
+        )
+      )
+    end
+
+    def mentioned_emails
+      return [] unless content
+      content.scan(/@([\w.\-+]+@[a-zA-Z0-9\-.]+\.[a-zA-Z]{2,})/)
+             .flatten
+             .map(&:downcase)
+             .uniq
+    end
+
+    def mentioned_names
+      return [] unless content
+      content.scan(/@([^:]+):/)
+             .flatten
+             .map(&:downcase)
+             .uniq
+    end
+
+    def mentioned_users
+      return Collavre.user_class.none unless user
+      emails = mentioned_emails - [ user.email.downcase ]
+      names = mentioned_names - [ user.name.downcase ]
+
+      origin = creative.effective_origin
+      mentionable_users = Collavre.user_class.mentionable_for(origin)
+
+      scope = Collavre.user_class.none
+      scope = scope.or(mentionable_users.where(email: emails)) if emails.any?
+      scope = scope.or(mentionable_users.where("LOWER(name) IN (?)", names)) if names.any?
+      scope
+    end
+
+    def broadcast_create
+      return if private?
+      broadcast_append_later_to([ creative, :comments ], target: "comments-list", partial: "collavre/comments/comment")
+    end
+
+    def broadcast_update
+      return if private?
+      broadcast_replace_later_to([ creative, :comments ], partial: "collavre/comments/comment")
+    end
+
+    def broadcast_destroy
+      return if private? || !creative
+      broadcast_remove_to([ creative, :comments ])
+    end
+
+    def broadcast_badges
+      return unless creative
+      Comment.broadcast_badges(creative)
+    end
+
+    def notify_write_users
+      return if private? || !user
+      base_creative = creative.effective_origin
+      present_ids = CommentPresenceStore.list(base_creative.id)
+      recipients = base_creative.all_shared_users(:write).map(&:user)
+      recipients << base_creative.user
+      recipients.compact!
+      recipients.uniq!
+      recipients.delete(user)
+      recipients -= mentioned_users.to_a
+      recipients.reject! { |u| present_ids.include?(u.id) }
+      recipients.each do |recipient|
+        create_inbox_item(
+          recipient,
+          "inbox.comment_added",
+          { user: user.display_name, comment: content, creative: creative_snippet }
+        )
+      end
+    end
+
+    def notify_mentions
+      return if private?
+      mentioned_users.each do |mentioned|
+        create_inbox_item(
+          mentioned,
+          "inbox.user_mentioned",
+          { user: user.display_name, comment: content, creative: creative_snippet }
+        )
+      end
+    end
+
+    def assign_default_user
+      self.user ||= Collavre.current_user
+    end
+
+    def use_origin_creative
+      return unless creative
+      self.creative = creative.effective_origin
+    end
+
+    def creative_must_be_origin_creative
+      return unless creative
+      return unless creative.origin_id.present?
+
+      errors.add(:creative, "must be an origin creative")
+    end
+
+    def should_apply_link_previews?
+      will_save_change_to_content? && content.present?
+    end
+
+    def apply_link_previews
+      self.content = CommentLinkFormatter.new(content).format
+    rescue StandardError => e
+      Rails.logger.warn("Comment link preview formatting failed: #{e.class} #{e.message}")
+    end
+
+    def images_must_be_images
+      return unless images.attached?
+
+      invalid_images = images.reject { |image| image.blob&.content_type&.start_with?("image/") }
+      return if invalid_images.empty?
+
+      errors.add(:images, "must be an image")
+      invalid_images.each(&:purge)
+    end
+
+    def self.broadcast_badges(creative)
+      origin = creative.effective_origin
+      users = [ origin.user ].compact + origin.all_shared_users(:feedback).map(&:user)
+      users.compact!
+      users.uniq!
+      return if users.empty?
+
+      user_ids = users.map(&:id)
+
+      # Batch load all comment read pointers for these users
+      pointers = CommentReadPointer.where(user_id: user_ids, creative: origin).index_by(&:user_id)
+
+      # Get present users once
+      present_user_ids = CommentPresenceStore.list(origin.id)
+
+      # Batch count queries - get counts grouped by user visibility
+      # For public comments (visible to all)
+      public_count = origin.comments.where(private: false).count
+
+      # For private comments, get counts per user
+      private_counts = origin.comments
+        .where(private: true, user_id: user_ids)
+        .group(:user_id)
+        .count
+
+      # Batch unread counts - first get the min last_read_id per user
+      last_read_ids = pointers.transform_values { |p| p.last_read_comment_id || 0 }
+
+      # Get unread public comments for each threshold
+      unread_public_by_threshold = {}
+      last_read_ids.values.uniq.each do |threshold|
+        unread_public_by_threshold[threshold] = origin.comments
+          .where(private: false)
+          .where("comments.id > ?", threshold)
+          .count
+      end
+
+      # Get unread private comments per user
+      unread_private_counts = {}
+      user_ids.each do |uid|
+        threshold = last_read_ids[uid] || 0
+        unread_private_counts[uid] = origin.comments
+          .where(private: true, user_id: uid)
+          .where("comments.id > ?", threshold)
+          .count
+      end
+
+      users.each do |u|
+        user_private_count = private_counts[u.id] || 0
+        total_count = public_count + user_private_count
+
+        threshold = last_read_ids[u.id] || 0
+        unread_public = unread_public_by_threshold[threshold] || 0
+        unread_private = unread_private_counts[u.id] || 0
+        unread_count = unread_public + unread_private
+
+        unread_count = 0 if present_user_ids.include?(u.id)
+
+        Turbo::StreamsChannel.broadcast_replace_to(
+          [ u, origin, :comment_badge ],
+          target: "comment-badge-#{origin.id}",
+          partial: "inbox/badge_component/count",
+          locals: {
+            count: unread_count,
+            badge_id: "comment-badge-#{origin.id}",
+            show_zero: total_count.positive?
+          }
+        )
+      end
+    end
+
+    def self.broadcast_badge(creative, user)
+      origin = creative.effective_origin
+      visible_comments = origin.comments.where("comments.private = ? OR comments.user_id = ?", false, user.id)
+      comments_count = visible_comments.count
+      pointer = CommentReadPointer.find_by(user: user, creative: origin)
+      last_read_id = pointer&.last_read_comment_id
+      unread_scope = last_read_id ? visible_comments.where("comments.id > ?", last_read_id) : visible_comments
+      unread_count = unread_scope.count
+      unread_count = 0 if CommentPresenceStore.list(origin.id).include?(user.id)
+      Turbo::StreamsChannel.broadcast_replace_to(
+        [ user, origin, :comment_badge ],
+        target: "comment-badge-#{origin.id}",
+        partial: "inbox/badge_component/count",
+        locals: {
+          count: unread_count,
+          badge_id: "comment-badge-#{origin.id}",
+          show_zero: comments_count.positive?
+        }
+      )
+    end
+  end
+end

data/app/models/collavre/comment_presence_store.rb

@@ -0,0 +1,30 @@
+module Collavre
+  class CommentPresenceStore
+    KEY_PREFIX = "comment_presence:"
+
+    def self.add(creative_id, user_id)
+      ids = list(creative_id)
+      unless ids.include?(user_id)
+        ids << user_id
+        Rails.cache.write(key(creative_id), ids)
+      end
+      ids
+    end
+
+    def self.remove(creative_id, user_id)
+      ids = list(creative_id)
+      if ids.delete(user_id)
+        Rails.cache.write(key(creative_id), ids)
+      end
+      ids
+    end
+
+    def self.list(creative_id)
+      Rails.cache.read(key(creative_id)) || []
+    end
+
+    def self.key(creative_id)
+      "#{KEY_PREFIX}#{creative_id}"
+    end
+  end
+end

data/app/models/collavre/comment_reaction.rb

@@ -0,0 +1,11 @@
+module Collavre
+  class CommentReaction < ApplicationRecord
+    self.table_name = "comment_reactions"
+
+    belongs_to :comment, class_name: "Collavre::Comment"
+    belongs_to :user, class_name: Collavre.configuration.user_class_name
+
+    validates :emoji, presence: true, length: { maximum: 16 }
+    validates :user_id, uniqueness: { scope: [ :comment_id, :emoji ] }
+  end
+end

data/app/models/collavre/comment_read_pointer.rb

@@ -0,0 +1,26 @@
+module Collavre
+  class CommentReadPointer < ApplicationRecord
+    self.table_name = "comment_read_pointers"
+
+    belongs_to :user, class_name: Collavre.configuration.user_class_name
+    belongs_to :creative, class_name: "Collavre::Creative"
+    belongs_to :last_read_comment, class_name: "Collavre::Comment", optional: true
+
+    validates :user_id, uniqueness: { scope: :creative_id }
+
+    def effective_comment_id(sorted_visible_ids)
+      return nil unless last_read_comment_id
+
+      # Find the nearest visible comment ID <= last_read_comment_id
+      idx = sorted_visible_ids.bsearch_index { |x| x > last_read_comment_id }
+
+      if idx
+        # If idx is 0, target is smaller than all visible IDs
+        idx > 0 ? sorted_visible_ids[idx - 1] : nil
+      else
+        # target is >= all visible IDs
+        sorted_visible_ids.last
+      end
+    end
+  end
+end

data/app/models/collavre/contact.rb

@@ -0,0 +1,23 @@
+module Collavre
+  class Contact < ApplicationRecord
+    self.table_name = "contacts"
+
+    belongs_to :user, class_name: Collavre.configuration.user_class_name
+    belongs_to :contact_user, class_name: Collavre.configuration.user_class_name
+
+    validates :user_id, uniqueness: { scope: :contact_user_id }
+    validate :cannot_add_self
+
+    def self.ensure(user:, contact_user:)
+      return if user.nil? || contact_user.nil? || user == contact_user
+
+      find_or_create_by!(user: user, contact_user: contact_user)
+    end
+
+    private
+
+    def cannot_add_self
+      errors.add(:contact_user, :invalid) if user_id.present? && contact_user_id.present? && user_id == contact_user_id
+    end
+  end
+end