fintecture 0.2.1 → 0.3.0

data/lib/fintecture/api/ressources/test_accounts.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'json'
+require 'faraday'
+require 'fintecture/utils/validation'
+require 'fintecture/exceptions'
+require 'fintecture/utils/date'
+require 'fintecture/utils/constants'
+
+module Fintecture
+  module Ressources
+    class TestAccounts
+      class << self
+        # ------------ PUBLIC METHOD ------------
+        def get(client, provider_id)
+          @client = client
+
+          # Do the request
+          _request provider_id
+        end
+
+        private
+
+        # ------------ REQUEST ------------
+        def _request(provider_id)
+          # Get the url request
+          url = _endpoint
+
+          # Build additional headers
+          additional_headers = {}
+          additional_headers['app_id'] = @client.app_id
+
+          # Build uri params
+          query_string = ''
+          query_string = "?filter[provider_id]=#{provider_id}" if provider_id
+          # Do connect request
+          Fintecture::Faraday::Authentication::Connection.get(
+            url: url + query_string,
+            client: @client,
+            custom_content_type: 'application/json',
+            secure_headers: true,
+            additional_headers: additional_headers
+          )
+        end
+
+        # ------------ API ENDPOINT ------------
+        def _endpoint
+          "#{_api_base_url}/#{Fintecture::Api::Endpoints::Ressources::TESTACCOUNTS}"
+        end
+
+        # ------------ BASE URL ------------
+        def _api_base_url
+          Fintecture::Api::BaseUrl::FINTECTURE_API_URL[@client.environment.to_sym]
+        end
+
+      end
+    end
+  end
+end

data/lib/fintecture/base_url.rb

@@ -0,0 +1,26 @@
+module Fintecture
+  module Api
+    module BaseUrl
+      FINTECTURE_OAUTH_URL = {
+        local: 'http://localhost:3030/oauth',
+        test: 'https://oauth-sandbox-test.fintecture.com/oauth',
+        sandbox: 'https://api-sandbox.fintecture.com/oauth',
+        production: 'https://api.fintecture.com/oauth'
+      }
+
+      FINTECTURE_API_URL = {
+        local: 'http://localhost:3030',
+        test: 'https://api-sandbox-test.fintecture.com',
+        sandbox: 'https://api-sandbox-test.fintecture.com',
+        production: 'https://api.fintecture.com'
+      }
+
+      FINTECTURE_CONNECT_URL = {
+        local: 'http://localhost:4201',
+        test: 'https://connect-test.fintecture.com',
+        sandbox: 'https://connect-sandbox.fintecture.com',
+        production: 'https://connect.fintecture.com'
+      }
+    end
+  end
+end

data/lib/fintecture/endpoints/ais.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Fintecture
+  module Api
+    module Endpoints
+      module Ais
+        # TODO: faire plus complet, avec un mot clef a remplacer
+        CONNECT = 'ais/v2/connect'
+        ACCOUNTS = 'ais/v1/customer'
+        TRANSACTIONS = 'ais/v1/customer'
+        ACCOUNTHOLDERS = 'ais/v1/customer'
+        CUSTOMER = 'ais/v1/customer'
+        AUTHORIZE = 'ais/v1/provider'
+      end
+    end
+  end
+end

data/lib/fintecture/{api/endpoints → endpoints}/authentication.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 module Fintecture
   module Api
     module Endpoints
       module Authentication
-
         OAUTH_TOKEN_AUTHORIZE = '/token/authorize'
         OAUTH_ACCESS_TOKEN = '/accesstoken'
         OAUTH_REFRESH_TOKEN = '/refreshtoken'
-
       end
     end
   end
-end
+end

data/lib/fintecture/endpoints/pis.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Fintecture
+  module Api
+    module Endpoints
+      module Pis
+        INITIATE = 'pis/v2/provider'
+        REFUND = 'pis/v2/refund'
+        REQUEST_TO_PAY = 'pis/v2/request-to-pay'
+        PAYMENTS = 'pis/v2/payments'
+        CONNECT = 'pis/v2/connect'
+        SETTLEMENTS = 'pis/v2/settlements'
+      end
+    end
+  end
+end

data/lib/fintecture/endpoints/ressources.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Fintecture
+  module Api
+    module Endpoints
+      module Ressources
+        APPLICATION = 'res/v1/applications'
+        PROVIDERS = 'res/v1/providers'
+        TESTACCOUNTS = 'res/v1/testaccounts'
+      end
+    end
+  end
+end

data/lib/fintecture/exceptions.rb

@@ -1,33 +1,72 @@
+# frozen_string_literal: true
+
+require 'json'
+
 module Fintecture
-  class ValidationException < Exception; end
-  class CryptoException < Exception; end
+  class ValidationException < RuntimeError; end
+
+  class CryptoException < RuntimeError; end
+
   class ApiException
     class << self
-
       def error(res)
         body = JSON.parse res.body
-        
-        code = body['code']
-        log_id = body['log_id']
-        errors = body['errors']
 
-        raise Exception.new(_construct_message(res.status, code, log_id, errors))
+        # Errors array
+        if body['code'] && body['log_id'] && body['errors']
+          raise _construct_message_errors(res, body)
+        # Single error
+        else
+          raise _construct_message_error(res, body)
+        end
       end
 
+      private
+
+      def _construct_message_errors(res, body)
+        status = res.status
+        code = body['code']
+        log_id = body['log_id']
+        errors_array = body['errors']
 
-      private 
-      def _construct_message(status, code, log_id, errors_array)
         error_string = "\nFintecture server errors : "
         error_string += "\n status: #{status} "
         error_string += "\n code: #{code}"
         error_string += "\n id : #{log_id}"
+
         errors_array.each do |error|
-          formated_error = error.map {|key,value| "   #{key}: #{value}"}.join("\n")
+          formated_error = error.map { |key, value| "   #{key}: #{value}" }.join("\n")
           error_string += "\n\n#{formated_error}"
         end
         error_string += "\n\n"
-        error_string
+
+        {
+          type: 'Fintecture api',
+          status: status,
+          errors: errors_array,
+          error_string: error_string
+        }.to_json
+      end
+
+      def _construct_message_error(res, body)
+        status = res.status
+        error = body['meta']
+
+        error_string = "\nFintecture server errors : "
+        error_string += "\n status: #{status} "
+
+        formated_error = error.map { |key, value| "   #{key}: #{value}" }.join("\n")
+        error_string += "\n\n#{formated_error}"
+
+        error_string += "\n\n"
+
+        {
+          type: 'Fintecture api',
+          status: status,
+          errors: [error],
+          error_string: error_string
+        }.to_json
       end
     end
   end
-end
+end

data/lib/fintecture/faraday/authentication/connection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'base64'
 require 'faraday'
 require 'uri'
@@ -9,112 +11,130 @@ module Fintecture
     module Authentication
       class Connection
         class << self
-
           def connection(url)
             ::Faraday.new(url: url) do |faraday|
               faraday.request :url_encoded
-              faraday.adapter  ::Faraday.default_adapter
+              faraday.adapter ::Faraday.default_adapter
             end
           end
 
-          def post(url:, req_body: nil, custom_content_type: nil, bearer: nil, secure_headers: false, additional_headers: nil)
+          def post(url:, req_body: nil, client: nil, custom_content_type: nil, bearer: nil, secure_headers: false, additional_headers: nil, disableAuthorization: nil)
+            @client = client
             conn = connection(url)
-
             res = conn.post do |req|
               req.options.params_encoder = Faraday::DisabledEncoder
-              req.headers = req_headers(custom_content_type, bearer, secure_headers, additional_headers, method: 'post', body: req_body, url: url)
+              req.headers = req_headers(custom_content_type, bearer, secure_headers, additional_headers, disableAuthorization,
+                                        method: 'post', body: req_body, url: url)
               req.body = req_body
             end
 
             !res.success? ? Fintecture::ApiException.error(res) : res
           end
 
-          def get(url:, req_body: nil, custom_content_type: nil, bearer: nil, secure_headers: false, additional_headers: nil)
+          def get(url:, req_body: nil, client: nil, custom_content_type: nil, bearer: nil, secure_headers: false, additional_headers: nil, disableAuthorization: nil)
+            @client = client
             conn = connection(url)
 
             res = conn.get do |req|
               req.options.params_encoder = Faraday::DisabledEncoder
-              req.headers = req_headers(custom_content_type, bearer, secure_headers, additional_headers, method: 'get', url: url)
+              req.headers = req_headers(custom_content_type, bearer, secure_headers, additional_headers, disableAuthorization,
+                                        method: 'get', url: url)
               req.body = req_body
             end
 
             !res.success? ? Fintecture::ApiException.error(res) : res
           end
 
-          def req_headers(custom_content_type, bearer, secure_headers, additional_headers, method: '', body: {}, url:)
+          def delete(url:, req_body: nil, client: nil, custom_content_type: nil, bearer: nil, secure_headers: false, additional_headers: nil, disableAuthorization: nil)
+            @client = client
+            conn = connection(url)
+
+            res = conn.delete do |req|
+              req.options.params_encoder = Faraday::DisabledEncoder
+              req.headers = req_headers(custom_content_type, bearer, secure_headers, additional_headers, disableAuthorization,
+                                        method: 'delete', body: req_body, url: url)
+              req.body = req_body
+            end
+
+            !res.success? ? Fintecture::ApiException.error(res) : res
+          end
 
-            client_token = Base64.strict_encode64("#{Fintecture.app_id}:#{Fintecture.app_secret}")
+          def req_headers(custom_content_type, bearer, secure_headers, additional_headers, disableAuthorization, url:, method: '', body: {})
+            if !additional_headers.nil? && !additional_headers.is_a?(Hash)
+              raise Fintecture::ValidationException, 'additional_headers must be an object'
+            end
 
-            {
-                'Accept' => 'application/json',
-                'User-Agent' => "Fintecture Ruby SDK v #{Fintecture::VERSION}",
-                'Authorization' => bearer ? bearer : "Basic #{client_token}",
-                'Content-Type' => custom_content_type ? custom_content_type : 'application/x-www-form-urlencoded',
-            }.merge(secure_headers ? req_secure_headers(additional_headers, body: body, url: url, method: method) : {})
+            client_token = Base64.strict_encode64("#{@client.app_id}:#{@client.app_secret}")
 
+            headers = {
+              'Accept' => 'application/json',
+              'User-Agent' => "Fintecture Ruby SDK v #{Fintecture::VERSION}",
+              'Content-Type' => custom_content_type || 'application/x-www-form-urlencoded'
+            }
+            headers['Authorization'] = bearer || "Basic #{client_token}" unless disableAuthorization
+            headers = headers.merge(additional_headers) unless additional_headers.nil?
+            headers.merge(secure_headers ? req_secure_headers(body: body, url: url, method: method) : {})
           end
 
-          def req_secure_headers(additional_headers, body: {}, url: '', method: '')
-            raise Fintecture::ValidationException.new('additional_headers must be an object') if additional_headers != nil && !additional_headers.is_a?(Hash) 
-          
-            payload = ( body.class.name == 'String' ? body : body.to_s )
+          def req_secure_headers(body: {}, url: '', method: '')
+            payload = (body.instance_of?(String) ? body : body.to_s)
             path_name = URI(url).path
             search_params = URI(url).query
 
-
             request_target = search_params ? "#{method.downcase} #{path_name}?#{search_params}" : "#{method.downcase} #{path_name}"
             date = Fintecture::Utils::Date.header_time.to_s
             digest = load_digest(payload)
             x_request_id = Fintecture::Utils::Crypto.generate_uuid
 
-
             headers = {
-                'Date' => date,
-                'X-Request-ID' => x_request_id
+              'Date' => date,
+              'X-Request-ID' => x_request_id
             }.merge(payload ? digest : {})
 
-            # Add additional_headers if exists
-            headers = headers.merge(additional_headers) if additional_headers != nil
-
-
-            headers['Signature'] = Fintecture::Utils::Crypto.create_signature_header({'(request-target)' => request_target}.merge(headers))
+            headers['Signature'] =
+              Fintecture::Utils::Crypto.create_signature_header(
+                { '(request-target)' => request_target }.merge(headers), @client
+              )
             headers
           end
 
           def load_digest(payload)
-            {'Digest' => "SHA-256=#{Fintecture::Utils::Crypto.hash_base64(payload)}"}
+            { 'Digest' => "SHA-256=#{Fintecture::Utils::Crypto.hash_base64(payload)}" }
           end
 
         end
       end
     end
 
-
     module DisabledEncoder
       class << self
         extend Forwardable
         def_delegators :'Faraday::Utils', :escape, :unescape
       end
-  
 
       def self.encode(params)
         return nil if params.nil?
-  
-        query_string = "#{params.map{|key, value| "#{key}=#{value}"}.join('&')}"
-        
+
+        newParams = {}
+        params.each do |key, value|
+          if value.instance_of?(Hash)
+            value.each do |subkey, subvalue|
+              newParams["#{key}[#{subkey}]"] = subvalue
+            end
+          else
+            newParams[key] = value
+          end
+        end
+
+        newParams.map { |key, value| "#{key}=#{value}" }.join('&').to_s
       end
-  
 
-  
       class << self
         attr_accessor :sort_params
       end
-  
+
       # Useful default for OAuth and caching.
       @sort_params = true
     end
   end
 end
-
-
-

data/lib/fintecture/pis_client.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'fintecture/api/pis/connect'
+require 'fintecture/api/pis/request_to_pay'
+require 'fintecture/api/pis/payments'
+require 'fintecture/api/pis/initiate'
+require 'fintecture/api/pis/refund'
+require 'fintecture/api/pis/settlements'
+
+require 'fintecture/api/ressources/providers'
+require 'fintecture/api/ressources/applications'
+require 'fintecture/api/ressources/test_accounts'
+
+module Fintecture
+  class PisClient
+    @environment = %w[local test sandbox production].freeze
+
+    def initialize(config)
+      @app_id = config[:app_id]
+      @app_secret = config[:app_secret]
+      @private_key = config[:private_key]
+
+      environment = config[:environment].downcase
+      unless environment.include?(environment)
+        raise "#{environment} not a valid environment, options are [#{environment.join(', ')}]"
+      end
+
+      @environment = config[:environment]
+    end
+
+    # Getters
+    attr_reader :app_id, :app_secret, :private_key, :environment, :token, :token_expires_in
+
+    #  Methodes
+    def generate_token
+      res = Fintecture::Authentication.get_access_token self
+      body = JSON.parse res.body
+
+      @token = body['access_token']
+      @token_expires_in = body['expires_in']
+
+      body
+    end
+
+    def connect(payload, state, redirect_uri = nil, origin_uri = nil)
+      res = Fintecture::Pis::Connect.generate self, Marshal.load(Marshal.dump(payload)), state, redirect_uri, origin_uri
+
+      JSON.parse res.body
+    end
+
+    def request_to_pay(payload, x_language, redirect_uri = nil)
+      res = Fintecture::Pis::RequestToPay.generate self, Marshal.load(Marshal.dump(payload)), x_language, redirect_uri
+
+      JSON.parse res.body
+    end
+
+    def initiate(payload, provider_id, redirect_uri, state = nil)
+      res = Fintecture::Pis::Initiate.generate self, Marshal.load(Marshal.dump(payload)), provider_id, redirect_uri,
+                                               state
+
+      JSON.parse res.body
+    end
+
+    def payments(session_id = nil)
+      res = Fintecture::Pis::Payments.get self, session_id
+
+      JSON.parse res.body
+    end
+
+    def refund(session_id, amount = nil)
+      res = Fintecture::Pis::Refund.generate self, session_id, amount
+
+      JSON.parse res.body
+    end
+
+    def settlements(settlement_id = nil)
+      res = Fintecture::Pis::Settlements.get self, settlement_id
+
+      JSON.parse res.body
+    end
+
+    def providers(provider_id: nil, paramsProviders: nil)
+      res = Fintecture::Ressources::Providers.get self, provider_id, paramsProviders
+
+      JSON.parse res.body
+    end
+
+    def applications
+      res = Fintecture::Ressources::Applications.get self
+
+      JSON.parse res.body
+    end
+
+    def test_accounts(provider_id = nil)
+      res = Fintecture::Ressources::TestAccounts.get self, provider_id
+
+      JSON.parse res.body
+    end
+  end
+end

data/lib/fintecture/utils/constants.rb

@@ -1,14 +1,11 @@
-
-
+# frozen_string_literal: true
 
 module Fintecture
   module Utils
     module Constants
-
-      SIGNEDHEADERPARAMETERLIST = %w[(request-target) Date Digest X-Request-ID];
-      PSU_TYPES = %w[retail corporate all]
-      SCOPES = %w[pis ais]
-
+      SIGNEDHEADERPARAMETERLIST = %w[(request-target) Date Digest X-Request-ID].freeze
+      PSU_TYPES = %w[retail corporate all].freeze
+      SCOPES = %w[pis ais].freeze
     end
   end
-end
+end

data/lib/fintecture/utils/crypto.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'securerandom'
 require 'openssl'
 require 'base64'
@@ -10,39 +12,38 @@ module Fintecture
   module Utils
     class Crypto
       class << self
-
         def generate_uuid
           SecureRandom.uuid
         end
 
         def generate_uuid_only_chars
-          generate_uuid.gsub!('-','')
+          generate_uuid.gsub!('-', '')
         end
 
         def sign_payload(payload)
           payload = payload.to_json.to_s if payload.is_a? Hash
-          digest = OpenSSL::Digest::SHA256.new
-          private_key = OpenSSL::PKey::RSA.new(Fintecture.private_key)
+          digest = OpenSSL::Digest.new('SHA256')
+          private_key = OpenSSL::PKey::RSA.new(@client.private_key)
 
           begin
             signature = private_key.sign(digest, payload)
             Base64.strict_encode64(signature)
-          rescue
-            raise Fintecture::CryptoException.new('error during signature')
+          rescue StandardError
+            raise Fintecture::CryptoException, 'error during signature'
           end
         end
 
         def decrypt_private(digest)
           digest = URI.unescape digest
           encrypted_string = Base64.decode64(digest)
-          private_key = OpenSSL::PKey::RSA.new(Fintecture.private_key)
+          private_key = OpenSSL::PKey::RSA.new(@client.private_key)
 
           begin
             private_key.private_decrypt(encrypted_string, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
           rescue OpenSSL::PKey::RSAError => e
-            raise Fintecture::CryptoException.new("error while decrypt, #{e.message}")
-          rescue
-            raise Fintecture::CryptoException.new('error during decryption')
+            raise Fintecture::CryptoException, "error while decrypt, #{e.message}"
+          rescue StandardError
+            raise Fintecture::CryptoException, 'error during decryption'
           end
         end
 
@@ -51,12 +52,11 @@ module Fintecture
           Base64.strict_encode64(digest)
         end
 
-        def create_signature_header(headers)
+        def create_signature_header(headers, client)
+          @client = client
           signing = []
           header = []
 
-
-
           Fintecture::Utils::Constants::SIGNEDHEADERPARAMETERLIST.each do |param|
             next unless headers[param]
 
@@ -64,15 +64,12 @@ module Fintecture
             signing << "#{param_low}: #{headers[param]}"
             header << param_low
           end
-          
 
           # Double quote in join needed. If not we will get two slashes \\n
           signature = sign_payload signing.join("\n")
-          'keyId="' + Fintecture.app_id + '",algorithm="rsa-sha256",headers="' + header.join(' ') + '",signature="' + signature + '"'
-           
+          "keyId=\"#{@client.app_id}\",algorithm=\"rsa-sha256\",headers=\"#{header.join(' ')}\",signature=\"#{signature}\""
         end
-
       end
     end
   end
-end
+end

data/lib/fintecture/utils/date.rb

@@ -1,15 +1,15 @@
+# frozen_string_literal: true
+
 require 'time'
 
 module Fintecture
   module Utils
     class Date
       class << self
-
         def header_time
-          Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S GMT")
+          Time.now.utc.strftime('%a, %d %b %Y %H:%M:%S GMT')
         end
-
       end
     end
   end
-end
+end