Dio: POST, PUT, DELETE, ошибки и состояния загрузки

import 'package:equatable/equatable.dart';

class Note extends Equatable {
  const Note({this.id, required this.title, required this.body, required this.userId});

  final int? id; // у новой заметки id ещё нет — его выдаст сервер
  final String title;
  final String body;
  final int userId;

  factory Note.fromJson(Map<String, dynamic> json) => Note(
        id: json['id'] as int?,
        title: json['title'] as String,
        body: json['body'] as String,
        userId: json['userId'] as int,
      );

  Map<String, dynamic> toJson() => {
        if (id != null) 'id': id,
        'title': title,
        'body': body,
        'userId': userId,
      };

  @override
  List<Object?> get props => [id, title, body, userId];
}

import 'package:dio/dio.dart';

final dio = Dio(BaseOptions(
  baseUrl: 'https://jsonplaceholder.typicode.com',
  connectTimeout: const Duration(seconds: 10),
  receiveTimeout: const Duration(seconds: 10),
));

Future<Note> createNote(Note note) async {
  final response = await dio.post<Map<String, dynamic>>(
    '/posts',
    data: note.toJson(),
  );
  return Note.fromJson(response.data!);
}

Future<Note> updateNote(Note note) async {
  final response = await dio.put<Map<String, dynamic>>(
    '/posts/${note.id}',
    data: note.toJson(),
  );
  return Note.fromJson(response.data!);
}

Future<void> renameNote(int id, String newTitle) async {
  await dio.patch('/posts/$id', data: {'title': newTitle});
}

Future<void> deleteNote(int id) async {
  await dio.delete('/posts/$id');
}

await dio.delete(
  '/posts/1',
  options: Options(headers: {'Authorization': 'Bearer YOUR_TOKEN'}),
);

dio.interceptors.add(
  InterceptorsWrapper(
    onRequest: (options, handler) {
      options.headers['Authorization'] = 'Bearer YOUR_TOKEN';
      handler.next(options); // обязательно передать запрос дальше
    },
  ),
);

String describeError(DioException e) {
  switch (e.type) {
    case DioExceptionType.connectionTimeout:
    case DioExceptionType.sendTimeout:
    case DioExceptionType.receiveTimeout:
      return 'Сервер долго не отвечает. Проверьте интернет.';
    case DioExceptionType.connectionError:
      return 'Нет подключения к интернету.';
    case DioExceptionType.badResponse:
      final code = e.response?.statusCode ?? 0;
      if (code == 400) return 'Неверные данные запроса.';
      if (code == 401) return 'Нужно войти заново.';
      if (code == 404) return 'Данные не найдены.';
      if (code >= 500) return 'Ошибка сервера ($code). Попробуйте позже.';
      return 'Ошибка запроса ($code).';
    case DioExceptionType.cancel:
      return 'Запрос отменён.';
    default:
      return 'Что-то пошло не так.';
  }
}

class ApiException implements Exception {
  ApiException(this.message, {this.statusCode});

  final String message;
  final int? statusCode;

  @override
  String toString() => message;
}

class NotesRepository {
  NotesRepository(this._dio);

  final Dio _dio;

  Future<Note> create(Note note) async {
    try {
      final response = await _dio.post<Map<String, dynamic>>('/posts', data: note.toJson());
      return Note.fromJson(response.data!);
    } on DioException catch (e) {
      throw ApiException(describeError(e), statusCode: e.response?.statusCode);
    }
  }

  Future<void> delete(int id) async {
    try {
      await _dio.delete('/posts/$id');
    } on DioException catch (e) {
      throw ApiException(describeError(e), statusCode: e.response?.statusCode);
    }
  }
}

import 'package:equatable/equatable.dart';

sealed class NotesState extends Equatable {
  const NotesState();
  @override
  List<Object?> get props => [];
}

final class NotesInitialState extends NotesState {
  const NotesInitialState();
}

final class NotesLoadingState extends NotesState {
  const NotesLoadingState();
}

final class NotesSuccessState extends NotesState {
  const NotesSuccessState(this.notes);
  final List<Note> notes;
  @override
  List<Object?> get props => [notes];
}

final class NotesErrorState extends NotesState {
  const NotesErrorState(this.message, {this.statusCode});
  final String message;
  final int? statusCode;
  @override
  List<Object?> get props => [message, statusCode];
}

import 'package:flutter_bloc/flutter_bloc.dart';

class NotesCubit extends Cubit<NotesState> {
  NotesCubit(this._repository) : super(const NotesInitialState());

  final NotesRepository _repository;
  final List<Note> _notes = [];

  Future<void> add(String title, String body) async {
    emit(const NotesLoadingState());
    try {
      final created = await _repository.create(Note(title: title, body: body, userId: 1));
      _notes.add(created);
      emit(NotesSuccessState(List.unmodifiable(_notes)));
    } on ApiException catch (e) {
      emit(NotesErrorState(e.message, statusCode: e.statusCode));
    }
  }

  Future<void> remove(int id) async {
    emit(const NotesLoadingState());
    try {
      await _repository.delete(id);
      _notes.removeWhere((n) => n.id == id);
      emit(NotesSuccessState(List.unmodifiable(_notes)));
    } on ApiException catch (e) {
      emit(NotesErrorState(e.message, statusCode: e.statusCode));
    }
  }
}

class NotesView extends StatelessWidget {
  const NotesView({super.key});

  @override
  Widget build(BuildContext context) {
    return BlocConsumer<NotesCubit, NotesState>(
      listener: (context, state) {
        if (state is NotesErrorState && state.statusCode == 401) {
          // здесь будет переход на экран входа
        }
      },
      builder: (context, state) {
        return switch (state) {
          NotesInitialState() => const Center(child: Text('Заметок пока нет')),
          NotesLoadingState() => const Center(child: CircularProgressIndicator()),
          NotesErrorState(:final message) => Center(child: Text(message)),
          NotesSuccessState(:final notes) => ListView(
              children: [for (final n in notes) ListTile(title: Text(n.title))],
            ),
        };
      },
    );
  }
}