# Exemple d’application avec Issuing et Treasury pour les plateformes

Utilisez l’application test Stripe Next.js pour développer votre propre intégration Issuing et Treasury pour les plateformes.

En plus d’une suite complète de documentation et de SDK pour Stripe Issuing et Stripe Treasury pour les plateformes, nous proposons une application test Next.js.

Visionnez une démo de notre application test sur [baas.stripe.dev](https://baas.stripe.dev) ou consultez le [référentiel GitHub](https://github.com/stripe-samples/issuing-treasury).

## Accès au code

L’application test est une application Next.js qui exploite TypeScript, React et Material UI. Vous pouvez créer un fork du projet à partir du [référentiel GitHub d’exemples Stripe](https://github.com/stripe-samples/issuing-treasury) et utiliser les composants inclus comme point de départ pour votre propre application.

## Fonctionnalités de l’application

L’application fournit de nombreux exemples pratiques, notamment :

- Tirez parti de Stripe Connect Onboarding pour collecter les informations Know Your Customer (KYC) afin d’inscrire les comptes connectés en toute conformité
- Afficher les informations et le solde du compte
- Afficher les transactions sur le compte financier
- Simulez l’envoi de fonds vers un compte externe par ACH ou par virement bancaire
- Simulez la réception d’un virement ACH
- Visualisez le volume des flux d’argent entrants et sortants à l’aide d’[ApexCharts](https://github.com/apexcharts/apexcharts.js)
- Créez des titulaires de carte en toute conformité
- Créer des cartes en utilisant le compte financier comme solde d’émission
- Affichez les numéros de cartes sensibles conformément à la norme PCI
- Simuler des autorisations de carte bancaire
- Faites-vous payer via un lien de paiement, puis transférez des fonds de votre solde Stripe vers le compte financier
- Utilisez des outils d’aide aux tests pour simuler des actions affectant le compte

## Détails des composants

Les sections suivantes fournissent une vue d’ensemble du fonctionnement de chaque composant de l’application test.

Vous pouvez en savoir plus sur les [API et fonctionnalités d’Issuing](https://docs.stripe.com/issuing.md) ou sur les [API du compte financier](https://docs.stripe.com/api/treasury/financial_accounts.md)et ses [fonctionnalités](https://docs.stripe.com/treasury/connect.md).

### Création de compte

Le flux de création de compte comprend quatre étapes :

1. Créer un [compte connecté](https://docs.stripe.com/treasury/connect/account-management/connected-accounts.md) avec les fonctionnalités suivantes : `transferts`, `card_issuing` et `trésorerie`.

```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. Créer un [compte financier](https://docs.stripe.com/treasury/connect/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. Créez un lien Connect Onboarding et utilisez-le pour rediriger les nouveaux comptes connectés afin de collecter les informations de profil nécessaires pour les fonctionnalités demandées.

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

### Solde du compte

La carte de solde du compte utilise uniquement l’API `stripe.treasury.financialAccounts.list`.

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

La charge utile de la commande ci-dessus contient un objet solde composé du [solde](https://docs.stripe.com/treasury/connect/account-management/working-with-balances-and-transactions.md) actuel (argent liquide) et des fonds sortants.

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

### Graphique des entrées et sorties de fonds

Le graphique des mouvements de fonds utilise uniquement l’API `stripe.treasury.transactions.list`.

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

Les réponses sont regroupées par solde positif ou négatif et par date de création. Les données sont ensuite transférées dans [ApexCharts](https://github.com/apexcharts/apexcharts.js) pour créer un affichage dynamique du flux de fonds.

```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}}"
  }
}
```

### Liste des transactions

La liste des transactions utilise l’API `stripe.treasury.transactions.list`.

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

Les colonnes de la table des transactions sont analysées à partir de l’objet `transaction` à l’aide du mappage suivant :

- `created` → Date
- `amount` → Montant/Devise
- `flow_type` → Type
- `status` → État
- `description` → Description

### Interface d’envoi de fonds

La fonctionnalité d’envoi de fonds de l’application de test utilise la fonctionnalité [OutboundPayments](https://docs.stripe.com/treasury/connect/moving-money/out-of/outbound-payments.md) de Treasury pour les plateformes. Vous pouvez utiliser `OutboundPayments` pour envoyer des fonds vers le compte externe d’un tiers.

```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
  },
);
```

### Création d’un titulaire de carte Issuing

Vous devez créer un `Cardholder` avant de pouvoir émettre une carte bancaire avec Stripe Issuing pour dépenser des fonds du compte financier. Utilisez l’API `stripe.issuing.cardholders.create` pour créer des titulaires de carte.

```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,
  }
);
```

### Émission de cartes

Après avoir créé un `Cardholder`, vous pouvez émettre une carte pour le `Cardholder` à l’aide de l’API `stripe.issuing.cards.create`.

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

### Liste des cartes

La liste des cartes bancaires s’affiche à l’aide des données de l’API `stripe.issuing.cards.list`.

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

### Liste des autorisations de carte bancaire

Utilisez l’API `stripe.issuing.authorizations.list` pour récupérer les autorisations pour une carte spécifique. L’exemple suivant limite la liste aux 10 autorisations les plus récentes.

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

Les colonnes de la table des autorisations sont analysées à partir de l’objet de réponse à l’aide du mappage suivant :

- `created` → Date
- `amount` → Montant/Devise du montant
- `card.cardholder.name` → Nom sur la carte bancaire
- `card.last4` → Les 4 derniers chiffres de la carte bancaire
- `approved` → Approuvé
- `status` → État
- `merchant_data.name` → Marchand
- `merchant_data.category` → Catégorie de marchand

## Assistants de test

L’application de test comprend des fonctionnalités d’aide en mode test qui vous permettent d’effectuer certaines actions, par exemple approvisionner votre compte, créer un lien de paiement pour collecter des fonds dans un compte connecté et virer des fonds sur le compte financier. Vous pouvez accéder à la plupart des outils d’aide en mode test en cliquant sur le bouton **Générer des données de test** ou sur **Données de test**.

### Outil d’aide au test pour les crédits reçus

En mode test, vous pouvez ajouter des fonds à un compte financier à l’aide des [assistants de test ReceivedCredit](https://docs.stripe.com/api/treasury/received_credits/test_mode_create.md). Cet outil d’aide au test simule la réception d’un transfert d’un compte bancaire externe vers votre compte financier.

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

### Liens de paiement et virements

Vous pouvez utiliser des liens de paiement pour ajouter des fonds au compte connecté associé à un compte financier :

1. Créez un `Price` correspondant au montant qui sera déposé sur le compte connecté une fois le paiement finalisé.

```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. Une fois le tarif obtenu, Stripe crée un `PaymentLink`, tandis que vous redirigez le client pour qu’il finalise le paiement. Utilisez l’`id` de `Price` de l’étape précédente pour définir la valeur du paramètre `price`. Vous pouvez également exclure le paramètre pour utiliser une valeur par défaut à la place.

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

### Virement à partir du solde des paiements du compte connecté

Les [virements](https://docs.stripe.com/treasury/connect/moving-money/payouts.md#payouts) permettent d’envoyer des fonds depuis le solde des paiements d’un compte connecté vers leur compte financier. Pour effectuer un virement, procédez comme suit&nbsp;:

1. Vérifiez si un compte externe est configuré pour le compte connecté. À cet effet, utilisez l’API [accounts.retrieve](https://docs.stripe.com/api/accounts/retrieve.md) pour obtenir l’[objet Account](https://docs.stripe.com/api/accounts/object.md) et vérifiez si la propriété `external_account` est renseignée.

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

let hasExternalAccount = false;

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

1. Si le compte connecté ne dispose pas de compte externe, il peut configurer le compte financier en tant que compte externe.

```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. Initiez un virement vers le compte externe du compte connecté. Dans notre cas, le compte externe est le compte financier.

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

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