fintecture 0.1.1

data/README.md

@@ -0,0 +1,113 @@
+# Fintecture
+
+Fintecture is connected with most European banks and enables a user to initiate a payment directly from their bank account. This results to a bank transfer sent from the user's bank account directly to your bank account, skipping all intermediaries. Within the SEPA region, transfers take between 10 seconds to 1 business day to arrive on your bank account. No hidden fees. Check out [our website](https://fintecture.com/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fintecture', '~> 0.1.0'
+```
+
+or install it through our github repository
+
+```ruby
+gem 'fintecture', github: 'Fintecture/fintecture-sdk-ruby'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fintecture
+
+## Usage
+
+Get started by subscribing to a free developer account. Join today to get access to our sandbox by registering on the [developer console](https://console.fintecture.com) by creating your first sets of API Keys. When creating an account, specify you are an ECOMMERCE. When you’re ready to deploy to production, just go through the Activation Form in your console. Once the Fintecture Team activates your account, you’ll be ready to start receiving real bank transfers directly on the bank account specified during activation.
+
+Initialize your client credentials
+
+```ruby
+Fintecture.app_id = 'your_app_id'
+Fintecture.app_secret = 'your_app_secret'
+Fintecture.app_private_key = %q(your_app_private_key)
+```
+    
+    
+#### Environments
+
+By default `sandbox` is the initial environment, but you can change to sandbox by doing
+
+```ruby
+Fintecture.environment = 'sandbox'
+```
+
+You can also see the available environments
+
+    Fintecture::ENVIRONMENTS
+     => ["sandbox", "production"]
+
+### Authentication     
+    
+
+#### Access token
+
+```ruby
+Fintecture::Authentication.access_token
+```
+
+### Connect 
+
+#### Get connect URL
+```ruby
+payment_attrs = {
+    amount: 123,
+    currency: 'EUR',
+    order_id: 123,
+    customer_id: 123,
+    customer_full_name: 'John Doe',
+    customer_email: 'john.doe@email.com',
+    customer_ip: '127.0.0.1',
+    end_to_end_id: '5f78e902907e4209aa8df63659b05d24', # uuid optional
+    redirect_uri: '',
+    origin_uri: ''
+}
+url = Fintecture::Connect.connect_url_pis payment_attrs
+```
+    
+#### Verify URL parameters
+
+```ruby
+callback_params = {
+    session_id: 'uri_session_id',
+    status: 'uri_status',
+    customer_id: 'uri_customer_id',
+    provider: 'uri_provider',
+    state: 'uri_state',
+    s: 'uri_s'
+}
+
+Fintecture::Connect.verify_url_parameters callback_params
+```
+This function returns `true` if the parameters have verified, `false` in other case.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Fintecture/fintecture-sdk-ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [GPL-3.0 License](http://www.gnu.org/licenses/gpl-3.0.txt).
+
+## Code of Conduct
+
+Everyone interacting in the Fintecture project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/Fintecture/fintecture-sdk-ruby/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fintecture"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/fintecture.gemspec

@@ -0,0 +1,43 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fintecture/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fintecture"
+  spec.version       = Fintecture::VERSION
+  spec.authors       = ['Fintecture']
+  spec.email         = ["alvaro.fernandez@nazaries.com"]
+
+  spec.summary       = 'Short summary'
+  spec.description   = 'Longer summary'
+  spec.homepage      = "http://fintecture.com"
+  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/Fintecture/fintecture-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('..', __FILE__)) 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", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_dependency'faraday'
+end

data/lib/fintecture/api/base_url.rb

@@ -0,0 +1,28 @@
+module Fintecture
+  module Api
+    module BaseUrl
+
+      FINTECTURE_OAUTH_URL = {
+          local: 'http://localhost:3000/oauth',
+          test: 'https://oauth-sandbox-test.fintecture.com/oauth',
+          sandbox: 'https://oauth-sandbox.fintecture.com/oauth',
+          production: 'https://oauth.fintecture.com/oauth'
+      }
+
+      FINTECTURE_API_URL = {
+          local: 'http://localhost:3000',
+          test: 'https://api-sandbox-test.fintecture.com',
+          sandbox: 'https://api-sandbox.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/api/endpoints/authentication.rb

@@ -0,0 +1,13 @@
+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

data/lib/fintecture/authentication.rb

@@ -0,0 +1,76 @@
+require 'json'
+require 'faraday'
+
+module Fintecture
+  class Authentication
+    class << self
+
+      def authorize(redirect_uri, state = nil)
+        query_string = "?#{{
+            response_type: 'code',
+            app_id: Fintecture.app_id,
+            redirect_uri: redirect_uri,
+            state: state
+        }.map{|key, value| "#{key}=#{value}"}.join('&')}"
+
+        ::Faraday.get "#{token_authorize_endpoint}#{query_string}"
+      end
+
+      def access_token(auth_code =  nil)
+        body = access_token_data auth_code
+
+        Fintecture::Faraday::Authentication::Connection.post url: access_toke_url, req_body: body
+      end
+
+      def refresh_token(refresh_token)
+        body = refresh_token_data refresh_token
+
+        Fintecture::Faraday::Authentication::Connection.post url: refresh_token_url, req_body: body
+      end
+
+      private
+
+      def base_url
+        Fintecture::Api::BaseUrl::FINTECTURE_OAUTH_URL[Fintecture.environment.to_sym]
+      end
+
+      def token_authorize_endpoint
+        "#{base_url}#{Fintecture::Api::Endpoints::Authentication::OAUTH_TOKEN_AUTHORIZE}"
+      end
+
+      def access_toke_url
+        "#{base_url}#{Fintecture::Api::Endpoints::Authentication::OAUTH_ACCESS_TOKEN}"
+      end
+
+      def refresh_token_url
+        "#{base_url}#{Fintecture::Api::Endpoints::Authentication::OAUTH_REFRESH_TOKEN}"
+      end
+
+      def access_token_data(auth_code)
+        data =  {
+            scope: 'PIS',
+            app_id: Fintecture.app_id,
+            grant_type: 'client_credentials'
+        }
+
+        if auth_code
+          data = {
+              scope: 'AIS',
+              code: auth_code,
+              grant_type: 'authorization_code'
+          }
+        end
+
+        data
+      end
+
+      def refresh_token_data(refresh_token)
+        {
+            grant_type: 'refresh_token',
+            refresh_token: refresh_token
+        }
+      end
+
+    end
+  end
+end

data/lib/fintecture/connect.rb

@@ -0,0 +1,130 @@
+require 'base64'
+require 'json'
+
+module Fintecture
+  class Connect
+    class << self
+      SIGNATURE_TYPE = 'rsa-sha256'.freeze
+
+      def connect_url_pis(payment_attrs = nil)
+          connect_url(payment_attrs: payment_attrs, type: 'pis')
+      end
+
+      def connect_url(payment_attrs: nil, type: 'pis')
+        @payment_attrs = payment_attrs
+        @type = type
+
+        validate_payment_integrity
+
+        payment_attrs[:end_to_end_id] ||= Fintecture::Utils::Crypto.generate_uuid
+        payload = build_payload
+        state = build_state(payload).to_json.to_s
+
+        "#{base_url}/#{type}?state=#{Base64.strict_encode64(state)}"
+      end
+
+      def verify_url_parameters(parameters = nil)
+          @post_payment_attrs = parameters
+
+          validate_post_payment_integrity
+
+          decrypted =  Fintecture::Utils::Crypto.decrypt_private parameters[:s]
+          local_digest = build_local_digest parameters
+
+          decrypted == local_digest
+      end
+
+      private
+
+      def raise_if_klass_mismatch(target, klass, param_name = nil)
+        return if target.is_a? klass
+
+        raise "invalid #{param_name ? param_name : 'parameter'} format, the parameter should be a #{klass} instead a #{target.class.name}"
+      end
+
+      def validate_payment_integrity
+        raise_if_klass_mismatch @payment_attrs, Hash, 'payment_attrs'
+
+        error_msg = 'invalid payment payload parameter'
+
+        raise "#{error_msg} type" unless %w[pis ais].include? @type
+
+        %i[amount currency order_id customer_id customer_full_name customer_email customer_ip].each do |param|
+          raise "#{error_msg} #{param.to_s}" if @payment_attrs[param].nil?
+        end
+      end
+
+      def validate_post_payment_integrity
+        raise_if_klass_mismatch @post_payment_attrs, Hash, 'post_payment_attrs'
+
+        %i[s state status session_id customer_id provider].each do |param|
+          raise "invalid post payment parameter #{param.to_s}" if @post_payment_attrs[param].nil?
+        end
+      end
+
+      def build_payload
+        attributes = {
+            amount: @payment_attrs[:amount],
+            currency: @payment_attrs[:currency],
+            communication: @payment_attrs[:order_id].to_s,
+            end_to_end_id: @payment_attrs[:end_to_end_id]
+        }
+
+        meta = {
+            psu_local_id: @payment_attrs[:customer_id],
+            psu_name: @payment_attrs[:customer_full_name],
+            psu_email: @payment_attrs[:customer_email],
+            psu_ip: @payment_attrs[:customer_ip]
+        }
+
+        data = {
+            type: 'SEPA',
+            attributes: attributes,
+        }
+
+        {
+            data: data,
+            meta: meta
+        }
+      end
+
+      def build_signature(payload)
+        Fintecture::Utils::Crypto.sign_payload payload
+      end
+
+      def build_state(payload)
+        access_token_response = Fintecture::Authentication.access_token
+        access_token = JSON.parse(access_token_response.body)['access_token']
+        {
+            app_id: Fintecture.app_id,
+            access_token: access_token,
+            signature_type: SIGNATURE_TYPE,
+            signature: build_signature(payload),
+            redirect_uri: @payment_attrs[:redirect_uri] || '',
+            origin_uri: @payment_attrs[:origin_uri] || '',
+            order_id: @payment_attrs[:order_id],
+            payload: payload,
+            version: Fintecture::VERSION,
+        }
+      end
+
+      def build_local_digest(parameters)
+        test_string = Base64.strict_encode64({
+             app_id: Fintecture.app_id,
+             app_secret: Fintecture.app_secret,
+             session_id: parameters[:session_id],
+             status: parameters[:status],
+             customer_id: parameters[:customer_id],
+             provider: parameters[:provider],
+             state: parameters[:state]
+         }.to_json.to_s)
+
+        Fintecture::Utils::Crypto.hash_base64 test_string
+      end
+
+      def base_url
+        Fintecture::Api::BaseUrl::FINTECTURE_CONNECT_URL[Fintecture.environment.to_sym]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'base64'
+require 'faraday'
+
+module Fintecture
+  module Faraday
+    module Authentication
+      class Connection
+        class << self
+
+          def connection(url)
+            ::Faraday.new(url: url) do |faraday|
+              faraday.request :url_encoded
+              faraday.adapter  ::Faraday.default_adapter
+            end
+          end
+
+          def post(url:, req_body:)
+            conn = connection(url)
+
+            conn.post do |req|
+              req.headers = req_headers
+              req.body = req_body
+            end
+          end
+
+          def req_headers
+            client_token = Base64.strict_encode64("#{Fintecture.app_id}:#{Fintecture.app_secret}")
+
+            {
+                'Accept' => 'application/json',
+                'User-Agent' => "Fintecture Ruby SDK v #{Fintecture::VERSION}",
+                'Authorization' => "Basic #{client_token}",
+                'Content-Type' => 'application/x-www-form-urlencoded',
+            }
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/fintecture/utils/crypto.rb

@@ -0,0 +1,48 @@
+require 'securerandom'
+require 'openssl'
+require 'base64'
+require 'json'
+
+
+module Fintecture
+  module Utils
+    class Crypto
+      class << self
+
+        def generate_uuid
+          SecureRandom.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.app_private_key)
+
+          begin
+            signature = private_key.sign(digest, payload)
+            Base64.strict_encode64(signature)
+          rescue
+            raise 'error during signature'
+          end
+        end
+
+        def decrypt_private(digest)
+          encrypted_string = Base64.decode64(digest)
+          private_key = OpenSSL::PKey::RSA.new(Fintecture.app_private_key)
+
+          begin
+            private_key.private_decrypt(encrypted_string, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
+          rescue
+            raise 'error during decryption'
+          end
+        end
+
+        def hash_base64(plain_text)
+          Base64.strict_encode64(Digest::SHA2.new(256).hexdigest(plain_text))
+        end
+
+      end
+    end
+  end
+end

data/lib/fintecture/version.rb

@@ -0,0 +1,3 @@
+module Fintecture
+  VERSION = "0.1.1"
+end

data/lib/fintecture.rb

@@ -0,0 +1,80 @@
+require 'logger'
+require 'uri'
+require 'faraday'
+
+#ToRemove
+require 'openssl'
+require 'cgi'
+
+# Version
+require 'fintecture/version'
+
+# Modules
+require 'fintecture/connect'
+require 'fintecture/authentication'
+
+# Utilities
+require 'fintecture/utils/crypto'
+
+# Endpoints
+require 'fintecture/api/base_url'
+require 'fintecture/api/endpoints/authentication'
+
+# Connections
+require 'fintecture/faraday/authentication/connection'
+
+
+module Fintecture
+  @log_level = nil
+  @logger = nil
+  @environment = 'sandbox'
+
+  ENVIRONMENTS = %w[sandbox production].freeze
+
+  class << self
+    attr_accessor :app_id, :app_secret, :app_private_key
+
+    def environment=(environment)
+      environment = environment.downcase
+
+      raise "#{environment} not a valid environment, options are [#{ENVIRONMENTS.join(', ')}]" unless ENVIRONMENTS.include?(environment)
+
+      @environment = environment
+    end
+
+    def environment
+      @environment
+    end
+
+    # Logging
+    LEVEL_DEBUG = Logger::DEBUG
+    LEVEL_ERROR = Logger::ERROR
+    LEVEL_INFO = Logger::INFO
+
+    def log_level
+      @log_level
+    end
+
+    def log_level=(val)
+      if val == "debug"
+        val = LEVEL_DEBUG
+      elsif val == "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
+
+    def logger
+      @logger
+    end
+
+    def logger=(val)
+      @logger = val
+    end
+
+  end
+end