# Muster-App für Issuing und Treasury für Plattformen

Verwenden Sie die Muster-App Stripe Next.js, um Ihre eigene Integration von Issuing und Treasury für Plattformen durchzuführen.

> #### Veraltete Integration (Legacy)
> 
> Die v1-Version von Treasury für Plattformen ist eine veraltete Integration, die viele der in [Treasury für Plattformen v2](https://docs.stripe.com/treasury/connect.md) eingeführten Funktionen nicht unterstützt. Erstellen Sie keine neue v1-Integration.

Zusätzlich zu einer vollständigen Suite an Dokumentationen und SDKs für Stripe Issuing und Stripe Treasury for platforms bieten wir die Muster-App Next.js an.

Eine Demo unserer Beispiel-App finden Sie unter [baas.stripe.dev](https://baas.stripe.dev) oder im [GitHub-Repository](https://github.com/stripe-samples/issuing-treasury).

## Auf Code zugreifen

Bei der Beispiel-App handelt es sich um eine Next.js-App, die die Nutzeroberflächen von TypeScript, React und Material nutzt. Sie finden das Projekt im [GitHub-Repository der Stripe-Beispiele](https://github.com/stripe-samples/issuing-treasury) und können die enthaltenen Komponenten als Ausgangspunkt für Ihre eigene App verwenden.

## App-Funktionen

Die App bietet viele Anleitungsbeispiele, mit denen Sie z. B.:

- Stripe Connect Onboarding nutzen, um KYC-Angaben (Know Your Customer) zu erfassen und ein konformes Onboarding Ihrer verbundenen Konten zu gewährleisten
- Kontoinformationen und Guthaben anzeigen
- Transaktionen auf dem Finanzkonto anzeigen
- Das Senden von Geldern per ACH oder Überweisung an ein externes Konto simulieren
- Den Erhalt von ACH-Gutschriften simulieren
- Das Volumen der ein- und ausgehenden Geldbewegungen mit [ApexCharts](https://github.com/apexcharts/apexcharts.js) visualisieren
- Karteninhaber/innen konform erstellen
- Erstellen Sie Karten mit dem Finanzkonto als auszahlbarem Guthaben
- Vertrauliche Kartennummern auf PCI-konforme Weise anzeigen
- Kartenautorisierungen simulieren
- Zahlungen per Zahlungslink empfangen und Guthaben aus Ihren Stripe-Zahlungen an das Finanzkonto übertragen
- Mit Tools im Test-Modus Aktionen simulieren und herausfinden, wie sich diese auf das Konto auswirken

## Aufschlüsselung der Komponenten

Die folgenden Abschnitte zeigen beispielhaft, wie die einzelnen Komponenten der Beispiel-App funktionieren.

Weitere Informationen finden Sie unter [Issuing- APIs und Funktionen](https://docs.stripe.com/issuing.md) oder [APIs für Finanzkonten](https://docs.stripe.com/api/treasury/financial_accounts.md) und [Funktionen](https://docs.stripe.com/treasury/connect/legacy/v1.md).

### Kontoerstellung

Die Kontoerstellung besteht aus vier Schritten:

1. Erstellen Sie ein [verbundenes Konto](https://docs.stripe.com/treasury/connect/legacy/v1/account-management/connected-accounts.md) mit den folgenden Funktionen: `Übertragungen`, `card_issuing`und `Treasury`.

```javascript
const account = await stripe.accounts.create({
  country: 'US',
  email: email,
  capabilities: {
    transfers: {requested: true},
    treasury: {requested: true},
    card_issuing: {requested: true},
  },
  controller: {
    dashboard: {type: "none"},
    losses: {payments: "application"},
    requirement_collection: "application",
    fees: {payer: "application"}
  },
});
```

1. Erstellen Sie ein [Finanzkonto](https://docs.stripe.com/treasury/connect/legacy/v1/account-management/financial-accounts.md).

```javascript
const financialAccount = await stripe.treasury.financialAccounts.create(
  {
    supported_currencies: ['usd'],
    features: {
      card_issuing: {requested: true},
      deposit_insurance: {requested: true},
      financial_addresses: {aba: {requested: true}},
      inbound_transfers: {ach: {requested: true}},
      intra_stripe_flows: {requested: true},
      outbound_payments: {
        ach: {requested: true},
        us_domestic_wire: {requested: true},
      },
      outbound_transfers: {
        ach: {requested: true},
        us_domestic_wire: {requested: true},
      },
    },
  },
  {stripeAccount: account.id},
);
```

1. Generieren Sie einen Link für Connect Onboarding und leiten über diesen neue verbundene Konten weiter. Anschließend können die erforderlichen Profilangaben für die angeforderten Funktionen erfasst werden.

```javascript
const { url } = await stripe.accountLinks.create({
  type: 'account_onboarding',
  account: accountId,
  refresh_url: host + '/onboard',
  return_url: host + '/onboard',
  collect: 'eventually_due',
});
```

### Kontostand

Die Kontoguthabenkarte verwendet nur die `stripe.treasury.financialAccounts.list`-API.

```javascript
const financialAccounts = await stripe.treasury.financialAccounts.list({
  stripeAccount: StripeAccountID,
});
const financialAccount = financialAccounts.data[0];
```

Die Nutzlast des obigen Befehls enthält ein Saldenobjekt, das aus dem aktuellen [Guthaben](https://docs.stripe.com/treasury/connect/legacy/v1/account-management/working-with-balances-and-transactions.md) (Bargeld) und ausgehenden Geldmitteln besteht.

```json
{
  "id": "fa_...",
 ...
  "balance": {
    "cash": { "usd": 534214 },
    "inbound_pending": { "usd": 0 },
    "outbound_pending": { "usd": 2200 }
  },
 ...
  "supported_currencies": [ "usd" ]
}
```

### Tabelle zu eingehenden und ausgehenden Geldern

Das Diagramm für Geldbewegungen verwendet nur die `stripe.treasury.transactions.list`-API.

```javascript
const fa_transactions = await stripe.treasury.transactions.list(
  {
    financial_account: financialAccount.id,
    order_by: 'created',
    limit: 100,
  },
  {stripeAccount: StripeAccountID},
);
```

Die Antworten werden nach positivem und negativem Saldo sowie Erstellungsdatum gruppiert. Die Daten werden dann in [ApexCharts](https://github.com/apexcharts/apexcharts.js) portiert, um eine dynamische Anzeige der Geldbewegungen zu erstellen.

```json
{
  "id": "{{TRANSACTION_ID}}",
  "object": "treasury.transaction",
  "created": "{{T}}",
  ...
  "flow": "{{OUTBOUND_PAYMENT_ID}}",
  "flow_type": "outbound_payment",
  "status": "open",
  "amount": -1000,
  "currency": "usd",
  "balance_impact": {
    "cash": -1000,
    "inbound_pending": 0,
    "outbound_pending": 1000
  },
  "entries": {
    "data": [
      {
        "id": "{{TRANSACTION_ENTRY_ID}}",
        "object": "treasury.transaction_entry",
        ...
        "created": "{{T}}",
        "effective_at": "{{T}}",
        "currency": "usd",
        "balance_impact": {
          "cash": -1000,
          "inbound_pending": 0,
          "outbound_pending": 1000
        }
      }
    ],
    "has_more": false,
    "object": "list",
    "url": "/v1/treasury/transaction_entries?financial_account={{FINANCIAL_ACCOUNT_ID}}&transaction={{TRANSACTION_ID}}"
  }
}
```

### Transaktionsliste

Die Transaktionsliste verwendet die `stripe.treasury.transactions.list`-API.

```javascript
const fa_transactions = await stripe.treasury.transactions.list(
  {
    financial_account: financialAccount.id,
    order_by: 'created',
    limit: 100,
  },
  {stripeAccount: StripeAccountID},
);
```

Die Spalten in der Transaktionstabelle werden aus dem `transaction`-Objekt mithilfe der folgenden Zuordnung analysiert:

- `created` → Datum
- `amount` → Betrag/Währung
- `flow_type` → Typ
- `status` → Status
- `description` → Beschreibung

### Schnittstelle zum Senden von Geld

Die Funktion zum Senden von Geld in der Muster-App verwendet die Funktion [OutboundPayments](https://docs.stripe.com/treasury/connect/legacy/v1/moving-money/out-of/outbound-payments.md) von Treasury für Plattformen. Sie können `OutboundPayments` verwenden, um Geld auf externe Konten Dritter zu senden.

```javascript
const outboundPayment = await stripe.treasury.outboundPayments.create(
  {
    financial_account: financialAccount.id,
    amount: amount,
    currency: 'usd',
    statement_descriptor: req.descriptor,
    destination_payment_method_data: {
      type: 'us_bank_account',
      us_bank_account: {
        account_holder_type: 'individual',
        routing_number: '110000000',
        account_number: '000000000009',
      }
    }
  },
  {
    stripeAccount: StripeAccountId
  },
);
```

### Erstellung von Issuing-Karteninhaber/innen

Sie müssen einen `Cardholder` erstellen, bevor Sie mit Stripe Issuing eine Karte ausstellen können, um Geld vom Finanzkonto auszugeben. Verwenden Sie die API `stripe.issuing.cardholders.create` zum Erstellen von Karteninhabern.

```javascript
const cardholder = await stripe.issuing.cardholders.create(
  {
    type: 'individual',
    name: firstName + ' ' + lastName,
    email: email,
    individual: {
      first_name: firstName,
      last_name: lastName,
      dob: {day: day, month: month, year: year}
    },
    billing: {
      address: {
        city: city,
        line1: address1,
        state: state,
        postal_code: postalCode,
        country: country,
      },
    },
  },
  {
    stripeAccount: StripeAccountId,
  }
);
```

### Karten ausstellen

Nachdem Sie eine/n `Cardholder` erstellt haben, können Sie diesem/dieser `Cardholder` mit der `stripe.issuing.cards.create`-API eine Karte ausstellen.

```javascript
const card = await stripe.issuing.cards.create(
  {
    cardholder: req.body.cardholderid,
    financial_account: financialAccount.id,
    currency: 'usd',
    type: 'virtual',
    status: 'active',
  },
  {stripeAccount: StripeAccountId},
);
```

### Kartenliste

Die Kartenliste wird mit Daten aus der `stripe.issuing.cards.list`-API angezeigt.

```javascript
const cards = await stripe.issuing.cards.list(
  {limit: 10},
  {stripeAccount: StripeAccountID},
);
```

### Autorisierungsliste für Karten

Mit der API `stripe.issuing.authorizations.list` können Sie Autorisierungen für eine bestimmte Karte abrufen. Im folgenden Beispiel wird die Liste auf die letzten zehn Autorisierungen beschränkt.

```javascript
const card_authorizations = await stripe.issuing.authorizations.list(
  {
    card: cardId,
    limit: 10,
  },
  {stripeAccount: StripeAccountID},
);
```

Die Spalten in der Autorisierungstabelle werden mithilfe der folgenden Zuordnung aus dem Antwortobjekt analysiert:

- `created` → Datum
- `amount` → Betrag/Betragswährung
- `card.cardholder.name` → Name auf der Karte
- `card.last4` → Letzte 4 Ziffern
- `approved` → Genehmigt
- `status` → Status
- `merchant_data.name` → Händler
- `merchant_data.category` → Händlerkategorie

## Test Helper

Mit den Testhelfern der Muster-App können Sie bestimmte Aktionen durchführen können. So können Sie z. B. Ihr Konto finanzieren, Zahlungslinks erstellen, um Gelder zentral in einem verbundenen Konto zu sammeln, und Auszahlungen an Finanzkonten tätigen. Auf die meisten Testhelfer können Sie zugreifen, indem Sie auf die Schaltfläche **Testdaten generieren** oder auf **Testdaten** klicken.

### Testhelfer für empfangene Gutschriften

In Testumgebungen können Sie einem Finanzkonto mit der Funktion [ReceivedCredit-Testhelfer](https://docs.stripe.com/api/treasury/received_credits/test_mode_create.md) Geldmittel hinzufügen. Dieser Testhelfer simuliert den Empfang einer Überweisung von einem externen Bankkonto auf Ihr Finanzkonto.

```javascript
const receivedCredit = await stripe.testHelpers.treasury.receivedCredits.create(
  {
    amount: 50000,
    currency: 'usd',
    financial_account: financialAccount.id,
    network: 'ach',
  },
  {stripeAccount: StripeAccountId},
);
```

### Zahlungslinks und Auszahlungen

Über Zahlungslinks können Sie Geldmittel an das verbundene Konto einzahlen, das mit einem Finanzkonto verknüpft sind:

1. Erstellen Sie einen `Price`, der den Betrag festlegt, der nach Zahlungsabschluss auf das verbundene Konto eingezahlt wird.

```javascript
const prices = await stripe.prices.list(
  {
    limit: 1,
    active: true,
    type: 'one_time',
  },
  {stripeAccount: StripeAccountId,},
);

let price;

if (prices.data.length < 1) {
  price = await stripe.prices.create(
    {
      unit_amount: 1000,
      currency: 'usd',
      product_data:
        {
          name: 'Unit',
      },
    },
    {stripeAccount: StripeAccountId,},
  );
} else {
  price = prices.data[0];
}
```

1. Nachdem der Preis bekannt ist, erstellt Stripe einen `PaymentLink` und Sie leiten die Kundin/den Kunden weiter, um die Zahlung abzuschließen. Verwenden Sie die `id` `Price` aus dem vorherigen Schritt, um den Wert für den Parameter `price` festzulegen. Alternativ können Sie den Parameter auch weglassen und stattdessen einen Standardwert verwenden.

```javascript
const paymentLink = await stripe.paymentLinks.create(
  {
    line_items: [
      {
        price: price.id,
        quantity: 1,
        adjustable_quantity: {enabled: true},
      },
    ],
  },
  {stripeAccount: StripeAccountId,},
);
```

### Auszahlung aus dem Guthaben des verbundenen Kontos

Bei [Auszahlungen](https://docs.stripe.com/treasury/connect/legacy/v1/moving-money/payouts.md#payouts) können Geldmittel aus dem Zahlungsguthaben eines verbundenen Kontos auf dessen Finanzkonto gesendet werden. Gehen Sie wie folgt vor, um eine Auszahlung durchzuführen:

1. Prüfen Sie, ob für das verbundene Konto ein externes Konto konfiguriert ist. Verwenden Sie dazu die [accounts.retrieve](https://docs.stripe.com/api/accounts/retrieve.md) API, um das [Account-Objekt](https://docs.stripe.com/api/accounts/object.md) abzurufen und zu überprüfen, ob die Eigenschaft `external_account` ausgefüllt ist.

```javascript
const responseAccount = await stripe.accounts.retrieve(StripeAccountID);
const accountExternalAccount = responseAccount.external_accounts.data[0];

let hasExternalAccount = false;

if (accountExternalAccount) {
  hasExternalAccount = true;
}
```

1. Wenn das verbundene Konto nicht über ein externes Konto verfügt, kann es das Finanzkonto als externes Konto einrichten.

```javascript
const financialAccounts = await stripe.treasury.financialAccounts.list(
  {expand: ['data.financial_addresses.aba.account_number']},
  {
    stripeAccount: StripeAccountId,
  },
);

const financialAccount = financialAccounts.data[0];

await stripe.accounts.createExternalAccount(StripeAccountId, {
  external_account: {
    object: 'bank_account',
    country: 'US',
    currency: 'usd',
    account_number:
      financialAccount.financial_addresses[0].aba.account_number,
    routing_number:
      financialAccount.financial_addresses[0].aba.routing_number,
  },
});
```

1. Initiieren Sie eine Auszahlung auf das externe Konto des verbundenen Kontos. In diesem Fall ist das externe Konto das Finanzkonto.

```javascript
const balance = await stripe.balance.retrieve({
  stripeAccount: StripeAccountId,
});

const payout = await stripe.payouts.create(
  {
    amount: balance.available[0].amount,
    currency: 'usd',
  },
  {stripeAccount: StripeAccountId},
);
```