t2_airtime 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40184e3caa2b4c0f270c5a7942213d4d767c4fc5
-  data.tar.gz: 1a93efdccc04226c874954fa3f95010cb4e40bae
+  metadata.gz: 326cdd5b38f8d1c9749d76ba60268f5d5d7c98d1
+  data.tar.gz: '07913bae3db4c8571829ac372aac6a4112472023'
 SHA512:
-  metadata.gz: d07b06bf1606067eb0385cace5dbc01d826c7516ea25a63c4f87463a54c57cbc2cd6434afef9882569ff1852968ee376c2e3b108f00103085bdd02742cf840be
-  data.tar.gz: b38610435a2bcb450b3fa805f77d47ec7927c802a97fadf9419ccf065320fe2a721828006143f8262965818de36f968ea9b40aad75b28a41bc66c05202a93679
+  metadata.gz: 28c3c4f9055cbd006ff05b2bd629e874d93162859e25ab7180a463a61aa68028aad04e7d9bcad5da4038f8544bae6b06ebec7e2d6951006b5b617a601161853e
+  data.tar.gz: f64ba5dd35a5e8d7ba427526ccc732c5c6049fe9a979bdee67b4e0311b02983eb0bbaef0f6c5caa5cbca09840b79b414dab0b9cef154dc23e8285c18447cf3b6

data/app/controllers/t2_airtime/topups_controller.rb

@@ -0,0 +1,66 @@
+module T2Airtime
+    # Help with topup
+    class TopupsController < ApplicationController
+      def msisdn_info
+        @msisdn_info = T2Airtime::Msisdn.info permitted_params[:destination_number]
+        if @msisdn_info.success?
+          render_data T2Airtime::Msisdn.serialize @msisdn_info.data,
+                                                  @msisdn_info.headers[:date]
+        else 
+          render_error T2Airtime::Error.new @msisdn_info.error_code,
+                                            @msisdn_info.error_message
+        end
+      end
+
+      def reserve_id
+        @reserve_id = T2Airtime::API.api.reserve_id
+        if @reserve_id.success?
+          render_data @reserve_id.data
+        else
+          render_error T2Airtime::Error.new @reserve_id.error_code,
+                                            @reserve_id.error_message
+        end
+      end      
+
+      def topup
+        @topup = T2Airtime::API.api.topup permitted_params[:msisdn],
+                                          permitted_params[:destination_number],
+                                          permitted_params[:product],
+                                          permitted_params[:method],
+                                          permitted_params[:reserved_id],
+                                          permitted_params[:send_sms],
+                                          permitted_params[:sms],
+                                          permitted_params[:sender_text],
+                                          permitted_params[:cid1],
+                                          permitted_params[:cid2],
+                                          permitted_params[:cid3]
+
+        if @topup.success?
+          render_data T2Airtime::Topup.serialize @topup.data
+        else
+          render_error T2Airtime::Error.new @topup.error_code,
+                                            @topup.error_message
+        end
+      end      
+    
+      private
+    
+  
+      def permitted_params
+        params.permit(
+            :msisdn,        
+            :destination_number,
+            :product,
+            :method,
+            :reserved_id,
+            :send_sms,
+            :sms,
+            :sender_text,
+            :cid1,
+            :cid2,
+            :cid3
+        )
+      end
+    end
+  end
+  

data/app/controllers/t2_airtime/transactions_controller.rb

@@ -16,7 +16,7 @@ module T2Airtime
     end
 
     def show
-      @transaction = T2Airtime::API.api.transaction_info(params[:id])
+      @transaction = T2Airtime::Transaction.get(params[:id])
       if @transaction.success?
         render_data T2Airtime::Transaction.serialize_one @transaction.data,
                                                          @transaction.headers[:date]

data/config/routes.rb

@@ -4,4 +4,7 @@ T2Airtime::Engine.routes.draw do
   resources :operators, only: %i[index show]
   resources :products, only: [:index]
   resources :transactions, only: %i[index show]
+  get "msisdn_info", to: "topups#msisdn_info"
+  get "reserve_id", to: "topups#reserve_id"
+  post "topup", to: "topups#topup"
 end

data/lib/t2_airtime/api.rb

@@ -75,7 +75,9 @@ module T2Airtime
     # “sms” of the topup method.
 
     def topup(msisdn, destination_msisdn, product, method = 'topup',
-              reserved_id = nil, send_sms = true, sms = nil, sender_text = nil, operator_id = nil,
+              reserved_id = nil, send_sms = true, sms = nil, sender_text = nil,
+              cid1 = '', cid2 = '', cid3 = '',
+              operator_id = nil,
               return_service_fee = 1, delivered_amount_info = 1, return_timestamp = 1, return_version = 1,
               return_promo = 0)
 
@@ -86,7 +88,7 @@ module T2Airtime
       }
       self.oid = operator_id
 
-      @params.merge(cid1: '', cid2: '', cid3: '',
+      @params.merge(cid1: cid1, cid2: cid2, cid3: cid3,
                     reserved_id: reserved_id,
                     sender_sms: (sender_text ? 'yes' : 'no'),
                     send_sms: (send_sms ? 'yes' : 'no'),
@@ -99,26 +101,6 @@ module T2Airtime
                     return_promo: return_promo)
 
       run_action method
-      # {
-      #  requesting_msisdn:         response[:msisdn],
-      #  destination_msisdn:        response[:destination_msisdn],
-      #  product_sent:              response[:actual_product_sent].to_i,
-      #  local_amount:              response[:local_info_amount],
-      #  local_value:               response[:local_info_value],
-      #  local_currency_code:       response[:local_info_currency],
-      #  transaction_status:        response[:error_txt],
-      #  operation_result:          response[:error_code],
-      #  operation_info:            response[:info_txt],
-      #  transaction_api_id:        response[:transactionid].to_i,
-      #  country_api_id:            response[:countryid].to_i,
-      #  operator_api_id:           response[:operatorid].to_i,
-      #  product_api_id:            response[:product_requested].to_i,
-      #  originator_currency_code:  response[:originating_currency],
-      #  destination_currency_code: response[:destination_currency],
-      #  wholesale_price:           response[:wholesale_price],
-      #  retail_price:              response[:retail_price],
-      #  service_fee:               response[:service_fee]
-      # }
     end
 
     # This method is used to retrieve various information of a specific MSISDN
@@ -194,11 +176,13 @@ module T2Airtime
     # ---------
     # Defines the end date of the search (included). Format must be YYYY-MM-DD.
     def transaction_list(start = (Time.now - 24.hours), stop = Time.now, msisdn = nil, destination = nil, code = nil)
-      @params[:code]               = code unless code
-      @params[:msisdn]             = msisdn unless msisdn
-      @params[:stop_date]          = to_yyyymmdd(stop)
-      @params[:start_date]         = to_yyyymmdd(start)
-      @params[:destination_msisdn] = destination unless destination
+      @params = {
+        stop_date: to_yyyymmdd(stop),
+        start_date: to_yyyymmdd(start)
+      }     
+      code && !code.empty? && @params[:code] = code
+      msisdn && !msisdn.empty? && @params[:msisdn] = msisdn
+      destination && !destination.empty? && @params[:destination_msisdn] = destination    
       run_action :trans_list
     end
 

data/lib/t2_airtime/serializer.rb

@@ -1,4 +1,69 @@
 module T2Airtime
+
+  class Topup
+
+    def self.serialize(data, ts = Time.zone.now.to_s)
+      {
+        type: 'topup',
+        balance: data[:balance],
+        balanceDisplay: "#{Money.new(Integer(data[:balance]) * 100, Account.currency).format}",
+        msisdn: data[:destination_msisdn],
+        destinationMsisdn: data[:destination_msisdn],
+        transactionId: data[:transactionid],
+        transactionAuthenticationKey: data[:authentication_key],
+        transactionErrorCode: Integer(data[:error_code]),
+        transactionErrorTxt: data[:error_txt],
+        referenceOperator: data[:reference_operator],
+        actualProductSent: data[:actual_product_sent],
+        sms: data[:sms],
+        smsSent: data[:sms_sent],
+        cid1: data[:cid1],
+        cid2: data[:cid2],
+        cid3: data[:cid3],
+        currency: data[:originating_currency],
+        localCurrency: data[:destination_currency],
+        countryId: Integer(data[:countryid]), 
+        countryName: data[:country],
+        operatorId: Integer(data[:operatorid]),
+        operatorName: data[:operator],
+        operatorLogo: T2Airtime::Util.operator_logo_url(data[:operatorid]),  
+        productName: "#{Money.new(Integer(data[:product_requested]) * 100, data[:destination_currency]).format}",
+        productLocalCurrency: data[:destination_currency],
+        productLocalCurrencySymbol: Money::Currency.new(data[:destination_currency]).symbol,
+        productCurrency: Account.currency,
+        productCurrencySymbol: Money::Currency.new(Account.currency).symbol,
+        productLocalPrice: Float(data[:product_requested]),
+        productRetailPrice: Float(data[:retail_price]),
+        productWholesalePrice: Float(data[:wholesale_price]),  
+        executedAt: T2Airtime::Util.format_time(ts)
+      }
+    end
+
+  end
+
+
+  class Msisdn
+
+    def self.info(msisdn)
+      Rails.cache.fetch("msisdn/#{msisdn}", expires_in: 24.hours) do # cache the result for 1 day
+        T2Airtime::API.api.msisdn_info(msisdn)
+      end
+    end
+
+    def self.serialize(data, ts = Time.zone.now.to_s)
+      {
+        type: 'msisdn',
+        msisdn: data[:destination_msisdn],
+        country: data[:country],
+        countryId: data[:countryid],
+        operator: data[:operator],
+        operatorId: data[:operatorid],
+        fetchedAt: T2Airtime::Util.format_time(ts)
+      }
+    end
+
+  end
+
   class Account
     def self.get
       Rails.cache.fetch('accounts', expires_in: 1.hour) do
@@ -7,8 +72,9 @@ module T2Airtime
     end
 
     def self.currency
-      Rails.cache.fetch('accounts/currency', expires_in: 24.hours) do        
-        serialize(get.data)["attributes"]["currency"]
+      account = serialize(get.data)
+      Rails.cache.fetch('accounts/currency', expires_in: 24.hours) do # cache the result for 1 day        
+        account[:attributes][:currency]
       end      
     end
 
@@ -56,6 +122,7 @@ module T2Airtime
             attributes: {
               name: names[n],
               alpha3: alpha3(names[n]),
+              callingCode: calling_code(alpha3(names[n])),
               fetchedAt: T2Airtime::Util.format_time(ts)
             }
           }
@@ -92,6 +159,17 @@ module T2Airtime
         name: name
       )
     end
+
+    def self.calling_code(alpha3)  
+      country_code = case alpha3
+          when 'PCN'
+            '64'
+          when 'ATF'
+            '262'            
+      end
+      country_code || ISO3166::Country.find_country_by_alpha3(alpha3).try(:country_code)       
+    end
+
   end
 
   class Operator
@@ -153,9 +231,7 @@ module T2Airtime
     def self.take(operator_qty = 1, qty = 5)
       operators = T2Airtime::Operator.take(operator_qty).shuffle
       unless operators.empty?
-        operators.flat_map do |operator| (
-
-          
+        operators.flat_map do |operator| (          
           products = all(operator['id'])
           products.success? ? serialize(products.data, products.headers[:date], qty) : []
         )
@@ -222,73 +298,81 @@ module T2Airtime
       ids.take(qty.nil? ? ids.count : qty).each.map { |id| show(id) }
     end
 
+    def self.get(id)
+      Rails.cache.fetch("transactions/#{id}", expires_in: 365.days) do # once we've got it, no need to refetch
+        T2Airtime::API.api.transaction_info(id)
+      end
+    end    
+
     def self.show(id)
-      reply = T2Airtime::API.api.transaction_info(id)
-      reply.success? ? serialize_one(reply.data, reply.headers[:date]) : {}
+      transaction = get(id)
+      transaction.success? ? serialize_one(transaction.data, transaction.headers[:date]) : {}
     end
 
     def self.serialize_one(data, ts = Time.zone.now.to_s)
-      {
-        type: 'transactions',
-        id: Integer(data[:transactionid]),
-        attributes: {
-          msisdn: data[:msisdn],
-          destinationMsisdn: data[:destination_msisdn],
-          transactionAuthenticationKey: data[:transaction_authentication_key],
-          transactionErrorCode: Integer(data[:transaction_error_code]),
-          transactionErrorTxt: data[:transaction_error_txt],
-          referenceOperator: data[:reference_operator],
-          actualProductSent: data[:actual_product_sent],
-          sms: data[:sms],
-          cid1: data[:cid1],
-          cid2: data[:cid2],
-          cid3: data[:cid3],
-          date: data[:date],
-          currency: data[:originating_currency],
-          localCurrency: data[:destination_currency],
-          pinBased: data[:pin_based],
-          localInfoAmount: data[:local_info_amount],
-          localInfoCurrency: data[:local_info_currency],
-          localInfoValue: data[:local_info_value],
-          errorCode: data[:error_code],
-          errorTxt: data[:error_txt],
-          countryId: Integer(data[:countryid]), 
-          countryName: data[:country],
-          countryAlpha3: T2Airtime::Country.alpha3(data[:country]),
-          operatorId: Integer(data[:operatorid]),
-          operatorName: data[:operator],
-          operatorLogo: T2Airtime::Util.operator_logo_url(data[:operatorid]),  
-          productName: "#{Money.new(Integer(data[:product_requested]) * 100, data[:destination_currency]).format}",
-          productLocalCurrency: data[:destination_currency],
-          productLocalCurrencySymbol: Money::Currency.new(data[:destination_currency]).symbol,
-          productCurrency: Account.currency,
-          productCurrencySymbol: Money::Currency.new(Account.currency).symbol,
-          productLocalPrice: Float(data[:product_requested]),
-          productRetailPrice: Float(data[:retail_price]),
-          productWholesalePrice: Float(data[:wholesale_price]),          
-          fetchedAt: T2Airtime::Util.format_time(ts)
-        },
-        relationships: {
-          country: {
-            data: {
-              type: 'countries',
-              id: Integer(data[:countryid])
-            }
-          },
-          operator: {
-            data: {
-              type: 'operators',
-              id: Integer(data[:operatorid])
-            }
+      Rails.cache.fetch("transactions/#{data[:transactionid]}/serializer", expires_in: 365.hour) do
+        {
+          type: 'transactions',
+          id: Integer(data[:transactionid]),
+          attributes: {
+            msisdn: data[:msisdn],
+            destinationMsisdn: data[:destination_msisdn],
+            transactionAuthenticationKey: data[:transaction_authentication_key],
+            transactionErrorCode: Integer(data[:transaction_error_code]),
+            transactionErrorTxt: data[:transaction_error_txt],
+            referenceOperator: data[:reference_operator],
+            actualProductSent: data[:actual_product_sent],
+            sms: data[:sms],
+            cid1: data[:cid1],
+            cid2: data[:cid2],
+            cid3: data[:cid3],
+            date: data[:date],
+            currency: data[:originating_currency],
+            localCurrency: data[:destination_currency],
+            pinBased: data[:pin_based],
+            localInfoAmount: data[:local_info_amount],
+            localInfoCurrency: data[:local_info_currency],
+            localInfoValue: data[:local_info_value],
+            errorCode: data[:error_code],
+            errorTxt: data[:error_txt],
+            countryId: Integer(data[:countryid]), 
+            countryName: data[:country],
+            countryAlpha3: T2Airtime::Country.alpha3(data[:country]),
+            operatorId: Integer(data[:operatorid]),
+            operatorName: data[:operator],
+            operatorLogo: T2Airtime::Util.operator_logo_url(data[:operatorid]),  
+            productName: "#{Money.new(Integer(data[:product_requested]) * 100, data[:destination_currency]).format}",
+            productLocalCurrency: data[:destination_currency],
+            productLocalCurrencySymbol: Money::Currency.new(data[:destination_currency]).symbol,
+            productCurrency: Account.currency,
+            productCurrencySymbol: Money::Currency.new(Account.currency).symbol,
+            productLocalPrice: Float(data[:product_requested]),
+            productRetailPrice: Float(data[:retail_price]),
+            productWholesalePrice: Float(data[:wholesale_price]),          
+            fetchedAt: T2Airtime::Util.format_time(ts)
           },
-          product: {
-            data: {
-              type: 'products',
-              id: Integer(data[:product_requested])
+          relationships: {
+            country: {
+              data: {
+                type: 'countries',
+                id: Integer(data[:countryid])
+              }
+            },
+            operator: {
+              data: {
+                type: 'operators',
+                id: Integer(data[:operatorid])
+              }
+            },
+            product: {
+              data: {
+                type: 'products',
+                id: Integer(data[:product_requested])
+              }
             }
           }
         }
-      }
+      end
     end
   end
 end

data/lib/t2_airtime/version.rb

@@ -1,3 +1,3 @@
 module T2Airtime
-  VERSION = '0.3.1'.freeze
+  VERSION = '0.4.0'.freeze
 end