appiq-solution 1.2.0 → 1.3.1

package/#NEW APP PROMPT/project_ai_prompt.md

@@ -0,0 +1,544 @@
+# AiGo Project Architecture Documentation
+
+## Overview
+
+AiGo is a Flutter application following clean architecture principles with a clear separation of concerns. The app is built using modern Flutter development practices, including:
+
+- **Clean Architecture**: Separation between UI, domain logic, and data sources
+- **Riverpod**: State management with `riverpod_annotation` for code generation
+- **Freezed**: Immutable state classes with code generation
+- **Go Router**: Declarative routing
+- **Internationalization**: Multi-language support with ARB files
+- **Firebase Integration**: Authentication, Firestore, and Storage
+- **Responsive Design**: Adapts to different screen sizes and orientations
+
+## Folder Structure
+
+```
+lib/
+├── core/                # Core utilities and shared components
+│   ├── config/          # App configuration
+│   ├── initialization/  # App initialization logic
+│   ├── json_converters/ # JSON conversion helpers
+│   ├── locale/          # Locale handling
+│   ├── location/        # Location services
+│   ├── mixins/          # Reusable mixins
+│   ├── network/         # Network utilities
+│   ├── routing/         # Routing configuration
+│   ├── services/        # Core services
+│   ├── storage/         # Local storage
+│   ├── theme/           # Theme configuration
+│   ├── utils/           # Utility functions
+│   └── widgets/         # Shared widgets
+│
+├── data/                # Data layer
+│   ├── datasources/     # Data sources (local, remote)
+│   ├── dtos/            # Data Transfer Objects
+│   ├── mappers/         # Mappers between DTOs and domain models 
+│   └── repositories/    # Repository implementations
+│
+├── domain/              # Domain layer
+│   ├── models/          # Domain models
+│   ├── repositories/    # Repository interfaces
+│   └── usecases/        # Business logic use cases
+│
+├── l10n/                # Localization
+│   ├── app_*.arb        # Translation files for different languages
+│   └── generate_translations.py # Script to manage translations
+│
+├── views/               # UI components organized by feature
+│   ├── event/           # Event feature module
+│   │   ├── providers/   # State management
+│   │   │   └── states/  # Immutable state classes
+│   │   ├── screens/     # Screens
+│   │   └── widgets/     # Feature-specific widgets
+│   ├── home/            # Home feature
+│   ├── place/           # Place feature
+│   ├── plan/            # Plan feature
+│   ├── profile/         # Profile feature
+│   └── settings/        # Settings feature
+│
+├── service_locator.dart # Dependency injection
+├── app.dart             # App configuration
+└── main.dart            # Entry point
+```
+
+## Core Architecture
+
+### Dependency Injection
+
+AiGo uses GetIt and Riverpod for dependency injection:
+
+- **GetIt**: Service locator pattern for globally accessible services
+- **Riverpod**: Provider-based dependency injection for component-specific dependencies
+
+Example from `service_locator.dart`:
+
+```dart
+final GetIt getIt = GetIt.instance;
+
+Future<void> setupServiceLocator() async {
+  // Initialize provider container
+  providerContainer = ProviderContainer();
+  
+  // Register services
+  getIt
+    ..registerLazySingleton(() => Logger())
+    ..registerLazySingleton(() => FirebaseAuth.instance)
+    // More registrations...
+}
+```
+
+### Routing
+
+Routing is handled by Go Router with a declarative approach:
+
+```dart
+final router = GoRouter(
+  navigatorKey: _rootNavigatorKey,
+  initialLocation: AppRoutes.initialRoute,
+  routes: [
+    ShellRoute(
+      navigatorKey: _shellNavigatorKey,
+      builder: (context, state, child) {
+        return BottomNavBar(child: child);
+      },
+      routes: [
+        GoRoute(
+          path: AppRoutes.homeRoute,
+          builder: (context, state) => const HomeScreen(),
+        ),
+        // More routes...
+      ],
+    ),
+    // More top-level routes...
+  ],
+);
+```
+
+Route paths are defined in a centralized `routes.dart` file for easy reference:
+
+```dart
+class AppRoutes {
+  // Core Routes
+  static const String initialRoute = '/';
+  static const String homeRoute = '/home';
+  static const String exploreRoute = '/explore';
+  // More routes...
+}
+```
+
+## Localization
+
+AiGo supports multiple languages: English, German, Russian, Turkish, and Arabic. Translations are managed using:
+
+1. **ARB Files**: Source of truth for all translations
+2. **Code Generation**: Flutter's built-in localization code generation
+3. **Python Script**: Helper script to manage translations
+
+The localization system:
+
+```dart
+MaterialApp.router(
+  // ...
+  locale: locale,
+  localizationsDelegates: const <LocalizationsDelegate<dynamic>>[
+    AppLocalizations.delegate,
+    GlobalMaterialLocalizations.delegate,
+    GlobalWidgetsLocalizations.delegate,
+    GlobalCupertinoLocalizations.delegate,
+  ],
+  supportedLocales: const [
+    Locale('en'),
+    Locale('de'),
+    Locale('ru'),
+    Locale('tr'),
+    Locale('ar'),
+  ],
+  // ...
+)
+```
+
+Using translations in code:
+
+```dart
+final l10n = AppLocalizations.of(context);
+Text(l10n.eventOrganizer)
+```
+
+## State Management
+
+### Providers
+
+Riverpod is used for state management with code generation:
+
+```dart
+@Riverpod(keepAlive: true)
+class EventDetailsNotifier extends _$EventDetailsNotifier {
+  late final EventRepository _eventRepository = getIt<EventRepository>();
+
+  @override
+  EventDetailsState build({required String eventId}) {
+    return EventDetailsState(eventId: eventId);
+  }
+
+  Future<void> loadEventDetails() async {
+    state = state.copyWith(isLoading: true, hasError: false);
+    
+    try {
+      final event = await _eventRepository.getEventById(state.eventId);
+      
+      // ...
+
+      state = state.copyWith(
+        isLoading: false,
+        hasError: false,
+        event: event,
+        travelInfo: travelInfo,
+      );
+    } catch (e) {
+      state = state.copyWith(
+        isLoading: false,
+        hasError: true,
+        errorMessage: e.toString(),
+      );
+    }
+  }
+}
+```
+
+### State Classes
+
+Immutable state classes using Freezed:
+
+```dart
+@freezed
+abstract class EventDetailsState with _$EventDetailsState {
+  const factory EventDetailsState({
+    required String eventId,
+    Event? event,
+    @Default(false) bool isLoading,
+    @Default(false) bool hasError,
+    String? errorMessage,
+    @Default(EventDetailsTab.details) EventDetailsTab activeTab,
+    @Default(false) bool isJoining,
+    Map<String, dynamic>? travelInfo,
+  }) = _EventDetailsState;
+}
+```
+
+## Domain Layer
+
+### Models
+
+Domain models represent business entities:
+
+```dart
+class Event {
+  final String id;
+  final String title;
+  final String description;
+  final DateTime startTime;
+  final DateTime endTime;
+  final Position location;
+  final String category;
+  final int capacity;
+  final double? price;
+  final List<String> images;
+  final String? venue;
+  final String? organizer;
+  final List<String>? attendees;
+  final bool? isOnline;
+  final String? link;
+  final dynamic additionalInfo;
+
+  // Constructor, fromJson, toJson methods...
+}
+```
+
+### Repository Interfaces
+
+Repository interfaces define the contract between domain and data layers:
+
+```dart
+abstract class EventRepository {
+  Future<List<Event>> getUpcomingEvents({Position? location});
+  Future<List<Event>> getEventsByDate(DateTime date, {Position? location});
+  Future<Event?> getEventById(String id);
+  Future<List<Event>> searchEvents(String query, {Position? location});
+  // More methods...
+}
+```
+
+## Data Layer
+
+### DTOs
+
+DTOs define the structure for data transfer:
+
+```dart
+@freezed
+abstract class EventDTO with _$EventDTO {
+  factory EventDTO({
+    required String id,
+    required String title,
+    required String description,
+    required DateTime startTime,
+    required DateTime endTime,
+    @PositionConverter() required Position location,
+    required String category,
+    required int capacity,
+    required List<String> images,
+    double? price,
+    String? venue,
+    String? organizer,
+    // More fields...
+  }) = _EventDTO;
+
+  factory EventDTO.fromJson(Map<String, dynamic> json) =>
+      _$EventDTOFromJson(json);
+}
+```
+
+### Mappers
+
+Mappers transform between DTOs and domain models:
+
+```dart
+class EventMapper {
+  static Event toDomain(EventDTO dto) {
+    return Event(
+      id: dto.id,
+      title: dto.title,
+      // Map all fields...
+    );
+  }
+
+  static EventDTO fromDomain(Event domain) {
+    // Transform domain model to DTO...
+  }
+}
+```
+
+### Repository Implementations
+
+Repository implementations handle data access logic:
+
+```dart
+class EventRepositoryImpl implements EventRepository {
+  @override
+  Future<Event?> getEventById(String id) async {
+    try {
+      // Fetch data from remote or local source
+      final eventDTO = await _dataSource.fetchEvent(id);
+      if (eventDTO == null) return null;
+      
+      // Convert DTO to domain model
+      return EventMapper.toDomain(eventDTO);
+    } catch (e) {
+      throw AppException.fromError('Failed to get event: $e');
+    }
+  }
+  
+  // More implementations...
+}
+```
+
+## UI Layer
+
+### Screens
+
+Screens represent full-page UI components and handle user interactions:
+
+```dart
+class EventDetailsScreen extends ConsumerStatefulWidget {
+  final String eventId;
+  
+  const EventDetailsScreen({required this.eventId, super.key});
+  
+  @override
+  ConsumerState<EventDetailsScreen> createState() => _EventDetailsScreenState();
+}
+
+class _EventDetailsScreenState extends ConsumerState<EventDetailsScreen> {
+  @override
+  void initState() {
+    super.initState();
+    // Load data when screen initializes
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      ref.read(eventDetailsNotifierProvider(eventId: widget.eventId).notifier)
+        .loadEventDetails();
+    });
+  }
+  
+  @override
+  Widget build(BuildContext context) {
+    final state = ref.watch(eventDetailsNotifierProvider(eventId: widget.eventId));
+    
+    if (state.isLoading) {
+      return EventDetailsShimmer();
+    }
+    
+    if (state.hasError) {
+      return ErrorView(message: state.errorMessage);
+    }
+    
+    final event = state.event;
+    if (event == null) {
+      return NotFoundView();
+    }
+    
+    return DetailScaffold(
+      title: event.title,
+      body: Column(
+        children: [
+          // Event details widgets...
+          EventOrganizerSection(event: event),
+          EventActionButtons(event: event),
+        ],
+      ),
+    );
+  }
+}
+```
+
+### Widgets
+
+Reusable UI components:
+
+```dart
+class EventOrganizerSection extends StatelessWidget {
+  final Event event;
+
+  const EventOrganizerSection({required this.event, super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final l10n = AppLocalizations.of(context);
+
+    if (event.organizer == null) return const SizedBox.shrink();
+
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        ResponsiveText.h3(l10n.organizer),
+        // Widget implementation...
+      ],
+    );
+  }
+}
+```
+
+## Theming
+
+AiGo uses a comprehensive theming system:
+
+```dart
+ThemeData get lightTheme {
+  return ThemeData(
+    useMaterial3: true,
+    brightness: Brightness.light,
+    colorScheme: ColorScheme.fromSeed(
+      seedColor: AppColors.primary,
+      brightness: Brightness.light,
+    ),
+    // More theme configuration...
+  );
+}
+```
+
+Theme colors with light/dark mode support:
+
+```dart
+class AppColors {
+  // Brand Colors
+  static const Color primary = Color(0xFF3f5e95);
+  static const Color primaryLight = Color.fromARGB(255, 136, 174, 239);
+  // More colors...
+
+  // Helper methods for theme-aware colors
+  static Color getTextColor() => ThemeService().isDark ? lightText : darkText;
+  static Color getBackgroundColor() =>
+      ThemeService().isDark ? darkBackground : lightBackground;
+  // More helpers...
+}
+```
+
+## Utilities and Helpers
+
+### Responsive Design
+
+Responsive utilities help adapt the UI to different screen sizes:
+
+```dart
+class ResponsiveUtil {
+  // Check device type
+  static bool isPhone(BuildContext context) => 
+      MediaQuery.of(context).size.width < 600;
+      
+  static bool isTablet(BuildContext context) =>
+      MediaQuery.of(context).size.width >= 600 && 
+      MediaQuery.of(context).size.width < 1200;
+      
+  // Get responsive values
+  static double getResponsiveFontSize(BuildContext context, double size) {
+    // Calculate appropriate font size based on screen width
+  }
+  
+  static EdgeInsets getResponsivePadding(BuildContext context) {
+    // Return appropriate padding based on screen size
+  }
+}
+```
+
+Responsive components:
+
+```dart
+class ResponsiveText extends StatelessWidget {
+  // Implementation of responsive text
+  
+  // Factory constructors for text styles
+  factory ResponsiveText.h1(String text, {...}) { ... }
+  factory ResponsiveText.h2(String text, {...}) { ... }
+  factory ResponsiveText.body(String text, {...}) { ... }
+}
+```
+
+### String Utilities
+
+```dart
+class StringUtils {
+  // Capitalize text
+  static String capitalize(String text) {
+    if (text.isEmpty) return text;
+    return text[0].toUpperCase() + text.substring(1).toLowerCase();
+  }
+  
+  // Truncate text with ellipsis
+  static String truncate(String text, int maxLength) {
+    if (text.length <= maxLength) return text;
+    return '${text.substring(0, maxLength)}...';
+  }
+  
+  // More utility methods...
+}
+```
+
+## Adding New Features
+
+When adding a new feature to AiGo:
+
+1. **Create the domain model**: Define the entity in `domain/models/`
+2. **Create the repository interface**: Define data access methods in `domain/repositories/`
+3. **Create the DTO and mapper**: Define data transfer objects in `data/dtos/` and mappers in `data/mappers/`
+4. **Implement the repository**: Create concrete implementation in `data/repositories/`
+5. **Create state classes**: Define the UI state using Freezed in `views/feature/providers/states/`
+6. **Create providers**: Implement state management in `views/feature/providers/`
+7. **Build UI components**: Create screens and widgets in `views/feature/screens/` and `views/feature/widgets/`
+8. **Add routing**: Update `app_router.dart` with new routes
+9. **Add translations**: Update ARB files with new strings for all supported languages
+
+## Conclusion
+
+The AiGo application follows modern Flutter development practices with a clean, maintainable architecture. The separation of concerns between domain, data, and UI layers makes the code modular and testable, while the use of code generation reduces boilerplate code and improves type safety.