ruby-bandwidth-iris

failed_import_tn_order = "some_id"
begin
    response = BandwidthIris::ImportTnOrders.get_import_tn_order(failed_import_tn_order)
    puts response[0]
rescue BandwidthIris::Errors::GenericError => e
    puts e
end

require 'ruby-bandwidth-iris'

# Using  directly
client = BandwidthIris::Client.new('accountId', 'userName', 'password')
sites = BandwidthIris::Site.list(client)

# Or you can use default client instance (do this only once)
BandwidthIris::Client.global_options = {
  :account_id => 'accountId',
  :username => 'userName',
  :password => 'password'
}

# Now you can call any functions without first arg 'client'

sites = BandwidthIris::Site.list()

site = BandwidthIris::Site.create({siteObject})

# or

site = BandwidthIris::Site.create(client, {siteObject})

list = BandwidthIris::AvailableNumber.list(query)

list = BandwidthIris::AvailableNpaNxx.list({:area_code => "818", :quantity =>5})

list = BandwidthIris::City.list({:available => true, :state =>"CA"})

BandwidthIris::CoveredRateCenter.list({:zip => "27601"})

BandwidthIris::DiscNumber.list({:area_code => "919"})

order = BandwidthIris::Disconnect.create("Disconnect Order Name", ["9195551212", "9195551213"])

order.add_note({:user_id => "my id", :description => "Test"})

order.get_notes()

dlda_data = {
  :customer_order_id => "Your Order Id",
  :dlda_tn_groups => [
    :dlda_tn_group => {
      :telephone_numbers => ["9195551212"],
      :subscriber_type => "RESIDENTIAL",
      :listing_type => "LISTED",
      :listing_name => {
        :first_name => "John",
        :last_name => "Smith"
      },
      :list_address => true,
      :address => {
        :house_number => "123",
        :street_name => "Elm",
        :street_suffix => "Ave",
        :city => "Carpinteria",
        :state_code => "CA",
        :zip => "93013",
        :address_type => "DLDA"
      }
    }
  ]
}

BandwidthIris::Dlda.create(dlda_data)

dlda = Bandwidth::Dlda.get("dlda_id")

dlda.get_history()

BandwidthIris::Dlda.list({:telephone_number => "9195551212"})

BandwidthIris::InServiceNumber.list({:area_code => "919"})

BandwidthIris::InServiceNumber.get("9195551212")

data = {
  :customer_order_id => "A test order",
  :lidb_tn_groups => {
    :lidb_tn_group => {
      :telephone_numbers => ["8048030097", "8045030098"],
      :subscriber_information => "Joes Grarage",
      :use_type => "RESIDENTIAL",
      :visibility => "PUBLIC"
    }
  }
}
BandwidthIris::Lidb.create(data)

BandwidthIris::Lidb.get("lidb_id")

BandwidthIris::Lidb.list({:telephone_number => "9195551212"})

numbers = ["9195551212", "9195551213"]
full_check = true
BandwidthIris::LnpChecker.check(numbers, full_check)

data = {
  :pon => "Some Pon",
  :customer_order_id => "MyId5",
  'sPID' => "123C",
  :billing_telephone_number => "9192381468",
  :requested_foc_date => "2015-11-15",
  :authorizing_person => "Jim Hopkins",
  :subscriber => {
    :subscriber_type => "BUSINESS",
    :business_name => "BusinessName",
    :service_address => {
      :house_number => "11",
      :street_name => "Park",
      :street_suffix => "Ave",
      :city => "New York",
      :state_code => "NY",
      :zip => "90025"
    },
    :account_number => "123463",
    :pin_number => "1231"
  },
  :list_of_telephone_numbers => {
    :telephone_number => ["9192381848", "9192381467"]
  }
}

BandwidthIris::LsrOrder.create(data)

BandwidthIris::LsrOrder.get("lsr_order_response_id")

BandwidthIris::LsrOrder.list({:pon =>"Some Pon"})

order.requestedFocDate = "2015-11-16"
BandwidthIris::LsrOrder.update(order)

order.get_history()

order.get_notes()

note = {:user_id => "my id", :description => "Test"}
order.add_note(note)

order_data = {
  :name => "A Test Order",
  :site_id => 1111,
  :existing_telephone_number_order_type => {
    :telephone_number_list =>
      {
        :telephone_number => ["9195551212"]
      }

  }
}

BandwidthIris::Order.create(order_data)

order = BandwidthIris::Order.get("order_id")

order = BandwidthIris::Order.get_order_response(client, "101")
completed_number = order.completed_numbers[:telephone_number][:full_number]

BandwidthIris::Order.list(query)

// get Area Codes
order.get_area_codes()

// add note to order
note = {:user_id => "my id", :description => "Test"}
order.add_note(note)

//get Npa Nxxs
order.get_npa_nxx()

// get number totals
order.get_totals()

// get all Tns for an order
order.get_tns()
##Use the below method to grab TNs via an already existing Order ID##
BandwidthIris::Order.get_tns_by_order_id("id")

// get order history
order.get_history()

// get order notes
order.get_notes()

page = BandwidthIris::PortIn.list(client, {'page': 1, 'size': 5})

data = {
  :site_id =>1234,
  :peer_id => 5678,
  :billing_telephone_number => "9195551212",
  :subscriber => {
    :subscriber_type => "BUSINESS",
    :business_name => "Company",
    :service_address => {
      :house_number => "123",
      :street_name => "EZ Street",
      :city => "Raleigh",
      :state_code => "NC",
      :county => "Wake"
    }
  },
  :loa_authorizing_person => "Joe Blow",
  :list_of_phone_numbers => {
    :phone_number => ["9195551212"]
  },
  :billing_type => "PORTIN"
}

portin_response = BandwidthIris::PortIn.create(data)

portIn = BandwidthIris::PortIn.get("portin_id", callback)

portIn.update(data)
portIn.delete()

# Add File
portIn.create_file(IO.read("myFile.txt"))

# Update File
portIn.update_file("myFile.txt", IO.read("myFile.txt"))

# Get File
portIn.get_file("myFile.txt")

# Get File Metadata
portIn.get_file_metadata("myFile.txt")

# Get Files
portIn.get_files()

query = {:status => "complete"}
list = BandwidthIris::PortOut.list(query)

portout = BandwidthIris::PortOut.get("portout_id")

query = {:available => true, :state => "CA"}
BandwidthIris::RateCenter.list(query)

data = {
  :peer_name => "A New SIP Peer",
  :is_default_peer => false,
  :short_messaging_protocol =>"SMPP",
  :site_id => selectedSite,
  :voice_hosts =>
    {
      :host => [{
        :host_name => "1.1.1.1"
      }]
    },
  :sms_hosts =>
    {
      :host => [{
        :host_name => "1.1.1.1"
      }]
    },
  :termination_hosts =>
    {
        :termination_host =>[{
        :host_name => "1.1.1.1",
        :port => 5060
      }]
    }

}

BandwidthIris::SipPeer.create(data)

sipPeer = BandwidthIris::SipPeer.get("sippeer_id")

BandwidthIris::SipPeer.list(sipPeer.siteId)

sipPeer.delete()

#peer_id
sipPeer.peer_id

#peer_name
sipPeer.peer_name

#is_default_peer
sipPeer.is_default_peer

#products
sipPeer.products

#ss_send_to_customer
sipPeer.ss_send_to_customer

#site_id
sipPeer.site_id

# get TN for this peer
sipPeer.get_tns(number)

# get all TNs for this peer
sipPeer.get_tns()

# Update TNs for this peer
tns = {:full_number => "123456", :rewrite_user => "test"}
sipPeer.update_tns(number, tns)

#  Move Tns to new peer
numbers_to_move = ["9195551212", "9195551213"]
sipPeer.move_tns(numbers_to_move)

site = {
  :name =>"A new site",
  :description =>"A new description",
  :address => {
    :house_number => "123",
    :street_name => "Anywhere St",
    :city => "Raleigh",
    :state_code =>"NC",
    :zip => "27609",
    :address_type => "Service"
  }
};
site = BandwidthIris::Site.create(site)

site = BandwidthIris::Site.get("site_id")

site.update({:name => "New name"})

site.delete()

BandwidthIris::Site.list()

# get Sip Peers
site.get_sip_peers()

# get Sip Peer
site.get_sip_peer("sip_peer_id")

# create Sip Peer
sip_peer = {:name =>"SIP Peer"}
site.create_sip_peer(sipPeer)

subscription = {
  :order_type => "orders",
  :callback_subscription => {
    :URL => "http://mycallbackurl.com",
    :user => "userid",
    :expiry => 12000
  }
}
BandwidthIris::Subscription.create(subscription)

BandwidthIris::Subscription.get("subscription_id")

BandwidthIris::Subscription.list(query)

# update subscription
updatedData = {:order_type => "portins"}
subscription.update(updatedData)

# delete subscription
subscription.delete()
});

tn = BandwidthIris::Tn.get("9195555555")

BandwidthIris::Tn.list(query)

# Get TN Details
tn = tn.geti_tn_details()

# Get Sites
tn.get_sites()

# Get Sip Peers
tn.get_sip_peers()

# Get Rate Center
tn.get_rate_center()

BandwidthIris::TnReservation.create("9195551212")

tn = BandwidthIris::TnReservation.get("tn_reservation_id")

tn.delete()

import_tn_order = {
    :customer_order_id => "id",
    :site_id => "12345",
    :sip_peer_id => "23456",
    :subscriber => {
        :service_address => {
            :city => "city",
            :house_number => "1",
            :street_name => "Street",
            :state_code => "XY",
            :zip => "54345",
            :county => "County"
        },
        :name => "Company INC"
    },
    :loa_authorizing_person => "Test Person",
    :telephone_numbers => {
        :telephone_number => ["5554443333"]
    }
}
response = BandwidthIris::ImportTnOrders.create_import_tn_order(import_tn_order)
puts response

response = BandwidthIris::ImportTnOrders.get_import_tn_orders({
    :createdDateFrom => "2013-10-22T00:00:00.000Z",
    :createdDateTo => "2013-10-25T00:00:00.000Z"}
)
puts response

response = BandwidthIris::ImportTnOrders.get_import_tn_order("id")
puts response

response = BandwidthIris::ImportTnOrders.get_import_tn_order_history("id")
puts response

response = BandwidthIris::ImportTnChecker.check_tns_portability({
    :telephone_numbers => {
        :telephone_number => ["5554443333", "5553334444"]
    }
})
puts response

response = BandwidthIris::InServiceNumber.list()
puts response[0]
#{:total_count=>2, :links=>{:first=>"Link=<https://dashboard.bandwidth.com:443/v1.0/accounts/99/inserviceNumbers?page=1&size=500>;rel=\"first\";"}, :telephone_numbers=>{:count=>2, :telephone_number=>["5554443333", "5554442222"]}}

response = BandwidthIris::RemoveImportedTnOrders.get_remove_imported_tn_orders({
    :createdDateFrom => "2013-10-22T00:00:00.000Z",
    :createdDateTo => "2013-10-25T00:00:00.000Z"
})
puts response

response = BandwidthIris::RemoveImportedTnOrders.get_remove_imported_tn_order("order_id")
puts response

response = BandwidthIris::RemoveImportedTnOrders.get_remove_imported_tn_order_history("order_id")
puts response

remove_imported_tn_order = {
    :customer_order_id => "custom string",
    :telephone_numbers => {
        :telephone_number => ["5554443333", "5554442222"]
    }
}

response = BandwidthIris::RemoveImportedTnOrders.create_remove_imported_tn_order(remove_imported_tn_order)
puts response

response = BandwidthIris::ImportTnOrders.get_loa_files("order_id")
puts response[0][:result_message]
puts response[0][:file_names] #this can be a single string (if there's 1 file) or an array of strings (if there's multiple files)

BandwidthIris::ImportTnOrders.upload_loa_file("order_id", "binary_file_contents", "mime_type")

f = open("loa.pdf", "rb")
file_content = f.read
f.close()

BandwidthIris::ImportTnOrders.upload_loa_file("order_id", file_content, "application/pdf")

f = open("write.pdf", "wb")
response = BandwidthIris::ImportTnOrders.download_loa_file("order_id", "file_id")
f.puts(response)
f.close()

BandwidthIris::ImportTnOrders.replace_loa_file("order_id", "file_id", "binary_file_contents", "mime_type")

BandwidthIris::ImportTnOrders.delete_loa_file("order_id", "file_id")

response = BandwidthIris::ImportTnOrders.get_loa_file_metadata("order_id", "file_id")
puts response[0][:document_name]
puts response[0][:file_name]

metadata = {
    :document_name => "file_name",
    :document_type => "LOA"
}
BandwidthIris::ImportTnOrders.update_loa_file_metadata("order_id", "file_id", metadata)

BandwidthIris::ImportTnOrders.delete_loa_file_metadata("order_id", "file_id")

csr_data = {
    :customer_order_id => "order id",
    :working_or_billing_telephone_number => "5554443333"
}

response = BandwidthIris::Csr.create(csr_data)
puts response[0][:order_id]

csr_data = {
    :customer_order_id => "order id",
    :working_or_billing_telephone_number => "5554443333"
}

response = BandwidthIris::Csr.replace("csr_id", csr_data)
puts response[0][:order_id]

response = BandwidthIris::Csr.get("csr_id")
puts response[0][:order_id]

response = BandwidthIris::Csr.get_notes("csr_id")
puts response[0][:note][0][:id]

note_data = {
    :user_id => "id",
    :description => "description"
}

BandwidthIris::Csr.add_note("csr_id", note_data)

note_data = {
    :user_id => "id",
    :description => "description"
}

BandwidthIris::Csr.update_note("csr_id", "note_id", note_data)

data = {
  :service_type => "Messaging-V2",
  :app_name => "Name",
  :msg_callback_url => "https://test.com"
}
application = BandwidthIris::Applications.create_application(data)
puts application

applications = BandwidthIris::Applications.get_applications()
puts applications[0]

application = BandwidthIris::Applications.get_application("id")
puts application

data = {
  :app_name => "Name2"
}
application = BandwidthIris::Applications.partial_update_application("id", data)
puts application

data = {
  :service_type => "Messaging-V2",
  :app_name => "Name2",
  :msg_callback_url => "https://test2.com"
}
application = BandwidthIris::Applications.complete_update_application("id", data)
puts application

BandwidthIris::Applications.delete_application("id")

sippeers = BandwidthIris::Applications.get_application_sippeers("id")
puts sippeers[0]

puts BandwidthIris::SipPeerProducts.get_origination_settings("site_id", "sippeer_id")

data = {
  :voice_protocol => "HTTP"
}
puts BandwidthIris::SipPeerProducts.create_origination_settings("site_id", "sippeer_id", data)

data = {
  :voice_protocol => "HTTP"
}
BandwidthIris::SipPeerProducts.update_origination_settings("site_id", "sippeer_id", data)

puts BandwidthIris::SipPeerProducts.get_termination_settings("site_id", "sippeer_id")

data = {
  :voice_protocol => "HTTP"
}
puts BandwidthIris::SipPeerProducts.create_termination_settings("site_id", "sippeer_id", data)

data = {
  :voice_protocol => "HTTP"
}
BandwidthIris::SipPeerProducts.update_termination_settings("site_id", "sippeer_id", data)

puts BandwidthIris::SipPeerProducts.get_sms_feature_settings("site_id", "sippeer_id")

data = {
  :sip_peer_sms_feature_settings => {
    :toll_free => true,
    :protocol => "HTTP",
    :zone_1 => true,
    :zone_2 => false,
    :zone_3 => false,
    :zone_4 => false,
    :zone_5 => false
  },
  :http_settings => {}
}

puts BandwidthIris::SipPeerProducts.create_sms_feature_settings("site_id", "sippeer_id", data)

data = {
  :sip_peer_sms_feature_settings => {
    :toll_free => true,
    :protocol => "HTTP",
    :zone_1 => true,
    :zone_2 => false,
    :zone_3 => false,
    :zone_4 => false,
    :zone_5 => false
  },
  :http_settings => {}
}

puts BandwidthIris::SipPeerProducts.update_sms_feature_settings("site_id", "sippeer_id", data)

BandwidthIris::SipPeerProducts.delete_sms_feature_settings("site_id", "sippeer_id")

puts BandwidthIris::SipPeerProducts.get_mms_feature_settings("site_id", "sippeer_id")

data = {
  :mms_settings => {
    :protocol => "HTTP"
  },
  :protocols => {
    :HTTP => {
      :http_settings => {}
    }
  }
}

puts BandwidthIris::SipPeerProducts.create_mms_feature_settings("site_id", "sippeer_id", data)

data = {
  :mms_settings => {
    :protocol => "HTTP"
  },
  :protocols => {
    :HTTP => {
      :http_settings => {}
    }
  }
}

BandwidthIris::SipPeerProducts.update_mms_feature_settings("site_id", "sippeer_id", data)

BandwidthIris::SipPeerProducts.delete_mms_feature_settings("site_id", "sippeer_id")

puts BandwidthIris::SipPeerProducts.get_mms_feature_mms_settings("site_id", "sippeer_id")

puts BandwidthIris::SipPeerProducts.get_messaging_application_settings("site_id", "sippeer_id")

data = {
  :http_messaging_v2_app_id => "4-d-4-8-5"
}

puts BandwidthIris::SipPeerProducts.update_messaging_application_settings("site_id", "sippeer_id", data)

puts BandwidthIris::SipPeerProducts.get_messaging_settings("site_id", "sippeer_id")

data = {
  :break_out_countries => {
    :country => "CAN"
  }
}

puts BandwidthIris::SipPeerProducts.update_messaging_settings("site_id", "sippeer_id", data)

data = {
  :description => "Email to Bldg. 3 Front Desk",
  :type => "EMAIL",
  :email_address => "foo@bar.com"
}

enr = BandwidthIris::EmergencyNotificationRecipients.create_emergency_notification_recipient(data)
puts enr

enrs = BandwidthIris::EmergencyNotificationRecipients.get_emergency_notification_recipients()
puts enrs

enr = BandwidthIris::EmergencyNotificationRecipients.get_emergency_notification_recipient("id")
puts enr

data = {
  :description => "Email to Bldg. 3 Front Desk",
  :type => "EMAIL",
  :email_address => "foo@bar.com"
}

enr = BandwidthIris::EmergencyNotificationRecipients.replace_emergency_notification_recipient("id", data)
puts enr

BandwidthIris::EmergencyNotificationRecipients.delete_emergency_notification_recipient("id")

data = {
  :customer_order_id => "value",
  :added_emergency_notification_group => {
    :description => "description",
    :added_emergency_notification_recipients => {
      :emergency_notification_recipient => [
        {
          :identifier => "123"
        }
      ]
    }
  }
}

order = BandwidthIris::EmergencyNotificationGroups.create_emergency_notification_group_order(data)
puts order

orders = BandwidthIris::EmergencyNotificationGroups.get_emergency_notification_group_orders()
puts orders

order = BandwidthIris::EmergencyNotificationGroups.get_emergency_notification_group_order("id")
puts order

groups = BandwidthIris::EmergencyNotificationGroups.get_emergency_notification_groups()
puts groups

group = BandwidthIris::EmergencyNotificationGroups.get_emergency_notification_group("id")
puts group

data = {
  :customer_order_id => "123",
  :emergency_notification_endpoint_associations => {
    :emergency_notification_group => {
      :identifier => "456"
    }
  }
}

order = BandwidthIris::EmergencyNotificationEndpoints.create_emergency_notification_endpoint_order(data)
puts order

orders = BandwidthIris::EmergencyNotificationEndpoints.get_emergency_notification_endpoint_orders()
puts orders

order = BandwidthIris::EmergencyNotificationEndpoints.get_emergency_notification_endpoint_order("id")
puts order

aeuis = BandwidthIris::AlternateEndUserIdentity.get_alternate_end_user_information()
puts aeuis

aeui = AlternateEndUserIdentity.get_alternate_caller_information("id")
puts aeui

orders = BandwidthIris::TnOptions.get_tn_option_orders()
puts orders

order = BandwidthIris::TnOptions.get_tn_option_order("order_id")
puts order

begin
  order = BandwidthIris::TnOptions.get_tn_option_order("error_id")
rescue BandwidthIris::Errors::GenericError => e
  puts e
end

data = {
  :customer_order_id => "custom order",
  :tn_option_groups => {
    :tn_option_group => [
      {
        :port_out_passcode => "12abd38",
        :telephone_numbers => {
          :telephone_number => ["2018551020"]
        }
      }
    ]
  }
}


order = BandwidthIris::TnOptions.create_tn_option_order(data)
puts order

data = {
  :customer_order_id => "custom order",
  :tn_option_groups => {
    :tn_option_group => [
      {
        :call_forward => "2018551022",
        :telephone_numbers => {
          :telephone_number => ["2018551020"]
        }
      }
    ]
  }
}


order = BandwidthIris::TnOptions.create_tn_option_order(data)
puts order

data = {
  :customer_order_id => "custom order",
  :tn_option_groups => {
    :tn_option_group => [
      {
        :sms => "on",
        :telephone_numbers => {
          :telephone_number => ["2018551020"]
        }
      }
    ]
  }
}


order = BandwidthIris::TnOptions.create_tn_option_order(data)
puts order