ruby-bandwidth-iris 1.0.0

data/examples/city.rb

@@ -0,0 +1,16 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'yaml'
+require 'ruby-bandwidth-iris'
+config = YAML.load_file('config.yml')
+
+BandwidthIris::Client.global_options = {
+  :api_endpoint => config['api_endpoint'],
+  :user_name => config['user_name'],
+  :password => config['password'],
+  :account_id => config['account_id']
+}
+
+puts BandwidthIris::City.list({:available => true, :state => 'NC'})
+

data/examples/config.yml.example

@@ -0,0 +1,4 @@
+api_endpoint: "https://api.inetwork.com"
+account_id: ""
+user_name: ""
+password: ""

data/examples/covered-rate-center.rb

@@ -0,0 +1,19 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'yaml'
+require 'ruby-bandwidth-iris'
+config = YAML.load_file('config.yml')
+
+BandwidthIris::Client.global_options = {
+  :api_endpoint => config['api_endpoint'],
+  :user_name => config['user_name'],
+  :password => config['password'],
+  :account_id => config['account_id']
+}
+
+
+BandwidthIris::CoveredRateCenter.list({:zip => '27609', :page=>1, :size=>100}).each do |c|
+  puts c.to_data
+end
+

data/examples/order.rb

@@ -0,0 +1,51 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'yaml'
+require 'ruby-bandwidth-iris'
+config = YAML.load_file('config.yml')
+
+BandwidthIris::Client.global_options = {
+  :api_endpoint => config['api_endpoint'],
+  :user_name => config['user_name'],
+  :password => config['password'],
+  :account_id => config['account_id']
+}
+
+number = '9195551212' #exisitng number for order
+
+
+site = BandwidthIris::Site.create({
+  :name => "Ruby Test Site",
+  :description => "A Site From Ruby SDK Examples",
+  :address => {
+    :house_number => "123",
+    :street_name => "Anywhere St",
+    :city => "Raleigh",
+    :state_code =>"NC",
+    :zip => "27609",
+    :address_type => "Service"
+  }
+})
+
+order =  BandwidthIris::Order.create({
+  :name =>"A Test Order",
+  :site_id => site.id,
+  :existing_telephone_number_order_type => {
+    :telephone_number_list =>
+      {
+        :telephone_number => [number]
+      }
+
+  }
+})
+
+puts order.to_data
+
+order = BandwidthIris::Order.get(order.id)
+
+puts order.to_data
+
+order.delete()
+site.delete()
+

data/examples/port-in.rb

@@ -0,0 +1,95 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'yaml'
+require 'ruby-bandwidth-iris'
+config = YAML.load_file('config.yml')
+
+BandwidthIris::Client.global_options = {
+  :api_endpoint => config['api_endpoint'],
+  :user_name => config['user_name'],
+  :password => config['password'],
+  :account_id => config['account_id']
+}
+
+number_to_check = '+12525130283' #TODO fill with valid number
+
+host = '1.1.2.3'
+
+
+site = BandwidthIris::Site.create({
+  :name => "Ruby Test Site",
+  :description => "A Site From Ruby SDK Examples",
+  :address => {
+    :house_number => "123",
+    :street_name => "Anywhere St",
+    :city => "Raleigh",
+    :state_code =>"NC",
+    :zip => "27609",
+    :address_type => "Service"
+  }
+})
+
+data = {
+  :peer_name => "A New SIP Peer",
+  :is_default_peer => true,
+  :short_messaging_protocol => "SMPP",
+  :site_id => site[:id],
+  :voice_hosts =>
+  {
+      :host => {
+        :host_name => host
+      }
+  },
+  :sms_hosts =>
+  {
+      :host => {
+        :host_name => host
+      }
+  },
+  :termination_hosts =>
+    {
+      :termination_host => {
+        :host_name => host,
+        :port => 5060,
+      }
+    }
+
+}
+
+sip_peer = BandwidthIris::SipPeer.create(site[:id], data)
+
+res = BandwidthIris::LnpChecker.check(number_to_check)
+
+if res[:portable_numbers] && res[:portable_numbers][:tn] == number_to_check
+  puts 'Your number is portable. Creating PortIn Order'
+  port_in = BandwidthIris::PortIn.create(create_port_in_order(number_to_check, site, sip_peer))
+  puts "Created order #{port_in[:id]}"
+  port_in.create_file(File.open('./loa.pdf', 'r'), 'application/pdf')
+end
+
+def create_port_in_order(number, site, sip_peer)
+   {
+    :site_id => site[:id],
+    :peer_id => sip_peer[:id],
+    :billing_telephone_number => number,
+    :subscriber => {
+      :subscriber_type => "BUSINESS",
+      :business_name => "Company",
+      :service_address => {
+        :house_number => "123",
+        :street_name => "EZ Street",
+        :city => "Raleigh",
+        :state_code => "NC",
+        :zip => "27615",
+        :county => "Wake"
+      }
+    },
+    :loa_authorizing_person => "Joe Blow",
+    :list_of_phone_numbers => {
+      :phoneNumber => number
+    },
+    :billingType => "PORTIN"
+  }
+end
+

data/examples/sip_peer.rb

@@ -0,0 +1,60 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'yaml'
+require 'ruby-bandwidth-iris'
+config = YAML.load_file('config.yml')
+
+BandwidthIris::Client.global_options = {
+  :api_endpoint => config['api_endpoint'],
+  :user_name => config['user_name'],
+  :password => config['password'],
+  :account_id => config['account_id']
+}
+
+host = '10.20.30.41'
+
+
+site = BandwidthIris::Site.create({
+  :name => "Ruby Test Site",
+  :description => "A Site From Ruby SDK Examples",
+  :address => {
+    :house_number => "123",
+    :street_name => "Anywhere St",
+    :city => "Raleigh",
+    :state_code =>"NC",
+    :zip => "27609",
+    :address_type => "Service"
+  }
+})
+
+data = {
+  :peer_name => "A New SIP Peer",
+  :is_default_peer => true,
+  :short_messaging_protocol => "SMPP",
+  :site_id => site[:id],
+  :voice_hosts =>
+  {
+      :host => {
+        :host_name => host
+      }
+  },
+  :sms_hosts =>
+  {
+      :host => {
+        :host_name => host
+      }
+  },
+  :termination_hosts =>
+    {
+      :termination_host => {
+        :host_name => host,
+        :port => 5060,
+      }
+    }
+
+}
+sip_peer = BandwidthIris::SipPeer.create(site[:id], data)
+
+
+sip_peer.delete(site[:id])

data/examples/site.rb

@@ -0,0 +1,29 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'yaml'
+require 'ruby-bandwidth-iris'
+config = YAML.load_file('config.yml')
+
+BandwidthIris::Client.global_options = {
+  :api_endpoint => config['api_endpoint'],
+  :user_name => config['user_name'],
+  :password => config['password'],
+  :account_id => config['account_id']
+}
+
+
+site = BandwidthIris::Site.create({
+  :name => "Ruby Test Sitei1",
+  :description => "A Site From Ruby SDK Examples",
+  :address => {
+    :house_number => "123",
+    :street_name => "Anywhere St",
+    :city => "Raleigh",
+    :state_code =>"NC",
+    :zip => "27609",
+    :address_type => "Service"
+  }
+})
+
+site.delete()

data/examples/tn.rb

@@ -0,0 +1,20 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'yaml'
+require 'ruby-bandwidth-iris'
+config = YAML.load_file('config.yml')
+
+
+BandwidthIris::Client.global_options = {
+  :api_endpoint => config['api_endpoint'],
+  :user_name => config['user_name'],
+  :password => config['password'],
+  :account_id => config['account_id']
+}
+
+list = BandwidthIris::Tn.list({:npa => '818', :page => 1, :size => 100}).each do |n|
+  puts n.to_data
+end
+
+puts BandwidthIris::Tn.get(list[0][:full_number]).to_data

data/lib/bandwidth-iris/account.rb

@@ -0,0 +1,10 @@
+module BandwidthIris
+  class Account
+    extend ClientWrapper
+
+    def self.get(client)
+      client.make_request(:get, client.concat_account_path(nil))[0][:account]
+    end
+    wrap_client_arg :get
+  end
+end

data/lib/bandwidth-iris/api_item.rb

@@ -0,0 +1,36 @@
+module BandwidthIris
+  # Module which adds common operations for all Catapult api related classes
+  module ApiItem
+    # Initializer
+    #
+    # @param data [Hash] Hash with data of api item. Initializer will create accessors for each key of this hash
+    # @param client [Client] Optional client instance. If omitted Client instance with default parameters will be used
+    def initialize(data={}, client = nil)
+      @client = client || Client.new()
+      @data = (data || {}).clone()
+      @data.each do |k,v|
+        self.define_singleton_method(k) do
+          @data[k]
+        end
+        self.define_singleton_method("#{k}=".to_sym()) do |val|
+          @data[k] = val
+        end
+      end
+    end
+
+    # Return data of api item as hash
+    def to_data()
+      @data.clone()
+    end
+
+    # Return item of @data by name
+    def [] (name)
+      @data[name]
+    end
+
+    # Set value of @data's item by name
+    def []= (name, value)
+      @data[name] = value
+    end
+  end
+end

data/lib/bandwidth-iris/available_npa_nxx.rb

@@ -0,0 +1,15 @@
+module BandwidthIris
+  AVAILABLE_NPA_NXX_PATH = 'availableNpaNxx'
+
+  class AvailableNpaNxx
+    extend ClientWrapper
+
+    def self.list(client, query)
+      list = client.make_request(:get, client.concat_account_path(AVAILABLE_NPA_NXX_PATH), query)[0][:available_npa_nxx_list][:available_npa_nxx]
+      return [] if !list
+      if list.is_a?(Array) then list else [list] end
+    end
+    wrap_client_arg :list
+
+  end
+end

data/lib/bandwidth-iris/available_number.rb

@@ -0,0 +1,15 @@
+module BandwidthIris
+  AVAILABLE_NUMBER_PATH = 'availableNumbers'
+
+  class AvailableNumber
+    extend ClientWrapper
+
+    def self.list(client, query)
+      list = client.make_request(:get, client.concat_account_path(AVAILABLE_NUMBER_PATH), query)[0][:telephone_number_list][:telephone_number]
+      return [] if !list
+      if list.is_a?(Array) then list else [list] end
+    end
+    wrap_client_arg :list
+
+  end
+end

data/lib/bandwidth-iris/city.rb

@@ -0,0 +1,15 @@
+module BandwidthIris
+  CITY_PATH = 'cities'
+
+  class City
+    extend ClientWrapper
+
+    def self.list(client, query)
+      list = client.make_request(:get, CITY_PATH, query)[0][:cities][:city]
+      return [] if !list
+      if list.is_a?(Array) then list else [list] end
+    end
+    wrap_client_arg :list
+
+  end
+end

data/lib/bandwidth-iris/client.rb

@@ -0,0 +1,232 @@
+require 'faraday'
+require 'certified'
+require 'active_support/xml_mini'
+require 'active_support/core_ext/hash/conversions'
+require 'active_support/core_ext/string/inflections'
+
+
+module BandwidthIris
+
+  class Client
+    def initialize (account_id = nil, user_name = nil, password = nil, options = nil)
+      if user_name == nil && password == nil && options == nil
+        if account_id && account_id.is_a?(Hash)
+          options = account_id
+          account_id = nil
+        end
+      end
+      options = options || @@global_options
+      account_id = options[:account_id] unless account_id
+      user_name = options[:user_name] || options[:username]  unless user_name
+      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_version = options[:api_version] || "v1.0"
+
+      @build_path = lambda {|path| "/#{api_version}" + (if path[0] == "/" then path else "/#{path}" end) }
+      @set_adapter = lambda {|faraday| faraday.adapter(Faraday.default_adapter)}
+      @create_connection = lambda{||
+        Faraday.new(api_endpoint) { |faraday|
+          faraday.basic_auth(user_name, password)
+          #faraday.response :logger
+          faraday.headers['Accept'] = 'application/xml'
+          @set_adapter.call(faraday)
+        }
+      }
+      @concat_account_path = lambda {|path| "/accounts/#{account_id}" + (if path then (if path[0] == "/" then path else "/#{path}" end) else '' end) }
+      @api_endpoint = api_endpoint
+      @api_version = api_version
+    end
+
+    attr_reader :api_endpoint, :api_version
+
+    @@global_options = {}
+
+    # Return global options
+    def Client.global_options
+      @@global_options
+    end
+
+    # Set global options
+    def Client.global_options=(v)
+      @@global_options = v
+    end
+
+    # Extract id from location header
+    # @param location [String] location header value
+    # @return [String] extracted id
+    def Client.get_id_from_location_header(location)
+      items = (location || '').split('/')
+      raise StandardError.new('Missing id in the location header') if items.size < 2
+      items.last
+    end
+
+    # Make HTTP request to IRIS API
+    # @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 [Array] array with 2 elements: parsed  data of response and response headers
+    def make_request(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
+      body = check_response(response)
+      [body || {}, symbolize(response.headers || {})]
+    end
+
+    # Check response object and raise error if status code >= 400
+    # @param response response object
+    def check_response(response)
+      parsed_body = parse_xml(response.body || '')
+      code = find_first_descendant(parsed_body, :error_code)
+      description = find_first_descendant(parsed_body, :description)
+      unless code
+        error = find_first_descendant(parsed_body, :error)
+        if error
+          code = error[:code]
+          description = error[:description]
+        else
+          errors = find_first_descendant(parsed_body, :errors)
+          if errors == nil || errors.length == 0
+            code = find_first_descendant(parsed_body, :result_code)
+            description = find_first_descendant(parsed_body, :result_message)
+          else
+            errors = [errors] if errors.is_a?(Hash)
+            raise Errors::AgregateError.new(errors.map {|e| Errors::GenericError.new(e[:code], e[:description], response.status)})
+          end
+        end
+      end
+      raise Errors::GenericError.new(code, description, response.status) if code && description && code != '0' && code != 0
+      raise Errors::GenericError.new('', "Http code #{response.status}", response.status) if response.status >= 400
+      parsed_body
+    end
+
+    # Build url path like /accounts/<account-id>/<path>
+    def concat_account_path(path)
+      @concat_account_path.call(path)
+    end
+
+    # Return new configured connection object
+    # @return [Faraday::Connection] connection
+    def create_connection()
+      @create_connection.call()
+    end
+
+    def build_xml(data)
+       doc = build_doc(data)
+       doc.values.first.to_xml({:root => doc.keys.first, :skip_types => true, :indent => 0 })
+    end
+
+    protected
+
+    # Convert all keys of a hash to camel cased strings
+    def camelcase v
+      case
+        when v.is_a?(Array)
+          v.map {|i| camelcase(i)}
+        when v.is_a?(Hash)
+          result = {}
+          v.each do |k, val|
+            result[k.to_s().camelcase(:lower)] = camelcase(val)
+          end
+          result
+        else
+          v
+      end
+    end
+
+    # Convert all keys of hash to underscored symbols
+    def symbolize v
+      case
+        when v.is_a?(Array)
+          v.map {|i| symbolize(i)}
+        when v.is_a?(Hash)
+          result = {}
+          v.each do |k, val|
+            result[k.underscore().to_sym()] = symbolize(val)
+          end
+          result
+        else
+          v
+      end
+    end
+
+    def parse_xml(xml)
+      doc = ActiveSupport::XmlMini.parse(xml)
+      process_parsed_doc(doc.values.first)
+    end
+
+    def build_doc(v)
+      case
+        when v.is_a?(Array)
+          v.map {|i| build_doc(i)}
+        when v.is_a?(Hash)
+          result = {}
+          v.each do |k, val|
+            if k[0] != '_'
+              result[v["_#{k}XmlElement"] || (k.to_s().camelcase(:upper))] = build_doc(val)
+            end
+          end
+          result
+        else
+          v
+      end
+    end
+
+    def process_parsed_doc(v)
+      case
+        when v.is_a?(Array)
+          v.map {|i| process_parsed_doc(i)}
+        when v.is_a?(Hash)
+          return process_parsed_doc(v['__content__']) if v.keys.length == 1 && v['__content__']
+          result = {}
+          v.each do |k, val|
+            key =  if k.downcase() == 'lata' then :lata else k.underscore().to_sym() end
+            result[key] = process_parsed_doc(val)
+          end
+          result
+        when v == "true" || v == "false"
+          v == "true"
+        when /^\d{4}\-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}(\.\d{3})?Z$/.match(v)
+          DateTime.iso8601(v)
+        when /\A\d{9}\d?\Z/.match(v)
+          v
+        when /\A\d+\Z/.match(v)
+          Integer(v)
+        when /\A[-+]?[0-9]*\.?[0-9]+\Z/.match(v)
+          Float(v)
+        else
+          v
+      end
+    end
+
+    def find_first_descendant v, name
+      result = nil
+      case
+        when v.is_a?(Array)
+          v.each do |val|
+            result = find_first_descendant(val, name)
+            break if result
+          end
+        when v.is_a?(Hash)
+          v.each do |k, val|
+            if k == name
+              result = val
+              break
+            else
+              result = find_first_descendant(val, name)
+              break if result
+            end
+          end
+      end
+      result
+    end
+  end
+end

data/lib/bandwidth-iris/client_wrapper.rb

@@ -0,0 +1,28 @@
+module BandwidthIris
+  # Allows to make first argument (client instance) of defined singletom function optional
+  module ClientWrapper
+    # Make first argument (client instance) of a method optional
+    #
+    # @param method [Symbol] singleton method name
+    # @example
+    #   class MyClass
+    #     extend ClientWrapper
+    #
+    #     def self.do_something(client, arg1, arg2)
+    #     end
+    #
+    #     wrap_client_arg :do_something
+    #     # Now you can make calls like MyClass.do_something(client, arg1, arg2) and MyClass.do_something(arg1, arg2)
+    #     # In last case Client instance with default parameters (from Client.global_options) will be used
+    #   end
+    def wrap_client_arg(method)
+      old = method(method)
+      define_singleton_method(method) do |*args|
+        if(args.size == 0 || !(args[0] || {}).is_a?(Client))
+          args.unshift(Client.new())
+        end
+        old.call(*args)
+      end
+    end
+  end
+end

data/lib/bandwidth-iris/covered_rate_center.rb

@@ -0,0 +1,17 @@
+module BandwidthIris
+  COVERED_RATE_CENTER_PATH = 'coveredRateCenters'
+  class CoveredRateCenter
+    extend ClientWrapper
+    include ApiItem
+
+    def self.list(client, query = nil)
+      list = client.make_request(:get, COVERED_RATE_CENTER_PATH, query)[0][:covered_rate_center]
+      return [] if !list
+      list = if list.is_a?(Array) then list else [list] end
+      list.map do |i|
+        CoveredRateCenter.new(i, client)
+      end
+    end
+    wrap_client_arg :list
+  end
+end