Class: T2Airtime::Transaction

Inherits:

Object

• Object
• T2Airtime::Transaction

Defined in:

lib/t2_airtime/serializer.rb

Class Method Summary

• .get(id) ⇒ Object
• .serialize(data, qty = 'all') ⇒ Object
• .serialize_one(data, ts = Time.zone.now.to_s) ⇒ Object
• .show(id) ⇒ Object
• .take(start = (Time.now - 24.hours), stop = Time.now, msisdn = nil, destination = nil, code = nil, qty = 5) ⇒ Object

Class Method Details

.get(id) ⇒ Object

# File 'lib/t2_airtime/serializer.rb', line 302

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

.serialize(data, qty = 'all') ⇒ Object

# File 'lib/t2_airtime/serializer.rb', line 296

def self.serialize(data, qty = 'all')
  return [] if data[:transaction_list].nil?
  ids = data[:transaction_list].split(',')
  ids.take(qty==='all' ? ids.count : qty).each.map { |id| show(id) }
end

.serialize_one(data, ts = Time.zone.now.to_s) ⇒ Object

# File 'lib/t2_airtime/serializer.rb', line 313

def self.serialize_one(data, ts = Time.zone.now.to_s)
  Rails.cache.fetch("transactions/#{data[:transactionid]}/serializer", expires_in: 365.days) 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] && data[:originating_currency] || 'XXX',
        localCurrency: data[:destination_currency] && data[:destination_currency] || 'XXX',
        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: data[:countryid] && Integer(data[:countryid]) || nil, 
        countryName: data[:country],
        countryAlpha3: data[:country] && T2Airtime::Country.alpha3(data[:country]) || 'XXX',
        operatorId: data[:operatorid] && Integer(data[:operatorid]) || nil,
        operatorName: data[:operator],
        operatorLogo: data[:operatorid] && T2Airtime::Util.operator_logo_url(data[:operatorid]) || nil,  
        productName: data[:destination_currency] && "#{Money.new(Integer(data[:product_requested]) * 100, data[:destination_currency]).format}" || nil,
        productLocalCurrency: data[:destination_currency],
        productLocalCurrencySymbol: data[:destination_currency] && Money::Currency.new(data[:destination_currency]).symbol || 'XXX',
        productCurrency: Account.currency,
        productCurrencySymbol: Money::Currency.new(Account.currency).symbol,
        productLocalPrice: data[:product_requested] && Float(data[:product_requested]) || 0,
        productRetailPrice: data[:retail_price] && Float(data[:retail_price]) || 0,
        productWholesalePrice: data[:wholesale_price] && Float(data[:wholesale_price]) || 0,          
        fetchedAt: T2Airtime::Util.format_time(ts)
      },
      relationships: {
        country: {
          data: {
            type: 'countries',
            id: data[:countryid] && Integer(data[:countryid]) || nil
          }
        },
        operator: {
          data: {
            type: 'operators',
            id: data[:operatorid] && Integer(data[:operatorid]) || nil
          }
        },
        product: {
          data: {
            type: 'products',
            id: data[:product_requested] && Integer(data[:product_requested]) || nil
          }
        }
      }
    }
  end
end

.show(id) ⇒ Object

# File 'lib/t2_airtime/serializer.rb', line 308

def self.show(id)
  transaction = get(id)
  transaction.success? ? serialize_one(transaction.data, transaction.headers[:date]) : {}
end

.take(start = (Time.now - 24.hours), stop = Time.now, msisdn = nil, destination = nil, code = nil, qty = 5) ⇒ Object

# File 'lib/t2_airtime/serializer.rb', line 291

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