connfu-client 0.1

data/lib/connfu/provisioning/base.rb

@@ -0,0 +1,95 @@
+require 'rest_client'
+
+module Connfu
+  module Provisioning
+
+    ##
+    # This class is the responsible of any HTTP request to connFu endpoint
+    #
+    class Base
+
+      # valid api_key that authenticates the application
+      attr_accessor :api_key
+
+      # Connfu endpoint (host:port)
+      attr_accessor :endpoint
+
+      ##
+      # Initializer
+      # ==== Parameters
+      # * +api_key+ valid api_key that authenticates the application
+      # * +endpoint+ Connfu endpoint (host:port)
+      #
+      def initialize(api_key, endpoint = nil)
+        @api_key = api_key
+        @endpoint = endpoint.nil? ? Base.endpoint : endpoint # if no endpoint retrieved, try to use the class one
+      end
+
+      ##
+      # HTTP GET request
+      #
+      def get(path, params = {}, headers = {})
+        headers.merge!(base_headers).merge!({:Accept => "application/json"})
+        RestClient.get("#{@endpoint}/#{path}?".concat(params.collect { |k, v| "#{k}=#{v.to_s}" }.join("&")), headers)
+      end
+
+      ##
+      # HTTP POST request
+      #
+      def post(path, body = {}, headers = {})
+        headers.merge!(base_headers).merge!({:content_type => :json, :Accept => "application/json"})
+        RestClient.post("#{@endpoint}/#{path}", ActiveSupport::JSON.encode(body), headers) { |response, request, result|
+          case response.code
+            when 200..201
+              # If there is a :location header, return it
+              if response.headers.has_key?(:location)
+                return response.headers[:location]
+              end
+              # else, do the normal stuff
+              if block_given?
+                response.return!(request, result, &Proc.new)
+              else
+                response.return!(request, result)
+              end
+            else
+              if block_given?
+                response.return!(request, result, &Proc.new)
+              else
+                response.return!(request, result)
+              end
+          end
+        }
+      end
+
+      ##
+      # HTTP PUT request
+      #
+      def put(path, body = {}, headers = {})
+        headers.merge!(base_headers).merge!({:content_type => :json, :Accept => "application/json"})
+        RestClient.put("#{@endpoint}/#{path}", ActiveSupport::JSON.encode(body), headers)
+      end
+
+      ##
+      # HTTP DELETE request
+      #
+      def delete(path, params = {}, headers = {})
+        headers.merge!(base_headers).merge!({:content_type => :json, :Accept => "application/json"})
+        RestClient.delete("#{@endpoint}/#{path}?".concat(params.collect { |k, v| "#{k}=#{v.to_s}" }.join("&")), headers)
+      end
+
+      class << self
+        # Enable to configure just once the endpoint
+        attr_accessor :endpoint
+      end
+
+      private
+
+      ##
+      # Required HTTP headers to be sent in each request
+      def base_headers
+        {:AUTH_TOKEN => "#{@api_key}", :REQUEST_ID => "#{@api_key[0..10]}#{Time.now.to_i.to_s}"}
+      end
+
+    end
+  end
+end

data/lib/connfu/provisioning/channel.rb

@@ -0,0 +1,79 @@
+
+module Connfu
+  module Provisioning
+
+    ##
+    # Channel class models a connFu application channel. Its the superclass of Twitter and Voice and any other
+    # forthcoming connFu channel
+    class Channel
+
+      # created at timestamp
+      attr_accessor :created_at
+
+      # updated at timestamp
+      attr_accessor :updated_at
+
+      # channel unique identifier
+      attr_accessor :uid
+
+      # channel type
+      attr_accessor :type
+
+      # Creates a Channel instance using a Hash values
+      # It creates an instance variable per each hash key
+      def initialize(params)
+        self.type = self.class.to_s.downcase
+        params.each_pair { |key, value|
+          self.instance_variable_set("@#{key}", value)
+        }
+      end
+
+      # Creates a hash with the instance info
+      def to_hash
+        {"uid" => uid}
+      end
+
+      # Print object using metaprogramming. This method is used by any child class
+      def to_s
+        value = []
+        self.instance_variables.each { |var|
+          value << "#{var[1..-1]}: #{self.instance_variable_get(var)}"
+        }
+        self.class.name + "{\n" + value.join("\t\n").to_s + "\n}"
+      end
+
+      class << self
+
+        ##
+        #
+        # Creates a Channel instance (or a Channel child class instance) object or an Array using a Hash values
+        #
+        # ==== Parameters
+        #
+        # * +data+ - hash containing channel information retrieved using the connFu API
+        def unmarshal(data)
+
+          # Helper to get the channel class using the type attribute (we are
+          # retrieving all the channels) or the client class (we are retrieving
+          # specific a channel type)
+          create_channel = lambda { |channel|
+            if channel.has_key?("type") # get the class from type attribute (get all channels)
+              type = channel["type"].capitalize
+              Connfu::Provisioning.const_get(type).new(channel)
+            else # get the class from class
+              self.new(channel)
+            end
+          }
+
+          if data.is_a?(Array) # more than one element
+            data.map { |channel| create_channel.call(channel) }
+          else # one element
+            create_channel.call(data)
+          end
+        end
+      end
+
+
+    end
+  end
+end

data/lib/connfu/provisioning/phone.rb

@@ -0,0 +1,55 @@
+module Connfu
+
+  module Provisioning
+
+    #
+    # connFu Phone (belongs to a Voice channel)
+    #
+    class Phone
+
+      # specific country where the phone is allocated
+      attr_accessor :country
+
+      # phone number
+      attr_accessor :phone_number
+
+      # voice channel unique identifier
+      attr_reader :voice
+
+      # @param voice voice channel identifier
+      # @param phone_number
+      # @param country
+      def initialize(voice, phone_number, country = "")
+        @voice = voice
+        @phone_number = phone_number
+        @country = country
+      end
+      
+      # Hash way to retrieve attributes
+      def [](value)
+        self.respond_to?(value.to_sym) ? self.send(value.to_sym) : nil
+      end
+
+      def to_hash
+        {"country" => country, "phone_number" => phone_number}
+      end
+
+      def to_s
+        "#{self.class.to_s}: #{to_hash}"
+      end
+
+      #
+      # Creates a Phone object using the raw data from the provisioning API
+      # @param voice channel unique identifier
+      # @param data Hash containing the raw data
+      def self.unmarshal(voice, data)
+        if data.is_a?(Array)
+          data.map{|item| Phone.new(voice, item["phone_number"], item["country"])}
+        else
+          Phone.new(voice, data["phone_number"], data["country"])
+        end
+      end
+
+    end
+  end
+end

data/lib/connfu/provisioning/rss.rb

@@ -0,0 +1,21 @@
+module Connfu
+  module Provisioning
+
+    # This class models s connFu RSS channel
+    class Rss < Channel
+
+      # RSS URI
+      attr_accessor :uri
+
+      def initialize(params)
+        super(params)
+        self.type = "rss"
+      end
+
+      def to_hash
+        {"uid" => uid, "type" => type, "uri" => uri}
+      end
+
+    end
+  end
+end

data/lib/connfu/provisioning/twitter.rb

@@ -0,0 +1,28 @@
+
+module Connfu
+  module Provisioning
+
+    #
+    # This class models a connFu Twitter channel
+    #
+    class Twitter < Channel
+
+      # Twitter accounts associated to that Twitter channel
+      attr_accessor :accounts
+
+      # string that filters the tweets to retrieve only the desired hashtag
+      attr_accessor :filter
+
+      def initialize(params)
+        super(params)
+        self.type = "twitter"
+      end
+
+      # Creates a hash with the Twitter instance info
+      def to_hash
+        {"uid" => uid, "type" => type, "accounts" => accounts, "filter" => filter}
+      end
+
+    end
+  end
+end

data/lib/connfu/provisioning/voice.rb

@@ -0,0 +1,89 @@
+require 'connfu/provisioning/whitelist'
+
+module Connfu
+
+  module Provisioning
+
+    ##
+    # This class models a connFu Voice channel
+    #
+    class Voice < Channel
+
+      class Privacy
+        WHITELIST = "whitelisted"
+        PUBLIC = "public"
+      end
+      
+      # Voice channel attributes that could be updated
+      UPDATE_ATTRIBUTES = ["topic", "welcome_message", "rejected_message", "privacy"]
+
+      _values = UPDATE_ATTRIBUTES.dup
+      _values.each { |value|
+        UPDATE_ATTRIBUTES << value.to_sym
+      }
+      UPDATE_ATTRIBUTES.freeze
+      UPDATE_ATTRIBUTES.each { |value| value.freeze }
+
+      # current topic
+      attr_accessor :topic
+
+      # welcome message for valid users while joining the conference
+      attr_accessor :welcome_message
+
+      # rejected message for invalid users while trying to join the conference
+      attr_accessor :rejected_message
+
+      # Identifies if the conference is open to any phone number or users must 
+      # be whitelisted to join the conference
+      attr_accessor :privacy
+
+      def initialize(params)
+        super(params)
+        self.type = "voice"
+      end
+
+      def to_hash
+        {"uid" => uid, "type" => type, "phones" => phones.map(&:to_hash)}
+      end
+
+      # access the Voice channel Whitelist
+      def whitelist
+        Whitelist.new(@name)
+      end
+      
+      # Retrieves the phone numbers
+      def phone_number
+        values = phones.collect{|phone| phone[:phone_number]}
+      end
+
+      def phones
+        @phones||=[]
+      end
+
+      def phones=(_phones)
+        @phones=_phones
+      end
+
+      def <<(phone)
+        phones << phone
+      end
+
+      class << self
+
+        # Creates a Voice object or an Array using a Hash values
+        def unmarshal(data)
+          obj = super(data)
+          if obj.is_a?(Array) # more than one element
+            obj.each { |voice|
+              voice.phones = voice.phones.map { |phone| Phone.new(voice.uid, phone["phone_number"], phone["country"]) }
+            }
+          else # one element
+            obj.phones = obj.phones.map { |phone| Phone.new(obj.uid, phone["phone_number"], phone["country"]) }
+            obj
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/connfu/provisioning/whitelist.rb

@@ -0,0 +1,62 @@
+module Connfu
+
+  module Provisioning
+
+    ##
+    # This class defines a whitelist user (whitelist item)
+    WhitelistUser = Struct.new(:name, :phone)
+
+    ##
+    # This class models a conference whitelist
+    class Whitelist
+
+       # WhitelistUser array
+      attr_accessor :users
+
+      # Conference phone
+      attr_reader :voice
+
+      def initialize(voice, users = [])
+        @voice = voice
+        @users = users
+      end
+
+      # Iterator based on users array
+      def each
+        users.each{|user|
+          yield user
+        }
+      end
+
+      def to_s
+        value = []
+        self.instance_variables.each { |var|
+          value << "#{var}: #{self.instance_variable_get(var)}"
+        }
+        value.join("\n").to_s
+      end
+
+      ##
+      # Creates a Whitelist object using the raw data from the provisioning API
+      # ==== Parameters
+      # * +voice+ voice channel unique identifier
+      # * +data+ raw data retrieved using the connFu API
+      def self.unmarshal(voice, data)
+
+        if data.is_a?(Array)
+          numbers = []
+          data.each { |number|
+            numbers << WhitelistUser.new(*number.values)
+
+          }
+          users = numbers
+        else
+          users = [WhitelistUser.new(*data.values)]
+        end
+        Whitelist.new(voice, users)
+      end
+
+    end
+
+  end
+end

data/lib/connfu/version.rb

@@ -0,0 +1,6 @@
+
+module Connfu
+  ##
+  # Current connFu DSL version
+  VERSION = "0.1"
+end