connector-ruby 0.1.1 → 0.3.0

data/lib/connector_ruby/channels/messenger.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  module Channels
+    class Messenger < Base
+      BASE_URL = "https://graph.facebook.com/v21.0/me/messages"
+
+      def initialize(page_access_token: nil)
+        @page_access_token = page_access_token || ConnectorRuby.configuration.messenger_page_access_token
+        raise ConfigurationError, "Messenger page_access_token is required" unless @page_access_token
+      end
+
+      def send_text(to:, text:)
+        validate_send!(to: to, text: text)
+        payload = {
+          recipient: { id: to },
+          message: { text: text }
+        }
+        post_message(payload)
+      end
+
+      def send_buttons(to:, text:, buttons:)
+        validate_send!(to: to, text: text)
+        formatted = buttons.map do |btn|
+          { type: "postback", title: btn[:title], payload: btn[:id] }
+        end
+
+        payload = {
+          recipient: { id: to },
+          message: {
+            attachment: {
+              type: "template",
+              payload: {
+                template_type: "button",
+                text: text,
+                buttons: formatted
+              }
+            }
+          }
+        }
+        post_message(payload)
+      end
+
+      def send_image(to:, url:, caption: nil)
+        validate_send!(to: to)
+        payload = {
+          recipient: { id: to },
+          message: {
+            attachment: {
+              type: "image",
+              payload: { url: url, is_reusable: true }
+            }
+          }
+        }
+        post_message(payload)
+      end
+
+      def send_quick_replies(to:, text:, replies:)
+        validate_send!(to: to, text: text)
+        formatted = replies.map do |r|
+          { content_type: "text", title: r[:title], payload: r[:id] }
+        end
+
+        payload = {
+          recipient: { id: to },
+          message: { text: text, quick_replies: formatted }
+        }
+        post_message(payload)
+      end
+
+      def self.parse_webhook(body)
+        data = body.is_a?(String) ? JSON.parse(body) : body
+
+        entry = data.dig("entry", 0)
+        return nil unless entry
+
+        messaging = entry.dig("messaging", 0)
+        return nil unless messaging
+
+        if messaging["message"]
+          parse_message(messaging)
+        elsif messaging["postback"]
+          parse_postback(messaging)
+        end
+      end
+
+      private
+
+      def post_message(payload)
+        http_client.post(BASE_URL, body: payload, headers: auth_headers)
+      end
+
+      def auth_headers
+        { "Authorization" => "Bearer #{@page_access_token}" }
+      end
+
+      def validate_send!(to:, text: nil)
+        raise ConnectorRuby::Error, "Recipient 'to' cannot be nil or empty" if to.nil? || to.to_s.strip.empty?
+        if text
+          raise ConnectorRuby::Error, "Text cannot be nil or empty" if text.nil? || text.to_s.strip.empty?
+          raise ConnectorRuby::Error, "Text exceeds 2000 character limit" if text.length > 2000
+        end
+      end
+
+      def self.parse_message(messaging)
+        msg = messaging["message"]
+        sender = messaging.dig("sender", "id")
+
+        Event.new(
+          type: :message,
+          channel: :messenger,
+          from: sender,
+          to: messaging.dig("recipient", "id"),
+          text: msg["text"],
+          timestamp: messaging["timestamp"] ? Time.at(messaging["timestamp"].to_i / 1000) : nil,
+          message_id: msg["mid"],
+          metadata: {
+            is_echo: msg["is_echo"],
+            quick_reply_payload: msg.dig("quick_reply", "payload")
+          }
+        )
+      end
+
+      def self.parse_postback(messaging)
+        postback = messaging["postback"]
+        sender = messaging.dig("sender", "id")
+
+        Event.new(
+          type: :callback,
+          channel: :messenger,
+          from: sender,
+          to: messaging.dig("recipient", "id"),
+          text: postback["payload"],
+          timestamp: messaging["timestamp"] ? Time.at(messaging["timestamp"].to_i / 1000) : nil,
+          metadata: {
+            title: postback["title"]
+          }
+        )
+      end
+    end
+  end
+end

data/lib/connector_ruby/channels/slack.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  module Channels
+    class Slack < Base
+      BASE_URL = "https://slack.com/api"
+
+      def initialize(bot_token: nil)
+        @bot_token = bot_token || ConnectorRuby.configuration.slack_bot_token
+        raise ConfigurationError, "Slack bot_token is required" unless @bot_token
+      end
+
+      def send_text(channel:, text:)
+        validate_send!(channel: channel, text: text)
+        payload = { channel: channel, text: text }
+        api_call("chat.postMessage", payload)
+      end
+
+      def send_buttons(channel:, text:, buttons:)
+        validate_send!(channel: channel, text: text)
+        actions = buttons.map do |btn|
+          {
+            type: "button",
+            text: { type: "plain_text", text: btn[:title] },
+            action_id: btn[:id],
+            value: btn[:id]
+          }
+        end
+
+        payload = {
+          channel: channel,
+          text: text,
+          blocks: [
+            { type: "section", text: { type: "mrkdwn", text: text } },
+            { type: "actions", elements: actions }
+          ]
+        }
+        api_call("chat.postMessage", payload)
+      end
+
+      def send_image(channel:, url:, caption: nil)
+        validate_send!(channel: channel)
+        blocks = [
+          {
+            type: "image",
+            image_url: url,
+            alt_text: caption || "image"
+          }
+        ]
+        blocks.first[:title] = { type: "plain_text", text: caption } if caption
+
+        payload = { channel: channel, text: caption || "Image", blocks: blocks }
+        api_call("chat.postMessage", payload)
+      end
+
+      def send_blocks(channel:, text:, blocks:)
+        validate_send!(channel: channel)
+        payload = { channel: channel, text: text, blocks: blocks }
+        api_call("chat.postMessage", payload)
+      end
+
+      def self.parse_webhook(body)
+        data = body.is_a?(String) ? JSON.parse(body) : body
+
+        # URL verification challenge
+        return { challenge: data["challenge"] } if data["type"] == "url_verification"
+
+        event = data["event"]
+        return nil unless event
+
+        case event["type"]
+        when "message"
+          return nil if event["subtype"] # skip bot messages, edits, etc.
+          parse_message(event)
+        when "app_mention"
+          parse_message(event)
+        end
+      end
+
+      private
+
+      def api_call(method, payload)
+        http_client.post("#{BASE_URL}/#{method}", body: payload, headers: auth_headers)
+      end
+
+      def auth_headers
+        { "Authorization" => "Bearer #{@bot_token}" }
+      end
+
+      def validate_send!(channel:, text: nil)
+        raise ConnectorRuby::Error, "Recipient 'channel' cannot be nil or empty" if channel.nil? || channel.to_s.strip.empty?
+        if text
+          raise ConnectorRuby::Error, "Text cannot be nil or empty" if text.nil? || text.to_s.strip.empty?
+        end
+      end
+
+      def self.parse_message(event)
+        Event.new(
+          type: :message,
+          channel: :slack,
+          from: event["user"],
+          text: event["text"],
+          timestamp: event["ts"] ? Time.at(event["ts"].to_f) : nil,
+          message_id: event["ts"],
+          metadata: {
+            channel_id: event["channel"],
+            channel_type: event["channel_type"],
+            team: event["team"],
+            thread_ts: event["thread_ts"]
+          }
+        )
+      end
+    end
+  end
+end

data/lib/connector_ruby/channels/telegram.rb

@@ -38,6 +38,24 @@ module ConnectorRuby
         api_call("sendPhoto", payload)
       end
 
+      def send_document(chat_id:, url:, caption: nil)
+        validate_send!(chat_id: chat_id)
+        payload = { chat_id: chat_id, document: url }
+        payload[:caption] = caption if caption
+        api_call("sendDocument", payload)
+      end
+
+      def send_location(chat_id:, latitude:, longitude:)
+        validate_send!(chat_id: chat_id)
+        payload = { chat_id: chat_id, latitude: latitude, longitude: longitude }
+        api_call("sendLocation", payload)
+      end
+
+      def send_typing(chat_id:)
+        validate_send!(chat_id: chat_id)
+        api_call("sendChatAction", { chat_id: chat_id, action: "typing" })
+      end
+
       def self.parse_webhook(body)
         data = body.is_a?(String) ? JSON.parse(body) : body
 

data/lib/connector_ruby/channels/whatsapp.rb

@@ -57,6 +57,103 @@ module ConnectorRuby
         post_message(payload)
       end
 
+      def send_template(to:, template_name:, language: "en", components: [])
+        validate_send!(to: to)
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "template",
+          template: {
+            name: template_name,
+            language: { code: language },
+            components: components
+          }
+        }
+        post_message(payload)
+      end
+
+      def send_document(to:, url:, filename: nil, caption: nil)
+        validate_send!(to: to)
+        doc = { link: url }
+        doc[:filename] = filename if filename
+        doc[:caption] = caption if caption
+
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "document",
+          document: doc
+        }
+        post_message(payload)
+      end
+
+      def send_location(to:, latitude:, longitude:, name: nil, address: nil)
+        validate_send!(to: to)
+        location = { latitude: latitude, longitude: longitude }
+        location[:name] = name if name
+        location[:address] = address if address
+
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "location",
+          location: location
+        }
+        post_message(payload)
+      end
+
+      def send_contact(to:, name:, phone:)
+        validate_send!(to: to)
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "contacts",
+          contacts: [{
+            name: { formatted_name: name },
+            phones: [{ phone: phone }]
+          }]
+        }
+        post_message(payload)
+      end
+
+      def send_reaction(to:, message_id:, emoji:)
+        validate_send!(to: to)
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "reaction",
+          reaction: { message_id: message_id, emoji: emoji }
+        }
+        post_message(payload)
+      end
+
+      def send_list(to:, body:, button_text:, sections:)
+        validate_send!(to: to, text: body)
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "interactive",
+          interactive: {
+            type: "list",
+            body: { text: body },
+            action: {
+              button: button_text,
+              sections: sections
+            }
+          }
+        }
+        post_message(payload)
+      end
+
+      def mark_as_read(message_id:)
+        payload = {
+          messaging_product: "whatsapp",
+          status: "read",
+          message_id: message_id
+        }
+        post_message(payload)
+      end
+
       def self.parse_webhook(body, signature: nil)
         data = body.is_a?(String) ? JSON.parse(body) : body
 

data/lib/connector_ruby/configuration.rb

@@ -4,6 +4,10 @@ module ConnectorRuby
   class Configuration
     attr_accessor :whatsapp_phone_number_id, :whatsapp_access_token,
                   :telegram_bot_token,
+                  :messenger_page_access_token,
+                  :line_channel_access_token,
+                  :slack_bot_token,
+                  :livechat_pat, :livechat_region,
                   :http_timeout, :http_retries, :http_open_timeout,
                   :on_request, :on_response, :on_error
 
@@ -11,6 +15,11 @@ module ConnectorRuby
       @whatsapp_phone_number_id = nil
       @whatsapp_access_token = nil
       @telegram_bot_token = nil
+      @messenger_page_access_token = nil
+      @line_channel_access_token = nil
+      @slack_bot_token = nil
+      @livechat_pat = nil
+      @livechat_region = nil
       @http_timeout = 30
       @http_retries = 3
       @http_open_timeout = 10

data/lib/connector_ruby/delivery_tracker.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  class DeliveryTracker
+    attr_reader :entries
+
+    def initialize
+      @entries = {}
+      @callbacks = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def track(message_id, metadata: {})
+      @entries[message_id] = {
+        status: :sent,
+        sent_at: Time.now,
+        metadata: metadata,
+        history: [{ status: :sent, at: Time.now }]
+      }
+    end
+
+    def update(message_id, status:)
+      entry = @entries[message_id]
+      return nil unless entry
+
+      entry[:status] = status.to_sym
+      entry[:history] << { status: status.to_sym, at: Time.now }
+
+      fire(status.to_sym, message_id, entry)
+      entry
+    end
+
+    def status(message_id)
+      @entries.dig(message_id, :status)
+    end
+
+    def on(status, &block)
+      @callbacks[status.to_sym] << block
+    end
+
+    def pending
+      @entries.select { |_, v| v[:status] == :sent }
+    end
+
+    def delivered
+      @entries.select { |_, v| v[:status] == :delivered }
+    end
+
+    def read
+      @entries.select { |_, v| v[:status] == :read }
+    end
+
+    private
+
+    def fire(status, message_id, entry)
+      @callbacks[status].each { |cb| cb.call(message_id, entry) }
+    end
+  end
+end

data/lib/connector_ruby/message.rb

@@ -4,9 +4,14 @@ module ConnectorRuby
   class Message
     attr_reader :type, :to, :text, :buttons, :image_url, :caption, :metadata
 
-    TYPES = %i[text buttons image template].freeze
+    TYPES = %i[text buttons image template document location contact reaction list].freeze
 
-    def initialize(type:, to:, text: nil, buttons: nil, image_url: nil, caption: nil, metadata: {})
+    attr_reader :document_url, :filename, :latitude, :longitude,
+                :location_name, :address, :phone, :contact_name,
+                :template_name, :language, :components,
+                :emoji, :sections, :button_text
+
+    def initialize(type:, to:, text: nil, buttons: nil, image_url: nil, caption: nil, metadata: {}, **extra)
       @type = type
       @to = to
       @text = text
@@ -14,8 +19,10 @@ module ConnectorRuby
       @image_url = image_url
       @caption = caption
       @metadata = metadata
+      extra.each { |k, v| instance_variable_set(:"@#{k}", v) }
     end
 
+    # Factory methods
     def self.text(to:, text:)
       new(type: :text, to: to, text: text)
     end
@@ -28,6 +35,24 @@ module ConnectorRuby
       new(type: :image, to: to, image_url: url, caption: caption)
     end
 
+    def self.document(to:, url:, filename: nil, caption: nil)
+      new(type: :document, to: to, document_url: url, filename: filename, caption: caption)
+    end
+
+    def self.location(to:, latitude:, longitude:, name: nil, address: nil)
+      new(type: :location, to: to, latitude: latitude, longitude: longitude,
+          location_name: name, address: address)
+    end
+
+    def self.contact(to:, name:, phone:)
+      new(type: :contact, to: to, contact_name: name, phone: phone)
+    end
+
+    # Builder DSL
+    def self.build
+      Builder.new
+    end
+
     def to_h
       {
         type: @type,
@@ -39,5 +64,61 @@ module ConnectorRuby
         metadata: @metadata
       }.compact
     end
+
+    class Builder
+      def initialize
+        @attrs = { metadata: {} }
+      end
+
+      def to(recipient)
+        @attrs[:to] = recipient
+        self
+      end
+
+      def text(content)
+        @attrs[:type] = :text
+        @attrs[:text] = content
+        self
+      end
+
+      def buttons(btns)
+        @attrs[:type] = :buttons
+        @attrs[:buttons] = btns
+        self
+      end
+
+      def image(url, caption: nil)
+        @attrs[:type] = :image
+        @attrs[:image_url] = url
+        @attrs[:caption] = caption
+        self
+      end
+
+      def document(url, filename: nil)
+        @attrs[:type] = :document
+        @attrs[:document_url] = url
+        @attrs[:filename] = filename
+        self
+      end
+
+      def location(lat, lng, name: nil)
+        @attrs[:type] = :location
+        @attrs[:latitude] = lat
+        @attrs[:longitude] = lng
+        @attrs[:location_name] = name
+        self
+      end
+
+      def metadata(hash)
+        @attrs[:metadata] = hash
+        self
+      end
+
+      def build
+        raise ConnectorRuby::Error, "Message requires a recipient" unless @attrs[:to]
+        raise ConnectorRuby::Error, "Message requires a type" unless @attrs[:type]
+        Message.new(**@attrs)
+      end
+    end
   end
 end

data/lib/connector_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConnectorRuby
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 end