k2-connect-ruby 2.0.0 → 3.0.0

data/lib/k2-connect-ruby/k2_utilities/k2_process_webhook.rb

@@ -1,55 +1,56 @@
-# Processes Webhook
-module K2ProcessWebhook
-  def self.process(payload, secret_key, signature)
-    raise ArgumentError, 'Empty/Nil Request Body Argument!' if payload.blank?
-    self.check_topic(payload) if K2Authenticator.authenticate(payload, secret_key, signature)
-  end
+module K2ConnectRuby
+  module K2Utilities
+    module K2ProcessWebhook
+      extend self
 
-  def self.check_topic(payload)
-    result_topic = payload.dig('topic')
-    case result_topic
-      # Buygoods Transaction Received
-    when 'buygoods_transaction_received'
-      buygoods_received = BuygoodsTransactionReceived.new(payload)
-      return buygoods_received
-      # Buygoods Transaction Reversed
-    when 'buygoods_transaction_reversed'
-      buygoods_reversed = BuygoodsTransactionReversed.new(payload)
-      return buygoods_reversed
-      # B2b Transaction
-    when 'b2b_transaction_received'
-      b2b_transaction = B2b.new(payload)
-      return b2b_transaction
-      # Merchant to Merchant
-    when 'm2m_transaction_received'
-      m2m_transaction_received = MerchantToMerchant.new(payload)
-      return m2m_transaction_received
-      # Settlement Transfer
-    when 'settlement_transfer_completed'
-      settlement_transfer = SettlementWebhook.new(payload)
-      return settlement_transfer
-      # Customer Created
-    when 'customer_created'
-      customer_created = CustomerCreated.new(payload)
-      return customer_created
-    else
-      raise ArgumentError, 'No Other Specified Event!'
-    end
-  end
+      def process(payload, secret_key, signature)
+        raise ArgumentError, 'Empty/Nil Request Body Argument!' if payload.blank?
+        check_topic(payload) if K2ConnectRuby::K2Utilities::K2Authenticator.authenticate(payload, secret_key, signature)
+      end
 
-  # Returns a Hash Object
-  def self.return_obj_hash(instance_hash = HashWithIndifferentAccess.new, obj)
-    obj.instance_variables.each do |value|
-      instance_hash[:"#{value.to_s.tr('@', '')}"] = obj.instance_variable_get(value)
-    end
-    instance_hash.each(&:freeze).freeze
-  end
+      def check_topic(payload)
+        result_topic = payload.dig('topic')
+        case result_topic
+          # Buygoods Transaction Received
+        when 'buygoods_transaction_received'
+          buygoods_received = K2ConnectRuby::K2Services::Payloads::Webhooks::BuygoodsTransactionReceived.new(payload)
+          return buygoods_received
+          # Buygoods Transaction Reversed
+        when 'buygoods_transaction_reversed'
+          buygoods_reversed = K2ConnectRuby::K2Services::Payloads::Webhooks::BuygoodsTransactionReversed.new(payload)
+          return buygoods_reversed
+          # B2b Transaction
+        when 'b2b_transaction_received'
+          b2b_transaction = K2ConnectRuby::K2Services::Payloads::Webhooks::B2bTransactionReceived.new(payload)
+          return b2b_transaction
+          # Settlement Transfer
+        when 'settlement_transfer_completed'
+          settlement_transfer = K2ConnectRuby::K2Services::Payloads::Webhooks::SettlementWebhook.new(payload)
+          return settlement_transfer
+          # Customer Created
+        when 'customer_created'
+          customer_created = K2ConnectRuby::K2Services::Payloads::Webhooks::CustomerCreated.new(payload)
+          return customer_created
+        else
+          raise ArgumentError, 'No Other Specified Event!'
+        end
+      end
+
+      # Returns a Hash Object
+      def return_obj_hash(instance_hash = HashWithIndifferentAccess.new, obj)
+        obj.instance_variables.each do |value|
+          instance_hash[:"#{value.to_s.tr('@', '')}"] = obj.instance_variable_get(value)
+        end
+        instance_hash.each(&:freeze).freeze
+      end
 
-  # Returns an Array Object
-  def self.return_obj_array(instance_array = [], obj)
-    obj.instance_variables.each do |value|
-      instance_array << obj.instance_variable_get(value)
+      # Returns an Array Object
+      def return_obj_array(instance_array = [], obj)
+        obj.instance_variables.each do |value|
+          instance_array << obj.instance_variable_get(value)
+        end
+        instance_array.each(&:freeze).freeze
+      end
     end
-    instance_array.each(&:freeze).freeze
   end
-end
+end

data/lib/k2-connect-ruby/k2_utilities/k2_url_parse.rb

@@ -1,7 +1,12 @@
-# Module for dealing with Parsing URLS properly
-module K2UrlParse
-  def self.remove_localhost(url)
-    url.host = '127.0.0.1' if url.host.eql?('localhost')
-    url
+module K2ConnectRuby
+  module K2Utilities
+    module K2UrlParse
+      extend self
+
+      def remove_localhost(url)
+        url.host = '127.0.0.1' if url.host.eql?('localhost')
+        url
+      end
+    end
   end
-end
+end

data/lib/k2-connect-ruby/k2_utilities/k2_validation.rb

@@ -1,126 +1,128 @@
-# Module for Validating Input
-# TODO: Correct validation of url so that it only accepts https
-module K2Validation
-  ALL_EVENT_TYPES = %[buygoods_transaction_received b2b_transaction_received buygoods_transaction_reversed customer_created settlement_transfer_completed m2m_transaction_received]
-  TILL_SCOPE_EVENT_TYPES = %[buygoods_transaction_received b2b_transaction_received buygoods_transaction_reversed]
+module K2ConnectRuby
+  module K2Utilities
+    module K2Validation
+      ALL_EVENT_TYPES = %[buygoods_transaction_received b2b_transaction_received buygoods_transaction_reversed customer_created settlement_transfer_completed]
+      TILL_SCOPE_EVENT_TYPES = %[buygoods_transaction_received b2b_transaction_received buygoods_transaction_reversed]
 
-  # Validating Method
-  def validate_input(the_input, the_array)
-    if the_input.blank?
-      raise ArgumentError, "Empty or Nil Input!\n No Input Content has been given."
-    else
-      unless !!the_input == the_input
-        if the_input.is_a?(Hash)
-          validate_hash(the_input.with_indifferent_access, the_array)
+      # Validating Method
+      def validate_input(the_input, the_array)
+        if the_input.blank?
+          raise ArgumentError, "Empty or Nil Input!\n No Input Content has been given."
         else
-          begin
-            if the_input.is_a?(String)
-              raise ArgumentError, "Wrong Input Format.\n The Input is a String."
-            elsif the_input.is_a?(Integer)
-              raise ArgumentError, "Wrong Input Format.\n The Input is an Integer."
-            elsif the_input.key?(:authenticity_token)
-              nil_values(the_input.permit(the_array).to_hash.with_indifferent_access)
+          unless !!the_input == the_input
+            if the_input.is_a?(Hash)
+              validate_hash(the_input.with_indifferent_access, the_array)
             else
-              raise ArgumentError, "Undefined Input Format.\n The Input is Neither a Hash nor an ActionController::Parameter Object."
-            end
-          rescue NoMethodError => nme
-            if nme.message.include?('has_key?')
-              raise ArgumentError, "Undefined Input Format.\n The Input is Neither a Hash nor an ActionController::Parameter Object."
+              begin
+                if the_input.is_a?(String)
+                  raise ArgumentError, "Wrong Input Format.\n The Input is a String."
+                elsif the_input.is_a?(Integer)
+                  raise ArgumentError, "Wrong Input Format.\n The Input is an Integer."
+                elsif the_input.key?(:authenticity_token)
+                  nil_values(the_input.permit(the_array).to_hash.with_indifferent_access)
+                else
+                  raise ArgumentError, "Undefined Input Format.\n The Input is Neither a Hash nor an ActionController::Parameter Object."
+                end
+              rescue NoMethodError => nme
+                if nme.message.include?('has_key?')
+                  raise ArgumentError, "Undefined Input Format.\n The Input is Neither a Hash nor an ActionController::Parameter Object."
+                end
+              end
             end
           end
         end
+        to_indifferent_access(the_input)
       end
-    end
-    to_indifferent_access(the_input)
-  end
 
-  # Validate the Hash Input Parameters
-  def validate_hash(the_input, the_array)
-    nil_values(the_input)
-    incorrect_keys(the_input, the_array)
-  end
+      # Validate the Hash Input Parameters
+      def validate_hash(the_input, the_array)
+        nil_values(the_input)
+        incorrect_keys(the_input, the_array)
+      end
 
-  # Return Incorrect Key Symbols for Hashes
-  def incorrect_keys(the_input, invalid_hash = [], the_array)
-    the_input.each_key do |key|
-      validate_network(the_input[:network]) if key.eql?("network")
-      validate_settlement_method(the_input[:settlement_method]) if key.eql?("settlement_method")
-      invalid_hash << key unless the_array.include?(key.to_s)
-    end
-    raise K2IncorrectParams, invalid_hash if invalid_hash.present?
-  end
+      # Return Incorrect Key Symbols for Hashes
+      def incorrect_keys(the_input, invalid_hash = [], the_array)
+        the_input.each_key do |key|
+          validate_network(the_input[:network]) if key.eql?("network")
+          validate_settlement_method(the_input[:settlement_method]) if key.eql?("settlement_method")
+          invalid_hash << key unless the_array.include?(key.to_s)
+        end
+        raise K2IncorrectParams, invalid_hash if invalid_hash.present?
+      end
 
-  # Return Key Symbols with Blank Values
-  def nil_values(the_input, nil_keys_array = [])
-    the_input.select { |_, v| v.blank? }.each_key do |key|
-      nil_keys_array << key.to_s
-    end
-    raise K2EmptyParams, nil_keys_array unless nil_keys_array.blank?
-  end
+      # Return Key Symbols with Blank Values
+      def nil_values(the_input, nil_keys_array = [])
+        the_input.select { |_, v| v.blank? }.each_key do |key|
+          nil_keys_array << key.to_s
+        end
+        raise K2EmptyParams, nil_keys_array unless nil_keys_array.blank?
+      end
 
-  # Validate Phone Number
-  def validate_phone(phone)
-    raise ArgumentError, "No Phone Number given." if phone.blank?
-    # Kenyan Phone Numbers
-    unless phone.blank?
-      if phone[-(number = phone.to_i.to_s.size).to_i, 3].eql?(254.to_s)
-        raise ArgumentError, 'Invalid Kenyan Phone Number.' unless phone[-9, 9][0].eql?(7.to_s)
-      else
-        raise ArgumentError, 'Invalid Phone Number.' unless number.eql?(9)
+      # Validate Phone Number
+      def validate_phone(phone)
+        raise ArgumentError, "No Phone Number given." if phone.blank?
+        # Kenyan Phone Numbers
+        unless phone.blank?
+          if phone[-(number = phone.to_i.to_s.size).to_i, 3].eql?(254.to_s)
+            raise ArgumentError, 'Invalid Kenyan Phone Number.' unless phone[-9, 9][0].eql?(7.to_s)
+          else
+            raise ArgumentError, 'Invalid Phone Number.' unless number.eql?(9)
+          end
+          phone.tr('+', '')
+        end
       end
-      phone.tr('+', '')
-    end
-  end
 
-  # Validate Email Format
-  def validate_email(email)
-    unless email.blank?
-      raise ArgumentError, 'Invalid Email Address.' unless email.match(URI::MailTo::EMAIL_REGEXP).present?
-    end
-    email
-  end
+      # Validate Email Format
+      def validate_email(email)
+        unless email.blank?
+          raise ArgumentError, 'Invalid Email Address.' unless email.match(URI::MailTo::EMAIL_REGEXP).present?
+        end
+        email
+      end
 
-  # Validate the Network Operator
-  def validate_network(network)
-    raise ArgumentError, "Invalid Network Operator." unless K2Config.network_operators.include?(network.to_s.upcase)
-  end
+      # Validate the Network Operator
+      def validate_network(network)
+        raise ArgumentError, "Invalid Network Operator." unless K2ConnectRuby::K2Utilities::Config::K2Config.network_operators.include?(network.to_s.upcase)
+      end
 
-  def validate_settlement_method(settlement_method)
-    raise ArgumentError, "Wrong Settlement Method" unless settlement_method.eql?("EFT") || settlement_method.eql?("RTS")
-  end
+      def validate_settlement_method(settlement_method)
+        raise ArgumentError, "Wrong Settlement Method" unless settlement_method.eql?("EFT") || settlement_method.eql?("RTS")
+      end
 
-  # Converts Hash Objects to HashWithIndifferentAccess Objects
-  def to_indifferent_access(params)
-    params.with_indifferent_access
-  end
+      # Converts Hash Objects to HashWithIndifferentAccess Objects
+      def to_indifferent_access(params)
+        params.with_indifferent_access
+      end
 
-  def validate_url(url)
-    raise ArgumentError, 'Invalid URL Format.' unless url =~ /\A#{URI.regexp(%w[https http])}\z/
-    url
-  end
+      def validate_url(url)
+        raise ArgumentError, 'Invalid URL Format.' unless url =~ /\A#{URI.regexp(%w[https http])}\z/
+        url
+      end
 
-  def validate_till_number_prefix(till_number)
-    raise ArgumentError, "No Till Number given." if till_number.blank?
-    raise ArgumentError, "Invalid Till Number format." unless till_number[0, 1].eql?('K')
-    till_number
-  end
+      def validate_till_number_prefix(till_number)
+        raise ArgumentError, "No Till Number given." if till_number.blank?
+        raise ArgumentError, "Invalid Till Number format." unless till_number[0, 1].eql?('K')
+        till_number
+      end
 
-  def validate_webhook(params)
-    raise ArgumentError, 'Subscription Service does not Exist!' unless params[:event_type].in?(ALL_EVENT_TYPES)
-    determine_scope_details(params)
-  end
+      def validate_webhook(params)
+        raise ArgumentError, 'Subscription Service does not Exist!' unless params[:event_type].in?(ALL_EVENT_TYPES)
+        determine_scope_details(params)
+      end
 
-  def validate_webhook_input(params)
-    if params[:event_type].in?(TILL_SCOPE_EVENT_TYPES)
-      validate_input(params, %w[event_type scope scope_reference url])
-    else
-      validate_input(params.except(:scope_reference), %w[event_type scope url])
-    end
-  end
+      def validate_webhook_input(params)
+        if params[:event_type].in?(TILL_SCOPE_EVENT_TYPES)
+          validate_input(params, %w[event_type scope scope_reference url])
+        else
+          validate_input(params.except(:scope_reference), %w[event_type scope url])
+        end
+      end
 
-  def determine_scope_details(params)
-    if params[:scope].eql?('till')
-      raise ArgumentError, "Invalid scope till for the event type" unless params[:event_type].in?(TILL_SCOPE_EVENT_TYPES)
+      def determine_scope_details(params)
+        if params[:scope].eql?('till')
+          raise ArgumentError, "Invalid scope till for the event type" unless params[:event_type].in?(TILL_SCOPE_EVENT_TYPES)
+        end
+      end
     end
   end
 end

data/lib/k2-connect-ruby/{utilities.rb → k2_utilities.rb}

@@ -1,22 +1,22 @@
 require 'k2-connect-ruby/k2_utilities/k2_url_parse'
-require 'k2-connect-ruby/k2_utilities/k2_authorize'
+require 'k2-connect-ruby/k2_utilities/k2_authenticator'
 require 'k2-connect-ruby/k2_utilities/k2_connection'
 require 'k2-connect-ruby/k2_utilities/k2_validation'
 require 'k2-connect-ruby/k2_utilities/config/k2_config'
 require 'k2-connect-ruby/k2_utilities/k2_process_result'
 require 'k2-connect-ruby/k2_utilities/k2_process_webhook'
 
-# For Stub Requests
-require 'k2-connect-ruby/k2_utilities/spec_modules/spec_config'
-
-module K2Utilities
-  def make_hash(path_url, request, access_token, class_type, body)
-    {
+module K2ConnectRuby
+  module K2Utilities
+    def make_hash(path_url, request, access_token, class_type, body, requires_token = true)
+      {
         path_url: path_url,
         access_token: access_token,
         request_type: request,
+        requires_token: requires_token,
         class_type: class_type,
         params: body
-    }.with_indifferent_access
+      }.with_indifferent_access
+    end
   end
 end

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

@@ -1,3 +1,3 @@
 module K2ConnectRuby
-  VERSION = '2.0.0'
+  VERSION = "3.0.0"
 end

data/lib/k2-connect-ruby.rb

@@ -1,34 +1,16 @@
-# Base
-require 'k2-connect-ruby/k2_errors'
-require 'k2-connect-ruby/version'
 require 'active_model'
 require 'active_support/json'
-# For the blank? check
 require 'active_support/dependencies/autoload'
 require 'active_support/core_ext'
-
-# Utilities
-require 'k2-connect-ruby/utilities'
-
-# Services
-require 'k2-connect-ruby/k2_services/payload_process'
-
-# Entity
-require 'k2-connect-ruby/k2_entity/k2_entity'
-require 'k2-connect-ruby/k2_entity/entity'
-
-# ActiveSupport
 require 'active_support/core_ext/hash/indifferent_access'
-
-# YAJL
-require 'yajl'
-
-# YAML
 require 'yaml'
-
-# Rest Client
 require 'rest-client'
-
-# JSON
 require 'json'
 
+require 'k2-connect-ruby/k2_utilities'
+require 'k2-connect-ruby/k2_services/payload_process'
+require 'k2-connect-ruby/entity'
+require 'k2-connect-ruby/k2_errors'
+require 'k2-connect-ruby/version'
+
+module K2ConnectRuby; end