k2-connect-ruby 0.0.1

data/lib/k2-connect-ruby/k2_financial_entity/entity.rb

@@ -0,0 +1,6 @@
+require 'k2-connect-ruby/k2_financial_entity/k2_token'
+require 'k2-connect-ruby/k2_financial_entity/k2_subscribe'
+require 'k2-connect-ruby/k2_financial_entity/entities/k2_stk'
+require 'k2-connect-ruby/k2_financial_entity/entities/k2_pay'
+require 'k2-connect-ruby/k2_financial_entity/entities/k2_transfer'
+require 'k2-connect-ruby/k2_financial_entity/entities/k2_settlement'

data/lib/k2-connect-ruby/k2_financial_entity/k2_entity.rb

@@ -0,0 +1,34 @@
+# Common Class Behaviours for stk, pay and transfers
+class K2Entity
+  attr_accessor :access_token, :the_array
+  attr_reader :k2_response_body, :query_hash, :location_url
+  include K2Validation, K2Utilities
+
+  # Initialize with access token from Subscriber Class
+  def initialize(access_token)
+    @access_token = access_token
+    @threads = []
+    @exception_array = %w[authenticity_token]
+  end
+
+  # Query/Check the status of a previously initiated request
+  def query_status(class_type, path_url)
+    query(class_type, path_url)
+  end
+
+  # Query Location URL
+  def query_resource(class_type, url)
+    query(class_type, url)
+  end
+
+  def query(class_type, path_url)
+    # TODO: Add back the validation to ensure only https location urls are returned
+    # path_url = validate_url(@location_url)
+    query_hash = make_hash(path_url, 'get', @access_token, class_type, nil)
+    @threads << Thread.new do
+      sleep 0.25
+      @k2_response_body = K2Connect.make_request(query_hash)
+    end
+    @threads.each(&:join)
+  end
+end

data/lib/k2-connect-ruby/k2_financial_entity/k2_subscribe.rb

@@ -0,0 +1,42 @@
+# Class for Subscription Service
+class K2Subscribe
+  include K2Validation, K2Utilities
+  attr_reader :location_url, :k2_response_body
+  attr_accessor :access_token, :webhook_secret
+
+  # Initialize with the event_type
+  def initialize(access_token)
+    raise ArgumentError, 'Nil or Empty Access Token Given!' if access_token.blank?
+    @threads = []
+    @access_token = access_token
+  end
+
+  # Implemented a Case condition that minimises repetition
+  def webhook_subscribe(params)
+    params = validate_webhook_input(params)
+    validate_webhook(params)
+    k2_request_body = {
+        event_type: params[:event_type],
+        url: params[:url],
+        scope: params[:scope],
+        scope_reference: params[:scope_reference]
+    }
+    subscribe_hash = make_hash(K2Config.path_url('webhook_subscriptions'), 'post', @access_token,'Subscription', k2_request_body)
+    @location_url =  K2Connect.make_request(subscribe_hash)
+  end
+
+  # Query Recent Webhook
+  def query_webhook(location_url = @location_url)
+    query_hash = make_hash(location_url, 'get', @access_token, 'Subscription', nil)
+    @threads << Thread.new do
+      sleep 0.25
+      @k2_response_body = K2Connect.make_request(query_hash)
+    end
+    @threads.each(&:join)
+  end
+
+  # Query Specific Webhook URL
+  def query_resource_url(url)
+    query_webhook(url)
+  end
+end

data/lib/k2-connect-ruby/k2_financial_entity/k2_token.rb

@@ -0,0 +1,37 @@
+# Class for Gaining Access Token
+class K2AccessToken
+  attr_reader :access_token
+
+  def initialize(client_id, client_secret)
+    validate_client_credentials(client_id, client_secret)
+    @client_id = client_id
+    @client_secret = client_secret
+  end
+
+  # Method for sending the request to K2 sandbox or Mock Server (Receives the access_token)
+  def request_token
+    token_params = {
+        client_id: @client_id,
+        client_secret: @client_secret,
+        grant_type: 'client_credentials'
+    }
+    token_hash = K2AccessToken.make_hash(K2Config.path_url('oauth_token'), 'post', 'Access Token', token_params)
+    @access_token = K2Connect.make_request(token_hash)
+  end
+
+  def validate_client_credentials(client_id, client_secret)
+    raise ArgumentError, 'Nil or Empty Client Id or Secret!' if client_id.blank? || client_secret.blank?
+  end
+
+  class << self
+    # Create a Hash containing important details accessible for K2Connect
+    def make_hash(path_url, request, class_type, body)
+      {
+          path_url: path_url,
+          request_type: request,
+          class_type: class_type,
+          params: body
+      }.with_indifferent_access
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_services/client/k2_client.rb

@@ -0,0 +1,24 @@
+# TODO: Uncomment the checking of the request scheme
+class K2Client
+  attr_accessor :api_secret_key,
+                :hash_body,
+                :k2_signature
+
+  # Initialize method
+  def initialize(api_secret_key)
+    raise ArgumentError, 'No Secret Key Given!' if api_secret_key.blank?
+    @api_secret_key = api_secret_key
+  end
+
+  # Method for parsing the Entire Request. Come back to it later to trim. L8r call it set_client_variables
+  def parse_request(the_request)
+    raise ArgumentError, 'Nil Request Parameter Input!' if the_request.blank?
+
+    # The Response Body.
+    @hash_body = Yajl::Parser.parse(the_request.body.read.as_json)
+    # The Response Header
+    hash_header = Yajl::Parser.parse(the_request.env.select { |k, _| k =~ /^HTTP_/ }.to_json)
+    # The K2 Signature
+    @k2_signature = hash_header['HTTP_X_KOPOKOPO_SIGNATURE']
+  end
+end

data/lib/k2-connect-ruby/k2_services/payload_process.rb

@@ -0,0 +1,14 @@
+require 'k2-connect-ruby/k2_services/client/k2_client'
+
+require 'k2-connect-ruby/k2_services/payloads/k2_webhooks'
+require 'k2-connect-ruby/k2_services/payloads/webhooks/b2b_received'
+require 'k2-connect-ruby/k2_services/payloads/webhooks/m2m_transaction'
+require 'k2-connect-ruby/k2_services/payloads/webhooks/customer_created'
+require 'k2-connect-ruby/k2_services/payloads/webhooks/buygoods_received'
+require 'k2-connect-ruby/k2_services/payloads/webhooks/buygoods_reversal'
+require 'k2-connect-ruby/k2_services/payloads/webhooks/settlement_webhook'
+
+require 'k2-connect-ruby/k2_services/payloads/k2_transaction'
+require 'k2-connect-ruby/k2_services/payloads/transactions/transfer'
+require 'k2-connect-ruby/k2_services/payloads/transactions/incoming_payment'
+require 'k2-connect-ruby/k2_services/payloads/transactions/outgoing_payment'

data/lib/k2-connect-ruby/k2_services/payloads/k2_transaction.rb

@@ -0,0 +1,48 @@
+class K2Transaction
+  attr_reader :id,
+              :type,
+              :metadata,
+              :links_self,
+              :callback_url
+
+  def initialize(payload)
+    @id = payload.dig('data', 'id')
+    @type = payload.dig('data', 'type')
+    @metadata = payload.dig('data', 'attributes', 'metadata')
+    @links_self = payload.dig('data', 'attributes', '_links', 'self')
+    @callback_url = payload.dig('data', 'attributes', '_links', 'callback_url')
+  end
+end
+
+class CommonPayment < K2Transaction
+  include ActiveModel::Validations
+
+  attr_reader :status,
+              :initiation_time
+
+  validate :valid_payment_type
+
+  def initialize(payload)
+    super
+    @status = payload.dig('data', 'attributes', 'status')
+    @initiation_time = payload.dig('data', 'attributes', 'initiation_time') if @type.eql?('incoming_payment')
+  end
+
+  private
+
+  def valid_payment_type; end
+end
+
+class OutgoingTransaction < CommonPayment
+  attr_reader :created_at,
+              :transfer_batches,
+              :total_value
+
+  def initialize(payload)
+    super
+    @created_at = payload.dig('data', 'attributes', 'created_at')
+    @currency = payload.dig('data', 'attributes', 'amount', 'currency')
+    @total_value = payload.dig('data', 'attributes', 'amount', 'value')
+    @transfer_batches = payload.dig('data', 'attributes', 'transfer_batches')
+  end
+end

data/lib/k2-connect-ruby/k2_services/payloads/k2_webhooks.rb

@@ -0,0 +1,59 @@
+class Webhook
+  attr_reader :id,
+              :topic,
+              :created_at,
+              :links_self,
+              :event_type,
+              :links_resource,
+              :event_resource,
+              :resource_id
+
+  def initialize(payload)
+    @id = payload.dig('id')
+    @topic = payload.dig('topic')
+    @created_at = payload.dig('created_at')
+    # Event
+    @event_type = payload.dig('event', 'type')
+    @resource_id = payload.dig('event', 'resource', 'id') unless @event_type.eql?('Customer Created')
+    # Links
+    @links_self = payload.dig('_links', 'self')
+    @links_resource = payload.dig('_links', 'resource')
+  end
+end
+
+class K2CommonEvents < Webhook
+  REFERENCE_EXCEPTIONS = ["Merchant to Merchant Transaction", "Settlement Transfer"]
+
+  attr_reader :reference,
+  :origination_time,
+  :amount,
+  :currency,
+  :status
+
+  def initialize(payload)
+    super
+    @reference = payload.dig('event', 'resource', 'reference') unless REFERENCE_EXCEPTIONS.include?(@event_type)
+    @origination_time = payload.dig('event', 'resource', 'origination_time')
+    @amount = payload.dig('event', 'resource', 'amount')
+    @currency = payload.dig('event', 'resource', 'currency')
+    @status = payload.dig('event', 'resource', 'status')
+  end
+
+end
+
+class Buygoods < K2CommonEvents
+  attr_reader :system,
+              :till_number,
+              :sender_phone_number,
+              :sender_first_name,
+              :sender_last_name
+
+  def initialize(payload)
+    super
+    @system = payload.dig('event', 'resource', 'system')
+    @till_number = payload.dig('event', 'resource', 'till_number')
+    @sender_phone_number = payload.dig('event', 'resource', 'sender_phone_number')
+    @sender_first_name = payload.dig('event', 'resource', 'sender_first_name')
+    @sender_last_name = payload.dig('event', 'resource', 'sender_last_name')
+  end
+end

data/lib/k2-connect-ruby/k2_services/payloads/transactions/incoming_payment.rb

@@ -0,0 +1,46 @@
+class IncomingPayments < CommonPayment
+  attr_reader :event,
+              :event_type,
+              :transaction_reference,
+              :origination_time,
+              :sender_phone_number,
+              :amount,
+              :currency,
+              :till_number,
+              :system,
+              :resource_id,
+              :resource_status,
+              :sender_first_name,
+              :sender_middle_name,
+              :sender_last_name,
+              :errors
+
+  def initialize(payload)
+    super
+    # Event details
+    @event = payload.dig('data', 'attributes', 'event')
+    @event_type = payload.dig('data', 'attributes', 'event', 'type')
+    # Resource details
+    @resource_id = payload.dig('data', 'attributes', 'event', 'resource', 'id')
+    @transaction_reference = payload.dig('data', 'attributes', 'event', 'resource', 'reference')
+    @origination_time = payload.dig('data', 'attributes', 'event', 'resource', 'origination_time')
+    @sender_phone_number = payload.dig('data', 'attributes', 'event', 'resource', 'sender_phone_number')
+    @amount = payload.dig('data', 'attributes', 'event', 'resource', 'amount')
+    @currency = payload.dig('data', 'attributes', 'event', 'resource', 'currency')
+    @till_number = payload.dig('data', 'attributes', 'event', 'resource', 'till_number')
+    @system = payload.dig('data', 'attributes', 'event', 'resource', 'system')
+    @resource_status = payload.dig('data', 'attributes', 'event', 'resource', 'status')
+    @sender_first_name = payload.dig('data', 'attributes', 'event', 'resource', 'sender_first_name')
+    @sender_middle_name = payload.dig('data', 'attributes', 'event', 'resource', 'sender_middle_name')
+    @sender_last_name = payload.dig('data', 'attributes', 'event', 'resource', 'sender_last_name')
+    # Errors
+    @errors = payload.dig('data', 'attributes', 'event', 'errors')
+  end
+
+  private
+
+  def valid_payment_type
+    raise ArgumentError, "Wrong Payment Type" unless @type.eql?("incoming_payment")
+  end
+
+end

data/lib/k2-connect-ruby/k2_services/payloads/transactions/outgoing_payment.rb

@@ -0,0 +1,15 @@
+class OutgoingPayment < OutgoingTransaction
+  attr_reader :transaction_reference,
+              :destination
+
+  def initialize(payload)
+    super
+  end
+
+  private
+
+  def valid_payment_type
+    raise ArgumentError, "Wrong Payment Type" unless @type.eql?("payment")
+  end
+
+end

data/lib/k2-connect-ruby/k2_services/payloads/transactions/transfer.rb

@@ -0,0 +1,12 @@
+class Transfer < OutgoingTransaction
+
+  def initialize(payload)
+    super
+  end
+
+  private
+
+  def valid_payment_type
+    raise ArgumentError, "Wrong Payment Type" unless @type.eql?("settlement_transfer")
+  end
+end

data/lib/k2-connect-ruby/k2_services/payloads/webhooks/b2b_received.rb

@@ -0,0 +1,10 @@
+class B2b < K2CommonEvents
+  attr_reader :sending_till,
+              :till_number
+
+  def initialize(payload)
+    super
+    @till_number = payload.dig('event', 'resource', 'till_number')
+    @sending_till = payload.dig('event', 'resource', 'sending_till')
+  end
+end

data/lib/k2-connect-ruby/k2_services/payloads/webhooks/buygoods_received.rb

@@ -0,0 +1,5 @@
+class BuygoodsTransactionReceived < Buygoods
+  def initialize(payload)
+    super
+  end
+end

data/lib/k2-connect-ruby/k2_services/payloads/webhooks/buygoods_reversal.rb

@@ -0,0 +1,5 @@
+class BuygoodsTransactionReversed < Buygoods
+  def initialize(payload)
+    super
+  end
+end

data/lib/k2-connect-ruby/k2_services/payloads/webhooks/customer_created.rb

@@ -0,0 +1,14 @@
+class CustomerCreated < Webhook
+  attr_reader :resource_first_name,
+              :resource_middle_name,
+              :resource_last_name,
+              :resource_phone_number
+
+  def initialize(payload)
+    super
+    @resource_first_name = payload.dig('event', 'resource', 'first_name')
+    @resource_middle_name = payload.dig('event', 'resource', 'middle_name')
+    @resource_last_name = payload.dig('event', 'resource', 'last_name')
+    @resource_phone_number = payload.dig('event', 'resource', 'phone_number')
+  end
+end

data/lib/k2-connect-ruby/k2_services/payloads/webhooks/m2m_transaction.rb

@@ -0,0 +1,8 @@
+class MerchantToMerchant < K2CommonEvents
+  attr_reader :resource_sending_merchant
+
+  def initialize(payload)
+    super
+    @resource_sending_merchant = payload.dig('event', 'resource', 'sending_merchant')
+  end
+end

data/lib/k2-connect-ruby/k2_services/payloads/webhooks/settlement_webhook.rb

@@ -0,0 +1,36 @@
+class SettlementWebhook < K2CommonEvents
+  attr_reader :disbursements,
+              :destination_type,
+              :destination_network,
+              :destination_reference,
+              :destination_last_name,
+              :destination_first_name,
+              :destination_account_name,
+              :destination_phone_number,
+              :destination_account_number,
+              :destination_bank_branch_ref,
+              :destination_settlement_method
+
+  def initialize(payload)
+    super
+    # Destination
+    @disbursements = payload.dig('event', 'resource', 'disbursements')
+    @destination_type = payload.dig('event', 'resource', 'destination', 'type')
+    @destination_reference = payload.dig('event', 'resource', 'destination', 'resource', 'reference')
+    destination_assets(payload)
+  end
+
+  def destination_assets(payload)
+    if @destination_type.eql?('Mobile Wallet')
+      @destination_network = payload.dig('event', 'resource', 'destination', 'resource', 'network')
+      @destination_last_name = payload.dig('event', 'resource', 'destination', 'resource', 'last_name')
+      @destination_first_name = payload.dig('event', 'resource', 'destination', 'resource', 'first_name')
+      @destination_phone_number = payload.dig('event', 'resource', 'destination', 'resource', 'phone_number')
+    elsif @destination_type.eql?('Bank Account')
+      @destination_account_name = payload.dig('event', 'resource', 'destination', 'resource', 'account_name')
+      @destination_account_number = payload.dig('event', 'resource', 'destination', 'resource', 'account_number')
+      @destination_bank_branch_ref = payload.dig('event', 'resource', 'destination', 'resource', 'bank_branch_ref')
+      @destination_settlement_method = payload.dig('event', 'resource', 'destination', 'resource', 'settlement_method')
+    end
+  end
+end