k2-connect-ruby 2.0.0 → 3.0.0

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

@@ -1,42 +1,40 @@
-# Class for Subscription Service
-class K2Subscribe
-  include K2Validation, K2Utilities
-  attr_reader :location_url, :k2_response_body
-  attr_accessor :access_token, :webhook_secret
+module K2ConnectRuby
+  module K2Entity
+    class K2Subscribe
+      include K2ConnectRuby::K2Utilities::K2Validation, K2ConnectRuby::K2Utilities
+      attr_reader :location_url, :k2_response_body
+      attr_accessor :access_token, :webhook_secret
 
-  # Initialize with access token
-  def initialize(access_token)
-    raise ArgumentError, 'Nil or Empty Access Token Given!' if access_token.blank?
-    @threads = []
-    @access_token = access_token
-  end
+      # Initialize with access token
+      def initialize(access_token)
+        raise ArgumentError, 'Nil or Empty Access Token Given!' if access_token.blank?
+        @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
+      # 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(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('webhook_subscriptions'), 'post', @access_token,'Subscription', k2_request_body)
+        @location_url =  K2ConnectRuby::K2Utilities::K2Connection.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 Recent Webhook
+      def query_webhook(location_url = @location_url)
+        query_hash = make_hash(location_url, 'get', @access_token, 'Subscription', nil)
+        @k2_response_body = K2ConnectRuby::K2Utilities::K2Connection.make_request(query_hash)
+      end
 
-  # Query Specific Webhook URL
-  def query_resource_url(url)
-    query_webhook(url)
+      # Query Specific Webhook URL
+      def query_resource_url(url)
+        query_webhook(url)
+      end
+    end
   end
 end

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

@@ -1,63 +1,67 @@
-# Class for Gaining Access Token
-class K2AccessToken
-  attr_reader :access_token, :token_response
-
-  def initialize(client_id, client_secret)
-    validate_client_credentials(client_id, client_secret)
-    @client_id = client_id
-    @client_secret = client_secret
-  end
+module K2ConnectRuby
+  module K2Entity
+    class K2Token
+      attr_reader :access_token, :token_response
 
-  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 initialize(client_id, client_secret)
+        validate_client_credentials(client_id, client_secret)
+        @client_id = client_id
+        @client_secret = client_secret
+      end
 
-  def revoke_token(access_token)
-    token_params = {
-      client_id: @client_id,
-      client_secret: @client_secret,
-      token: access_token
-    }
-    token_hash = K2AccessToken.make_hash(K2Config.path_url('revoke_token'), 'post', 'Access Token', token_params)
-    @token_response = K2Connect.make_request(token_hash)
-  end
+      def request_token
+        token_params = {
+          client_id: @client_id,
+          client_secret: @client_secret,
+          grant_type: 'client_credentials'
+        }
+        token_hash = K2ConnectRuby::K2Entity::K2Token.make_hash(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('oauth_token'), 'post', 'Access Token', token_params)
+        @access_token = K2ConnectRuby::K2Utilities::K2Connection.make_request(token_hash)
+      end
 
-  def introspect_token(access_token)
-    token_params = {
-      client_id: @client_id,
-      client_secret: @client_secret,
-      token: access_token
-    }
-    token_hash = K2AccessToken.make_hash(K2Config.path_url('introspect_token'), 'post', 'Access Token', token_params)
-    @token_response = K2Connect.make_request(token_hash)
-  end
+      def revoke_token(access_token)
+        token_params = {
+          client_id: @client_id,
+          client_secret: @client_secret,
+          token: access_token
+        }
+        token_hash = K2ConnectRuby::K2Entity::K2Token.make_hash(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('revoke_token'), 'post', 'Access Token', token_params)
+        @token_response = K2ConnectRuby::K2Utilities::K2Connection.make_request(token_hash)
+      end
 
-  def token_info(access_token)
-    token_hash = K2AccessToken.make_hash(K2Config.path_url('token_info'), 'get', 'Access Token', nil)
+      def introspect_token(access_token)
+        token_params = {
+          client_id: @client_id,
+          client_secret: @client_secret,
+          token: access_token
+        }
+        token_hash = K2ConnectRuby::K2Entity::K2Token.make_hash(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('introspect_token'), 'post', 'Access Token', token_params)
+        @token_response = K2ConnectRuby::K2Utilities::K2Connection.make_request(token_hash)
+      end
 
-    token_hash[:access_token] = access_token
-    @token_response = K2Connect.make_request(token_hash)
-  end
+      def token_info(access_token)
+        token_hash = K2ConnectRuby::K2Entity::K2Token.make_hash(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('token_info'), 'get', 'Access Token', nil, false)
 
-  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
+        token_hash[:access_token] = access_token
+        @token_response = K2ConnectRuby::K2Utilities::K2Connection.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
+      class << K2ConnectRuby::K2Entity::K2Token
+        # Create a Hash containing important details accessible for K2Connect
+        def make_hash(path_url, request, class_type, body, requires_token = true)
+          {
+            path_url: path_url,
+            request_type: request,
+            class_type: class_type,
+            requires_token: requires_token,
+            params: body
+          }.with_indifferent_access
+        end
+      end
     end
   end
-end
+end

data/lib/k2-connect-ruby/k2_errors.rb

@@ -1,77 +1,79 @@
-# Standard K2Error
-class K2Errors < StandardError
-  attr_reader :status, :message
-  def initialize(msg = @message)
-    super(msg)
+module K2ConnectRuby
+  # Standard K2Error
+  class K2Errors < StandardError
+    attr_reader :status, :message
+    def initialize(msg = @message)
+      super(msg)
+    end
   end
-end
 
-# For errors concerning the Status code returned from Kopo Kopo
-class K2ConnectionError < K2Errors
-  def initialize(error)
-    @error = error
-  end
+  # For errors concerning the Status code returned from Kopo Kopo
+  class K2ConnectionError < K2Errors
+    def initialize(error)
+      @error = error
+    end
 
-  def message
-    case @error
-    when 400.to_s
-      STDERR.puts "Bad Request.\n\tYour request is Invalid"
-    when 401.to_s
-      STDERR.puts "Unauthorized.\n Your API key is wrong"
-    when 403.to_s
-      STDERR.puts "Forbidden.\n The resource requested cannot be accessed"
-    when 404.to_s
-      STDERR.puts "Not Found.\n\tThe specified resource could not be found"
-    when 405.to_s
-      STDERR.puts "Method Not Allowed.\n You tried to access a resource with an invalid method"
-    when 406.to_s
-      STDERR.puts "Not Acceptable.\n You requested a format that isn't valid json"
-    when 410.to_s
-      STDERR.puts "Gone.\n The resource requested has been moved"
-    when 429.to_s
-      STDERR.puts "Too Many Requests.\n Request threshold has been exceeded"
-    when 500.to_s
-      STDERR.puts "Internal Server Error.\n We had a problem with our server. Try again later"
-    when 503.to_s
-      STDERR.puts "Service Unavailable.\n We're temporarily offline for maintenance. Please try again later"
-    else
-      STDERR.puts 'Undefined Kopo Kopo Server Response.'
+    def message
+      case @error
+      when 400.to_s
+        STDERR.puts("Bad Request.\n\tYour request is Invalid")
+      when 401.to_s
+        STDERR.puts("Unauthorized.\n Your API key is wrong")
+      when 403.to_s
+        STDERR.puts("Forbidden.\n The resource requested cannot be accessed")
+      when 404.to_s
+        STDERR.puts("Not Found.\n\tThe specified resource could not be found")
+      when 405.to_s
+        STDERR.puts("Method Not Allowed.\n You tried to access a resource with an invalid method")
+      when 406.to_s
+        STDERR.puts("Not Acceptable.\n You requested a format that isn't valid json")
+      when 410.to_s
+        STDERR.puts("Gone.\n The resource requested has been moved")
+      when 429.to_s
+        STDERR.puts("Too Many Requests.\n Request threshold has been exceeded")
+      when 500.to_s
+        STDERR.puts("Internal Server Error.\n We had a problem with our server. Try again later")
+      when 503.to_s
+        STDERR.puts("Service Unavailable.\n We're temporarily offline for maintenance. Please try again later")
+      else
+        STDERR.puts("Undefined Kopo Kopo Server Response.")
+      end
     end
   end
-end
 
-# Errors concerning the Validation module
-class K2ValidateErrors < K2Errors
-  attr_reader :the_keys
+  # Errors concerning the Validation module
+  class K2ValidateErrors < K2Errors
+    attr_reader :the_keys
 
-  def initialize(the_keys)
-    super
-    @the_keys = the_keys
-    @status = :bad_request
-  end
+    def initialize(the_keys)
+      super
+      @the_keys = the_keys
+      @status = :bad_request
+    end
 
-  def loop_keys
-    STDERR.puts @message
-    @the_keys.each(&method(:puts))
-  end
+    def loop_keys
+      STDERR.puts @message
+      @the_keys.each(&method(:puts))
+    end
 
-  def message
-    loop_keys
+    def message
+      loop_keys
+    end
   end
-end
 
-# Hash / Params has Empty Values within it
-class K2EmptyParams < K2ValidateErrors
-  def initialize(the_keys)
-    @message = "Invalid Hash Object!\n The Following Parameter(s) are Empty: "
-    super
+  # Hash / Params has Empty Values within it
+  class K2EmptyParams < K2ValidateErrors
+    def initialize(the_keys)
+      @message = "Invalid Hash Object!\n The Following Parameter(s) are Empty: "
+      super
+    end
   end
-end
 
-# Error for Incorrect Hash Key Symbols (K2Entity validate => input)
-class K2IncorrectParams < K2ValidateErrors
-  def initialize(the_keys)
-    @message = "Incorrect Hash/Parameters Object!\n The Following Parameter(s) are Incorrect: "
-    super
+  # Error for Incorrect Hash Key Symbols (K2Entity validate => input)
+  class K2IncorrectParams < K2ValidateErrors
+    def initialize(the_keys)
+      @message = "Incorrect Hash/Parameters Object!\n The Following Parameter(s) are Incorrect: "
+      super
+    end
   end
 end

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

@@ -0,0 +1,27 @@
+module K2ConnectRuby
+  module K2Services
+    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 = JSON.parse(the_request.body.read)
+        # The Response Header
+        hash_header = JSON.parse(the_request.env.select { |k, _| k =~ /^HTTP_/ }.to_json)
+        # The K2 Signature
+        @k2_signature = hash_header['HTTP_X_KOPOKOPO_SIGNATURE']
+      end
+    end
+  end
+end

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

@@ -1,14 +1,19 @@
-require 'k2-connect-ruby/k2_services/client/k2_client'
+require 'k2-connect-ruby/k2_services/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/b2b_transaction_received'
 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/buygoods_transaction_received'
+require 'k2-connect-ruby/k2_services/payloads/webhooks/buygoods_transaction_reversed'
 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'
+
+module K2ConnectRuby
+  module K2Services
+    module PayloadProcess; end
+  end
+end

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

@@ -1,48 +1,54 @@
-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')
+module K2ConnectRuby
+  module K2Services
+    module Payloads
+      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
+    end
   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

@@ -1,59 +1,65 @@
-class Webhook
-  attr_reader :id,
-              :topic,
-              :created_at,
-              :links_self,
-              :event_type,
-              :links_resource,
-              :event_resource,
-              :resource_id
+module K2ConnectRuby
+  module K2Services
+    module Payloads
+      class K2Webhooks
+        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
+        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"]
+      class K2CommonEvents < K2Webhooks
+        REFERENCE_EXCEPTIONS = ["Merchant to Merchant Transaction", "Settlement Transfer"]
 
-  attr_reader :reference,
-  :origination_time,
-  :amount,
-  :currency,
-  :status
+        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
+        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
+      end
 
-class Buygoods < K2CommonEvents
-  attr_reader :system,
-              :till_number,
-              :sender_phone_number,
-              :sender_first_name,
-              :sender_last_name
+      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')
+        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
+    end
   end
-end
+end