Connecting your users account#

composer require adoy/oauth2

pip install oauth2client

echo "gem 'oauth2'" >> Gemfile
bundle install

<-- Add the following to your Maven file -->
<dependency>
  <groupId>com.squareup.okhttp3</groupId>
  <artifactId>okhttp</artifactId>
  <version>3.4.1</version>
</dependency>

<?php
require 'vendor/autoload.php';

// You should store your client ID and secret in environment variables rather than
// committing them with your code
$client = new OAuth2\Client(getenv('GOCARDLESS_CLIENT_ID'), getenv('GOCARDLESS_CLIENT_SECRET'));

$authorizeUrl = $client->getAuthenticationUrl(
// Once you go live, this should be set to https://connect.gocardless.com. You'll also
// need to create a live app and update your client ID and secret.
'https://connect-sandbox.gocardless.com/oauth/authorize',
'https://acme.enterprises/redirect', // Your redirect URL
['scope' => 'read_write',
'initial_view' => 'login',
'prefill' => ['email' => 'tim@gocardless.com',
'given_name' => 'Tim',
'family_name' => 'Rogers',
'organisation_name' => 'Tim\'s Fishing Store']]
);

// You'll now want to direct your user to the URL - you could redirect them or display it
// as a link on the page
header("Location: " . $authorizeUrl);

import os
from oauth2client.client import OAuth2WebServerFlow

# You should store your client ID and secret in environment variables rather than

# committing them with your code

flow = OAuth2WebServerFlow(
client_id=os.environ['GOCARDLESS_CLIENT_ID'],
client_secret=os.environ['GOCARDLESS_CLIENT_SECRET'],
scope="read_write",
redirect_uri="https://acme.enterprises/redirect", # Once you go live, this should be set to https://connect.gocardless.com. You'll # also need to create a live app and update your client ID and secret.
auth_uri="https://connect-sandbox.gocardless.com/oauth/authorize",
token_uri="https://connect-sandbox.gocardless.com/oauth/access_token",
initial_view="signup",
prefill={
"email": "tim@gocardless.com",
"given_name": "Tim",
"family_name": "Rogers",
"organisation_name": "Tim's Fishing Store"
}
)

authorize_url = flow.step1_get_authorize_url()

# You'll now want to direct your user to the URL - you could redirect them or display it

# as a link on the page

flask.redirect(authorize_url, code=302)

require 'oauth2'

# You should store your client ID and secret in environment variables rather than

# committing them with your code

oauth = OAuth2::Client.new(ENV['GOCARDLESS_CLIENT_ID'],
ENV['GOCARDLESS_CLIENT_SECRET'], # Once you go live, this should be set to # https://connect.gocardless.com. You'll also need to create # a live app and update your client ID and secret.
site: 'https://connect-sandbox.gocardless.com',
authorize_url: '/oauth/authorize',
token_url: '/oauth/access_token',
auth_scheme: :request_body)

authorize_url = oauth.auth_code.authorize_url(redirect_uri: 'https://acme.enterprises/redirect',
scope: 'read_only',
initial_view: 'signup',
prefill: {
email: "tim@gocardless.com",
given_name: "Tim",
family_name: "Rogers",
organisation_name: "Tim's Fishing Store"
})

redirect_to authorize_url

// See https://raw.githubusercontent.com/gocardless/gocardless-pro-java-maven-example/master/src/main/java/hello/OAuthController.java

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.http.HttpStatus;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.util.UriComponentsBuilder;

@RestController
public class OAuthController {

private static final String authoriseRedirectUrl =
"https://connect-sandbox.gocardless.com/oauth/authorize";
private static final String redirectUrl =
"https://bb314345.ngrok.io/redirect";
private static final String clientID =
System.getenv("GOCARDLESS_CLIENT_ID");
private static final String clientSecret =
System.getenv("GOCARDLESS_CLIENT_SECRET");

@GetMapping("/")
public ResponseEntity<String> index() {
String oauthUrl = UriComponentsBuilder
.fromUriString(authoriseRedirectUrl)
.queryParam("client_id", clientID)
.queryParam("redirect_uri", redirectUrl)
.queryParam("scope", "read_write")
.queryParam("response_type", "code")
.queryParam("initial_view", "signup")
.queryParam("prefill[email]", "tim@gocardless.com")
.queryParam("prefill[given_name]", "Tim")
.queryParam("prefill[family_name]", "Rogers")
.queryParam("prefill[organisation_name]", "Tim's Fishing Store")
.queryParam("prefill[country_code]", "GB")
.toUriString();
HttpHeaders headers = new HttpHeaders();
headers.add("Location", oauthUrl);
return new ResponseEntity<String>(oauthUrl, headers, HttpStatus.FOUND);
}
}

// This is example code and must be inserted into your application structure

private readonly string authoriseRedirectUrl = "https://connect-sandbox.gocardless.com/oauth/authorize";
private readonly string redirectUrl = "https://acme.enterprises/redirect";
private readonly string clientID = Environment.GetEnvironmentVariable("GOCARDLESS_CLIENT_ID");
private readonly string clientSecret = Environment.GetEnvironmentVariable("GOCARDLESS_CLIENT_SECRET");

public static void redirect()
{
var uriBuilder = new UriBuilder(authoriseRedirectUrl);

uriBuilder.Query = "?client_id=" + clientID;
uriBuilder.Query += "&redirect_uri=" + redirectUrl;
uriBuilder.Query += "&scope=read_write";
uriBuilder.Query += "&response_type=code";
uriBuilder.Query += "&prefill[email]=tim@gocardless.com";
uriBuilder.Query += "&prefill[given_name]=Tim";
uriBuilder.Query += "&prefill[family_name]=Rogers";
uriBuilder.Query += "&prefill[organisation_name]=Fishing%20Store";
uriBuilder.Query += "&prefill[country_code]=GB";

Response.Redirect(uriBuilder.ToString());
}

<?php
require 'vendor/autoload.php';

$client = new OAuth2\Client(getenv('GOCARDLESS_CLIENT_ID'),
getenv('GOCARDLESS_CLIENT_SECRET'));

// You'll need to use exactly the same redirect URI as in the last step
$response = $client->getAccessToken(
'https://connect-sandbox.gocardless.com/oauth/access_token',
'authorization_code',
['code' => $_GET['code'], 'redirect_uri' => 'https://acme.enterprises/redirect']
);

$payload = ['gocardless_access_token' => $response['result']['access_token'],
'gocardless_organisation_id' => $response['result']['organisation_id']];

$currentUser->update($payload);

import os
from requests_oauthlib import OAuth2Session
from oauthlib.oauth2 import WebApplicationClient

# Configuration

client_id = os.environ['GOCARDLESS_CLIENT_ID']
client_secret = os.environ['GOCARDLESS_CLIENT_SECRET']
redirect_uri = "https://acme.enterprises/redirect"

# Authorization endpoint and token endpoint for GoCardless (sandbox in this case)

auth_base_url = "https://connect-sandbox.gocardless.com/oauth/authorize"
token_url = "https://connect-sandbox.gocardless.com/oauth/access_token"
scope = ["read_write"]

# Create OAuth2 client

oauth_client = OAuth2Session(client_id=client_id, redirect_uri=redirect_uri, scope=scope)

# Step 1: Redirect user to GoCardless for authorization

authorization_url, state = oauth_client.authorization_url(auth_base_url)
print(f"Visit this URL to authorize the app: {authorization_url}")

# After the user authorizes the app, they will be redirected to your redirect_uri with a code parameter.

# You will retrieve the code parameter in your web app after redirection.

# For example, assuming you're in a web framework like Flask:

# code = request.args.get('code')

# Step 2: Exchange the authorization code for an access token

# Replace 'code' with the authorization code obtained from the redirect

code = 'authorization_code_from_redirect'
token = oauth_client.fetch_token(
token_url=token_url,
code=code,
client_id=client_id,
client_secret=client_secret,
include_client_id=True # Ensure the client_id is included in the request body
)

# Step 3: Store the access token and organization ID

access_token = token.get('access_token')
organisation_id = token.get('organisation_id')

# Now, you can store these tokens for later use:

current_user.update(
gocardless_access_token=access_token,
gocardless_organisation_id=organisation_id
)

require 'oauth2'

# You should store your client ID and secret in environment variables rather than

# committing them with your code

oauth = OAuth2::Client.new(ENV['GOCARDLESS_CLIENT_ID'],
ENV['GOCARDLESS_CLIENT_SECRET'], # Once you go live, this should be set to # https://connect.gocardless.com. You'll also need to create # a live app and update your client ID and secret.
site: 'https://connect-sandbox.gocardless.com',
authorize_url: '/oauth/authorize',
token_url: '/oauth/access_token',
auth_scheme: :request_body)

access_token = oauth.auth_code.get_token(
params[:code],

# You'll need to use exactly the same access token as you did in the last step

redirect_uri: 'https://acme.enterprises/redirect'
)

# You should store the user's access token - you'll need it to make API requests on their

# behalf in future. If you want to handle webhooks for your users, you should also store

# their organisation ID which will allow you to identify webhooks belonging to them.

current_user.update!(gocardless_access_token: access_token.token,
gocardless_organisation_id: access_token['organisation_id'])

// See https://raw.githubusercontent.com/gocardless/gocardless-pro-java-maven-example/master/src/main/java/hello/OAuthController.java

import okhttp3.FormBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;

@RestController
public class OAuthController {
private static final String accessTokenUrl =
"https://connect-sandbox.gocardless.com/oauth/access_token";
private static final String redirectUri =
"https://bb314345.ngrok.io/redirect";
private static final String clientID =
System.getenv("GOCARDLESS_CLIENT_ID");
private static final String clientSecret =
System.getenv("GOCARDLESS_CLIENT_SECRET");

private static final OkHttpClient client =
new OkHttpClient();

private String getAccessToken(String oauthCode) throws IOException {
RequestBody body = new FormBody.Builder()
.add("client_id", clientID)
.add("client_secret", clientSecret)
.add("redirect_uri", redirectUri)
.add("grant_type", "authorization_code")
.add("code", oauthCode)
.build();

    Request request = new Request.Builder()
      .url(accessTokenUrl)
      .post(body)
      .build();
    try (Response response = client.newCall(request).execute()) {
        return response.body().string();
    }

}

@GetMapping("/redirect")
public String loggedIn(@RequestParam("code") String oauthCode) throws IOException {
String accessToken = getAccessToken(oauthCode);
System.out.println("Save the access token " +
accessToken + " to your database.");
return "Greetings!";
}
}

// This is example code and must be inserted into your application structure

private readonly string accessTokenUrl = "https://connect-sandbox.gocardless.com/oauth/access_token";
private readonly string redirectUrl = "https://acme.enterprises/redirect";
private readonly string clientID = Environment.GetEnvironmentVariable("GOCARDLESS_CLIENT_ID");
private readonly string clientSecret = Environment.GetEnvironmentVariable("GOCARDLESS_CLIENT_SECRET");

public Task<string> RedirectHandler(request Request) {
var oauthCode = request.Query["code"].ToString();

using (HttpClient client = new HttpClient()) {
using (MultipartFormDataContent data = new MultipartFormDataContent())
{
data.Add(new StringContent(clientID), "client_id");
data.Add(new StringContent(clientSecret), "client_secret");
data.Add(new StringContent(redirectUrl), "redirect_uri");
data.Add(new StringContent("authorization_code"), "grant_type");
data.Add(new StringContent(redirectUrl), "redirect_uri");
data.Add(new StringContent(oauthCode), "code");

    var response = await client.PostAsync(accessTokenUrl, data);
    var accessToken = response.Content

    return accessToken;
  }

}
}

<?php
function process_organisation_event($event)
{
  switch ($event->action) {
      case "disconnected":
          print("Organisation " . $event->links->organisation . " has been disconnected!\n");
          MarkOrganisationAsDisconnected($event->links->organisation);
          break;
      default:
          print("Don't know how to process an organisation " . $event->action . " event\n");
          break;
  }
}

$webhook_endpoint_secret = getenv("GOCARDLESS_WEBHOOK_ENDPOINT_SECRET");
$request_body = file_get_contents('php://input');

$headers = getallheaders();
$signature_header = $headers["Webhook-Signature"];

try {
$events = \GoCardlessPro\Webhook::parse($request_body,
$signature_header,
$webhook_endpoint_secret);

  foreach ($events as $event) {
      print("Processing event " . $event->id . "\n");

      switch ($event->resource_type) {
          case "organisations":
              process_organisation_event($event);
              break;
          default:
              print("Don't know how to process an event with resource_type " . $event->resource_type . "\n");
              break;
      }
  }

  header("HTTP/1.1 200 OK");

} catch(\GoCardlessPro\Core\Exception\InvalidSignatureException $e) {
header("HTTP/1.1 498 Invalid Token");
}

# Here, we're using a Django view, but essentially the same code will work in

# other Python web frameworks (e.g. Flask) with minimal changes

import os
import logging

from django.views.generic import View
from django.views.decorators.csrf import csrf_exempt
from django.utils.decorators import method_decorator
from django.http import HttpResponse

from gocardless_pro import webhooks, Client
from gocardless_pro.errors import InvalidSignatureError

from myinvoicingapp.models import GoCardlessEvent

# Handle the incoming Webhook and perform an action with the Webhook data.

class Webhook(View):
logger = logging.getLogger(**name**)

  @method_decorator(csrf_exempt)
  def dispatch(self, *args, **kwargs):
      return super(Webhook, self).dispatch(*args, **kwargs)

  def post(self, request, *args, **kwargs):
      try:
          for event in self._get_events(request):
              self.process(event)
          return HttpResponse(204)
      except InvalidSignatureError:
          return HttpResponse(498)

  def process(self, event):
      self.logger.info("Processing event {}\n".format(event.id))

      if event.resource_type == 'organisations':
          return self.process_organisation_event(event)
      # ... Handle other resource types
      else:
          self.logger.info("Don't know how to process an event with \
              resource_type {}\n".format(event.resource_type))

  def process_organisation_event(self, event):
      if event.action == 'disconnected':
          self.logger.info(
              "Organisation {} has been disconnected\n".
              format(event.links.organisation)
          )
      else:
          self.logger.info("Don't know how to process an event with \
              resource_type {}\n".format(event.resource_type))

  def _get_events(self, request):
      secret = os.environ['GC_WEBHOOK_SECRET']
      signature = request.META["HTTP_WEBHOOK_SIGNATURE"]
      body = request.body.strip()
      return webhooks.parse(body, secret, signature)

require 'gocardless_pro'

class OrganisationEventProcessor
def self.process(event, response)
case event.action
when 'disconnected'
response.stream.write("Organisation #{event.links.organisation} has been disconnected\n")

    DisconnectOrganisation.enqueue(event['links']['organisation'])

  else
    response.stream.write(
      "Don't know how to process a organisation #{event.action} event\n"
      )
  end

end
end

def create

# We recommend storing your webhook endpoint secret in an environment variable

# for security

webhook_endpoint_secret = ENV['GOCARDLESS_WEBHOOK_ENDPOINT_SECRET']

# In a Rack app (e.g. Sinatra), access the POST body with

# `request.body.tap(&:rewind).read`

request_body = request.raw_post

# In a Rack app (e.g. Sinatra), the header is available as

# `request.env['HTTP_WEBHOOK_SIGNATURE']`

signature_header = request.headers['Webhook-Signature']

begin
events = GoCardlessPro::Webhook.parse(request_body: request_body,
signature_header: signature_header,
webhook_endpoint_secret: webhook_endpoint_secret)

  events.each do |event|
    # We're using Rails's streaming functionality here to write directly to the
    # response rather than using views, as one would usually.
    response.stream.write("Processing event #{event.id}\n")

    case event.resource_type
    when 'organisations'
      OrganisationEventProcessor.process(event, response)
    else
      response.stream.write(
        "Don't know how to process an event with resource_type #{event.resource_type}\n"
        )
    end
  end

  response.stream.close
  render status: 200

rescue GoCardlessPro::Webhook::InvalidSignatureError
render status: 498
end
end

package hello;

// Use the POM file at
// https://raw.githubusercontent.com/gocardless/gocardless-pro-java-maven-example/master/pom.xml

import com.gocardless.errors.InvalidSignatureException;
import com.gocardless.resources.Event;
import com.gocardless.Webhook;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.http.ResponseEntity;

@RestController
public class HelloController {
private String processDisconnections(Event event) {
switch (event.getAction()) {
case "disconnected":
// here, you probably want to mark the organisation as disconnected
// and stop sending any requests on their behalf
return "Organisation " + event.getLinks().getOrganisation() +
" has been cancelled.\n";
default:
return "Do not know how to process an event with action " +
event.getAction() + ".\n";
}
}

  private String processEvent(Event event) {
      switch (event.getResourceType()) {
          case ORGANISATIONS:
              return processDisconnections(event);
          default:
              return "Don't know how to process an event of resource_type " +
                  event.getResourceType().toString() + ".\n";
      }
  }

  @PostMapping("/")
  public ResponseEntity<String> handlePost(
          @RequestHeader("Webhook-Signature") String signatureHeader,
          @RequestBody String requestBody) {
      String webhookEndpointSecret = System.getenv("GOCARDLESS_WEBHOOK_ENDPOINT_SECRET");

      try {
          List<Event> events = Webhook.parse(requestBody, signatureHeader, webhookEndpointSecret);

          String responseBody = "";

          for (Event event : events) {
              responseBody += processEvent(event);
          }

          return new ResponseEntity<String>(responseBody, HttpStatus.OK);
      } catch(InvalidSignatureException e) {
          return new ResponseEntity<String>("Incorrect Signature", HttpStatus.BAD_REQUEST);
      }
  }

}

POST https://example.com/webhooks HTTP/1.1
Content-Type: application/json
{
"events": [
{
"id": null,
"created_at": "2018-08-03T12:00:00.000Z",
"action": "disconnected",
"resource_type": "organisations",
"links": {
"organisation": "OR123"
},
"details": {
"cause": "app_disconnected",
"origin": "gocardless",
"description": "Your app has been has disconnected from this organisation"
},
"metadata": {}
}
]
}