k2-connect-ruby 3.0.0 → 4.0.0

data/lib/k2-connect-ruby/k2_utilities/config/k2_config.rb

@@ -1,51 +1,43 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Utilities
     module Config
       module K2Config
-        @config = YAML.load_file(File.join(File.dirname(__FILE__), 'k2_config.yml'), permitted_classes: [ActiveSupport::HashWithIndifferentAccess]).with_indifferent_access
+        @config = YAML.load_file(
+          File.join(File.dirname(__FILE__), "k2_config.yml"), permitted_classes: [ActiveSupport::HashWithIndifferentAccess]
+        ).with_indifferent_access
 
         class << self
           # Set the Host Url
-          def set_base_url(base_url)
-            raise ArgumentError, 'Invalid URL Format.' unless base_url =~ /\A#{URI.regexp(%w[http https])}\z/
+          def base_url=(base_url)
+            raise(ArgumentError, "Invalid URL Format.") unless base_url =~ /\A#{URI.regexp(["http", "https"])}\z/
+
             @config[:base_url] = base_url
-            File.open(File.join(File.dirname(__FILE__), 'k2_config.yml'), 'w') { |f| YAML.dump(@config, f) }
+            File.open(File.join(File.dirname(__FILE__), "k2_config.yml"), "w") { |f| YAML.dump(@config, f) }
           end
 
-          def set_version(version_number)
-            raise ArgumentError, 'Invalid Format: Version Number input should be Numeric' unless version_number.is_a?(Numeric)
-            @config[:version] = "v#{version_number}"
-            File.open(File.join(File.dirname(__FILE__), 'k2_config.yml'), 'w') { |f| YAML.dump(@config, f) }
+          def base_url
+            @config[:base_url]
           end
 
-          def version
-            @config[:version]
+          def endpoints
+            @config[:endpoints]
           end
 
-          def path_endpoint(key)
-            unless key.include?('token')
-              return "api/#{version}/#{@config[:endpoints][:"#{key}"]}"
-            end
-            @config[:endpoints][:"#{key}"]
+          def endpoint(key)
+            base_url + path(key)
           end
 
-          def path_endpoints
-            @config[:endpoints]
-          end
+          def path(key)
+            return @config[:endpoints][:"#{key}"].to_s unless key.include?("token")
 
-          def path_url(key)
-            base_url + path_endpoint(key)
+            @config[:endpoints][:"#{key}"]
           end
 
           def network_operators
             @config[:network_operators]
           end
-
-          private
-
-          def base_url
-            @config[:base_url]
-          end
         end
 
       end

data/lib/k2-connect-ruby/k2_utilities/config/k2_config.yml

@@ -1,19 +1,18 @@
 --- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-version: v1
 base_url: https://sandbox.kopokopo.com/
 endpoints: !ruby/hash:ActiveSupport::HashWithIndifferentAccess
   oauth_token: oauth/token
   revoke_token: oauth/revoke
   introspect_token: oauth/introspect
   token_info: oauth/token/info
-  webhook_subscriptions: webhook_subscriptions
-  pay_recipient: pay_recipients
-  payments: payments
-  incoming_payments: incoming_payments
-  settlement_mobile_wallet: merchant_wallets
-  settlement_bank_account: merchant_bank_accounts
-  transfers: settlement_transfers
-  poll: polling
-  transaction_sms_notifications: transaction_sms_notifications
+  webhook_subscriptions: api/v2/webhook_subscriptions
+  external_recipient: api/v2/external_recipients
+  send_money: api/v2/send_money
+  incoming_payments: api/v2/incoming_payments
+  reversals: api/v2/reversals
+  payment_links: "/api/v2/payment_links"
+  settlement_mobile_wallet: api/v2/merchant_wallets
+  settlement_bank_account: api/v2/merchant_bank_accounts
+  poll: api/v2/polling
 network_operators:
 - SAFARICOM

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

@@ -1,5 +1,7 @@
-require 'openssl'
-require 'active_support/security_utils'
+# frozen_string_literal: true
+
+require "openssl"
+require "active_support/security_utils"
 
 module K2ConnectRuby
   module K2Utilities
@@ -7,11 +9,16 @@ module K2ConnectRuby
       extend self
 
       def authenticate(body, api_secret_key, signature)
-        raise ArgumentError, "Nil Authentication Argument!\n Check whether your Input is Empty" if body.blank? || api_secret_key.blank? || signature.blank?
+        if body.blank? || api_secret_key.blank? || signature.blank?
+          raise ArgumentError, "Nil Authentication Argument!\n Check whether your Input is Empty"
+        end
 
-        digest = OpenSSL::Digest.new('sha256')
+        digest = OpenSSL::Digest.new("sha256")
         hmac = OpenSSL::HMAC.hexdigest(digest, api_secret_key, body.to_json)
-        raise ArgumentError, "Invalid Details Given!\n Ensure that your the Arguments Given are correct, namely:\n\t- The Response Body\n\t- Secret Key\n\t- Signature" unless ActiveSupport::SecurityUtils.secure_compare(hmac, signature)
+        unless ActiveSupport::SecurityUtils.secure_compare(hmac, signature)
+          raise ArgumentError, "Invalid Details Given!\n Ensure that your the Arguments Given are correct, namely:\n\t- The Response Body\n\t- Secret Key\n\t- Signature"
+        end
+
         true
       end
     end

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

@@ -1,48 +0,0 @@
-module K2ConnectRuby
-  module K2Utilities
-    module K2Connection
-      extend self
-      # Method for sending the request to K2 sandbox or Mock Server
-      def make_request(connection_hash)
-        access_token = connection_hash[:access_token]
-        class_type = connection_hash[:class_type]
-        path_url = connection_hash[:path_url]
-        request_type = connection_hash[:request_type]
-        requires_token = connection_hash[:requires_token]
-
-        unless class_type.eql?('Access Token') || access_token.present?
-          raise ArgumentError, 'No Access Token in Arguments!'
-        end
-
-        # Set up Headers
-        headers = if requires_token
-          { 'Content-Type': 'application/json', Accept: 'application/json', Authorization: "Bearer #{access_token}" }
-        else
-          { 'Content-Type': 'application/json' }
-        end
-
-        k2_response = RestClient::Request.execute(
-          method: request_type,
-          url: path_url,
-          headers: headers,
-          payload: connection_hash[:params].to_json
-        )
-
-        # Response Body
-        response_body = JSON.parse(k2_response.body, symbolize_names: true) if k2_response.body.present?
-        response_headers = JSON.parse(k2_response.headers.to_json, symbolize_names: true)
-        response_code = k2_response.code.to_s
-        raise K2ConnectRuby::K2ConnectionError.new(response_code) unless response_code.starts_with?("2")
-
-        if request_type.eql?('get')
-          response_body
-        else
-          # Returns the access token for authorization
-          return response_body[:access_token] if path_url.include?('oauth/token')
-
-          response_headers[:location]
-        end
-      end
-    end
-  end
-end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Utilities
+    module K2ConnectionHelper
+      extend self
+
+      def rest_client_error(ex)
+        ex.response.present? ? JSON.parse(ex.response.body) : {}
+      end
+
+      def response_headers(headers)
+        headers.blank? ? {} : JSON.parse(headers.to_json, symbolize_names: true)
+      end
+
+      def response_body(body)
+        body.blank? ? {} : JSON.parse(body, symbolize_names: true)
+      end
+    end
+  end
+end

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

@@ -1,35 +1,36 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Utilities
     module K2ProcessResult
       extend self
 
       def process(payload, secret_key, signature)
-        raise ArgumentError, 'Empty/Nil Request Body Argument!' if payload.blank?
+        raise ArgumentError, "Empty/Nil Request Body Argument!" if payload.blank?
+
         check_type(payload) if K2ConnectRuby::K2Utilities::K2Authenticator.authenticate(payload, secret_key, signature)
       end
 
       # Check the Event Type.
       def check_type(payload)
-        result_type = payload.dig('data', 'type')
+        result_type = payload.dig("data", "type")
         case result_type
           # Incoming Payments
-        when 'incoming_payment'
-          incoming_payments = K2ConnectRuby::K2Services::Payloads::Transactions::IncomingPayment.new(payload)
-          return incoming_payments
-          # Outgoing Payments
-        when 'payment'
-          outgoing_payments = K2ConnectRuby::K2Services::Payloads::Transactions::OutgoingPayment.new(payload)
-          return outgoing_payments
-        when 'settlement_transfer'
-          transfer = K2ConnectRuby::K2Services::Payloads::Transactions::Transfer.new(payload)
-          return transfer
+        when "incoming_payment"
+          K2ConnectRuby::K2Services::Payloads::Transactions::IncomingPayment.new(payload)
+        when "send_money"
+          K2ConnectRuby::K2Services::Payloads::Transactions::SendMoneyPayment.new(payload)
+        when "reversal"
+          K2ConnectRuby::K2Services::Payloads::Transactions::Reversal.new(payload)
+        when "payment_link"
+          K2ConnectRuby::K2Services::Payloads::Transactions::PaymentLink.new(payload)
         else
-          raise ArgumentError, 'No Other Specified Payment Type!'
+          raise ArgumentError, "No Other Specified Payment Type!"
         end
       end
 
       # Returns a Hash Object
-      def return_obj_hash(instance_hash = HashWithIndifferentAccess.new, obj)
+      def return_obj_hash(obj, instance_hash = HashWithIndifferentAccess.new)
         obj.instance_variables.each do |value|
           instance_hash[:"#{value.to_s.tr('@', '')}"] = obj.instance_variable_get(value)
         end
@@ -37,7 +38,7 @@ module K2ConnectRuby
       end
 
       # Returns an Array Object
-      def return_obj_array(instance_array = [], obj)
+      def return_obj_array(obj, instance_array = [])
         obj.instance_variables.each do |value|
           instance_array << obj.instance_variable_get(value)
         end

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

@@ -1,41 +1,54 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Utilities
     module K2ProcessWebhook
       extend self
 
       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)
+        raise ArgumentError, "Empty/Nil Request Body Argument!" if payload.blank?
+
+        process_webhook(payload) if K2ConnectRuby::K2Utilities::K2Authenticator.authenticate(payload, secret_key, signature)
+      end
+
+      def process_webhook(payload)
+        if daraja_payload?(payload)
+          K2ConnectRuby::K2Services::Payloads::DarajaWebhooks.new(payload)
+        else
+          process_k2_connect_payload(payload)
+        end
       end
 
-      def check_topic(payload)
-        result_topic = payload.dig('topic')
+      def process_k2_connect_payload(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
+        when "buygoods_transaction_received"
+          K2ConnectRuby::K2Services::Payloads::Webhooks::BuygoodsTransactionReceived.new(payload)
           # 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
+        when "buygoods_transaction_reversed"
+          K2ConnectRuby::K2Services::Payloads::Webhooks::BuygoodsTransactionReversed.new(payload)
+          # B2B Transaction
+        when "b2b_transaction_received"
+          K2ConnectRuby::K2Services::Payloads::Webhooks::B2bTransactionReceived.new(payload)
+          # B2B Transaction Reversed
+        when "b2b_transaction_reversed"
+          K2ConnectRuby::K2Services::Payloads::Webhooks::B2bTransactionReversed.new(payload)
           # Settlement Transfer
-        when 'settlement_transfer_completed'
-          settlement_transfer = K2ConnectRuby::K2Services::Payloads::Webhooks::SettlementWebhook.new(payload)
-          return settlement_transfer
+        when "settlement_transfer_completed"
+          K2ConnectRuby::K2Services::Payloads::Webhooks::TransferWebhook.new(payload)
           # Customer Created
-        when 'customer_created'
-          customer_created = K2ConnectRuby::K2Services::Payloads::Webhooks::CustomerCreated.new(payload)
-          return customer_created
+        when "customer_created"
+          K2ConnectRuby::K2Services::Payloads::Webhooks::CustomerCreated.new(payload)
         else
-          raise ArgumentError, 'No Other Specified Event!'
+          raise ArgumentError, "No Other Specified Event!"
         end
       end
 
+      def daraja_payload?(payload)
+        payload.key?("TransactionType")
+      end
+
       # Returns a Hash Object
       def return_obj_hash(instance_hash = HashWithIndifferentAccess.new, obj)
         obj.instance_variables.each do |value|

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Utilities
     module K2UrlParse
       extend self
 
       def remove_localhost(url)
-        url.host = '127.0.0.1' if url.host.eql?('localhost')
+        url.host = "127.0.0.1" if url.host.eql?("localhost")
         url
       end
     end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Utilities
+    class PhoneNumberValidator < ActiveModel::Validator
+      def validate(record)
+        phone_number = record.phone_number
+
+        record.errors.add(:phone_number, "is invalid.") if phone_number&.size == 13 && !phone_number&.starts_with?("+2547")
+        record.errors.add(:phone_number, "is invalid.") if phone_number&.size == 12 && !phone_number&.starts_with?("2547")
+        record.errors.add(:phone_number, "is invalid.") if phone_number&.size == 10 && !phone_number&.starts_with?("07")
+      end
+    end
+  end
+end

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

@@ -1,22 +1,11 @@
-require 'k2-connect-ruby/k2_utilities/k2_url_parse'
-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'
+require "k2-connect-ruby/k2_utilities/config/k2_config"
+require "k2-connect-ruby/k2_utilities/k2_url_parse"
+require "k2-connect-ruby/k2_utilities/k2_authenticator"
+require "k2-connect-ruby/k2_utilities/k2_connection_helper"
+require "k2-connect-ruby/k2_utilities/k2_process_result"
+require "k2-connect-ruby/k2_utilities/k2_process_webhook"
+require "k2-connect-ruby/k2_utilities/phone_number_validator"
 
 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
-    end
-  end
-end
+  module K2Utilities; end
+end

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

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

data/lib/k2-connect-ruby.rb

@@ -1,16 +1,17 @@
-require 'active_model'
-require 'active_support/json'
-require 'active_support/dependencies/autoload'
-require 'active_support/core_ext'
-require 'active_support/core_ext/hash/indifferent_access'
-require 'yaml'
-require 'rest-client'
-require 'json'
+require "active_model"
+require "active_support/json"
+require "active_support/dependencies/autoload"
+require "active_support/core_ext"
+require "active_support/core_ext/hash/indifferent_access"
+require "yaml"
+require "rest-client"
+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'
+require "k2-connect-ruby/k2_utilities"
+require "k2-connect-ruby/k2_services"
+require "k2-connect-ruby/entity"
+require "k2-connect-ruby/k2_errors"
+require "k2-connect-ruby/version"
+require "k2-connect-ruby/http_client"
 
 module K2ConnectRuby; end