ruby-bandwidth-iris 2.1.0 → 2.6.0

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

@@ -77,12 +77,44 @@ 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 || {})]
     end
 
+    # 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 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)
+      connection = @create_connection.call()
+      response = connection.run_request(method, @build_path.call(path), data, {'Content-Type' => content_type})
+      body = check_response(response)
+      [body || {}, symbolize(response.headers || {})]
+    end
+
+    # Makes an HTTP request for a file download
+    # @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
+    def make_request_file_download(method, path, data = {})
+      connection = @create_connection.call()
+      response =  if method == :get || method == :delete
+                    d  = camelcase(data)
+                    connection.run_request(method, @build_path.call(path), nil, nil) do |req|
+                      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'})
+                  end
+      return response.body
+    end
+
     # Check response object and raise error if status code >= 400
     # @param response response object
     def check_response(response)

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/import_tn_orders.rb

@@ -1,5 +1,5 @@
 module BandwidthIris
-  IMPORT_TN_ORDERS_PATH = "importTnOrders"
+  IMPORT_TN_ORDERS_PATH = "importtnorders"
 
   class ImportTnOrders
     extend ClientWrapper
@@ -28,5 +28,48 @@ module BandwidthIris
       return data
     end
     wrap_client_arg :create_import_tn_order
+
+    def self.get_loa_files(client, order_id)
+      data = client.make_request(:get, client.concat_account_path("#{IMPORT_TN_ORDERS_PATH}/#{order_id}/#{LOAS_PATH}"))
+      return data
+    end
+    wrap_client_arg :get_loa_files
+
+    def self.upload_loa_file(client, order_id, file_contents, mime_type)
+      client.make_request_file_upload(:post, client.concat_account_path("#{IMPORT_TN_ORDERS_PATH}/#{order_id}/#{LOAS_PATH}"), file_contents, mime_type)
+    end
+    wrap_client_arg :upload_loa_file
+
+    def self.download_loa_file(client, order_id, file_id)
+      data = client.make_request_file_download(:get, client.concat_account_path("#{IMPORT_TN_ORDERS_PATH}/#{order_id}/#{LOAS_PATH}/#{file_id}"))
+      return data
+    end
+    wrap_client_arg :download_loa_file
+
+    def self.replace_loa_file(client, order_id, file_id, file_contents, mime_type)
+      data = client.make_request_file_upload(:put, client.concat_account_path("#{IMPORT_TN_ORDERS_PATH}/#{order_id}/#{LOAS_PATH}/#{file_id}"), file_contents, mime_type)
+    end
+    wrap_client_arg :replace_loa_file
+
+    def self.delete_loa_file(client, order_id, file_id)
+      client.make_request(:delete, client.concat_account_path("#{IMPORT_TN_ORDERS_PATH}/#{order_id}/#{LOAS_PATH}/#{file_id}"))
+    end
+    wrap_client_arg :delete_loa_file
+
+    def self.get_loa_file_metadata(client, order_id, file_id)
+      data = client.make_request(:get, client.concat_account_path("#{IMPORT_TN_ORDERS_PATH}/#{order_id}/#{LOAS_PATH}/#{file_id}/metadata"))
+      return data
+    end
+    wrap_client_arg :get_loa_file_metadata
+
+    def self.update_loa_file_metadata(client, order_id, file_id, file_metadata)
+      client.make_request(:put, client.concat_account_path("#{IMPORT_TN_ORDERS_PATH}/#{order_id}/#{LOAS_PATH}/#{file_id}/metadata"), {:file_meta_data => file_metadata})
+    end
+    wrap_client_arg :update_loa_file_metadata
+
+    def self.delete_loa_file_metadata(client, order_id, file_id)
+      client.make_request(:delete, client.concat_account_path("#{IMPORT_TN_ORDERS_PATH}/#{order_id}/#{LOAS_PATH}/#{file_id}/metadata"))
+    end
+    wrap_client_arg :delete_loa_file_metadata
   end
 end