restcomm-ruby 1.2.0

data/lib/restcomm-ruby/rest/conferences.rb

@@ -0,0 +1,12 @@
+module Restcomm
+  module REST
+    class Conferences < ListResource; end
+
+    class Conference < InstanceResource
+      def initialize(path, client, params={})
+        super path, client, params
+        resource :participants
+      end
+    end
+  end
+end

data/lib/restcomm-ruby/rest/conferences/participants.rb

@@ -0,0 +1,23 @@
+module Restcomm
+  module REST
+    class Participants < ListResource
+      def initialize(path, client)
+        super
+        # hard-code the json key since participants don't have sids
+        @instance_id_key = 'call_sid'
+      end
+    end
+
+    class Participant < InstanceResource
+      def mute
+        update muted: 'true'
+      end
+
+      def unmute
+        update muted: 'false'
+      end
+
+      alias :kick :delete
+    end
+  end
+end

data/lib/restcomm-ruby/rest/connect_apps.rb

@@ -0,0 +1,6 @@
+module Restcomm
+  module REST
+    class ConnectApps < ListResource; end
+    class ConnectApp < InstanceResource; end
+  end
+end

data/lib/restcomm-ruby/rest/errors.rb

@@ -0,0 +1,14 @@
+module Restcomm
+  module REST
+    class ServerError < StandardError; end
+
+    class RequestError < StandardError
+      attr_reader :code
+
+      def initialize(message, code=nil);
+        super message
+        @code = code
+      end
+    end
+  end
+end

data/lib/restcomm-ruby/rest/incoming_phone_numbers.rb

@@ -0,0 +1,17 @@
+module Restcomm
+  module REST
+    class IncomingPhoneNumbers < ListResource
+      def initialize(path, client)
+        super
+        @submodule = :NumberType
+        resource :mobile, :local, :toll_free
+      end
+
+      def buy(phone_number)
+        create phone_number: phone_number
+      end
+    end
+
+    class IncomingPhoneNumber < InstanceResource; end
+  end
+end

data/lib/restcomm-ruby/rest/incoming_phone_numbers/local.rb

@@ -0,0 +1,13 @@
+module Restcomm
+  module REST
+    module NumberType
+      class Local < ListResource
+        def initialize(path, client)
+          @path, @client = path, client
+          @instance_class = Restcomm::REST::IncomingPhoneNumber
+          @list_key, @instance_id_key = 'incoming_phone_numbers', 'sid'
+        end
+      end
+    end
+  end
+end

data/lib/restcomm-ruby/rest/incoming_phone_numbers/mobile.rb

@@ -0,0 +1,13 @@
+module Restcomm
+  module REST
+    module NumberType
+      class Mobile < ListResource
+        def initialize(path, client)
+          @path, @client = path, client
+          @instance_class = Restcomm::REST::IncomingPhoneNumber
+          @list_key, @instance_id_key = 'incoming_phone_numbers', 'sid'
+        end
+      end
+    end
+  end
+end

data/lib/restcomm-ruby/rest/incoming_phone_numbers/toll_free.rb

@@ -0,0 +1,13 @@
+module Restcomm
+  module REST
+    module NumberType
+      class TollFree < ListResource
+        def initialize(path, client)
+          @path, @client = path, client
+          @instance_class = Restcomm::REST::IncomingPhoneNumber
+          @list_key, @instance_id_key = 'incoming_phone_numbers', 'sid'
+        end
+      end
+    end
+  end
+end

data/lib/restcomm-ruby/rest/instance_resource.rb

@@ -0,0 +1,88 @@
+module Restcomm
+  module REST
+    ##
+    # A class to wrap an instance resource (like a call or application) within
+    # the Restcomm API. All other instance resource classes within this library
+    # inherit from this class. You shouldn't need to instantiate this class
+    # directly. But reviewing the available methods is informative since they
+    # are rarely overridden in the inheriting class.
+    class InstanceResource
+      include Utils
+
+      ##
+      # Instantiate a new instance resource object. You must pass the +path+ of
+      # the instance (e.g. /2010-04-01/Accounts/AC123/Calls/CA456) as well as a
+      # +client+ object that responds to #get #post and #delete. This client
+      # is meant to be an instance of Restcomm::REST::Client but could just as
+      # well be a mock object if you want to test the interface. The optional
+      # +params+ hash will be converted into attributes on the instantiated
+      # object.
+      def initialize(path, client, params = {})
+        @path, @client = path, client
+        set_up_properties_from params
+      end
+
+      def inspect # :nodoc:
+        "<#{self.class} @path=#{@path}>"
+      end
+
+      ##
+      # Update the properties of this instance resource using the key/value
+      # pairs in +params+. This makes an HTTP POST request to <tt>@path</tt>
+      # to handle the update. For example, to update the +VoiceUrl+ of a Restcomm
+      # Application you could write:
+      #
+      #   @app.update voice_url: 'http://my.other.app.com/handle_voice'
+      #
+      # After returning, the object will contain the most recent state of the
+      # instance resource, including the newly updated properties.
+      def update(params = {})
+        raise "Can't update a resource without a REST Client" unless @client
+        set_up_properties_from(@client.post(@path, params))
+        #self
+      end
+
+      ##
+      # Refresh the attributes of this instance resource object by fetching it
+      # from Restcomm. Calling this makes an HTTP GET request to <tt>@path</tt>.
+      def refresh
+        raise "Can't refresh a resource without a REST Client" unless @client
+        @updated = false
+        set_up_properties_from(@client.get(@path))
+        self
+      end
+
+      ##
+      # Delete an instance resource from Restcomm. This operation isn't always
+      # supported. For instance, you can't delete an SMS. Calling this method
+      # makes an HTTP DELETE request to <tt>@path</tt>.
+      def delete
+        raise "Can't delete a resource without a REST Client" unless @client
+        @client.delete @path
+      end
+
+
+      ##
+      # Lazily load attributes of the instance resource by waiting to fetch it
+      # until an attempt is made to access an unknown attribute.
+      def method_missing(method, *args)
+        super if @updated
+        set_up_properties_from(@client.get(@path))
+        self.send method, *args
+      end
+
+      protected
+
+      def set_up_properties_from(hash)
+       eigenclass = class << self; self; end
+        hash.each do |p,v|
+          property = derestify p
+          unless ['client', 'updated'].include? property
+            eigenclass.send :define_method, property.to_sym, &lambda { v }
+          end
+        end
+        @updated = !hash.keys.empty?
+      end
+    end
+  end
+end

data/lib/restcomm-ruby/rest/list_resource.rb

@@ -0,0 +1,132 @@
+require 'json'
+require 'rubygems'
+module Restcomm
+  module REST
+    class ListResource
+      include Utils
+
+      def initialize(path, client)
+        custom_names = {
+          'Activities' => 'Activity',
+          'Media' => 'MediaInstance',
+          'IpAddresses' => 'IpAddress',
+          'Feedback' => 'FeedbackInstance',
+          'Addresses' => 'Address'
+        }
+        @path, @client = path, client
+
+        resource_name = self.class.name.split('::')[-1]
+
+        instance_name = custom_names.fetch(resource_name, resource_name.chop)
+
+
+        # The next line grabs the enclosing module. Necessary for resources
+        # contained in their own submodule like /SMS/Messages
+        parent_module = self.class.to_s.split('::')[-2]
+        full_module_path = if parent_module == "REST"
+          Restcomm::REST
+        else
+          Restcomm::REST.const_get(parent_module)
+        end
+
+        @instance_class = full_module_path.const_get(instance_name)
+	
+        @list_key, @instance_id_key = derestify(resource_name), 'sid'
+
+      end
+
+      def inspect # :nodoc:
+        "<#{self.class} @path=#{@path}>"
+      end
+
+      ##
+      # Grab a list of this kind of resource and return it as an array. The
+      # array includes a special attribute named +total+ which will return the
+      # total number of items in the list on Restcomm's server. This may differ
+      # from the +size+ and +length+ attributes of the returned array since
+      # by default Restcomm will only return 50 resources, and the maximum number
+      # of resources you can request is 1000.
+      #
+      # The optional +params+ hash allows you to filter the list returned. The
+      # filters for each list resource type are defined by Restcomm.
+      def list(params={}, full_path=false)
+        raise "Can't get a resource list without a REST Client" unless @client
+
+
+        response = @client.get( @path, params, full_path)
+
+
+	if @list_key == "calls" 
+		resources = response[@list_key]
+	elsif @list_key == "recordings" 	 
+		resources = response
+	else
+		resources = response
+	end	
+
+	path = full_path ? @path.split('.')[0] : @path
+	
+	resource_list = resources.map do |resource| 
+        @instance_class.new("#{path}/#{resource[@instance_id_key]}", @client, resource)
+	end
+
+
+        # set the +total+ and +next_page+ properties on the array
+        client, list_class = @client, self.class
+        resource_list.instance_eval do
+          eigenclass = class << self; self; end
+          eigenclass.send :define_method, :total, &lambda { response['total'] }
+          eigenclass.send :define_method, :next_page, &lambda {
+            if response['next_page_uri']
+              list_class.new(response['next_page_uri'], client).list({}, true)
+            else
+              []
+            end
+          }
+        end
+
+        resource_list
+
+
+      end
+
+
+
+      ##
+      # Ask Restcomm for the total number of items in the list.
+      # Calling this method makes an HTTP GET request to <tt>@path</tt> with a
+      # page size parameter of 1 to minimize data over the wire while still
+      # obtaining the total. Don't use this if you are planning to
+      # call #list anyway, since the array returned from #list will have a
+      # +total+ attribute as well.
+      def total
+        raise "Can't get a resource total without a REST Client" unless @client
+        @client.get(@path, page_size: 1)['total']
+      end
+
+      ##
+      # Return an empty instance resource object with the proper path. Note that
+      # this will never raise a Restcomm::REST::RequestError on 404 since no HTTP
+      # request is made. The HTTP request is made when attempting to access an
+      # attribute of the returned instance resource object, such as
+      # its #date_created or #voice_url attributes.
+      def get(sid)
+        @instance_class.new "#{@path}/#{sid}", @client
+      end
+      alias :find :get # for the ActiveRecord lovers
+
+      ##
+      # Return a newly created resource. Some +params+ may be required. Consult
+      # the Restcomm REST API documentation related to the kind of resource you
+      # are attempting to create for details. Calling this method makes an HTTP
+      # POST request to <tt>@path</tt> with the given params
+      def create(params={})
+        raise "Can't create a resource without a REST Client" unless @client
+        response = @client.post @path, params
+        @instance_class.new "#{@path}/#{response[@instance_id_key]}", @client,
+      
+	response
+      end
+    end
+  end
+end

data/lib/restcomm-ruby/rest/media.rb

@@ -0,0 +1,14 @@
+module Restcomm
+  module REST
+    class Media < ListResource
+
+      def initialize(path, client)
+        super
+        @list_key = 'media_list'
+      end
+
+    end
+
+    class MediaInstance < InstanceResource; end
+  end
+end

data/lib/restcomm-ruby/rest/messages.rb

@@ -0,0 +1,23 @@
+module Restcomm
+  module REST
+    class Messages < ListResource
+      def initialize(path, client)
+       # path.gsub! '/SMS', ''
+       path.gsub! '/Messages', '/SMS/Messages'
+        super
+      end
+    end
+
+    class Message < InstanceResource
+      def initialize(path, client, params={})
+        super
+        resource :media
+      end
+
+      def redact()
+        update({body: ''})
+      end
+
+    end
+  end
+end

data/lib/restcomm-ruby/rest/next_gen_list_resource.rb

@@ -0,0 +1,29 @@
+module Restcomm
+  module REST
+    class NextGenListResource < Restcomm::REST::ListResource
+      def list(params={}, full_path=false)
+        raise "Can't get a resource list without a REST Client" unless @client
+        response = @client.get @path, params, full_path
+        list_key = response['meta']['key']
+        raise "Couldn't find a list key in response meta" unless list_key
+        resources = response[list_key]
+        resource_list = resources.map do |resource|
+          @instance_class.new "#{@path}/#{resource[@instance_id_key]}", @client,
+                              resource
+        end
+        client, list_class = @client, self.class
+        resource_list.instance_eval do
+          eigenclass = class << self; self; end
+          eigenclass.send :define_method, :next_page, &lambda {
+            if response['meta']['next_page_url']
+              list_class.new(response['meta']['next_page_url'], client).list({})
+            else
+              []
+            end
+          }
+        end
+        resource_list
+      end
+    end
+  end
+end

data/lib/restcomm-ruby/rest/notifications.rb

@@ -0,0 +1,6 @@
+module Restcomm
+  module REST
+    class Notifications < ListResource; end
+    class Notification < InstanceResource; end
+  end
+end

data/lib/restcomm-ruby/rest/outgoing_caller_ids.rb

@@ -0,0 +1,25 @@
+module Restcomm
+  module REST
+    class OutgoingCallerIds < ListResource
+      def add(phone_number)
+        create phone_number: phone_number
+      end
+      alias :verify :add
+
+      ##
+      # Override ListResource#create to instantiate the proper instance class.
+      # This doesn't actually matter since all properties are lazily loaded into
+      # whatever object is instantiated. But it might matter in the future.
+      def create(params={}) # :nodoc:
+        old_instance_class = @instance_class
+        @instance_class = Restcomm::REST::PhoneNumberVerificationRequest
+        verification_request = super
+        @instance_class = old_instance_class
+        verification_request
+      end
+    end
+
+    class OutgoingCallerId < InstanceResource; end
+    class PhoneNumberVerificationRequest < InstanceResource; end
+  end
+end