feat: using generated for booking

lib/booking/notification_service.dart

@@ -1,15 +1,14 @@
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:myecl/booking/providers/booking_list_provider.dart';
 import 'package:myecl/booking/providers/confirmed_booking_list_provider.dart';
-import 'package:myecl/booking/providers/user_booking_list_provider.dart';
 import 'package:myecl/booking/router.dart';
 import 'package:tuple/tuple.dart';
 
 final Map<String, Tuple2<String, List<StateNotifierProvider>>>
     bookingProviders = {
   "userBooking": Tuple2(
     BookingRouter.root,
-    [userBookingListProvider, confirmedBookingListProvider],
+    [bookingListProvider, confirmedBookingListProvider],
   ),
   "bookings": Tuple2(
     BookingRouter.root + BookingRouter.admin,

lib/booking/providers/admin_booking_list_provider.dart

@@ -0,0 +1,25 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:myecl/generated/openapi.swagger.dart';
+import 'package:myecl/tools/providers/list_notifier%20copy.dart';
+import 'package:myecl/tools/repository/repository2.dart';
+import 'package:myecl/tools/token_expire_wrapper.dart';
+
+class BookingListProvider extends ListNotifier2<BookingReturnApplicant> {
+  final Openapi bookingRepository;
+  BookingListProvider({required this.bookingRepository})
+      : super(const AsyncValue.loading());
+
+  Future<AsyncValue<List<BookingReturnApplicant>>> loadBookings() async {
+    return await loadList(bookingRepository.bookingBookingsUsersMeManageGet);
+  }
+}
+
+final adminBookingListProvider = StateNotifierProvider<BookingListProvider,
+    AsyncValue<List<BookingReturnApplicant>>>((ref) {
+  final bookingRepository = ref.watch(repositoryProvider);
+  final provider = BookingListProvider(bookingRepository: bookingRepository);
+  tokenExpireWrapperAuth(ref, () async {
+    await provider.loadBookings();
+  });
+  return provider;
+});

lib/booking/providers/booking_list_provider.dart

@@ -1,71 +1,84 @@
 import 'package:flutter_riverpod/flutter_riverpod.dart';
-import 'package:myecl/booking/class/booking.dart';
-import 'package:myecl/booking/providers/is_manager_provider.dart';
-import 'package:myecl/booking/repositories/booking_repository.dart';
-import 'package:myecl/booking/repositories/user_booking_repository.dart';
-import 'package:myecl/tools/providers/list_notifier.dart';
+import 'package:myecl/generated/openapi.swagger.dart';
+import 'package:myecl/tools/providers/list_notifier%20copy.dart';
+import 'package:myecl/tools/repository/repository2.dart';
 import 'package:myecl/tools/token_expire_wrapper.dart';
 import 'package:myecl/user/providers/user_provider.dart';
 
-class BookingListProvider extends ListNotifier<Booking> {
-  final BookingRepository bookingRepository;
-  final UserBookingRepository userRepository;
-  BookingListProvider(
-      {required this.bookingRepository, required this.userRepository})
+class BookingListProvider extends ListNotifier2<BookingReturn> {
+  final Openapi bookingRepository;
+  BookingListProvider({required this.bookingRepository})
       : super(const AsyncValue.loading());
 
-  Future<AsyncValue<List<Booking>>> loadBookings() async {
-    return await loadList(bookingRepository.getBookingList);
+  Future<AsyncValue<List<BookingReturn>>> loadUserBookings(
+      String userId) async {
+    return await loadList(() async => bookingRepository
+        .bookingBookingsUsersApplicantIdGet(applicantId: userId));
   }
 
-  Future<AsyncValue<List<Booking>>> loadUserBookings(String userId) async {
-    return await loadList(() async => userRepository.getMyBookingList(userId));
-  }
-
-  Future<bool> addBooking(Booking booking) async {
-    return await add(bookingRepository.createBooking, booking);
+  Future<bool> addBooking(BookingReturn booking) async {
+    return await add(
+        (booking) async => bookingRepository.bookingBookingsPost(
+                body: BookingBase(
+              reason: booking.reason,
+              start: booking.start,
+              end: booking.end,
+              note: booking.note,
+              roomId: booking.roomId,
+              key: booking.key,
+              recurrenceRule: booking.recurrenceRule,
+              entity: booking.entity,
+            )),
+        booking);
   }
 
-  Future<bool> updateBooking(Booking booking) async {
+  Future<bool> updateBooking(BookingReturn booking) async {
     return await update(
-        bookingRepository.updateBooking,
+        (booking) async => bookingRepository.bookingBookingsBookingIdPatch(
+            bookingId: booking.id,
+            body: BookingEdit(
+              reason: booking.reason,
+              start: booking.start,
+              end: booking.end,
+              note: booking.note,
+              key: booking.key,
+              recurrenceRule: booking.recurrenceRule,
+              entity: booking.entity,
+            )),
         (bookings, booking) => bookings
           ..[bookings.indexWhere((b) => b.id == booking.id)] = booking,
         booking);
   }
 
-  Future<bool> deleteBooking(Booking booking) async {
+  Future<bool> deleteBooking(BookingReturn booking) async {
     return await delete(
-        bookingRepository.deleteBooking,
+        (bookingId) async => bookingRepository.bookingBookingsBookingIdDelete(
+            bookingId: bookingId),
         (bookings, booking) => bookings..removeWhere((i) => i.id == booking.id),
         booking.id,
         booking);
   }
 
-  Future<bool> toggleConfirmed(Booking booking, Decision decision) async {
+  Future<bool> toggleConfirmed(
+      BookingReturn booking, AppUtilsTypesBookingTypeDecision decision) async {
     return await update(
-        (booking) => bookingRepository.confirmBooking(booking, decision),
+        (booking) =>
+            bookingRepository.bookingBookingsBookingIdReplyDecisionPatch(
+                bookingId: booking.id, decision: decision),
         (bookings, booking) => bookings
           ..[bookings.indexWhere((b) => b.id == booking.id)] = booking,
         booking);
   }
 }
 
 final bookingListProvider =
-    StateNotifierProvider<BookingListProvider, AsyncValue<List<Booking>>>(
+    StateNotifierProvider<BookingListProvider, AsyncValue<List<BookingReturn>>>(
         (ref) {
-  final bookingRepository = ref.watch(bookingRepositoryProvider);
-  final userRepository = ref.watch(userBookingRepositoryProvider);
-  final provider = BookingListProvider(
-      bookingRepository: bookingRepository, userRepository: userRepository);
-  final isManager = ref.watch(isManagerProvider);
+  final bookingRepository = ref.watch(repositoryProvider);
+  final provider = BookingListProvider(bookingRepository: bookingRepository);
   tokenExpireWrapperAuth(ref, () async {
-    if (isManager) {
-      await provider.loadBookings();
-    } else {
-      final userId = ref.watch(userProvider);
-      await provider.loadUserBookings(userId.id);
-    }
+    final userId = ref.watch(userProvider);
+    await provider.loadUserBookings(userId.id);
   });
   return provider;
 });

lib/booking/providers/booking_provider.dart

@@ -1,14 +1,14 @@
 import 'package:hooks_riverpod/hooks_riverpod.dart';
-import 'package:myecl/booking/class/booking.dart';
+import 'package:myecl/generated/openapi.swagger.dart';
 
-class BookingNotifier extends StateNotifier<Booking> {
-  BookingNotifier() : super(Booking.empty());
+class BookingNotifier extends StateNotifier<BookingReturnApplicant> {
+  BookingNotifier() : super(BookingReturnApplicant.fromJson({}));
 
-  void setBooking(Booking booking) {
+  void setBooking(BookingReturnApplicant booking) {
     state = booking;
   }
 }
 
-final bookingProvider = StateNotifierProvider<BookingNotifier, Booking>((ref) {
+final bookingProvider = StateNotifierProvider<BookingNotifier, BookingReturnApplicant>((ref) {
   return BookingNotifier();
 });