Class: Plivo::Resources::PhoneNumberInterface

Inherits:
Base::ResourceInterface show all
Defined in:
lib/plivo/resources/numbers.rb

Constant Summary

Constants included from Utils

Utils::TYPE_WHITELIST

Instance Method Summary collapse

Methods included from Utils

GetSortedQueryParamString?, compute_signatureV3?, expected_type?, expected_value?, generate_url?, getMapFromQueryString?, is_one_among_string_url?, multi_valid_param?, raise_invalid_request, valid_account?, valid_date_format?, valid_mainaccount?, valid_multiple_destination_integers?, valid_multiple_destination_nos?, valid_param?, valid_range?, valid_signature?, valid_signatureV3?, valid_subaccount?, valid_url?

Constructor Details

#initialize(client, resource_list_json = nil) ⇒ PhoneNumberInterface

Returns a new instance of PhoneNumberInterface.



45
46
47
48
49
50
 
# File 'lib/plivo/resources/numbers.rb', line 45

def initialize(client, resource_list_json = nil)
  @_name = 'PhoneNumber'
  @_resource_type = PhoneNumber
  @_identifier_string = 'number'
  super
end

Instance Method Details

#buy(number, app_id = nil, verification_info = nil) ⇒ Object 



121
122
123
124
125
 
# File 'lib/plivo/resources/numbers.rb', line 121

def buy(number, app_id = nil, verification_info = nil)
  valid_param?(:number, number, [Integer, String, Symbol], true)
  PhoneNumber.new(@_client,
                  resource_id: number).buy(app_id, verification_info)
end

#each(country_iso) ⇒ Object 



111
112
113
114
115
116
117
118
119
 
# File 'lib/plivo/resources/numbers.rb', line 111

def each(country_iso)
  offset = 0
  loop do
    phone_number_list = search(country_iso, offset: offset)
    phone_number_list[:objects].each { |phone_number| yield phone_number }
    offset += 20
    return unless number_list.length == 20
  end
end

#search(country_iso, options = nil) ⇒ Object

Parameters:

  • country_iso (String) —

    The ISO code A2 of the country ( BE for Belgium, DE for Germany, GB for United Kingdom, US for United States etc ). See the Wikipedia site for a list of ISOs for different countries.

  • options (Hash) (defaults to: nil)

Options Hash (options):

  • :type (String) —

    The type of number you are looking for. The possible number types are fixed, mobile and tollfree. Defaults to any if this field is not specified. type also accepts the value any, which will search for all 3 number types.

  • :pattern (String) —

    Represents the pattern of the number to be searched. Adding a pattern will search for numbers which start with the country code + pattern. For eg. a pattern of 415 and a country_iso: US will search for numbers starting with 1415.

  • :region (String) —

    This filter is only applicable when the type is fixed. If the type is not provided, it is assumed to be fixed. Region based filtering can be performed with the following terms:

    • Exact names of the region: You could use region=Frankfurt if you were looking for a number in Frankfurt. Performed if the search term is three or more characters in length.

  • :services (String) —

    Filters out phone numbers according to the services you want from that number. The following values are valid:

    • voice - If this option is selected, it ensures that the results have voice enabled numbers. These numbers may or may not be SMS enabled.

    • voice,sms - If this option is selected, it ensures that the results have both voice and sms enabled on the same number.

    • sms - If this option is selected, it ensures that the results have sms enabled numbers. These numbers may or may not be voice enabled.

    • By default, numbers that have either voice or sms or both enabled are returned.

  • :lata (String) —

    Numbers can be searched using Local Access and Transport Area http://en.wikipedia.org/wiki/Local_access_and_transport_area. This filter is applicable only for country_iso US and CA.

  • :rate_center (String) —

    Numbers can be searched using Rate Center http://en.wikipedia.org/wiki/Telephone_exchange. This filter is application only for country_iso US and CA.

  • :city (String) —

    Filter phone number based on the city name. This filter is only applicable when the type is Local

  • :eligible (Boolean) —

    If set to true, lists only those numbers that you are eligible to buy at the moment. To list all numbers, ignore this option.

  • :limit (Int) —

    Used to display the number of results per page. The maximum number of results that can be fetched is 20.

  • :offset (Int) —

    Denotes the number of value items by which the results should be offset. Eg:- If the result contains a 1000 values and limit is set to 10 and offset is set to 705, then values 706 through 715 are displayed in the results. This parameter is also used for pagination of the results.



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/plivo/resources/numbers.rb', line 69

def search(country_iso, options = nil)
  valid_param?(:country_iso, country_iso, [String, Symbol], true)
  unless country_iso.length == 2
    raise_invalid_request('country_iso should be of length 2')
  end
  params = { country_iso: country_iso }

  return perform_list(params) if options.nil?

  %i[type pattern region services lata rate_center city].each do |param|
    if options.key?(param) &&
       valid_param?(param, options[param], [String, Symbol], true)
      params[param] = options[param]
    end
  end

  %i[offset limit].each do |param|
    if options.key?(param) && valid_param?(param, options[param],
                                           [Integer, Integer], true)
      params[param] = options[param]
    end
  end

  %i[eligible].each do |param|
    if options.key?(param) && valid_param?(param, options[param],
                                           nil, true, [true, false])
      params[param] = options[param]
    end
  end

  if options.key?(:limit) && (options[:limit] > 20 || options[:limit] <= 0)
    raise_invalid_request('The maximum number of results that can be '\
    "fetched is 20. limit can't be more than 20 or less than 1")
  end

  if options.key?(:offset) && options[:offset] < 0
    raise_invalid_request("Offset can't be negative")
  end

  perform_list(params)
end