: (data) => List.from(data).map((json) => User.fromJson(json)).toList(),
User: (data) => User.fromJson(data),
// ...
};
```
Nel file modelDecoders, dobbiamo fornire il `Type` come chiave e gestire la trasformazione nel valore come nell'esempio sopra.
L'argomento `data` conterra' il payload dalla richiesta API.
## Decoder Tipizzati
Richiede
Nylo 7.5.0+
nylo_support 7.37.0+
`decoders([...])` costruisce la tua mappa `modelDecoders` a partire da una lista. `Decode(User.fromJson)` decodifica un `User`, e anche una `List`, senza una voce propria:
```dart
final Map modelDecoders = decoders([
Decode(User.fromJson),
Decode(Order.fromJson, from: 'data'),
]);
```
Usa `from` per leggere il modello dall'interno di un corpo incapsulato, come `{"data": {...}}`. Una chiave con punti come `'data.user'` legge piu' in profondita', e per una lista, la lista stessa viene letta da `from`.
`Decode` accetta un `fromJson` che riceve `dynamic` o `Map`. Per una closure, tipizza il suo parametro:
```dart
Decode((dynamic json) => User.fromJson(json)),
```
I decoder closure in una mappa `{...}`, come `User: (data) => User.fromJson(data)`, continuano a funzionare. Entrambi sono un `NyDecoder`, la classe che `Decode` e `OneOf` estendono. Un `NyDecoder` personalizzato implementa `decode(json, response, decoders)` e vede l'intera `NyResponse`, quindi puo' leggere il codice di stato o gli header.
## OneOf
Richiede
Nylo 7.5.0+
nylo_support 7.37.0+
`OneOf` decodifica una risposta che puo' avere piu' di una forma. Registralo sotto il tipo padre condiviso e scegli la forma tramite un campo del corpo, tramite il codice di stato o con le tue condizioni:
```dart
final Map modelDecoders = decoders([
OneOf.byKey('status', {
'success': LoginSuccess.fromJson,
'two_factor': TwoFactorRequired.fromJson,
}, otherwise: (json) => LoginFailed(ApiError.fromJson(json))),
]);
```
Un `OneOf` decodifica anche i corpi 4xx e 5xx, e una `List` elemento per elemento. Una forma che non riconosce lascia i dati della risposta a null.
| Costruttore | Sceglie la forma tramite |
|-------------|--------------------|
| `OneOf.byKey(key, types, otherwise:)` | Il valore di `key` nel corpo. Una chiave con punti come `'data.type'` legge un campo annidato |
| `OneOf.byStatus(types, otherwise:)` | Il codice di stato. Una chiave e' un codice come `404`, o un pattern come `'4xx'` o `'40x'` |
| `OneOf.byJson(types, otherwise:)` | Le tue condizioni, ciascuna delle quali riceve il corpo e la risposta. Vince la prima che restituisce true |
| `OneOf(resolve)` | Una funzione che riceve il corpo e la risposta e restituisce il valore, o null |
Per codice di stato:
```dart
OneOf.byStatus({
200: OrderPlaced.fromJson,
404: OrderNotFound.fromJson,
'4xx': (json) => OrderRejected(ApiError.fromJson(json)),
}),
```
Vince un codice esatto, poi il pattern con meno `x`.
Con le tue condizioni:
```dart
OneOf.byJson({
(json, response) => response.statusCode == 200 && json['status'] == 'ok': SignUpComplete.fromJson,
(json, response) => response.statusCode == 200 && json['status'] == 'verify': VerifyEmail.fromJson,
}),
```
Con una funzione:
```dart
OneOf((json, response) => switch ((response.statusCode, json)) {
(200, {'status': 'placed'}) => OrderPlaced.fromJson(json),
(200, _) => OrderPending.fromJson(json),
_ => null,
}),
```
Leggi la forma da una risposta con `dataAs()` e `dataIs()`; vedi [NyResponse](/docs/7.x/networking#ny-response).
Metro crea per te il padre, i suoi sottotipi e la voce `OneOf.byKey`:
```bash
metro make:model login_result --one-of="success,two_factor"
```
Vedi [Creare un modello OneOf](/docs/7.x/metro#make-a-one-of-model).
## API decoder
I decoder API vengono utilizzati quando si chiama il metodo helper `api`.
```dart
loadUser() async {
User user = await api((request) => request.fetchUser());
}
```
L'helper `api` abbinera' il servizio API corretto utilizzando i generics, quindi puoi chiamare l'helper qui sotto per accedere al tuo servizio.
```dart
await api((request) => request.callMyMethod());
```
Prima di utilizzare l'helper `api`, dovrai prima aggiungere il tuo servizio API in lib/config/decoders.dart > apiDecoders.
```dart
final Map apiDecoders = {
ApiService: ApiService(),
// ...
};
```