whatsapp_sdk 0.0.1

data/lib/whatsapp_sdk/api/messages.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative "request"
+require_relative "response"
+
+module WhatsappSdk
+  module Api
+    class Messages < Request
+      class MissingArgumentError < StandardError
+        attr_reader :message
+
+        def initialize(message)
+          @message = message
+          super(message)
+        end
+      end
+
+      def send_text(sender_id:, recipient_number:, message:)
+        params = {
+          messaging_product: "whatsapp",
+          to: recipient_number,
+          recepient_type: "individual",
+          type: "text",
+          "text": { body: message }
+        }
+
+        response = send_request(
+          endpoint: endpoint(sender_id),
+          params: params
+        )
+
+        WhatsappSdk::Api::Response.new(response: response, class_type: WhatsappSdk::Api::Responses::MessageDataResponse)
+      end
+
+      def send_location(sender_id:, recipient_number:, longitude:, latitude:, name:, address:)
+        params = {
+          messaging_product: "whatsapp",
+          to: recipient_number,
+          recepient_type: "individual",
+          type: "location",
+          "location": {
+            "longitude": longitude,
+            "latitude": latitude,
+            "name": name,
+            "address": address
+          }
+        }
+
+        response = send_request(
+          endpoint: endpoint(sender_id),
+          params: params
+        )
+
+        WhatsappSdk::Api::Response.new(response: response, class_type: WhatsappSdk::Api::Responses::MessageDataResponse)
+      end
+
+      def send_image(sender_id:, recipient_number:, image_id: nil, link: nil, caption: "")
+        raise MissingArgumentError, "image_id or link is required" if !image_id && !link
+
+        params = {
+          messaging_product: "whatsapp",
+          to: recipient_number,
+          recepient_type: "individual",
+          type: "image"
+        }
+        params[:image] = if link
+                           { link: link, caption: caption }
+                         else
+                           { id: image_id, caption: caption }
+                         end
+
+        response = send_request(
+          endpoint: endpoint(sender_id),
+          params: params
+        )
+
+        WhatsappSdk::Api::Response.new(response: response, class_type: WhatsappSdk::Api::Responses::MessageDataResponse)
+      end
+
+      def send_audio(sender_id:, recipient_number:, audio_id: nil, link: nil)
+        raise MissingArgumentError, "audio_id or link is required" if !audio_id && !link
+
+        params = {
+          messaging_product: "whatsapp",
+          to: recipient_number,
+          recepient_type: "individual",
+          type: "audio"
+        }
+        params[:audio] = link ? { link: link } : { id: audio_id }
+
+        response = send_request(
+          endpoint: endpoint(sender_id),
+          params: params
+        )
+
+        WhatsappSdk::Api::Response.new(response: response, class_type: WhatsappSdk::Api::Responses::MessageDataResponse)
+      end
+
+      def send_video(sender_id:, recipient_number:, video_id: nil, link: nil, caption: "")
+        raise MissingArgumentError, "video_id or link is required" if !video_id && !link
+
+        params = {
+          messaging_product: "whatsapp",
+          to: recipient_number,
+          recepient_type: "individual",
+          type: "video"
+        }
+        params[:video] = if link
+                           { link: link, caption: caption }
+                         else
+                           { id: video_id, caption: caption }
+                         end
+
+        response = send_request(
+          endpoint: endpoint(sender_id),
+          params: params
+        )
+
+        WhatsappSdk::Api::Response.new(response: response, class_type: WhatsappSdk::Api::Responses::MessageDataResponse)
+      end
+
+      def send_document(sender_id:, recipient_number:, document_id: nil, link: nil, caption: "")
+        raise MissingArgumentError, "document or link is required" if !document_id && !link
+
+        params = {
+          messaging_product: "whatsapp",
+          to: recipient_number,
+          recepient_type: "individual",
+          type: "document"
+        }
+        params[:document] = if link
+                              { link: link, caption: caption }
+                            else
+                              { id: document_id, caption: caption }
+                            end
+
+        response = send_request(
+          endpoint: endpoint(sender_id),
+          params: params
+        )
+
+        WhatsappSdk::Api::Response.new(response: response, class_type: WhatsappSdk::Api::Responses::MessageDataResponse)
+      end
+
+      def send_sticker(sender_id:, recipient_number:, sticker_id: nil, link: nil)
+        raise MissingArgumentError, "sticker or link is required" if !sticker_id && !link
+
+        params = {
+          messaging_product: "whatsapp",
+          to: recipient_number,
+          recepient_type: "individual",
+          type: "sticker"
+        }
+        params[:sticker] = link ? { link: link } : { id: sticker_id }
+
+        response = send_request(
+          endpoint: endpoint(sender_id),
+          params: params
+        )
+
+        WhatsappSdk::Api::Response.new(response: response, class_type: WhatsappSdk::Api::Responses::MessageDataResponse)
+      end
+
+      def send_contacts(sender_id:, recipient_number:, contacts: nil, contacts_json: {})
+        params = {
+          messaging_product: "whatsapp",
+          to: recipient_number,
+          recepient_type: "individual",
+          type: "contacts"
+        }
+        params[:contacts] = contacts ? contacts.map(&:to_h) : contacts_json
+
+        response = send_request(
+          endpoint: endpoint(sender_id),
+          params: params
+        )
+
+        WhatsappSdk::Api::Response.new(response: response, class_type: WhatsappSdk::Api::Responses::MessageDataResponse)
+      end
+
+      def send_interactive_button
+        # TODO: https://developers.facebook.com/docs/whatsapp_sdk/cloud-api/reference/messages#contacts-object
+      end
+
+      def send_interactive_reply_buttons
+        # TODO: https://developers.facebook.com/docs/whatsapp_sdk/cloud-api/reference/messages#contacts-object
+      end
+
+      def send_interactive_section
+        # TODO: https://developers.facebook.com/docs/whatsapp_sdk/cloud-api/reference/messages#contacts-object
+      end
+
+      private
+
+      def endpoint(sender_id)
+        "#{sender_id}/messages"
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/api/phone_numbers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "request"
+require_relative "response"
+
+module WhatsappSdk
+  module Api
+    class PhoneNumbers < Request
+      def registered_numbers(business_id)
+        response = send_request(
+          http_method: "get",
+          endpoint: "#{business_id}/phone_numbers"
+        )
+
+        WhatsappSdk::Api::Response.new(response: response,
+                                       class_type: WhatsappSdk::Api::Responses::PhoneNumbersDataResponse)
+      end
+
+      def registered_number(phone_number_id)
+        response = send_request(
+          http_method: "get",
+          endpoint: phone_number_id.to_s
+        )
+
+        WhatsappSdk::Api::Response.new(response: response,
+                                       class_type: WhatsappSdk::Api::Responses::PhoneNumberDataResponse)
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/api/request.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Api
+    class Request
+      API_VERSION = "v13.0"
+      API_CLIENT = "https://graph.facebook.com/#{API_VERSION}/"
+
+      def initialize(client)
+        @client = client
+      end
+
+      def send_request(endpoint:, http_method: "post", params: {})
+        @client.send_request(http_method: http_method, endpoint: endpoint, params: params)
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/api/response.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "responses/message_data_response"
+require_relative "responses/phone_number_data_response"
+require_relative "responses/phone_numbers_data_response"
+require_relative "responses/error_response"
+
+module WhatsappSdk
+  module Api
+    class Response
+      attr_accessor :error, :data
+
+      CLASS_TYPE = {
+        message_data_response: Responses::MessageDataResponse,
+        phone_number_data_response: Responses::PhoneNumberDataResponse,
+        phone_numbers_data_response: Responses::PhoneNumbersDataResponse
+      }.freeze
+
+      def initialize(response:, class_type:)
+        @data = class_type.build_from_response(response: response)
+        @error = Responses::ErrorResponse.build_from_response(response: response)
+      end
+
+      def ok?
+        @error.nil?
+      end
+
+      def error?
+        !!@error
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/api/responses/data_response.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Api
+    module Responses
+      class DataResponse
+        attr_reader :raw_data_response
+
+        def initialize(response)
+          @raw_data_response = response
+        end
+
+        def self.build_from_response(response:) # rubocop:disable Lint/UnusedMethodArgument:
+          raise NotImplemented
+        end
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/api/responses/error_response.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Api
+    module Responses
+      class ErrorResponse
+        attr_reader :code, :subcode, :message, :type, :data, :fbtrace_id
+
+        def initialize(code:, subcode:, message:, type:, data:, fbtrace_id:)
+          @code = code
+          @subcode = subcode
+          @message = message
+          @type = type
+          @data = data
+          @fbtrace_id = fbtrace_id
+        end
+
+        def self.build_from_response(response:)
+          error_response = response["error"]
+          return unless error_response
+
+          new(
+            code: error_response["code"],
+            subcode: error_response["error_subcode"],
+            message: error_response["message"],
+            type: error_response["type"],
+            data: error_response["data"],
+            fbtrace_id: error_response["fbtrace_id"]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/api/responses/message_data_response.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../request"
+require_relative "data_response"
+require_relative "../../resource/message"
+require_relative "../../resource/contact_response"
+
+module WhatsappSdk
+  module Api
+    module Responses
+      class MessageDataResponse < DataResponse
+        attr_reader :contacts, :messages
+
+        def initialize(response:)
+          @contacts = response["contacts"]&.map { |contact_json| parse_contact(contact_json) }
+          @messages = response["messages"]&.map { |contact_json| parse_message(contact_json) }
+          super(response)
+        end
+
+        def self.build_from_response(response:)
+          return unless response["messages"]
+
+          new(response: response)
+        end
+
+        private
+
+        def parse_message(message_json)
+          ::WhatsappSdk::Resource::Message.new(id: message_json["id"])
+        end
+
+        def parse_contact(contact_json)
+          ::WhatsappSdk::Resource::ContactResponse.new(input: contact_json["input"], wa_id: contact_json["wa_id"])
+        end
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/api/responses/phone_number_data_response.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "data_response"
+
+module WhatsappSdk
+  module Api
+    module Responses
+      class PhoneNumberDataResponse < DataResponse
+        attr_accessor :id, :verified_name, :display_phone_number, :quality_rating
+
+        def initialize(response)
+          @id = response["id"]
+          @verified_name = response["verified_name"]
+          @display_phone_number = response["display_phone_number"]
+          @quality_rating = response["quality_rating"]
+          super(response)
+        end
+
+        def self.build_from_response(response:)
+          return unless response["id"]
+
+          new(response)
+        end
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/api/responses/phone_numbers_data_response.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "data_response"
+require_relative "phone_number_data_response"
+
+module WhatsappSdk
+  module Api
+    module Responses
+      class PhoneNumbersDataResponse < DataResponse
+        attr_reader :phone_numbers
+
+        def initialize(response)
+          @phone_numbers = response['data']&.map { |phone_number| parse_phone_number(phone_number) }
+          super(response)
+        end
+
+        def self.build_from_response(response:)
+          return unless response["data"]
+
+          new(response)
+        end
+
+        private
+
+        def parse_phone_number(phone_number)
+          PhoneNumberDataResponse.new(phone_number)
+        end
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  class Error < StandardError; end
+end

data/lib/whatsapp_sdk/resource/address.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Resource
+    class Address
+      attr_accessor :street, :city, :state, :zip, :country, :country_code, :typ
+
+      ADDRESS_TYPE = {
+        home: "HOME",
+        work: "WORK"
+      }.freeze
+
+      def initialize(street:, city:, state:, zip:, country:, country_code:, type: ADDRESS_TYPE::HOME)
+        @street = street
+        @city = city
+        @state = state
+        @zip = zip
+        @country = country
+        @country_code = country_code
+        @type = 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/whatsapp_sdk/resource/contact.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Resource
+    class Contact
+      attr_accessor :addresses, :birthday, :emails, :name, :org, :phones, :urls
+
+      def initialize(addresses:, birthday:, emails:, name:, org:, phones:, urls:)
+        @addresses = addresses
+        @birthday = birthday
+        @emails = emails
+        @name = name
+        @org = org
+        @phones = phones
+        @urls = urls
+      end
+
+      def to_h
+        {
+          addresses: addresses.map(&:to_h),
+          birthday: birthday,
+          emails: emails.map(&:to_h),
+          name: name.to_h,
+          org: org.to_h,
+          phones: phones.map(&:to_h),
+          urls: urls.map(&:to_h)
+        }
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/resource/contact_response.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Resource
+    class ContactResponse
+      attr_accessor :input, :wa_id
+
+      def initialize(input:, wa_id:)
+        @input = input
+        @wa_id = wa_id
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/resource/email.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Resource
+    class Email
+      attr_accessor :email, :type
+
+      EMAIL_TYPE = {
+        home: "HOME",
+        work: "WORK"
+      }.freeze
+
+      def initialize(email:, type:)
+        @email = email
+        @type = type
+      end
+
+      def to_h
+        {
+          email: @email,
+          type: @type
+        }
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/resource/message.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Resource
+    class Message
+      attr_reader :id
+
+      def initialize(id:)
+        @id = id
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/resource/name.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Resource
+    class Name
+      attr_accessor :formatted_name, :first_name, :last_name, :middle_name, :suffix, :prefix
+
+      def initialize(
+        formatted_name: nil, first_name: nil,
+        last_name: nil, middle_name: nil, suffix: nil, prefix: nil
+      )
+        @formatted_name = formatted_name
+        @first_name = first_name
+        @last_name = last_name
+        @middle_name = middle_name
+        @suffix = suffix
+        @prefix = 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/whatsapp_sdk/resource/org.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Resource
+    class Org
+      attr_accessor :company, :department, :title
+
+      def initialize(company:, department:, title:)
+        @company = company
+        @department = department
+        @title = title
+      end
+
+      def to_h
+        {
+          company: @company,
+          department: @department,
+          title: @title
+        }
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/resource/phone_number.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Resource
+    class PhoneNumber
+      attr_accessor :phone, :type, :wa_id
+
+      PHONE_NUMBER_TYPE = {
+        home: "HOME",
+        work: "WORK"
+      }.freeze
+
+      def initialize(phone:, type:, wa_id:)
+        @phone = phone
+        @type = type
+        @wa_id = wa_id
+      end
+
+      def to_h
+        {
+          phone: @phone,
+          type: @type,
+          wa_id: @wa_id
+        }
+      end
+    end
+  end
+end

data/lib/whatsapp_sdk/resource/url.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module WhatsappSdk
+  module Resource
+    class Url
+      attr_accessor :url, :type
+
+      ADDRESS_TYPE = {
+        home: "HOME",
+        work: "WORK"
+      }.freeze
+
+      def initialize(url:, type:)
+        @url = url
+        @type = type
+      end
+
+      def to_h
+        {
+          url: @url,
+          type: @type
+        }
+      end
+    end
+  end
+end