backchat-client 0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--colour
+--tty

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in backchat-client.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Juan de Bravo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,101 @@
+This is a light library to access the Backchat provisioning API
+
+# Installation
+
+    gem install backchat-client
+
+# Current version
+
+0.1
+
+# Getting started
+
+You need a valid api-key to access Backchat API
+
+    require 'backchat-client'
+	bc = Backchat::Client.new("api-key")
+	
+# User Management
+
+## Get user profile
+
+    require 'backchat-client'
+    bc = Backchat::Client.new("api-key")
+    bc.get_profile
+
+## Delete user
+
+    require 'backchat-client'
+    bc = Backchat::Client.new("api-key")
+    bc.delete_user
+
+# Streams
+
+## Create a new stream
+
+    require 'backchat-client'
+    bc = Backchat::Client.new("api-key")
+    bc.create_stream("stream-name")
+
+## Retrieve application streams
+
+    require 'backchat-client'
+    bc = Backchat::Client.new("api-key")
+
+    # get all streams
+    streams = bc.find_stream
+
+    # get a specific stream
+    stream = bc.find_stream("stream-name")
+
+## Delete a stream
+
+    require 'backchat-client'
+    bc = Backchat::Client.new("api-key")
+    bc.destroy_stream("stream-name")
+
+# Channels
+
+## Create a new channel
+
+    require 'backchat-client'
+    bc = Backchat::Client.new("api-key")
+    bc.create_channel("twitter", "juandebravo")
+
+## Retrieve application channels
+
+    require 'backchat-client'
+    bc = Backchat::Client.new("api-key")
+
+    # get all channels
+    streams = bc.find_channel
+
+## Delete a channel
+
+    require 'backchat-client'
+    bc = Backchat::Client.new("api-key")
+    bc.destroy_channel("twitter://juandebravo")
+
+# License
+
+    The MIT License
+
+    Copyright (c) 2011 Juan de Bravo, Alberto Pastor, Rafael de Oleza.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => [:test]
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:test) do |spec|
+    spec.skip_bundler = true
+    spec.pattern = 'spec/*_spec.rb'
+    spec.rspec_opts = '--color --format doc'
+end

data/backchat-client.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "backchat_client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "backchat-client"
+  s.version     = BackchatClient::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["This gem provides an easy way to access Backchat provisioning API"]
+  s.email       = ["juandebravo@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Gem to access Backchat provisioning API}
+  s.description = %q{Gem to access Backchat provisioning API using rest_client as http client}
+
+  s.rubyforge_project = "backchat-client"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency("rest-client")
+  s.add_dependency("activesupport")
+  s.add_dependency("addressable")  
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('webmock')
+end

data/examples/add_channel_to_stream.rb

@@ -0,0 +1,23 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'backchat-client'
+
+ARGV.length < 3 and
+(
+  puts "Please include as argument the api_key, the origin stream slug and the new channel to be used"
+  exit
+)
+
+api_key = ARGV.shift
+stream_slug = ARGV.shift
+channel = ARGV.shift
+
+bc = Backchat::Client.new(api_key)
+bc.logger.level = Logger::DEBUG
+
+begin
+  puts bc.set_channels(stream_slug, [{:channel  => channel}])
+rescue Exception => ex
+  puts ex
+  puts ex.inspect
+end

data/examples/create_channel.rb

@@ -0,0 +1,20 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'backchat-client'
+
+ARGV.length < 2 and
+(
+  puts "Please include as argument the api_key, channel_type and channel_name to be used"
+  exit
+)
+
+api_key = ARGV.shift
+
+type = ARGV.shift
+
+name = ARGV.shift
+
+bc = Backchat::Client.new(api_key)
+bc.logger.level = Logger::DEBUG
+
+puts bc.create_channel(type, name)

data/examples/create_stream.rb

@@ -0,0 +1,18 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'backchat-client'
+
+ARGV.length < 2 and
+(
+  puts "Please include as argument the api_key and stream_name to be used"
+  exit
+)
+
+api_key = ARGV.shift
+
+stream = ARGV.shift
+
+bc = Backchat::Client.new(api_key)
+bc.logger.level = Logger::DEBUG
+
+puts bc.create_stream(stream)

data/examples/delete_channel.rb

@@ -0,0 +1,18 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'backchat-client'
+
+ARGV.length < 2 and
+(
+  puts "Please include as argument the api_key, channel_name to be used"
+  exit
+)
+
+api_key = ARGV.shift
+
+channel = ARGV.shift
+
+bc = Backchat::Client.new(api_key)
+bc.logger.level = Logger::DEBUG
+
+puts bc.destroy_channel(channel, true)

data/examples/delete_stream.rb

@@ -0,0 +1,18 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'backchat-client'
+
+ARGV.length < 2 and
+(
+  puts "Please include as argument the api_key, stream_name to be used"
+  exit
+)
+
+api_key = ARGV.shift
+
+stream = ARGV.shift
+
+bc = Backchat::Client.new(api_key)
+bc.logger.level = Logger::DEBUG
+
+puts bc.destroy_stream(stream)

data/examples/delete_user.rb

@@ -0,0 +1,19 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'backchat-client'
+
+ARGV.length < 1 and
+(
+  puts "Please include as argument the api_key to be used"
+  exit
+)
+
+api_key = ARGV.shift
+
+bc = Backchat::Client.new(api_key)
+
+bc.logger.level = Logger::DEBUG
+
+puts bc.delete_user
+
+

data/examples/get_channels.rb

@@ -0,0 +1,22 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'backchat-client'
+
+ARGV.length < 1 and
+(
+  puts "Please include as argument the api_key"
+  exit
+)
+
+api_key = ARGV.shift
+
+bc = Backchat::Client.new(api_key)
+bc.logger.level=Logger::DEBUG
+
+begin
+  puts bc.find_channel
+rescue Exception => ex
+  puts ex.message
+  puts ex
+end
+

data/examples/stream.rb

@@ -0,0 +1,29 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'backchat-client'
+
+ARGV.length < 1 and
+(
+  puts "Please include as argument the api_key to be used"
+  exit
+)
+
+api_key = ARGV.shift
+
+stream = if ARGV.length < 1
+             ""
+         else
+             ARGV.shift
+         end
+
+Backchat::Client.log_level=Logger::DEBUG
+bc = Backchat::Client.new(api_key)
+
+begin
+  puts bc.find_stream(stream)
+rescue Exception => ex
+  puts ex.message
+  puts ex
+end
+
+

data/examples/user.rb

@@ -0,0 +1,16 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'backchat-client'
+
+ARGV.length < 1 and
+(
+  puts "Please include as argument the api_key to be used"
+  exit
+)
+
+api_key = ARGV.shift
+
+
+bc = Backchat::Client.new(api_key)
+puts bc.get_profile
+

data/lib/backchat-client.rb

@@ -0,0 +1,212 @@
+require 'backchat_client/channel'
+require 'backchat_client/stream'
+require 'backchat_client/user'
+require 'backchat_client/backchat_logger'
+require 'addressable/uri'
+
+module Backchat
+
+  include BackchatClient::BackchatLogger
+
+  #
+  # This class is the main entry point to use the backchat-client gem.
+  # It creates a client with a specific api_key that connects to Backchat
+  # and processes any request.
+  #
+  class Client
+    include BackchatClient::BackchatLogger
+
+    # default endpoint where Backchat is deployed
+    DEFAULT_ENDPOINT = "https://api.backchat.io/1"
+
+    attr_accessor :api_key
+    attr_reader :endpoint
+
+    #
+    # @param *api_key* application identifier
+    # @param *endpoint* Backchat endpoint
+    #
+    def initialize(api_key, endpoint = nil)
+      @api_key = api_key
+      @endpoint = endpoint.nil? ? DEFAULT_ENDPOINT : endpoint
+    end
+
+    #
+    # Checks if a Token is valid
+    # @return true|false
+    #
+    def valid?
+      !get_profile.nil?
+    end
+
+    #
+    # *User management*
+
+    #
+    # get user profile.
+    # The api_key used should be associated to a user
+    # @return user profile or nil if invalid api_key
+    #
+    def get_profile
+      user.find
+    end
+
+    #
+    # Delete user account
+    #
+    def delete_user
+      user.destroy
+    end
+
+    # *Channels management*
+
+    #
+    # Retrieves a specific channel or all the channels associated to the api_key
+    # @return one or more channel data
+    #
+    def find_channel
+      channels = channel.find
+
+      # check that the data has the expected format
+      if channels.respond_to?("has_key?") and channels.has_key?("data")
+        channels["data"]
+      else
+        logger.info("Unable to find channels")
+        nil
+      end
+    end
+
+    #
+    # Creates a specific channel
+    # @param channel_type kind of channel: check Backchat documentation about supported channel types
+    # @param id channel unique identifier (in user scope)
+    #
+    def create_channel(channel_type, id, bql=nil)
+      _channel = channel.create(generate_channel_url(channel_type, id, bql))
+
+      if _channel.respond_to?("has_key?") and _channel.has_key?("data")
+        _channel["data"]
+      else
+        logger.error("Invalid data received while creating channel #{_channel}")
+        raise "No data received from Backchat while creating channel"
+      end
+    end
+
+    #
+    # Delete a channel
+    # @param *name*
+    # @param *force* true|false if channel should be deleted even if being used in a stream
+    #
+    def destroy_channel(name, force = false)
+      channel.destroy(name, force)
+    end
+
+    # Streams management
+
+
+    #
+    # Retrieves a specific stream
+    # @param *name* (optional) stream name. If undefined, all the user streams are retrieved
+    # @return stream data hash
+    #
+    def find_stream(name = nil)
+      streams = stream.find(name)
+
+      if !streams.nil? and streams.respond_to?("has_key?") and streams.has_key?("data")
+        streams["data"]
+      else
+        logger.debug "Stream with name #{name} not found in backchat"
+        nil
+      end
+    end
+
+    #
+    # Create a specific stream
+    # @param *name* unique stream identifier
+    # @param *description* (optional)
+    # @param *filters* (optional) array of filters
+    #
+    def create_stream(name, description = nil, filters = [])
+      description.nil? and description = "Stream created using backchat-client gem"
+      _stream = stream.create(name, description, filters)
+
+      if _stream.respond_to?("has_key?") and _stream.has_key?("data")
+        _stream["data"]
+      else
+        logger.error("Invalid data received while creating stream: #{_stream}")
+        raise "No data received from Backchat while creating stream"
+      end
+    end
+
+    #
+    # This method updates the stream, assigning the new channels array to it.
+    # In order to simplify, all the channels received will be automatically enabled.
+    # @param stream_slug stream name
+    # @param channels array of channels to be included in the stream
+    # @param reset the channels are added (false) to the current channels or remove (true) the previous ones
+    # @param filter valid Lucene syntax to filter the channels
+    # @return true if the stream was successfully updated
+    # @raise exception if stream is not found
+    #
+    def set_channels(stream_slug, channels = [], reset = false, filter = nil)
+      st = stream.find(stream_slug) or raise "stream does not exist"
+
+      st = st["data"]
+      # format the channels array
+      channels.map { |channel|
+        channel[:enabled] = true
+        channel[:channel]+="?q=#{filter}" unless filter.nil?
+        channel[:channel] = Addressable::URI.parse(channel[:channel]).normalize.to_s
+      }
+
+      if reset
+        # reset the stream channels
+        st["channel_filters"] = channels
+      else
+        # add the new channels to the existing ones
+        st["channel_filters"] |= channels
+      end
+
+      stream.update(stream_slug, st)
+      true
+    end
+
+    #
+    # Delete a stream
+    #
+    def destroy_stream(name)
+      stream.destroy(name)
+    end
+
+    #
+    # Helper that generates the channel url using Addressable help
+    #
+    def generate_channel_url(type, id, filter = nil)
+      channel_uri = "#{type}://#{id}"
+      if filter
+        channel_uri += "?q=#{filter}"
+      end
+      Addressable::URI.parse(channel_uri).normalize.to_s
+    end
+
+    private
+
+    # Composition pattern
+
+    # user management object
+    def user
+      @user ||= BackchatClient::User.new(api_key, endpoint.dup)
+    end
+
+    # channel management object
+    def channel
+      @channel ||= BackchatClient::Channel.new(api_key, endpoint.dup)
+    end
+
+    # stream management object
+    def stream
+      @stream ||= BackchatClient::Stream.new(api_key, endpoint.dup)
+    end
+
+  end
+end

data/lib/backchat_client/backchat_logger.rb

@@ -0,0 +1,75 @@
+require 'logger'
+
+module BackchatClient
+
+  #
+  # This module injects methods to handle log mechanism
+  #
+  module BackchatLogger
+    #
+    # Nice way to include the Module methods when including it in a class/module
+    #
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    #
+    # This module acts as a wrapper to include the class/module level methods
+    #
+    module ClassMethods
+
+      # logger setter
+      # @param value should be a valid IO object (STDOUT, string representing a valid filename, File object)
+      # @return new Logger object created
+      def logger=(value)
+        # _logger must be static var and not class var to be shared between objects/classes
+        if value.is_a?(String)
+          @@_logger = Logger.new(value)
+        else
+          @@_logger = value
+        end
+      end
+
+      # logger getter
+      # @return Logger object
+      def logger
+        @@_logger ||= create_logger
+      end
+
+      #change logger level
+      # @param level valid    Logger level constant (Logger::DEBUG, etc)
+      def log_level=(level)
+        logger.level = level
+      end
+
+      #
+      # Creates a new Logger object and defines the level and format
+      #
+      def create_logger(output = nil)
+        output.nil? and output = STDOUT
+        logger = Logger.new(output)
+        logger.level = Logger::ERROR
+        #logger.formatter = proc { |severity, datetime, progname, msg|
+        #  "#{severity} on #{datetime} at #{progname}: #{msg}\n"
+        #}
+        logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+        logger
+      end
+    end
+
+    def logger
+      self.class.logger
+    end
+
+    # debug message with the class name a the beginning of the log
+    def debug(message)
+      logger.debug "#{self.class} #{message}"
+    end
+
+    # error message with the class name a the beginning of the log
+    def error(message)
+      logger.error "#{self.class} #{message}"
+    end
+
+  end
+end

data/lib/backchat_client/channel.rb

@@ -0,0 +1,61 @@
+require 'backchat_client/http_client'
+require 'active_support'
+require 'backchat_client/backchat_logger'
+
+module BackchatClient
+
+  #
+  # A Backchat Channel allows to define an external resource to fetch events using Backchat infrastructure
+  #
+  class Channel
+    include BackchatClient::HttpClient
+    include BackchatClient::BackchatLogger
+
+    # http uri to handle channels
+    URI_PATH = "channels"
+
+    #
+    # @param *api_key* application identifier
+    # @param *endpoint* Backchat endpoint
+    #
+    def initialize(api_key, endpoint)
+      @api_key = api_key
+      @endpoint = endpoint
+    end
+
+    #
+    # This method POST a request to create a new channel on behalf of the
+    # authenticated application
+    # @param uri valid Backchat URI, i.e. twitter://username
+    # @return response body
+    #
+    def create(uri)
+      ActiveSupport::JSON.decode(post("index.json", {:channel => uri}))
+    end
+
+    #
+    # This method sends a GET request to retrieve all the user channels
+    # There is no way to retrieve a specific channel
+    # @return response body
+    #
+    def find
+      ActiveSupport::JSON.decode(get("index.json"))
+    end
+
+    #
+    # Delete an application channel
+    # @param *name* valid channel URI
+    # @param *force* delete even if it is being used by a stream
+    # @return true|false
+    #
+    def destroy(name, force = false)
+      begin
+        ActiveSupport::JSON.decode(delete("", {:channel => name, :force => force}))
+        return true
+      rescue RestClient::ResourceNotFound
+        return false
+      end
+    end
+
+  end
+end

data/lib/backchat_client/http_client.rb

@@ -0,0 +1,76 @@
+require 'rest_client'
+require 'backchat_client/backchat_logger'
+
+module BackchatClient
+  #
+  # This module sends HTTP requests to Backchat including the specific
+  # header authenticating the sender
+  # It's just a mixin, some features must be pre-loaded in the entity that uses
+  # the mixin
+  # @endpoint: Backchat API URI: https://api.backchat.io
+  # @api_key: application api key: kljdfjrwerwlkdfjsldkf
+  # URI_PATH: entity/model specific: streams, channels, etc.
+  #
+  module HttpClient
+
+    include BackchatClient::BackchatLogger
+
+    # HTTP GET
+    def get(path, params = {}, headers = {})
+      headers.merge!({:Authorization => "Backchat #{@api_key}", :Accept => "application/json"})
+
+      uri = set_path(path)
+      uri = "#{uri}?".concat(params.collect { |k, v| "#{k}=#{v.to_s}" }.join("&"))
+      debug("get request to uri #{uri}")
+      RestClient.get(uri, headers)
+    end
+
+    # HTTP POST
+    def post(path, body = {}, headers = {})
+      headers.merge!({:Authorization => "Backchat #{@api_key}", :content_type => :json, :accept => :json})
+      body = ActiveSupport::JSON.encode(body)
+      uri = set_path(path)
+      debug("post request to uri #{uri}")
+      debug("post body: <#{body}>")
+      RestClient.post("#{uri}", body, headers)
+    end
+
+    # HTTP PUT
+    def put(path, body = {}, headers = {})
+      headers.merge!({:Authorization => "Backchat #{@api_key}", :content_type => :json, :accept => :json})
+      body = ActiveSupport::JSON.encode(body)
+      uri = set_path(path)
+      debug("put request to uri #{uri}")
+      debug("put body: <#{body}>")
+      RestClient.put("#{uri}", body, headers)
+    end
+
+    # HTTP DELETE
+    def delete(path, params = {}, headers = {})
+      headers.merge!({:Authorization => "Backchat #{@api_key}", :accept => :json})
+      uri = set_path(path)
+      uri = "#{uri}?".concat(params.collect { |k, v| "#{k}=#{v.to_s}" }.join("&"))
+      debug("delete request to uri #{uri}")
+      RestClient.delete(uri, headers)
+    end
+
+    private
+
+    def set_path(path)
+      if uri_path.nil?
+        "#{@endpoint}/#{path}"
+      else
+        "#{@endpoint}/#{uri_path}/#{path}"
+      end
+    end
+
+    # Returns the entity URI_PATH constant (loaded from the entity class)
+    def uri_path
+      unless defined? self.class::URI_PATH
+        raise RuntimeError.new "URI_PATH constant should be defined"
+      end
+      self.class::URI_PATH
+    end
+
+  end
+end

data/lib/backchat_client/stream.rb

@@ -0,0 +1,75 @@
+require 'backchat_client/http_client'
+require 'backchat_client/backchat_logger'
+require 'active_support'
+
+module BackchatClient
+
+  #
+  # A Backchat Stream allows to define a set of channels with filters
+  #
+  class Stream
+    include BackchatClient::HttpClient
+    include BackchatClient::BackchatLogger
+
+    # http uri to handle streams
+    URI_PATH = "streams"
+
+    #
+    # @param *api_key* application identifier
+    # @param *endpoint* Backchat endpoint
+    #
+    def initialize(api_key, endpoint)
+      @api_key = api_key
+      @endpoint = endpoint
+    end
+
+    #
+    # This method POST a request to create a new stream on behalf of the
+    # authenticated application
+    # @param name
+    # @param description
+    # @param filters one or more valid channel URIs
+    # @param filter_enabled one or more boolean values enabling|disabling the filters
+    # @return response body
+    #
+    def create(name, description, filters = [])
+      ActiveSupport::JSON.decode(post("", {:name => name, :description => description, :channel_filters => filters}))
+    end
+
+    #
+    # Retrieves a stream
+    # @param *name* get a stream
+    # @return stream data or nil if not found
+    #
+    def find(name)
+      if name
+        begin
+          ActiveSupport::JSON.decode(get(name))
+        rescue RestClient::ResourceNotFound
+          return nil
+        end
+      else
+        ActiveSupport::JSON.decode(get("index.json"))
+      end
+    end
+
+    def update(slug, params)
+      ActiveSupport::JSON.decode(put(slug, params))
+    end
+
+    #
+    # Delete a defined stream
+    # @param *name* valid stream name
+    # @param true|false if deleted or not
+    #
+    def destroy(name)
+      begin
+        ActiveSupport::JSON.decode(delete(name))
+        return true
+      rescue RestClient::ResourceNotFound
+        return false
+      end
+    end
+
+  end
+end

data/lib/backchat_client/user.rb

@@ -0,0 +1,57 @@
+require 'active_support'
+require 'backchat_client/http_client'
+require 'backchat_client/backchat_logger'
+
+module BackchatClient
+
+  #
+  # A Backchat User is a developer that has an api_key and can create applications using Backchat API
+  #
+  class User
+    include BackchatClient::HttpClient
+    include BackchatClient::BackchatLogger
+
+    URI_PATH = nil # no suffix for user path
+
+    #
+    # @param *api_key* application identifier
+    # @param *endpoint* Backchat endpoint
+    #
+    def initialize(api_key, endpoint)
+      @api_key = api_key
+      @endpoint = endpoint
+    end
+    
+    #
+    # Delete user account
+    #
+    def destroy
+      delete("")
+    end
+    
+    # this method return the user profile in case that the token provided is valid
+    # @return user profile with information about channels, streams and plan
+    # @return nil if token is invalid or an unexpected error takes place
+    def find
+      begin
+        debug("Fetching user profile")
+        data = get("index.json")
+        if data.is_a?(String)
+          data = ActiveSupport::JSON.decode(data)
+          if data.has_key?("data")
+            data["data"]
+          else
+            nil
+          end
+        end
+      rescue RestClient::Unauthorized => ex
+        error "Invalid api_key #{@api_key}"
+        nil # Invalid token
+      rescue Exception => ex
+        logger.error " Unexpected error"
+        logger.error ex.inspect
+        nil # Unexpected error
+      end
+    end
+  end
+end

data/lib/backchat_client/version.rb

@@ -0,0 +1,3 @@
+module BackchatClient
+  VERSION = "0.1"
+end

data/spec/backchat-client_spec.rb

@@ -0,0 +1,50 @@
+require 'backchat-client'
+require 'webmock/rspec'
+
+describe Backchat::Client do
+  
+  before(:each) do
+    Backchat::Client.log_level = Logger::DEBUG
+  end
+
+  describe "it initializes correctly the client" do
+
+    it "gets the api key and the endpoint" do
+      bc = Backchat::Client.new("api-key", "endpoint")
+      bc.endpoint.should eq("endpoint")
+      bc.api_key.should eq("api-key")
+    end
+
+    it "gets the api key and the default endpoint" do
+      bc = Backchat::Client.new("api-key")
+      bc.endpoint.should eq(Backchat::Client::DEFAULT_ENDPOINT)
+      bc.api_key.should eq("api-key")
+    end
+    
+    describe "valid? method" do
+      it "returns true with a valid token" do
+        api_key = "valid-api-key"
+        stub_request(:get, "https://api.backchat.io/1/index.json?").
+                  with(:headers => {'Accept'=>'application/json', 'Authorization' => "Backchat #{api_key}"}).
+                  to_return(:status => 200, :body => "{'data':{'channels':[],'email':'user@backchat.com','_id':'user_id','api_key':'#{api_key}','last_name':'lastname','first_name':'name','plan':'https://api.backchat.io/1/plans/free','streams':[],'login':'user'},'errors':[]}", :headers => {})
+
+        bc = Backchat::Client.new(api_key)
+        bc.valid?.should eql(true)
+      end
+
+      it "returns false with a valid token" do
+        api_key = "invalid-api-key"
+        stub_request(:get, "https://api.backchat.io/1/index.json?").
+                  with(:headers => {'Accept'=>'application/json', 'Authorization' => "Backchat #{api_key}"}).
+                  to_return(:status => 401, :body => "{'data':null,'errors':[['','Unauthorized']]}", :headers => {})
+
+        bc = Backchat::Client.new(api_key)
+        bc.valid?.should eql(false)
+      end
+    end
+
+    
+
+  end
+
+end

data/spec/channel_spec.rb

@@ -0,0 +1,67 @@
+require 'backchat-client'
+require 'webmock/rspec'
+
+describe BackchatClient::Channel do
+  API_KEY = "valid-api-key"
+
+  describe "when working with find method" do
+
+    it "gets all the user defined channels" do
+      stub_request(:get, "https://api.backchat.io/1/channels/index.json?").
+          with(:headers => {'Accept'=>'application/json', 'Authorization' => "Backchat #{API_KEY}"}).
+          to_return(:body => '{"data":[{"uri":"twitter://pastoret/#timeline"},{"uri":"twitter://juandebravo/#timeline"}],"errors":[]}')
+
+      bc = Backchat::Client.new(API_KEY)
+      channels = bc.find_channel
+      channels.should be_a(Array)
+      channels.length.should eql(2)
+      channels.each { |channel|
+        channel.should be_a(Hash)
+        channel.should have_key("uri")
+      }
+    end
+
+  end
+
+  describe "when creating a channel" do
+    it "returns the channel identifier" do
+      stub_request(:post, "https://api.backchat.io/1/channels/index.json").
+          with(:body => '{"channel":"twitter://juandebravo"}', :headers => {'Accept'=>'application/json', 'Authorization' => "Backchat #{API_KEY}"}).
+          to_return(:body => '{"data":{"uri":"twitter://juandebravo/#timeline"}, "errors":[]}')
+
+      bc = Backchat::Client.new(API_KEY)
+
+      channel = bc.create_channel("twitter", "juandebravo")
+      channel.should be_a(Hash)
+      channel.should have_key("uri")
+      channel["uri"].should eql("twitter://juandebravo/#timeline")
+    end
+  end
+
+  describe "when deleting a channel" do
+    it "returns ok when the channel exists and force is set to false" do
+      pending("need to fix web mock")
+      stub_request(:delete, "https://api.backchat.io/1/channels/").
+          with(:query => {"channel" => "twitter://juandebravo/#timeline"}, :headers => {'Accept'=>'application/json', 'Authorization' => "Backchat #{API_KEY}"}).
+          to_return(:body => '{"data":{"uri":"twitter://juandebravo/#timeline"}, "errors":[]}')
+
+      bc = Backchat::Client.new(API_KEY)
+      result = bc.destroy_channel("twitter://juandebravo/#timeline")
+      result.should eql(true)
+    end
+
+    it "returns ok when the channel exists and force is set to true" do
+      pending("need to fix web mock")
+      stub_request(:delete, "https://api.backchat.io/1/channels/").
+          with(:query => {"channel" => "twitter://juandebravo/#timeline", "force" => "true"}, :headers => {'Accept'=>'application/json', 'Authorization' => "Backchat #{API_KEY}"}).
+          to_return(:body => '{"data":{"uri":"twitter://juandebravo/#timeline"}, "errors":[]}')
+
+      bc = Backchat::Client.new(API_KEY)
+      result = bc.destroy_channel("twitter://juandebravo/#timeline", true)
+      result.should eql(true)
+    end
+
+
+  end
+
+end

data/spec/streams_spec.rb

@@ -0,0 +1,38 @@
+require 'backchat-client'
+require 'webmock/rspec'
+
+describe BackchatClient::Stream do
+  API_KEY = "valid_api_key"
+
+  before(:each) do
+    Backchat::Client.log_level = Logger::DEBUG
+  end
+
+  describe "when working with find method" do
+
+    it "gets all the user defined streams when no name is provided" do
+      pending
+    end
+
+    it "gets a specific stream when name is provided" do
+      pending
+    end
+
+  end
+
+  describe "when creating a stream" do
+    it "returns the stream identifier" do
+      pending
+      bc = Backchat::Client.new(API_KEY)
+      puts bc.create_stream("stream-name", nil, [{:channel => "twitter://juandebravo/#timeline", :enabled => true}])
+    end
+  end
+
+  describe "when deleting a stream" do
+    it "returns ok when the stream exists" do
+      pending
+      bc = Backchat::Client.new(API_KEY)
+      puts bc.destroy_stream("stream-name")
+    end
+  end
+end

data/spec/user_spec.rb

@@ -0,0 +1,38 @@
+require 'backchat-client'
+require 'webmock/rspec'
+
+describe BackchatClient::User do
+  
+  before(:each) do
+    Backchat::Client.log_level = Logger::DEBUG
+  end
+
+  describe "when working with find method" do
+
+    it "gets all the user defined streams when no name is provided" do
+      API_KEY = "valid_api_key"
+      bc = Backchat::Client.new(API_KEY)
+      stub_request(:get, "https://api.backchat.io/1/index.json?").
+                with(:headers => {'Accept'=>'application/json', 'Authorization' => "Backchat #{API_KEY}"}).
+                to_return(:status => 200, :body => "{'data':{'channels':[{'uri':'smtp://user.channel/'}, {'uri':'twitter://username'}],'email':'user@backchat.com','_id':'user_id','api_key':'#{API_KEY}','last_name':'lastname','first_name':'name','plan':'https://api.backchat.io/1/plans/free','streams':['https://api.backchat.io/1/streams/user-stream'],'login':'user'},'errors':[]}", :headers => {})
+
+      profile = bc.get_profile
+      ["channels", "email", "api_key"].each{|key|
+        profile.should have_key(key)
+      }
+    end
+  
+    it "deletes a user when valid api_key provided" do
+      API_KEY = "valid_api_key"
+      bc = Backchat::Client.new(API_KEY)
+      stub_request(:delete, "https://api.backchat.io/1/?").
+                with(:headers => {'Accept'=>'application/json', 'Authorization' => "Backchat #{API_KEY}"}).
+                to_return(:status => 200, :body => "", :headers => {})
+
+      result = bc.delete_user
+      result.should eql("")
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification 
+name: backchat-client
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: "0.1"
+platform: ruby
+authors: 
+- This gem provides an easy way to access Backchat provisioning API
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-26 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Gem to access Backchat provisioning API using rest_client as http client
+email: 
+- juandebravo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- backchat-client.gemspec
+- examples/add_channel_to_stream.rb
+- examples/create_channel.rb
+- examples/create_stream.rb
+- examples/delete_channel.rb
+- examples/delete_stream.rb
+- examples/delete_user.rb
+- examples/get_channels.rb
+- examples/stream.rb
+- examples/user.rb
+- lib/backchat-client.rb
+- lib/backchat_client/backchat_logger.rb
+- lib/backchat_client/channel.rb
+- lib/backchat_client/http_client.rb
+- lib/backchat_client/stream.rb
+- lib/backchat_client/user.rb
+- lib/backchat_client/version.rb
+- spec/backchat-client_spec.rb
+- spec/channel_spec.rb
+- spec/streams_spec.rb
+- spec/user_spec.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: backchat-client
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Gem to access Backchat provisioning API
+test_files: 
+- spec/backchat-client_spec.rb
+- spec/channel_spec.rb
+- spec/streams_spec.rb
+- spec/user_spec.rb