warb 1.0.0

data/examples/video.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "../lib/warb"
+
+# Configure your variables here
+
+access_token = ""
+business_id = ""
+sender_id = ""
+recipient_number = ""
+
+video_link = ""
+
+# We recommend testing one section at a time, as it can be overwhelming to see all the messages at once.
+# So you can comment out the sections you don't want to test.
+
+# ############################################## #
+# ============== Using Warb.setup ============== #
+# ############################################## #
+
+warb_from_setup = Warb.setup do |config|
+  config.access_token = access_token
+  config.business_id = business_id
+  config.sender_id = sender_id
+end
+
+# To send video using its ID, you may need to retrieve it first, which can be retrieved this way
+file_path = "" # fill this in with the file path pointing to wherever the video is located
+file_type = "" # fill this in with the mimetype of the video to be uploaded. allowed values: "video/3gpp" or "video/mp4"
+video_id = warb_from_setup.video.upload(file_path: file_path, file_type: file_type)
+# if you already have a video id, you can simply replace the above line with such id
+
+warb_from_setup.video.dispatch(recipient_number, media_id: video_id)
+warb_from_setup.video.dispatch(recipient_number, media_id: video_id, caption: "OPTIONAL - Image caption")
+warb_from_setup.video.dispatch(recipient_number, link: video_link)
+warb_from_setup.video.dispatch(recipient_number, link: video_link, caption: "OPTIONAL - Image caption")
+
+warb_from_setup.video.dispatch(recipient_number) do |builder|
+  builder.media_id = video_id
+  builder.caption = "OPTIONAL - Image caption"
+end
+
+warb_from_setup.video.dispatch(recipient_number) do |builder|
+  builder.link = video_link
+  builder.caption = "OPTIONAL - Image caption"
+end
+
+# ############################################ #
+# ============== Using Warb.new ============== #
+# ############################################ #
+
+warb_from_new = Warb.new(
+  access_token: access_token,
+  business_id: business_id,
+  sender_id: sender_id
+)
+
+# Same as stated above, if you need a video id, you can upload it this way
+file_path = "" # fill this in with the file path pointing to wherever the video is located
+file_type = "" # fill this in with the mimetype of the video to be uploaded. allowed values: "video/3gpp" or "video/mp4"
+video_id = warb_from_setup.video.upload(file_path: file_path, file_type: file_type)
+# if you already have a video id, you can simply replace the above line with such id
+
+warb_from_new.video.dispatch(recipient_number, media_id: video_id)
+warb_from_new.video.dispatch(recipient_number, media_id: video_id, caption: "OPTIONAL - Image caption")
+warb_from_new.video.dispatch(recipient_number, link: video_link)
+warb_from_new.video.dispatch(recipient_number, link: video_link, caption: "OPTIONAL - Image caption")
+
+warb_from_new.video.dispatch(recipient_number) do |builder|
+  builder.media_id = video_id
+  builder.caption = "OPTIONAL - Image caption"
+end
+
+warb_from_new.video.dispatch(recipient_number) do |builder|
+  builder.link = video_link
+  builder.caption = "OPTIONAL - Image caption"
+end
+
+# ################################################# #
+# ============== Using Warb directly ============== #
+# ################################################# #
+
+Warb.video.dispatch(recipient_number, media_id: video_id)
+Warb.video.dispatch(recipient_number, media_id: video_id, caption: "OPTIONAL - Image caption")
+Warb.video.dispatch(recipient_number, link: video_link)
+Warb.video.dispatch(recipient_number, link: video_link, caption: "OPTIONAL - Image caption")
+
+Warb.video.dispatch(recipient_number) do |builder|
+  builder.media_id = video_id
+  builder.caption = "OPTIONAL - Image caption"
+end
+
+Warb.video.dispatch(recipient_number) do |builder|
+  builder.link = video_link
+  builder.caption = "OPTIONAL - Image caption"
+end

data/examples/webhook.rb

@@ -0,0 +1,144 @@
+require "sinatra/base"
+require "faraday"
+
+class Webhook < Sinatra::Base
+  configure do
+    set :bind, "0.0.0.0"
+    set :port, 3000
+    set :host_authorization, { permitted_hosts: [] }
+  end
+
+  post "/webhook" do
+    request_body = JSON.parse(request.body.read)
+
+    puts "\n🪝 Incoming webhook message: #{request_body}"
+
+    message = request_body.dig("entry", 0, "changes", 0, "value", "messages", 0)
+
+    if message && message["type"] == "text"
+      message_id = message["id"]
+
+      Warb.indicator.mark_as_read(message_id)
+
+      Warb.message.dispatch(message["from"], reply_to: message_id, message: "Echo #{message["text"]["body"]}")
+
+      reaction = {
+        message_id:,
+        emoji: "✅"
+      }
+
+      Warb.reaction.dispatch(message["from"], **reaction)
+    elsif message && message["type"] == "location"
+      message_id = message["id"]
+
+      Warb.indicator.mark_as_read(message_id)
+
+      # indicate the response is being processed
+      Warb.indicator.send_typing_indicator(message_id)
+
+      # wait a little before send the actual response, so the user can see the typing indicator
+      sleep 2
+
+      location = {
+        latitude: message["location"]["latitude"],
+        longitude: message["location"]["longitude"],
+        name: message["location"]["name"],
+        address: message["location"]["address"]
+      }
+
+      Warb.location.dispatch(message["from"], reply_to: message_id, **location)
+    elsif message && message["type"] == "image"
+      message_id = message["id"]
+
+      Warb.indicator.mark_as_read(message_id)
+
+      # for images, documents, videos, audios and stickers, you may need to keep the respective field id
+      # the respective ids are:
+      #   message["image"]["id"]
+      #   message["sticker"]["id"]
+      #   message["audio"]["id"]
+      #   message["document"]["id"]
+      #   message["video"]["id"]
+      #
+      # and only one of them is presented within the webhook response data
+      #
+      # with the media id in hands, you can re-send it and/or download it
+      #
+      # below, we resend the received image, using its id.
+
+      image = {
+        media_id: message["image"]["id"],
+        link: message["image"]["link"],
+        caption: message["image"]["caption"]
+      }
+
+      Warb.image.dispatch(message["from"], reply_to: message_id, **image)
+
+      # and here, we download the received image
+      Warb.image.download(media_id: image[:media_id], file_path: "#{Time.now}.jpg")
+    elsif message && message["type"] == "document"
+      message_id = message["id"]
+
+      Warb.indicator.mark_as_read(message_id)
+
+      document = {
+        id: message["document"]["id"],
+        link: message["document"]["link"],
+        caption: message["document"]["caption"],
+        filename: message["document"]["filename"]
+      }
+
+      Warb.document.dispatch(message["from"], reply_to: message_id, **document)
+    elsif message && message["type"] == "sticker"
+      message_id = message["id"]
+
+      Warb.indicator.mark_as_read(message_id)
+
+      sticker = {
+        media_id: message["sticker"]["id"],
+        link: message["sticker"]["link"]
+      }
+
+      Warb.sticker.dispatch(message["from"], reply_to: message_id, **sticker)
+      # you could keep adding verifications for different types of messages...
+      # elsif message && message["type"] == "image"
+      # elsif message && message["type"] == "video"
+      # elsif message && message["type"] == "contacts ?"
+      # elsif message && message["type"] == "button"
+      # elsif message && message["type"] == "interactive"
+      # elsif message && message["type"] == "unknown"
+    end
+
+    status 200
+  end
+
+  # this is the endpoint which gets called to verify the server within the Meta's API
+  # you can do whatever you want here to verify your server
+  # returning the challenge value which was received as query param is enough
+  get "/webhook" do
+    mode = params["hub.mode"]
+    token = params["hub.verify_token"]
+    challenge = params["hub.challenge"]
+
+    if mode == "subscribe" && token == Warb.configuration.webhook_verify_token
+      status 200
+      body challenge
+
+      puts "\n✨ Webhook verified successfully!"
+    else
+      status 403
+    end
+  end
+
+  run! if app_file == $PROGRAM_NAME
+
+  private
+
+  def conn
+    @conn ||= Faraday.new("https://graph.facebook.com/v22.0") do |conn|
+      conn.headers["Authorization"] = "Bearer #{Warb.configuration.access_token}" if Warb.configuration.access_token
+      conn.request(:json)
+      conn.response(:json)
+    end
+  end
+end

data/lib/warb/client.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "connection"
+module Warb
+  class Client
+    include DispatcherConcern
+    extend Forwardable
+
+    attr_reader :access_token, :sender_id, :business_id, :adapter, :logger
+
+    def_delegators :@configuration, :access_token, :sender_id, :business_id, :adapter, :logger
+
+    def initialize(configuration = nil, access_token: nil, sender_id: nil, business_id: nil,
+                   adapter: nil, logger: nil)
+      @configuration = (configuration || Warb.configuration).dup
+
+      @configuration.access_token = access_token || @configuration.access_token
+      @configuration.sender_id = sender_id || @configuration.sender_id
+      @configuration.business_id = business_id || @configuration.business_id
+      @configuration.adapter = adapter || @configuration.adapter
+      @configuration.logger = logger || @configuration.logger
+    end
+
+    def get(endpoint, data = {}, **args)
+      conn.send_request(http_method: "get", endpoint: endpoint, data: data, **args)
+    end
+
+    def post(endpoint, data = {}, **args)
+      conn.send_request(http_method: "post", endpoint: endpoint, data: data, **args)
+    end
+
+    def put(endpoint, data = {}, **args)
+      conn.send_request(http_method: "put", endpoint: endpoint, data: data, **args)
+    end
+
+    def delete(endpoint, data = {}, **args)
+      conn.send_request(http_method: "delete", endpoint: endpoint, data: data, **args)
+    end
+
+    private
+
+    def conn
+      @conn ||= Warb::Connection.new(self)
+    end
+  end
+end

data/lib/warb/components/action.rb

@@ -0,0 +1,121 @@
+module Warb
+  module Components
+    class Row
+      attr_accessor :title, :description
+
+      def initialize(title: nil, description: nil)
+        @title = title
+        @description = description
+      end
+
+      def to_h
+        {
+          title: @title,
+          description: @description
+        }
+      end
+    end
+
+    class Section
+      attr_accessor :title, :rows
+
+      def initialize(title: nil, rows: [])
+        @title = title
+        @rows = rows
+      end
+
+      def add_row(**args, &block)
+        row = Row.new(**args)
+
+        @rows << row
+
+        block_given? ? row.tap(&block) : row
+      end
+
+      def to_h
+        {
+          title: @title,
+          rows: @rows.map.with_index do |row, index|
+            row_title = row.title.slice(0, 10)
+            title = row_title.normalize.gsub(/\s/, "").downcase
+            id = "#{title}_#{index}"
+
+            row.to_h.merge(id: id)
+          end
+        }
+      end
+    end
+
+    class ListAction
+      attr_accessor :button_text, :sections
+
+      def initialize(button_text: nil, sections: [])
+        @button_text = button_text
+        @sections = sections
+      end
+
+      def add_section(**args, &block)
+        section = Section.new(**args)
+
+        @sections << section
+
+        block_given? ? section.tap(&block) : section
+      end
+
+      def to_h
+        {
+          button: @button_text,
+          sections: @sections.map(&:to_h)
+        }
+      end
+    end
+
+    class ReplyButtonAction
+      attr_accessor :buttons_texts
+
+      def initialize(buttons_texts: [])
+        @buttons_texts = buttons_texts
+      end
+
+      def to_h
+        {
+          buttons: @buttons_texts.map.with_index do |button_text, index|
+            text = button_text.normalize.gsub(/\s/, "").downcase
+            id = "#{text}_#{index}"
+
+            {
+              type: "reply",
+              reply: {
+                id: id,
+                title: button_text
+              }
+            }
+          end
+        }
+      end
+
+      def add_button_text(button_text)
+        @buttons_texts << button_text
+      end
+    end
+
+    class CTAAction
+      attr_accessor :button_text, :url
+
+      def initialize(button_text: nil, url: nil)
+        @button_text = button_text
+        @url = url
+      end
+
+      def to_h
+        {
+          name: "cta_url",
+          parameters: {
+            display_text: @button_text,
+            url: @url
+          }
+        }
+      end
+    end
+  end
+end

data/lib/warb/components/address.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Warb
+  module Components
+    class Address
+      attr_accessor :street, :city, :state, :zip, :country, :country_code, :type
+
+      def initialize(**params)
+        @street = params[:street]
+        @city = params[:city]
+        @state = params[:state]
+        @zip = params[:zip]
+        @country = params[:country]
+        @country_code = params[:country_code]
+        @type = params[:type]
+      end
+
+      def to_h
+        {
+          street: street,
+          city: city,
+          state: state,
+          zip: zip,
+          country: country,
+          country_code: country_code,
+          type: type
+        }
+      end
+    end
+  end
+end

data/lib/warb/components/email.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Warb
+  module Components
+    class Email
+      attr_accessor :type, :email
+
+      def initialize(**params)
+        @type = params[:type]
+        @email = params[:email]
+      end
+
+      def to_h
+        {
+          type: type,
+          email: email
+        }
+      end
+    end
+  end
+end

data/lib/warb/components/name.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Warb
+  module Components
+    class Name
+      attr_accessor :formatted_name, :first_name, :last_name, :middle_name, :suffix, :prefix
+
+      def initialize(**params)
+        @formatted_name = params[:formatted_name]
+        @first_name = params[:first_name]
+        @last_name = params[:last_name]
+        @middle_name = params[:middle_name]
+        @suffix = params[:suffix]
+        @prefix = params[:prefix]
+      end
+
+      def to_h
+        {
+          formatted_name: formatted_name,
+          first_name: first_name,
+          last_name: last_name,
+          middle_name: middle_name,
+          suffix: suffix,
+          prefix: prefix
+        }
+      end
+    end
+  end
+end

data/lib/warb/components/org.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Warb
+  module Components
+    class Org
+      attr_accessor :company, :department, :title
+
+      def initialize(**params)
+        @company = params[:company]
+        @department = params[:department]
+        @title = params[:title]
+      end
+
+      def to_h
+        {
+          company: company,
+          department: department,
+          title: title
+        }
+      end
+    end
+  end
+end

data/lib/warb/components/phone.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Warb
+  module Components
+    class Phone
+      attr_accessor :phone, :type, :wa_id
+
+      def initialize(**params)
+        @phone = params[:phone]
+        @type = params[:type]
+        @wa_id = params[:wa_id]
+      end
+
+      def to_h
+        {
+          phone: phone,
+          type: type,
+          wa_id: wa_id
+        }
+      end
+    end
+  end
+end

data/lib/warb/components/url.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Warb
+  module Components
+    class URL
+      attr_accessor :url, :type
+
+      def initialize(**params)
+        @type = params[:type]
+        @url = params[:url]
+      end
+
+      def to_h
+        {
+          type: type,
+          url: url
+        }
+      end
+    end
+  end
+end

data/lib/warb/configuration.rb

@@ -0,0 +1,13 @@
+module Warb
+  class Configuration
+    attr_accessor :access_token, :sender_id, :business_id, :adapter, :logger
+
+    def initialize(access_token: nil, sender_id: nil, business_id: nil, adapter: nil, logger: nil)
+      @access_token = access_token
+      @sender_id = sender_id
+      @business_id = business_id
+      @adapter = adapter || Faraday.default_adapter
+      @logger = logger || Logger.new($stdout)
+    end
+  end
+end

data/lib/warb/connection.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Warb
+  class Connection
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def send_request(http_method:, endpoint:, url: nil, data: {}, headers: {}, multipart: false,
+                     endpoint_prefix: :sender_id)
+      conn = set_connection(url:, multipart:)
+      conn.send(http_method, handle_endpoint(endpoint:, endpoint_prefix:), data, headers)
+    rescue StandardError => e
+      @client.logger.error e.inspect
+      e.response
+    end
+
+    private
+
+    def set_connection(url:, multipart:)
+      url ||= "https://graph.facebook.com/v22.0"
+
+      Faraday.new(url) do |conn|
+        conn.request(:multipart) if multipart
+        conn.request(:url_encoded) if multipart
+        conn.request(:json)
+        conn.response(:json)
+        conn.headers["Authorization"] = "Bearer #{@client.access_token}" unless @client.access_token.nil?
+        conn.adapter(@client.adapter)
+        conn.response :raise_error
+      end
+    end
+
+    def handle_endpoint(endpoint:, endpoint_prefix:)
+      case endpoint_prefix
+      when :sender_id
+        "#{@client.sender_id}/#{endpoint}"
+      when :business_id
+        "#{@client.business_id}/#{endpoint}"
+      else
+        endpoint
+      end
+    end
+  end
+end

data/lib/warb/dispatcher.rb

@@ -0,0 +1,16 @@
+module Warb
+  class Dispatcher
+    def initialize(klass, client)
+      @klass = klass
+      @client = client
+    end
+
+    def dispatch(recipient_number, reply_to: nil, **args, &block)
+      resource = block_given? ? @klass.new.tap(&block) : @klass.new(**args)
+
+      data = resource.call(recipient_number, reply_to:)
+
+      @client.post("messages", data)
+    end
+  end
+end