k2-connect-ruby 3.1.0 → 4.0.0

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/k2_stk.rb

@@ -1,46 +1,29 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Entity
     class K2Stk < K2ConnectRuby::K2Entity::K2Entity
       # Receive payments from M-PESA users.
-      def receive_mpesa_payments(params)
-        # Validation
-        params = validate_input(params, @exception_array += %w[payment_channel till_number first_name last_name phone_number email currency value metadata callback_url])
-        # The Request Body Parameters
-        k2_request_subscriber = {
-          first_name: params[:first_name],
-          middle_name: params[:middle_name],
-          last_name: params[:last_name],
-          phone_number: validate_phone(params[:phone_number]),
-          email: validate_email(params[:email])
-        }
-        k2_request_amount = {
-          currency: 'KES',
-          value: params[:value]
-        }
-        k2_request_metadata = params[:metadata]
-        k2_request_links = {
-          callback_url: params[:callback_url]
-        }
-        receive_body = {
-          payment_channel: params[:payment_channel],
-          till_number: validate_till_number_prefix(params[:till_number]),
-          subscriber: k2_request_subscriber,
-          amount: k2_request_amount,
-          meta_data: k2_request_metadata,
-          _links: k2_request_links
-        }
-        receive_hash = make_hash(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('incoming_payments'), 'post', @access_token, 'STK', receive_body)
-        @location_url = K2ConnectRuby::K2Utilities::K2Connection.make_request(receive_hash)
+      def send_stk_request(params)
+        stk_push_request = K2ConnectRuby::K2Entity::K2FinancialEntities::StkPush::StkPushRequest.new(params)
+        raise(ArgumentError, stk_push_request.errors.full_messages.first) unless stk_push_request.valid?
+
+        result = K2ConnectRuby::K2Services::SendK2ConnectPostRequestService.call(
+          access_token,
+          stk_push_request.endpoint,
+          stk_push_request.request_body,
+        )
+        @location_url = result.data[:response_headers][:location]
       end
 
       # Query/Check STK Payment Request Status
       def query_status
-        super('STK', path_url=@location_url)
+        super(location_url)
       end
 
       # Query Location URL
       def query_resource(url)
-        super('STK', url)
+        super(url)
       end
     end
   end

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/payment_link.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Entity
+    # Service class to initiate or cancel a payment link
+    class PaymentLink < K2ConnectRuby::K2Entity::K2Entity
+      attr_accessor :payment_link_location_url
+
+      def create_payment_link(params)
+        payment_link_request = build_payment_link_request(params)
+        raise(ArgumentError, payment_link_request.errors.full_messages.first) unless payment_link_request.valid?
+
+        result = K2ConnectRuby::K2Services::SendK2ConnectPostRequestService.call(
+          access_token,
+          payment_link_request.endpoint,
+          payment_link_request.request_body,
+        )
+        raise(result.errors.first) unless result.success?
+
+        @payment_link_location_url = result.data[:response_headers][:location]
+      end
+
+      def cancel_payment_link(resource_url)
+        result = K2ConnectRuby::K2Services::SendK2ConnectPostRequestService.call(
+          access_token,
+          "#{resource_url}/cancel",
+          nil,
+        )
+        raise(result.errors.first) unless result.success?
+
+        result.data[:response_body][:message]
+      end
+
+      def query_status
+        super(payment_link_location_url)
+      end
+
+      private
+
+      def build_payment_link_request(params)
+        K2ConnectRuby::K2Entity::K2FinancialEntities::PaymentLinks::PaymentLinkRequest.new(
+          till_number: params[:till_number],
+          currency: params[:currency],
+          amount: params[:amount],
+          payment_reference: params[:payment_reference],
+          note: params[:note],
+          metadata: params[:metadata],
+          callback_url: params[:callback_url],
+        )
+      end
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/payment_links/payment_link_request.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Entity
+    module K2FinancialEntities
+      module PaymentLinks
+        # Request to create a payment link
+        class PaymentLinkRequest
+          include ActiveModel::Validations
+
+          attr_accessor :till_number, :currency, :amount, :payment_reference, :note, :metadata, :callback_url
+
+          validates :till_number, :currency, :amount, :callback_url, presence: true
+          validates :currency, inclusion: { in: ["KES"], message: "must be 'KES'" }
+
+          def initialize(kwargs)
+            kwargs.each do |key, value|
+              instance_variable_set("@#{key}", value)
+            end
+          end
+
+          def request_body
+            {
+              till_number: till_number,
+              currency: currency,
+              amount: amount,
+              payment_reference: payment_reference,
+              note: note,
+              metadata: metadata,
+              _links: {
+                callback_url: callback_url,
+              },
+            }
+          end
+
+          def endpoint
+            K2ConnectRuby::K2Utilities::Config::K2Config.endpoint("payment_links")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/reversal.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Entity
+    # Initiate or get status of a reversal request
+    class Reversal < K2ConnectRuby::K2Entity::K2Entity
+      attr_accessor :reversal_location_url
+
+      def initiate_reversal(params)
+        reversal_request = build_reversal_request(params)
+        raise ArgumentError, reversal_request.errors.full_messages.first unless reversal_request.valid?
+
+        result = K2ConnectRuby::K2Services::SendK2ConnectPostRequestService.call(
+          access_token,
+          reversal_request.endpoint,
+          reversal_request.request_body,
+        )
+        raise(result.errors.first) unless result.success?
+
+        @reversal_location_url = result.data[:response_headers][:location]
+      end
+
+      def query_status
+        super(reversal_location_url)
+      end
+
+      private
+
+      def build_reversal_request(params)
+        K2ConnectRuby::K2Entity::K2FinancialEntities::Reversals::ReversalRequest.new(
+          transaction_reference: params[:transaction_reference],
+          reason: params[:reason],
+          metadata: params[:metadata],
+          callback_url: params[:callback_url],
+        )
+      end
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/reversals/reversal_request.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Entity
+    module K2FinancialEntities
+      module Reversals
+        # Request to initiate a reversal
+        class ReversalRequest
+          include ActiveModel::Validations
+
+          attr_accessor :transaction_reference, :reason, :metadata, :callback_url
+
+          validates :transaction_reference, :reason, :callback_url, presence: true
+
+          def initialize(kwargs)
+            kwargs.each do |key, value|
+              instance_variable_set("@#{key}", value)
+            end
+          end
+
+          def request_body
+            {
+              transaction_reference: transaction_reference,
+              reason: reason,
+              metadata: metadata,
+              _links: {
+                callback_url: callback_url
+              }
+            }
+          end
+
+          def endpoint
+            K2ConnectRuby::K2Utilities::Config::K2Config.endpoint("reversals")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/send_money/send_money_request.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Entity
+    module K2FinancialEntities
+      module SendMoney
+        class SendMoneyRequest
+          include ActiveModel::Validations
+
+          attr_accessor :source_identifier, :destinations, :destination_requests, :currency, :callback_url, :metadata
+
+          validates :currency, :callback_url, presence: true
+          validates :currency, inclusion: { in: ["KES"], message: "must be 'KES'." }
+          validate :validate_destination_details
+
+          def initialize(kwargs)
+            kwargs.each do |key, value|
+              instance_variable_set("@#{key}", value)
+            end
+          end
+
+          def endpoint
+            K2ConnectRuby::K2Utilities::Config::K2Config.endpoint("send_money")
+          end
+
+          def request_body
+            {
+              source_identifier: source_identifier,
+              destinations: destination_requests&.map(&:destination_payload),
+              currency: currency,
+              metadata: metadata,
+              _links: {
+                callback_url: callback_url,
+              },
+            }
+          end
+
+          private
+
+          def validate_destination_details
+            return if destination_requests.blank?
+
+            invalid_destination_request = destination_requests.find { |request| !request.valid? }
+
+            if invalid_destination_request.present?
+              invalid_destination_request.errors.full_messages.each { |message| self.errors.add(:base, message) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/send_money.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Create a send money request (Either a payment to an external recipient/third party, or transferring funds to ones own accounts).
+module K2ConnectRuby
+  module K2Entity
+    class SendMoney < K2ConnectRuby::K2Entity::K2Entity
+      attr_accessor :payments_location_url
+
+      def create_payment(params)
+        send_money_request = build_send_money_request(params)
+        raise(ArgumentError, send_money_request.errors.full_messages.first) unless send_money_request.valid?
+
+        result = K2ConnectRuby::K2Services::SendK2ConnectPostRequestService.call(
+          access_token,
+          send_money_request.endpoint,
+          send_money_request.request_body,
+        )
+        if result.success?
+          @payments_location_url = result.data[:response_headers][:location]
+        else
+          raise(result.errors.first)
+        end
+      end
+
+      # Query/Check the status of a recently initiated Send money request
+      def query_status
+        super(payments_location_url)
+      end
+
+      # Query specific URL
+      def query_resource(url)
+        super(url)
+      end
+
+      private
+
+      def build_send_money_request(params)
+        K2ConnectRuby::K2Entity::K2FinancialEntities::SendMoney::SendMoneyRequest.new(
+          source_identifier: params[:source_identifier],
+          destination_requests: build_destination_requests(params[:destinations]),
+          metadata: params[:metadata],
+          currency: params[:currency],
+          callback_url: params[:callback_url],
+        )
+      end
+
+      def build_destination_requests(destination_params)
+        destination_params&.map do |params|
+          build_destination_request(params)
+        end
+      end
+
+      def build_destination_request(destination_request)
+        case destination_request[:type]
+        when "mobile_wallet"
+          K2ConnectRuby::K2Entity::K2FinancialEntities::Destination::ExternalMpesaWallet.new(destination_request)
+        when "bank_account"
+          K2ConnectRuby::K2Entity::K2FinancialEntities::Destination::ExternalBankAccount.new(destination_request)
+        when "paybill"
+          K2ConnectRuby::K2Entity::K2FinancialEntities::Destination::ExternalPaybill.new(destination_request)
+        when "till"
+          K2ConnectRuby::K2Entity::K2FinancialEntities::Destination::ExternalTill.new(destination_request)
+        when "merchant_bank_account"
+          K2ConnectRuby::K2Entity::K2FinancialEntities::Destination::MerchantBankAccount.new(destination_request)
+        when "merchant_wallet"
+          K2ConnectRuby::K2Entity::K2FinancialEntities::Destination::MerchantMpesaWallet.new(destination_request)
+        else
+          raise(ArgumentError, "Undefined destination type.")
+        end
+      end
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/stk_push/stk_push_request.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Entity
+    module K2FinancialEntities
+      module StkPush
+        class StkPushRequest
+          include ActiveModel::Validations
+
+          attr_accessor :till_number, :payment_channel, :first_name, :middle_name, :last_name, :phone_number, :email, :amount, :callback_url, :metadata
+
+          validates :till_number, :phone_number, :amount, :callback_url, presence: true
+
+          validates_with K2ConnectRuby::K2Utilities::PhoneNumberValidator
+
+          def initialize(kwargs)
+            kwargs.each do |key, value|
+              instance_variable_set("@#{key}", value)
+            end
+          end
+
+          def endpoint
+            K2ConnectRuby::K2Utilities::Config::K2Config.endpoint("incoming_payments")
+          end
+
+          def request_body
+            {
+              payment_channel: payment_channel,
+              till_number: till_number,
+              subscriber: {
+                first_name: first_name,
+                middle_name: middle_name,
+                last_name: last_name,
+                phone_number: phone_number,
+                email: email,
+              },
+              amount: {
+                currency: "KES",
+                value: amount,
+              },
+              metadata: metadata,
+              _links: {
+                callback_url: callback_url,
+              },
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/transfer_account/merchant_bank_account.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Entity
+    module K2FinancialEntities
+      module TransferAccount
+        class MerchantBankAccount < TransferAccountRequest
+          include ActiveModel::Validations
+
+          attr_accessor :account_name, :account_number, :bank_branch_ref, :settlement_method
+
+          validates :account_name, :account_number, :bank_branch_ref, :settlement_method, presence: true
+          validates :settlement_method, inclusion: {
+            in: ["EFT", "RTS"],
+            message: "is invalid.",
+          }
+
+          def endpoint
+            K2ConnectRuby::K2Utilities::Config::K2Config.endpoint("settlement_bank_account")
+          end
+
+          def request_body
+            {
+              nickname: nickname,
+              account_name: account_name,
+              account_number: account_number,
+              bank_branch_ref: bank_branch_ref,
+              settlement_method: settlement_method,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/transfer_account/merchant_mpesa_wallet.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Entity
+    module K2FinancialEntities
+      module TransferAccount
+        class MerchantMpesaWallet < TransferAccountRequest
+          include ActiveModel::Validations
+
+          attr_accessor :first_name, :last_name, :phone_number, :email, :network
+
+          validates :first_name, :last_name, :email, presence: true
+          validates :phone_number, presence: true, length: { maximum: 13 }
+          validates :email, format: {
+            with: URI::MailTo::EMAIL_REGEXP,
+            message: "is invalid.",
+          }
+
+          validates_with K2ConnectRuby::K2Utilities::PhoneNumberValidator
+
+          def endpoint
+            K2ConnectRuby::K2Utilities::Config::K2Config.endpoint("settlement_mobile_wallet")
+          end
+
+          def request_body
+            {
+              nickname: nickname,
+              first_name: first_name,
+              last_name: last_name,
+              phone_number: phone_number,
+              network: network,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/transfer_account/transfer_account_request.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module K2ConnectRuby
+  module K2Entity
+    module K2FinancialEntities
+      module TransferAccount
+        class TransferAccountRequest
+          include ActiveModel::Validations
+
+          attr_accessor :type, :nickname
+
+          def initialize(kwargs)
+            kwargs.each do |key, value|
+              instance_variable_set("@#{key}", value)
+            end
+          end
+
+          def endpoint; end
+
+          def request_body; end
+        end
+      end
+    end
+  end
+end

data/lib/k2-connect-ruby/k2_entity/k2_financial_entities/transfer_account.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Adding either one's own bank account or M-PESA phone
+module K2ConnectRuby
+  module K2Entity
+    class TransferAccount < K2ConnectRuby::K2Entity::K2Entity
+      attr_accessor :transfer_account_location_url
+
+      def add_transfer_account(params)
+        params = params.with_indifferent_access
+        transfer_account = build_transfer_account(params)
+        raise(ArgumentError, transfer_account.errors.full_messages.first) unless transfer_account.valid?
+
+        result = K2ConnectRuby::K2Services::SendK2ConnectPostRequestService.call(
+          access_token,
+          transfer_account.endpoint,
+          transfer_account.request_body,
+        )
+        if result.success?
+          @transfer_account_location_url = result.data[:response_headers][:location]
+        else
+          raise(result.errors.first)
+        end
+      end
+
+      # Query/Check the status of a recently initiated Send money request
+      def query_status
+        super(transfer_account_location_url)
+      end
+
+      # Query specific URL
+      def query_resource(url)
+        super(url)
+      end
+
+      private
+
+      def build_transfer_account(params)
+        if params[:type].eql?("merchant_wallet")
+          K2ConnectRuby::K2Entity::K2FinancialEntities::TransferAccount::MerchantMpesaWallet.new(params)
+        elsif params[:type].eql?("merchant_bank_account")
+          K2ConnectRuby::K2Entity::K2FinancialEntities::TransferAccount::MerchantBankAccount.new(params)
+        else
+          raise(ArgumentError, "Unknown transfer account type.")
+        end
+      end
+    end
+  end
+end

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

@@ -1,32 +1,35 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Entity
     class K2Polling
-      include K2ConnectRuby::K2Utilities::K2Validation, K2ConnectRuby::K2Utilities
+      include K2ConnectRuby::K2Utilities
       attr_reader :location_url, :k2_response_body
       attr_accessor :access_token
 
       # Initialize with access token
       def initialize(access_token)
-        raise ArgumentError, 'Nil or Empty Access Token Given!' if access_token.blank?
+        raise ArgumentError, "Nil or Empty Access Token Given!" if access_token.blank?
+
         @access_token = access_token
       end
 
       def poll(params)
-        k2_request_body = {
-          scope: params[:scope],
-          scope_reference: params[:scope_reference],
-          from_time: params[:from_time],
-          to_time: params[:to_time],
-          _links: { callback_url: params[:callback_url] }
-        }
-        poll_hash = make_hash(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('poll'), 'post', @access_token,'Polling', k2_request_body)
-        @location_url =  K2ConnectRuby::K2Utilities::K2Connection.make_request(poll_hash)
+        polling_request = K2ConnectRuby::K2Entity::K2FinancialEntities::Polling::PollingRequest.new(params)
+        raise(ArgumentError, polling_request.errors.full_messages.first) unless polling_request.valid?
+
+        result = K2ConnectRuby::K2Services::SendK2ConnectPostRequestService.call(
+          access_token,
+          polling_request.endpoint,
+          polling_request.request_body,
+        )
+        @location_url = result.data[:response_headers][:location]
       end
 
       # Retrieve your newly created polling request by its resource location
       def query_resource(location_url = @location_url)
-        query_hash = make_hash(location_url, 'get', @access_token, 'Polling', nil)
-        @k2_response_body = K2ConnectRuby::K2Utilities::K2Connection.make_request(query_hash)
+        result = K2ConnectRuby::K2Services::SendK2ConnectGetRequestService.call(access_token, location_url)
+        @k2_response_body = result.data[:response_body]
       end
 
       # Retrieve your newly created polling request by specific resource location

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

@@ -1,34 +1,36 @@
+# frozen_string_literal: true
+
 module K2ConnectRuby
   module K2Entity
     class K2Subscribe
-      include K2ConnectRuby::K2Utilities::K2Validation, K2ConnectRuby::K2Utilities
+      include 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?
+        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(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('webhook_subscriptions'), 'post', @access_token,'Subscription', k2_request_body)
-        @location_url =  K2ConnectRuby::K2Utilities::K2Connection.make_request(subscribe_hash)
+        webhook_subscription_request = K2ConnectRuby::K2Entity::K2FinancialEntities::Webhook::WebhookSubscriptionRequest.new(params)
+        raise(ArgumentError, webhook_subscription_request.errors.full_messages.first) unless webhook_subscription_request.valid?
+
+        result = K2ConnectRuby::K2Services::SendK2ConnectPostRequestService.call(
+          access_token,
+          webhook_subscription_request.endpoint,
+          webhook_subscription_request.request_body,
+        )
+        @location_url = result.data[:response_headers][:location]
       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)
+        result = K2ConnectRuby::K2Services::SendK2ConnectGetRequestService.call(access_token, location_url)
+        @k2_response_body = result.data[:response_body]
       end
 
       # Query Specific Webhook URL