sipwizard 0.0.1 → 0.1.0

data/lib/sipwizard/provider.rb

@@ -0,0 +1,99 @@
+module Sipwizard
+  class Provider < Hashie::Trash
+    API_PATH_MAP = {
+      count: 'sipprovider/count',
+      find: 'sipprovider/get',
+      create: 'sipprovider/add',
+      update: 'sipprovider/update',
+      delete: 'sipprovider/delete'
+    }
+
+    string_to_bool = ->(string) { string == "true" }
+
+    property :id,                       from: :ID
+    property :provider_name,            from: :ProviderName
+    property :provider_username,        from: :ProviderUsername
+    property :provider_password,        from: :ProviderPassword
+    property :provider_server,          from: :ProviderServer
+    property :provider_auth_username,   from: :ProviderAuthUsername
+    property :provider_outbound_proxy,  from: :ProviderOutboundProxy
+    property :provider_type,            from: :ProviderType
+    property :provider_from,            from: :ProviderFrom
+    property :custom_headers,           from: :CustomHeaders
+    property :register_contact,         from: :RegisterContact
+    property :register_expiry,          from: :RegisterExpiry
+    property :register_server,          from: :RegisterServer
+    property :register_realm,           from: :RegisterRealm
+    property :register_enabled,         from: :RegisterEnabled, transform_with: ->(b) { string_to_bool.call(b) }
+    property :gv_callback_number,       from: :GVCallbackNumber
+    property :gv_callback_pattern,      from: :GVCallbackPattern
+    property :gv_callback_type,         from: :GVCallbackType
+
+    alias :register_enabled? :register_enabled
+
+    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.build_for_request(h)
+      provider = self.new(h)
+      provider = Hash[provider.map{ |k,v| ["#{k}".camelize, v] }]
+      provider['ID']                = provider.delete('Id')
+      provider['GVCallbackType']    = provider.delete('GvCallbackType')
+      provider['GVCallbackNumber']    = provider.delete('GvCallbackType')
+      provider['GVCallbackPattern']    = provider.delete('GvCallbackPattern')
+
+      provider.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.new.post(API_PATH_MAP[:create], payload)
+
+      raise ArgumentError.new(result["Error"]) unless result['Success']
+
+      result['Result'] #ID
+    end
+
+    def save
+      payload = Provider.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 binding(cache=true)
+      return @binding if @binding && cache
+      @binding = ProviderBinding.find_by_provider_id(self.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 delete
+      Provider.delete(self.id)
+    end
+  end
+end

data/lib/sipwizard/provider_binding.rb

@@ -0,0 +1,53 @@
+module Sipwizard
+  class ProviderBinding < Hashie::Trash
+    API_PATH_MAP={
+      count: 'sipproviderbinding/count',
+      find: 'sipproviderbinding/get'
+    }
+
+    string_to_bool = ->(string) { string == "true" }
+
+    property :id,                          from: :ID
+    property :provider_id,                 from: :ProviderID
+    property :provider_name,               from: :ProviderName
+    property :registration_failur_message, from: :RegistrationFailureMessage
+    property :last_register_time,          from: :LastRegisterTime
+    property :next_registration_time,      from: :NextRegistrationTime
+    property :last_register_attempt,       from: :LastRegisterAttempt
+    property :is_registered,               from: :IsRegistered, transform_with: ->(b) { string_to_bool.call(b) }
+    property :binding_expiry,              from: :BindingExpiry
+    property :binding_uri,                 from: :BindingURI
+    property :registrar_sip_socket,        from: :RegistrarSIPSocket
+    property :cseq,                        from: :CSeq
+
+    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.find_by_provider_id(id)
+      relation = self.where({ ProviderID: 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/rate.rb

@@ -0,0 +1,81 @@
+module Sipwizard
+  class Rate < Hashie::Trash
+    API_PATH_MAP={
+      count: 'rate/count',
+      create: 'rate/add',
+      find: 'rate/get',
+      update: 'rate/update',
+      delete: 'rate/delete'
+    }
+
+    property :id,                from: :ID
+    property :description,       from: :Description
+    property :prefix,            from: :Prefix
+    property :rate,              from: :Rate
+    property :rate_code,         from: :RateCode
+    property :setup_cost,        from: :SetupCost
+    property :inserted,          from: :Inserted
+    property :increment_seconds, from: :IncrementSeconds
+
+    def self.count(params={})
+      response = connection.get(API_PATH_MAP[:count], params)
+
+      response['Success'] ? response['Result'] : -1
+    end
+
+    def self.build_for_request(h)
+      rate = self.new(h)
+      rate = Hash[rate.map{ |k,v| ["#{k}".camelize, v] }]
+      rate['ID']                = rate.delete('Id')
+
+      rate.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 = Rate.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
+      Rate.delete(self.id)
+    end
+    private
+
+    def self.connection
+      Connection.new(api_type: :accounting)
+    end
+  end
+end

data/lib/sipwizard/relation.rb

@@ -0,0 +1,27 @@
+module Sipwizard
+  class Relation
+    attr_reader :relation
+
+    def initialize
+      @relation = Hashie::Clash.new
+    end
+
+    def where(params)
+      @relation.where( hash_to_query(params) )
+      self
+    end
+
+    def count(nb)
+      @relation.merge!({count: nb})
+      self
+    end
+
+    private
+
+    #Hack to comply with the api spec ... which sucks
+    def hash_to_query(h)
+      h = Hash[h.map{|k,v| [k, "\"#{v}\""]}]
+      Rack::Utils.unescape Rack::Utils.build_query(h)
+    end
+  end
+end

data/lib/sipwizard/version.rb

@@ -1,3 +1,3 @@
 module Sipwizard
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/sipwizard.gemspec

@@ -19,8 +19,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency 'rack', "~> 1.5.2"
-  spec.add_development_dependency "faraday", '~> 0.8.9'
-  spec.add_development_dependency "faraday_middleware", "~> 0.9.0"
+  spec.add_dependency "rake"
+  spec.add_dependency 'rack', "~> 1.5.2"
+  spec.add_dependency "faraday", '~> 0.8.9'
+  spec.add_dependency "faraday_middleware", "~> 0.9.0"
+  spec.add_dependency "hashie", "~> 2.0.5"
+  spec.add_dependency "activesupport"
 end

data/spec/lib/sipwizard/account_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Sipwizard::Account do
+  describe '.count(params={})' do
+    subject{ described_class.count }
+    it 'returns a result' do
+      expect(subject).to be_instance_of Fixnum
+    end
+  end
+
+  describe '.find(id)' do
+    let(:id){ settings['sensitive_data']['ID'] }
+
+    subject{ described_class.find(id) }
+
+    it 'returns an account' do
+      subject.should be_instance_of Sipwizard::Account
+      subject.id.should eq id
+    end
+  end
+
+  describe '.create(params)' do
+    let(:params) do
+      {
+        username: "foo",
+        password: "bar"
+      }
+    end
+
+    subject{ described_class.create(params) }
+
+    it 'creates a new account' do
+      response = subject
+      expect(response).not_to be_nil
+      expect(response).to be_instance_of String
+      expect(response).to match(/(?:\w|-)+/)
+    end
+
+    context 'if the username already exists' do
+      it 'raise an argument error' do
+        expect do
+          described_class.create(params)
+          described_class.create({username: 'foo', password: 'bra'})
+        end.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe '.save' do
+    let(:id){ settings['sensitive_data']['ID'] }
+    let(:account){ described_class.find(id) }
+
+    before{ account.should be_instance_of Sipwizard::Account }
+
+    subject{ account.save }
+
+    it 'updates the account' do
+      account.avatar_url = "foo"
+      response = subject
+      expect(response).not_to be_nil
+      expect(response).to be_instance_of String
+      expect(response).to match(/(?:\w|-)+/)
+    end
+  end
+
+  describe 'delete' do
+    let(:id){ settings['sensitive_data']['ID'] }
+
+    let(:account){ described_class.find(id) }
+
+    before{ account.should be_instance_of Sipwizard::Account }
+
+    subject{ account.delete }
+
+    it 'delete the account' do
+      response = subject
+      expect(response).to be_true
+    end
+  end
+end

data/spec/lib/sipwizard/binding_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Sipwizard::Binding do
+  describe '.count' do
+    subject{ described_class.count }
+
+    it 'returns the nb of account bindings' do
+      expect(subject).to be_instance_of Fixnum
+    end
+  end
+
+  describe '.find(id)' do
+    let(:id){ settings['sensitive_data']['ACCOUNT_BINDING_ID'] }
+
+    subject{ described_class.find(id) }
+
+    it 'returns an account binding' do
+      subject.should be_instance_of Sipwizard::Binding
+      subject.id.should eq id
+    end
+  end
+end

data/spec/lib/sipwizard/cdr_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Sipwizard::Cdr do
+  describe '.count' do
+    subject{ described_class.count }
+    it 'returns a result' do
+      expect(subject).to be_instance_of Fixnum
+    end
+  end
+
+  describe '.find(id)' do
+    let(:id){ settings['sensitive_data']['CDR_ID'] }
+
+    subject{ described_class.find(id) }
+
+    it 'returns an account' do
+      subject.should be_instance_of Sipwizard::Cdr
+      subject.id.should eq id
+    end
+  end
+end

data/spec/lib/sipwizard/configuration_spec.rb

@@ -7,7 +7,7 @@ describe Sipwizard::Configuration do
     let(:api_key){ 'foo' }
 
     it 'has a api_key' do
-      subject.api_key.must_equal api_key
+      subject.api_key.should eq api_key
     end
   end
 end

data/spec/lib/sipwizard/connection_spec.rb

@@ -2,40 +2,34 @@ require 'spec_helper'
 
 describe Sipwizard::Connection do
   let(:default_faraday_adapter) { Faraday::Adapter::NetHttp }
-  subject{ Sipwizard::Connection.new }
+  subject{ described_class.new }
 
   it 'returns a Faraday::Connection with the nethttp adapter' do
-    subject.faraday_connection.must_be_instance_of Faraday::Connection
-    subject.faraday_connection.builder.handlers.must_include default_faraday_adapter
+    subject.faraday_connection.should be_instance_of Faraday::Connection
+    subject.faraday_connection.builder.handlers.should include(default_faraday_adapter)
   end
 
-  describe '.uri_for_path' do
-    let(:path){ 'bar' }
-    subject{ Sipwizard::Connection.uri_for_path(path) }
+  describe '#get(params)' do
+    subject{ described_class.new.get('cdr/count') }
 
-    it "returns the base_uri of the api" do
-      subject.must_equal "#{Sipwizard::Connection::API_PATH}#{path}"
-    end
-  end
-
-  describe 'get(params)' do
-    let(:params){ { foo: 'bar' } }
-    let(:path){ '/path' }
-    let(:uri){ Sipwizard::Connection.uri_for_path(path) }
-    let(:faraday_connection) { Minitest::Mock.new }
-    let(:connection) do
-      Sipwizard::Connection.new.tap do |connection|
-        connection.faraday_connection = faraday_connection
+    context 'when the api key is valid' do
+      it 'doesnt complain' do
+        expect(subject["Error"]).to be_nil
+        expect(subject["Success"]).to be_true
       end
     end
 
-    subject { connection.get(path, params) }
+    context 'when the api key is invalid' do
+      let(:connection){ described_class.new }
+      subject{ connection.get('cdr/count') }
+      before do
+        connection.faraday_connection.headers['apikey'] = 'bar'
+      end
 
-    it 'calls connection.get with the right uri' do
-      response =  Minitest::Mock.new
-      faraday_connection.expect :get, response, [uri, params]
-      subject
-      faraday_connection.verify
+      it 'returns an error' do
+        expect(subject["Error"]).not_to be_nil
+        expect(subject["Success"]).to be_false
+      end
     end
   end
 end