sipwizard 0.0.1 → 0.1.0

data/.gitignore

@@ -3,6 +3,7 @@
 .bundle
 .config
 .yardoc
+spec/*.yml
 Gemfile.lock
 InstalledFiles
 _yardoc

data/Gemfile

@@ -3,12 +3,18 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in sipwizard.gemspec
 
 group :test do
-  gem 'minitest', '~> 4.7.5'
+  gem 'rspec'
   gem 'guard'
-  gem 'guard-minitest'
+  gem 'guard-rspec'
+  gem 'vcr'
+  gem 'spork'
+end
+
+group :test, :development do
   gem 'pry'
   gem 'pry-debugger'
-  gem 'turn'
+  gem 'pry-rescue'
+  gem 'pry-stack_explorer'
 end
 
 gemspec

data/Guardfile

@@ -1,9 +1,10 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
-guard :minitest do
-  # with Minitest::Spec
-  watch(%r{^spec/(.*)_spec\.rb})
-  watch(%r{^lib/(.+)\.rb})         { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch(%r{^spec/spec_helper\.rb}) { 'spec' }
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
 end
+

data/lib/sipwizard.rb

@@ -1,6 +1,9 @@
+require 'rack'
+require 'hashie'
 Dir[File.dirname(__FILE__) + '/sipwizard/*.rb'].each{ |file| require file }
 
 module Sipwizard
+  HTTP_STATUS_CODES = Rack::Utils::HTTP_STATUS_CODES.invert
   extend self
 
   attr_accessor :config

data/lib/sipwizard/account.rb

@@ -0,0 +1,101 @@
+require 'active_support/core_ext/string/inflections'
+
+module Sipwizard
+  class Account < Hashie::Trash
+    API_PATH_MAP ={
+      count: 'sipaccount/count',
+      find:  'sipaccount/get',
+      create: 'sipaccount/add',
+      update: 'sipaccount/update',
+      delete: 'sipaccount/delete'
+    }
+
+    string_to_bool = ->(string) { string == "true" }
+
+    property :id,                      from: :ID
+    property :domain,                  from: :SIPDomain
+    property :username,                from: :SIPUsername, required: true
+    property :password,                from: :SIPPassword,required: true
+    property :account_code,            from: :AccountCode
+    property :avatar_url,              from: :AvatarURL
+    property :description,             from: :Description
+    property :dont_mangle_enabled,     from: :DontMangleEnabled,    transform_with: ->(b) { string_to_bool.call(b) }
+    property :ip_address_acl,          from: :IPAddressACL
+    property :in_dial_plan_name,       from: :InDialPlanName
+    property :is_incoming_only,        from: :IsIncomingOnly,       transform_with: ->(b) { string_to_bool.call(b) }
+    property :is_switch_board_enabled, from: :IsSwitchboardEnabled, transform_with: ->(b) { string_to_bool.call(b) }
+    property :is_user_disabled,        from: :IsUserDisabled,       transform_with: ->(b) { string_to_bool.call(b) }
+    property :network_id,              from: :NetworkID
+    property :out_dial_plan_name,      from: :OutDialPlanName
+    property :send_nat_keep_alives,    from: :SendNATKeepAlives,    transform_with: ->(b) { string_to_bool.call(b) }
+
+    alias :dont_mangle? :dont_mangle_enabled
+    alias :incoming_only? :is_incoming_only
+    alias :switch_board_enabled? :is_switch_board_enabled
+    alias :user_disabled? :is_user_disabled
+    alias :send_nat_keep_alives? :send_nat_keep_alives
+
+    def self.build_for_request(h)
+      account = self.new(h)
+      account = Hash[account.map{ |k,v| ["#{k}".camelize, v] }]
+      account['ID']                = account.delete('Id')
+      account['SIPDomain']         = account.delete('Domain')
+      account['SIPUsername']       = account.delete('Username')
+      account['SIPPassword']       = account.delete('Password')
+      account['IPAddressACL']      = account.delete('IpAddressAcl')
+      account['AvatarURL']         = account.delete('AvatarUrl')
+      account['NetworkID']         = account.delete('NetworkId')
+      account['SendNATKeepAlives'] = account.delete('SendNatKeepAlives')
+
+      account.delete_if{ |_,v| v.nil? } #delete all the keys for which we dont have value
+    end
+
+    def self.count(params={})
+      response = Connection.new.get(API_PATH_MAP[:count], params)
+
+      response['Success'] ? response['Result'] : -1
+    end
+
+    def self.where(params)
+      Relation.new.where(params)
+    end
+
+    def self.find(id)
+      relation = self.where({ ID: id }).count(1)
+      result = Connection.new.get(API_PATH_MAP[:find], relation.relation)
+
+      return nil unless result['Success']
+
+      self.new(result['Result'][0])
+    end
+
+    def self.create(params)
+      payload = self.build_for_request(params)
+      result = Connection.new.post(API_PATH_MAP[:create], payload)
+
+      raise ArgumentError.new(result["Error"]) unless result['Success']
+
+      result['Result'] #ID
+    end
+
+    def self.delete(id)
+      result = Connection.new.get(API_PATH_MAP[:delete], {id: id})
+
+      raise ArgumentError.new(result["Error"]) unless result['Success']
+
+      result['Result'] #true | false
+    end
+
+    def save
+      payload = Account.build_for_request(self.to_hash)
+      result = Connection.new.post(API_PATH_MAP[:update], payload)
+      raise ArgumentError.new(result["Error"]) unless result['Success']
+
+      result['Result'] #ID
+    end
+
+    def delete
+      Account.delete(self.id)
+    end
+  end
+end

data/lib/sipwizard/binding.rb

@@ -0,0 +1,40 @@
+module Sipwizard
+  class Binding < Hashie::Trash
+    API_PATH_MAP={
+      count: 'sipaccountbinding/count',
+      find:  'sipaccountbinding/get'
+    }
+
+    property :id,                   from: :ID
+    property :contact_udi,          from: :ContactURI
+    property :expiry,               from: :Expiry
+    property :expiry_time,          from: :ExpiryTime
+    property :last_update,          from: :LastUpdate
+    property :mangled_contact_uri,  from: :MangledContactURI
+    property :proxy_sip_socket,     from: :ProxySIPSocket
+    property :registrat_sip_socket, from: :RegistrarSIPSocket
+    property :remote_sip_socket,    from: :RemoteSIPSocket
+    property :account_id,           from: :SIPAccountID
+    property :account_name,         from: :SIPAccountName
+    property :user_agent,           from: :UserAgent
+
+    def self.count
+      response = Connection.new.get(API_PATH_MAP[:count])
+
+      response['Success'] ? response['Result'] : -1
+    end
+
+    def self.where(params)
+      Relation.new.where(params)
+    end
+
+    def self.find(id)
+      relation = self.where({ ID: id }).count(1)
+      result = Connection.new.get(API_PATH_MAP[:find], relation.relation)
+
+      return nil unless result['Success']
+
+      self.new(result['Result'][0])
+    end
+  end
+end

data/lib/sipwizard/cdr.rb

@@ -0,0 +1,59 @@
+module Sipwizard
+  class Cdr < Hashie::Trash
+    API_PATH_MAP={
+      count: 'cdr/count',
+      find:  'cdr/get'
+    }
+
+    property :account_code, from: :AccountCode
+    property :answered_reason,      from: :AnsweredReason
+    property :answered_status,      from: :AnsweredStatus
+    property :answered_time,        from: :AnsweredTime
+    property :balance,              from: :Balance
+    property :bridge_id,            from: :BridgeId
+    property :call_direction,       from: :CallDirection
+    property :call_id,              from: :CallId
+    property :cost,                 from: :Cost
+    property :created,              from: :Created
+    property :dial_plan_context_id, from: :DialPlanContextID
+    property :dst,                  from: :Dst
+    property :dst_host,             from: :DstHost
+    property :dst_uri,              from: :DstURI
+    property :duration,             from: :Duration
+    property :from_header,          from: :FromHeader
+    property :from_name,            from: :FromName
+    property :from_user,            from: :FromUser
+    property :hungup_reason,        from: :HungupReason
+    property :hungup_time,          from: :HungupTime
+    property :id,                   from: :ID
+    property :in_progress_reason,   from: :InProgressReason
+    property :in_progress_status,   from: :InProgressStatus
+    property :in_progress_time,     from: :InProgressTime
+    property :increment_seconds,    from: :IncrementSeconds
+    property :inserted,             from: :Inserted
+    property :local_socket,         from: :LocalSocket
+    property :rate,                 from: :Rate
+    property :remote_socket,        from: :RemoteSocket
+    property :ring_duration,        from: :RingDuration
+    property :setup_cost,           from: :SetupCost
+
+    def self.count
+      response = Connection.new.get(API_PATH_MAP[:count])
+
+      response['Success'] ? response['Result'] : -1
+    end
+
+    def self.where(params)
+      Relation.new.where(params)
+    end
+
+    def self.find(id)
+      relation = self.where({ ID: id }).count(1)
+      result = Connection.new.get(API_PATH_MAP[:find], relation.relation)
+
+      return nil unless result['Success']
+
+      self.new(result['Result'][0])
+    end
+  end
+end

data/lib/sipwizard/connection.rb

@@ -3,27 +3,51 @@ require 'faraday_middleware'
 
 module Sipwizard
   class Connection
-    API_PATH = 'https://www.sipsorcery.com/rest/v0.1/provisioning.svc'
+    BASE_REST_API= "https://www.sipsorcery.com/rest/v0.1"
+    API_PATHS ={
+      provisioning: "#{BASE_REST_API}/provisioning.svc",
+      accounting: "#{BASE_REST_API}/accounting.svc",
+    }
 
     attr_accessor :faraday_connection
 
-    def initialize(faraday_adapter=Faraday.default_adapter)
-      @faraday_connection = Faraday.new do |faraday|
+    def initialize(options={})
+      faraday_adapter = options.fetch(:adapter){ Faraday.default_adapter }
+      api_type        = options.fetch(:api_type){ :provisioning }
+      @faraday_connection = Faraday.new(API_PATHS[api_type]) do |faraday|
         faraday.request :url_encoded #for post/put params
+
         faraday.response :logger
+        faraday.response :raise_error
         faraday.response :json, content_type: /\bjson\z/
+
         faraday.adapter faraday_adapter
       end
 
       @faraday_connection.headers['apikey'] = Sipwizard.config.api_key
     end
 
-    def self.uri_for_path(path)
-      "#{API_PATH}#{path}"
-    end
 
+    # Public make a get request to the api
+    #
+    # path   - The path of the api
+    # params - The query parameters (default: {}):
+    #
+    # Examples
+    #
+    #   get('cdr/count')
+    #
+    #   get('cdr/count', { where: 'FromName="John Doe"'})
+    #
+    # Returns Faraday::Response
     def get(path, params={})
-      self.faraday_connection.get(Connection.uri_for_path(path), params)
+      self.faraday_connection.get(path, params).body
+    end
+
+    def post(path, params)
+      self.faraday_connection.headers['Content-Type'] ='application/json; charset=utf-8'
+      payload = params.to_json
+      self.faraday_connection.post(path, payload).body
     end
   end
 end

data/lib/sipwizard/customer.rb

@@ -0,0 +1,81 @@
+module Sipwizard
+  class Customer < Hashie::Trash
+    API_PATH_MAP={
+      count:  'customeraccount/count',
+      create: 'customeraccount/add',
+      find:   'customeraccount/get',
+      update: 'customeraccount/update',
+      delete: 'customeraccount/delete'
+    }
+
+    property :id,             from: :ID
+    property :account_code,   from: :AccountCode
+    property :credit,         from: :Credit
+    property :account_name,   from: :AccountName
+    property :account_number, from: :AccountNumber
+    property :pin,            from: :PIN
+    property :inserted,       from: :Inserted
+
+    def self.count(params={})
+      response = connection.get(API_PATH_MAP[:count], params)
+
+      response['Success'] ? response['Result'] : -1
+    end
+
+    def self.build_for_request(h)
+      customer = self.new(h)
+      customer = Hash[customer.map{ |k,v| ["#{k}".camelize, v] }]
+      customer['ID']                = customer.delete('Id')
+      customer['PIN']               = customer.delete('Pin')
+
+      customer.delete_if{ |_,v| v.nil? } #delete all the keys for which we dont have value
+    end
+
+    def self.create(params)
+      payload = self.build_for_request(params)
+      result = connection.post(API_PATH_MAP[:create], payload)
+
+      raise ArgumentError.new(result["Error"]) unless result['Success']
+
+      result['Result'] #ID
+    end
+
+    def self.where(params)
+      Relation.new.where(params)
+    end
+
+    def self.find(id)
+      relation = self.where({ ID: id }).count(1)
+      result = connection.get(API_PATH_MAP[:find], relation.relation)
+
+      return nil unless result['Success']
+
+      self.new(result['Result'][0])
+    end
+
+    def save
+      payload = Customer.build_for_request(self.to_hash)
+      result = Connection.new(api_type: :accounting).post(API_PATH_MAP[:update], payload)
+      raise ArgumentError.new(result["Error"]) unless result['Success']
+
+      result['Result'] #ID
+    end
+
+    def self.delete(id)
+      result = connection.get(API_PATH_MAP[:delete], {id: id})
+
+      raise ArgumentError.new(result["Error"]) unless result['Success']
+
+      result['Result'] #true | false
+    end
+
+    def delete
+      Customer.delete(self.id)
+    end
+    private
+
+    def self.connection
+      Connection.new(api_type: :accounting)
+    end
+  end
+end

data/lib/sipwizard/dial_plan.rb

@@ -0,0 +1,91 @@
+module Sipwizard
+  class DialPlan < Hashie::Trash
+    API_PATH_MAP= {
+      count: 'dialplan/count',
+      find: 'dialplan/get',
+      create: 'dialplan/add',
+      delete: 'dialplan/delete',
+      update: 'dialplan/update',
+      copy: 'dialplan/copy'
+    }
+
+    string_to_bool = ->(string) { string == "true" }
+
+    property :id,                      from: :ID
+    property :dial_plan_name,          from: :DialPlanName
+    property :trace_email_address,     from: :TraceEmailAddress
+    property :dial_plan_script,        from: :DialPlanScript
+    property :script_type_description, from: :ScriptTypeDescription
+    property :accept_non_invite,       from: :AcceptNonInvite, transform_with: ->(b) { string_to_bool.call(b) }
+
+    alias :accept_non_invite? :accept_non_invite
+
+    def self.build_for_request(h)
+      dial_plan = self.new(h)
+      dial_plan = Hash[dial_plan.map{ |k,v| ["#{k}".camelize, v] }]
+      dial_plan['ID'] = dial_plan.delete('Id')
+
+      dial_plan.delete_if{ |_,v| v.nil? } #delete all the keys for which we dont have value
+    end
+
+    def self.count(params={})
+      response = Connection.new.get(API_PATH_MAP[:count], params)
+
+      response['Success'] ? response['Result'] : -1
+    end
+
+    def self.where(params)
+      Relation.new.where(params)
+    end
+
+    def self.find(id)
+      relation = self.where({ ID: id }).count(1)
+      result = Connection.new.get(API_PATH_MAP[:find], relation.relation)
+
+      return nil unless result['Success']
+
+      self.new(result['Result'][0])
+    end
+
+    def self.create(params)
+      payload = self.build_for_request(params)
+      result = Connection.new.post(API_PATH_MAP[:create], payload)
+
+      raise ArgumentError.new(result["Error"]) unless result['Success']
+
+      result['Result'] #ID
+    end
+
+    def self.delete(id)
+      result = Connection.new.get(API_PATH_MAP[:delete], {id: id})
+
+      raise ArgumentError.new(result["Error"]) unless result['Success']
+
+      result['Result'] #true | false
+    end
+
+    def self.copy(id)
+      result = Connection.new.get(API_PATH_MAP[:copy], {id: id})
+
+      raise ArgumentError.new(result["Error"]) unless result['Success']
+
+      result['Result'] #true | false
+    end
+
+    def save
+      payload = DialPlan.build_for_request(self.to_hash)
+      result = Connection.new.post(API_PATH_MAP[:update], payload)
+      raise ArgumentError.new(result["Error"]) unless result['Success']
+
+      result['Result'] #ID
+    end
+
+    def delete
+      DialPlan.delete(self.id)
+    end
+
+    def copy
+      DialPlan.copy(self.id)
+    end
+  end
+end