fabychy 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f924047f96a10cc6621472e8981969e5f9745bdb
-  data.tar.gz: 9d1c71c1528cf4efe31f60d0c3385bb7af2be453
+  metadata.gz: 181d4fef07c43d43edb2c4e8f231c767d2f6b389
+  data.tar.gz: a50bbbca768f2aa4adf523237d143660b4406af7
 SHA512:
-  metadata.gz: 77934e87e88c1b0fb3ec4241f0f44d5c3153ac47740ff8b3095637372662718a80b489cc36b37bab80cd36983af07cf1c745f0a28344bb076cea1ce04f3d0533
-  data.tar.gz: 415aed5a85989b4fef7ed208be7ed4eebd094f47e8960f45a9fca6a1d9a55c214b13675e20f238a1f72ff717f4d007b88a31a532435c52bc64c1fead8f09f5a9
+  metadata.gz: da317f6104a82b6594951bb53028eca5b44da70442301b65846d90e632a4713fce795ca7a58288ec7fc3ae09030a145ec161f995bc2b700052f8f31b5a584c15
+  data.tar.gz: 7d3e72f81a6a02d7e0e966d45728ad87ee3d790fc1f625f6f7d19123f0b35e88fa6b362a6bdba38bc4987d8c27cf125d49cf481b16dbb16f694669b24459a568

data/README.md

@@ -0,0 +1,159 @@
+<!--
+  Title: fabychy
+  Description: A ruby client for Facebook Messenger's bot API
+  Author: Nima Kaviani - nkaviani
+  -->
+<meta name='keywords' content='fabychy, facebook, bot, ruby, api, library'>
+<table border="0">
+<tr>
+<td width="200px">
+  <img src="https://s3-us-west-2.amazonaws.com/robochyassets/fabychy/fabychu-150x150.png" alt="Rubychy" height="150px"/> 
+</td>
+<td>
+<h1>fabychy</h1>
+A ruby client for <a href="https://messengerplatform.fb.com/">Facebook Messenger's bot API</a> provided by <a href="http://robochy.com">Robochy</a>. 
+</td>
+</tr>
+</table>
+
+## Installation
+
+Add the gem to your application's Gemfile
+
+```ruby
+gem 'fabychy'
+```
+
+and run the following
+
+```ruby
+$ bundle install
+```
+
+## Usage
+Create a bot using [Facebook Messenger](https://developers.facebook.com/docs/messenger-platform/product-overview) developer portal. Once the registration is complete, copy the `Page Access Token` to be used by this library.
+
+With your `Page Access Token` you can use `fabychy` like the following:
+
+```ruby
+require 'fabychy'
+
+bot = Fabychy::Bot.new('[PAGE ACCESS TOKEN]')
+```
+
+## Get User Information
+You need to have the `USER_ID` for the target user and then call the `get_user` function:
+
+```ruby
+require 'fabychy'
+
+bot = Fabychy::Bot.new('[PAGE ACCESS TOKEN]')
+bot.get_user('[USER_ID]')
+```
+
+## Sending Messages
+With a created bot you can create messages of different types, attach custom keyboards, and pass them to the `send_message` function as follows:
+```ruby
+require 'fabychy'
+
+bot = Fabychy::Bot.new('[PAGE ACCESS TOKEN]')
+message = Fabychy::Message.new(
+  recipient: {id: [USER_ID] },
+  message: {
+    text: "hi there"
+  },
+  notification_type: Fabychy::Notification::REGULAR
+)
+```
+
+The following notification types can be used:
+```ruby
+Fabychy::Notification::REGULAR
+Fabychy::Notification::SILENT_PUSH
+Fabychy::Notification::NO_PUSH
+```
+
+## DataTypes and Validations
+Fabychy provides some light-weight validation of the generated message. However, when there is too much scaffolding it also allows you to pass the hash object instead of an actual element to create your messages. Below is an example:
+
+```ruby
+require 'fabychy/message'
+
+bot = Fabychy::Bot.new('[PAGE ACCESS TOKEN]')
+message = Fabychy::Message.new(
+  recipient: {id: "1056613714384965"},
+  message: Fabychy::DataTypes::MessageBody.new(
+    attachment: Fabychy::DataTypes::TemplateAttachment.new(
+        payload: Fabychy::DataTypes::GenericTemplatePayload.new(
+          elements: [
+            Fabychy::DataTypes::GenericElement.new(
+                title: 123,
+                image_url: "http://wip.org/media/nima-456.jpg",
+                subtitle: "This thing is great!",
+                buttons: [
+                  Fabychy::DataTypes::Button.new(
+                    type: "web_url",
+                    title: "robochy",
+                    url: "http://robochy.com"
+                  )
+                ]
+              ),
+            Fabychy::DataTypes::GenericElement.new(
+                title: "hello",
+                image_url: "http://wip.org/media/nima-456.jpg",
+                subtitle: "This thing a second thing great!",
+              )
+          ]
+        )
+      )
+    )
+  )
+  bot.send_message(message)
+```
+
+### Allowed Object Types
+
+#### Attachments
+```ruby
+Fabychy::DataTypes::TemplateAttachment
+# OR
+Fabychy::DataTypes::ImageAttachment
+```
+#### Payloads
+```ruby
+# use the following for Fabychy::DataTypes::ImageAttachment
+Fabychy::DataTypes::ImagePayload 
+
+# use the following for Fabychy::DataTypes::TemplateAttachment
+Fabychy::DataTypes::GenericTemplatePayload 
+Fabychy::DataTypes::ButtonTemplatePayload 
+Fabychy::DataTypes::ReceiptTemplatePayload 
+```
+
+#### Elements
+```ruby
+# for Fabychy::DataTypes::GenericTemplatePayload 
+Fabychy::DataTypes::GenericElement
+
+# for Fabychy::DataTypes::ReceiptTemplatePayload 
+Fabychy::DataTypes::ReceiptElement
+```
+
+## Parsing the Response
+
+In your callback servlet, pass the received `request` (not the request body) to the `Fabychy::ApiResponse.parse` function and you will get the hash response back:
+
+```ruby
+class Simple < WEBrick::HTTPServlet::AbstractServlet
+  def do_POST(request, response)
+    response = Fabychy::ApiResponse.parse(request) # response is of type Hash
+  end
+end
+```
+
+## Contributing
+- Fork it: https://github.com/nkaviani/fabychy/fork
+- Create your feature branch (`git checkout -b my-new-feature`)
+- Commit your changes (`git commit -am 'Add some feature'`)
+- Push to the branch (`git push origin my-new-feature`)
+- Create a new Pull Request

data/lib/fabychy/bot.rb

@@ -13,7 +13,7 @@ module Fabychy
     end
 
     def send_message(message)
-      api_post("me/messages?access_token=#{@access_token}", Fabychy::Sanitizer.sanitize(message))
+      api_post("me/messages?access_token=#{@access_token}", Fabychy::Sanitizer.sanitize(:msg, message))
     end
 
     def get_user(user_id)

data/lib/fabychy/sanitizer.rb

@@ -1,25 +1,25 @@
 module Fabychy
   class Sanitizer
 
-    def self.sanitize(object)
+    def self.sanitize(k, object)
       return object if object.class.name !~ /Fabychy::/
-      internal = sanitize_internal(object)
+      internal = sanitize_internal(k, object)
       h = Hash.new
       object.attributes.each do |k, att|
         next unless internal.nil? || internal.key?(k)
         if !att.is_a? Array
-          h[k]=sanitize(att)
+          h[k]=sanitize(k, att)
         else
           h[k]=Array.new
           att.each do |attr|
-            h[k] << sanitize(attr)
+            h[k] << sanitize(k, attr)
           end
         end
       end
       return h
     end
 
-    def self.sanitize_internal(object)
+    def self.sanitize_internal(k, object)
       return if !object.methods.include?(:validations)
       # Delete params not accepted by the API
       validated_param = object.to_hash.delete_if do |k, _v|
@@ -36,29 +36,29 @@ module Fabychy
       object.validations.each do |key, _value|
         next if ignored_exclusive.include?(key)
         if _value[:required] && (!validated_param.key?(key) || validated_param[key].nil?)
-          fail Fabychy::Errors::MissingParamsError.new(key, object.class.name)
+          fail Fabychy::Errors::MissingParamsError.new("#{k}:#{key}", object.class.name)
         end
 
         # Check param types
         unless _value[:class].include?(validated_param[key].class) || (_value[:drop_empty] && validated_param[key].nil?)
-          fail Fabychy::Errors::InvalidParamTypeError.new(key, validated_param[key].class, _value[:class])
+          fail Fabychy::Errors::InvalidParamTypeError.new("#{k}:#{key}", validated_param[key].class, _value[:class])
         end
 
-        if _value[:class] && _value[:class].include?(Array)
+        if _value[:class] && _value[:class].include?(Array) && validated_param[key]
           if validated_param[key].empty?
-            fail Fabychy::Errors::InvalidParamValueError.new(key, validated_param[key], ["should not be empty"])
+            fail Fabychy::Errors::InvalidParamValueError.new("#{k}:#{key}", validated_param[key], ["should not be empty"])
           end
           if _value[:inner_class]
             validated_param[key].each do |v|
               unless _value[:inner_class].include?(v.class)
-                fail Fabychy::Errors::InvalidParamTypeError.new(key, validated_param[key].class, _value[:inner_class])
+                fail Fabychy::Errors::InvalidParamTypeError.new("#{k}:#{key}", validated_param[key].class, _value[:inner_class])
               end
             end
           end
         end
 
         unless _value[:in].nil? || _value[:in].include?(validated_param[key])
-          fail Fabychy::Errors::InvalidParamValueError.new(key, validated_param[key], _value[:in])
+          fail Fabychy::Errors::InvalidParamValueError.new("#{k}:#{key}", validated_param[key], _value[:in])
         end
         validated_param[key] = validated_param[key].to_s if _value[:class] == Fixnum
       end

data/lib/fabychy/version.rb

@@ -1,4 +1,4 @@
 module Fabychy
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fabychy
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Nima Kaviani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-16 00:00:00.000000000 Z
+date: 2016-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient