rothzerg 0.1.0

package/templates/mobile-app/lib/screens/settings/delete_account_screen.dart

@@ -0,0 +1,261 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:cloud_firestore/cloud_firestore.dart';
+import 'package:device_info_plus/device_info_plus.dart';
+import 'dart:io';
+import '../../core/config/app_config.dart';
+import '../../core/services/logging_service.dart';
+import '../../l10n/app_localizations.dart';
+import '../../providers/auth_provider.dart';
+import '../../providers/subscription_provider.dart';
+import '../../widgets/custom_app_bar.dart';
+import '../../widgets/app_button.dart';
+import '../../widgets/top_notification.dart';
+import '../auth/login_screen.dart';
+
+class DeleteAccountScreen extends ConsumerStatefulWidget {
+  const DeleteAccountScreen({super.key});
+
+  @override
+  ConsumerState<DeleteAccountScreen> createState() =>
+      _DeleteAccountScreenState();
+}
+
+class _DeleteAccountScreenState extends ConsumerState<DeleteAccountScreen> {
+  bool _isDeleting = false;
+  final LoggingService _loggingService = LoggingService();
+
+  Future<void> _deleteAccount() async {
+    final l10n = AppLocalizations.of(context)!;
+
+    // Show confirmation dialog
+    final confirmed = await showDialog<bool>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text(l10n.confirmDeletion),
+        content: Text(l10n.confirmDeletionMessage),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context, false),
+            child: Text(l10n.cancel),
+          ),
+          TextButton(
+            onPressed: () => Navigator.pop(context, true),
+            style: TextButton.styleFrom(
+              foregroundColor: Theme.of(context).colorScheme.error,
+            ),
+            child: Text(l10n.delete),
+          ),
+        ],
+      ),
+    );
+
+    if (confirmed != true) return;
+
+    setState(() {
+      _isDeleting = true;
+    });
+
+    try {
+      final authController = ref.read(authControllerProvider);
+      final user = authController.currentUser;
+
+      if (user == null) {
+        throw Exception('No user logged in');
+      }
+
+      // Get device information
+      final deviceInfo = DeviceInfoPlugin();
+      String deviceModel = 'Unknown';
+      String osVersion = 'Unknown';
+
+      if (Platform.isAndroid) {
+        final androidInfo = await deviceInfo.androidInfo;
+        deviceModel = androidInfo.model;
+        osVersion = 'Android ${androidInfo.version.release}';
+      } else if (Platform.isIOS) {
+        final iosInfo = await deviceInfo.iosInfo;
+        deviceModel = iosInfo.model;
+        osVersion = 'iOS ${iosInfo.systemVersion}';
+      }
+
+      // Calculate deletion date (30 days from now)
+      final deletionDate = DateTime.now().add(const Duration(days: 30));
+
+      // Get subscription details
+      final customerInfo = await ref
+          .read(customerInfoProvider.future)
+          .catchError((_) => null);
+      final isPremium = await ref
+          .read(premiumStatusProvider.future)
+          .catchError((_) => false);
+
+      Map<String, dynamic> subscriptionData = {
+        'isPremium': isPremium,
+        'hasActiveSubscription': false,
+        'subscriptionProductId': null,
+        'subscriptionExpirationDate': null,
+        'subscriptionPurchaseDate': null,
+      };
+
+      if (customerInfo != null && customerInfo.entitlements.active.isNotEmpty) {
+        final activeEntitlement = customerInfo.entitlements.active.values.first;
+        final expirationDate = activeEntitlement.expirationDate;
+        final purchaseDate = activeEntitlement.latestPurchaseDate;
+
+        subscriptionData = {
+          'isPremium': isPremium,
+          'hasActiveSubscription': true,
+          'subscriptionProductId': activeEntitlement.productIdentifier,
+          'subscriptionExpirationDate': expirationDate != null
+              ? Timestamp.fromDate(DateTime.parse(expirationDate))
+              : null,
+          'subscriptionPurchaseDate': Timestamp.fromDate(
+            DateTime.parse(purchaseDate),
+          ),
+          'subscriptionWillRenew': activeEntitlement.willRenew,
+          'subscriptionStore': activeEntitlement.store.name,
+        };
+      }
+
+      // Create account deletion request in Firestore
+      await FirebaseFirestore.instance
+          .collection('accountdeleterequest')
+          .doc(user.uid)
+          .set({
+            'userId': user.uid,
+            'email': user.email,
+            'displayName': user.displayName,
+            'phoneNumber': user.phoneNumber,
+            'requestedAt': FieldValue.serverTimestamp(),
+            'deletionDate': Timestamp.fromDate(deletionDate),
+            'deviceModel': deviceModel,
+            'osVersion': osVersion,
+            'appVersion': AppConfig.displayName,
+            'subscription': subscriptionData,
+          });
+
+      // Log account deletion request
+      await _loggingService.logAccountDeletion(
+        uid: user.uid,
+        additionalData: {
+          'scheduled_deletion_date': deletionDate.toIso8601String(),
+          'isPremium': isPremium,
+        },
+      );
+
+      // Sign out the user
+      await authController.signOut();
+
+      if (mounted) {
+        // Show success notification
+        TopNotification.showSuccess(
+          context,
+          message: l10n.accountDeletionScheduled,
+          duration: const Duration(seconds: 4),
+        );
+
+        // Navigate to login screen
+        Navigator.of(context).pushAndRemoveUntil(
+          MaterialPageRoute(builder: (context) => const LoginScreen()),
+          (route) => false,
+        );
+      }
+    } catch (e) {
+      setState(() {
+        _isDeleting = false;
+      });
+
+      if (mounted) {
+        TopNotification.showError(
+          context,
+          message: '${l10n.deletionFailed}: $e',
+        );
+      }
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final l10n = AppLocalizations.of(context)!;
+    final theme = Theme.of(context);
+
+    return Scaffold(
+      appBar: CustomAppBar(title: l10n.deleteAccount),
+      body: Padding(
+        padding: const EdgeInsets.all(24.0),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.stretch,
+          children: [
+            // Warning Icon
+            Icon(
+              Icons.warning_amber_rounded,
+              size: 80,
+              color: theme.colorScheme.error,
+            ),
+            const SizedBox(height: 32),
+
+            // Warning Message
+            Card(
+              child: Padding(
+                padding: const EdgeInsets.all(20.0),
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Text(
+                      l10n.deleteAccountWarning(AppConfig.displayName),
+                      style: theme.textTheme.bodyLarge?.copyWith(height: 1.5),
+                    ),
+                    const SizedBox(height: 24),
+                    Text(
+                      l10n.deleteAccountConfirmation,
+                      style: theme.textTheme.titleMedium?.copyWith(
+                        fontWeight: FontWeight.bold,
+                        color: theme.colorScheme.error,
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+
+            const Spacer(),
+
+            // Delete and Cancel Buttons
+            Row(
+              children: [
+                Expanded(
+                  child: AppButton(
+                    label: l10n.delete,
+                    onPressed: _isDeleting ? null : _deleteAccount,
+                    variant: AppButtonVariant.primary,
+                    size: AppButtonSize.large,
+                    isFullWidth: true,
+                    isLoading: _isDeleting,
+                    leading: const Icon(
+                      Icons.delete_forever,
+                      color: Colors.white,
+                    ),
+                  ),
+                ),
+                const SizedBox(width: 12),
+                Expanded(
+                  child: AppButton(
+                    label: l10n.cancel,
+                    onPressed: _isDeleting
+                        ? null
+                        : () => Navigator.pop(context),
+                    variant: AppButtonVariant.outlined,
+                    size: AppButtonSize.large,
+                    isFullWidth: true,
+                  ),
+                ),
+              ],
+            ),
+            const SizedBox(height: 24),
+          ],
+        ),
+      ),
+    );
+  }
+}

package/templates/mobile-app/lib/screens/settings/settings_screen.dart

@@ -0,0 +1,400 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:package_info_plus/package_info_plus.dart';
+import 'package:share_plus/share_plus.dart';
+import '../../core/config/app_config.dart';
+import '../../providers/theme_provider.dart';
+import '../../providers/auth_provider.dart';
+import '../../l10n/app_localizations.dart';
+import '../../widgets/app_button.dart';
+import '../../widgets/section_header.dart';
+import '../../widgets/language_picker.dart';
+import '../../widgets/bottom_sheet_selector.dart';
+import '../../core/constants/languages.dart';
+import '../../widgets/top_notification.dart';
+import '../../widgets/success_overlay.dart';
+import '../auth/auth_home_screen.dart';
+import '../legal/privacy_policy_screen.dart';
+import '../legal/terms_screen.dart';
+import '../premium/subscription_screen.dart';
+import '../profile/edit_profile_screen.dart';
+import '../admin/admin_panel_screen.dart';
+import 'change_password_screen.dart';
+import 'about_app_screen.dart';
+import 'cache_manager_screen.dart';
+import 'delete_account_screen.dart';
+
+class SettingsScreen extends ConsumerStatefulWidget {
+  const SettingsScreen({super.key});
+
+  @override
+  ConsumerState<SettingsScreen> createState() => _SettingsScreenState();
+}
+
+class _SettingsScreenState extends ConsumerState<SettingsScreen> {
+  String _appVersion = '';
+  Language? _selectedLanguage;
+  String? _lastLang;
+
+  @override
+  void initState() {
+    super.initState();
+    _loadAppInfo();
+  }
+
+  Future<void> _loadAppInfo() async {
+    final packageInfo = await PackageInfo.fromPlatform();
+    setState(() {
+      _appVersion = '${packageInfo.version} (${packageInfo.buildNumber})';
+    });
+  }
+
+  Future<void> _updateLanguage(Language language) async {
+    try {
+      final authState = ref.read(authStateProvider);
+      final uid = authState.value?.uid;
+
+      if (uid != null) {
+        await ref
+            .read(authControllerProvider)
+            .setupProfile(uid: uid, lang: language.code);
+
+        if (mounted) {
+          setState(() {
+            _selectedLanguage = language;
+          });
+          await SuccessOverlay.show(context);
+        }
+      }
+    } catch (e) {
+      if (mounted) {
+        TopNotification.showError(
+          context,
+          message: 'Failed to update language: $e',
+        );
+      }
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final l10n = AppLocalizations.of(context)!;
+    final themeMode = ref.watch(themeModeProvider);
+    final theme = Theme.of(context);
+    final authState = ref.watch(authStateProvider);
+    final uid = authState.value?.uid;
+
+    // Watch user profile and update language when stream data changes
+    bool isAdmin = false;
+    if (uid != null) {
+      final userProfileAsync = ref.watch(userProfileProvider(uid));
+      userProfileAsync.whenData((userProfile) {
+        if (userProfile != null) {
+          final newLang = userProfile.lang;
+          if (_lastLang != newLang) {
+            WidgetsBinding.instance.addPostFrameCallback((_) {
+              if (mounted) {
+                setState(() {
+                  _selectedLanguage = getLanguageByCode(newLang);
+                  _lastLang = newLang;
+                });
+              }
+            });
+          }
+        }
+      });
+      // Check if user is admin
+      isAdmin = userProfileAsync.value?.isAdmin ?? false;
+    }
+
+    return Scaffold(
+      body: ListView(
+        children: [
+          // Appearance Section
+          SectionHeader(title: l10n.appearance),
+          ListTile(
+            leading: const Icon(Icons.brightness_6_outlined),
+            title: Text(l10n.theme),
+            subtitle: Text(_getThemeModeLabel(themeMode, l10n)),
+            onTap: () => _showThemeDialog(context),
+          ),
+          ListTile(
+            leading: const Icon(Icons.language_outlined),
+            title: Text(l10n.language),
+            subtitle: Text(
+              _selectedLanguage?.nativeName ?? l10n.selectYourLanguage,
+            ),
+            onTap: () async {
+              final selected = await showSelectorBottomSheet<Language>(
+                context: context,
+                builder: (context) => LanguagePicker(
+                  selectedLanguage: _selectedLanguage,
+                  onLanguageSelected: (language) async {
+                    if (language != null) {
+                      await _updateLanguage(language);
+                    }
+                  },
+                ),
+              );
+              if (selected != null) {
+                await _updateLanguage(selected);
+              }
+            },
+          ),
+          const Divider(),
+
+          // Account & Security Section (only for non-anonymous users)
+          // if (user != null && !user.isAnonymous) ...[
+          SectionHeader(title: l10n.accountSecurity),
+          ListTile(
+            leading: const Icon(Icons.person_outline),
+            title: Text(l10n.editProfile),
+            trailing: const Icon(Icons.chevron_right),
+            onTap: () {
+              Navigator.push(
+                context,
+                MaterialPageRoute(
+                  builder: (context) => const EditProfileScreen(),
+                ),
+              );
+            },
+          ),
+          ListTile(
+            leading: const Icon(Icons.lock_outlined),
+            title: Text(l10n.changePassword),
+            trailing: const Icon(Icons.chevron_right),
+            onTap: () {
+              Navigator.push(
+                context,
+                MaterialPageRoute(
+                  builder: (context) => const ChangePasswordScreen(),
+                ),
+              );
+            },
+          ),
+          ListTile(
+            leading: const Icon(Icons.star_outline),
+            title: Text(l10n.subscription),
+            trailing: const Icon(Icons.chevron_right),
+            onTap: () {
+              Navigator.push(
+                context,
+                MaterialPageRoute(
+                  builder: (context) => const SubscriptionScreen(),
+                ),
+              );
+            },
+          ),
+          ListTile(
+            leading: const Icon(Icons.share_outlined),
+            title: Text(l10n.tellAFriend),
+            trailing: const Icon(Icons.chevron_right),
+            onTap: () {
+              final shareMessage = l10n.shareMessage(
+                AppConfig.displayName,
+                AppConfig.website,
+              );
+              final box = context.findRenderObject() as RenderBox?;
+              SharePlus.instance.share(
+                ShareParams(
+                  text: shareMessage,
+                  title: l10n.shareTitle(AppConfig.displayName),
+                  subject: l10n.shareSubject(AppConfig.displayName),
+                  sharePositionOrigin:
+                      box!.localToGlobal(Offset.zero) & box.size,
+                ),
+              );
+            },
+          ),
+          const Divider(),
+          // ],
+
+          // Admin Section (only for admin users)
+          if (isAdmin) ...[
+            SectionHeader(title: 'Admin'),
+            ListTile(
+              leading: Icon(
+                Icons.admin_panel_settings,
+                color: Colors.purple,
+              ),
+              title: const Text('Admin Panel'),
+              trailing: const Icon(Icons.chevron_right),
+              onTap: () {
+                Navigator.push(
+                  context,
+                  MaterialPageRoute(
+                    builder: (context) => const AdminPanelScreen(),
+                  ),
+                );
+              },
+            ),
+            const Divider(),
+          ],
+
+          // Legal Section
+          SectionHeader(title: AppConfig.displayName),
+          ListTile(
+            leading: const Icon(Icons.info_outline),
+            title: Text(l10n.aboutAppName(AppConfig.displayName)),
+            trailing: const Icon(Icons.chevron_right),
+            onTap: () {
+              Navigator.push(
+                context,
+                MaterialPageRoute(builder: (context) => const AboutAppScreen()),
+              );
+            },
+          ),
+          ListTile(
+            leading: const Icon(Icons.privacy_tip_outlined),
+            title: Text(l10n.privacyPolicy),
+            trailing: const Icon(Icons.chevron_right),
+            onTap: () {
+              Navigator.push(
+                context,
+                MaterialPageRoute(
+                  builder: (context) => const PrivacyPolicyScreen(),
+                ),
+              );
+            },
+          ),
+          ListTile(
+            leading: const Icon(Icons.description_outlined),
+            title: Text(l10n.termsAndConditions),
+            trailing: const Icon(Icons.chevron_right),
+            onTap: () {
+              Navigator.push(
+                context,
+                MaterialPageRoute(builder: (context) => const TermsScreen()),
+              );
+            },
+          ),
+          const Divider(),
+
+          // About Section
+          SectionHeader(title: "System"),
+          ListTile(
+            leading: const Icon(Icons.info_outlined),
+            title: Text(l10n.appVersion),
+            subtitle: Text(_appVersion.isEmpty ? l10n.loading : _appVersion),
+          ),
+          ListTile(
+            leading: const Icon(Icons.cleaning_services_outlined),
+            title: Text(l10n.cacheManager),
+            trailing: const Icon(Icons.chevron_right),
+            onTap: () {
+              Navigator.push(
+                context,
+                MaterialPageRoute(
+                  builder: (context) => const CacheManagerScreen(),
+                ),
+              );
+            },
+          ),
+          ListTile(
+            leading: Icon(
+              Icons.delete_forever_outlined,
+              color: theme.colorScheme.error,
+            ),
+            title: Text(
+              l10n.deleteAccount,
+              style: TextStyle(color: theme.colorScheme.error),
+            ),
+            trailing: const Icon(Icons.chevron_right),
+            onTap: () {
+              Navigator.push(
+                context,
+                MaterialPageRoute(
+                  builder: (context) => const DeleteAccountScreen(),
+                ),
+              );
+            },
+          ),
+          const Divider(),
+
+          const SizedBox(height: 24),
+
+          // Sign Out
+          Padding(
+            padding: const EdgeInsets.fromLTRB(16, 8, 16, 24),
+            child: AppButton(
+              label: l10n.signOut,
+              onPressed: () async {
+                await ref.read(authControllerProvider).signOut();
+                if (context.mounted) {
+                  Navigator.of(context).pushAndRemoveUntil(
+                    MaterialPageRoute(
+                      builder: (context) => const AuthHomeScreen(),
+                    ),
+                    (route) => false,
+                  );
+                }
+              },
+              variant: AppButtonVariant.outlined,
+              size: AppButtonSize.large,
+              isFullWidth: true,
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  String _getThemeModeLabel(ThemeMode mode, AppLocalizations l10n) {
+    switch (mode) {
+      case ThemeMode.light:
+        return l10n.light;
+      case ThemeMode.dark:
+        return l10n.dark;
+      case ThemeMode.system:
+        return l10n.systemDefault;
+    }
+  }
+
+  void _showThemeDialog(BuildContext context) {
+    final l10n = AppLocalizations.of(context)!;
+    final currentMode = ref.read(themeModeProvider);
+
+    showModalBottomSheet(
+      context: context,
+      builder: (context) => SafeArea(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            Padding(
+              padding: const EdgeInsets.all(16.0),
+              child: Text(
+                l10n.selectTheme,
+                style: Theme.of(context).textTheme.titleLarge,
+              ),
+            ),
+            RadioGroup<ThemeMode>(
+              groupValue: currentMode,
+              onChanged: (value) {
+                if (value != null) {
+                  ref.read(themeModeProvider.notifier).setThemeMode(value);
+                  Navigator.pop(context);
+                }
+              },
+              child: Column(
+                children: [
+                  RadioListTile<ThemeMode>(
+                    title: Text(l10n.light),
+                    value: ThemeMode.light,
+                  ),
+                  RadioListTile<ThemeMode>(
+                    title: Text(l10n.dark),
+                    value: ThemeMode.dark,
+                  ),
+                  RadioListTile<ThemeMode>(
+                    title: Text(l10n.systemDefault),
+                    value: ThemeMode.system,
+                  ),
+                ],
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}