Refactor memory service implementation: rename MemoryBookableSpaceService to MemoryCalendarService for clarity and consistency

lib/pages/access_management/booking_system/data/services/memory_bookable_space_service.dart

@@ -0,0 +1,63 @@
+import 'package:syncrow_web/pages/access_management/booking_system/data/services/remote_calendar_service.dart';
+import 'package:syncrow_web/pages/access_management/booking_system/domain/LoadEventsParam.dart';
+import 'package:syncrow_web/pages/access_management/booking_system/domain/models/calendar_event_booking.dart';
+import 'package:syncrow_web/pages/access_management/booking_system/domain/services/calendar_system_service.dart';
+
+class MemoryCalendarService implements CalendarSystemService {
+  final Map<String, CalendarEventsResponse> _eventsCache = {};
+
+  @override
+  Future<CalendarEventsResponse> getCalendarEvents({
+    required LoadEventsParam params,
+  }) async {
+    final key = params.generateKey();
+
+    return _eventsCache[key]!;
+  }
+
+  void setEvents(
+    LoadEventsParam param,
+    CalendarEventsResponse events,
+  ) {
+    final key = param.generateKey();
+    _eventsCache[key] = events;
+  }
+
+  void addEvent(LoadEventsParam param, CalendarEventsResponse event) {
+    final key = param.generateKey();
+
+    _eventsCache[key] = event;
+  }
+
+  void clear() {
+    _eventsCache.clear();
+  }
+}
+
+class MemoryCalendarServiceWithRemoteFallback implements CalendarSystemService {
+  final MemoryCalendarService memoryService;
+  final RemoteCalendarService remoteService;
+
+  MemoryCalendarServiceWithRemoteFallback({
+    required this.memoryService,
+    required this.remoteService,
+  });
+
+  @override
+  Future<CalendarEventsResponse> getCalendarEvents({
+    required LoadEventsParam params,
+  }) async {
+    final key = params.generateKey();
+    final doesExistInMemory = memoryService._eventsCache.containsKey(key);
+
+    if (doesExistInMemory) {
+      return memoryService.getCalendarEvents(params: params);
+    } else {
+      final remoteResult =
+          await remoteService.getCalendarEvents(params: params);
+      memoryService.setEvents(params, remoteResult);
+
+      return remoteResult;
+    }
+  }
+}

lib/pages/access_management/booking_system/data/services/remote_calendar_service.dart

@@ -1,4 +1,5 @@
 import 'package:dio/dio.dart';
+import 'package:syncrow_web/pages/access_management/booking_system/domain/LoadEventsParam.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/domain/models/calendar_event_booking.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/domain/services/calendar_system_service.dart';
 import 'package:syncrow_web/services/api/api_exception.dart';
@@ -13,17 +14,17 @@ class RemoteCalendarService implements CalendarSystemService {
 
   @override
   Future<CalendarEventsResponse> getCalendarEvents({
-    required String spaceId,
-    required String month,
-    required String year,
+    required LoadEventsParam params,
   }) async {
+    final month = params.startDate.month.toString().padLeft(2, '0');
+    final year = params.startDate.year.toString();
 
     try {
       return await _httpService.get<CalendarEventsResponse>(
         path: ApiEndpoints.getBookings
             .replaceAll('{mm}', month)
             .replaceAll('{yyyy}', year)
-            .replaceAll('{space}', spaceId),
+            .replaceAll('{space}', params.id),
         expectedResponseModel: (json) {
           return CalendarEventsResponse.fromJson(json as Map<String, dynamic>);
         },

lib/pages/access_management/booking_system/domain/LoadEventsParam.dart

@@ -0,0 +1,34 @@
+import 'package:equatable/equatable.dart';
+
+class LoadEventsParam extends Equatable {
+  final DateTime startDate;
+  final DateTime endDate;
+  final String id;
+
+  const LoadEventsParam({
+    required this.startDate,
+    required this.endDate,
+    required this.id,
+  });
+
+  @override
+  List<Object?> get props => [startDate, endDate, id];
+
+  LoadEventsParam copyWith({
+    DateTime? startDate,
+    DateTime? endDate,
+    String? id,
+  }) {
+    return LoadEventsParam(
+      startDate: startDate ?? this.startDate,
+      endDate: endDate ?? this.endDate,
+      id: id ?? this.id,
+    );
+  }
+}
+
+extension KeyGenerator on LoadEventsParam {
+  String generateKey() {
+    return '$id-${startDate.year}-${startDate.month.toString().padLeft(2, '0')}';
+  }
+}

lib/pages/access_management/booking_system/domain/services/calendar_system_service.dart

@@ -1,9 +1,8 @@
+import 'package:syncrow_web/pages/access_management/booking_system/domain/LoadEventsParam.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/domain/models/calendar_event_booking.dart';
 
 abstract class CalendarSystemService {
   Future<CalendarEventsResponse> getCalendarEvents({
-    required String spaceId,
-    required String month,
-    required String year,
+    required LoadEventsParam params,
   });
 }

lib/pages/access_management/booking_system/presentation/bloc/calendar/events_bloc.dart

@@ -2,21 +2,20 @@ import 'dart:async';
 import 'package:bloc/bloc.dart';
 import 'package:calendar_view/calendar_view.dart';
 import 'package:flutter/material.dart';
+import 'package:syncrow_web/pages/access_management/booking_system/domain/LoadEventsParam.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/domain/models/calendar_event_booking.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/domain/services/calendar_system_service.dart';
+import 'package:syncrow_web/pages/access_management/booking_system/data/services/memory_bookable_space_service.dart';
 part 'events_event.dart';
 part 'events_state.dart';
 
 class CalendarEventsBloc extends Bloc<CalendarEventsEvent, CalendarEventState> {
   final EventController eventController = EventController();
   final CalendarSystemService calendarService;
-  final Map<String, List<CalendarEventData>> _eventsCache = {};
 
-  String? _lastSpaceId;
-  int? _lastMonth;
-  int? _lastYear;
-
-  CalendarEventsBloc({required this.calendarService}) : super(EventsInitial()) {
+  CalendarEventsBloc({
+    required this.calendarService,
+  }) : super(EventsInitial()) {
     on<LoadEvents>(_onLoadEvents);
     on<AddEvent>(_onAddEvent);
     on<DisposeResources>(_onDisposeResources);
@@ -26,45 +25,20 @@ class CalendarEventsBloc extends Bloc<CalendarEventsEvent, CalendarEventState> {
     LoadEvents event,
     Emitter<CalendarEventState> emit,
   ) async {
-    final month = event.weekEnd.month;
-    final year = event.weekEnd.year;
-    final cacheKey =
-        '${event.spaceId}-$year-${month.toString().padLeft(2, '0')}';
-
-    if (_eventsCache.containsKey(cacheKey)) {
-      final cachedEvents = _eventsCache[cacheKey]!;
-      eventController.addAll(cachedEvents);
-      emit(EventsLoaded(
-        events: cachedEvents,
-        spaceId: event.spaceId,
-        month: month,
-        year: year,
-      ));
-      return;
-    }
-    if (_lastSpaceId == event.spaceId &&
-        _lastMonth == month &&
-        _lastYear == year) {
-      return;
-    }
+    final param = event.param;
+    final month = param.endDate.month;
+    final year = param.endDate.year;
+    final spaceId = param.id;
 
     emit(EventsLoading());
     try {
-      final response = await calendarService.getCalendarEvents(
-        month: month.toString().padLeft(2, '0'),
-        year: year.toString(),
-        spaceId: event.spaceId,
-      );
+      final response = await calendarService.getCalendarEvents(params: param);
 
       final events = response.data.map(_toCalendarEventData).toList();
-      _eventsCache[cacheKey] = events;
       eventController.addAll(events);
-      _lastSpaceId = event.spaceId;
-      _lastMonth = month;
-      _lastYear = year;
       emit(EventsLoaded(
         events: events,
-        spaceId: event.spaceId,
+        spaceId: spaceId,
         month: month,
         year: year,
       ));
@@ -78,15 +52,6 @@ class CalendarEventsBloc extends Bloc<CalendarEventsEvent, CalendarEventState> {
 
     if (state is EventsLoaded) {
       final loaded = state as EventsLoaded;
-      final cacheKey =
-          '${loaded.spaceId}-${loaded.year}-${loaded.month.toString().padLeft(2, '0')}';
-
-      if (_eventsCache.containsKey(cacheKey)) {
-        final cachedEvents =
-            List<CalendarEventData>.from(_eventsCache[cacheKey]!);
-        cachedEvents.add(event.event);
-        _eventsCache[cacheKey] = cachedEvents;
-      }
 
       emit(EventsLoaded(
         events: [...eventController.events],

lib/pages/access_management/booking_system/presentation/bloc/calendar/events_event.dart

@@ -6,17 +6,11 @@ abstract class CalendarEventsEvent {
 }
 
 class LoadEvents extends CalendarEventsEvent {
-  final String spaceId;
-  final DateTime weekStart;
-  final DateTime weekEnd;
-
-  const LoadEvents({
-    required this.spaceId,
-    required this.weekStart,
-    required this.weekEnd,
-  });
+  final LoadEventsParam param;
+  const LoadEvents(this.param);
 }
 
+
 class AddEvent extends CalendarEventsEvent {
   final CalendarEventData event;
   const AddEvent(this.event);

lib/pages/access_management/booking_system/presentation/view/booking_page.dart

@@ -2,11 +2,13 @@ import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:calendar_view/calendar_view.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/data/services/remote_calendar_service.dart';
+import 'package:syncrow_web/pages/access_management/booking_system/domain/LoadEventsParam.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/presentation/bloc/calendar/events_bloc.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/presentation/bloc/date_selection/date_selection_bloc.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/presentation/bloc/date_selection/date_selection_event.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/presentation/bloc/date_selection/date_selection_state.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/presentation/bloc/selected_bookable_space_bloc/selected_bookable_space_bloc.dart';
+import 'package:syncrow_web/pages/access_management/booking_system/data/services/memory_bookable_space_service.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/presentation/view/widgets/booking_sidebar.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/presentation/view/widgets/custom_calendar_page.dart';
 import 'package:syncrow_web/pages/access_management/booking_system/presentation/view/widgets/icon_text_button.dart';
@@ -46,9 +48,11 @@ class _BookingPageState extends State<BookingPage> {
     if (selectedRoom != null) {
       context.read<CalendarEventsBloc>().add(
             LoadEvents(
-              spaceId: selectedRoom.uuid,
-              weekStart: dateState.weekStart,
-              weekEnd: dateState.weekStart.add(const Duration(days: 6)),
+              LoadEventsParam(
+                startDate: dateState.weekStart,
+                endDate: dateState.weekStart.add(const Duration(days: 6)),
+                id: selectedRoom.uuid,
+              ),
             ),
           );
     }
@@ -61,12 +65,14 @@ class _BookingPageState extends State<BookingPage> {
         BlocProvider(create: (_) => SelectedBookableSpaceBloc()),
         BlocProvider(create: (_) => DateSelectionBloc()),
         BlocProvider(
-          create: (_) => CalendarEventsBloc(
-            calendarService: RemoteCalendarService(
-              HTTPService(),
-            ),
-          ),
-        ),
+            create: (_) => CalendarEventsBloc(
+                  calendarService: MemoryCalendarServiceWithRemoteFallback(
+                    remoteService: RemoteCalendarService(
+                      HTTPService(),
+                    ),
+                    memoryService: MemoryCalendarService(),
+                  ),
+                )),
       ],
       child: Builder(
         builder: (context) =>

lib/pages/access_management/booking_system/presentation/view/widgets/weekly_calendar_page.dart

@@ -24,7 +24,7 @@ class WeeklyCalendarPage extends StatelessWidget {
   });
   static const double timeLineWidth = 65;
   static const int totalDays = 7;
-  static const double dayColumnWidth = 220; // or any width you want
+  static const double dayColumnWidth = 220; 
 
   final double calendarContentWidth =
       timeLineWidth + (totalDays * dayColumnWidth);