Reconciling Payouts#

require 'vendor/autoload.php';

function processPayoutEvent($event) {
$client = new \GoCardlessPro\Client([
'access_token' => $_ENV["GOCARDLESS_ACCESS_TOKEN"],
'environment' => \GoCardlessPro\Environment::SANDBOX
]);

$payoutId = $event->links['payout'];

$payout = $client->payouts()->get($payoutId);
echo $payout->amount;

$payoutItems = $client
->payoutItems()
->all(["params" => ["payout" => $payoutId]]);

foreach ($payoutItems as $payoutItem) {
echo $payoutItem->amount;
echo $payoutItem->type;
echo $payoutItem->links->payment;
}
}

import os
import gocardless_pro

def process_payout_event(event):
client = gocardless_pro.Client(
access_token=os.environ['GOCARDLESS_ACCESS_TOKEN'],
environment='sandbox'
)

payout_id = event['links']['payout']
payout = client.payouts.get(payout_id)
print(payout.amount)

payout_items = client.payout_items.all(params={ "payout": payout_id }).records

for payout_item in payout_items:
print(payout_item.amount)
print(payout_item.type)
print(payout_item.links.payment)

require 'gocardless_pro'

def process_payout_event(event)
client = GoCardlessPro::Client.new(
access_token: ENV['GOCARDLESS_ACCESS_TOKEN'],
environment: :sandbox
)

payout_id = event.links.payout
payout = @client.payouts.find(payout_id)
puts payout.amount

payout_items = client.payout_items.all(params: { payout: payout_id })

payout_items.each do |payout_item|
puts payout_item.amount
puts payout_item.type
puts payout_item.links.payment
end
end

import com.gocardless.GoCardlessClient;
import com.gocardless.resources.Event;
import com.gocardless.resources.Payout;
import com.gocardless.resources.PayoutItem;

public class PayoutsWebhookHandler {
public static void handlePayoutPaidEvent(Event event) {
GoCardlessClient client = GoCardlessClient
.newBuilder(System.getenv("GOCARDLESS_ACCESS_TOKEN"))
.withEnvironment(GoCardlessClient.Environment.SANDBOX)
.build();

      String payoutId = event.getLinks().getPayout();
      Payout payout = client.payouts().get(payoutId).execute();

      for (PayoutItem payoutItem : client.payoutItems().all().withPayout(payoutId).execute()) {
          System.out.println(payoutItem.getAmount());
          System.out.println(payoutItem.getType());
          System.out.println(payoutItem.getLinks().getPayment());
      }
  }

}

const gocardless = require("gocardless-nodejs");

const client = gocardless(process.env.GoCardlessAccessToken, constants.Environments.Sandbox);

async function processPayoutEvent(event) {
const payoutId = event.links.payout;
const payout = await client.payouts.find(payoutId);
console.log(payout.id);

const payoutItems = client.payoutItems.all({ payout: payoutId });

for await (let payoutItem of payoutItems) {
console.log(payoutItem.amount);
console.log(payoutItem.type);
console.log(payoutItem.links.payment);
}
}

using GoCardless;

public void HandlePayoutPaidEvent(GoCardless.Resources.Event event)
{
var client = GoCardlessClient.Create(
ConfigurationManager.AppSettings["GoCardlessAccessToken"],
GoCardlessClient.Environment.SANDBOX
);

  var payoutId = event.Links.Payout;
  var payoutResponse = await client.Payouts.GetAsync(payoutId);
  var payout = paymentResponse.Payout;
  Console.WriteLine(payout.Id);

  var payoutItemsRequest = new GoCardless.Services.PayoutItemListRequest()
  {
      Payout = payoutId
  };

  var payoutItems = client.PayoutItems.All(payoutItemsRequest);

  foreach (GoCardless.Resources.PayoutItem payoutItem in payoutItems)
  {
      Console.WriteLine(payoutItem.Amount);
      Console.WriteLine(payoutItem.Type);
      Console.WriteLine(payoutItem.Links.Payment);
  }

}

package main

import (
"context"
"fmt"
"http"

  gocardless "github.com/gocardless/gocardless-pro-go/v6"

)

func main() {
accessToken := "your_access_token_here"
config, err := gocardless.NewConfig(accessToken, gocardless.WithEndpoint(gocardless.SandboxEndpoint))
if err != nil {
fmt.Printf("got err in initialising config: %s", err.Error())
return
}
client, err := gocardless.New(config)
if err != nil {
fmt.Println("error in initialisating client: %s", err.Error())
return
}

  parseEvent := func(event gocardless.Event) {
  	payoutId := event.Links.Payout
  	ctx := context.TODO()

  	payoutListParams := gocardless.PayoutItemListParams{
  		Payout: payoutId,
  	}
  	payoutItems, err := client.PayoutItems().All(ctx, payoutListParams)

  	for _, payoutItem := range payoutItems {
  		fmt.Println(payoutItem.Amount)
  		fmt.Println(payoutItem.Type)
  		fmt.Println(payoutItem.Links.Payment)
  	}
  }

  http.HandleFunc("/webhookEndpoint", func(w http.ResponseWriter, r *http.Request) {
  	wh, err := gocardless.NewWebhookHandler("secret", gocardless.EventHandlerFunc(func(event gocardless.Event) error {
  		parseEvent(event)
  	}))
  	wh.ServeHTTP(w, r)
  })

}