tikkie-api 0.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c0fb0212ecabd850a104349b9edff3fc279c90f9
-  data.tar.gz: dbce2933f3a3b0750f385d1c74bb53f232256824
+SHA256:
+  metadata.gz: c22db51585d284e809e24912acf561c023f9063da1669fdc49330dd223039f32
+  data.tar.gz: e7bf5498e81def5bbf47efa0800d9bb8dc1248cb154df1b227004ab7b2fc80f0
 SHA512:
-  metadata.gz: ed9a6a3f22a00360a990527fe9700c07ad68795db7bf2474523703467726aec375bb537d7dfb766bc0fe480b7bce1a74a38cc11bab7108d8b1a50fa62dd587f9
-  data.tar.gz: c60da0bf7f3b15499ea768389527161e0acaec5b4bbbcfc0f636862966a37406d2ef46a091c47c7b2d9539ca33c28a2c961c47a61c4bdcf4b4d2f59dba5899e0
+  metadata.gz: 1c99bc7d78ed22482810d6f12042fe0497ed298cee190c5a73404d9028ab408cf4770ad8650a6cab6bbe4b42b78c852b2e877fcdedc77c7d5a3ce5f778a1373b
+  data.tar.gz: b48d40c3a519e24a83582e5ccc1c66f882d09d16a5090f1ac628c4610c5c9e75ee2c5a8442d360adf13a60becf1f182424fe401186e2a07710e0004e37ea977c

data/.rubocop.yml

@@ -1,29 +1,53 @@
+require:
+  - rubocop-performance
+  - rubocop-rspec
+
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.4
   DisplayCopNames: true
   DisplayStyleGuide: true
+  Exclude:
+    - 'lib/tikkie/api/v1/**/*'
+    - 'spec/tikkie/api/v1/**/*'
+    - 'vendor/**/*'
+
+
+Layout/LineLength:
+  Enabled: false
+
 
 Metrics/AbcSize:
-  Max: 21
+  Max: 43
 
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/*'
 
 Metrics/CyclomaticComplexity:
-  Max: 7
-
-Metrics/LineLength:
-  Enabled: false
+  Max: 11
 
 Metrics/MethodLength:
   Enabled: false
 
+Metrics/PerceivedComplexity:
+  Max: 9
+
+
+RSpec/DescribedClass:
+  EnforcedStyle: explicit
+
+RSpec/ExampleLength:
+  Max: 12
+
+RSpec/MultipleExpectations:
+  Max: 8
+
+
 Style/Documentation:
   Exclude:
     - 'spec/**/*'
 
-Style/GuardClause:
+Style/FormatStringToken:
   Enabled: false
 
 Style/SafeNavigation:

data/.travis.yml

@@ -1,7 +1,11 @@
 sudo: false
 language: ruby
+cache: bundler
+before_install:
+  - gem update --system
+  - gem install bundler -v '< 2'
 rvm:
-  - 2.2.9
-  - 2.3.6
-  - 2.4.3
-before_install: gem install bundler -v 1.16.1
+  - 2.4.10
+  - 2.5.8
+  - 2.6.6
+  - 2.7.2

data/Gemfile

@@ -7,4 +7,6 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 # Specify your gem's dependencies in tikkie-api.gemspec
 gemspec
 
-gem 'rubocop', '~> 0.52.0'
+gem 'rubocop', '~> 0.79.0'
+gem 'rubocop-performance', '~> 1.6.1'
+gem 'rubocop-rspec', '~> 1.41.0'

data/Gemfile.lock

@@ -1,51 +1,54 @@
 PATH
   remote: .
   specs:
-    tikkie-api (0.1.0)
-      jwt (>= 1.0)
+    tikkie-api (2.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.5.2)
+    addressable (2.6.0)
       public_suffix (>= 2.0.2, < 4.0)
-    ast (2.3.0)
+    ast (2.4.1)
     crack (0.4.3)
       safe_yaml (~> 1.0.0)
     diff-lcs (1.3)
-    hashdiff (0.3.7)
-    jwt (2.1.0)
-    parallel (1.12.1)
-    parser (2.4.0.2)
-      ast (~> 2.3)
-    powerpack (0.1.1)
-    public_suffix (3.0.1)
+    hashdiff (0.3.8)
+    jaro_winkler (1.5.4)
+    jwt (2.2.2)
+    parallel (1.19.2)
+    parser (2.7.2.0)
+      ast (~> 2.4.1)
+    public_suffix (3.0.3)
     rainbow (3.0.0)
-    rake (10.5.0)
-    rspec (3.7.0)
-      rspec-core (~> 3.7.0)
-      rspec-expectations (~> 3.7.0)
-      rspec-mocks (~> 3.7.0)
-    rspec-core (3.7.1)
-      rspec-support (~> 3.7.0)
-    rspec-expectations (3.7.0)
+    rake (13.0.1)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-mocks (3.7.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-support (3.7.0)
-    rubocop (0.52.1)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rubocop (0.79.0)
+      jaro_winkler (~> 1.5.1)
       parallel (~> 1.10)
-      parser (>= 2.4.0.2, < 3.0)
-      powerpack (~> 0.1)
+      parser (>= 2.7.0.1)
       rainbow (>= 2.2.2, < 4.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (~> 1.0, >= 1.0.1)
-    ruby-progressbar (1.9.0)
-    safe_yaml (1.0.4)
+      unicode-display_width (>= 1.4.0, < 1.7)
+    rubocop-performance (1.6.1)
+      rubocop (>= 0.71.0)
+    rubocop-rspec (1.41.0)
+      rubocop (>= 0.68.1)
+    ruby-progressbar (1.10.1)
+    safe_yaml (1.0.5)
     timecop (0.9.1)
-    unicode-display_width (1.3.0)
+    unicode-display_width (1.6.1)
     webmock (2.3.2)
       addressable (>= 2.3.6)
       crack (>= 0.3.2)
@@ -56,12 +59,15 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.16)
-  rake (~> 10.0)
+  jwt (>= 1.0)
+  rake (~> 13.0)
   rspec (~> 3.0)
-  rubocop (~> 0.52.0)
+  rubocop (~> 0.79.0)
+  rubocop-performance (~> 1.6.1)
+  rubocop-rspec (~> 1.41.0)
   tikkie-api!
   timecop (~> 0.9)
   webmock (~> 2.3)
 
 BUNDLED WITH
-   1.16.1
+   1.17.3

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Peter Postma
+Copyright (c) 2018-2020 Kentaa BV
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,13 +1,44 @@
 # Tikkie API
 
-Unofficial Ruby library for communicating with the [Tikkie API](https://developer.abnamro.com/content/tikkie).
+[![Gem Version](https://badge.fury.io/rb/tikkie-api.svg)](https://badge.fury.io/rb/tikkie-api)
+[![Build Status](https://travis-ci.org/KentaaNL/tikkie-api.svg?branch=master)](https://travis-ci.org/KentaaNL/tikkie-api)
+[![Code Climate](https://codeclimate.com/github/KentaaNL/tikkie-api/badges/gpa.svg)](https://codeclimate.com/github/KentaaNL/tikkie-api)
+
+Unofficial Ruby library for communicating with the [Tikkie API](https://developer.abnamro.com/api-products/tikkie).
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Payment requests](#payment-requests)
+    - [Create a Payment request](#create-a-payment-request)
+    - [List Payment requests](#list-payment-requests)
+    - [Get Payment request](#get-payment-request)
+  - [Payments](#payments)
+    - [List Payments](#list-payments)
+    - [Get Payment](#get-payment)
+  - [Refunds](#refunds)
+    - [Create a Refund](#create-a-refund)
+    - [Get Refund](#get-refund)
+  - [Payment requests notification](#payment-requests-notification)
+    - [Create a subscription](#create-a-subscription)
+    - [Delete subscription](#delete-subscription)
+  - [Sandbox apps](#sandbox-apps)
+    - [Create a Sandbox app](#create-a-sandbox-app)
+- [Error handling](#error-handling)
+- [Notifications](#notifications)
+- [API support](#api-support)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'tikkie-api'
+gem 'tikkie-api', '~> 2.0'
 ```
 
 And then execute:
@@ -20,121 +51,240 @@ Or install it yourself as:
 
 ## Usage
 
-### Initialization
-
-First create a Tikkie configuration and specify your API key and the path to your private RSA key. See also the [developer documentation from ABN AMRO](https://developer.abnamro.com/get-started) to get started.
-
-Use the configuration to initialize a Tikkie client:
+Create a Tikkie client using your API key and an App token. If you don't have an App token yet, please read the [documentation about App tokens](https://developer.abnamro.com/api-products/tikkie/reference-documentation#section/Overview/App-token) or use the [Sandbox apps endpoint](#sandbox-apps) to create an App token in the sandbox environment.
 
 ```ruby
 require 'tikkie/api'
 
-config = Tikkie::Api::Configuration.new("your_api_key", "private_rsa.pem")
-client = Tikkie::Api::Client.new(config)
+client = Tikkie::Api::Client.new(api_key: "12345", app_token: "abcdef")
 ```
 
-### Platforms
-
-Retrieve all platforms:
+The client is created for the production environment by default. If you want to use the sandbox environment, then add `sandbox: true`:
 
 ```ruby
-platforms = client.platforms.list
+client = Tikkie::Api::Client.new(api_key: "12345", app_token: "abcdef", sandbox: true)
 ```
 
-Create a new platform:
+### Payment requests
+
+#### Create a Payment request
+
+Creates a new payment request. When the parameter `amount` is omitted, it will create a payment request with an open amount, where the payer can decide on the amount.
 
 ```ruby
-platform = client.platforms.create(
-  name: "Kentaa",
-  phone_number: "0601234567",
-  platform_usage: Tikkie::Api::Types::PlatformUsage::FOR_MYSELF,
-  email: "info@kentaa.nl",                      # optional
-  notification_url: "https://kentaa.nl/tikkie"  # optional
+payment_request = client.payment_requests.create(
+  description: "Test",           # mandatory
+  amount: "12.50",
+  expiry_date: "2021-01-01",
+  reference_id: "Invoice 12345"
 )
 
-platform_token = platform.platform_token
+payment_request.payment_request_token  # => "qzdnzr8hnVWTgXXcFRLUMc"
+payment_request.url  # => "https://tikkie.me/pay/Tikkie/qzdnzr8hnVWTgXXcFRLUMc"
+payment_request.amount  # => BigDecimal("12.50")
 ```
 
-### Users
+See [Tikkie::Api::Resources::PaymentRequest](lib/tikkie/api/resources/payment_request.rb) for all available properties.
 
-Retrieve all users for a platform:
+#### List Payment requests
+
+Retrieves all payment requests.
 
 ```ruby
-users = client.users.list("platform_token")
+payment_requests = client.payment_requests.list
 ```
 
-Create a new user for a platform:
+The payments requests response is paginated. You can iterate through the pages using `payment_requests.next` and checking the result:
 
 ```ruby
-user = client.users.create("platform_token",
-  name: "Kentaa",
-  phone_number: "0601234567",
-  iban: "NL02ABNA0123456789",
-  bank_account_label: "Personal account"
-)
+payment_requests = client.payment_requests.list
 
-user_token = user.user_token
-bank_account_token = user.bank_accounts.first.bank_account_token
+loop do
+  # Do something with payment requests
+
+  payment_requests = payment_requests.next
+  break if payment_requests.nil?
+end
 ```
 
-### Payment requests
+See [Tikkie::Api::Resources::PaymentRequests](lib/tikkie/api/resources/payment_requests.rb) for all available properties.
+
+#### Get Payment request
+
+Retrieve details of a specific payment request.
+
+```ruby
+payment_request = client.payment_requests.get("payment_request_token")
+
+payment_request.payment_request_token  # => "qzdnzr8hnVWTgXXcFRLUMc"
+payment_request.url  # => "https://tikkie.me/pay/Tikkie/qzdnzr8hnVWTgXXcFRLUMc"
+payment_request.amount  # => BigDecimal("12.50")
+payment_request.payments  # => Tikkie::Api::Resources::Payments
+```
 
-Retrieve all payment requests for a user on a platform:
+See [Tikkie::Api::Resources::PaymentRequest](lib/tikkie/api/resources/payment_request.rb) for all available properties.
+
+
+### Payments
+
+#### List Payments
+
+Retrieves all payments for a specific payment request.
 
 ```ruby
-payment_requests = client.payment_requests.list("platform_token", "user_token")
+payments = client.payments.list("payment_request_token")
 ```
 
-The payments requests response is paginated. You can use the method `more_elements?` to determine if there's more data to retrieve. In the next request, set the `offset` parameter to the new offset using the method `next_offset` from the previous response. For example:
+The payments requests response is paginated. You can iterate through the pages using `payments.next` and checking the result:
 
 ```ruby
-response = client.payment_requests.list("platform_token", "user_token")
-payment_requests = response.to_a
+payments = client.payments.list("qzdnzr8hnVWTgXXcFRLUMc")
+
+loop do
+  # Do something with payments
 
-while response.more_elements?
-  response = client.payment_requests.list("platform_token", "user_token", offset: response.next_offset)
-  payment_requests << response.to_a
+  payments = payments.next
+  break if payments.nil?
 end
 ```
 
-To retrieve a single payment request:
+See [Tikkie::Api::Resources::Payments](lib/tikkie/api/resources/payments.rb) for all available properties.
+
+#### Get Payment
+
+Retrieves details of specific payment based on the token value.
 
 ```ruby
-payment_request = client.payment_requests.get("platform_token", "user_token", "payment_request_token")
+payment = client.payments.get("payment_request_token", "payment_token")
+
+payment.payment_token  # => "21ef7413-cc3c-4c80-9272-6710fada28e4"
+payment.amount  # => BigDecimal("12.50")
+payment.description  # => "Test"
+payment.refunds  # => Array[Tikkie::Api::Resources::Refund]
 ```
 
-Create a new payment request for an existing user:
+See [Tikkie::Api::Resources::Payment](lib/tikkie/api/resources/payment.rb) for all available properties.
+
+### Refunds
+
+#### Create a Refund
+
+Creates a refund for a specific payment.
 
 ```ruby
-payment_request = client.payment_requests.create("platform_token", "user_token", "bank_account_token",
-  amount: "5.00",
-  currency: "EUR",
-  description: "Test",
-  external_id: "Invoice 12345"  # optional
+refund = client.refunds.create("payment_request_token", "payment_token",
+  description: "Test",           # mandatory
+  amount: "10.00",               # mandatory
+  reference_id: "Invoice 12345"
 )
 
-tikkie_url = payment_request.payment_request_url
-payment_request_token =payment_request.payment_request_token
+refund.refund_token  # => "abcdzr8hnVWTgXXcFRLUMc"
+refund.amount  # => BigDecimal("10.00")
+refund.paid?   # => true
+```
+
+See [Tikkie::Api::Resources::Refund](lib/tikkie/api/resources/refund.rb) for all available properties.
+
+#### Get Refund
+
+Retrieves details of a specific refund based on the token value.
+
+```ruby
+refund = client.refunds.get("payment_request_token", "payment_token", "refund_token")
+
+refund.refund_token  # => "abcdzr8hnVWTgXXcFRLUMc"
+refund.amount  # => BigDecimal("10.00")
+refund.paid?   # => true
 ```
 
-### Error handling
+See [Tikkie::Api::Resources::Refund](lib/tikkie/api/resources/refund.rb) for all available properties.
 
-All responses to an API request include the methods `success?` and `error?` to determine whether the API call was successful or not. When the API request was not successful, the method `errors` will return details about the error response.
+### Payment requests notification
+
+See [Notifications](#notifications) for information about parsing the callbacks.
+
+#### Create a subscription
+
+Subscribes to payment request related notifications.
+
+```ruby
+subscription = client.payment_requests_subscription.create(url: "https://www.example.com/notification")
+
+subscription.subscription_id  # => "e0111835-e8df-4070-874a-f12cf3f77e39"
+```
+
+See [Tikkie::Api::Resources::PaymentRequestsSubscription](lib/tikkie/api/resources/payment_requests_subscription.rb) for all available properties.
+
+#### Delete subscription
+
+Deletes the current subscription.
+
+```ruby
+client.payment_requests_subscription.delete
+```
+
+### Sandbox apps
+
+A sandbox app is used to make API requests in the sandbox environment.
+
+You must initialize the Tikkie client by omitting the App token and adding the option `sandbox: true`:
+
+```ruby
+client = Tikkie::Api::Client.new(api_key: "12345", sandbox: true)
+```
+
+#### Create a Sandbox app
+
+Creates an app in the sandbox. The returned `app_token` should be used for all other API operations.
 
 ```ruby
-payment_request = client.payment_requests.create("platform_token", "user_token", "bank_account_token", ...)
+sandbox_app = client.sandbox_apps.create
+
+sandbox_app.app_token  # => "935059a6-58b3-4f8d-a021-7bdda0d8d6ad"
+```
 
-if payment_request.success?
-  # Success handling...
+See [Tikkie::Api::Resources::SandboxApp](lib/tikkie/api/resources/sandbox_app.rb) for all available properties.
 
-  redirect_to payment_request.payment_request_url
-else
-  # Error handling...
+## Error handling
 
-  puts payment_request.errors
+All responses that are not HTTP status 20x will result in a [Tikkie::Api::RequestError](lib/tikkie/api/exception.rb).
+
+```ruby
+begin
+  client.payment_requests.get("invalid")
+rescue Tikkie::Api::RequestError => e
+  e.http_code # => 404
+  e.http_message # => Not Found
+  e.errors # => Array[Tikkie::Api::Resources::Error]
+  e.messages # => "No payment request was found for the specified paymentRequestToken."
 end
 ```
 
+## Notifications
+
+When subscribed to notifications, you can use `Tikkie::Notification.parse` to parse the payload of a callback.
+
+```ruby
+require 'tikkie/notification'
+
+notification = Tikkie::Notification.parse(request.raw_post)
+
+notification  # => Tikkie::Notifications::PaymentNotification
+notification.subscription_id  # => "e0111835-e8df-4070-874a-f12cf3f77e39"
+notification.notification_type  # => "PAYMENT"
+notification.payment_request_token  # => "qzdnzr8hnVWTgXXcFRLUMc"
+notification.payment_token  # => "21ef7413-cc3c-4c80-9272-6710fada28e4"
+```
+
+See [Tikkie::Notifications](lib/tikkie/notifications/) for all types of notifications.
+
+## API support
+
+This gem supports [Tikkie API (v2)](https://developer.abnamro.com/api-products/tikkie) as of release 2.0.0.
+
+The deprecated [Tikkie Payment Request API (v1)](https://developer.abnamro.com/api-products/tikkie-payment-request) is currently namespaced under [Tikkie::Api::V1](lib/tikkie/api/v1/) to allow migration to Tikkie v2. This code is not supported anymore and will be removed in a future release of this gem.
+To use the Tikkie v1 code, make sure to include the [jwt gem](https://rubygems.org/gems/jwt) in your code.
+
 ## 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.