t2_airtime 0.3.0 → 0.3.1

data/lib/t2_airtime/serializer.rb

@@ -1,313 +1,294 @@
-module T2Airtime
-
-  class Account
-
-    def self.info
-        reply = T2Airtime::API.api.account_info
-        reply.success? ? serialize(reply.data, reply.headers[:date]) : []
-    end
-
-    def self.serialize(data, ts="#{Time.zone.now}")
-      {
-        type: "accounts",
-        id: T2Airtime::API.api.user,
-        attributes: {
-          "type": data[:type],
-          "name": data[:name],
-          "currency": data[:currency],
-          "balance": Float(data[:balance]),          
-          "wallet": Float(data[:wallet]),
-          "fetched-at": T2Airtime::Util.format_time(ts)
-        }
-      }.as_json
-    end
-
-  end  
-
-  class Country
-
-    def self.take(qty=5)
-        reply = T2Airtime::API.api.country_list
-        reply.success? ? serialize(reply.data, reply.headers[:date], qty) : []
-    end
-
-    def self.serialize(data, ts="#{Time.zone.now}", qty=nil)
-        return [] if data[:countryid].nil?
-        names = data[:country].split(",") 
-        ids = data[:countryid].split(",")
-        ids.take(qty.nil? ? ids.count : qty).each_with_index.map{|id, n| {
-          type: "countries",
-          id: Integer(id),
-          attributes: {
-            "name": names[n], 
-            "alpha3": alpha3(names[n]),
-            "fetched-at": T2Airtime::Util.format_time(ts)
-          },
-          relationships: {
-            operators: {
-              links: {
-                related: "/countries/#{id}/operators"
-              }
-            }
-          }
-        }}.as_json
-    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["id"])
-            reply.success? ? serialize(reply.data, reply.headers[:date], qty) : []
-          )}        
-        end
-    end    
-
-    def self.serialize(data, ts="#{Time.zone.now}", qty=nil)
-         return [] if data[:operator].nil?
-         names = data[:operator].split(",") 
-         ids = data[:operatorid].split(",")
-         ids.take(qty.nil? ? ids.count : qty).each_with_index.map{|id, n| {
-            type: "operators",
-            id: Integer(id),
-            attributes: {
-              "name": names[n], 
-              "fetched-at": T2Airtime::Util.format_time(ts)
-            },
-            links: {
-              logo: T2Airtime::Util.operator_logo_url(id)
-            },
-            relationships: {
-              country: {
-                data: { 
-                  type: "countries",
-                  id: Integer(data[:countryid])
-                }
-              },
-              products: {
-                links: {
-                  related: "/countries/#{data[:countryid]}/operators/#{id}/products"
-                }
-              }              
-            },
-            included: [
-              {
-                  type: "countries",
-                  id: Integer(data[:countryid]),
-                  attributes: {
-                    "name": data[:country],
-                    "alpha3": T2Airtime::Country.alpha3(data[:country])
-                  }                
-              }
-            ]            
-         }}.as_json
-    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["id"])
-            reply.success? ? serialize(reply.data, reply.headers[:date], qty) : []
-          )}        
-        end         
-    end
-
-    def self.serialize(data, ts="#{Time.zone.now}", qty=nil)
-         return [] if data[:product_list].nil?          
-         ids = data[:product_list].split(",")
-         retail_prices = data[:retail_price_list].split(",") 
-         wholesale_prices = data[:wholesale_price_list].split(",")         
-         ids.take(qty.nil? ? ids.count : qty).each_with_index.map{|id, n| {
-           type: "products",
-           id: Integer(id), 
-           attributes: {
-            "name": "#{id}#{data[:destination_currency]}", 
-            "currency": data[:destination_currency],
-            "local-price": Float(id),
-            "retail-price": Float(retail_prices[n]),
-            "wholesale-price": Float(wholesale_prices[n]),           
-            "fetched-at": T2Airtime::Util.format_time(ts)
-           },
-            relationships: {
-              country: {
-                data: { 
-                  type: "countries",
-                  id: Integer(data[:countryid])
-                }
-              },
-              operator: {
-                data: { 
-                  type: "operators",
-                  id: Integer(data[:operatorid])
-                }
-              }
-            },
-            included: [
-              {
-                  type: "countries",
-                  id: Integer(data[:countryid]),
-                  attributes: {
-                    "name": data[:country],
-                    "alpha3": T2Airtime::Country.alpha3(data[:country])
-                  }                
-              },
-              {
-                  type: "operators",
-                  id: Integer(data[:operatorid]),
-                  attributes: {
-                    "name": data[:operator]
-                  },
-                  links: {
-                    logo: T2Airtime::Util.operator_logo_url(data[:operatorid])
-                  }              
-              }
-            ]
-         }}.as_json
-    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.transaction_list(start, stop, msisdn, destination, code)
-        reply.success? ? serialize(reply.data, qty) : []
-    end
-      
-    def self.serialize(data, qty=nil)
-      return [] if data[:transaction_list].nil?
-      ids = data[:transaction_list].split(",")
-      ids.take(qty.nil? ? ids.count : qty).each.map{ |id| show(id) }
-    end
-
-
-    def self.show(id)
-        reply = T2Airtime::API.api.transaction_info(id)
-        reply.success? ? serialize_one(reply.data, reply.headers[:date]) : {}
-    end
-
-    def self.serialize_one(data, ts="#{Time.zone.now}")
-      {
-        type: "transactions",
-        id: Integer(data[:transactionid]),
-        attributes: {
-          "msisdn": data[:msisdn],
-          "destination-msisdn": data[:destination_msisdn],
-          "transaction-authentication-key": data[:transaction_authentication_key],
-          "transaction-error-code": Integer(data[:transaction_error_code]),
-          "transaction-error-txt": data[:transaction_error_txt],
-          "reference-operator": data[:reference_operator],
-          "actual-product-sent": data[:actual_product_sent],
-          "sms": data[:sms],
-          "cid1": data[:cid1],
-          "cid2": data[:cid2],
-          "cid3": data[:cid3],
-          "date": data[:date],
-          "originating-currency": data[:originating_currency],
-          "destination-currency": data[:destination_currency],
-          "pin-based": data[:pin_based],
-          "local-info-amount": data[:local_info_amount],
-          "local-info-currency": data[:local_info_currency],
-          "local-info-value": data[:local_info_value],
-          "error-code": data[:error_code],
-          "error-txt": data[:error_txt],
-          "fetched-at": T2Airtime::Util.format_time(ts)
-        },
-        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])
-            }
-          }
-        },
-        included: [
-          {
-              type: "countries",
-              id: Integer(data[:countryid]),
-              attributes: {
-                "name": data[:country],
-                "alpha3": T2Airtime::Country.alpha3(data[:country])
-              }                
-          },
-          {
-              type: "operators",
-              id: Integer(data[:operatorid]),
-              attributes: {
-                "name": data[:operator]
-              },
-              links: {
-                logo: T2Airtime::Util.operator_logo_url(data[:operatorid])
-              }               
-          },
-          {
-              type: "products",
-              id: Integer(data[:product_requested]),
-              attributes: {
-                "name": "#{data[:product_requested]}#{data[:destination_currency]}",
-                "currency": data[:destination_currency],
-                "wholesale-price": data[:wholesale_price],
-                "retail-price": data[:retail_price],
-                "local-price": Float(data[:product_requested])
-              }              
-          }
-        ]
-      }.as_json
-    end
-
-
-  end
-
-  
-end
+module T2Airtime
+  class Account
+    def self.get
+      Rails.cache.fetch('accounts', expires_in: 1.hour) do
+        T2Airtime::API.api.account_info
+      end
+    end
+
+    def self.currency
+      Rails.cache.fetch('accounts/currency', expires_in: 24.hours) do        
+        serialize(get.data)["attributes"]["currency"]
+      end      
+    end
+
+    def self.info
+      get.success? ? serialize(get.data, get.headers[:date]) : []
+    end
+
+    def self.serialize(data, ts = Time.zone.now.to_s)
+      {
+        type: 'accounts',
+        id: T2Airtime::API.api.user,
+        attributes: {
+          type: data[:type],
+          name: data[:name],
+          currency: data[:currency],
+          balance: Float(data[:balance]),
+          wallet: Float(data[:wallet]),
+          fetchedAt: T2Airtime::Util.format_time(ts)
+        }
+      }
+    end
+  end
+
+  class Country
+    def self.all
+      Rails.cache.fetch('countries', expires_in: 1.hour) do
+        T2Airtime::API.api.country_list
+      end
+    end
+
+    def self.take(qty = 5)
+      countries = all
+      countries.success? ? serialize(countries.data, countries.headers[:date], qty) : []
+    end
+
+    def self.serialize(data, ts = Time.zone.now.to_s, qty = nil)
+      return [] if data[:countryid].nil?
+      names = data[:country].split(',')
+      ids = data[:countryid].split(',')
+      Rails.cache.fetch('countries/serializer', expires_in: 1.hour) do
+        ids.take(qty.nil? ? ids.count : qty).each_with_index.map do |id, n|
+          {
+            type: 'countries',
+            id: Integer(id),
+            attributes: {
+              name: names[n],
+              alpha3: alpha3(names[n]),
+              fetchedAt: T2Airtime::Util.format_time(ts)
+            }
+          }
+        end
+      end
+    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.all(country_id)
+      Rails.cache.fetch("operators/#{country_id}", expires_in: 1.hour) do
+        T2Airtime::API.api.operator_list(country_id)
+      end
+    end
+
+    def self.take(country_qty = 1, qty = 5)
+      countries = T2Airtime::Country.take(country_qty).shuffle
+      unless countries.empty?
+        countries.flat_map do |country| (          
+          operators = all(country['id'])
+          operators.success? ? serialize(operators.data, operators.headers[:date], qty) : []
+        )
+        end
+      end
+    end
+
+    def self.serialize(data, ts = Time.zone.now.to_s, qty = nil)
+      return [] if data[:operator].nil?
+      names = data[:operator].split(',')
+      ids = data[:operatorid].split(',')
+      Rails.cache.fetch("operators/#{data[:countryid]}/serializer", expires_in: 1.hour) do
+        ids.take(qty.nil? ? ids.count : qty).each_with_index.map do |id, n|
+          {
+            type: 'operators',
+            id: Integer(id),
+            attributes: {
+              name: names[n],
+              logo: T2Airtime::Util.operator_logo_url(id),
+              countryId: Integer(data[:countryid]), 
+              countryName: data[:country],
+              countryAlpha3: T2Airtime::Country.alpha3(data[:country]),              
+              fetchedAt: T2Airtime::Util.format_time(ts)
+            },
+            relationships: {
+              country: {
+                data: {
+                  type: 'countries',
+                  id: Integer(data[:countryid])
+                }
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+
+  class Product
+    def self.all(operator_id)
+      Rails.cache.fetch("products/#{operator_id}", expires_in: 1.hour) do
+        T2Airtime::API.api.product_list(operator_id)
+      end
+    end
+
+    def self.take(operator_qty = 1, qty = 5)
+      operators = T2Airtime::Operator.take(operator_qty).shuffle
+      unless operators.empty?
+        operators.flat_map do |operator| (
+
+          
+          products = all(operator['id'])
+          products.success? ? serialize(products.data, products.headers[:date], qty) : []
+        )
+        end
+      end
+    end
+
+    def self.serialize(data, ts = Time.zone.now.to_s, qty = nil)
+      return [] if data[:product_list].nil?
+      ids = data[:product_list].split(',')
+      retail_prices = data[:retail_price_list].split(',')
+      wholesale_prices = data[:wholesale_price_list].split(',')
+      Rails.cache.fetch("products/#{data[:operatorid]}/serializer", expires_in: 1.hour) do
+        ids.take(qty.nil? ? ids.count : qty).each_with_index.map do |id, n|
+          {
+            type: 'products',
+            id: Integer(id),
+            attributes: {
+              name: "#{Money.new(Integer(id) * 100, data[:destination_currency]).format}",
+              localCurrency: data[:destination_currency],
+              localCurrencySymbol: Money::Currency.new(data[:destination_currency]).symbol,
+              currency: Account.currency,
+              currencySymbol: Money::Currency.new(Account.currency).symbol,
+              localPrice: Float(id),
+              retailPrice: Float(retail_prices[n]),
+              wholesalePrice: Float(wholesale_prices[n]),
+              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]),                      
+              fetchedAt: T2Airtime::Util.format_time(ts)
+            },
+            relationships: {
+              country: {
+                data: {
+                  type: 'countries',
+                  id: Integer(data[:countryid])
+                }
+              },
+              operator: {
+                data: {
+                  type: 'operators',
+                  id: Integer(data[:operatorid])
+                }
+              }
+            }
+          }
+        end
+      end
+    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.transaction_list(start, stop, msisdn, destination, code)
+      reply.success? ? serialize(reply.data, qty) : []
+    end
+
+    def self.serialize(data, qty = nil)
+      return [] if data[:transaction_list].nil?
+      ids = data[:transaction_list].split(',')
+      ids.take(qty.nil? ? ids.count : qty).each.map { |id| show(id) }
+    end
+
+    def self.show(id)
+      reply = T2Airtime::API.api.transaction_info(id)
+      reply.success? ? serialize_one(reply.data, reply.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])
+            }
+          },
+          product: {
+            data: {
+              type: 'products',
+              id: Integer(data[:product_requested])
+            }
+          }
+        }
+      }
+    end
+  end
+end

data/lib/t2_airtime/url.rb

@@ -1,6 +1,6 @@
-module T2Airtime
-  DOMAIN = "transferto.com"
-  AIRTIME_DN = "airtime"
-  OPLOGO_DN = "operator-logo"
-  ENDPOINT = "cgi-bin/shop/topup"
-end
+module T2Airtime
+  DOMAIN = 'transferto.com'.freeze
+  AIRTIME_DN = 'airtime'.freeze
+  OPLOGO_DN = 'operator-logo'.freeze
+  ENDPOINT = 'cgi-bin/shop/topup'.freeze
+end