k2-connect-ruby 3.0.0 → 4.0.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Entity
     class K2Token
@@ -10,57 +12,30 @@ module K2ConnectRuby
       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)
+        result = K2ConnectRuby::K2Services::SendRequestTokenRequestService.call(@client_id, @client_secret)
+
+        @access_token = result.data[:response_body][:access_token]
       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)
+        result = K2ConnectRuby::K2Services::SendRevokeTokenRequestService.call(@client_id, @client_secret, access_token)
+
+        true
       end
 
       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)
+        result = K2ConnectRuby::K2Services::SendIntrospectTokenRequestService.call(@client_id, @client_secret, access_token)
+
+        result.data[:response_body]
       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)
-
-        token_hash[:access_token] = access_token
-        @token_response = K2ConnectRuby::K2Utilities::K2Connection.make_request(token_hash)
+        result = K2ConnectRuby::K2Services::SendTokenInfoRequestService.call(access_token)
+        result.data[:response_body]
       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 << 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
+        raise ArgumentError, "Nil or Empty Client Id or Secret!" if client_id.blank? || client_secret.blank?
       end
     end
   end

data/lib/k2-connect-ruby/k2_entity/polling/polling_request.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Entity
+    module K2FinancialEntities
+      module Polling
+        class PollingRequest
+          include ActiveModel::Validations
+
+          attr_accessor :from_time, :to_time, :callback_url, :scope, :scope_reference
+
+          validates :from_time, :to_time, :callback_url, :scope, presence: true
+          validates :scope_reference, presence: true, if: :till_scope?
+          validates :scope, inclusion: {
+            in: ["till", "company"],
+            message: "must be one of 'till' or 'company'.",
+          }
+
+          def initialize(kwargs)
+            kwargs.each do |key, value|
+              instance_variable_set("@#{key}", value)
+            end
+          end
+
+          def endpoint
+            K2ConnectRuby::K2Utilities::Config::K2Config.endpoint("poll")
+          end
+
+          def request_body
+            {
+              scope: scope,
+              scope_reference: scope_reference,
+              from_time: from_time,
+              to_time: to_time,
+              _links: {
+                callback_url: callback_url,
+              },
+            }
+          end
+
+          def till_scope?
+            scope == "till"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_entity/webhook/webhook_subscription_request.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Entity
+    module K2FinancialEntities
+      module Webhook
+        class WebhookSubscriptionRequest
+          include ActiveModel::Validations
+
+          attr_accessor :event_type, :url, :scope, :scope_reference, :enable_daraja_payload
+
+          validates :event_type, :url, :scope, presence: true
+          validates :scope_reference, presence: true, if: :till_scope?
+          validates :event_type, inclusion: {
+            in: [
+              "buygoods_transaction_received",
+              "b2b_transaction_received",
+              "settlement_transfer_completed",
+              "customer_created",
+              "buygoods_transaction_reversed",
+              "card_transaction_received",
+              "card_transaction_voided",
+              "card_transaction_reversed"
+            ],
+            message: "is invalid",
+          }
+          validates :scope, inclusion: {
+            in: ["till", "company"],
+            message: "must be one of 'till' or 'company'.",
+          }
+          validate :validate_daraja_payload_flag, if: :enable_daraja_payload
+
+          def initialize(kwargs)
+            kwargs.each do |key, value|
+              instance_variable_set("@#{key}", value)
+            end
+          end
+
+          def endpoint
+            K2ConnectRuby::K2Utilities::Config::K2Config.endpoint("webhook_subscriptions")
+          end
+
+          def request_body
+            {
+              event_type: event_type,
+              url: url,
+              scope: scope,
+              scope_reference: scope_reference,
+              enable_daraja_payload: enable_daraja_payload || false,
+            }
+          end
+
+          def till_scope?
+            scope == "till"
+          end
+
+          def validate_daraja_payload_flag
+            unless event_type.in?(["buygoods_transaction_received", "b2b_transaction_received"])
+              errors.add(:base, "Can only enable daraja_payloads for 'buygoods_transaction_received' and 'b2b_transaction_received' webhooks.")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,79 +1,23 @@
-module K2ConnectRuby
-  # Standard K2Error
-  class K2Errors < StandardError
-    attr_reader :status, :message
-    def initialize(msg = @message)
-      super(msg)
-    end
-  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.")
-      end
-    end
-  end
+# frozen_string_literal: true
 
-  # Errors concerning the Validation module
-  class K2ValidateErrors < K2Errors
-    attr_reader :the_keys
+module K2ConnectRuby
 
-    def initialize(the_keys)
-      super
-      @the_keys = the_keys
-      @status = :bad_request
-    end
+  module K2Errors
 
-    def loop_keys
-      STDERR.puts @message
-      @the_keys.each(&method(:puts))
-    end
+    class Error < StandardError; end
+    class TimeoutError < Error; end
+    class NotFoundError < Error; end
+    class UnauthorizedError < Error; end
+    class ConnectionError < Error; end
 
-    def message
-      loop_keys
-    end
-  end
+    class ApiError < Error
+      attr_reader :code, :details
 
-  # 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
-
-  # 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
+      def initialize(message:, code: nil, details: nil)
+        @code = code
+        @details = details
+        super(message)
+      end
     end
   end
 end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Services
+    class BaseService
+      CallResult = Struct.new(:success?, :data, :errors) do
+        class << self
+          def success(data = nil)
+            new(true, data, [])
+          end
+
+          def errors(messages)
+            new(false, nil, messages)
+          end
+        end
+      end
+
+      class << self
+        def call(*args, &block)
+          new(*args, &block).execute
+        end
+      end
+    end
+  end
+end

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

@@ -1,26 +1,27 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Services
     class K2Client
-      attr_accessor :api_secret_key,
-                    :hash_body,
-                    :k2_signature
+      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?
+        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?
+        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']
+        @k2_signature = hash_header["HTTP_X_KOPOKOPO_SIGNATURE"]
       end
     end
   end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Services
+    module Payloads
+      class DarajaWebhooks
+        include ActiveModel::Validations
+
+        attr_reader :transaction_type,
+          :transaction_id,
+          :transaction_time,
+          :transaction_amount,
+          :business_short_code,
+          :bill_ref_number,
+          :invoice_number,
+          :org_account_balance,
+          :third_party_transaction_id,
+          :msisdn,
+          :first_name,
+          :middle_name,
+          :last_name
+
+        validates :transaction_type, :transaction_id, :transaction_time, :transaction_amount, presence: true
+
+        def initialize(payload)
+          @transaction_type = payload.dig("TransactionType")
+          @transaction_id = payload.dig("TransID")
+          @transaction_time = payload.dig("TransTime")
+          @transaction_amount = payload.dig("TransAmount")
+          @business_short_code = payload.dig("BusinessShortCode")
+          @bill_ref_number = payload.dig("BillRefNumber")
+          @invoice_number = payload.dig("InvoiceNumber")
+          @org_account_balance = payload.dig("OrgAccountBalance")
+          @third_party_transaction_id = payload.dig("ThirdPartyTransId")
+          @msisdn = payload.dig("MSISDN")
+          @first_name = payload.dig("FirstName")
+          @middle_name = payload.dig("MiddleName")
+          @last_name = payload.dig("LastName")
+        end
+      end
+    end
+  end
+end

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

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Services
     module Payloads
       class K2Transaction
         attr_reader :id,
-                    :type,
-                    :metadata,
-                    :links_self,
-                    :callback_url
+          :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')
+          @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
 
@@ -21,14 +23,14 @@ module K2ConnectRuby
         include ActiveModel::Validations
 
         attr_reader :status,
-                    :initiation_time
+          :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')
+          @status = payload.dig("data", "attributes", "status")
+          @initiation_time = payload.dig("data", "attributes", "initiation_time") if @type.eql?("incoming_payment")
         end
 
         private
@@ -38,15 +40,15 @@ module K2ConnectRuby
 
       class OutgoingTransaction < CommonPayment
         attr_reader :created_at,
-                    :transfer_batches,
-                    :total_value
+          :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')
+          @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

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

@@ -1,26 +1,28 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Services
     module Payloads
       class K2Webhooks
         attr_reader :id,
-                    :topic,
-                    :created_at,
-                    :links_self,
-                    :event_type,
-                    :links_resource,
-                    :event_resource,
-                    :resource_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')
+          @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')
+          @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')
+          @links_self = payload.dig("_links", "self")
+          @links_resource = payload.dig("_links", "resource")
         end
       end
 
@@ -28,36 +30,38 @@ module K2ConnectRuby
         REFERENCE_EXCEPTIONS = ["Merchant to Merchant Transaction", "Settlement Transfer"]
 
         attr_reader :reference,
-                    :origination_time,
-                    :amount,
-                    :currency,
-                    :status
+          :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')
+          @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
+          :till_number,
+          :sender_phone_number,
+          :hashed_sender_phone,
+          :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')
+          @system = payload.dig("event", "resource", "system")
+          @till_number = payload.dig("event", "resource", "till_number")
+          @sender_phone_number = payload.dig("event", "resource", "sender_phone_number")
+          @hashed_sender_phone = payload.dig("event", "resource", "hashed_sender_phone")
+          @sender_first_name = payload.dig("event", "resource", "sender_first_name")
+          @sender_last_name = payload.dig("event", "resource", "sender_last_name")
         end
       end
     end

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

@@ -1,44 +1,46 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Services
     module Payloads
       module Transactions
         class IncomingPayment < 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
+            :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,
+            :k2_errors
 
           def initialize(payload)
             super
             # Event details
-            @event = payload.dig('data', 'attributes', 'event')
-            @event_type = payload.dig('data', 'attributes', 'event', 'type')
+            @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')
+            @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')
+            @k2_errors = payload.dig("data", "attributes", "event", "errors")
           end
 
           private