expresscheckout 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2911f083bf551ec6ea823f7c7e51a9550640618
-  data.tar.gz: 554f843e45ea181479b224cb15ef3a014289676f
+  metadata.gz: 943df6f1dca8ae6f76f96ecea6843fe6abe112d2
+  data.tar.gz: 94048f6a2fcdca9ba1a02910562d792e4dc490d1
 SHA512:
-  metadata.gz: 45df3a1113adaba0a7d720791971d3ac19d5c4755a8f14638b5beac1fc05c0e3b2aa1584b2f63c1f55cfe0138883661d7d1c727e151b9eb6c1537bdd1ef49317
-  data.tar.gz: 4930e17109385464d634759ff372cb15fd98ffd9275b583c4b3dfcd4c502fba3a728d6fcc1b4b4eed35da31d71ea682cafd6846fe78fca00f613d578103419ad
+  metadata.gz: 6665100fb84b0d0f64a178715970097f829033f3f85f175d6798cd893a7b288cdf21e320042ba68d6a8c22eb9ddd3c4d60301f480a3d3c9597059fb79b4103c4
+  data.tar.gz: 7e934728755289d271a71d5e6c94efaf4f06ed28d2acc1d9a353799b64329a10ede5acdbb81263556d54079080ac954e62271804bbfa8ed0cb06894b7c5411be

data/.gitignore

@@ -7,3 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+.idea/
+*xml

data/README.md

@@ -26,7 +26,7 @@ Or install it yourself as:
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## Contributing
 

data/RELEASE.md

@@ -0,0 +1,3 @@
+# Release New Version
+
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

data/example.rb

@@ -0,0 +1,12 @@
+require 'expresscheckout'
+require 'pp'
+
+$api_key = '187BF8D543A545789497F14FCAFBD85C'
+
+@timestamp = Time.now.to_i
+
+order = Orders.create(:order_id => @timestamp, :amount =>10)
+pp order
+
+list = Orders.list()
+pp list

data/expresscheckout.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib","lib/Orders.rb","lib/expresscheckout.rb","lib/Payments.rb","lib/Cards.rb","lib/Test.rb","lib/util.rb",]
+  spec.require_paths = ["lib","lib/Orders.rb","lib/expresscheckout.rb","lib/Payments.rb","lib/Cards.rb","lib/Test.rb","lib/util.rb","lib/Customers.rb","lib/Wallets.rb"]
 
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/Cards.rb

@@ -26,56 +26,26 @@ class Cards
 
   end
 
-  def Cards.add(options={})
+  def Cards.create(options={})
+    if (options.length == 0)
+      raise InvalidArguementError.new()
+    end
+
     method = 'POST'
     url = '/card/add'
-    parameters = {}
-    required_args = {}
-    Array[:merchant_id, :customer_id, :customer_email, :card_number, :card_exp_year, :card_exp_month].each do |key|
-      required_args.store(key,'False')
-    end
-    options.each do |key, value|
-      parameters.store(key,value)
-      required_args[key] = 'True'
-    end
-    Array[:merchant_id, :customer_id, :customer_email, :card_number, :card_exp_year, :card_exp_month].each do |key|
-      if required_args[key] == 'False'
-        raise "ERROR: #{key} is a required argument for Cards.add"
-      end
-    end
-    parameters.each do |key, _|
-      unless Array[:merchant_id, :customer_id, :customer_email, :card_number, :card_exp_year,
-                   :card_exp_month, :name_on_card, :nickname].include?(key)
-        puts " #{key} is an invalid argument for Cards.add"
-      end
-    end
     response = request(method,url,options)
     card = Card.new(response.body)
     return card
   end
 
   def Cards.list(options={})
+    customer_id = get_arg(options,:customer_id)
+    if customer_id == NIL
+      raise InvalidArguementError.new("ERROR: `customer_id` is a required parameter for Cards.list().")
+    end
+
     method = 'GET'
     url = '/card/list'
-    parameters = {}
-    required_args = {}
-    Array[:customer_id].each do |key|
-      required_args.store(key,'False')
-    end
-    options.each do |key, value|
-      parameters.store(key,value)
-      required_args[key] = 'True'
-    end
-    Array[:customer_id].each do |key|
-      if required_args[key] == 'False'
-        raise "ERROR: #{key} is a required argument for Cards.list"
-      end
-    end
-    parameters.each do |key, _|
-      unless Array[:customer_id].include?(key)
-        puts " #{key} is an invalid argument for Cards.list"
-      end
-    end
     response = Array(request(method,url,options).body['cards'])
     cards = []
     i=0
@@ -88,27 +58,13 @@ class Cards
   end
 
   def Cards.delete(options={})
+    card_token = get_arg(options,:card_token)
+    if card_token == NIL
+      raise InvalidArguementError.new("ERROR: `card_token` is a required parameter for Card.delete().")
+    end
+
     method = 'POST'
     url = '/card/delete'
-    parameters = {}
-    required_args = {}
-    Array[:card_token].each do |key|
-      required_args.store(key,'False')
-    end
-    options.each do |key, value|
-      parameters.store(key,value)
-      required_args[key] = 'True'
-    end
-    Array[:card_token].each do |key|
-      if required_args[key] == 'False'
-        raise "ERROR: #{key} is a required argument for  Cards.delete"
-      end
-    end
-    parameters.each do |key, _|
-      unless Array[:card_token].include?(key)
-        puts " #{key} is an invalid argument for Cards.delete"
-      end
-    end
     response = request(method,url,options)
     card = Card.new(response.body)
     return card

data/lib/Customers.rb

@@ -0,0 +1,92 @@
+require_relative 'util'
+
+class Customers
+
+  # noinspection ALL
+  class Customer
+
+    attr_reader :id, :object, :date_created, :email_address, :first_name, :last_name, :mobile_country_code, :mobile_number, :object_reference_id
+
+    def initialize(options = {})
+      @id = get_arg(options, 'id')
+      @object = get_arg(options, 'object')
+      @date_created = get_arg(options, 'date_created')
+      @last_update = get_arg(options, 'last_updated')
+      @email_address = get_arg(options, 'email_address')
+      @first_name = get_arg(options, 'first_name')
+      @last_name = get_arg(options, 'last_name')
+      @mobile_country_code = get_arg(options, 'mobile_country_code')
+      @mobile_number = get_arg(options, 'mobile_number')
+      @object_reference_id = get_arg(options, 'object_reference_id')
+    end
+
+  end
+
+  def Customers.create(options={})
+    if (options.length == 0)
+      raise InvalidArguementError.new()
+    end
+    method = 'POST'
+    url = '/customers'
+    response = request(method,url,options)
+    customers = Customer.new(response.body)
+    return customers
+  end
+
+  def Customers.list(options={})
+    method = 'GET'
+    url = '/customers'
+    offset = get_arg(options,:offset)
+    count = get_arg(options,:count)
+
+    if count == NIL and offset == NIL
+          puts "count & offset can be passed if required.\n"
+    end
+
+    response = request(method,url,options).body
+    customer_list = Array(response['list'])
+    customers = []
+    customer_list.each  do |customerData|
+      customer = Customer.new(customerData)
+      customers.push(customer)
+    end
+    customer_response = {
+        'count' => response['count'],
+        'offset' => response['offset'],
+        'total' => response['total'],
+        'list' => customers
+    }
+    return customer_response
+  end
+
+  def Customers.get(options={})
+    customer_id = get_arg(options,:customer_id)
+    if customer_id == NIL
+      raise InvalidArguementError.new("ERROR: `customer_id` is a required parameter for Customers.get().")
+    end
+
+    method = 'GET'
+    url = "/customers/#{customer_id}"
+    response = request(method,url,options)
+    customers = Customer.new(response.body)
+    return customers
+  end
+
+  def Customers.update(options={})
+    customer_id = get_arg(options,:customer_id)
+    if customer_id == NIL
+      raise InvalidArguementError.new("ERROR: `customer_id` is a required parameter for Customers.update().")
+    end
+
+    method = 'POST'
+    url = "/customers/#{customer_id}"
+    response = request(method,url,options)
+    customers = Customer.new(response.body)
+    return customers
+  end
+
+  def Customers.delete(options={})
+    raise "ERROR: Not Implemented"
+  end
+
+end

data/lib/Orders.rb

@@ -142,57 +142,26 @@ class Orders
   end
 
   def Orders.create(options={})
+    order = get_arg(options, :order_id)
+    if order == NIL
+      raise InvalidArguementError.new("ERROR: `order_id` is required parameter for Orders.create()")
+    end
+
     method = 'POST'
     url = '/order/create'
-    parameters = {}
-    required_args = {}
-    Array[:order_id,:amount].each do |key|
-      required_args.store(key,'False')
-    end
-    options.each do |key, value|
-      parameters.store(key,value)
-      required_args[key] = 'True'
-    end
-    Array[:order_id,:amount].each do |key|
-      if required_args[key] == 'False'
-        raise "ERROR: #{key} is a required argument for Orders.create"
-      end
-    end
-    parameters.each do |key, _|
-      unless @all_input_params.include?(key)
-        puts " #{key} is an invalid argument for Orders.create"
-      end
-    end
-    if parameters[:amount].class != Fixnum and parameters[:amount].class != Float
-      raise "ERROR: 'amount' should be of type Fixnum or FLoat"
-    end
     response = request(method,url,options)
     order = Order.new(response.body)
     return order
   end
 
-  def Orders.get_status(options={})
+  def Orders.status(options={})
+    order = get_arg(options, :order_id)
+    if order == NIL
+      raise InvalidArguementError.new("ERROR: `order_id` is required parameter for Orders.status()")
+    end
+
     method = 'GET'
     url = '/order/status'
-    parameters = {}
-    required_args = {}
-    Array[:order_id].each do |key|
-      required_args.store(key,'False')
-    end
-    options.each do |key, value|
-      parameters.store(key,value)
-      required_args[key] = 'True'
-    end
-    Array[:order_id].each do |key|
-      if required_args[key] == 'False'
-        raise "ERROR: #{key} is a required argument for Orders.get_status"
-      end
-    end
-    parameters.each do |key, _|
-      unless Array[:order_id].include?(key)
-        puts " #{key} is an invalid argument for Orders.get_status"
-      end
-    end
     response = request(method,url,options)
     order = Order.new(response.body)
     return order
@@ -201,142 +170,40 @@ class Orders
   def Orders.list(options={})
     method = 'GET'
     url = '/order/list'
-    parameters = {}
-    required_args = {}
-    Array[].each do |key|
-      required_args.store(key,'False')
-    end
-    options.each do |key, value|
-      parameters.store(key,value)
-      required_args[key] = 'True'
-    end
-    Array[].each do |key|
-      if required_args[key] == 'False'
-        raise "ERROR: #{key} is a required argument for Orders.list"
-      end
-    end
-    parameters.each do |key, _|
-      unless Array[:'created.gt', :'created.gt', :'created.lt', :'created.ge', :'created.le', :count, :offset].include?(key)
-        puts " #{key} is an invalid argument for Orders.get_status"
-      end
-    end
-    parameters.each do |key,_|
-      if key == :'created.gt'
-        if parameters[:'created.gt'].class != Fixnum
-          puts 'created.gt should be of type Numeric\n'
-        end
-      end
-      if key == :'created.lt'
-        if parameters[:'created.lt'].class != Fixnum
-          puts 'lt should be of type Numeric\n'
-        end
-      end
-      if key == :'created.ge'
-        if parameters[:'created.ge'].class != Fixnum
-          puts 'created.ge should be of type Numeric\n'
-        end
-      end
-      if key == :'created.le'
-        if parameters[:'created.le'].class != Fixnum
-          puts 'created.le should be of type Numeric\n'
-        end
-      end
-      if key == :count
-        if parameters[:count].class != Fixnum
-          puts 'count should be of type Numeric\n'
-        end
-      end
-      if key == :offset
-        if parameters[:offset].class != Fixnum
-          puts 'offset should be of type Numeric\n'
-        end
-      end
-    end
     response = request(method,url,options).body
     orders = {count: response['count'],total: response['total'], offset: response['offset'] }
     list = []
-    i=0
-    while i < response['count']
-      order = Order.new(response['list'][i])
+    order_list = Array(response['list'])
+    order_list.each do |orderData|
+      order = Order.new(orderData)
       list.push(order)
-      i+=1
     end
     orders[:list] = list
     return orders
   end
 
   def Orders.update(options={})
+    order = get_arg(options, :order_id)
+    if order == NIL
+      raise InvalidArguementError.new("ERROR: `order_id` is required parameter for Orders.update()")
+    end
+
     method = 'POST'
     url = '/order/create'
-    parameters = {}
-    required_args = {}
-    Array[:order_id].each do |key|
-      required_args.store(key,'False')
-    end
-    options.each do |key, value|
-      parameters.store(key,value)
-      required_args[key] = 'True'
-    end
-    Array[:order_id].each do |key|
-      if required_args[key] == 'False'
-        raise "ERROR: #{key} is a required argument for Orders.update"
-      end
-    end
-    parameters.each do |key, _|
-      unless @all_input_params.include?(key)
-        puts " #{key} is an invalid argument for Orders.create"
-      end
-    end
-    parameters.each do |key,_|
-      if key == :currency
-        puts 'currency cannot be changed\n'
-      end
-      if key == :customer_id
-        puts 'customer_id cannot be changed\n'
-      end
-      if key == :customer_email
-        puts 'customer_email cannot be changed\n'
-      end
-      if key == :customer_phone
-        puts 'customer_phone cannot be changed\n'
-      end
-      if key == :description
-        puts 'description cannot be changed\n'
-      end
-      if key == :product_id
-        puts 'product_id cannot be changed\n'
-      end
-      if key == :return_url
-        puts 'return_url cannot be changed\n'
-      end
-    end
     response = request(method,url,options)
     order = Order.new(response.body)
     return order
   end
 
   def Orders.refund(options={})
+    order = get_arg(options, :order_id)
+    unique_request = get_arg(options, :unique_request_id)
+    if order == NIL or unique_request == NIL
+      raise InvalidArguementError.new("ERROR: `order_id` & `unique_request_id` is required parameter for Orders.refund()")
+    end
+
     method = 'POST'
     url = '/order/refund'
-    parameters = {}
-    required_args = {}
-    Array[:unique_request_id,:order_id].each do |key|
-      required_args.store(key,'False')
-    end
-    options.each do |key, value|
-      parameters.store(key,value)
-      required_args[key] = 'True'
-    end
-    Array[:unique_request_id,:order_id].each do |key|
-      if required_args[key] == 'False'
-        raise "ERROR: #{key} is a required argument for Orders.refund"
-      end
-    end
-    parameters.each do |key, _|
-      unless Array[:unique_request_id,:order_id, :amount].include?(key)
-        puts " #{key} is an invalid argument for Orders.create"
-      end
-    end
     response = request(method,url,options)
     order = Order.new(response.body)
     return order

data/lib/Payments.rb

@@ -34,9 +34,12 @@ class Payments
   def Payments.create_card_payment(options={})
     method = 'POST'
     url = '/txns'
-    parameters = {}
+    parameters = {
+      :payment_method_type => "CARD",
+      :format => 'json'
+    }
     required_args = {}
-    Array[:order_id, :merchant_id, :payment_method_type, :card_token, :card_number, :name_on_card,
+    Array[:order_id, :merchant_id, :card_token, :payment_method_type, :card_number, :name_on_card,
           :card_exp_year, :card_exp_month, :card_security_code, :save_to_locker, :redirect_after_payment,
           :format].each do |key|
       required_args.store(key,'False')
@@ -45,11 +48,15 @@ class Payments
       parameters.store(key,value)
       required_args[key] = 'True'
     end
-    Array[:order_id, :merchant_id, :payment_method_type, :card_token, :card_number, :name_on_card,
-          :card_exp_year, :card_exp_month, :card_security_code, :save_to_locker, :redirect_after_payment,
-          :format].each do |key|
+    
+    # Either token or card number validation    
+    if required_args[:card_token] == 'False' and !([:card_number, :name_on_card, :card_exp_year,:card_exp_month, :card_security_code, :save_to_locker].all? {|s| options.key? s})
+        raise InvalidArguementError.new("ERROR: Either [card_token] or [card_number, name_on_card, card_exp_year, card_exp_month, card_security_code, save_to_locker] are required arguments for Payments.create_card_payment()")
+    end
+        
+    Array[:order_id, :merchant_id, :redirect_after_payment].each do |key|
       if required_args[key] == 'False'
-        raise "ERROR: #{key} is a required argument for Payments.create_card_payment"
+        raise InvalidArguementError.new("ERROR: #{key} is a required argument for Payments.create_card_payment")
       end
     end
     parameters.each do |key, _|
@@ -59,13 +66,14 @@ class Payments
         puts " #{key} is an invalid argument for Payments.create_card_payment"
       end
     end
-    if parameters[:save_to_locker] != true and parameters[:save_to_locker] != false
-      raise "ERROR: 'save_to_locker' should be true or false"
+    if required_args[:save_to_locker] == 'True' && parameters[:save_to_locker] != true and parameters[:save_to_locker] != false
+      raise InvalidArguementError.new("ERROR: 'save_to_locker' should be true or false")
     end
     if parameters[:redirect_after_payment] != true and parameters[:redirect_after_payment] != false
-      raise "ERROR: 'redirect_after_payment' should be true or false"
+      raise InvalidArguementError.new("ERROR: 'redirect_after_payment' should be true or false")
     end
-    response = request(method,url,options)
+
+    response = request(method,url,parameters)
     payment = Transaction.new(response.body)
     return payment
   end
@@ -73,18 +81,21 @@ class Payments
   def Payments.create_net_banking_payment(options={})
     method = 'POST'
     url = '/txns'
-    parameters = {}
+        parameters = {
+      :payment_method_type => "NB",
+      :format => 'json'
+    }
     required_args = {}
-    Array[:order_id, :merchant_id, :payment_method_type, :payment_method, :redirect_after_payment, :format].each do |key|
+    Array[:order_id, :merchant_id, :payment_method, :redirect_after_payment].each do |key|
       required_args.store(key,'False')
     end
     options.each do |key, value|
       parameters.store(key,value)
       required_args[key] = 'True'
     end
-    Array[:order_id, :merchant_id, :payment_method_type, :payment_method, :redirect_after_payment, :format].each do |key|
+    Array[:order_id, :merchant_id, :payment_method, :redirect_after_payment].each do |key|
       if required_args[key] == 'False'
-        raise "ERROR: #{key} is a required argument for Payments.create_net_banking_payment"
+        raise InvalidArguementError.new("ERROR: #{key} is a required argument for Payments.create_net_banking_payment")
       end
     end
     parameters.each do |key, _|
@@ -92,9 +103,41 @@ class Payments
         puts " #{key} is an invalid argument for Payments.create_net_banking_payment"
       end
     end
-    response = request(method,url,options)
+
+    response = request(method,url,parameters)
+    payment = Transaction.new(response.body)
+    return payment
+  end
+
+  def Payments.create_wallet_payment(options={})
+    method = 'POST'
+    url = '/txns'
+    parameters = {
+      :payment_method_type => "WALLET",
+      :format => 'json'
+    }
+    required_args = {}
+    Array[:order_id, :merchant_id, :payment_method, :redirect_after_payment].each do |key|
+      required_args.store(key,'False')
+    end
+    options.each do |key, value|
+      parameters.store(key,value)
+      required_args[key] = 'True'
+    end
+    Array[:order_id, :merchant_id, :payment_method, :redirect_after_payment].each do |key|
+      if required_args[key] == 'False'
+        raise InvalidArguementError.new("ERROR: #{key} is a required argument for Payments.create_wallet_payment")
+      end
+    end
+    parameters.each do |key, _|
+      unless Array[:order_id, :merchant_id, :payment_method_type, :payment_method, :redirect_after_payment, :format, :direct_wallet_token].include?(key)
+        puts " #{key} is an invalid argument for Payments.create_wallet_payment"
+      end
+    end
+
+    response = request(method,url,parameters)
     payment = Transaction.new(response.body)
     return payment
   end
 
-end
+end

data/lib/Test.rb

@@ -1,6 +1,8 @@
 require_relative 'Orders'
 require_relative 'Cards'
 require_relative 'Payments'
+require_relative 'Wallets'
+require_relative 'Customers'
 require 'minitest/autorun'
 require 'pp'
 
@@ -16,9 +18,8 @@ def pp(obj)
 end
 
 class Test < Minitest::Test
-
-  $api_key = '4168A8A476B84DBCAF409C24F379BAC5'
-  $environment = 'production'
+  $api_key = '187BF8D543A545789497F14FCAFBD85C'
+  $environment = 'staging'
 
   def setup
     @timestamp = Time.now.to_i
@@ -31,7 +32,7 @@ class Test < Minitest::Test
     #pp order
 
     # Test for get_status
-    status = Orders.get_status(order_id:@timestamp)
+    status = Orders.status(order_id:@timestamp)
     assert_equal(Float(status.order_id), @timestamp)
     #pp status
 
@@ -42,12 +43,13 @@ class Test < Minitest::Test
 
     # Test for update
     updated_order = Orders.update(order_id:@timestamp, amount:500)
-    status = Orders.get_status(order_id:@timestamp)
+    status = Orders.status(order_id:@timestamp)
     assert_equal(status.amount, updated_order.amount)
-    #pp updated_order
+  end
 
+  def test_refund
     # Test for refund
-    refunded_order = Orders.refund(unique_request_id: @timestamp, order_id: 1465833326,amount: 10)
+    refunded_order = Orders.refund(unique_request_id: @timestamp, order_id: '1471441349',amount: 1)
     #pp refunded_order
   end
 
@@ -61,7 +63,7 @@ class Test < Minitest::Test
   def test_cards
 
     # Test for add
-    card = Cards.add(merchant_id:'shreyas', customer_id:'user', customer_email:'abc@xyz.com',
+    card = Cards.create(merchant_id:'shreyas', customer_id:'user', customer_email:'abc@xyz.com',
         card_number:@timestamp*(10**6), card_exp_year:'20', card_exp_month:'12')
     refute_nil(card.reference)
     refute_nil(card.token)
@@ -73,9 +75,9 @@ class Test < Minitest::Test
     #pp deleted_card
     # Test for list
     #Test.delete_all_cards
-    Cards.add(merchant_id:'shreyas', customer_id:'user', customer_email:'abc@xyz.com',
+    Cards.create(merchant_id:'shreyas', customer_id:'user', customer_email:'abc@xyz.com',
         card_number:@timestamp * (10 ** 6), card_exp_year:'20', card_exp_month:'12')
-    Cards.add(merchant_id:'shreyas', customer_id:'user', customer_email:'abc@xyz.com',
+    Cards.create(merchant_id:'shreyas', customer_id:'user', customer_email:'abc@xyz.com',
         card_number:@timestamp * (10 ** 6)+1, card_exp_year:'20', card_exp_month:'12')
     card_list = Cards.list(customer_id:'user')
     refute_nil(card_list)
@@ -88,13 +90,10 @@ class Test < Minitest::Test
 
     # Test for create_card_payment
     payment = Payments.create_card_payment(
-        order_id:1465893617,
-        merchant_id:'juspay_recharge',
-        payment_method_type:'CARD',
-        card_token:'68d6b0c6-6e77-473f-a05c-b460ef983fd8',
+        order_id:1470043679,
+        merchant_id:'azhar',
         redirect_after_payment:false,
-        format:'json',
-        card_number:'5243681100075285',
+        card_number:'4242424242424242',
         name_on_card:'Customer',
         card_exp_year:'20',
         card_exp_month:'12',
@@ -102,18 +101,74 @@ class Test < Minitest::Test
         save_to_locker:false)
     refute_nil(payment.txn_id)
     assert_equal(payment.status, 'PENDING_VBV')
-    pp payment
+
     # Test for create_net_banking_payment
     payment = Payments.create_net_banking_payment(
-        order_id:1465893617,
-        merchant_id:'juspay_recharge',
-        payment_method_type:'NB',
-        payment_method:'NB_ICICI',
-        redirect_after_payment:false,
-        format:'json')
+        order_id:1470043679,
+        merchant_id:'azhar',
+        payment_method:'NB_DUMMY',
+        redirect_after_payment:false)
     refute_nil(payment.txn_id)
     assert_equal(payment.status, 'PENDING_VBV')
-    pp payment
+
+    # Test for create_wallet_payment
+    payment = Payments.create_wallet_payment(
+        order_id:'check5',
+        merchant_id:'azharamin',
+        payment_method:'MOBIKWIK',
+        redirect_after_payment:false)
+    refute_nil(payment.txn_id)
+    assert_match(/^(PENDING_VBV|CHARGED)$/,payment.status)
+  end
+
+  def test_customers
+    #Add customer
+    customer = Customers.create(
+        object_reference_id: "CustId#{@timestamp}",
+        mobile_number: '7272727272',
+        email_address: 'az@temp.com',
+        first_name: 'temp',
+        last_name: 'kumar',
+        mobile_country_code: '35'
+      )
+    refute_nil(customer)
+
+    #Get customer
+    customer = Customers.get(
+        customer_id: customer.id
+    )
+    refute_nil(customer)
+
+    #Update customer
+    customer = Customers.update(
+        customer_id: customer.id,
+        mobile_number: '7272727273',
+        email_address: 'newaz@temp.com',
+        first_name: 'newtemp',
+        last_name: 'newkumar',
+        mobile_country_code: '91'
+    )
+    refute_nil(customer)
+
+    #List customer
+    customer = Customers.list(
+        count: 1
+    )
+    assert_equal(customer['count'], 1)
+  end
+
+  def test_wallets
+    # List wallets by orderId
+    wallets = Wallets.list(order_id:'1471434419')
+    refute_nil(wallets[0].id)
+
+    # List wallets by customerId
+    wallets = Wallets.list(customer_id:'guest_user_101')
+    refute_nil(wallets[0].id)
+
+    # List wallets by customerId
+    wallets = Wallets.refresh_balance(customer_id:'guest_user_104')
+    refute_nil(wallets[0].id)
   end
 end
 

data/lib/Wallets.rb

@@ -0,0 +1,74 @@
+require_relative 'util'
+
+class Wallets
+
+  # noinspection ALL
+  class Wallet
+
+    attr_reader :id, :wallet, :object, :token, :current_balance, :last_refresh
+
+    def initialize(options = {})
+      @id = get_arg(options, 'id')
+      @object = get_arg(options, 'object')
+      @wallet = get_arg(options, 'wallet')
+      @token = get_arg(options, 'token')
+      @current_balance = get_arg(options, 'current_balance')
+      @last_refresh = get_arg(options, 'last_refreshed')
+    end
+
+  end
+
+  def Wallets.create(options={})
+    raise "ERROR: Not Implemented"
+  end
+
+  def Wallets.list(options={})
+    order = get_arg(options, :order_id)
+    customer = get_arg(options, :customer_id)
+
+    if customer == NIL and order == NIL
+      raise InvalidArguementError.new("ERROR: `customer_id` or `order_id` is required parameter for Wallets.list()")
+    end
+
+    if customer
+      url = "/customers/#{customer}/wallets"
+    else
+      url = "/orders/#{order}/wallets"
+    end
+
+    method = 'GET'
+    response = Array(request(method,url,{}).body['list'])
+    wallets = []
+    i=0
+    while i != response.count
+      wallet = Wallet.new(response[i])
+      wallets.push(wallet)
+      i+=1
+    end
+    return wallets
+  end
+
+  def Wallets.refresh_balance(options={})
+    customer = get_arg(options, :customer_id)
+
+    if customer == NIL
+      raise InvalidArguementError.new("ERROR: `customer_id` is required parameter for Wallets.refresh_balance()")
+    end
+
+    url = "/customers/#{customer}/wallets/refresh-balances"
+    method = 'GET'
+    response = Array(request(method,url,{}).body['list'])
+    wallets = []
+    i=0
+    while i != response.count
+      wallet = Wallet.new(response[i])
+      wallets.push(wallet)
+      i+=1
+    end
+    return wallets
+  end    
+
+  def Wallets.delete(options={})
+    raise "ERROR: Not Implemented"
+  end
+end

data/lib/errors/api_connection_error.rb

@@ -0,0 +1,2 @@
+ class APIConnectionError < JuspayError
+  end

data/lib/errors/api_error.rb

@@ -0,0 +1,3 @@
+class APIError < JuspayError
+end
+

data/lib/errors/authentication_error.rb

@@ -0,0 +1,3 @@
+class AuthenticationError < JuspayError
+end
+

data/lib/errors/invalid_arguement_error.rb

@@ -0,0 +1,7 @@
+class InvalidArguementError < JuspayError
+  def initialize(message=nil)
+    @_message = (message ? message : "ERROR: Please pass requiered parameters.")
+    super(@_message)
+  end
+end
+

data/lib/errors/invalid_request_error.rb

@@ -0,0 +1,3 @@
+class InvalidRequestError < JuspayError
+end
+

data/lib/errors/juspay_error.rb

@@ -0,0 +1,14 @@
+class JuspayError < StandardError
+  
+  def initialize(message=nil, http_status=nil, json_body=nil)
+    @_message = message
+    @http_status = http_status
+    @json_body = json_body
+  end
+
+  def to_s
+    status_string = @http_status.nil? ? '' : "(Status #{@http_status})\n"
+    json_string = @json_body.nil? ? '' : "(Response #{@json_body})\n"
+    "\n#{status_string}#{json_string}#{@_message}\n"
+  end
+end

data/lib/expresscheckout/version.rb

@@ -1,3 +1,3 @@
 module Expresscheckout
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/lib/expresscheckout.rb

@@ -1,12 +1,15 @@
 require "expresscheckout/version"
 
 module Expresscheckout
-	require 'unirest'
 	require_relative 'Orders'
 	require_relative 'Cards'
 	require_relative 'Payments'
+	require_relative 'Customers'
+	require_relative 'Wallets'
 
-	$api_key = ''
-	$environment = 'production'
+	$api_key = nil
+	$environment = 'staging'
 	$version= {:JuspayAPILibrary=>'Ruby v1.0'}
 end
+
+require 'unirest'

data/lib/util.rb

@@ -1,19 +1,43 @@
 require_relative 'expresscheckout'
+# Errors
+require 'errors/juspay_error'
+require 'errors/api_error'
+require 'errors/api_connection_error'
+require 'errors/invalid_request_error'
+require 'errors/authentication_error'
+require 'errors/invalid_arguement_error'
 
-def request(method,url,parameters={})
-  if $environment == 'production'
-    $server = 'https://api.juspay.in'
-  elsif $environment == 'staging'
-    $server = 'https://sandbox.juspay.in'
-  else
-    raise 'ERROR: environment variable can be "production" or "staging"'
-  end
-  if method == 'GET'
-    response = Unirest.get $server+url, headers: $version, auth:{:user=>$api_key, :password=>''}, parameters: parameters
-  else
-    response = Unirest.post $server +url, headers: $version, auth:{:user=>$api_key, :password=>''}, parameters: parameters
+def request(method, url, parameters={})
+  begin
+    if $environment == 'production'
+      $server = 'https://api.juspay.in'
+    elsif $environment == 'staging'
+      $server = 'https://sandbox.juspay.in'
+    else
+      raise InvalidArguementError.new('ERROR: environment variable can be "production" or "staging"')
+    end
+    if $api_key == nil
+      raise AuthenticationError.new("ERROR: API key missing. Please specify api_key.")
+    end
+    if method == 'GET'
+      response = Unirest.get $server+url, headers: $version, auth: {:user => $api_key, :password => ''}, parameters: parameters
+    else
+      response = Unirest.post $server +url, headers: $version, auth: {:user => $api_key, :password => ''}, parameters: parameters
+    end
+    if (response.code >= 200 && response.code < 300)
+      return response
+    elsif ([400, 404].include? response.code)
+      raise InvalidRequestError.new('Invalid Request', response.code, response.body)
+    elsif (response.code == 401)
+      raise AuthenticationError.new('Unauthenticated Request', response.code, response.body)
+    else
+      raise APIError.new('Invalid Request', response.code, response.body)
+    end
+  rescue IOError
+    raise APIConnectionError.new('Connection error')
+  rescue SocketError
+    raise APIConnectionError.new('Socket error. Failed to connect.')
   end
-  response
 end
 
 def get_arg(options = {}, param)
@@ -27,10 +51,10 @@ def get_arg(options = {}, param)
 end
 
 def check_param(options = {}, param)
-  options.each do |key,_|
+  options.each do |key, _|
     if key.include?(param)
       return true
     end
   end
   false
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expresscheckout
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Juspay
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-14 00:00:00.000000000 Z
+date: 2016-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,14 +65,24 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
+- RELEASE.md
 - Rakefile
 - bin/console
 - bin/setup
+- example.rb
 - expresscheckout.gemspec
 - lib/Cards.rb
+- lib/Customers.rb
 - lib/Orders.rb
 - lib/Payments.rb
 - lib/Test.rb
+- lib/Wallets.rb
+- lib/errors/api_connection_error.rb
+- lib/errors/api_error.rb
+- lib/errors/authentication_error.rb
+- lib/errors/invalid_arguement_error.rb
+- lib/errors/invalid_request_error.rb
+- lib/errors/juspay_error.rb
 - lib/expresscheckout.rb
 - lib/expresscheckout/version.rb
 - lib/util.rb
@@ -91,6 +101,8 @@ require_paths:
 - lib/Cards.rb
 - lib/Test.rb
 - lib/util.rb
+- lib/Customers.rb
+- lib/Wallets.rb
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="