rave_ruby 0.1.1

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rave_ruby"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rave_ruby/error.rb

@@ -0,0 +1,48 @@
+class RaveServerError < StandardError
+	attr_reader :response
+	def initialize(response=nil)
+		@response = response
+	end
+end
+
+class RaveBadKeyError < StandardError
+end
+
+class IncompleteParameterError < StandardError
+end
+
+class SuggestedAuthError < StandardError
+end
+
+class RequiredAuthError < StandardError
+end
+
+class InitiateTransferError < StandardError
+end
+
+class CreatePaymentPlanError < StandardError
+end
+
+class ListPaymentPlanError < StandardError
+end
+
+class FetchPaymentPlanError < StandardError
+end
+
+class CancelPaymentPlanError < StandardError
+end
+
+class EditPaymentPlanError < StandardError
+end
+
+class ListSubscriptionError < StandardError
+end
+
+class FetchSubscriptionError < StandardError
+end
+
+class CancelSubscriptionError < StandardError
+end
+
+class ActivateSubscriptionError < StandardError
+end

data/lib/rave_ruby/rave_modules/base_endpoints.rb

@@ -0,0 +1,21 @@
+module BASE_ENDPOINTS
+    RAVE_LIVE_URL = "https://api.ravepay.co/"
+    RAVE_SANDBOX_URL = "https://ravesandboxapi.flutterwave.com/"
+    CHARGE_ENDPOINT = "flwv3-pug/getpaidx/api/charge"
+    TOKENISED_CHARGE_ENDPOINT = "flwv3-pug/getpaidx/api/tokenized/charge"
+    PREAUTH_CHARGE_ENDPOINT = "flwv3-pug/getpaidx/api/tokenized/preauth_charge"
+    CAPTURE_ENDPOINT = "flwv3-pug/getpaidx/api/capture"
+    REFUND_VOID_ENDPOINT = "flwv3-pug/getpaidx/api/refundorvoid"
+    CARD_VALIDATE_ENDPOINT = "flwv3-pug/getpaidx/api/validatecharge"
+    ACCOUNT_VALIDATE_ENDPOINT = "flwv3-pug/getpaidx/api/validate"
+    VERIFY_ENDPOINT = "flwv3-pug/getpaidx/api/v2/verify"
+    PAYMENT_PLANS_ENDPOINT = "v2/gpx/paymentplans"
+    SUBSCRIPTIONS_ENDPOINT = "v2/gpx/subscriptions"
+    TRANSFER_ENDPOINT = "v2/gpx/transfers"
+    SUBACCOUNT_ENDPOINT = "v2/gpx/subaccounts"
+    GET_FEE_ENDPOINT = "v2/gpx/transfers/fee"
+    GET_BALANCE_ENDPOINT = "v2/gpx/balance"
+    FETCH_ENDPOINT = "v2/gpx/transfers"
+    REFUND_ENDPOINT = "gpx/merchant/transactions"
+    BANKS_ENDPOINT = "flwv3-pug/getpaidx/api/flwpbf-banks.js"
+end

data/lib/rave_ruby/rave_modules/util.rb

@@ -0,0 +1,46 @@
+require "digest"
+require "openssl"
+require "base64"
+require 'json'
+require 'securerandom'
+
+module Util
+
+    # method to generate merchants transaction reference
+    def self.transaction_reference_generator
+      transaction_ref = "MC-" + SecureRandom.hex
+      return transaction_ref
+    end
+
+    # method for encryption algorithm
+    def self.encrypt(key, data)
+      cipher = OpenSSL::Cipher.new("des-ede3")
+      cipher.encrypt # Call this before setting key
+      cipher.key = key
+      data = data.to_json
+      ciphertext = cipher.update(data)
+      ciphertext << cipher.final
+      return Base64.encode64(ciphertext)
+    end
+
+    # def self.decrypt(key, ciphertext)
+
+    #   cipher = OpenSSL::Cipher.new("des-ede3")
+    #   cipher.encrypt # Call this before setting key or iv
+    #   cipher.key = key
+    #   cipher.decrypt
+    #   plaintext = cipher.update(Base64.decode64(ciphertext))
+    #   plaintext << cipher.final
+    #   return plaintext
+      
+    # end
+  
+    # def checksum(payload)
+    #   payload.sort_by { |k,v| k.to_s }
+    #   hashed_payload = ''
+    #   family.each { |k,v|
+    #     hashed_payload << v
+    #   }
+    #   return Digest::SHA256.hexdigest(hashed_payload + self.secret_key)
+    # end
+end

data/lib/rave_ruby/rave_objects/account.rb

@@ -0,0 +1,68 @@
+require_relative "base/charge_base.rb"
+require 'json'
+
+class Account < ChargeBase
+
+# method to initiate the account payment 
+
+    def initiate_charge(data)
+        base_url = rave_object.base_url
+        hashed_secret_key = get_hashed_key
+        public_key = rave_object.public_key
+
+
+        # only update the payload with the transaction reference if it isn't already added to the payload
+        if !data.key?("txRef")
+            data.merge!({"txRef" => Util.transaction_reference_generator})
+        end
+
+        data.merge!({"PBFPubKey" => public_key})
+
+        required_parameters = ["accountbank", "accountnumber", "amount", "email", "phonenumber", "IP"]
+        check_passed_parameters(required_parameters, data)
+
+        encrypt_data = Util.encrypt(hashed_secret_key, data)
+
+        payload = {
+            "PBFPubKey" => public_key,
+            "client" => encrypt_data,
+            "alg" => "3DES-24"
+        }
+
+        payload = payload.to_json
+        response = post_request("#{base_url}#{BASE_ENDPOINTS::CHARGE_ENDPOINT}", payload) 
+
+        return handle_charge_response(response)
+    end
+
+    def validate_charge(flwRef, otp)
+        base_url = rave_object.base_url
+        public_key = rave_object.public_key
+        
+        
+        payload = {
+            "PBFPubKey" => public_key,
+            "transactionreference" => flwRef,
+            "transaction_reference" => flwRef,
+            "otp" => otp,
+        }
+        payload = payload.to_json
+
+        response = post_request("#{base_url}#{BASE_ENDPOINTS::ACCOUNT_VALIDATE_ENDPOINT}", payload)
+        return handle_validate_account_response(response)
+    end
+
+    def verify_charge(txref)
+        base_url = rave_object.base_url
+
+        payload = {
+            "txref" => txref,
+            "SECKEY" => rave_object.secret_key.dup,
+        }
+
+        payload = payload.to_json
+
+        response = post_request("#{base_url}#{BASE_ENDPOINTS::VERIFY_ENDPOINT}", payload)
+        return handle_verify_account_response(response)
+    end
+end

data/lib/rave_ruby/rave_objects/base/base.rb

@@ -0,0 +1,106 @@
+require 'httparty'
+require_relative "../../rave_modules/base_endpoints"
+require "json"
+require_relative "../../error"
+
+class Base
+
+  attr_reader :rave_object, :get_hashed_key
+
+  # method to initialize this class
+  
+  def initialize(rave_object=nil)
+    unless !rave_object.nil?
+      raise ArgumentError, "Rave Object is required!!!"
+    end
+    @rave_object = rave_object
+  end
+
+
+  # method to get the hashed secret key
+  def get_hashed_key
+    hash = Digest::MD5.hexdigest(rave_object.secret_key)
+    last_twelve = hash[hash.length-12..hash.length-1]
+    private_secret_key = rave_object.secret_key.dup
+    private_secret_key['FLWSECK-'] = ''
+    first_twelve = private_secret_key[0..11]
+    return first_twelve + last_twelve
+  end
+
+  # method to make a get request
+  def get_request(endpoint, data={})
+    http_params = {}
+    unless data.empty?
+      http_params[:query] = data
+    end
+
+    begin
+      response = HTTParty.get(endpoint, http_params)
+      unless (response.code == 200 || response.code == 201)
+        raise RaveServerError.new(response), "HTTP Code #{response.code}: #{response.body}"
+      end
+
+      # response_body = response.body
+
+      return response
+
+      unless(response.code != 0 )
+        raise RaveServerError.new(response), "Server Message: #{response.message}"
+      end
+
+      rescue JSON::ParserError => jsonerr
+        raise RaveServerError.new(response) , "Invalid result data. Could not parse JSON response body \n #{jsonerr.message}"
+
+      # rescue RaveServerError => e
+      #   Util.serverErrorHandler(e)
+      # end	
+
+        return response
+      end
+  end
+
+  # method to make a post request
+  def post_request(endpoint, data)
+    begin
+      response = HTTParty.post(endpoint, {
+        body: data,
+        headers: {
+          'Content-Type' => 'application/json'
+        }
+      })
+
+      unless (response.code == 200 || response.code == 201)
+        raise RaveServerError.new(response), "HTTP Code #{response.code}: #{response.body}"
+      end
+
+      return response
+    end
+
+  end
+
+  # method to check if the passed parameters is equal to the expected parameters
+  def check_passed_parameters(required_params, passed_params)
+
+    # This is used to check if the passed authorization parameters matches the required parameters
+    required_params.each do |k, v|
+      if !passed_params.key?(k)
+        raise IncompleteParameterError, "Parameters Incomplete, Missing Parameter: #{k}, Please pass in the complete parameter."
+      end
+      # return true
+    end
+  end
+
+  # method to handle list bank response
+  def handle_list_bank(response)
+    list_bank = response
+
+    if list_bank.code == 200
+        response = {"error" => false, "data" => JSON.parse(list_bank.body)}
+        return response
+    else
+        response = {"error" => true, "data" => JSON.parse(list_bank.body)}
+        return response
+        # raise InitiateTransferError, response
+    end
+  end
+end

data/lib/rave_ruby/rave_objects/base/charge_base.rb

@@ -0,0 +1,154 @@
+require_relative "base.rb"
+
+class ChargeBase < Base
+
+    # method to the passed suggested auth to the corresponding value in the available hash
+  def get_auth_type(suggested_auth)
+    auth_map = {"PIN" => :pin, "AVS_VBVSECURECODE" => :address, "NOAUTH_INTERNATIONAL" => :address, "AVS_NOAUTH" => :address}
+
+    # Raise Error if the right authorization type is not passed
+    unless !auth_map.has_key? auth_map[suggested_auth]
+      raise RequiredAuthError, "Required suggested authorization type not available."
+    end
+    return auth_map[suggested_auth]
+  end
+
+
+  # method to update payload
+  def update_payload(suggested_auth, payload, **keyword_args)
+    auth_type = get_auth_type(suggested_auth)
+    
+    # Error is raised if the expected suggested auth is not found in the keyword arguments
+    if !keyword_args.key?(auth_type)
+      raise SuggestedAuthError, "Please pass the suggested auth."
+    end
+
+    # if the authorization type is equal to address symbol, update with the required parameters
+    if auth_type == :address
+      required_parameters = ["billingzip", "billingcity", "billingaddress", "billingstate", "billingcountry"]
+      check_passed_parameters(required_parameters, keyword_args[auth_type])
+      payload.merge!({"suggested_auth" => suggested_auth})
+      return payload.merge!(keyword_args[auth_type])
+    end
+
+    # return this updated payload if the passed authorization type isn't address symbol
+    return payload.merge!({"suggested_auth" => suggested_auth, auth_type.to_s => keyword_args[auth_type]})
+
+  end
+
+  # method to charge response
+  def handle_charge_response (response)
+
+    charge_response = response
+    # print charge_response
+    flwRef = charge_response["data"]["flwRef"]
+    txRef = charge_response["data"]["txRef"]
+    # status = charge_response["data"]["status"]
+    message = charge_response["message"]
+    status = charge_response["status"]
+    suggested_auth = charge_response["data"]["suggested_auth"]
+    amount = charge_response["data"]["amount"]
+    currency = charge_response["data"]["currency"]
+    auth_model_used = charge_response["data"]["authModelUsed"]
+    validate_instruction = charge_response["data"]["validateInstruction"]
+    payment_type = charge_response["data"]["paymentType"]
+    charge_response_code = charge_response["data"]["chargeResponseCode"]
+    charge_response_message = charge_response["data"]["chargeResponseMessage"]
+
+
+    if charge_response["data"]["authurl"] == "N/A"
+      authurl = "N/A"
+    else
+      authurl = charge_response["data"]["authurl"]
+    end
+
+    if charge_response_code == "00"
+      res = {"error": false, "status": status, "validation_required": false, "message": message, "suggested_auth": suggested_auth, "txRef": txRef, "flwRef": flwRef, "chargeResponseCode": charge_response_code, "chargeResponseMessage": charge_response_message, "amount": amount, "currency": currency, "validateInstruction": validate_instruction, "paymentType": payment_type, "authModelUsed": auth_model_used, "authurl": authurl}
+      return JSON.parse(res.to_json)
+    else
+      res = {"error": false, "status": status, "validation_required": true, "message": message, "suggested_auth": suggested_auth, "txRef": txRef, "flwRef": flwRef, "chargeResponseCode": charge_response_code, "chargeResponseMessage": charge_response_message, "amount": amount, "currency": currency, "validateInstruction": validate_instruction, "paymentType": payment_type, "authModelUsed": auth_model_used, "authurl": authurl}
+      return JSON.parse(res.to_json)
+    # else
+    #   # return charge_response
+    #   res = {"status": charge_response["status"], "message": charge_response["message"], "data": charge_response["data"]}
+    #   return JSON.parse(res.to_json)
+    end
+  end
+
+
+  # method to handle validate card response
+  def handle_validate_response(response)
+
+    validate_response = response
+    flwRef = validate_response["data"]["tx"]["flwRef"]
+    txRef = validate_response["data"]["tx"]["txRef"]
+    status = validate_response["status"]
+    message = validate_response["message"]
+    amount = validate_response["data"]["tx"]["amount"]
+    currency = validate_response["data"]["tx"]["currency"]
+    charge_response_code = validate_response["data"]["tx"]["chargeResponseCode"]
+    charge_response_message = validate_response["data"]["tx"]["chargeResponseMessage"]
+
+    if charge_response_code == "00"
+      res = {"error": false, "status": status, "message": message, "txRef": txRef, "flwRef": flwRef, "amount": amount, "currency": currency, "chargeResponseCode": charge_response_code, "chargeResponseMessage": charge_response_message}
+      return JSON.parse(res.to_json)
+    else
+      res = {"error": true, "status": status, "message": message, "txRef": txRef, "flwRef": flwRef, "amount": amount, "currency": currency, "chargeResponseCode": charge_response_code, "chargeResponseMessage": charge_response_message}
+      return JSON.parse(res.to_json)
+    end
+  end
+
+
+   # method to handle validate account response
+   def handle_validate_account_response(response)
+
+    validate_response = response
+    flwRef = validate_response["data"]["flwRef"]
+    txRef = validate_response["data"]["txRef"]
+    status = validate_response["status"]
+    message = validate_response["message"]
+    amount = validate_response["data"]["amount"]
+    currency = validate_response["data"]["currency"]
+    charge_response_code = validate_response["data"]["chargeResponseCode"]
+    charge_response_message = validate_response["data"]["chargeResponseMessage"]
+
+    if charge_response_code == "00"
+      res = {"error": false, "status": status, "message": message, "txRef": txRef, "flwRef": flwRef, "amount": amount, "currency": currency, "chargeResponseCode": charge_response_code, "chargeResponseMessage": charge_response_message}
+      return JSON.parse(res.to_json)
+    else
+      res = {"error": true, "status": status, "message": message, "txRef": txRef, "flwRef": flwRef, "amount": amount, "currency": currency, "chargeResponseCode": charge_response_code, "chargeResponseMessage": charge_response_message}
+      return JSON.parse(res.to_json)
+    end
+  end
+
+  # method to handle card verify response
+  def handle_verify_response(response)
+    verify_response = response
+    status = verify_response["data"]["status"]
+    charge_code = verify_response["data"]["chargecode"]
+
+
+    if charge_code == "00" && status == "successful"
+      res = {"error": false, "transaction_complete": true, "data": verify_response["data"]}
+      return JSON.parse(res.to_json)
+    else
+      res = {"error": true, "transaction_complete": false, "data": verify_response["data"]}
+      return JSON.parse(res.to_json)
+    end
+  end
+
+  # method to handle account verify response
+  def handle_verify_account_response(response)
+    verify_response = response
+    status = verify_response["data"]["status"]
+    charge_code = verify_response["data"]["chargecode"]
+
+    if charge_code == "00" && status == "successful"
+      res = {"error": false, "transaction_complete": true, "data": verify_response["data"]}
+      return JSON.parse(res.to_json)
+    else
+      res = {"error": true, "transaction_complete": false, "data": verify_response["data"]}
+      return JSON.parse(res.to_json)
+    end
+  end
+end 

data/lib/rave_ruby/rave_objects/base/mobile_money_base.rb

@@ -0,0 +1,44 @@
+require_relative "base.rb"
+
+class MobileMoneyBase < Base
+
+    # method to handle mobile money charge response
+    def handle_charge_response(response)
+        charge_response = response
+        flwRef = charge_response["data"]["flwRef"]
+        txRef = charge_response["data"]["txRef"]
+        status = charge_response["data"]["status"]
+        amount = charge_response["data"]["amount"]
+        currency = charge_response["data"]["currency"]
+        payment_type = charge_response["data"]["paymentType"]
+        validate_instruction = charge_response["data"]["validateInstruction"]
+        auth_model_used = charge_response["data"]["authModelUsed"]
+        charge_response_code = charge_response["data"]["chargeResponseCode"]
+        charge_response_message = charge_response["data"]["chargeResponseMessage"]
+
+
+        if charge_response_code == "00"
+            res = {"error": false, "status": status, "validation_required": false, "txRef": txRef, "flwRef": flwRef, "amount": amount, "currency": currency, "validateInstruction": validate_instruction, "authModelUsed": auth_model_used, "paymentType": payment_type}
+            return JSON.parse(res.to_json)
+        else
+            res = {"error": false, "status": status, "validation_required": true, "txRef": txRef, "flwRef": flwRef, "amount": amount, "currency": currency, "validateInstruction": validate_instruction, "authModelUsed": auth_model_used, "paymentType": payment_type}
+            return JSON.parse(res.to_json)
+        end
+    end
+
+
+    # method to handle mobile money verify response
+    def handle_verify_response(response)
+        verify_response = response
+        status = verify_response["data"]["status"]
+        charge_code = verify_response["data"]["chargecode"]
+
+        if charge_code == "00" && status == "successful"
+            res = {"error": false, "transaction_complete": true, "data": verify_response["data"]}
+            return JSON.parse(res.to_json)
+        else
+            res = {"error": false, "transaction_complete": false, "data": verify_response["data"]}
+            return JSON.parse(res.to_json)
+        end
+    end
+end

data/lib/rave_ruby/rave_objects/base/mpesa_base.rb

@@ -0,0 +1,41 @@
+require_relative "base.rb"
+
+class MpesaBase < Base
+
+    # method to handle mpesa charge response
+    def handle_charge_response(response)
+
+        charge_response = response
+        flwRef = charge_response["data"]["flwRef"]
+        txRef = charge_response["data"]["txRef"]
+        status = charge_response["data"]["status"]
+        amount = charge_response["data"]["amount"]
+        currency = charge_response["data"]["currency"]
+        payment_type = charge_response["data"]["paymentType"]
+
+
+        if status == "pending"
+            res = {"error": false, "status": status, "validation_required": true, "txRef": txRef, "flwRef": flwRef, "amount": amount, "currency": currency, "paymentType": payment_type}
+            return JSON.parse(res.to_json)
+        else
+            res = {"error": false, "status": status, "validation_required": false, "txRef": txRef, "flwRef": flwRef, "amount": amount, "currency": currency, "paymentType": payment_type}
+            return JSON.parse(res.to_json)
+        end
+    end
+
+
+    # method to handle mpesa verify response
+    def handle_verify_response(response)
+        verify_response = response
+        status = verify_response["data"]["status"]
+        charge_code = verify_response["data"]["chargecode"]
+
+        if charge_code == "00" && status == "successful"
+            res = {"error": false, "transaction_complete": true, "data": verify_response["data"]}
+            return JSON.parse(res.to_json)
+        else
+            res = {"error": false, "transaction_complete": false, "data": verify_response["data"]}
+            return JSON.parse(res.to_json)
+        end
+    end
+end

data/lib/rave_ruby/rave_objects/base/payment_plan_base.rb

@@ -0,0 +1,86 @@
+require_relative "base.rb"
+
+class PaymentPlanBase < Base
+
+    # method to handle payment plan response 
+
+    def handle_create_response(response)
+
+        create_response = response
+        statusMessage = create_response["status"]
+
+        if statusMessage == "success"
+            response = {"error": false, "data": create_response["data"]}
+            return JSON.parse(response.to_json)
+        else
+            response = {"error": true, "data": create_response["data"]}
+            raise CreatePaymentPlanError, JSON.parse(response.to_json)
+        end
+    end
+
+    # method to list payment plan
+
+    def handle_list_response(response)
+        list_response = response
+
+        status = list_response["status"]
+        message = list_response["message"]
+       data = list_response["data"]
+       paymentplans = list_response["data"]["paymentplans"]
+
+        if status == "success"
+            response = {"error": false, "status": status,"message": message, "data": data}
+            return JSON.parse(response.to_json)
+        else
+            response = {"error": true, "data": list_response["data"]}
+            raise ListPaymentPlanError, JSON.parse(response.to_json)
+        end
+    end
+
+    # method to handle fetch payment plan response
+    def handle_fetch_response(response)
+        fetch_response = response
+        status = fetch_response["status"]
+        data = fetch_response["data"]
+
+        if status == "success"
+            response = {"error": false, "data": data}
+            return JSON.parse(response.to_json)
+        else
+            response = {"error": true, "data": data}
+            raise FetchPaymentPlanError, JSON.parse(response.to_json)
+        end
+
+    end
+
+    # method to handle cancel payment response
+    def handle_cancel_response(response)
+        cancel_response = response
+        status = cancel_response["status"]
+        data = cancel_response["data"]
+
+        if status == "success"
+            response = {"error": false, "data": data}
+            return JSON.parse(response.to_json)
+        else
+            response = {"error": true, "data": data}
+            raise CancelPaymentPlanError, JSON.parse(response.to_json)
+        end
+    end
+
+    # method to handle edit payment plan response 
+    def handle_edit_response(response)
+        edit_response = response
+        status = edit_response["status"]
+        data = edit_response["data"]
+
+        if status == "success"
+            response = {"error": false, "data": data}
+            return JSON.parse(response.to_json)
+        else
+            response = {"error": true, "data": data}
+            raise EditPaymentPlanError, JSON.parse(response.to_json)
+        end
+    end
+
+end