collavre_slack 0.2.0

data/app/services/collavre_slack/mention_mapping.rb

@@ -0,0 +1,45 @@
+module CollavreSlack
+  module MentionMapping
+    SLACK_MENTION_REGEX = /<@([A-Z0-9]+)>/.freeze
+    COLLABRE_MENTION_REGEX = /@([^:]+):/.freeze
+
+    def self.from_slack(text, slack_account)
+      return text if text.blank?
+
+      text.gsub(SLACK_MENTION_REGEX) do |match|
+        slack_user_id = Regexp.last_match(1)
+        mapping = slack_account.slack_user_mappings.includes(:collavre_user).find_by(slack_user_id: slack_user_id)
+
+        if mapping
+          "@#{mapping.collavre_user.name}:"
+        else
+          # Fetch display name from Slack API for unmapped users
+          display_name = fetch_slack_display_name(slack_account, slack_user_id)
+          display_name ? "@#{display_name}:" : match
+        end
+      end
+    end
+
+    def self.fetch_slack_display_name(slack_account, slack_user_id)
+      client = SlackClient.new(access_token: slack_account.access_token)
+      client.get_user_display_name(user_id: slack_user_id)
+    rescue StandardError => e
+      Rails.logger.warn("[CollavreSlack] Failed to fetch Slack user info: #{e.message}")
+      nil
+    end
+
+    def self.to_slack(text, slack_account)
+      return text if text.blank?
+
+      mappings = slack_account.slack_user_mappings.includes(:collavre_user).to_a
+      by_name = mappings.index_by { |mapping| mapping.collavre_user.name.to_s.downcase }
+      by_email = mappings.index_by { |mapping| mapping.collavre_user.email.to_s.downcase }
+
+      text.gsub(COLLABRE_MENTION_REGEX) do |match|
+        key = Regexp.last_match(1).to_s.downcase
+        mapping = by_name[key] || by_email[key]
+        mapping ? "<@#{mapping.slack_user_id}>" : match
+      end
+    end
+  end
+end

data/app/services/collavre_slack/slack_client.rb

@@ -0,0 +1,141 @@
+module CollavreSlack
+  class SlackClient
+    BASE_URL = "https://slack.com/api".freeze
+
+    def initialize(access_token: nil)
+      @access_token = access_token
+    end
+
+    def oauth_authorize_url(state: nil)
+      query = {
+        client_id: client_id,
+        scope: default_scopes,
+        redirect_uri: redirect_uri,
+        state: state
+      }.compact
+
+      "https://slack.com/oauth/v2/authorize?#{query.to_query}"
+    end
+
+    def oauth_access(code:, redirect_uri:)
+      response = connection.post("oauth.v2.access", {
+        client_id: client_id,
+        client_secret: client_secret,
+        code: code,
+        redirect_uri: redirect_uri
+      })
+
+      parse_response(response)
+    end
+
+    def list_channels
+      get("conversations.list", limit: 1000, types: "public_channel,private_channel")
+    end
+
+    def list_messages(channel:, oldest: nil, cursor: nil)
+      params = { channel: channel, limit: 200 }
+      params[:oldest] = oldest if oldest.present?
+      params[:cursor] = cursor if cursor.present?
+      get("conversations.history", params)
+    end
+
+    def post_message(channel:, text:)
+      post("chat.postMessage", { channel: channel, text: text })
+    end
+
+    def update_message(channel:, timestamp:, text:)
+      post("chat.update", { channel: channel, ts: timestamp, text: text })
+    end
+
+    def delete_message(channel:, timestamp:)
+      post("chat.delete", { channel: channel, ts: timestamp })
+    end
+
+    def get_user_info(user_id:)
+      get("users.info", user: user_id)
+    end
+
+    def get_user_display_name(user_id:)
+      response = get_user_info(user_id: user_id)
+      return nil unless response[:ok]
+
+      profile = response.dig(:user, :profile) || {}
+      profile[:display_name].presence || profile[:real_name].presence || response.dig(:user, :name)
+    end
+
+    def add_reaction(channel:, timestamp:, name:)
+      post("reactions.add", { channel: channel, timestamp: timestamp, name: name })
+    end
+
+    def remove_reaction(channel:, timestamp:, name:)
+      post("reactions.remove", { channel: channel, timestamp: timestamp, name: name })
+    end
+
+    def redirect_uri
+      CollavreSlack.config.redirect_uri
+    end
+
+    private
+
+    attr_reader :access_token
+
+    def client_id
+      CollavreSlack.config.client_id
+    end
+
+    def client_secret
+      CollavreSlack.config.client_secret
+    end
+
+    def default_scopes
+      CollavreSlack.config.scopes
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: BASE_URL) do |builder|
+        builder.request :url_encoded
+        builder.request :retry, max: 3, interval: 0.2, backoff_factor: 2
+        builder.response :raise_error
+      end
+    end
+
+    def get(path, params = {})
+      request_with_handling do
+        connection.get(path) do |request|
+          request.headers["Authorization"] = "Bearer #{access_token}" if access_token.present?
+          request.params.update(params)
+        end
+      end
+    end
+
+    def post(path, payload = {})
+      request_with_handling do
+        connection.post(path) do |request|
+          request.headers["Authorization"] = "Bearer #{access_token}" if access_token.present?
+          request.headers["Content-Type"] = "application/json; charset=utf-8"
+          request.body = payload.to_json
+        end
+      end
+    end
+
+    def parse_response(response)
+      parsed = JSON.parse(response.body, symbolize_names: true)
+      parsed.merge(status: response.status, headers: response.headers)
+    rescue JSON::ParserError
+      { ok: false, error: "invalid_json", status: response.status, headers: response.headers }
+    end
+
+    def request_with_handling
+      error_response = {}
+      response = yield
+      parse_response(response)
+    rescue Faraday::ClientError => e
+      error_response = e.response || {}
+      body = error_response[:body].to_s
+      parsed = JSON.parse(body, symbolize_names: true)
+      parsed.merge(status: error_response[:status], headers: error_response[:headers])
+    rescue JSON::ParserError
+      { ok: false, error: "http_error", status: error_response[:status], headers: error_response[:headers] }
+    end
+  end
+end

data/app/services/collavre_slack/slack_event_handler.rb

@@ -0,0 +1,259 @@
+module CollavreSlack
+  class SlackEventHandler
+    def initialize(payload:)
+      @payload = payload
+    end
+
+    def call
+      return handle_reaction_event if reaction_event?
+      return handle_message_changed if message_changed_event?
+      return handle_message_deleted if message_deleted_event?
+      return unless message_event?
+
+      slack_account = SlackAccount.find_by(team_id: team_id)
+      return unless slack_account
+
+      channel_link = SlackChannelLink.find_by(
+        slack_account: slack_account,
+        channel_id: channel_id
+      )
+      return unless channel_link
+
+      user_result = find_or_map_user(slack_account, event_user_id)
+      user = user_result[:user] || channel_link.created_by
+      slack_display_name = user_result[:slack_display_name]
+      slack_email = user_result[:slack_email]
+      slack_user_id = user_result[:slack_user_id]
+
+      normalized_content = MentionMapping.from_slack(formatted_content, slack_account)
+
+      # Prepend Slack username if user is not mapped
+      if user_result[:user].nil? && slack_display_name.present?
+        prefix = I18n.t("collavre_slack.messages.slack_user_prefix", name: slack_display_name)
+        normalized_content = "#{prefix} #{normalized_content}"
+      end
+
+      {
+        type: :message,
+        creative_id: channel_link.creative_id,
+        user_id: user&.id,
+        content: normalized_content,
+        slack_channel_link_id: channel_link.id,
+        slack_message_ts: event_ts,
+        slack_display_name: slack_display_name,
+        slack_email: slack_email,
+        slack_user_id: slack_user_id
+      }
+    end
+
+    def handle_message_changed
+      slack_account = SlackAccount.find_by(team_id: team_id)
+      return unless slack_account
+
+      # For message_changed, the edited message is in event.message
+      message = event_payload[:message] || {}
+      message_ts = message[:ts]
+      return unless message_ts
+
+      # Skip bot messages
+      return if message[:bot_id].present?
+
+      # Find the comment link by Slack message
+      comment_link = SlackCommentLink.find_by_slack_message(
+        slack_account: slack_account,
+        channel_id: channel_id,
+        message_ts: message_ts
+      )
+      return unless comment_link
+
+      new_text = message[:text].to_s
+      normalized_content = MentionMapping.from_slack(new_text, slack_account)
+
+      {
+        type: :message_updated,
+        comment_id: comment_link.comment_id,
+        content: normalized_content
+      }
+    end
+
+    def handle_message_deleted
+      slack_account = SlackAccount.find_by(team_id: team_id)
+      return unless slack_account
+
+      # For message_deleted, the deleted message ts is in event.deleted_ts
+      deleted_ts = event_payload[:deleted_ts]
+      return unless deleted_ts
+
+      # Find the comment link by Slack message
+      comment_link = SlackCommentLink.find_by_slack_message(
+        slack_account: slack_account,
+        channel_id: channel_id,
+        message_ts: deleted_ts
+      )
+      return unless comment_link
+
+      {
+        type: :message_deleted,
+        comment_id: comment_link.comment_id,
+        slack_comment_link_id: comment_link.id
+      }
+    end
+
+    def handle_reaction_event
+      slack_account = SlackAccount.find_by(team_id: team_id)
+      return unless slack_account
+
+      # Reaction events have item.channel and item.ts
+      item = event_payload[:item] || {}
+      reaction_channel_id = item[:channel]
+      reaction_message_ts = item[:ts]
+
+      return unless reaction_channel_id && reaction_message_ts
+
+      # Find the comment link by Slack message
+      comment_link = SlackCommentLink.find_by_slack_message(
+        slack_account: slack_account,
+        channel_id: reaction_channel_id,
+        message_ts: reaction_message_ts
+      )
+      return unless comment_link
+
+      # Map Slack user to Collavre user
+      user_result = find_or_map_user(slack_account, event_user_id)
+      user = user_result[:user]
+      return unless user # Can't add reaction without a mapped user
+
+      {
+        type: reaction_action,
+        comment_id: comment_link.comment_id,
+        user_id: user.id,
+        emoji: EmojiMapping.to_unicode(event_payload[:reaction])
+      }
+    end
+
+    private
+
+    attr_reader :payload
+
+    def message_event?
+      return false unless event_type == "event_callback"
+      return false unless event_payload[:type] == "message"
+      return false if event_payload[:subtype].present?
+      # Skip bot messages to prevent loops
+      return false if event_payload[:bot_id].present?
+      true
+    end
+
+    def reaction_event?
+      return false unless event_type == "event_callback"
+      %w[reaction_added reaction_removed].include?(event_payload[:type])
+    end
+
+    def message_changed_event?
+      return false unless event_type == "event_callback"
+      return false unless event_payload[:type] == "message"
+      event_payload[:subtype] == "message_changed"
+    end
+
+    def message_deleted_event?
+      return false unless event_type == "event_callback"
+      return false unless event_payload[:type] == "message"
+      event_payload[:subtype] == "message_deleted"
+    end
+
+    def reaction_action
+      event_payload[:type] == "reaction_added" ? :reaction_added : :reaction_removed
+    end
+
+    def team_id
+      payload[:team_id] || payload[:team]
+    end
+
+    def event_payload
+      payload[:event] || {}
+    end
+
+    def event_text
+      event_payload[:text].to_s
+    end
+
+    def formatted_content
+      content = event_text
+      content = "#{I18n.t('collavre_slack.messages.thread_reply')}\n#{content}" if thread_reply?
+      attachment_lines = attachment_summaries
+      if attachment_lines.any?
+        content = [ content, "", I18n.t("collavre_slack.messages.attachments"), *attachment_lines ].join("\n")
+      end
+      content
+    end
+
+    def attachment_summaries
+      files = Array(event_payload[:files])
+      files.filter_map do |file|
+        next unless file.is_a?(Hash)
+        name = file[:name] || file[:title] || "file"
+        url = file[:url_private] || file[:url_private_download]
+        url ? "- #{name}: #{url}" : "- #{name}"
+      end
+    end
+
+    def thread_reply?
+      event_payload[:thread_ts].present? && event_payload[:thread_ts] != event_payload[:ts]
+    end
+
+    def event_user_id
+      event_payload[:user]
+    end
+
+    def event_ts
+      event_payload[:ts]
+    end
+
+    def channel_id
+      event_payload[:channel]
+    end
+
+    def event_type
+      payload[:type]
+    end
+
+    def find_or_map_user(slack_account, slack_user_id)
+      # Fetch user info from Slack API first (needed for notifications even if mapping exists)
+      client = SlackClient.new(access_token: slack_account.access_token)
+      response = client.get_user_info(user_id: slack_user_id)
+
+      slack_display_name = nil
+      email = nil
+
+      if response[:ok]
+        profile = response.dig(:user, :profile) || {}
+        slack_display_name = profile[:display_name].presence || profile[:real_name].presence || response.dig(:user, :name)
+        email = profile[:email]
+      end
+
+      slack_info = { slack_display_name: slack_display_name, slack_email: email, slack_user_id: slack_user_id }
+
+      # Check existing mapping
+      mapping = slack_account.slack_user_mappings.find_by(slack_user_id: slack_user_id)
+      return slack_info.merge(user: mapping.collavre_user) if mapping
+
+      # Try to find Collavre user by email and auto-map
+      if email.present?
+        collavre_user = ::User.find_by(email: email)
+        if collavre_user
+          slack_account.slack_user_mappings.create(
+            slack_user_id: slack_user_id,
+            collavre_user: collavre_user
+          )
+          Rails.logger.info("[CollavreSlack] Auto-mapped Slack user #{slack_user_id} to Collavre user #{collavre_user.id} by email")
+          return slack_info.merge(user: collavre_user)
+        end
+      end
+
+      slack_info.merge(user: nil)
+    rescue StandardError => e
+      Rails.logger.warn("[CollavreSlack] Failed to map user: #{e.message}")
+      { user: nil, slack_user_id: slack_user_id }
+    end
+  end
+end

data/app/services/collavre_slack/slack_integration_service.rb

@@ -0,0 +1,26 @@
+module CollavreSlack
+  class SlackIntegrationService
+    def initialize(user:, slack_account:)
+      @user = user
+      @slack_account = slack_account
+    end
+
+    def link_channel(creative:, channel_id:, channel_name:)
+      SlackChannelLink.create!(
+        creative: creative,
+        slack_account: slack_account,
+        channel_id: channel_id,
+        channel_name: channel_name,
+        created_by: user
+      )
+    end
+
+    def unlink_channel(link)
+      link.destroy!
+    end
+
+    private
+
+    attr_reader :user, :slack_account
+  end
+end

data/app/services/collavre_slack/slack_message_dispatcher.rb

@@ -0,0 +1,24 @@
+module CollavreSlack
+  class SlackMessageDispatcher
+    def initialize(channel_link:)
+      @channel_link = channel_link
+    end
+
+    def enqueue(message:, sender: nil, comment: nil)
+      formatted = MentionMapping.to_slack(message.to_s, channel_link.slack_account)
+      log = SlackMessageLog.create!(
+        slack_channel_link: channel_link,
+        sender: sender,
+        comment: comment,
+        message: formatted,
+        status: "queued"
+      )
+      SlackMessageJob.perform_later(log.id)
+      log
+    end
+
+    private
+
+    attr_reader :channel_link
+  end
+end

data/app/views/collavre_slack/creatives/slack_integrations/index.html.erb

@@ -0,0 +1,18 @@
+<h1><%= t("collavre_slack.views.slack_integrations.title") %></h1>
+
+<p>
+  <%= link_to t("collavre_slack.views.slack_integrations.connect_slack"), slack_engine.auth_slack_path %>
+</p>
+
+<% if @links.any? %>
+  <ul>
+    <% @links.each do |link| %>
+      <li>
+        <strong><%= link.channel_name %></strong>
+        (<%= link.channel_id %>)
+      </li>
+    <% end %>
+  </ul>
+<% else %>
+  <p><%= t("collavre_slack.views.slack_integrations.no_channels_linked") %></p>
+<% end %>

data/app/views/collavre_slack/integrations/_modal.html.erb

@@ -0,0 +1,66 @@
+<div id="slack-integration-modal"
+     data-success-message="<%= t('collavre_slack.modal.success_message') %>"
+     data-login-required="<%= t('collavre_slack.modal.login_required') %>"
+     data-no-creative="<%= t('collavre_slack.modal.missing_creative') %>"
+     data-existing-message="<%= t('collavre_slack.modal.existing_message') %>"
+     data-delete-confirm="<%= t('collavre_slack.modal.delete_confirm') %>"
+     data-delete-success="<%= t('collavre_slack.modal.delete_success') %>"
+     data-delete-error="<%= t('collavre_slack.modal.delete_error') %>"
+     data-delete-button-label="<%= t('collavre_slack.modal.delete_button') %>"
+     data-add-first-channel="<%= t('collavre_slack.modal.add_first_channel') %>"
+     data-loading="<%= t('collavre_slack.modal.loading') %>"
+     data-linking="<%= t('collavre_slack.modal.linking') %>"
+     data-link-channel="<%= t('collavre_slack.modal.link_channel') %>"
+     data-refresh="<%= t('collavre_slack.modal.refresh') %>"
+     data-refresh-error="<%= t('collavre_slack.modal.refresh_error') %>"
+     data-linked-label="<%= t('collavre_slack.modal.linked_label') %>"
+     style="display:none;position:fixed;top:0;left:0;width:100vw;height:100vh;z-index:1000;align-items:center;justify-content:center;">
+  <div class="popup-box" style="min-width:360px;max-width:90vw;">
+    <button type="button" id="close-slack-modal" class="popup-close-btn">&times;</button>
+    <h2><%= t('collavre_slack.modal.title') %></h2>
+    <p id="slack-integration-status" class="slack-modal-status"></p>
+
+    <div class="slack-wizard-step" id="slack-step-connect">
+      <p id="slack-connect-message" class="slack-modal-subtext"><%= t('collavre_slack.modal.connect_message') %></p>
+      <a id="slack-login-btn" href="<%= integration.routes.auth_slack_path %>" class="btn btn-primary" target="slack-auth-window" data-window-width="620" data-window-height="720">
+        <%= t('collavre_slack.modal.login_button') %>
+      </a>
+      <div id="slack-connected-status" style="display:none;margin-bottom:1em;padding:0.75em 1em;background:var(--color-success-bg, #d4edda);border-radius:4px;color:var(--color-success-text, #155724);">
+        <strong><%= t('collavre_slack.modal.connected_status') %></strong>
+      </div>
+      <div id="slack-existing-connections" style="display:none;margin-top:0.5em;">
+        <p style="margin-bottom:0.5em;font-weight:500;"><%= t('collavre_slack.modal.existing_intro') %></p>
+        <ul id="slack-existing-channel-list" style="padding-left:0;margin-bottom:0.75em;list-style:none;"></ul>
+      </div>
+      <div id="slack-add-channel-section" style="display:none;margin-top:1em;padding-top:1em;border-top:1px solid var(--color-border);">
+        <button type="button" id="slack-add-channel-btn" class="btn btn-primary">
+          <%= t('collavre_slack.modal.add_channel') %>
+        </button>
+      </div>
+    </div>
+
+    <div class="slack-wizard-step" id="slack-step-channels" style="display:none;">
+      <p class="slack-modal-subtext"><%= t('collavre_slack.modal.choose_channel') %></p>
+      <div id="slack-channel-list" class="slack-list slack-modal-list-box" style="max-height:240px;overflow:auto;"></div>
+    </div>
+
+    <div class="slack-wizard-step" id="slack-step-summary" style="display:none;">
+      <p class="slack-modal-subtext"><%= t('collavre_slack.modal.summary_intro') %></p>
+      <div id="slack-link-summary" style="margin:1em 0;padding:1em;background:var(--color-bg-alt);border-radius:4px;">
+        <div><strong><%= t('collavre_slack.modal.channel_label') %></strong> <span id="slack-channel-summary"></span></div>
+        <div style="margin-top:0.5em;color:var(--color-text-secondary);font-size:0.9em;"><%= t('collavre_slack.modal.sync_note') %></div>
+      </div>
+    </div>
+
+    <div id="slack-wizard-error" style="display:none;margin:0.5em 0;color:#c0392b;font-weight:bold;"></div>
+
+    <div class="slack-wizard-footer" style="display:flex;justify-content:space-between;gap:0.5em;margin-top:1.5em;">
+      <button type="button" id="slack-prev-btn" class="btn btn-secondary" style="display:none;"><%= t('app.previous', default: 'Previous') %></button>
+      <div style="margin-left:auto;display:flex;gap:0.5em;">
+        <button type="button" id="slack-refresh-btn" class="btn btn-secondary" style="display:none;"><%= t('collavre_slack.modal.refresh') %></button>
+        <button type="button" id="slack-next-btn" class="btn btn-primary" style="display:none;"><%= t('app.next', default: 'Next') %></button>
+        <button type="button" id="slack-finish-btn" class="btn btn-primary" style="display:none;"><%= t('app.finish', default: 'Link Channel') %></button>
+      </div>
+    </div>
+  </div>
+</div>

data/config/initializers/collavre_slack.rb

@@ -0,0 +1,7 @@
+CollavreSlack.configure do |config|
+  config.client_id = ENV.fetch("SLACK_CLIENT_ID", config.client_id)
+  config.client_secret = ENV.fetch("SLACK_CLIENT_SECRET", config.client_secret)
+  config.signing_secret = ENV.fetch("SLACK_SIGNING_SECRET", config.signing_secret)
+  config.redirect_uri = ENV.fetch("SLACK_REDIRECT_URI", config.redirect_uri)
+  config.scopes = ENV.fetch("SLACK_SCOPES", config.scopes)
+end

data/config/locales/en.yml

@@ -0,0 +1,57 @@
+en:
+  collavre_slack:
+    integration:
+      label: "Slack"
+      description: "Sync chat messages with Slack channels"
+    errors:
+      forbidden: "Forbidden"
+      not_found: "Not found"
+      creative_already_linked: "is already linked to a Slack channel"
+      no_slack_account: "No Slack account connected"
+      authentication_required: "Authentication required"
+      missing_oauth_code: "Missing OAuth code"
+      missing_oauth_state: "Missing OAuth state"
+      invalid_oauth_state: "Invalid OAuth state"
+      user_not_found: "User not found"
+      oauth_failed: "Slack OAuth failed"
+      save_failed: "Failed to save: %{errors}"
+      invalid_signature: "Invalid signature"
+    messages:
+      anonymous: "Anonymous"
+      thread_reply: "[Thread reply]"
+      slack_user_prefix: "[Slack: @%{name}]"
+      attachments: "Attachments:"
+    views:
+      slack_integrations:
+        title: "Slack Integrations"
+        connect_slack: "Connect Slack"
+        no_channels_linked: "No Slack channels linked yet."
+      auth:
+        success_title: "Slack Connected"
+        success_message: "Slack workspace connected successfully! You can close this window."
+    modal:
+      title: "Configure Slack integration"
+      success_message: "Slack integration saved successfully."
+      login_required: "Sign in with your Slack workspace to start the integration."
+      missing_creative: "No Creative selected for integration."
+      existing_message: "You're already connected to Slack channels below."
+      delete_confirm: "Do you want to remove this Slack channel link?"
+      delete_success: "Slack channel link removed successfully."
+      delete_error: "Failed to remove the Slack channel link."
+      delete_button: "Remove"
+      add_first_channel: "Link a Slack Channel"
+      connect_message: "Connect your Slack workspace to sync messages with this Creative."
+      login_button: "Connect Slack Workspace"
+      connected_status: "Connected to Slack"
+      existing_intro: "Linked Slack channels:"
+      add_channel: "Add Another Channel"
+      choose_channel: "Select a Slack channel to link with this Creative."
+      summary_intro: "Ready to link your Slack channel:"
+      channel_label: "Channel:"
+      sync_note: "Messages posted in this Slack channel will appear in this Creative, and vice versa."
+      loading: "Loading..."
+      linking: "Linking..."
+      link_channel: "Link Channel"
+      refresh: "Refresh"
+      refresh_error: "Failed to refresh channels"
+      linked_label: "(Linked)"