collavre 0.5.0 → 0.7.0

data/app/controllers/concerns/collavre/users_controller/ai_user_management.rb

@@ -0,0 +1,119 @@
+module Collavre
+  module UsersController::AiUserManagement
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :set_user_for_ai_actions, only: [ :edit_ai, :update_ai ]
+      before_action :verify_ai_user, only: [ :edit_ai, :update_ai ]
+      before_action :verify_ai_user_authorization, only: [ :update_ai ]
+    end
+
+    def new_ai
+      @available_tools = load_available_tools
+
+      if params[:copy_from].present?
+        source = Collavre::User.find_by(id: params[:copy_from])
+        if source&.ai_user? && source.created_by_id == Current.user.id
+          @copy_source = source
+          @copy_name = "#{source.name} (copy)"
+        end
+      end
+    end
+
+    def create_ai
+      ai_id = params[:ai_id].to_s.strip.downcase
+      email = "#{ai_id}@ai.local"
+      searchable = ActiveModel::Type::Boolean.new.cast(params.fetch(:searchable, false))
+
+      @user = Collavre::User.new(
+        name: params[:name],
+        email: email,
+        password: SecureRandom.hex(36),
+        system_prompt: params[:system_prompt],
+        llm_vendor: params[:llm_vendor].presence || "google",
+        llm_model: params[:llm_model],
+        llm_api_key: params[:llm_api_key],
+        gateway_url: params[:gateway_url],
+        tools: params[:tools] || [],
+        searchable: searchable,
+        email_verified_at: Time.current,
+        created_by_id: Current.user.id,
+        routing_expression: params[:routing_expression]
+      )
+      @user.agent_conf = params[:agent_conf] if @user.respond_to?(:agent_conf=) && params[:agent_conf].present?
+
+      if @user.save
+        Collavre::Contact.ensure(user: Current.user, contact_user: @user)
+        share_ai_agent_to_creative(@user, params[:creative_id])
+        redirect_to user_path(Current.user, tab: "contacts"), notice: I18n.t("collavre.users.create_ai.success")
+      else
+        flash.now[:alert] = @user.errors.full_messages.to_sentence
+        @available_tools = load_available_tools
+        render :new_ai, status: :unprocessable_entity
+      end
+    end
+
+    def edit_ai
+      @available_tools = load_available_tools
+    end
+
+    def update_ai
+      ai_params = params.require(:user).permit(:name, :system_prompt, :llm_vendor, :llm_model, :llm_api_key, :gateway_url, :searchable, :routing_expression, :agent_conf, tools: [])
+
+      if @user.update(ai_params)
+        redirect_to edit_ai_user_path(@user), notice: I18n.t("collavre.users.update_ai.success")
+      else
+        @available_tools = load_available_tools
+        flash.now[:alert] = @user.errors.full_messages.to_sentence
+        render :edit_ai, status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    def load_available_tools
+      Collavre::McpService.available_tools(Current.user).map do |tool|
+        {
+          name: tool[:name],
+          description: tool[:description],
+          parameters: tool[:params]
+        }
+      end
+    end
+
+    def set_user_for_ai_actions
+      @user = Collavre::User.find(params[:id])
+    end
+
+    def verify_ai_user
+      unless @user.ai_user?
+        redirect_to user_path(@user), alert: I18n.t("collavre.users.edit_ai.not_an_ai")
+      end
+    end
+
+    def verify_ai_user_authorization
+      allowed = Current.user.system_admin? ||
+                (@user.ai_user? && @user.created_by_id == Current.user.id)
+
+      unless allowed
+        fallback = user_path(Current.user, tab: "contacts")
+        redirect_back fallback_location: fallback, alert: I18n.t("collavre.users.destroy.not_authorized")
+      end
+    end
+
+    def share_ai_agent_to_creative(user, creative_id)
+      return if creative_id.blank?
+
+      creative = Collavre::Creative.find_by(id: creative_id)
+      return unless creative&.has_permission?(Current.user, :admin)
+
+      Collavre::CreativeShare.find_or_create_by!(
+        creative: creative,
+        user: user
+      ) do |share|
+        share.shared_by = Current.user
+        share.permission = :feedback
+      end
+    end
+  end
+end

data/app/controllers/concerns/collavre/users_controller/contact_management.rb

@@ -0,0 +1,166 @@
+module Collavre
+  module UsersController::ContactManagement
+    extend ActiveSupport::Concern
+
+    def search
+      term = params[:q].to_s.strip.downcase
+
+      if term.blank? && params[:scope] != "contacts"
+        return render json: []
+      end
+
+      creative = Collavre::Creative.find_by(id: params[:creative_id])
+
+      if creative.present? && !creative.has_permission?(Current.user, :read)
+        head :forbidden and return
+      end
+
+      scope = if params[:scope] == "contacts" && Current.user
+        # Include both contacts and searchable users (e.g., AI agents with searchable=true)
+        contact_ids = Current.user.contact_users.select(:id)
+        searchable_ids = Collavre::User.where(searchable: true).select(:id)
+        Collavre::User.where(id: contact_ids).or(Collavre::User.where(id: searchable_ids))
+      else
+        Collavre::User.mentionable_for(creative)
+      end
+
+      users = scope
+      if term.present?
+        users = users.where("LOWER(users.email) LIKE :term OR LOWER(users.name) LIKE :term", term: "#{term}%")
+      end
+
+      limit = params[:limit].to_i
+      limit = 20 if limit <= 0
+      limit = 50 if limit > 50
+
+      user_ids = users.select(:id).distinct.limit(limit).pluck(:id)
+      users = Collavre::User.where(id: user_ids)
+      render json: users.map { |u| { id: u.id, name: u.display_name, email: u.email, avatar_url: view_context.user_avatar_url(u, size: 20) } }
+    end
+
+    private
+
+    def prepare_contacts
+      per_page = 20
+      @contact_page = [ params[:contact_page].to_i, 1 ].max
+
+      creative_shares = Collavre::CreativeShare.arel_table
+      creatives = Collavre::Creative.arel_table
+
+      user_creative_origins_sql = Collavre::Creative
+        .where(user_id: Current.user.id)
+        .select("COALESCE(origin_id, id) AS origin_id")
+        .to_sql
+
+      shared_by_me_scope = Collavre::CreativeShare
+        .joins(:creative)
+        .where.not(permission: Collavre::CreativeShare.permissions[:no_access])
+        .where(
+          creative_shares[:shared_by_id].eq(Current.user.id)
+            .or(
+              creative_shares[:shared_by_id].eq(nil).and(creatives[:user_id].eq(Current.user.id))
+            )
+            .or(
+              creatives[:id].in(Arel.sql("(#{user_creative_origins_sql})"))
+            )
+        )
+
+      shared_with_me_scope = Collavre::CreativeShare
+        .joins(:creative)
+        .where(user_id: Current.user.id)
+        .where.not(permission: Collavre::CreativeShare.permissions[:no_access])
+
+      contact_ids_sql = [
+        Current.user.contacts.select("contact_user_id AS user_id").to_sql,
+        shared_by_me_scope.select("creative_shares.user_id AS user_id").to_sql,
+        shared_with_me_scope.select("COALESCE(creative_shares.shared_by_id, creatives.user_id) AS user_id").to_sql
+      ].join(" UNION ")
+
+      contact_users_relation = Collavre::User.where(
+        id: Collavre::User.from("(#{contact_ids_sql}) AS contact_ids").select(:user_id)
+      )
+
+      @total_contacts = contact_users_relation.count
+      @total_contact_pages = [ (@total_contacts.to_f / per_page).ceil, 1 ].max
+      paged_users = contact_users_relation
+        .includes(avatar_attachment: :blob)
+        .order(:name, :id)
+        .offset((@contact_page - 1) * per_page)
+        .limit(per_page)
+
+      existing_contacts = Current.user.contacts.includes(contact_user: [ avatar_attachment: :blob ]).index_by(&:contact_user_id)
+      @contacts = paged_users.map do |user|
+        existing_contacts[user.id] || Collavre::Contact.new(user: Current.user, contact_user: user)
+      end
+
+      shares_from_me = shared_by_me_scope
+        .where(user_id: paged_users.map(&:id))
+        .includes(:creative)
+
+      @shared_by_me = shares_from_me.group_by(&:user_id).transform_values { |shares| shares.map(&:creative) }
+
+      shares_to_me = Collavre::CreativeShare
+        .joins(:creative)
+        .where(user_id: Current.user.id)
+        .where.not(permission: Collavre::CreativeShare.permissions[:no_access])
+        .where(
+          creative_shares[:shared_by_id].in(paged_users.map(&:id))
+            .or(creative_shares[:shared_by_id].eq(nil).and(creatives[:user_id].in(paged_users.map(&:id))))
+        )
+        .includes(:creative)
+
+      @shared_with_me = shares_to_me.group_by(&:sharer_id)
+                                    .transform_values { |shares| shares.map(&:creative) }
+    end
+
+    def prepare_org_chart
+      # 1. Creatives with actual shares relevant to current user
+      shared_creative_ids = Collavre::Creative.shared_accessible_ids(Current.user)
+
+      # 2. Walk up ancestor chains to build full paths (A > B > C)
+      all_tree_ids = Set.new(shared_creative_ids)
+      Collavre::Creative.where(id: shared_creative_ids).find_each do |creative|
+        creative.ancestors.each { |a| all_tree_ids.add(a.id) }
+      end
+
+      # 3. Build the tree
+      all_creatives = Collavre::Creative.where(id: all_tree_ids.to_a).order(:sequence, :id)
+      @org_chart_roots = all_creatives.select { |c| c.parent_id.nil? || !all_tree_ids.include?(c.parent_id) }
+      @org_chart_children = all_creatives.select { |c| c.parent_id.present? && all_tree_ids.include?(c.parent_id) }.group_by(&:parent_id)
+
+      # 4. Preload shares (including origin shares for linked creatives)
+      origin_ids = all_creatives.filter_map(&:origin_id).uniq
+      share_lookup_ids = (all_tree_ids.to_a + origin_ids).uniq
+      shares = Collavre::CreativeShare
+        .where(creative_id: share_lookup_ids)
+        .includes(user: [ avatar_attachment: :blob ], shared_by: [ avatar_attachment: :blob ])
+      shares_by_creative = shares.group_by(&:creative_id)
+
+      # Map shares: linked creatives inherit from origin if they have no direct shares
+      @org_chart_shares = {}
+      all_creatives.each do |c|
+        direct = shares_by_creative.fetch(c.id, [])
+        if direct.empty? && c.origin_id.present?
+          @org_chart_shares[c.id] = shares_by_creative.fetch(c.origin_id, [])
+        else
+          @org_chart_shares[c.id] = direct
+        end
+      end
+
+      # 5. Preload pending invitations
+      @org_chart_invitations = Collavre::Invitation
+        .where(creative_id: all_tree_ids.to_a, accepted_at: nil)
+        .where("expires_at > ?", Time.current)
+        .order(created_at: :desc)
+        .group_by(&:creative_id)
+
+      # 6. Unassigned AI Agents: owned by current user but not in any CreativeShare
+      assigned_user_ids = shares.map(&:user_id).uniq
+      @org_chart_unassigned = Collavre::User.where(created_by_id: Current.user.id)
+                                            .where.not(id: assigned_user_ids)
+                                            .where.not(llm_vendor: [ nil, "" ])
+                                            .includes(avatar_attachment: :blob)
+                                            .order(:name)
+    end
+  end
+end

data/app/controllers/concerns/collavre/users_controller/profile_and_settings.rb

@@ -0,0 +1,102 @@
+module Collavre
+  module UsersController::ProfileAndSettings
+    extend ActiveSupport::Concern
+
+    def show
+      @user = Collavre::User.find(params[:id])
+      @active_tab = params[:tab].presence || "profile"
+      @active_tab = "contacts" if @active_tab == "org_chart"
+      @contacts_view = params[:contacts_view].presence || "list"
+      if Current.user
+        if @contacts_view == "org_chart"
+          prepare_org_chart
+        else
+          prepare_contacts
+        end
+      else
+        @contacts = []
+        @shared_by_me = {}
+        @shared_with_me = {}
+        @total_contact_pages = 1
+        @contact_page = 1
+        @org_chart_roots = []
+        @org_chart_shares = {}
+        @org_chart_invitations = {}
+        @org_chart_children = {}
+        @org_chart_unassigned = []
+      end
+    end
+
+    def update
+      @user = Collavre::User.find(params[:id])
+      if @user.update(profile_params)
+        redirect_to user_path(@user), notice: I18n.t("collavre.users.profile_updated")
+      else
+        render :show, status: :unprocessable_entity
+      end
+    end
+
+    def notification_settings
+      if Current.user.update(notification_settings_params)
+        head :no_content
+      else
+        render json: { errors: Current.user.errors.full_messages }, status: :unprocessable_entity
+      end
+    end
+
+    def edit_password
+      @user = Collavre::User.find(params[:id])
+    end
+
+    def passkeys
+      @user = Collavre::User.find(params[:id])
+
+      unless @user == Current.user || Current.user.system_admin?
+        redirect_to user_path(Current.user), alert: I18n.t("collavre.users.destroy.not_authorized")
+      end
+    end
+
+    def update_password
+      @user = Collavre::User.find(params[:id])
+      if @user.authenticate(params[:user][:current_password])
+        if @user.update(user_params)
+          redirect_to user_path(@user), notice: I18n.t("collavre.users.password_updated")
+        else
+          flash.now[:alert] = I18n.t("collavre.users.password_update_failed")
+          render :edit_password, status: :unprocessable_entity
+        end
+      else
+        @user.errors.add(:current_password, I18n.t("collavre.users.current_password_incorrect"))
+        flash.now[:alert] = I18n.t("collavre.users.password_update_failed")
+        render :edit_password, status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    def user_params
+      params.require(:user).permit(:email, :password, :password_confirmation, :name)
+    end
+
+    def profile_params
+      params.require(:user).permit(
+        :avatar,
+        :avatar_url,
+        :display_level,
+        :completion_mark,
+        :theme,
+        :name,
+        :notifications_enabled,
+        :calendar_id,
+        :timezone,
+        :locale
+      ).tap do |p|
+        p[:locale] = normalize_supported_locale(p[:locale]) if p.key?(:locale)
+      end
+    end
+
+    def notification_settings_params
+      params.require(:user).permit(:notifications_enabled)
+    end
+  end
+end

data/app/controllers/concerns/collavre/users_controller/registration.rb

@@ -0,0 +1,63 @@
+module Collavre
+  module UsersController::Registration
+    extend ActiveSupport::Concern
+
+    included do
+      allow_unauthenticated_access only: %i[new create exists]
+      before_action -> { enforce_auth_provider!(:email) }, only: [ :new, :create ]
+    end
+
+    def new
+      @user = Collavre::User.new
+      if params[:invite_token].present?
+        @invitation = Collavre::Invitation.find_by_token_for(:invite, params[:invite_token])
+        @user.email = @invitation&.email
+      end
+    end
+
+    def create
+      @user = Collavre::User.new(user_params)
+      Collavre::Invitation.transaction do
+        if params[:invite_token].present?
+          invitation = Collavre::Invitation.find_by_token_for(:invite, params[:invite_token])
+          if invitation
+            @invitation = invitation
+            @user.email = invitation.email
+          end
+        end
+        if @user.save
+          if invitation
+            invitation.update(accepted_at: Time.current)
+            Collavre::CreativeShare.create!(
+              creative: invitation.creative,
+              user: @user,
+              permission: invitation.permission,
+              shared_by: invitation.inviter
+            )
+            Collavre::Contact.ensure(user: invitation.inviter, contact_user: @user)
+            invitation.creative.create_linked_creative_for_user(@user)
+          end
+          Collavre::EmailVerificationMailer.verify(@user).deliver_later
+          session.delete(:return_to_after_authenticating)
+          redirect_to new_session_path, notice: I18n.t("collavre.users.new.success_sign_up")
+        else
+          render :new, status: :unprocessable_entity
+        end
+      rescue ActiveSupport::MessageVerifier::InvalidSignature
+        flash.now[:alert] = I18n.t("collavre.invites.invalid")
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def exists
+      user = Collavre::User.find_by(email: params[:email])
+      render json: { exists: user.present? }
+    end
+
+    private
+
+    def user_params
+      params.require(:user).permit(:email, :password, :password_confirmation, :name)
+    end
+  end
+end

data/app/helpers/collavre/application_helper.rb

@@ -36,6 +36,7 @@ module Collavre
         styles << render_theme_media_query(dark_theme, "dark")
       end
 
+      # Safe: CSS generated from admin-configured theme settings (CSS variables only)
       styles.join("\n").html_safe # rubocop:disable Rails/OutputSafety
     end
 

data/app/helpers/collavre/creatives_helper.rb

@@ -1,10 +1,5 @@
 module Collavre
   module CreativesHelper
-    # Shared toggle button symbol helper
-    def toggle_button_symbol(expanded: false)
-      expanded ? "\u25BC" : "\u25B6" # ▼ or ▶
-    end
-
     def render_tags(labels, class_name = nil, name_only = false)
       return "" if labels&.empty? or labels.nil?
 
@@ -13,8 +8,11 @@ module Collavre
         suffix = " 🗓#{label.target_date}" if label.type == "Plan" and !name_only
         index += 1
         content_tag(:span, class: "tag") do
-          (index == 1 ? "" : " ").html_safe +
-          link_to("##{strip_tags(label.name)}", collavre.creatives_path(tags: [ label.id ]), class: class_name ? class_name: "", title: strip_tags(label.name)) + suffix
+          safe_join([
+            (index == 1 ? "" : " "),
+            link_to("##{strip_tags(label.name)}", collavre.creatives_path(tags: [ label.id ]), class: class_name ? class_name: "", title: strip_tags(label.name)),
+            suffix
+          ].compact)
         end
       end)
     end
@@ -67,9 +65,14 @@ module Collavre
             class: classes.join(" ")
           )
         else
-          "".html_safe
+          safe_join([])
         end
-        render_progress_value(progress_value) + comment_part + "<br />".html_safe + (creative.tags ? render_creative_tags(creative) : "".html_safe)
+        safe_join([
+          render_progress_value(progress_value),
+          comment_part,
+          tag.br,
+          (creative.tags ? render_creative_tags(creative) : safe_join([]))
+        ])
       end
     end
 

data/app/helpers/collavre/navigation_helper.rb

@@ -103,7 +103,7 @@ module Collavre
 
     def render_nav_raw(item)
       content = resolve_nav_value(item[:content])
-      return "".html_safe if content.nil?
+      return safe_join([]) if content.nil?
       content.respond_to?(:html_safe?) && content.html_safe? ? content : ERB::Util.html_escape(content)
     end
 

data/app/javascript/collavre.js

@@ -11,7 +11,6 @@ import "./modules/export_to_markdown"
 import "./modules/plans_menu"
 import "./modules/inbox_panel"
 import "./modules/creative_guide"
-import "./modules/share_modal"
 import "./modules/creative_row_editor"
 import "./modules/slide_view"
 

data/app/javascript/controllers/comment_controller.js

@@ -8,7 +8,7 @@ if (!window._streamingCommentIds) window._streamingCommentIds = new Set()
 
 // Connects to data-controller="comment"
 export default class extends Controller {
-  static targets = ["ownerButton", "deleteButton", "approveButton", "actionApproveControls", "reviewButton", "replaceButton"]
+  static targets = ["ownerButton", "deleteButton", "approveButton", "actionApproveControls"]
 
   get _commentId() {
     return this.element.dataset.commentId
@@ -123,10 +123,6 @@ export default class extends Controller {
     this.handleMouseUp = this.handleMouseUp.bind(this)
     this.element.addEventListener('mouseup', this.handleMouseUp)
 
-    // Bound handlers for review/replace buttons (stored for cleanup)
-    this._boundReviewClick = this._onReviewClick.bind(this)
-    this._boundReplaceClick = this._onReplaceClick.bind(this)
-
     this.currentUserId = document.body.dataset.currentUserId
     const commentAuthorId = this.element.dataset.userId
     const creativeOwnerId = this.element.dataset.creativeOwnerId
@@ -228,7 +224,6 @@ export default class extends Controller {
       this._streamingTimeout = null
     }
     this.element.removeEventListener('mouseup', this.handleMouseUp)
-    this._removeSelectionChangeListener()
     this.hideReviewPopup()
     if (this._reviewPopupEl) {
       this._reviewPopupEl.remove()
@@ -291,7 +286,7 @@ export default class extends Controller {
         const commentId = this.element.dataset.commentId
         const formController = this.findFormController()
         if (formController) {
-          formController.quoteComment(commentId, selectedText)
+          formController.appendReviewQuote(commentId, selectedText)
         }
         window.getSelection().removeAllRanges()
         this.hideReviewPopup()
@@ -324,52 +319,43 @@ export default class extends Controller {
     return this.application.getControllerForElementAndIdentifier(popup, 'comments--form')
   }
 
-  reviewButtonTargetConnected(button) {
-    button.addEventListener('click', this._boundReviewClick)
-  }
-
-  reviewButtonTargetDisconnected(button) {
-    button.removeEventListener('click', this._boundReviewClick)
-  }
-
-  replaceButtonTargetConnected(button) {
-    button.addEventListener('click', this._boundReplaceClick)
-    // Only listen for selectionchange when a replace button exists
-    this._addSelectionChangeListener()
-  }
-
-  replaceButtonTargetDisconnected(button) {
-    button.removeEventListener('click', this._boundReplaceClick)
-    if (!this.hasReplaceButtonTarget) {
-      this._removeSelectionChangeListener()
-    }
-  }
-
-  _onReviewClick(event) {
+  // Stimulus action: click->comment#reviewClick (bound via data-action in template)
+  reviewClick(event) {
     event.preventDefault()
-    event.stopPropagation()
-    const commentId = this.element.dataset.commentId
-    const contentEl = this.element.querySelector('.comment-content')
-    const fullText = contentEl ? contentEl.textContent.trim() : ''
-    const formController = this.findFormController()
-    if (formController && fullText) {
-      formController.quoteComment(commentId, fullText)
-    }
-  }
-
-  _onReplaceClick(event) {
-    event.preventDefault()
-    event.stopPropagation()
     const selectedText = this._getSelectedTextInContent()
-    if (!selectedText) return
-
+    if (!selectedText) {
+      this._showReviewHint(event.currentTarget)
+      return
+    }
     const commentId = this.element.dataset.commentId
     const formController = this.findFormController()
     if (formController) {
-      formController.quoteComment(commentId, selectedText)
+      formController.appendReviewQuote(commentId, selectedText)
+      const textarea = formController.textareaTarget
+      if (textarea) {
+        textarea.scrollIntoView({ behavior: 'smooth', block: 'center' })
+        textarea.focus()
+        textarea.selectionStart = textarea.selectionEnd = textarea.value.length
+      }
     }
     window.getSelection().removeAllRanges()
-    this._updateReplaceButton()
+  }
+
+  _showReviewHint(button) {
+    // Remove any existing hint
+    document.querySelectorAll('.review-hint').forEach(el => el.remove())
+
+    // Show hint popup near the button using fixed positioning
+    const rect = button.getBoundingClientRect()
+    const hint = document.createElement('div')
+    hint.className = 'review-hint'
+    hint.textContent = button.dataset.hintText || 'Select text to review'
+    hint.style.position = 'fixed'
+    hint.style.top = `${rect.top - 8}px`
+    hint.style.left = `${rect.left + rect.width / 2}px`
+    hint.style.transform = 'translate(-50%, -100%)'
+    document.body.appendChild(hint)
+    hint.addEventListener('animationend', () => hint.remove(), { once: true })
   }
 
   _getSelectedTextInContent() {
@@ -388,30 +374,7 @@ export default class extends Controller {
     return text
   }
 
-  _addSelectionChangeListener() {
-    if (this._selectionChangeActive) return
-    this._handleSelectionChange = this._handleSelectionChange.bind(this)
-    document.addEventListener('selectionchange', this._handleSelectionChange)
-    this._selectionChangeActive = true
-  }
-
-  _removeSelectionChangeListener() {
-    if (!this._selectionChangeActive) return
-    document.removeEventListener('selectionchange', this._handleSelectionChange)
-    this._selectionChangeActive = false
-  }
-
-  _handleSelectionChange() {
-    this._updateReplaceButton()
-  }
-
-  _updateReplaceButton() {
-    if (!this.hasReplaceButtonTarget) return
-    const hasSelection = !!this._getSelectedTextInContent()
-    this.replaceButtonTargets.forEach((btn) => {
-      btn.disabled = !hasSelection
-    })
-  }
+  // Selection change listener and replace button logic removed — unified into review
 
   updateReactionsUI(reactionsData) {
     let reactionsContainer = this.element.querySelector('.comment-reactions')