helpful 0.0.1.pre → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae8b4de74ad5a4761ce73061ae9ea988e790754b
-  data.tar.gz: 7584493dc2dc4aace5498e3112248c0615b65f3e
+  metadata.gz: 472d84181e1393ba4152cee0c2307c56c5cc85c5
+  data.tar.gz: 974104771ae3ffe8e888bac99242040c254cbbba
 SHA512:
-  metadata.gz: 64c3c53b8ed342f348f167acc503c7038e30b2bf46ddf3e35111ba4776e1b3af728ff73864cc4fb67b1a09b506091a0b89f7429c7aee2ad12cc44ba0959b67a6
-  data.tar.gz: 94c4baace34cc708e6873dbbcd5b0c45e1797a2c2115baa6ebdcea8ec6571460a823c339004758e8856b4706876cf0571a4f108d749dfd491c4ebb4d18423f93
+  metadata.gz: e6198b4f5838633ecd0abc95ab357efed9e8b6fc08cfcf58d90eb79035ab54e6631177624336c72576d4f13a63f6044caee12c263349dde426f991db4f6c1cc6
+  data.tar.gz: b91b230ce161d23a688f0e74a37d1066a77bb70dee3f8cc45fc77fae2f84474553d5666cbd80a761e69fd7d96f5a5ba06c977e8e026d923ee52cf6dcdeabc14e

data/lib/helpful.rb

@@ -1 +1,8 @@
-require 'helpful/version'
+require "rubygems"
+
+require "helpful/client"
+require "helpful/error"
+require "helpful/http_client"
+
+module Helpful
+end

data/lib/helpful/api/accounts.rb

@@ -0,0 +1,47 @@
+module Helpful
+
+  module Api
+
+    # These are like organizations which use Helpful.
+    class Accounts
+
+      def initialize(client)
+        @client = client
+      end
+
+      # All the accounts the user has access to
+      #
+      # '/accounts' GET
+      def all(options = {})
+        body = options.fetch(:query, {})
+
+        @client.get("/accounts", body, options)
+      end
+
+      # Get an account the user has access to
+      #
+      # '/accounts/:account_id' GET
+      #
+      # account_id - Identifier of the account
+      def get(account_id, options = {})
+        body = options.fetch(:query, {})
+
+        @client.get("/accounts/#{account_id}", body, options)
+      end
+
+      # Update an account the user has access to
+      #
+      # '/accounts/:account_id' PATCH
+      #
+      # account_id - Identifier of the account
+      def update(account_id, options = {})
+        body = options.fetch(:body, {})
+
+        @client.patch("/accounts/#{account_id}", body, options)
+      end
+
+    end
+
+  end
+
+end

data/lib/helpful/api/conversations.rb

@@ -0,0 +1,49 @@
+module Helpful
+
+  module Api
+
+    # Conversations in an account
+    class Conversations
+
+      def initialize(client)
+        @client = client
+      end
+
+      # List all conversations in an account the user has access to
+      #
+      # '/accounts/:account_id/conversations' GET
+      #
+      # account_id - Identifier of the account
+      def all(account_id, options = {})
+        body = options.fetch(:query, {})
+
+        @client.get("/accounts/#{account_id}/conversations", body, options)
+      end
+
+      # Create an empty conversation in account the user has access to
+      #
+      # '/accounts/:account_id/conversations' POST
+      #
+      # account_id - Identifier of the account
+      def create(account_id, options = {})
+        body = options.fetch(:body, {})
+
+        @client.post("/accounts/#{account_id}/conversations", body, options)
+      end
+
+      # Get a conversation the user has access to
+      #
+      # '/conversations/:conversation_id' GET
+      #
+      # conversation_id - Identifier of the conversation
+      def get(conversation_id, options = {})
+        body = options.fetch(:query, {})
+
+        @client.get("/conversations/#{conversation_id}", body, options)
+      end
+
+    end
+
+  end
+
+end

data/lib/helpful/api/messages.rb

@@ -0,0 +1,27 @@
+module Helpful
+
+  module Api
+
+    # Messages in a conversation
+    class Messages
+
+      def initialize(client)
+        @client = client
+      end
+
+      # Get a message the user has access to
+      #
+      # '/messages/:message_id' GET
+      #
+      # message_id - Identifier of the message
+      def get(message_id, options = {})
+        body = options.fetch(:query, {})
+
+        @client.get("/messages/#{message_id}", body, options)
+      end
+
+    end
+
+  end
+
+end

data/lib/helpful/api/people.rb

@@ -0,0 +1,27 @@
+module Helpful
+
+  module Api
+
+    # People who operate or interacted with the account
+    class People
+
+      def initialize(client)
+        @client = client
+      end
+
+      # List all people in the account the user has access to
+      #
+      # '/accounts/:account_id/people' GET
+      #
+      # account_id - Identifier of the account
+      def all(account_id, options = {})
+        body = options.fetch(:query, {})
+
+        @client.get("/accounts/#{account_id}/people", body, options)
+      end
+
+    end
+
+  end
+
+end

data/lib/helpful/client.rb

@@ -0,0 +1,39 @@
+require "faraday"
+require "json"
+
+require "helpful/api/accounts"
+require "helpful/api/people"
+require "helpful/api/conversations"
+require "helpful/api/messages"
+
+module Helpful
+
+  class Client
+
+    def initialize(auth = {}, options = {})
+      @http_client = Helpful::HttpClient::HttpClient.new(auth, options)
+    end
+
+    # These are like organizations which use Helpful.
+    def accounts()
+      Helpful::Api::Accounts.new(@http_client)
+    end
+
+    # People who operate or interacted with the account
+    def people()
+      Helpful::Api::People.new(@http_client)
+    end
+
+    # Conversations in an account
+    def conversations()
+      Helpful::Api::Conversations.new(@http_client)
+    end
+
+    # Messages in a conversation
+    def messages()
+      Helpful::Api::Messages.new(@http_client)
+    end
+
+  end
+
+end

data/lib/helpful/error.rb

@@ -0,0 +1,9 @@
+require "helpful/error/client_error"
+
+module Helpful
+
+  module Error
+
+  end
+
+end

data/lib/helpful/error/client_error.rb

@@ -0,0 +1,18 @@
+module Helpful
+
+  module Error
+
+    class ClientError < ::StandardError
+
+      attr_reader :code
+
+      def initialize(message, code)
+        @code = code
+        super message
+      end
+
+    end
+
+  end
+
+end

data/lib/helpful/http_client.rb

@@ -0,0 +1,123 @@
+require "helpful/http_client/auth_handler"
+require "helpful/http_client/error_handler"
+require "helpful/http_client/request_handler"
+require "helpful/http_client/response"
+require "helpful/http_client/response_handler"
+
+module Helpful
+
+  module HttpClient
+
+    # Main HttpClient which is used by Api classes
+    class HttpClient
+
+      attr_accessor :options, :headers
+
+      def initialize(auth = {}, options = {})
+
+        if auth.is_a?(String)
+          auth = { :access_token => auth }
+        end
+
+        @options = {
+          :base => "https://helpful.io",
+          :api_version => "api",
+          :user_agent => "alpaca/0.2.1 (https://github.com/pksunkara/alpaca)"
+        }
+
+        @options.update(options)
+
+        @headers = {
+          "user-agent" => @options[:user_agent]
+        }
+
+        if @options.has_key?(:headers)
+          @headers.update(Hash[@options[:headers].map { |k, v| [k.downcase, v] }])
+          @options.delete(:headers)
+        end
+
+        @client = Faraday.new(@options[:base]) do |conn|
+          conn.use(Helpful::HttpClient::AuthHandler, auth)
+          conn.use(Helpful::HttpClient::ErrorHandler)
+
+          conn.adapter(Faraday.default_adapter)
+        end
+      end
+
+      def get(path, params = {}, options = {})
+        request(path, nil, "get", options.merge({ :query => params }))
+      end
+
+      def post(path, body = {}, options = {})
+        request(path, body, "post", options)
+      end
+
+      def patch(path, body = {}, options = {})
+        request(path, body, "patch", options)
+      end
+
+      def delete(path, body = {}, options = {})
+        request(path, body, "delete", options)
+      end
+
+      def put(path, body = {}, options = {})
+        request(path, body, "put", options)
+      end
+
+      # Intermediate function which does three main things
+      #
+      # - Transforms the body of request into correct format
+      # - Creates the requests with give parameters
+      # - Returns response body after parsing it into correct format
+      def request(path, body, method, options)
+        options = @options.merge(options)
+
+        options[:headers] = options[:headers] || {}
+        options[:headers] = @headers.merge(Hash[options[:headers].map { |k, v| [k.downcase, v] }])
+
+        options[:body] = body
+
+        if method != "get"
+          options[:body] = options[:body] || {}
+          options = set_body(options)
+        end
+
+        response = create_request(method, path, options)
+
+        body = get_body(response)
+
+        Helpful::HttpClient::Response.new(body, response.status, response.headers)
+      end
+
+      # Creating a request with the given arguments
+      #
+      # If api_version is set, appends it immediately after host
+      def create_request(method, path, options)
+        version = options.has_key?(:api_version) ? "/#{options[:api_version]}" : ""
+
+        path = "#{version}#{path}"
+
+        instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+          @client.#{method}(path) do |req|
+            req.body = options[:body]
+            req.headers.update(options[:headers])
+            req.params.update(options[:query]) if options[:query]
+          end
+        RUBY
+      end
+
+      # Get response body in correct format
+      def get_body(response)
+        Helpful::HttpClient::ResponseHandler.get_body(response)
+      end
+
+      # Set request body in correct format
+      def set_body(options)
+        Helpful::HttpClient::RequestHandler.set_body(options)
+      end
+
+    end
+
+  end
+
+end

data/lib/helpful/http_client/auth_handler.rb

@@ -0,0 +1,113 @@
+require "base64"
+
+module Helpful
+
+  module HttpClient
+
+    # AuthHandler takes care of devising the auth type and using it
+    class AuthHandler < Faraday::Middleware
+
+      HTTP_PASSWORD = 0
+
+      URL_SECRET = 2
+      URL_TOKEN = 3
+
+      def initialize(app, auth = {}, options = {})
+        @auth = auth
+        super(app)
+      end
+
+      def call(env)
+        if !@auth.empty?
+          auth = get_auth_type
+          flag = false
+
+          if auth == HTTP_PASSWORD
+            env = http_password(env)
+            flag = true
+          end
+
+          if auth == URL_SECRET
+            env = url_secret(env)
+            flag = true
+          end
+
+          if auth == URL_TOKEN
+            env = url_token(env)
+            flag = true
+          end
+
+          if !flag
+            raise StandardError.new "Unable to calculate authorization method. Please check"
+          end
+        else
+          raise StandardError.new "Server requires authentication to proceed further. Please check"
+        end
+
+        @app.call(env)
+      end
+
+      # Calculating the Authentication Type
+      def get_auth_type()
+
+        if @auth.has_key?(:username) and @auth.has_key?(:password)
+          return HTTP_PASSWORD
+        end
+
+        if @auth.has_key?(:client_id) and @auth.has_key?(:client_secret)
+          return URL_SECRET
+        end
+
+        if @auth.has_key?(:access_token)
+          return URL_TOKEN
+        end
+
+        return -1
+      end
+
+      # Basic Authorization with username and password
+      def http_password(env)
+        code = Base64.encode64 "#{@auth[:username]}:#{@auth[:password]}"
+
+        env[:request_headers]["Authorization"] = "Basic #{code}"
+
+        return env
+      end
+
+      # OAUTH2 Authorization with client secret
+      def url_secret(env)
+        query = {
+          :client_id => @auth[:client_id],
+          :client_secret => @auth[:client_secret]
+        }
+
+        merge_query(env, query)
+      end
+
+      # OAUTH2 Authorization with access token
+      def url_token(env)
+        query = { :access_token => @auth[:access_token] }
+
+        merge_query(env, query)
+      end
+
+      def query_params(url)
+        if url.query.nil? or url.query.empty?
+          {}
+        else
+          Faraday::Utils.parse_query(url.query)
+        end
+      end
+
+      def merge_query(env, query)
+        query = query.update query_params(env[:url])
+
+        env[:url].query = Faraday::Utils.build_query(query)
+
+        return env
+      end
+    end
+
+  end
+
+end

data/lib/helpful/http_client/error_handler.rb

@@ -0,0 +1,51 @@
+module Helpful
+
+  module HttpClient
+
+    # ErrorHanlder takes care of selecting the error message from response body
+    class ErrorHandler < Faraday::Middleware
+
+      def initialize(app)
+        super(app)
+      end
+
+      def call(env)
+        @app.call(env).on_complete do |env|
+          code = env.status
+          type = env.response_headers["content-type"]
+
+          case code
+          when 500...599
+            raise Helpful::Error::ClientError.new("Error #{code}", code)
+          when 400...499
+            body = Helpful::HttpClient::ResponseHandler.get_body(env)
+            message = ""
+
+            # If HTML, whole body is taken
+            if body.is_a?(String)
+              message = body
+            end
+
+            # If JSON, a particular field is taken and used
+            if type.include?("json") and body.is_a?(Hash)
+              if body.has_key?("error")
+                message = body["error"]
+              else
+                message = "Unable to select error message from json returned by request responsible for error"
+              end
+            end
+
+            if message == ""
+              message = "Unable to understand the content type of response returned by request responsible for error"
+            end
+
+            raise Helpful::Error::ClientError.new message, code
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/helpful/http_client/request_handler.rb

@@ -0,0 +1,30 @@
+module Helpful
+
+  module HttpClient
+
+    # RequestHandler takes care of encoding the request body into format given by options
+    class RequestHandler
+
+      def self.set_body(options)
+        type = options.fetch(:request_type, "json")
+
+        # Encoding request body into JSON format
+        if type == "json"
+          options[:body] = options[:body].to_json
+          options[:headers]["content-type"] = "application/json"
+        end
+
+        # Raw body
+        if type == "raw"
+          options[:body] = options[:body].is_a?(Hash) ? "" : options[:body]
+          options[:headers].delete("content-type")
+        end
+
+        return options
+      end
+
+    end
+
+  end
+
+end

data/lib/helpful/http_client/response.rb

@@ -0,0 +1,20 @@
+module Helpful
+
+  module HttpClient
+
+    # Response object contains the response returned by the client
+    class Response
+
+      attr_accessor :body, :code, :headers
+
+      def initialize(body, code, headers)
+        @body = body
+        @code = code
+        @headers = headers
+      end
+
+    end
+
+  end
+
+end

data/lib/helpful/http_client/response_handler.rb

@@ -0,0 +1,24 @@
+module Helpful
+
+  module HttpClient
+
+    # ResponseHandler takes care of decoding the response body into suitable type
+    class ResponseHandler
+
+      def self.get_body(response)
+        type = response.headers["content-type"]
+        body = response.body
+
+        # Response body is in JSON
+        if type.include?("json")
+          body = JSON.parse body
+        end
+
+        return body
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -1,27 +1,66 @@
 --- !ruby/object:Gem::Specification
 name: helpful
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre
+  version: 1.0.0
 platform: ruby
 authors:
-- Assembly
+- Pavan Kumar Sunkara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-18 00:00:00.000000000 Z
-dependencies: []
-description: 
-email:
-- christopher.lloyd@gmail.com
-- helpful@assemblymade.com
+date: 2014-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+description: Official Helpful API library client for ruby
+email: pavan.sss1991@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/helpful.rb
-- lib/helpful/version.rb
-homepage: http://assemblymade.com/helpful
-licenses: []
+- lib/helpful/api/accounts.rb
+- lib/helpful/api/conversations.rb
+- lib/helpful/api/messages.rb
+- lib/helpful/api/people.rb
+- lib/helpful/client.rb
+- lib/helpful/error.rb
+- lib/helpful/error/client_error.rb
+- lib/helpful/http_client.rb
+- lib/helpful/http_client/auth_handler.rb
+- lib/helpful/http_client/error_handler.rb
+- lib/helpful/http_client/request_handler.rb
+- lib/helpful/http_client/response.rb
+- lib/helpful/http_client/response_handler.rb
+homepage: https://helpful.io
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -34,13 +73,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: A Ruby client library for Helpful.io
+summary: Official Helpful API library client for ruby
 test_files: []

data/lib/helpful/version.rb

@@ -1,3 +0,0 @@
-module Helpful
-  VERSION = '0.0.1.pre'
-end