ruby-bandwidth-iris 2.3.0 → 2.7.1

data/examples/create_reservation_and_order.rb

@@ -0,0 +1,79 @@
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'ruby-bandwidth-iris'
+
+$bandwidth_account_id = ENV['BANDWIDTH_ACCOUNT_ID']
+$bandwidth_user_name = ENV['BANDWIDTH_API_USER']
+$bandwidth_password = ENV['BANDWIDTH_API_PASSWORD']
+## Fill these in
+$bandwidth_site_id = ENV['BANDWIDTH_SITE_ID']
+$bandwidth_to_sippeer_id = ENV['BANDWIDTH_SIPPEER_ID']
+
+
+def get_order_by_id(client, order_id:, attempts: 0)
+  begin
+    order_result = BandwidthIris::Order.get(client, order_id)
+    return order_result
+  rescue Exception => e
+    if attempts > 3
+      puts("Completely Failed fetching Order")
+      raise StandardError.new e
+    end
+    puts("Error Message: #{e.message}")
+    attempts = attempts+1
+    sleep(1)
+    return get_order_by_id(client, order_id: order_id, attempts: attempts)
+  end
+end
+
+def get_numbers_from_order_id(client, order_id:)
+  order = BandwidthIris::Order.new({:id => order_id}, client)
+  numbers_result = order.get_tns
+  return numbers_result
+end
+
+def order_numbers_with_reservation_id(client, reservation_id:, number:)
+  order_data = {
+      :name => "Reservation Test",
+      :site_id => $bandwidth_site_id,
+      :existing_telephone_number_order_type => {
+          :telephone_number_list => [
+              :telephone_number => number
+          ],
+          :reservation_id_list => [
+            :reservation_id => reservation_id
+          ]
+      }
+  }
+  order_result = BandwidthIris::Order.create(client, order_data)
+  return order_result
+end
+
+def reserve_numbers(client, number:)
+  reservation = BandwidthIris::TnReservation.create(client, number)
+  return reservation
+end
+
+def search_numbers(client, area_code: 919)
+  list = BandwidthIris::AvailableNumber.list(client, {:area_code => area_code, :quantity => 5})
+  return list
+end
+
+def main()
+  client = BandwidthIris::Client.new($bandwidth_account_id, $bandwidth_user_name, $bandwidth_password)
+  available_numbers = search_numbers(client)
+  number = available_numbers[0]
+  reservation = reserve_numbers(client, number: number)
+  reservation_id = reservation.id
+  order = order_numbers_with_reservation_id(client, reservation_id: reservation_id, number: number)
+  order_id = order.id
+  puts(order_id)
+  my_order = get_order_by_id(client, order_id: order_id)
+  my_numbers = get_numbers_from_order_id(client, order_id:order_id)
+  puts(my_numbers)
+end
+
+if __FILE__ == $0
+  main
+end

data/examples/order_number.rb

@@ -0,0 +1,83 @@
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "ruby-bandwidth-iris"
+
+def order_numbers_in_area_code(client, site_id:, sippeer_id:, area_code: 919, quantity: 1)
+  order_data = {
+      :name => "Test",
+      :site_id => site_id,
+      :area_code_search_and_order_type => {
+          :area_code => area_code,
+          :quantity => quantity
+      }
+  }
+  order_result = BandwidthIris::Order.create(client, order_data)
+  order_id = order_result.to_data[:id]
+  return order_id
+end
+
+def get_order_by_id(client, order_id:, attempts: 0)
+  begin
+    order_result = BandwidthIris::Order.get(client, order_id)
+    return order_result
+  rescue Exception => e
+    if attempts > 3
+      puts("Completely Failed fetching Order")
+      raise StandardError.new e
+    end
+    puts("Error Message: #{e.message}\nCode:#{e.code}")
+    attempts = attempts+1
+    sleep(1)
+    return get_order_by_id(client, order_id: order_id, attempts: attempts)
+  end
+end
+
+def get_order_response_by_id(client, order_id:, attempts: 0)
+  begin
+    order_response = BandwidthIris::Order.get_order_response(client, order_id)
+    order_data = order_response.to_data
+    numbers = order_response.completed_numbers
+    completed_number = order_data[:completed_numbers][:telephone_number][:full_number]
+    return order_data
+  rescue Exception => e
+    if attempts > 3
+      puts("Completely Failed fetching Order")
+      raise StandardError.new e
+    end
+    puts("Error Message: #{e.message}\nCode:#{e.code}")
+    attempts = attempts+1
+    sleep(1)
+    return get_order_response(client, order_id: order_id, attempts: attempts)
+  end
+end
+
+
+def get_numbers_from_order_id(client, order_id:)
+  order = BandwidthIris::Order.new({:id => order_id}, client)
+  numbers_result = order.get_tns
+  return numbers_result
+end
+
+def get_numbers_from_order(order)
+  numbers_result = order.get_tns
+  return numbers_result
+end
+
+def main
+  bandwidth_account_id = ENV["BANDWIDTH_ACCOUNT_ID"]
+  bandwidth_user_name = ENV["BANDWIDTH_API_USER"]
+  bandwidth_password = ENV["BANDWIDTH_API_PASSWORD"]
+  bandwidth_site_id = ENV["BANDWIDTH_SITE_ID"]
+  bandwidth_to_sippeer_id = ENV["BANDWIDTH_SIPPEER_ID"]
+  client = BandwidthIris::Client.new(bandwidth_account_id, bandwidth_user_name, bandwidth_password)
+  order_id = order_numbers_in_area_code(client, site_id: bandwidth_site_id, sippeer_id: bandwidth_to_sippeer_id)
+  my_order = get_order_by_id(client, order_id: order_id)
+  my_order_response = get_order_response_by_id(client, order_id: order_id)
+  my_numbers = get_numbers_from_order_id(client, order_id:order_id)
+  my_numbers = get_numbers_from_order(my_order)
+end
+
+if __FILE__ == $0
+  main
+end

data/lib/bandwidth-iris/aeui.rb

@@ -0,0 +1,20 @@
+module BandwidthIris
+  AEUI_PATH = 'aeuis'
+
+  class AlternateEndUserIdentity
+    extend ClientWrapper
+    include ApiItem
+
+    def self.get_alternate_end_user_information(client, query=nil)
+      response = client.make_request(:get, "#{client.concat_account_path(AEUI_PATH)}", query)
+      return response[0]
+    end
+    wrap_client_arg :get_alternate_end_user_information    
+
+    def self.get_alternate_caller_information(client, acid)
+      response = client.make_request(:get, "#{client.concat_account_path(AEUI_PATH)}/#{acid}")
+      return response[0][:alternate_end_user_identifier]
+    end
+    wrap_client_arg :get_alternate_caller_information
+  end
+end

data/lib/bandwidth-iris/applications.rb

@@ -0,0 +1,61 @@
+module BandwidthIris
+  APPLICATIONS_PATH = "applications"
+
+  class Applications
+    extend ClientWrapper
+    include ApiItem
+
+    def self.get_applications(client)
+      data = client.make_request(:get, client.concat_account_path(APPLICATIONS_PATH))
+      list = data[0][:application_list][:application]
+      return [] if !list
+      if list.is_a?(Array) then
+        return list
+      else
+        return [list]
+      end
+    end
+    wrap_client_arg :get_applications
+
+    def self.create_application(client, application_data)
+      data = client.make_request(:post, client.concat_account_path(APPLICATIONS_PATH), {:application => application_data})
+      return data[0][:application]
+    end
+    wrap_client_arg :create_application
+
+    def self.get_application(client, application_id)
+      data = client.make_request(:get, client.concat_account_path("#{APPLICATIONS_PATH}/#{application_id}"))
+      return data[0][:application]
+    end
+    wrap_client_arg :get_application
+
+    def self.partial_update_application(client, application_id, application_data)
+      data = client.make_request(:patch, client.concat_account_path("#{APPLICATIONS_PATH}/#{application_id}"), {:application => application_data})
+      return data[0][:application]
+    end
+    wrap_client_arg :partial_update_application
+
+    def self.complete_update_application(client, application_id, application_data)
+      data = client.make_request(:put, client.concat_account_path("#{APPLICATIONS_PATH}/#{application_id}"), {:application => application_data})
+      return data[0][:application]
+    end
+    wrap_client_arg :complete_update_application
+
+    def self.delete_application(client, application_id)
+      client.make_request(:delete, client.concat_account_path("#{APPLICATIONS_PATH}/#{application_id}"))
+    end
+    wrap_client_arg :delete_application
+
+    def self.get_application_sippeers(client, application_id)
+      data = client.make_request(:get, client.concat_account_path("#{APPLICATIONS_PATH}/#{application_id}/associatedsippeers"))
+      list = data[0][:associated_sip_peers][:associated_sip_peer]
+      return [] if !list
+      if list.is_a?(Array) then
+        return list
+      else
+        return [list]
+      end
+    end
+    wrap_client_arg :get_application_sippeers
+  end
+end

data/lib/bandwidth-iris/client.rb

@@ -22,7 +22,7 @@ module BandwidthIris
       password = options[:password] unless password
       options[:api_endpoint] = @@global_options[:api_endpoint] unless options[:api_endpoint]
       options[:api_version] = @@global_options[:api_version] unless options[:api_version]
-      api_endpoint = options[:api_endpoint] || "https://api.inetwork.com"
+      api_endpoint = options[:api_endpoint] || "https://dasbhoard.bandwidth.com"
       api_version = options[:api_version] || "v1.0"
 
       @build_path = lambda {|path| "/#{api_version}" + (if path[0] == "/" then path else "/#{path}" end) }
@@ -32,6 +32,7 @@ module BandwidthIris
           faraday.basic_auth(user_name, password)
           #faraday.response :logger
           faraday.headers['Accept'] = 'application/xml'
+          faraday.headers['user-agent'] = 'Ruby-Bandwidth-Iris'
           faraday.use FaradayMiddleware::FollowRedirects
           @set_adapter.call(faraday)
         }
@@ -77,7 +78,8 @@ module BandwidthIris
                       req.params = d unless d == nil || d.empty?
                     end
                   else
-                    connection.run_request(method, @build_path.call(path), build_xml(data), {'Content-Type' => 'application/xml'})
+                    xml_to_send = build_xml(data) # help debug
+                    connection.run_request(method, @build_path.call(path), xml_to_send, {'Content-Type' => 'application/xml'})
                   end
       body = check_response(response)
       [body || {}, symbolize(response.headers || {})]
@@ -86,7 +88,7 @@ module BandwidthIris
     # Makes an HTTP request for file uploads
     # @param method [Symbol] http method to make
     # @param path [string] path of url (exclude api verion and endpoint) to make call
-    # @param data [string] the raw binary string representing the file to upload 
+    # @param data [string] the raw binary string representing the file to upload
     # @param content_type [string] the content type of the request
     # @return [Array] array with 2 elements: parsed  data of response and response headers
     def make_request_file_upload(method, path, data, content_type)
@@ -100,7 +102,7 @@ module BandwidthIris
     # @param method [Symbol] http method to make
     # @param path [string] path of url (exclude api verion and endpoint) to make call
     # @param data [Hash] data  which will be sent with request (for :get and :delete request they will be sent with query in url)
-    # @return [string] raw response from the API 
+    # @return [string] raw response from the API
     def make_request_file_download(method, path, data = {})
       connection = @create_connection.call()
       response =  if method == :get || method == :delete

data/lib/bandwidth-iris/emergency_notification_endpoints.rb

@@ -0,0 +1,26 @@
+module BandwidthIris
+  ENE_ORDERS_PATH = 'emergencyNotificationEndpointOrders'
+
+  class EmergencyNotificationEndpoints
+    extend ClientWrapper
+    include ApiItem
+
+    def self.create_emergency_notification_endpoint_order(client, data)
+      response = client.make_request(:post, "#{client.concat_account_path(ENE_ORDERS_PATH)}", {:emergency_notification_endpoint_order => data})
+      return response[0][:emergency_notification_endpoint_order]
+    end
+    wrap_client_arg :create_emergency_notification_endpoint_order
+
+    def self.get_emergency_notification_endpoint_orders(client, query=nil)
+      response = client.make_request(:get, "#{client.concat_account_path(ENE_ORDERS_PATH)}", query)
+      return response[0]
+    end
+    wrap_client_arg :get_emergency_notification_endpoint_orders
+
+    def self.get_emergency_notification_endpoint_order(client, order_id)
+      response = client.make_request(:get, "#{client.concat_account_path(ENE_ORDERS_PATH)}/#{order_id}")
+      return response[0][:emergency_notification_endpoint_order]
+    end
+    wrap_client_arg :get_emergency_notification_endpoint_order
+  end
+end

data/lib/bandwidth-iris/emergency_notification_groups.rb

@@ -0,0 +1,39 @@
+module BandwidthIris
+  ENG_ORDERS_PATH = 'emergencyNotificationGroupOrders'
+  ENG_PATH = 'emergencyNotificationGroups'
+
+  class EmergencyNotificationGroups
+    extend ClientWrapper
+    include ApiItem
+
+    def self.create_emergency_notification_group_order(client, data)
+      response = client.make_request(:post, "#{client.concat_account_path(ENG_ORDERS_PATH)}", {:emergency_notification_group_order => data})
+      return response[0][:emergency_notification_endpoint_order]
+    end
+    wrap_client_arg :create_emergency_notification_group_order
+
+    def self.get_emergency_notification_group_orders(client, query=nil)
+      response = client.make_request(:get, "#{client.concat_account_path(ENG_ORDERS_PATH)}", query)
+      return response[0]
+    end
+    wrap_client_arg :get_emergency_notification_group_orders
+
+    def self.get_emergency_notification_group_order(client, order_id)
+      response = client.make_request(:get, "#{client.concat_account_path(ENG_ORDERS_PATH)}/#{order_id}")
+      return response[0][:emergency_notification_endpoint_order]
+    end
+    wrap_client_arg :get_emergency_notification_group_order
+
+    def self.get_emergency_notification_group(client, eng_id)
+      response = client.make_request(:get, "#{client.concat_account_path(ENG_PATH)}/#{eng_id}")
+      return response[0][:emergency_notification_group]
+    end
+    wrap_client_arg :get_emergency_notification_group
+
+    def self.get_emergency_notification_groups(client, query=nil)
+      response = client.make_request(:get, "#{client.concat_account_path(ENG_PATH)}", query)
+      return response[0]
+    end
+    wrap_client_arg :get_emergency_notification_groups
+  end
+end

data/lib/bandwidth-iris/emergency_notification_recipients.rb

@@ -0,0 +1,37 @@
+module BandwidthIris
+  ENR_PATH = 'emergencyNotificationRecipients'
+
+  class EmergencyNotificationRecipients
+    extend ClientWrapper
+    include ApiItem
+
+    def self.create_emergency_notification_recipient(client, data)
+      response = client.make_request(:post, "#{client.concat_account_path(ENR_PATH)}", {:emergency_notification_recipient => data})
+      return response[0][:emergency_notification_recipient]
+    end
+    wrap_client_arg :create_emergency_notification_recipient
+
+    def self.get_emergency_notification_recipients(client, query=nil)
+      response = client.make_request(:get, "#{client.concat_account_path(ENR_PATH)}", query)
+      return response[0]
+    end
+    wrap_client_arg :get_emergency_notification_recipients
+
+    def self.get_emergency_notification_recipient(client, enr_id)
+      response = client.make_request(:get, "#{client.concat_account_path(ENR_PATH)}/#{enr_id}")
+      return response[0][:emergency_notification_recipient]
+    end
+    wrap_client_arg :get_emergency_notification_recipient
+
+    def self.replace_emergency_notification_recipient(client, enr_id, data)
+      response = client.make_request(:put, "#{client.concat_account_path(ENR_PATH)}/#{enr_id}", {:emergency_notification_recipient => data})
+      return response[0][:emergency_notification_recipient]
+    end
+    wrap_client_arg :replace_emergency_notification_recipient
+
+    def self.delete_emergency_notification_recipient(client, enr_id)
+      client.make_request(:delete, "#{client.concat_account_path(ENR_PATH)}/#{enr_id}")
+    end
+    wrap_client_arg :delete_emergency_notification_recipient
+  end
+end

data/lib/bandwidth-iris/order.rb

@@ -13,6 +13,14 @@ module BandwidthIris
 
     def self.get(client, id)
       data = client.make_request(:get, "#{client.concat_account_path(ORDER_PATH)}/#{id}")[0][:order]
+      data[:id] = id
+      Order.new(data, client)
+    end
+    wrap_client_arg :get
+
+    def self.get_order_response(client, id)
+      data = client.make_request(:get, "#{client.concat_account_path(ORDER_PATH)}/#{id}")[0]
+      data[:id] = id
       Order.new(data, client)
     end
     wrap_client_arg :get

data/lib/bandwidth-iris/sip_peer_products.rb

@@ -0,0 +1,118 @@
+module BandwidthIris
+  SIPPEER_PRODUCTS_PATH = 'products'
+
+  class SipPeerProducts
+    extend ClientWrapper
+    include ApiItem
+
+    def self.get_origination_settings(client, site_id, sippeer_id)
+      response = client.make_request(:get, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/origination/settings")
+      return response[0][:sip_peer_origination_settings]
+    end
+    wrap_client_arg :get_origination_settings
+
+    def self.create_origination_settings(client, site_id, sippeer_id, data)
+      response = client.make_request(:post, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/origination/settings", {:sip_peer_origination_settings => data})
+      return response[0][:sip_peer_origination_settings]
+    end
+    wrap_client_arg :create_origination_settings
+
+    def self.update_origination_settings(client, site_id, sippeer_id, data)
+      client.make_request(:put, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/origination/settings", {:sip_peer_origination_settings => data})
+    end
+    wrap_client_arg :update_origination_settings
+
+    def self.get_termination_settings(client, site_id, sippeer_id)
+      response = client.make_request(:get, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/termination/settings")
+      return response[0][:sip_peer_termination_settings]
+    end
+    wrap_client_arg :get_termination_settings
+
+    def self.create_termination_settings(client, site_id, sippeer_id, data)
+      response = client.make_request(:post, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/termination/settings", {:sip_peer_termination_settings => data})
+      return response[0][:sip_peer_termination_settings]
+    end
+    wrap_client_arg :create_termination_settings
+
+    def self.update_termination_settings(client, site_id, sippeer_id, data)
+      client.make_request(:put, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/termination/settings", {:sip_peer_termination_settings => data})
+    end
+    wrap_client_arg :update_termination_settings
+
+    def self.get_sms_feature_settings(client, site_id, sippeer_id)
+      response = client.make_request(:get, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/features/sms")
+      return response[0][:sip_peer_sms_feature]
+    end
+    wrap_client_arg :get_sms_feature_settings
+
+    def self.create_sms_feature_settings(client, site_id, sippeer_id, data)
+      response = client.make_request(:post, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/features/sms", {:sip_peer_sms_feature => data})
+      return response[0][:sip_peer_sms_feature]
+    end
+    wrap_client_arg :create_sms_feature_settings
+
+    def self.update_sms_feature_settings(client, site_id, sippeer_id, data)
+      response = client.make_request(:put, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/features/sms", {:sip_peer_sms_feature => data})
+      return response[0][:sip_peer_sms_feature]
+    end
+    wrap_client_arg :update_sms_feature_settings
+
+    def self.delete_sms_feature_settings(client, site_id, sippeer_id)
+      response = client.make_request(:delete, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/features/sms")
+      return response
+    end
+    wrap_client_arg :delete_sms_feature_settings
+
+    def self.get_mms_feature_settings(client, site_id, sippeer_id)
+      response = client.make_request(:get, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/features/mms")
+      return response[0][:mms_feature]
+    end
+    wrap_client_arg :get_mms_feature_settings
+
+    def self.create_mms_feature_settings(client, site_id, sippeer_id, data)
+      response = client.make_request(:post, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/features/mms", {:mms_feature => data})
+      return response[0][:mms_feature]
+    end
+    wrap_client_arg :create_mms_feature_settings
+
+    def self.update_mms_feature_settings(client, site_id, sippeer_id, data)
+      client.make_request(:put, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/features/mms", {:mms_feature => data})
+    end
+    wrap_client_arg :update_mms_feature_settings
+
+    def self.delete_mms_feature_settings(client, site_id, sippeer_id)
+      client.make_request(:delete, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/features/mms")
+    end
+    wrap_client_arg :delete_mms_feature_settings
+
+    def self.get_mms_feature_mms_settings(client, site_id, sippeer_id)
+      response = client.make_request(:get, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/features/mms/settings")
+      return response[0][:mms_settings]
+    end
+    wrap_client_arg :get_mms_feature_mms_settings
+
+    def self.get_messaging_application_settings(client, site_id, sippeer_id)
+      response = client.make_request(:get, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/applicationSettings")
+      return response[0][:applications_settings]
+    end
+    wrap_client_arg :get_messaging_application_settings
+
+    def self.update_messaging_application_settings(client, site_id, sippeer_id, data)
+      response = client.make_request(:put, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/applicationSettings", {:applications_settings => data})
+      return response[0][:applications_settings]
+    end
+    wrap_client_arg :update_messaging_application_settings
+
+    def self.get_messaging_settings(client, site_id, sippeer_id)
+      response = client.make_request(:get, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/settings")
+      return response[0][:sip_peer_messaging_settings]
+    end
+    wrap_client_arg :get_messaging_settings
+
+    def self.update_messaging_settings(client, site_id, sippeer_id, data)
+      response = client.make_request(:put, "#{client.concat_account_path(SITE_PATH)}/#{site_id}/#{SIPPEER_PATH}/#{sippeer_id}/#{SIPPEER_PRODUCTS_PATH}/messaging/settings", {:sip_peer_messaging_settings => data})
+      return response[0][:sip_peer_messaging_settings]
+    end
+    wrap_client_arg :update_messaging_settings
+  end
+end