virementmaitrise 0.6.2

data/lib/virementmaitrise/exceptions.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'virementmaitrise/utils/json_parser'
+
+module VirementMaitrise
+  class ValidationException < StandardError; end
+
+  class CryptoException < StandardError; end
+
+  class ApiException < StandardError
+    attr_reader :status, :code, :log_id, :errors
+
+    def initialize(status:, code: nil, log_id: nil, errors: [])
+      @status = status
+      @code = code
+      @log_id = log_id
+      @errors = errors
+
+      error_message = build_message
+      super(error_message)
+    end
+
+    private
+
+    def build_message
+      msg = "API Error (status: #{@status})"
+      msg += ", code: #{@code}" if @code
+      msg += ", log_id: #{@log_id}" if @log_id
+
+      if @errors.any?
+        formatted_errors = @errors.map do |error|
+          if error.is_a?(Hash)
+            error.map { |key, value| "   #{key}: #{value}" }.join("\n")
+          else
+            error.to_s
+          end
+        end
+        msg += "\nErrors:\n#{formatted_errors.join("\n")}"
+      end
+
+      msg
+    end
+  end
+
+  module ApiExceptionHelper
+    def self.error(res)
+      body = VirementMaitrise::Utils::JsonParser.safe_parse(res.body, context: 'error response')
+
+      code = body['code'] unless body['code'].to_s.strip.empty?
+      log_id = body['log_id'] unless body['log_id'].to_s.strip.empty?
+      errors_array = body['errors'] || body['meta'] || []
+
+      raise VirementMaitrise::ApiException.new(
+        status: res.status,
+        code: code,
+        log_id: log_id,
+        errors: errors_array.compact
+      )
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'faraday'
+require 'uri'
+require 'virementmaitrise/utils/crypto'
+require 'virementmaitrise/utils/date'
+
+module VirementMaitrise
+  module Faraday
+    module Authentication
+      class Connection
+        class << self
+          def connection(url)
+            ::Faraday.new(url: url) do |faraday|
+              faraday.adapter ::Faraday.default_adapter
+            end
+          end
+
+          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
+
+              encoded_body =
+                if custom_content_type == 'application/json'
+                  req_body.is_a?(String) ? req_body : req_body.to_json
+                else
+                  URI.encode_www_form(req_body || {})
+                end
+
+              req.headers = req_headers(custom_content_type, bearer, secure_headers, additional_headers, disableAuthorization,
+                                        method: 'post', body: encoded_body, url: url)
+              req.body = encoded_body
+            end
+
+            !res.success? ? VirementMaitrise::ApiExceptionHelper.error(res) : res
+          end
+
+          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
+
+              encoded_body =
+                if req_body.nil?
+                  nil
+                elsif custom_content_type == 'application/json'
+                  req_body.is_a?(String) ? req_body : req_body.to_json
+                else
+                  URI.encode_www_form(req_body)
+                end
+
+              req.headers = req_headers(custom_content_type, bearer, secure_headers, additional_headers, disableAuthorization,
+                                        method: 'get', body: encoded_body, url: url)
+              req.body = encoded_body
+            end
+
+            !res.success? ? VirementMaitrise::ApiExceptionHelper.error(res) : res
+          end
+
+          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
+
+              encoded_body =
+                if req_body.nil?
+                  nil
+                elsif custom_content_type == 'application/json'
+                  req_body.is_a?(String) ? req_body : req_body.to_json
+                else
+                  URI.encode_www_form(req_body)
+                end
+
+              req.headers = req_headers(custom_content_type, bearer, secure_headers, additional_headers, disableAuthorization,
+                                        method: 'delete', body: encoded_body, url: url)
+              req.body = encoded_body
+            end
+
+            !res.success? ? VirementMaitrise::ApiExceptionHelper.error(res) : res
+          end
+
+          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 VirementMaitrise::ValidationException, 'additional_headers must be an object'
+            end
+
+            client_token = Base64.strict_encode64("#{@client.app_id}:#{@client.app_secret}")
+
+            headers = {
+              'Accept' => 'application/json',
+              'User-Agent' => "Virement Maitrisé Ruby SDK v #{VirementMaitrise::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(body: nil, url: '', method: '')
+            payload = if body.nil?
+                        ''
+                      elsif body.is_a?(String)
+                        body
+                      else
+                        body.to_json
+                      end
+            path_name = URI(url).path
+            search_params = URI(url).query
+
+            path_and_query = [path_name, search_params].compact.join('?')
+            request_target = "#{method.downcase} #{path_and_query}"
+            date = VirementMaitrise::Utils::Date.header_time.to_s
+            x_request_id = VirementMaitrise::Utils::Crypto.generate_uuid
+
+            should_include_digest = %w[post put patch].include?(method.downcase) && body && !payload.empty?
+            digest = should_include_digest ? load_digest(payload) : {}
+
+            headers = {
+              'Date' => date,
+              'X-Request-ID' => x_request_id
+            }.merge(digest)
+
+            headers['Signature'] =
+              VirementMaitrise::Utils::Crypto.create_signature_header(
+                { '(request-target)' => request_target }.merge(headers), @client
+              )
+            headers
+          end
+
+          def load_digest(payload)
+            { 'Digest' => "SHA-256=#{VirementMaitrise::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?
+
+        new_params = {}
+        params.each do |key, value|
+          if value.instance_of?(Hash)
+            value.each do |subkey, subvalue|
+              new_params["#{key}[#{subkey}]"] = subvalue
+            end
+          else
+            new_params[key] = value
+          end
+        end
+
+        new_params.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/virementmaitrise/pis_client.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'virementmaitrise/api/pis/connect'
+require 'virementmaitrise/api/pis/request_to_pay'
+require 'virementmaitrise/api/pis/payments'
+require 'virementmaitrise/api/pis/initiate'
+require 'virementmaitrise/api/pis/refund'
+require 'virementmaitrise/api/pis/settlements'
+
+require 'virementmaitrise/api/ressources/providers'
+require 'virementmaitrise/api/ressources/applications'
+require 'virementmaitrise/api/ressources/test_accounts'
+require 'virementmaitrise/utils/json_parser'
+
+module VirementMaitrise
+  class PisClient
+    DEFAULT_ENVIRONMENT = 'sandbox'
+    ENVIRONMENTS = %w[test sandbox production].freeze
+
+    def initialize(config)
+      raise ArgumentError, "app_id is required" if config[:app_id].nil?
+      @app_id = config[:app_id]
+      raise ArgumentError, "app_secret is required" if config[:app_secret].nil?
+      @app_secret = config[:app_secret]
+      raise ArgumentError, "private_key is required" if config[:private_key].nil?
+      @private_key = config[:private_key]
+
+      env_value = (config[:environment] || DEFAULT_ENVIRONMENT).to_s.downcase
+      unless ENVIRONMENTS.include?(env_value)
+        raise ArgumentError, "#{env_value} is not a valid environment. Options are [#{ENVIRONMENTS.join(', ')}]"
+      end
+
+      @environment = env_value
+    end
+
+    # Getters
+    attr_reader :app_id, :app_secret, :private_key, :environment, :token, :token_expires_in
+
+    private
+
+    def require_token!
+      raise VirementMaitrise::ValidationException, 'Token is required. Please call generate_token first.' if @token.nil?
+    end
+
+    public
+
+    #  Methodes
+    def generate_token
+      res = VirementMaitrise::Authentication.get_access_token self
+      body = VirementMaitrise::Utils::JsonParser.safe_parse(res.body, context: 'access token')
+
+      @token = body['access_token']
+      @token_expires_in = body['expires_in']
+
+      body
+    end
+
+    def connect(payload, state, redirect_uri = nil, origin_uri = nil, with_virtualbeneficiary: false)
+      require_token!
+      res = VirementMaitrise::Pis::Connect.generate self, payload.dup, state, redirect_uri, origin_uri, with_virtualbeneficiary: with_virtualbeneficiary
+
+      VirementMaitrise::Utils::JsonParser.safe_parse(res.body, context: 'connect')
+    end
+
+    def request_to_pay(payload, x_language, redirect_uri = nil)
+      require_token!
+      res = VirementMaitrise::Pis::RequestToPay.generate self, payload, x_language, redirect_uri
+
+      VirementMaitrise::Utils::JsonParser.safe_parse(res.body, context: 'request to pay')
+    end
+
+    def initiate(payload, provider_id, redirect_uri, state = nil)
+      require_token!
+      res = VirementMaitrise::Pis::Initiate.generate self, payload, provider_id, redirect_uri, state
+
+      VirementMaitrise::Utils::JsonParser.safe_parse(res.body, context: 'initiate')
+    end
+
+    def payments(session_id = nil, with_virtualbeneficiary: false)
+      require_token!
+      res = VirementMaitrise::Pis::Payments.get self, session_id, with_virtualbeneficiary: with_virtualbeneficiary
+
+      VirementMaitrise::Utils::JsonParser.safe_parse(res.body, context: 'payments')
+    end
+
+    def refund(session_id, amount = nil, user_id = nil)
+      require_token!
+      res = VirementMaitrise::Pis::Refund.generate self, session_id, amount, user_id
+
+      VirementMaitrise::Utils::JsonParser.safe_parse(res.body, context: 'refund')
+    end
+
+    def settlements(settlement_id = nil, include_payments = false)
+      require_token!
+      res = VirementMaitrise::Pis::Settlements.get self, settlement_id, include_payments
+
+      VirementMaitrise::Utils::JsonParser.safe_parse(res.body, context: 'settlements')
+    end
+
+    def providers(provider_id: nil, paramsProviders: nil)
+      res = VirementMaitrise::Ressources::Providers.get self, provider_id, paramsProviders
+
+      VirementMaitrise::Utils::JsonParser.safe_parse(res.body, context: 'providers')
+    end
+
+    def applications
+      res = VirementMaitrise::Ressources::Applications.get self
+
+      VirementMaitrise::Utils::JsonParser.safe_parse(res.body, context: 'applications')
+    end
+
+    def test_accounts(provider_id = nil)
+      res = VirementMaitrise::Ressources::TestAccounts.get self, provider_id
+
+      VirementMaitrise::Utils::JsonParser.safe_parse(res.body, context: 'test accounts')
+    end
+  end
+end

data/lib/virementmaitrise/utils/constants.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module VirementMaitrise
+  module Utils
+    module Constants
+      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

data/lib/virementmaitrise/utils/crypto.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'openssl'
+require 'base64'
+require 'json'
+require 'virementmaitrise/exceptions'
+require 'virementmaitrise/utils/constants'
+require 'cgi'
+
+module VirementMaitrise
+  module Utils
+    class Crypto
+      class << self
+        def generate_uuid
+          SecureRandom.uuid
+        end
+
+        def generate_uuid_only_chars
+          generate_uuid.gsub('-', '')
+        end
+
+        def sign_payload(payload)
+          payload = payload.to_json.to_s if payload.is_a? Hash
+          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 StandardError
+            raise VirementMaitrise::CryptoException, 'error during signature'
+          end
+        end
+
+        def decrypt_private(digest)
+          digest = CGI.unescape(digest)
+          encrypted_string = Base64.decode64(digest)
+          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 VirementMaitrise::CryptoException, "error while decrypt, #{e.message}"
+          rescue StandardError
+            raise VirementMaitrise::CryptoException, 'error during decryption'
+          end
+        end
+
+        def hash_base64(plain_text)
+          digest = Digest::SHA256.digest plain_text
+          Base64.strict_encode64(digest)
+        end
+
+        def create_signature_header(headers, client)
+          @client = client
+          signing = []
+          header = []
+
+          VirementMaitrise::Utils::Constants::SIGNEDHEADERPARAMETERLIST.each do |param|
+            next unless headers[param]
+
+            param_low = param.downcase
+            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=\"#{@client.app_id}\",algorithm=\"rsa-sha256\",headers=\"#{header.join(' ')}\",signature=\"#{signature}\""
+        end
+      end
+    end
+  end
+end

data/lib/virementmaitrise/utils/date.rb

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

data/lib/virementmaitrise/utils/json_parser.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module VirementMaitrise
+  module Utils
+    module JsonParser
+      class JsonParseException < StandardError
+        attr_reader :context, :raw_body, :parse_error
+
+        def initialize(message, context:, raw_body:, parse_error:)
+          super(message)
+          @context = context
+          @raw_body = raw_body
+          @parse_error = parse_error
+        end
+      end
+
+      def safe_parse(json_string, context: 'API response')
+        return {} if json_string.nil? || json_string.strip.empty?
+
+        JSON.parse(json_string)
+      rescue JSON::ParserError => e
+        truncated_body = json_string.length > 200 ? "#{json_string[0..200]}..." : json_string
+
+        raise JsonParseException.new(
+          "Failed to parse #{context}. JSON parse error: #{e.message}. Response body: #{truncated_body}",
+          context: context,
+          raw_body: json_string,
+          parse_error: e
+        )
+      end
+
+      module_function :safe_parse
+    end
+  end
+end

data/lib/virementmaitrise/utils/query_builder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module VirementMaitrise
+  module Utils
+    module QueryBuilder
+
+      def build_query_string(params)
+        return '' if params.nil? || params.empty?
+
+        "?#{params.map { |key, value| "#{key}=#{value}" }.join('&')}"
+      end
+
+      module_function :build_query_string
+    end
+  end
+end

data/lib/virementmaitrise/utils/validation.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'virementmaitrise/exceptions'
+
+module VirementMaitrise
+  module Utils
+    class Validation
+      class << self
+        def raise_if_klass_mismatch(target, klass, param_name = nil)
+          return if target.is_a? klass
+
+          raise VirementMaitrise::ValidationException,
+                "invalid #{param_name || 'parameter'} format, the parameter should be a #{klass} instead a #{target.class.name}"
+        end
+
+        def raise_if_invalid_date_format(date)
+          return unless date
+
+          valid_format = date.match(/\d{4}-\d{2}-\d{2}/)
+          valid_date = begin
+            ::Date.strptime(date, '%Y-%m-%d')
+          rescue StandardError
+            false
+          end
+          return if valid_format && valid_date
+
+          raise VirementMaitrise::ValidationException, "invalids #{date} date, the format should be YYYY-MM-DD"
+        end
+      end
+    end
+  end
+end

data/lib/virementmaitrise/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module VirementMaitrise
+  VERSION = '0.6.2'
+end

data/lib/virementmaitrise.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'uri'
+require 'faraday'
+
+require 'openssl'
+require 'cgi'
+
+# Version
+require 'virementmaitrise/version'
+
+# Modules
+require 'virementmaitrise/api/auth/authentication'
+
+# Clients
+require 'virementmaitrise/pis_client'
+require 'virementmaitrise/ais_client'
+
+# Utilities
+require 'virementmaitrise/utils/crypto'
+require 'virementmaitrise/utils/json_parser'
+require 'virementmaitrise/utils/query_builder'
+require 'virementmaitrise/utils/validation'
+
+# Endpoints
+require 'virementmaitrise/base_url'
+require 'virementmaitrise/endpoints/authentication'
+require 'virementmaitrise/endpoints/ais'
+require 'virementmaitrise/endpoints/pis'
+require 'virementmaitrise/endpoints/ressources'
+
+# Connections
+require 'virementmaitrise/faraday/authentication/connection'
+
+module VirementMaitrise
+  @log_level = nil
+  @logger = nil
+
+  class << self
+    attr_accessor :logger
+    attr_reader :log_level
+
+    # Logging
+    LEVEL_DEBUG = Logger::DEBUG
+    LEVEL_ERROR = Logger::ERROR
+    LEVEL_INFO = Logger::INFO
+
+    def log_level=(val)
+      case val
+      when 'debug'
+        val = LEVEL_DEBUG
+      when 'info'
+        val = LEVEL_INFO
+      end
+
+      if !val.nil? && ![LEVEL_DEBUG, LEVEL_ERROR, LEVEL_INFO].include?(val)
+        raise ArgumentError, 'log_level should only be set to `nil`, `debug` or `info`'
+      end
+
+      @log_level = val
+    end
+  end
+end
+
+VirementMaitrise.log_level = ENV['FINTECTURE_LOG'] unless ENV['FINTECTURE_LOG'].nil?

data/virementmaitrise.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'virementmaitrise/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'virementmaitrise'
+  spec.version       = VirementMaitrise::VERSION
+  spec.authors       = ['Fintecture']
+  spec.email         = ['support@fintecture.com']
+
+  spec.required_ruby_version = '>= 2.7.0'
+
+  spec.summary       = 'SDK to allow easy and secure access to bank account data and payment initiation with Virement Maitrisé.'
+  spec.description   = 'Our APIs allow easy and secure access to bank account data and payment initiation. The account data accessible are account holder\'s personal information, account balances, transaction history and much more. The available payment methods depend on the banks implementation but typically are domestic transfers, SEPA credit transfer, instant SEPA credit transfer, fast payment scheme, and SWIFT international payments.'
+  spec.homepage      = 'https://www.virementmaitrise.societegenerale.eu'
+  spec.license       = 'GPL-3.0'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    # spec.metadata["allowed_push_host"] = 'http://mygemserver.com'
+
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/Virementmaitrise/virementmaitrise-sdk-ruby'
+    # spec.metadata["changelog_uri"] = spec.homepage
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_dependency 'faraday', '> 1.0'
+end