bobot 3.7.9 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29b1b41bc20cd9dd03e408d9bf5519ba310df150d5d5b2d272f598dd46f486fd
-  data.tar.gz: b7f48c122d3f718eef872cae8e856a4901d09f4f0a2aa2b0db77c30da4cf6bcd
+  metadata.gz: 4683b34a194fb0c457ce91b230377a61e40e6011cc8311d6d34fc55e4ae01fc3
+  data.tar.gz: '09c541649cc4d9b5fa484166f883b8011be77d5237e22af5c906d08ab0c99355'
 SHA512:
-  metadata.gz: 691997c18880f11670d03d44b9412476ac6c3a579f4962d5657ddb46ba89b43fbc26f96c4bf3fa5db65e08a36b11e9a8bd7c62e41288654426a5bf5142062365
-  data.tar.gz: 4c2deaae54cfe56e78b21ebd23a74f8f020954683432a370798e8fe110251953ea00d521f0cdebc52f6740e7407be97f6043f541be059a5e45a7bb014b2876e0
+  metadata.gz: f75e580fd0a9993776e72ffc8a3f6ff11f22224b758efbb4fd79033364167dfc883a60cfac88ec6f56d2c707f8f20a94042f9075c3b819728d0e06741c0ce6d0
+  data.tar.gz: 1fab9db384a613f60b16c2321281606b56ad478a8660a09143fe3da83be66820ebb209750d8fe2dc65dc123a2d7423aec93c60b2c525572fb9d7eeb73b642ee2

data/lib/bobot/events/common.rb

@@ -29,60 +29,60 @@ module Bobot
         Time.zone.at(@messaging['timestamp'] / 1000)
       end
 
-      def sender_action(sender_action:, messaging_type: "RESPONSE")
-        page.sender_action(sender_action: sender_action, to: sender["id"], messaging_type: messaging_type)
+      def sender_action(sender_action:, messaging_options: nil)
+        page.sender_action(sender_action: sender_action, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def show_typing(state:, messaging_type: "RESPONSE")
-        page.show_typing(state: state, to: sender["id"], messaging_type: messaging_type)
+      def show_typing(state:, messaging_options: nil)
+        page.show_typing(state: state, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def mark_as_seen(messaging_type: "RESPONSE")
-        page.mark_as_seen(to: sender["id"], messaging_type: messaging_type)
+      def mark_as_seen(messaging_options: nil)
+        page.mark_as_seen(to: sender["id"], messaging_options: messaging_options)
       end
 
-      def reply(payload_message:, messaging_type: "RESPONSE")
-        page.send(payload_message: payload_message, to: sender["id"], messaging_type: messaging_type)
+      def reply(payload_message:, messaging_options: nil)
+        page.send(payload_message: payload_message, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def reply_with_text(text:, messaging_type: "RESPONSE")
-        page.send_text(text: text, to: sender["id"], messaging_type: messaging_type)
+      def reply_with_text(text:, messaging_options: nil)
+        page.send_text(text: text, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def reply_with_youtube_video(url:, messaging_type: "RESPONSE")
-        page.send_youtube_video(url: url, to: sender["id"], messaging_type: messaging_type)
+      def reply_with_youtube_video(url:, messaging_options: nil)
+        page.send_youtube_video(url: url, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def reply_with_attachment(url:, type:, messaging_type: "RESPONSE")
-        page.send_attachment(url: url, type: type, to: sender["id"], messaging_type: messaging_type)
+      def reply_with_attachment(url:, type:, messaging_options: nil)
+        page.send_attachment(url: url, type: type, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def reply_with_image(url:, messaging_type: "RESPONSE")
-        page.send_image(url: url, to: sender["id"], messaging_type: messaging_type)
+      def reply_with_image(url:, messaging_options: nil)
+        page.send_image(url: url, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def reply_with_audio(url:, messaging_type: "RESPONSE")
-        page.send_audio(url: url, to: sender["id"], messaging_type: messaging_type)
+      def reply_with_audio(url:, messaging_options: nil)
+        page.send_audio(url: url, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def reply_with_video(url:, messaging_type: "RESPONSE")
-        page.send_video(url: url, to: sender["id"], messaging_type: messaging_type)
+      def reply_with_video(url:, messaging_options: nil)
+        page.send_video(url: url, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def reply_with_file(url:, messaging_type: "RESPONSE")
-        page.send_file(url: url, to: sender["id"], messaging_type: messaging_type)
+      def reply_with_file(url:, messaging_options: nil)
+        page.send_file(url: url, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def reply_with_quick_replies(text:, quick_replies:, messaging_type: "RESPONSE")
-        page.send_quick_replies(text: text, quick_replies: quick_replies, to: sender["id"], messaging_type: messaging_type)
+      def reply_with_quick_replies(text:, quick_replies:, messaging_options: nil)
+        page.send_quick_replies(text: text, quick_replies: quick_replies, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def reply_with_buttons(text:, buttons:, messaging_type: "RESPONSE")
-        page.send_buttons(text: text, buttons: buttons, to: sender["id"], messaging_type: messaging_type)
+      def reply_with_buttons(text:, buttons:, messaging_options: nil)
+        page.send_buttons(text: text, buttons: buttons, to: sender["id"], messaging_options: messaging_options)
       end
 
-      def reply_with_generic(elements:, image_aspect_ratio: 'square', messaging_type: "RESPONSE")
-        page.send_generic(elements: elements, image_aspect_ratio: image_aspect_ratio, to: sender["id"], messaging_type: messaging_type)
+      def reply_with_generic(elements:, image_aspect_ratio: 'square', messaging_options: nil)
+        page.send_generic(elements: elements, image_aspect_ratio: image_aspect_ratio, to: sender["id"], messaging_options: messaging_options)
       end
       alias_method :reply_with_carousel, :reply_with_generic
 

data/lib/bobot/page.rb

@@ -35,37 +35,42 @@ module Bobot
     #####################################
 
     def deliver(payload_template:, to:)
-      raise Bobot::FieldFormat.new('payload_template is required') unless payload_template.present?
-      raise Bobot::FieldFormat.new('payload_template[:messaging_type] is required') unless payload_template.key?(:messaging_type)
-      raise Bobot::FieldFormat.new('payload_template[:messaging_type] is invalid, only "RESPONSE, UPDATE, MESSAGE_TAG" are permitted.', payload_template[:messaging_type]) unless %w[RESPONSE UPDATE MESSAGE_TAG].include?(payload_template[:messaging_type])
+      if payload_template.present?
+        if payload_template.key?(:messaging_options) && !payload_template[:messaging_options].nil? && payload_template[:messaging_options].key?(:messaging_type)
+          if !%w[RESPONSE UPDATE MESSAGE_TAG].include?(payload_template[:messaging_options][:messaging_type])
+            raise Bobot::FieldFormat.new('payload_template[:messaging_options][:messaging_type] is invalid, only "RESPONSE, UPDATE, MESSAGE_TAG" are permitted.', payload_template[:messaging_options][:messaging_type])
+          elsif "MESSAGE_TAG" == payload_template[:messaging_options][:messaging_type] && !payload_template[:messaging_options].key?(:tag)
+            raise Bobot::FieldFormat.new('payload_template[:messaging_options][:key] is required when messaging_type is MESSAGE_TAG.', payload_template[:messaging_options][:tag])
+          end
+        end
+      else
+        raise Bobot::FieldFormat.new('payload_template is required')
+      end
+      body = { recipient: { id: to }, messaging_type: "RESPONSE" }.merge(payload_template).merge(payload_template[:messaging_options] || {})
+      query = { access_token: page_access_token }
       Bobot::Commander.deliver(
-        body: {
-          recipient: { id: to },
-          messaging_type: "RESPONSE",
-        }.merge(payload_template),
-        query: {
-          access_token: page_access_token,
-        },
+        body: body,
+        query: query,
       )
     end
-
-    def sender_action(sender_action:, to: nil, messaging_type: "RESPONSE")
-      deliver(payload_template: { sender_action: sender_action, messaging_type: messaging_type }, to: to)
+    
+    def sender_action(sender_action:, to: nil, messaging_options: nil)
+      deliver(payload_template: { sender_action: sender_action, messaging_options: messaging_options }, to: to)
     end
 
-    def show_typing(state:, to: nil, messaging_type: "RESPONSE")
-      sender_action(sender_action: (state ? 'typing_on' : 'typing_off'), messaging_type: messaging_type, to: to)
+    def show_typing(state:, to: nil, messaging_options: nil)
+      sender_action(sender_action: (state ? 'typing_on' : 'typing_off'), messaging_options: messaging_options, to: to)
     end
 
-    def mark_as_seen(to: nil, messaging_type: "RESPONSE")
-      sender_action(sender_action: 'mark_seen', messaging_type: messaging_type, to: to)
+    def mark_as_seen(to: nil, messaging_options: nil)
+      sender_action(sender_action: 'mark_seen', messaging_options: messaging_options, to: to)
     end
 
-    def send(payload_message:, to: nil, messaging_type: "RESPONSE")
-      deliver(payload_template: { message: payload_message, messaging_type: messaging_type }, to: to)
+    def send(payload_message:, to: nil, messaging_options: nil)
+      deliver(payload_template: { message: payload_message, messaging_options: messaging_options }, to: to)
     end
 
-    def send_text(text:, to: nil, messaging_type: "RESPONSE")
+    def send_text(text:, to: nil, messaging_options: nil)
       raise Bobot::FieldFormat.new('text is required') unless text.present?
       raise Bobot::FieldFormat.new('text size is limited to 640.', "#{text} (#{text.size} chars)") if text.size > 640
       send(
@@ -73,11 +78,11 @@ module Bobot
           text: text,
         },
         to: to,
-        messaging_type: messaging_type,
+        messaging_options: messaging_options,
       )
     end
 
-    def send_attachment(url:, type:, to: nil, messaging_type: "RESPONSE")
+    def send_attachment(url:, type:, to: nil, messaging_options: nil)
       raise Bobot::FieldFormat.new('url is required') unless url.present?
       raise Bobot::FieldFormat.new('type is required') unless type.present?
       raise Bobot::FieldFormat.new('type is invalid, only "image, audio, video, file" are permitted.', type) unless %w[image audio video file].include?(type)
@@ -91,11 +96,11 @@ module Bobot
           },
         },
         to: to,
-        messaging_type: messaging_type,
+        messaging_options: messaging_options,
       )
     end
 
-    def send_youtube_video(url:, to: nil, messaging_type: "RESPONSE")
+    def send_youtube_video(url:, to: nil, messaging_options: nil)
       raise Bobot::FieldFormat.new('url is required') unless url.present?
       raise Bobot::FieldFormat.new('url is not valid', url) unless url =~ %r{^(?:https?:\/\/)?(?:www\.)?youtu(?:\.be|be\.com)\/(?:watch\?v=)?([\w-]{10,})}
       send(
@@ -111,27 +116,27 @@ module Bobot
           },
         },
         to: to,
-        messaging_type: messaging_type,
+        messaging_options: messaging_options,
       )
     end
 
-    def send_image(url:, to: nil, messaging_type: "RESPONSE")
-      send_attachment(url: url, type: 'image', to: to, messaging_type: messaging_type)
+    def send_image(url:, to: nil, messaging_options: nil)
+      send_attachment(url: url, type: 'image', to: to, messaging_options: messaging_options)
     end
 
-    def send_audio(url:, to: nil, messaging_type: "RESPONSE")
-      send_attachment(url: url, type: 'audio', to: to, messaging_type: messaging_type)
+    def send_audio(url:, to: nil, messaging_options: nil)
+      send_attachment(url: url, type: 'audio', to: to, messaging_options: messaging_options)
     end
 
-    def send_video(url:, to: nil, messaging_type: "RESPONSE")
-      send_attachment(url: url, type: 'video', to: to, messaging_type: messaging_type)
+    def send_video(url:, to: nil, messaging_options: nil)
+      send_attachment(url: url, type: 'video', to: to, messaging_options: messaging_options)
     end
 
-    def send_file(url:, to: nil, messaging_type: "RESPONSE")
-      send_attachment(url: url, type: 'file', to: to, messaging_type: messaging_type)
+    def send_file(url:, to: nil, messaging_options: nil)
+      send_attachment(url: url, type: 'file', to: to, messaging_options: messaging_options)
     end
 
-    def send_quick_replies(text:, quick_replies:, to: nil, messaging_type: "RESPONSE")
+    def send_quick_replies(text:, quick_replies:, to: nil, messaging_options: nil)
       raise Bobot::FieldFormat.new('text is required') unless text.present?
       raise Bobot::FieldFormat.new('text size is limited to 640.', "#{text} (#{text.size} chars)") if text.size > 640
       raise Bobot::FieldFormat.new('quick_replies are required') unless quick_replies.present?
@@ -142,11 +147,11 @@ module Bobot
           quick_replies: quick_replies,
         },
         to: to,
-        messaging_type: messaging_type,
+        messaging_options: messaging_options,
       )
     end
 
-    def send_buttons(text:, buttons:, to: nil, messaging_type: "RESPONSE")
+    def send_buttons(text:, buttons:, to: nil, messaging_options: nil)
       raise Bobot::FieldFormat.new('text is required') unless text.present?
       raise Bobot::FieldFormat.new('text size is limited to 640.', "#{text} (#{text.size} chars)") if text.size > 640
       raise Bobot::FieldFormat.new('buttons are required') unless buttons.present?
@@ -163,11 +168,11 @@ module Bobot
           },
         },
         to: to,
-        messaging_type: messaging_type,
+        messaging_options: messaging_options,
       )
     end
 
-    def send_generic(elements:, image_aspect_ratio: 'square', to: nil, messaging_type: "RESPONSE")
+    def send_generic(elements:, image_aspect_ratio: 'square', to: nil, messaging_options: nil)
       raise Bobot::FieldFormat.new('elements are required') if elements.nil?
       raise Bobot::FieldFormat.new('elements are limited to 10.', "#{elements.size} elements") if elements.size > 10
       raise Bobot::FieldFormat.new('image_aspect_ratio is required') if image_aspect_ratio.nil?
@@ -184,7 +189,7 @@ module Bobot
           },
         },
         to: to,
-        messaging_type: messaging_type,
+        messaging_options: messaging_options,
       )
     end
     alias_method :send_carousel, :send_generic

data/lib/bobot/version.rb

@@ -1,8 +1,8 @@
 module Bobot
   class Version
-    MAJOR = 3
-    MINOR = 7
-    PATCH = 9
+    MAJOR = 4
+    MINOR = 0
+    PATCH = 0
     PRE = nil
 
     class << self

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bobot
 version: !ruby/object:Gem::Version
-  version: 3.7.9
+  version: 4.0.0
 platform: ruby
 authors:
 - Navid EMAD
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-30 00:00:00.000000000 Z
+date: 2018-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n