: (data) => List.from(data).map((json) => User.fromJson(json)).toList(),
User: (data) => User.fromJson(data),
// ...
};
```
W pliku modelDecoders musimy podac `Type` jako klucz i obsluzyc przeksztalcenie w wartosci, jak w powyzszym przykladzie.
Argument `data` bedzie zawieral dane z zapytania API.
## Dekodery typowane
Wymagania
Nylo 7.5.0+
nylo_support 7.37.0+
`decoders([...])` buduje mape `modelDecoders` z listy. `Decode(User.fromJson)` dekoduje `User`, a takze `List`, bez osobnego wpisu:
```dart
final Map modelDecoders = decoders([
Decode(User.fromJson),
Decode(Order.fromJson, from: 'data'),
]);
```
Uzyj `from`, aby odczytac model z wnetrza opakowanego body, np. `{"data": {...}}`. Klucz z kropka, taki jak `'data.user'`, czyta glebiej, a w przypadku listy sama lista jest odczytywana z `from`.
`Decode` przyjmuje `fromJson`, ktory akceptuje `dynamic` lub `Map`. W przypadku closure okresl typ jego parametru:
```dart
Decode((dynamic json) => User.fromJson(json)),
```
Dekodery w postaci closure w mapie `{...}`, takie jak `User: (data) => User.fromJson(data)`, nadal dzialaja. Oba sa `NyDecoder`, klasa, ktora rozszerzaja `Decode` i `OneOf`. Wlasny `NyDecoder` implementuje `decode(json, response, decoders)` i widzi caly `NyResponse`, wiec moze odczytac kod statusu lub naglowki.
## OneOf
Wymagania
Nylo 7.5.0+
nylo_support 7.37.0+
`OneOf` dekoduje odpowiedz, ktora moze miec wiecej niz jeden ksztalt. Zarejestruj go pod wspolnym typem nadrzednym i wybierz ksztalt na podstawie pola w body, kodu statusu lub wlasnych warunkow:
```dart
final Map modelDecoders = decoders([
OneOf.byKey('status', {
'success': LoginSuccess.fromJson,
'two_factor': TwoFactorRequired.fromJson,
}, otherwise: (json) => LoginFailed(ApiError.fromJson(json))),
]);
```
`OneOf` dekoduje rowniez body odpowiedzi 4xx i 5xx oraz `List` element po elemencie. Nierozpoznany ksztalt pozostawia dane odpowiedzi jako null.
| Konstruktor | Wybiera ksztalt na podstawie |
|-------------|--------------------|
| `OneOf.byKey(key, types, otherwise:)` | Wartosci `key` w body. Klucz z kropka, taki jak `'data.type'`, czyta zagniezdzone pole |
| `OneOf.byStatus(types, otherwise:)` | Kodu statusu. Kluczem jest kod, np. `404`, lub wzorzec, np. `'4xx'` lub `'40x'` |
| `OneOf.byJson(types, otherwise:)` | Wlasnych warunkow, z ktorych kazdy przyjmuje body i odpowiedz. Wygrywa pierwszy, ktory zwroci true |
| `OneOf(resolve)` | Funkcji, ktora przyjmuje body i odpowiedz oraz zwraca wartosc lub null |
Wedlug kodu statusu:
```dart
OneOf.byStatus({
200: OrderPlaced.fromJson,
404: OrderNotFound.fromJson,
'4xx': (json) => OrderRejected(ApiError.fromJson(json)),
}),
```
Wygrywa dokladny kod, a nastepnie wzorzec z najmniejsza liczba `x`.
Z wlasnymi warunkami:
```dart
OneOf.byJson({
(json, response) => response.statusCode == 200 && json['status'] == 'ok': SignUpComplete.fromJson,
(json, response) => response.statusCode == 200 && json['status'] == 'verify': VerifyEmail.fromJson,
}),
```
Z funkcja:
```dart
OneOf((json, response) => switch ((response.statusCode, json)) {
(200, {'status': 'placed'}) => OrderPlaced.fromJson(json),
(200, _) => OrderPending.fromJson(json),
_ => null,
}),
```
Odczytaj ksztalt z odpowiedzi za pomoca `dataAs()` i `dataIs()`; zobacz [NyResponse](/docs/7.x/networking#ny-response).
Metro tworzy dla Ciebie typ nadrzedny, jego podtypy oraz wpis `OneOf.byKey`:
```bash
metro make:model login_result --one-of="success,two_factor"
```
Zobacz [Utworz model OneOf](/docs/7.x/metro#make-a-one-of-model).
## Dekodery API
Dekodery API sa uzywane podczas wywolywania metody pomocniczej `api`.
```dart
loadUser() async {
User user = await api((request) => request.fetchUser());
}
```
Helper `api` dopasuje odpowiedni serwis API za pomoca generyków, wiec mozesz wywolac ponizszy helper, aby uzyskac dostep do serwisu.
```dart
await api((request) => request.callMyMethod());
```
Przed uzyciem helpera `api` musisz najpierw dodac swoj serwis API do lib/config/decoders.dart > apiDecoders.
```dart
final Map apiDecoders = {
ApiService: ApiService(),
// ...
};
```