k2-connect-ruby 2.0.0 → 3.0.0

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

@@ -1,104 +1,98 @@
-# For PAY/ Send Money to others
-# TODO: Add K2Config configuration for the callback URL
-class K2Pay < K2Entity
-  attr_reader :recipients_location_url, :payments_location_url
+module K2ConnectRuby
+  module K2Entity
+    class K2Pay < K2ConnectRuby::K2Entity::K2Entity
+      attr_reader :recipients_location_url, :payments_location_url
 
-  # Adding PAY Recipients with either mobile_wallets or bank_accounts as destination of your payments.
-  def add_recipient(params)
-    params = params.with_indifferent_access
-    @exception_array += %w[type]
-    # In the case of mobile pay recipient
-    if params[:type].eql?('mobile_wallet')
-      params = validate_input(params, @exception_array += %w[first_name last_name phone_number email network])
-      k2_request_pay_recipient = {
-        first_name: params[:first_name],
-        last_name: params[:last_name],
-        phone_number: validate_phone(params[:phone_number]),
-        email: validate_email(params[:email]),
-        network: params[:network]
-      }
-      # In the case of bank pay recipient
-    elsif params[:type].eql?('bank_account')
-      params = validate_input(params, @exception_array += %w[account_name account_number bank_branch_ref settlement_method])
-      k2_request_pay_recipient = {
-          account_name: params[:account_name],
-          account_number: params[:account_number],
-          bank_branch_ref: params[:bank_branch_ref],
-          settlement_method: params[:settlement_method]
-      }
-      # In the case of till pay recipient
-    elsif params[:type].eql?('till')
-      params = validate_input(params, @exception_array += %w[till_name till_number])
-      k2_request_pay_recipient = {
-        till_name: params[:till_name],
-        till_number: params[:till_number]
-      }
-      # In the case of bank pay recipient
-    elsif params[:type].eql?('paybill')
-      params = validate_input(params, @exception_array += %w[paybill_name paybill_number paybill_account_number])
-      k2_request_pay_recipient = {
-        paybill_name: params[:paybill_name],
-        paybill_number: params[:paybill_number],
-        paybill_account_number: params[:paybill_account_number]
-      }
-    else
-      raise ArgumentError, 'Undefined Payment Method.'
-    end
-    recipients_body = {
-      type: params[:type],
-      #type: params['pay_type'],
-      pay_recipient: k2_request_pay_recipient
-    }
-    pay_recipient_hash = make_hash(K2Config.path_url('pay_recipient'), 'post', @access_token, 'PAY', recipients_body)
-    @threads << Thread.new do
-      sleep 0.25
-      @recipients_location_url = K2Connect.make_request(pay_recipient_hash)
-    end
-    @threads.each(&:join)
-  end
+      # Adding PAY Recipients with either mobile_wallets or bank_accounts as destination of your payments.
+      def add_recipient(params)
+        params = params.with_indifferent_access
+        @exception_array += %w[type]
+        # In the case of mobile pay recipient
+        k2_request_pay_recipient = if params[:type].eql?('mobile_wallet')
+                                     params = validate_input(params, @exception_array += %w[first_name last_name phone_number email network])
+                                     {
+                                       first_name: params[:first_name],
+                                       last_name: params[:last_name],
+                                       phone_number: validate_phone(params[:phone_number]),
+                                       email: validate_email(params[:email]),
+                                       network: params[:network]
+                                     }
+                                     # In the case of bank pay recipient
+                                   elsif params[:type].eql?('bank_account')
+                                     params = validate_input(params, @exception_array += %w[account_name account_number bank_branch_ref settlement_method])
+                                     {
+                                       account_name: params[:account_name],
+                                       account_number: params[:account_number],
+                                       bank_branch_ref: params[:bank_branch_ref],
+                                       settlement_method: params[:settlement_method]
+                                     }
+                                     # In the case of till pay recipient
+                                   elsif params[:type].eql?('till')
+                                     params = validate_input(params, @exception_array += %w[till_name till_number])
+                                     {
+                                       till_name: params[:till_name],
+                                       till_number: params[:till_number]
+                                     }
+                                     # In the case of bank pay recipient
+                                   elsif params[:type].eql?('paybill')
+                                     params = validate_input(params, @exception_array += %w[paybill_name paybill_number paybill_account_number])
+                                     {
+                                       paybill_name: params[:paybill_name],
+                                       paybill_number: params[:paybill_number],
+                                       paybill_account_number: params[:paybill_account_number]
+                                     }
+                                   else
+                                     raise ArgumentError, 'Undefined Payment Method.'
+                                   end
+        recipients_body = {
+          type: params[:type],
+          #type: params['pay_type'],
+          pay_recipient: k2_request_pay_recipient
+        }
+        pay_recipient_hash = make_hash(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('pay_recipient'), 'post', @access_token, 'PAY', recipients_body)
+        @recipients_location_url = K2ConnectRuby::K2Utilities::K2Connection.make_request(pay_recipient_hash)
+      end
 
-  # Create an outgoing Payment to a third party.
-  def create_payment(params)
-    # Validation
-    params = validate_input(params, @exception_array += %w[destination_reference destination_type description category tags currency value callback_url metadata])
-    # The Request Body Parameters
-    k2_request_pay_amount = {
-      currency: params[:currency],
-      value: params[:value]
-    }
-    k2_request_pay_metadata = params[:metadata]
-    k2_request_links = {
-        callback_url: params[:callback_url]
-    }
-    create_payment_body = {
-      destination_reference: params[:destination_reference],
-      destination_type: params[:destination_type],
-      description: params[:description],
-      category: params[:category],
-      tags: params[:tags],
-      amount: k2_request_pay_amount,
-      meta_data: k2_request_pay_metadata,
-      _links: k2_request_links
-    }
-    create_payment_hash = make_hash(K2Config.path_url('payments'), 'post', @access_token, 'PAY', create_payment_body)
-    @threads << Thread.new do
-      sleep 0.25
-      @payments_location_url = K2Connect.make_request(create_payment_hash)
-    end
-    @threads.each(&:join)
-  end
+      # Create an outgoing Payment to a third party.
+      def create_payment(params)
+        # Validation
+        params = validate_input(params, @exception_array += %w[destination_reference destination_type description category tags currency value callback_url metadata])
+        # The Request Body Parameters
+        k2_request_pay_amount = {
+          currency: params[:currency],
+          value: params[:value]
+        }
+        k2_request_pay_metadata = params[:metadata]
+        k2_request_links = {
+          callback_url: params[:callback_url]
+        }
+        create_payment_body = {
+          destination_reference: params[:destination_reference],
+          destination_type: params[:destination_type],
+          description: params[:description],
+          category: params[:category],
+          tags: params[:tags],
+          amount: k2_request_pay_amount,
+          meta_data: k2_request_pay_metadata,
+          _links: k2_request_links
+        }
+        create_payment_hash = make_hash(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('payments'), 'post', @access_token, 'PAY', create_payment_body)
+        @payments_location_url = K2ConnectRuby::K2Utilities::K2Connection.make_request(create_payment_hash)
+      end
 
-  # Query/Check the status of a previously initiated PAY Payment request
-  def query_status(method_type)
-    if method_type.eql?('recipients')
-      super('PAY', @recipients_location_url)
-    elsif method_type.eql?('payments')
-      super('PAY', @payments_location_url)
-    end
-  end
+      # Query/Check the status of a previously initiated PAY Payment request
+      def query_status(method_type)
+        if method_type.eql?('recipients')
+          super('PAY', @recipients_location_url)
+        elsif method_type.eql?('payments')
+          super('PAY', @payments_location_url)
+        end
+      end
 
-  # Query Location URL
-  def query_resource(url)
-    super('PAY', url)
+      # Query Location URL
+      def query_resource(url)
+        super('PAY', url)
+      end
+    end
   end
 end

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

@@ -1,49 +1,48 @@
-# For Creating pre-approved and owned settlement accounts
-class K2Settlement < K2Entity
-  # Create a Verified Settlement Account via API (Mobile Wallet and Bank Account)
-  def add_settlement_account(params)
-    params=params.with_indifferent_access
-    the_path_url = ''
-    settlement_body = {}
-    @exception_array += %w[type]
-    # The Request Body Parameters
-    if params[:type].eql?('merchant_wallet')
-      params = validate_input(params, @exception_array += %w[first_name last_name phone_number network])
-      settlement_body = {
-        first_name: params[:first_name],
-        last_name: params[:last_name],
-        phone_number: validate_phone(params[:phone_number]),
-        network: params[:network]
-      }
-      the_path_url = K2Config.path_url('settlement_mobile_wallet')
-    elsif params[:type].eql?('merchant_bank_account')
-      params = validate_input(params, @exception_array += %w[account_name bank_ref bank_branch_ref account_number currency value, settlement_method])
-      settlement_body = {
-          account_name: params[:account_name],
-          bank_branch_ref: params[:bank_branch_ref],
-          account_number: params[:account_number],
-          settlement_method: params[:settlement_method]
-      }
-      the_path_url = K2Config.path_url('settlement_bank_account')
-    else
-      raise ArgumentError, 'Unknown Settlement Account'
-    end
+module K2ConnectRuby
+  module K2Entity
+    class K2Settlement < K2ConnectRuby::K2Entity::K2Entity
+      # Create a Verified Settlement Account via API (Mobile Wallet and Bank Account)
+      def add_settlement_account(params)
+        params=params.with_indifferent_access
+        the_path_url = ''
+        settlement_body = {}
+        @exception_array += %w[type]
+        # The Request Body Parameters
+        settlement_body = if params[:type].eql?('merchant_wallet')
+                            params = validate_input(params, @exception_array += %w[first_name last_name phone_number network])
+                            the_path_url = K2ConnectRuby::K2Utilities::Config::K2Config.path_url('settlement_mobile_wallet')
+                            {
+                              first_name: params[:first_name],
+                              last_name: params[:last_name],
+                              phone_number: validate_phone(params[:phone_number]),
+                              network: params[:network]
+                            }
+                          elsif params[:type].eql?('merchant_bank_account')
+                            params = validate_input(params, @exception_array += %w[account_name bank_ref bank_branch_ref account_number currency value, settlement_method])
+                            the_path_url = K2ConnectRuby::K2Utilities::Config::K2Config.path_url('settlement_bank_account')
+                            {
+                              account_name: params[:account_name],
+                              bank_branch_ref: params[:bank_branch_ref],
+                              account_number: params[:account_number],
+                              settlement_method: params[:settlement_method]
+                            }
+                          else
+                            raise ArgumentError, 'Unknown Settlement Account'
+                          end
 
-    settlement_hash = make_hash(the_path_url, 'post', @access_token, 'Transfer', settlement_body)
-    @threads << Thread.new do
-      sleep 0.25
-      @location_url = K2Connect.make_request(settlement_hash)
-    end
-    @threads.each(&:join)
-  end
+        settlement_hash = make_hash(the_path_url, 'post', @access_token, 'Transfer', settlement_body)
+        @location_url = K2ConnectRuby::K2Utilities::K2Connection.make_request(settlement_hash)
+      end
 
-  # Check the status of a prior initiated Transfer. Make sure to add the id to the url
-  def query_status
-    super('Settlement', path_url=@location_url)
-  end
+      # Check the status of a prior initiated Transfer. Make sure to add the id to the url
+      def query_status
+        super('Settlement', path_url=@location_url)
+      end
 
-  # Query Location URL
-  def query_resource(url)
-    super('Settlement', url)
+      # Query Location URL
+      def query_resource(url)
+        super('Settlement', url)
+      end
+    end
   end
 end

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

@@ -1,48 +1,47 @@
-# For STK Push/Receive MPESA Payments from merchant's customers
-class K2Stk < 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(K2Config.path_url('incoming_payments'), 'post', @access_token, 'STK', receive_body)
-    @threads << Thread.new do
-      sleep 0.25
-      @location_url = K2Connect.make_request(receive_hash)
-    end
-    @threads.each(&:join)
-  end
+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)
+      end
 
-  # Query/Check STK Payment Request Status
-  def query_status
-    super('STK', path_url=@location_url)
-  end
+      # Query/Check STK Payment Request Status
+      def query_status
+        super('STK', path_url=@location_url)
+      end
 
-  # Query Location URL
-  def query_resource(url)
-    super('STK', url)
+      # Query Location URL
+      def query_resource(url)
+        super('STK', url)
+      end
+    end
   end
 end

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

@@ -1,45 +1,44 @@
-# For Transferring funds to pre-approved and owned settlement accounts
-class K2Transfer < K2Entity
-  # Create a either a 'blind' transfer, for when destination is specified, and a 'targeted' transfer which has a specified destination.
-  def transfer_funds(params)
-    # Validation
-    unless params["destination_reference"].blank? && params["destination_type"].blank?
-      params = validate_input(params, @exception_array += %w[destination_reference destination_type currency value callback_url metadata])
-    end
-    params = params.with_indifferent_access
-    # The Request Body Parameters
-    k2_request_transfer = {
-        destination_reference: params[:destination_reference],
-        destination_type: params[:destination_type],
-        amount: {
+module K2ConnectRuby
+  module K2Entity
+    class K2Transfer < K2ConnectRuby::K2Entity::K2Entity
+      # Create a either a 'blind' transfer, for when destination is specified, and a 'targeted' transfer which has a specified destination.
+      def transfer_funds(params)
+        # Validation
+        unless params["destination_reference"].blank? && params["destination_type"].blank?
+          params = validate_input(params, @exception_array += %w[destination_reference destination_type callback_url metadata])
+        end
+        params = params.with_indifferent_access
+        # The Request Body Parameters
+        k2_request_transfer = {
+          destination_reference: params[:destination_reference],
+          destination_type: params[:destination_type],
+          amount: {
             currency: params[:currency],
             value: params[:value]
+          }
         }
-    }
-    metadata = params[:metadata]
-    transfer_body = k2_request_transfer.merge(
-        {
+        metadata = params[:metadata]
+        transfer_body = k2_request_transfer.merge(
+          {
             _links:
-                {
-                    callback_url: params[:callback_url]
-                },
+              {
+                callback_url: params[:callback_url]
+              },
             metadata: metadata
-        })
-    transfer_hash = make_hash(K2Config.path_url('transfers'), 'post', @access_token, 'Transfer', transfer_body)
-    @threads << Thread.new do
-      sleep 0.25
-      @location_url = K2Connect.make_request(transfer_hash)
-    end
-    @threads.each(&:join)
-  end
+          })
+        transfer_hash = make_hash(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('transfers'), 'post', @access_token, 'Transfer', transfer_body)
+        @location_url = K2ConnectRuby::K2Utilities::K2Connection.make_request(transfer_hash)
+      end
 
-  # Check the status of a prior initiated Transfer. Make sure to add the id to the url
-  def query_status
-    super('Transfer', path_url=@location_url)
-  end
+      # Check the status of a prior initiated Transfer. Make sure to add the id to the url
+      def query_status
+        super('Transfer', path_url=@location_url)
+      end
 
-  # Query Location URL
-  def query_resource(url)
-    super('Transfer', url)
+      # Query Location URL
+      def query_resource(url)
+        super('Transfer', url)
+      end
+    end
   end
 end

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

@@ -1,41 +1,40 @@
-class K2Notification
-  include K2Validation, K2Utilities
-  attr_reader :location_url, :k2_response_body
-  attr_accessor :access_token
+module K2ConnectRuby
+  module K2Entity
+    class K2Notification
+      include K2ConnectRuby::K2Utilities::K2Validation, 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?
-    @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
 
-  # Sends transaction notifications via SMS
-  def send_sms_transaction_notification(params)
-    k2_request_links = {
-      callback_url: params[:callback_url]
-    }
-    k2_request_body = {
-      webhook_event_reference: params[:webhook_event_reference],
-      message: params[:message],
-      _links: k2_request_links,
-    }
-    subscribe_hash = make_hash(K2Config.path_url('transaction_sms_notifications'), 'post', @access_token,'Notification', k2_request_body)
-    @location_url =  K2Connect.make_request(subscribe_hash)
-  end
+      # Sends transaction notifications via SMS
+      def send_sms_transaction_notification(params)
+        k2_request_links = {
+          callback_url: params[:callback_url]
+        }
+        k2_request_body = {
+          webhook_event_reference: params[:webhook_event_reference],
+          message: params[:message],
+          _links: k2_request_links,
+        }
+        subscribe_hash = make_hash(K2ConnectRuby::K2Utilities::Config::K2Config.path_url('transaction_sms_notifications'), 'post', @access_token,'Notification', k2_request_body)
+        @location_url =  K2ConnectRuby::K2Utilities::K2Connection.make_request(subscribe_hash)
+      end
 
-  # Query Recent Webhook
-  def query_resource(location_url = @location_url)
-    query_hash = make_hash(location_url, 'get', @access_token, 'Notification', 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_resource(location_url = @location_url)
+        query_hash = make_hash(location_url, 'get', @access_token, 'Notification', nil)
+        @k2_response_body = K2ConnectRuby::K2Utilities::K2Connection.make_request(query_hash)
+      end
 
-  # Query Specific Webhook URL
-  def query_resource_url(url)
-    query_resource(url)
+      # Query Specific Webhook URL
+      def query_resource_url(url)
+        query_resource(url)
+      end
+    end
   end
 end

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

@@ -1,40 +1,38 @@
-# Class for Polling Service
-class K2Polling
-  include K2Validation, K2Utilities
-  attr_reader :location_url, :k2_response_body
-  attr_accessor :access_token
+module K2ConnectRuby
+  module K2Entity
+    class K2Polling
+      include K2ConnectRuby::K2Utilities::K2Validation, 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?
-    @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
 
-  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(K2Config.path_url('poll'), 'post', @access_token,'Polling', k2_request_body)
-    @location_url =  K2Connect.make_request(poll_hash)
-  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)
+      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)
-    @threads << Thread.new do
-      sleep 0.25
-      @k2_response_body = K2Connect.make_request(query_hash)
-    end
-    @threads.each(&:join)
-  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)
+      end
 
-  # Retrieve your newly created polling request by specific resource location
-  def query_resource_url(url)
-    query_resource(url)
+      # Retrieve your newly created polling request by specific resource location
+      def query_resource_url(url)
+        query_resource(url)
+      end
+    end
   end
 end