routengn-client 0.1.4

data/lib/routengn_client/models/inbound_end_point_group.rb

@@ -0,0 +1,70 @@
+module RouteNGNClient
+  class InboundEndPointGroup < RemoteModel
+
+    set_resource_attributes({
+                              :path_base => 'metallic/inbound_end_point_groups',
+                              :collection_name => 'inbound_end_point_groups',
+                              :per_page => 200,
+                              :request_options => {
+                              }
+                            })
+
+    belongs_to :carrier
+    has_many :end_points, :inbound_rates, :rate_sheets
+    has_one :allow_list
+
+    attr_accessor :account
+
+    def initialize(attributes = {})
+      super
+
+      @account ||= nil
+    end
+
+    def self.find_by_end_point_host(host, options = {}, &callback)
+      options = { :per_page => 200 }.merge(options)
+      all({:inbound_end_point_group => {:'end_points.host' => host}}, options, &callback)
+    end
+
+    def primary_route_table(options = {}, &callback)
+      if self.attributes.primary_route_table_id.blank?
+        callback.call(nil) if callback
+      else
+        RouteTable.find self.attributes.primary_route_table_id, options, &callback
+      end
+    end
+
+    def secondary_route_table(options = {}, &callback)
+      if self.attributes.secondary_route_table_id.blank?
+        callback.call(nil) if callback
+      else
+        RouteTable.find self.attributes.secondary_route_table_id, options, &callback
+      end
+    end
+
+    def dialcode_regexp
+      return @dr if @dr
+
+      @dr = Regexp.new(self.attributes.dialcode_expression) unless self.attributes.dialcode_expression.blank?
+    end
+
+    def dialcode_prefix_regexp
+      return @dpr if @dpr
+
+      @dpr = Regexp.new(self.attributes.dialcode_prefix_expression) unless self.attributes.dialcode_prefix_expression.blank?
+    end
+
+    def ani_regexp
+      return @ar if @ar
+
+      @ar = Regexp.new(self.attributes.ani_expression) unless self.attributes.ani_expression.blank?
+    end
+
+    def ani_prefix_regexp
+      return @apr if @apr
+
+      @apr = Regexp.new(self.attributes.ani_prefix_expression) unless self.attributes.ani_prefix_expression.blank?
+    end
+
+  end
+end

data/lib/routengn_client/models/inbound_rate.rb

@@ -0,0 +1,13 @@
+module RouteNGNClient
+  class InboundRate < RemoteModel
+
+    set_resource_attributes({
+                              :collection_name => 'rates',
+                              :index_method => 'inbound',
+                              :per_page => 200
+                            })
+
+    belongs_to :inbound_end_point_group
+
+  end
+end

data/lib/routengn_client/models/outbound_end_point_group.rb

@@ -0,0 +1,51 @@
+module RouteNGNClient
+  class OutboundEndPointGroup < RemoteModel
+
+    set_resource_attributes({
+                              :path_base => 'metallic/outbound_end_point_groups',
+                              :collection_name => 'outbound_end_point_groups',
+                              :per_page => 50,
+                              :request_options => {
+                              }
+                            })
+
+    belongs_to :carrier
+    has_many :end_points, :outbound_rates
+
+    def prioritized_end_points
+      eps_with_priority = self.end_points.select { |ep| !ep.attributes.priority.nil? }
+      eps_with_priority.shuffle!
+      eps_without_priority = self.end_points.select { |ep| ep.attributes.priority.nil? }
+      eps_without_priority.shuffle!
+
+      eps_with_priority.sort! { |x,y| x.attributes.priority <=> y.attributes.priority }
+      eps_without_priority.sort! { |x,y| x.random_priority <=> y.random_priority }
+
+      eps = (eps_with_priority + eps_without_priority)
+      self.attributes.max_contact_end_points ? eps[0, self.attributes.max_contact_end_points] : eps
+    end
+
+    def dialcode_regexp
+      Regexp.new(self.attributes.dialcode_expression) unless self.attributes.dialcode_expression.blank?
+    end
+
+    def build_uri_parts(options = {})
+      {
+        :uri_user_params => self.s_to_h(self.attributes.uri_user_params ? self.attributes.uri_user_params.strip : ''),
+        :uri_params => self.s_to_h(self.attributes.uri_params ? self.attributes.uri_params.strip : '')
+      }
+    end
+
+    protected
+
+      def s_to_h(s)
+        h = {}
+        m = s.match /^;*(.*);*$/
+
+        h = Hash[m[1].split(';').map! {|p| p.split('=')}] if m[1]
+
+        h
+      end
+
+  end
+end

data/lib/routengn_client/models/outbound_rate.rb

@@ -0,0 +1,13 @@
+module RouteNGNClient
+  class OutboundRate < RemoteModel
+
+    set_resource_attributes({
+                              :collection_name => 'rates',
+                              :index_method => 'outbound',
+                              :per_page => 200
+                            })
+
+    belongs_to :outbound_end_point_group
+
+  end
+end

data/lib/routengn_client/models/rate_sheet.rb

@@ -0,0 +1,13 @@
+module RouteNGNClient
+  class RateSheet < RemoteModel
+
+    set_resource_attributes({
+                              :collection_name => 'rate_sheets',
+                              :per_page => 25
+                            })
+    belongs_to :account
+    belongs_to :inbound_end_point_group
+    belongs_to :outbound_end_point_group
+
+  end
+end

data/lib/routengn_client/models/record.rb

@@ -0,0 +1,231 @@
+module RouteNGNClient
+  class Record < RemoteModel
+
+    set_resource_attributes({
+                              :collection_name => 'records',
+                              :per_page => 25
+                            })
+
+    belongs_to :account
+    belongs_to :inbound_end_point_group
+
+    def initialize(attributes = {})
+      super
+    end
+
+    def create!(attributes = {}, options = {})
+      options = options.merge({ :account_id => (self.account_id || (self.account.id if self.account)) })
+
+      attrs = attributes.merge({
+                :call_detail_record => (self.call_detail_record || self.call_detail_record_hash),
+                :inbound_end_point_group_id => (self.inbound_end_point_group_id || (self.inbound_end_point_group.id if self.inbound_end_point_group)),
+                :requested_at_float => (self.requested_at_float || (self.request.requested_at_float if self.request)),
+                :response_code => (self.response_code || (self.final_response.response_code if self.final_response)),
+                :logs => self.logs
+              })
+
+      self.class.create!(attrs, options)
+    end
+
+    def call_detail_record
+      self.attributes.call_detail_record
+    end
+
+    def call_detail_record_hash
+      self.class.values_to_hash(self.to_comma_headers, self.to_comma)
+    end
+
+    def routes_csvs(delimiter = ';')
+      (self.routes || []).map { |r| CSV.generate_line(r.to_comma, :force_quotes => true, :col_sep => delimiter, :quote_char => '\'').strip! }
+    end
+
+    def routes_string(delimiter = '|')
+      self.routes_csvs.join(delimiter)
+    end
+
+    def append_log(s, options = {})
+      append_timestamp = options.has_key?(:append_timestamp) ? options[:append_timestamp] : true
+
+      self.attributes.logs ||= []
+
+      if append_timestamp
+        age = self.attributes.request ? self.attributes.request.age.round(5) : nil
+        self.attributes.logs << "#{age}: #{s}"
+      else
+        self.attributes.logs << "#{s}"
+      end
+    end
+
+    def set_request(r)
+      return unless r
+
+      self.attributes.request = r
+      self.requested_at_float = r.requested_at_float
+      self.attributes.sip_request = r.sip_request
+      self.append_log "Processing request: #{(r.sip_request.blank? || r.sip_request.method.blank?) ? 'Unknown' : r.sip_request.method} from #{r.peer_ip.blank? ? 'Unknown' : r.peer_ip}"
+      self.append_log "#{r.sip_request.data if r.sip_request}"
+    end
+
+    def set_inbound_end_point_group(iepg)
+      return unless iepg
+
+      self.append_log "Using inbound_end_point_group:"
+      self.append_log iepg.to_log, :append_timestamp => false
+      self.attributes.inbound_end_point_group = iepg
+      self.attributes.account = iepg.account if iepg
+    end
+
+    def set_inbound_rate(rate)
+      return unless rate
+
+      self.append_log "Using inbound_rate:"
+      self.append_log rate.to_log, :append_timestamp => false
+      self.attributes.inbound_rate = rate
+    end
+
+    def set_origination_code(code)
+      return unless code
+
+      self.append_log "Using origination_code:"
+      self.append_log code.to_log, :append_timestamp => false
+      self.attributes.origination_code = code
+    end
+
+    def set_destination_code(code)
+      return unless code
+
+      self.append_log "Using destination_code:"
+      self.append_log code.to_log, :append_timestamp => false
+      self.attributes.destination_code = code
+    end
+
+    def set_rate_type(type)
+      return unless type
+
+      self.append_log "Using rate_type: #{type}"
+      self.attributes.rate_type = type
+    end
+
+    def add_route(route)
+      return unless route
+
+      self.append_log "Added route:"
+      self.append_log route.to_log, :append_timestamp => false
+      self.attributes.routes ||= []
+      self.attributes.routes << route
+    end
+
+    def add_route_table(route_table)
+      return unless route_table
+
+      self.append_log "Using route_table:"
+      self.append_log route_table.to_log, :append_timestamp => false
+      self.attributes.route_tables ||= []
+      self.attributes.route_tables << route_table
+    end
+
+    def final_route_table
+      self.attributes.route_tables.blank? ? nil : self.attributes.route_tables.last
+    end
+
+    def add_response(r)
+      return unless r
+
+      self.attributes.responses ||= []
+      self.attributes.responses << r
+      self.append_log "Sending response code: #{(r.sip_response.blank? || r.sip_response.status_code.blank?) ? 'Unknown' : r.sip_response.status_code}"
+      self.append_log "#{r.sip_response.data if r.sip_response}"
+    end
+
+    def final_response
+      self.attributes.responses.blank? ? nil : self.attributes.responses.last
+    end
+
+    def request
+      self.attributes.request
+    end
+
+    def sip_request
+      self.attributes.sip_request
+    end
+
+    def origination_code
+      self.attributes.origination_code
+    end
+
+    def destination_code
+      self.attributes.destination_code
+    end
+
+    def inbound_rate
+      self.attributes.inbound_rate
+    end
+
+    def sip_redirector_version
+      self.attributes.sip_redirector_version
+    end
+
+    def cache_prep!
+      attrs = Hashie::Mash.new
+      attrs.call_detail_record = self.call_detail_record_hash
+      attrs.account_id = self.account_id || (self.account.id if self.account)
+      attrs.inbound_end_point_group_id = self.inbound_end_point_group.id if self.inbound_end_point_group
+      attrs.requested_at_float = self.requested_at_float || (self.request.requested_at_float if self.request)
+      attrs.response_code = self.final_response.response_code if self.final_response
+      attrs.logs = self.logs
+      self.attributes = attrs
+    end
+
+    def as_cdr(delimiter = ',')
+      CSV.generate_line self.to_comma, :force_quotes => true, :col_sep => delimiter, :row_sep => nil
+    end
+
+    def self.values_to_hash(headers, values)
+      values.each_with_index {| v,i| headers[i] = [headers[i].to_sym, v] }
+      Hash[headers]
+    end
+
+    comma do
+      request :requested_at_iso => 'requested_at_iso'
+      request :requested_at_float => 'requested_at_float'
+      request :server_hostname => 'server'
+      request :peer_ip => 'peer_ip'
+      request :peer_port => 'peer_port'
+      request :sip_request_method => 'request_method'
+      request :uuid => 'request_uuid'
+      request :worker_id => 'worker_id'
+      sip_request :prefix => 'request_prefix'
+      sip_request :dialcode => 'request_dialcode'
+      sip_request :call_id => 'request_call_id'
+      sip_request :npdi => 'request_npdi'
+      sip_request :rn => 'request_rn'
+      sip_request :ani => 'request_ani'
+      origination_code :dialcode => 'origination_dialcode'
+      origination_code :local => 'origination_local'
+      origination_code :city => 'origination_city'
+      origination_code :state => 'origination_state'
+      origination_code :country => 'origination_country'
+      origination_code :lata => 'origination_lata'
+      origination_code :ocn => 'origination_ocn'
+      destination_code :dialcode => 'destination_dialcode'
+      destination_code :local => 'destination_local'
+      destination_code :city => 'destination_city'
+      destination_code :state => 'destination_state'
+      destination_code :country => 'destination_country'
+      destination_code :lata => 'destination_lata'
+      destination_code :ocn => 'destination_ocn'
+      final_route_table :name => 'route_table_name'
+      inbound_end_point_group :id => 'inbound_end_point_group_id'
+      inbound_end_point_group :name => 'inbound_end_point_group_name'
+      inbound_rate :price => 'inbound_rate_price'
+      inbound_rate :type => 'inbound_rate_type'
+      routes_string 'routes'  #"routes #{Route.to_comma_headers.join(';')}|route2|route3..."
+      final_response :elapsed_time => 'elapsed_time'
+      final_response :response_code => 'response_code'
+      final_response :internal_response_code => 'internal_response_code'
+      account :id => 'account_id'
+      sip_redirector_version 'sip_redirector_version'
+    end
+
+  end
+end

data/lib/routengn_client/models/route.rb

@@ -0,0 +1,42 @@
+module RouteNGNClient
+  class Route < Model
+
+    belongs_to :route_table, :outbound_end_point_group
+    has_one :outbound_rate
+
+    def contacts
+      @contacts ||= self.build_contacts
+    end
+
+    def build_contacts(end_points = nil)
+      if oepg = self.outbound_end_point_group
+        end_points ||= oepg.prioritized_end_points
+        @contacts = end_points.collect do |end_point|
+          Contact.new(:end_point => end_point, :route => self)
+        end
+      end
+    end
+
+    def build_aors(sip_request, inbound_end_point_group, options = {})
+      self.contacts.collect { |c| c.build_aor(sip_request, inbound_end_point_group, options) }
+    end
+
+    def inbound_rate
+      @attributes.inbound_rate
+    end
+
+    def blocked?
+      @attributes.has_key?('blocked') && @attributes.blocked == 'true' ? true : false
+    end
+
+    comma do
+      outbound_rate :price => 'outbound_rate_price'
+      outbound_rate :type => 'outbound_rate_type'
+      outbound_rate :dialcode => 'outbound_rate_dialcode'
+      outbound_rate :lata => 'outbound_rate_lata'
+      outbound_rate :ocn => 'outbound_rate_ocn'
+      outbound_end_point_group :name => 'outbound_end_point_group_name'
+    end
+
+  end
+end

data/lib/routengn_client/models/route_block.rb

@@ -0,0 +1,7 @@
+module RouteNGNClient
+  class RouteBlock < RemoteModel
+
+    belongs_to :route_table
+
+  end
+end

data/lib/routengn_client/models/route_container.rb

@@ -0,0 +1,18 @@
+module RouteNGNClient
+  class RouteContainer < Model
+
+    belongs_to :route_table
+    has_many :routes
+    has_one :inbound_rate
+
+    def enhanced_routes
+      self.routes.each do |route|
+        route.attributes.inbound_rate = self.inbound_rate
+        route.attributes.outbound_end_point_group = OutboundEndPointGroup.find(route.attributes.outbound_end_point_group_id, {:account_id => route.request_account_id})
+      end
+
+      self.routes
+    end
+
+  end
+end

data/lib/routengn_client/models/route_ordering_override.rb

@@ -0,0 +1,7 @@
+module RouteNGNClient
+  class RouteOrderingOverride < RemoteModel
+
+    belongs_to :route_table
+
+  end
+end

data/lib/routengn_client/models/route_table.rb

@@ -0,0 +1,30 @@
+module RouteNGNClient
+  class RouteTable < RemoteModel
+
+    set_resource_attributes({
+                              :path_base => 'metallic/route_tables',
+                              :collection_name => 'route_tables',
+                              :per_page => 25,
+                              :request_options => {
+                              }
+                            })
+
+    belongs_to :account
+    has_many :routes, :outbound_end_point_groups
+
+    def route_containers(params = {}, options = {}, &callback)      
+      options[:klass] ||= RouteContainer
+      options[:account_id] ||= self.request_account_id
+
+      models = []
+
+      response = Request.new(self.class.resource_attributes.merge(:collection_name => 'route_containers'), :get, [self.class.path_base, self.attributes.id, 'route_containers'], self.class.path_ext, params, options).execute(RouteNGNClient.connection)
+      models = response.to_models
+
+      callback.call(models) if callback
+
+      models
+    end
+
+  end
+end

data/lib/routengn_client/models/system_admin_account.rb

@@ -0,0 +1,5 @@
+module RouteNGNClient
+  class SystemAdminAccount < Account
+
+  end
+end

data/lib/routengn_client/models/uri_matcher.rb

@@ -0,0 +1,72 @@
+module RouteNGNClient
+  class URIMatcher < Model
+    include Comparable
+
+    HEADER_ORDER = %(contact from request)
+
+    belongs_to :allow_list
+
+    def <=>(other)
+      if self.header == other.header
+        case (self.weight <=> other.weight)
+        when 0
+          self.id.to_s <=> other.id.to_s
+        when 1 #self.weight is higher
+          -1
+        when -1 #self.weight is lower
+          1
+        else
+          0
+        end
+      else
+        return 0 if !HEADER_ORDER.include?(self.header) && !HEADER_ORDER.include?(other.header)
+        return -1 if !HEADER_ORDER.include?(self.header)
+        return 1 if !HEADER_ORDER.include?(other.header)
+        return (HEADER_ORDER.index(self.header) <=> HEADER_ORDER.index(other.header))
+      end
+    end
+
+    def weight
+      @weight ||= [@attributes.prefix, @attributes.user_params, @attributes.uri_params].select { |x| !x.blank? }.length
+    end
+
+    def matches?(args = {})
+      return false if !self.matches_header?(args[:header])
+      return false if !@attributes.prefix.blank? && !self.matches_prefix?(args[:prefix])
+      return false if !@attributes.user_params.blank? && !self.matches_user_params?(args[:user_params])
+      return false if !@attributes.uri_params.blank? && !self.matches_uri_params?(args[:uri_params])
+      return true
+    end
+
+    def matches_header?(arg)
+      !@attributes.header.blank? && !arg.blank? && @attributes.header == arg
+    end
+
+    def matches_prefix?(arg)
+      @attributes.prefix == arg
+    end
+
+    def matches_user_params?(arg)
+      if arg.is_a?(String)
+        @attributes.user_params == arg
+      elsif arg.is_a?(Array)
+        arg.include?(@attributes.user_params)
+      else
+        false
+      end
+    end
+
+    def matches_uri_params?(arg)
+      if arg.is_a?(String)
+        @attributes.uri_params == arg
+      elsif arg.is_a?(Array)
+        arg.include?(@attributes.uri_params)
+      else
+        false
+      end
+    end
+
+  end
+
+  class UriMatcher < URIMatcher;end
+end

data/lib/routengn_client/models/user.rb

@@ -0,0 +1,20 @@
+module RouteNGNClient
+  class User < RemoteModel
+
+    set_resource_attributes({
+                              :collection_name => 'users',
+                              :per_page => 25
+                            })
+
+    belongs_to :account
+
+    def admin?
+      self.admin.nil? ? false : self.admin
+    end
+
+    def call_processor?
+      self.call_processor.nil? ? false : self.call_processor
+    end
+
+  end
+end

data/lib/routengn_client/remote_model.rb

@@ -0,0 +1,69 @@
+module RouteNGNClient
+  class RemoteModel < Model
+
+    DEFAULT_RESOURCE_ATTRIBUTES = {
+      :path_base => nil,
+      :path_ext => '.json',
+      :index_method => nil,
+      :collection_name => '',
+      :per_page => 25,
+      :request_options => {}
+    }
+
+    @resource_attributes = DEFAULT_RESOURCE_ATTRIBUTES
+
+    module ClassMethods
+      attr_reader :resource_attributes
+      
+      def path_ext;@resource_attributes[:path_ext];end
+      def index_method;@resource_attributes[:index_method];end
+      def collection_name;@resource_attributes[:collection_name];end
+
+      def set_resource_attributes(ra)
+        @resource_attributes = DEFAULT_RESOURCE_ATTRIBUTES.merge(ra)
+      end
+
+      def path_base(params = {})
+        pb = @resource_attributes[:path_base] || File.join('/', @resource_attributes[:collection_name])
+        params.each { |k,v| pb.gsub!(":#{k}", v) } unless params.blank?
+        pb
+      end
+
+      def all(conditions = {}, options = {}, &callback)
+        options.merge!(:klass => self)
+        params = conditions
+        params[:per_page] ||= @resource_attributes[:per_page]
+        params[:page] ||= 1
+        params[:include_paging_info] = 'true' unless params.has_key?(:include_paging_info)
+        
+        response = Request.new(@resource_attributes, :get, [path_base, index_method], path_ext, params, options).execute(RouteNGNClient.connection)
+        models = response.to_models
+
+        callback.call(models) if callback
+
+        models
+      end
+
+      def where(conditions = {}, options = {}, &callback)
+        self.all(conditions, options, &callback)
+      end
+
+      def find(id, options = {}, &callback)
+        options.merge!(:klass => self)
+        
+        response = Request.new(@resource_attributes, :get, [path_base, id.to_s], path_ext, {}, options).execute(RouteNGNClient.connection)      
+        model = response.to_model
+
+        callback.call(models) if callback
+
+        model
+      end
+
+      def create!(attributes = {}, options = {}, &callback)
+        raise NotImplementedError
+      end
+    end
+
+    extend ClassMethods
+  end
+end