t2_airtime 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f76c758dc19f0a18801723bce129f79b3901ef2
-  data.tar.gz: 939e2277d01c62ef4d24ca7f772305352e0569c5
+  metadata.gz: e8417b02b8f2234aeb4bd95b977e84d41a1aa7f3
+  data.tar.gz: a9ad3262412847aa81343d5cd1a027e165657515
 SHA512:
-  metadata.gz: 7d734a1bd8ac1b49d86311205f4d4be15b0c3728de5132a440f6816010f529ef413cabf0dbfec74fb07adfd4effd8908cf568234499fe36e7820b43394f17d9f
-  data.tar.gz: 2f0f8aa5be119dda169c520b01c54cea00804c452f0d612c53f28fdffb90d280c330cd908984960149e633e3d6aefb69772af8970e1cbb244366302529169710
+  metadata.gz: 377d4ad5ea8676514dcf8e9e4024b76fd5a53e5ca6ec7c5b7f492caebc7052733e2cf511af3fad0661ce9936cb936b1c084b6c2ece6eb884cea650e7210f5610
+  data.tar.gz: 3f4ff3db7be4902a83e7e7e77dd90e365be2c370e1e5ef028f85219887583d034f6576c7cdeb23c0331d498466c134c4c26986db4633b2aa9c5b193b2bb70380

data/lib/t2_airtime/api.rb

@@ -252,11 +252,6 @@ module T2Airtime
     # @operator_aid the airtime id of the operator    
     def product_list(operator_aid) price_list('operator', operator_aid) end 
 
-    # Operator Logo URL
-    def operator_logo_url(operator_aid, size=1)
-      "#{T2Airtime::PROTOCOL}://#{T2Airtime::OPLOGO_DN}.#{T2Airtime::DOMAIN}/logo-#{operator_aid}-#{size}.png"    
-    end     
-
     private
 
     def oid=(operator_aid)

data/lib/t2_airtime/request.rb

@@ -26,21 +26,13 @@ module T2Airtime
       add_param :login, @user
     end
 
-    def add_param(key, value)
-      @params[key.to_sym] = value
-    end
+    def add_param(key, value) @params[key.to_sym] = value end
 
-    def key
-      @params[:key]
-    end
+    def key() @params[:key] end
 
-    def get?
-      @params[:method] == :get
-    end
+    def get?() @params[:method] == :get end
 
-    def post?
-      @params[:method] == :post
-    end
+    def post?() @params[:method] == :post end
 
     # More than 99.5% of the transactions are currently processed within a few seconds. 
     # However, it may happen in some rare cases that a transaction takes longer to be processed by the receiving

data/lib/t2_airtime/serializer.rb

@@ -0,0 +1,201 @@
+module T2Airtime
+
+  class Account
+
+    def self.info
+        reply = T2Airtime::API.api.check_wallet
+        reply.success? ? serialize(reply.data) : {}
+    end
+
+    def self.serialize(data)
+      {
+        type: data[:type],
+        name: data[:name],
+        currency: data[:currency],
+        balance: Float(data[:balance]),
+        wallet: Float(data[:wallet]),
+        balance_display: T2Airtime::Util.format_price(data[:balance], data[:currency]),
+        wallet_display: T2Airtime::Util.format_price(data[:wallet], data[:currency]),
+      }
+    end
+
+  end  
+
+  class Country
+
+    def self.take(qty=5)
+        reply = T2Airtime::API.api.country_list
+        reply.success? ? serialize(reply.data, qty) : []
+    end
+
+    def self.serialize(data, qty=nil)
+        names = data[:country].split(",") 
+        ids = data[:countryid].split(",")
+        ids.take(qty.nil? ? ids.count : qty).each_with_index.map{|id, n| {
+          name: names[n], 
+          alpha3: alpha3(names[n]),
+          aid: Integer(id)
+        }}
+    end
+
+    def self.normalize(name)
+       name.starts_with?("St") ? name.gsub("St", "Saint") : name
+    end
+
+    def self.alpha3(name)
+      alpha3 = ISO3166::Country.find_country_by_name(name).try(:alpha3)
+      unless alpha3           
+        alpha3 = case name
+        when 'Saint Vincent Grenadines'
+          'VCT';
+        when 'Kosovo'
+          'UNK'
+        when 'Netherlands Antilles'
+          'ANT'
+        when 'Serbia and Montenegro'
+          'SCG'
+        end        
+        register_alpha3(alpha3, name) if %w(VCT UNK ANT SCG).include?(alpha3)
+      end
+      alpha3 || "XXX"
+    end  
+
+    def self.register_alpha3(alpha3, name)
+        ISO3166::Data.register(
+          alpha2: 'XX',
+          alpha3: alpha3,
+          name: name
+        ) 
+    end
+
+  end
+
+  class Operator
+
+    def self.take(country_qty=1, qty=5)
+        countries = T2Airtime::Country.take(country_qty).shuffle
+        unless countries.empty?
+          countries.flat_map{|country| (
+            reply = T2Airtime::API.api.operator_list(country[:aid])
+            reply.success? ? serialize(reply.data, qty) : []
+          )}        
+        end
+    end    
+
+    def self.serialize(data, qty=nil)
+         names = data[:operator].split(",") 
+         ids = data[:operatorid].split(",")
+         ids.take(qty.nil? ? ids.count : qty).each_with_index.map{|id, n| {
+           country: data[:country], 
+           country_aid: Integer(data[:countryid]),
+           alpha3: T2Airtime::Country.alpha3(data[:country]),
+           name: names[n], 
+           logo_url: T2Airtime::Util.operator_logo_url(id),
+           aid: Integer(id)
+         }}
+    end
+    
+  end
+
+  class Product
+
+    def self.take(operator_qty=1, qty=5)
+        operators = T2Airtime::Operator.take(operator_qty).shuffle
+        unless operators.empty?
+          operators.flat_map{|operator| (
+            reply = T2Airtime::API.api.product_list(operator[:aid])
+            reply.success? ? serialize(reply.data, qty) : []
+          )}        
+        end         
+    end
+
+    def self.serialize(data, qty=nil)
+         currency = data[:destination_currency]
+         retail_prices = data[:retail_price_list].split(",") 
+         wholesale_prices = data[:wholesale_price_list].split(",")
+         ids = data[:product_list].split(",")
+         ids.take(qty.nil? ? ids.count : qty).each_with_index.map{|id, n| {
+           country: data[:country], 
+           country_aid: Integer(data[:countryid]),
+           alpha3: T2Airtime::Country.alpha3(data[:country]),
+           operator: data[:operator], 
+           operator_aid: Integer(data[:operatorid]),  
+           operator_logo_url: T2Airtime::Util.operator_logo_url(data[:operatorid]),         
+           name: "#{id}#{currency}", 
+           currency: currency,
+           local_price: Float(id),
+           retail_price: Float(retail_prices[n]),
+           wholesale_price: Float(wholesale_prices[n]),           
+           local_price_display: T2Airtime::Util.format_price(id, currency),
+           retail_price_display: T2Airtime::Util.format_price(retail_prices[n]),
+           wholesale_price_display: T2Airtime::Util.format_price(wholesale_prices[n]),
+           aid: Integer(id)
+         }}
+    end
+
+  end  
+
+  class Transaction
+
+    def self.take(start=(Time.now-24.hours), stop=Time.now, msisdn=nil, destination=nil, code=nil, qty=5)
+        reply = T2Airtime::API.api.trans_list(start, stop, msisdn, destination, code)
+        reply.success? ? serialize(reply.data, qty) : []
+    end
+      
+    def self.serialize(data, qty=nil)
+      ids = data[:transaction_list].split(",")
+      ids.empty? ? {} : ids.take(qty.nil? ? ids.count : qty).each.map{ |id| show(id) }
+    end
+
+
+    def self.show(id)
+        reply = T2Airtime::API.api.trans_info(id)
+        reply.success? ? serialize_one(reply.data) : {}
+    end
+
+    def self.serialize_one(t)
+      {
+        id: Integer(t[:transactionid]),
+        msisdn: t[:msisdn],
+        destination_msisdn: t[:destination_msisdn],
+        transaction_authentication_key: t[:transaction_authentication_key],
+        transaction_error_code: Integer(t[:transaction_error_code]),
+        transaction_error_txt: t[:transaction_error_txt],
+        country: t[:country],
+        country_aid: Integer(t[:countryid]),
+        alpha3: T2Airtime::Country.alpha3(t[:country]),
+        operator: t[:operator],
+        operator_aid: Integer(t[:operatorid]),
+        operator_logo_url: T2Airtime::Util.operator_logo_url(t[:operatorid]),  
+        reference_operator: t[:reference_operator],
+        product_requested: t[:product_requested],
+        product_requested_display: T2Airtime::Util.format_price(t[:product_requested], t[:destination_currency]),
+        actual_product_sent: t[:actual_product_sent],
+        actual_product_sent_display: T2Airtime::Util.format_price(t[:actual_product_sent], t[:destination_currency]),
+        wholesale_price: t[:wholesale_price],
+        wholesale_price_display: T2Airtime::Util.format_price(t[:wholesale_price], t[:originating_currency]),
+        retail_price: t[:retail_price],
+        retail_price_display: T2Airtime::Util.format_price(t[:retail_price], t[:originating_currency]),
+        sms: t[:sms],
+        cid1: t[:cid1],
+        cid2: t[:cid2],
+        cid3: t[:cid3],
+        date: t[:date],
+        originating_currency: t[:originating_currency],
+        destination_currency: t[:destination_currency],
+        pin_based: t[:pin_based],
+        local_info_amount: t[:local_info_amount],
+        local_info_amount_display: T2Airtime::Util.format_price(t[:local_info_amount], t[:local_info_currency]),
+        local_info_currency: t[:local_info_currency],
+        local_info_value: t[:local_info_value],
+        local_info_value_display: T2Airtime::Util.format_price(t[:local_info_value], t[:local_info_currency]),
+        error_code: t[:error_code],
+        error_txt: t[:error_txt]
+      }
+    end
+
+
+  end
+
+  
+end

data/lib/t2_airtime/{test.rb → util.rb}

@@ -1,5 +1,5 @@
 module T2Airtime
-  class Test
+  class Util
 
     # A few fake phone numbers in Indonesia have been created and set up with available products of IDR 5000, 10000, 20000, 50000 and 100000:  
     # 628123456710: error code 0 for PIN based Top-up (successful transaction).
@@ -10,12 +10,21 @@ module T2Airtime
     # 628123456798: error code 998 (system not available, please retry later).
     # 628123456799: error code 999 (unknown error, please contact support).
 
-    def self.numbers(num=0)
+    def self.test_numbers(num=0)
       numbers = [ "628123456710", "628123456770", "628123456780",
                   "628123456781", "628123456790", "628123456798",
                   "628123456799" ]
       num > 0 && num < 8 ? numbers[num-1] : numbers
     end 
 
+    def self.format_price(price, currency=ENV['T2_CURRENCY'])
+      Money.new(Float(price)*100, currency).format
+    end  
+
+    # Operator Logo URL
+    def self.operator_logo_url(operator_aid, size=1)
+      "https://#{T2Airtime::OPLOGO_DN}.#{T2Airtime::DOMAIN}/logo-#{operator_aid}-#{size}.png"    
+    end         
+
   end
 end

data/lib/t2_airtime/version.rb

@@ -1,3 +1,3 @@
 module T2Airtime
-  VERSION = "0.1.3"
+  VERSION = "0.1.5"
 end

data/lib/t2_airtime.rb

@@ -2,6 +2,8 @@ require 'dotenv'
 Dotenv.load
 require "faraday"
 require "net/http"
+require "countries"
+require "money"
 
 require "t2_airtime/version"
 require "t2_airtime/url"
@@ -10,7 +12,7 @@ require "t2_airtime/request"
 require "t2_airtime/reply"
 require "t2_airtime/base"
 require "t2_airtime/api"
-require "t2_airtime/test"
-require "t2_airtime/rest"
+require "t2_airtime/util"
+require "t2_airtime/serializer"
 
 module T2Airtime; end

data/t2_airtime.gemspec

@@ -27,5 +27,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'dotenv-rails', '~> 2.2', '>= 2.2.1'
   spec.add_dependency "faraday", "0.9.1"
+  spec.add_dependency "countries", "2.1.2"
+  spec.add_dependency "money", "6.9.0"
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: t2_airtime
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - matteolc
@@ -86,6 +86,34 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: countries
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: money
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 6.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 6.9.0
 description: Wrapper methods to interface with [TransferTo](https://www.transfer-to.com/home)
   Airtime API
 email:
@@ -108,9 +136,9 @@ files:
 - lib/t2_airtime/errors.rb
 - lib/t2_airtime/reply.rb
 - lib/t2_airtime/request.rb
-- lib/t2_airtime/rest.rb
-- lib/t2_airtime/test.rb
+- lib/t2_airtime/serializer.rb
 - lib/t2_airtime/url.rb
+- lib/t2_airtime/util.rb
 - lib/t2_airtime/version.rb
 - t2_airtime.gemspec
 homepage: https://github.com/matteolc/t2_airtime

data/lib/t2_airtime/rest.rb

@@ -1,78 +0,0 @@
-module T2Airtime
-
-  class Country
-
-    def self.all
-        reply = T2Airtime::API.api.country_list
-        reply.success? ? serialize_reply(reply.data) : []
-    end
-
-    def self.serialize_reply(data)
-        names = data[:country].split(",") 
-        ids = data[:countryid].split(",")
-        ids.each_with_index.map{|id, n| {
-          name: names[n], 
-          aid: Integer(id)
-        }}
-    end
-    
-  end
-
-  class Operator
-
-    def self.all
-        countries = T2Airtime::Country.all
-        unless countries.empty?
-          countries.flat_map{|country| (
-            reply = T2Airtime::API.api.operator_list(country[:aid])
-            reply.success? ? serialize_reply(reply.data) : []
-          )}        
-        end
-    end
-
-    def self.serialize_reply(data)
-         names = data[:operator].split(",") 
-         ids = data[:operatorid].split(",")
-         ids.each_with_index.map{|id, n| {
-           country: data[:country], 
-           country_aid: Integer(data[:countryid]),
-           name: names[n], 
-           aid: Integer(id)
-         }}
-    end
-    
-  end
-
-  class Product
-
-    def self.all
-        operators = T2Airtime::Operator.all
-        unless operators.empty?
-          operators.flat_map{|operator| (
-            reply = T2Airtime::API.api.product_list(operator[:aid])
-            reply.success? ? serialize_reply(reply.data) : []
-          )}        
-        end         
-    end
-
-    def self.serialize_reply(data)
-         currency = data[:destination_currency]
-         retail_prices = data[:retail_price_list].split(",") 
-         wholesale_prices = data[:wholesale_price_list].split(",")
-         ids = data[:product_list].split(",")
-         ids.each_with_index.map{|id, n| {
-           country: data[:country], 
-           country_aid: Integer(data[:countryid]),
-           operator: data[:operator], 
-           operator_aid: Integer(data[:operatorid]),           
-           name: "#{id}#{currency}", 
-           currency: currency,
-           retail_price: retail_prices[n],
-           wholesale_price: wholesale_prices[n],
-           aid: Integer(id)
-         }}
-    end
-    
-  end  
-  
-end