bvr 0.0.1 → 0.1.0

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+0.1.0
+-----
+* [More Customer Centric] [https://github.com/gregory/bvr/tree/v0.1.0]
+* Matched all the API in a customer centric way
+
+0.0.1
+-----
+* [Initial release] [https://github.com/gregory/bvr/tree/v0.0.1]

data/Guardfile

@@ -9,6 +9,6 @@ guard :minitest do
 
   # with Minitest::Spec
   watch(%r{^spec/(.*)_spec\.rb})
-  watch(%r{^lib/(.+)\.rb})         { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb})         { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch(%r{^spec/spec_helper\.rb}) { 'spec' }
 end

data/README.md

@@ -24,11 +24,27 @@ Bvr.configure do |config|
   config.username, config.password = ['username', 'password']
 end
 `
-### Retreiving Call Overview
+### Retreiving All the info and form, and manage a customer
 `
-Bvr::CallOverview.find('a customer id')
+customer = Bvr::Customer.find('customer_id')
+customer.phones
+customer.phones.add( Bvr::Phone.new('+4412345678') )
+customer.balance
+customer.credit.add(10.20)
+customer.credit.rm(1.20)
+customer.block!
+customer.unblock!
+calls = customer.calls({recordcount: 100})
+calls.count = 250
+calls.size #=> 100
+calls.next? # => true, 150 are left
+
+Bvr::Customer.authenticate('customer_id', 'pass')
+
 `
 
+A lot of class methods are available, just have a look at the specs
+
 
 ## Contributing
 

data/bvr.gemspec

@@ -6,11 +6,11 @@ require 'bvr/version'
 Gem::Specification.new do |spec|
   spec.name          = "bvr"
   spec.version       = Bvr::VERSION
-  spec.authors       = ["gregory"]
+  spec.authors       = ["Gregory Horion"]
   spec.email         = ["greg2502@gmail.com"]
   spec.description   = %q{A ruby interface to Bestvoipreselling API}
   spec.summary       = spec.description
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/gregory/bvr"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
@@ -19,8 +19,8 @@ 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'
-  spec.add_development_dependency "faraday"
-  spec.add_development_dependency "happymapper"
+  spec.add_development_dependency "rake", "~> 10.1.1"
+  spec.add_development_dependency 'rack', "~> 1.5.2"
+  spec.add_development_dependency "faraday", "~> 0.8.8"
+  spec.add_development_dependency "xml-simple", "~> 1.1.3"
 end

data/lib/bvr.rb

@@ -1,4 +1,3 @@
-require 'happymapper'
 Dir[File.dirname(__FILE__) + '/bvr/*.rb'].each{ |file| require file }
 
 module Bvr
@@ -11,6 +10,8 @@ module Bvr
   end
 
   def connection
+    raise ::Exception.new("Please provide username and password") if @config.nil?
+
     @connection ||= Bvr::Connection.new
   end
 end

data/lib/bvr/call.rb

@@ -1,18 +1,28 @@
-require_relative 'phone'
 module Bvr
   class Call
-    include HappyMapper
+    attr_accessor :id, :calltype, :raw_start_time, :raw_dest, :raw_duration, :charge
 
-    tag 'Call'
-    attribute :id, String, tag: 'CallId'
-    attribute :calltype, String, tag: 'CallType'
-    attribute :start_time, Time, tag: 'StartTime'
-    attribute :dest, Phone, tag: 'Destination', parser: :phone_number_parser
-    attribute :duration, String, tag: 'Duration'
-    attribute :charge, String, tag: 'Charge' #? currency
+    def self.new_from_response(h)
+      self.new.tap do |call|
+        call.id             = h['CallId']
+        call.calltype       = h['CallType']
+        call.raw_start_time = h['StartTime']
+        call.raw_dest       = h['Destination']
+        call.raw_duration   = h['Duration']
+        call.charge         = h['Charge']
+      end
+    end
+
+    def duration
+      @_duration ||= Time.parse(self.raw_duration, self.start_time)
+    end
+
+    def dest
+      @_dest ||= Bvr::Phone.new(self.raw_dest)
+    end
 
-    def relative_duration
-      Time.parse(self.duration, start_time)
+    def start_time
+      @_start_time ||= Time.parse(self.raw_start_time)
     end
   end
 end

data/lib/bvr/call_collection.rb

@@ -0,0 +1,62 @@
+module Bvr
+  class CallCollection
+    # Valid Options:
+    #  Variable  Value Option  Description
+    #  command calloverview  Mandatory
+    #  username  X..140  Mandatory the username of the reseller
+    #  password  X..100  Mandatory the password of the reseller
+    #  customer  X..140  Mandatory the username of the customer
+    #  date  YYYY-MM-DD hh:nn:ss Optional  the datetime from which to start retrieving the history, current datetime is default
+    #  callid  N..1000000  Optional  the callid from which to start retrieving the history, 0 is default
+    #  recordcount 1 - 500 Optional  the maximum number of records returned, 10 is default, 500 is maximum
+    #  direction forward / backward  Optional  the direction to search, backward is default
+    VALID_OPTIONS = [:date, :callid, :recordcount, :direction, :customer, :command]
+    API_COMMANDS= {
+      find_by_customer_id: 'calloverview'
+    }
+
+    attr_accessor :query_params, :raw_count, :raw_more_data, :collection
+
+    def self.find_by_customer_id(customer_id, options={})
+      raise ArgumentError.new('Unknown Argument') unless self.valid_options?(options)
+
+
+      params = {
+        command: API_COMMANDS[:find_by_customer_id],
+        customer: customer_id
+      }
+
+      response = Bvr.connection.get(params.merge(options))
+
+      return [] if response['Calls'].nil?
+
+      self.new_from_response(response).tap do |call_collection|
+        call_collection.query_params = options
+      end
+    end
+
+    def self.new_from_response(h)
+      self.new.tap do |calls_collection|
+        calls_collection.raw_more_data  = h['MoreData']
+        calls_collection.raw_count = h['Calls']['Count']
+        calls_collection.collection = h['Calls']['Call'].each_with_object([]) do |callH, array|
+          array << Call.new_from_response(callH)
+        end
+      end
+    end
+
+    def count
+      Integer(self.raw_count)
+    end
+
+    def next?
+      self.raw_more_data == 'True'
+    end
+
+  private
+
+    def self.valid_options?(options)
+      options.empty? ? true : options.keys.all? { |option| VALID_OPTIONS.include? option }
+    end
+  end
+end

data/lib/bvr/connection.rb

@@ -1,5 +1,6 @@
 require 'faraday'
 require 'rack'
+require 'xmlsimple'
 
 module Bvr
   class Connection
@@ -20,11 +21,11 @@ module Bvr
     end
 
     def get(params)
-      #TODO: prase body for 500
-      self.faraday_connection.get(uri(params)).body
+      body = self.faraday_connection.get(self.class.uri_from_h(params)).body
+      ::XmlSimple.xml_in body, {ForceArray: false}
     end
 
-    def uri(queryH)
+    def self.uri_from_h(queryH)
       params = {
         username: Bvr.config.username,
         password: Bvr.config.password

data/lib/bvr/credit.rb

@@ -0,0 +1,47 @@
+module Bvr
+  class Credit < Struct.new(:raw_specific_balance, :raw_balance, :customer)
+    API_COMMANDS= {
+      add: 'settransaction'
+    }
+
+    def self.add(id, amount)
+      params = {
+        command: API_COMMANDS[:add],
+        customer: id,
+        amount: amount
+      }
+
+      Bvr.connection.get(params)
+    end
+
+    def add(amount)
+      response = Bvr::Credit.add(self.customer.id, amount)
+      return false unless response['Result'] == 'Success'
+
+      add_amount(amount) && true
+    end
+
+
+    def balance
+      @_balance ||= Float(self.raw_balance)
+    end
+
+    def rm(amount)
+      self.add(-1 * amount)
+    end
+
+    def specific_balance
+      @_specific_balance ||= Float(self.raw_specific_balance)
+    end
+
+  private
+
+    def add_amount(amount)
+      @_specific_balance = self.specific_balance + Float("%.5f" % amount)
+      @_balance          = self.balance          + Float("%.2f" % amount)
+
+      self.raw_specific_balance = "#{@_specific_balance}"
+      self.raw_balance = "#{@_balance}"
+    end
+  end
+end

data/lib/bvr/customer.rb

@@ -0,0 +1,149 @@
+module Bvr
+  class Customer
+    API_COMMANDS = {
+      find: "getuserinfo",
+      create: "createcustomer",
+      block: "changeuserinfo",
+      authenticate: "validateuser",
+      changepassword: 'changepassword'
+    }
+
+    BLOCKED_VALUES = {
+      true => 'True',
+      false => 'False'
+    }
+
+    CREATE_OPTIONS = {
+      mendatory: [
+        :username,
+        :password,
+        :command,
+        :customer,
+        :customerpassword
+      ],
+      optional: [
+        :geocalicli,
+        :tariffrate
+      ]
+    }
+
+    attr_accessor :id, :email, :raw_blocked, :credit, :password, :phones
+
+    def initialize(id)
+      @id = id
+      @phones = Bvr::PhoneCollection.new(id)
+    end
+
+    def self.authenticate(id, password)
+      params = {
+        command: API_COMMANDS[:authenticate],
+        customer: id,
+        customerpassword: password
+      }
+
+      response = Bvr.connection.get(params)
+      response['Result'] == 'Success'
+    end
+
+    def self.block(id, block=true)
+      params = {
+        command: API_COMMANDS[:changeuserinfo],
+        customer: id,
+        customerblocked: block
+      }
+
+      raise ArgumentError.new('Please provide a boolean') unless !!block == block
+
+      Bvr.connection.get(params)
+    end
+
+    def self.change_password(id, old_password, new_password)
+      params = {
+        command: API_COMMANDS[:changepassword],
+        customer: id,
+        oldcustomerpassword: old_password,
+        newcustomerpassword: new_password
+      }
+
+      Bvr.connection.get(params)
+    end
+
+    def self.create(options)
+      params = { command: API_COMMANDS[:create] }
+
+      options.merge!(params)
+      raise ArgumentError.new('Invalid or unknown Argument') unless self.valid_create_options?(options)
+
+      Bvr.connection.get(options)
+    end
+
+    def self.find(id)
+      params = {
+        command: API_COMMANDS[:find],
+        customer: id
+      }
+
+      response = Bvr.connection.get(params)
+
+      response['Failed'].nil? ? self.new_from_response(response) : nil
+    end
+
+    def self.new_from_response(h)
+      self.new(h["Customer"]).tap do |customer|
+        customer.email   = h["EmailAddress"]
+        customer.raw_blocked = h["Blocked"]
+        customer.credit  = Bvr::Credit.new(h["SpecificBalance"], h["Balance"], customer)
+        h['GeocallCLI'].each{ |number| customer.phones << Bvr::Phone.new(number)}
+      end
+    end
+
+    def balance
+      self.credit.balance
+    end
+
+    def blocked?
+      self.raw_blocked == BLOCKED_VALUES[true]
+    end
+
+    def block!
+      response = Bvr::Customer.block(self.id, true)
+
+      if response['Result'][0] == 'Success'
+        self.raw_blocked = BLOCKED_VALUES[true]
+      end
+
+      return response['Result'][0] == 'Success'
+    end
+
+    def change_password(new_password)
+      response = Bvr::Customer.change_password(self.id, self.password, new_password)
+      return false if response['Result'] != 'Success'
+
+      self.password = new_password
+    end
+
+    def unblock!
+      response = Bvr::Customer.block(self.id, false)
+
+      if response['Result'][0] == 'Success'
+        self.raw_blocked = BLOCKED_VALUES[false]
+      end
+
+      return response['Result'][0] == 'Success'
+    end
+
+    def calls(options={})
+      return @_calls if @_calls && @_calls.query_params == options
+      @_calls = Bvr::CallCollection.find_by_customer_id(self.id, options)
+    end
+
+  private
+
+    def self.valid_create_options?(options)
+      return false if options.empty?
+      valid_options = CREATE_OPTIONS.values.flatten
+      return false unless options.keys.all? { |option| valid_options.include? option }
+      CREATE_OPTIONS[:mendatory].all? { |option| options.keys.include? option }
+    end
+  end
+end

data/lib/bvr/phone.rb

@@ -1,13 +1,4 @@
 module Bvr
-  class Phone
-    attr_accessor :number
-
-    def initialize(phone_number)
-      @number = phone_number
-    end
-
-    def self.phone_number_parser(phone_number)
-      self.new(phone_number)
-    end
+  class Phone < Struct.new(:number)
   end
 end

data/lib/bvr/phone_collection.rb

@@ -0,0 +1,59 @@
+module Bvr
+  class PhoneCollection
+    include Enumerable
+
+    API_COMMANDS = {
+      add: 'changeuserinfo'
+    }
+
+    attr_reader :collection, :customer_id
+
+    def initialize(customer_id)
+      @collection = []
+      @customer_id = customer_id
+    end
+
+    def self.add(customer_id, phone, add="add")
+      params = {
+        command: API_COMMANDS[:add],
+        customer: customer_id,
+        geocallcli_options: add,
+        geocallcli: phone
+      }
+
+      Bvr.connection.get(params)
+    end
+
+    def add(phone)
+      return true if self.collection.include? phone
+
+      response = Bvr::PhoneCollection.add(self.customer_id, phone.number)
+      return false unless response['Result'][0] == 'Success'
+
+      self.collection << phone
+      true
+    end
+
+    def each(&block)
+      @collection.each { |em| block.call(em) }
+    end
+
+    def rm(phone)
+      return false unless self.collection.include? phone
+
+      response = Bvr::PhoneCollection.add(self.customer_id, phone.number, "delete")
+      return false unless response['Result'][0] == 'Success'
+
+      self.collection.delete phone
+      true
+    end
+
+  private
+
+    def method_missing(method, arg, &block)
+      return super unless self.collection.respond_to? method
+
+      self.collection.send(method, arg, &block)
+    end
+  end
+end