added ipfs upload feature

ehsan6sha · ehsan6sha · commit 5c4c0c9bdd0e · 2026-04-08T23:23:13.000-04:00
diff --git a/lib/core/services/ipfs_public_service.dart b/lib/core/services/ipfs_public_service.dart
@@ -0,0 +1,89 @@
+import 'dart:convert';
+import 'package:flutter/foundation.dart';
+import 'package:http/http.dart' as http;
+import 'package:fula_files/core/services/secure_storage_service.dart';
+
+class IpfsPublicService {
+  IpfsPublicService._();
+  static final instance = IpfsPublicService._();
+
+  static const String _defaultIpfsEndpoint = 'https://ipfs.cloud.fx.land';
+  static const String _defaultIpfsServer = 'https://api.cloud.fx.land';
+  static const String _defaultIpfsGateway = 'https://ipfs.cloud.fx.land/gateway/';
+
+  /// Upload a file publicly to IPFS and pin it.
+  ///
+  /// 1. POST {ipfsEndpoint}/upload  (multipart file) → returns CID
+  /// 2. POST {ipfsServer}/api/pins  (JSON {cid, name}) → pins for persistence
+  /// 3. Build public gateway URL from CID
+  Future<({String cid, String gatewayUrl})> pinFile(
+    String localPath,
+    String fileName,
+  ) async {
+    final ipfsEndpoint = await SecureStorageService.instance
+            .read(SecureStorageKeys.ipfsEndpointUrl) ??
+        _defaultIpfsEndpoint;
+    final ipfsServer = await SecureStorageService.instance
+            .read(SecureStorageKeys.ipfsServerUrl) ??
+        _defaultIpfsServer;
+    final jwt =
+        await SecureStorageService.instance.read(SecureStorageKeys.jwtToken);
+    final ipfsGateway = await SecureStorageService.instance
+            .read(SecureStorageKeys.ipfsGatewayUrl) ??
+        _defaultIpfsGateway;
+
+    if (jwt == null || jwt.isEmpty) {
+      throw Exception(
+          'No API key configured. Please set your API key in Settings.');
+    }
+
+    // Step 1: Upload file to IPFS endpoint to get CID
+    final uploadUri = Uri.parse('$ipfsEndpoint/upload');
+    debugPrint('IPFS upload → $uploadUri');
+    final request = http.MultipartRequest('POST', uploadUri)
+      ..headers['Authorization'] = 'Bearer $jwt'
+      ..files.add(
+          await http.MultipartFile.fromPath('file', localPath,
+              filename: fileName));
+
+    final streamed = await request.send();
+    final body = await streamed.stream.bytesToString();
+
+    if (streamed.statusCode != 200) {
+      throw Exception(
+          'Upload failed (${streamed.statusCode}): $body');
+    }
+
+    final uploadJson = jsonDecode(body.trim()) as Map<String, dynamic>;
+    final cid = uploadJson['cid'] as String?;
+    if (cid == null || cid.isEmpty) {
+      throw Exception('Upload succeeded but no CID returned');
+    }
+    debugPrint('IPFS upload OK  cid=$cid');
+
+    // Step 2: Pin the CID via pinning service for persistence
+    try {
+      final pinUri = Uri.parse('$ipfsServer/api/pins');
+      debugPrint('IPFS pin → $pinUri');
+      final pinResponse = await http.post(
+        pinUri,
+        headers: {
+          'Authorization': 'Bearer $jwt',
+          'Content-Type': 'application/json',
+        },
+        body: jsonEncode({'cid': cid, 'name': fileName}),
+      );
+      debugPrint('Pin response (${pinResponse.statusCode}): ${pinResponse.body}');
+    } catch (e) {
+      // Pin failure is non-fatal — the file is already on IPFS
+      debugPrint('Pin request failed (non-fatal): $e');
+    }
+
+    // Step 3: Build gateway URL
+    final base = ipfsGateway.endsWith('/') ? ipfsGateway : '$ipfsGateway/';
+    final gatewayUrl = '$base$cid';
+
+    debugPrint('IPFS public share OK  url=$gatewayUrl');
+    return (cid: cid, gatewayUrl: gatewayUrl);
+  }
+}
diff --git a/lib/core/services/secure_storage_service.dart b/lib/core/services/secure_storage_service.dart
@@ -84,6 +84,9 @@ class SecureStorageKeys {
   static const String aiEndpointUrl = 'ai_endpoint_url';
   static const String ipfsGatewayUrl = 'ipfs_gateway_url';
 
+  // IPFS upload endpoint (ipfs-server with /upload and /gateway)
+  static const String ipfsEndpointUrl = 'ipfs_endpoint_url';
+
   // NFT wallet keys
   static const String nftWalletPrivateKey = 'nft_wallet_private_key';
 
diff --git a/lib/features/browser/screens/file_browser_screen.dart b/lib/features/browser/screens/file_browser_screen.dart
@@ -41,6 +41,8 @@ import 'package:fula_files/features/tags/widgets/tag_selector_dialog.dart';
 import 'package:fula_files/features/tags/widgets/tag_chip.dart';
 import 'package:open_filex/open_filex.dart';
 import 'package:share_plus/share_plus.dart';
+import 'package:url_launcher/url_launcher.dart';
+import 'package:fula_files/core/services/ipfs_public_service.dart';
 import 'package:fula_files/shared/utils/error_messages.dart';
 import 'package:fula_files/features/sharing/providers/collaboration_provider.dart';
 import 'package:fula_files/core/models/collaboration_group.dart';
@@ -2105,6 +2107,17 @@ class _FileBrowserScreenState extends ConsumerState<FileBrowserScreen> {
                   ],
                 );
               }),
+              // Share Publicly via IPFS (files only, no cloud sync required)
+              if (!file.isDirectory)
+                ListTile(
+                  leading: const Icon(LucideIcons.globe, color: Colors.teal),
+                  title: const Text('Share Publicly'),
+                  subtitle: const Text('Pin to IPFS (unencrypted)'),
+                  onTap: () {
+                    Navigator.pop(ctx);
+                    _sharePubliclyViaIpfs(file);
+                  },
+                ),
               const Divider(height: 1),
               // Archive actions - only for archive files
               if (!file.isDirectory && ArchiveService.instance.isArchive(file.path))
@@ -2647,6 +2660,146 @@ class _FileBrowserScreenState extends ConsumerState<FileBrowserScreen> {
   // ============================================================================
 
   /// Show info message when share is disabled
+  Future<void> _sharePubliclyViaIpfs(LocalFile file) async {
+    final confirmed = await showDialog<bool>(
+      context: context,
+      builder: (ctx) => AlertDialog(
+        title: const Text('Share Publicly?'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            const Text(
+              'This will upload the file to IPFS without any encryption. '
+              'Anyone with the link will be able to access it.',
+            ),
+            const SizedBox(height: 16),
+            Text('File: ${file.name}', style: const TextStyle(fontWeight: FontWeight.bold)),
+            Text('Size: ${file.sizeFormatted}'),
+          ],
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(ctx, false),
+            child: const Text('Cancel'),
+          ),
+          FilledButton(
+            style: FilledButton.styleFrom(backgroundColor: Colors.teal),
+            onPressed: () => Navigator.pop(ctx, true),
+            child: const Text('Share Publicly'),
+          ),
+        ],
+      ),
+    );
+
+    if (confirmed != true || !mounted) return;
+
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(
+        content: Row(
+          children: [
+            const SizedBox(
+              width: 20, height: 20,
+              child: CircularProgressIndicator(strokeWidth: 2, color: Colors.white),
+            ),
+            const SizedBox(width: 16),
+            Expanded(child: Text('Uploading ${file.name} to IPFS...')),
+          ],
+        ),
+        duration: const Duration(seconds: 60),
+      ),
+    );
+
+    try {
+      final result = await IpfsPublicService.instance.pinFile(file.path, file.name);
+
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).clearSnackBars();
+      _showPublicIpfsLinkDialog(result.gatewayUrl, file.name);
+    } catch (e, st) {
+      debugPrint('Share publicly failed: $e\n$st');
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).clearSnackBars();
+      // Show the actual exception message — our service throws clear messages
+      final msg = e is Exception
+          ? e.toString().replaceFirst('Exception: ', '')
+          : ErrorMessages.forPublicShare(e);
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(
+          content: Text(msg),
+          backgroundColor: Colors.red,
+          duration: const Duration(seconds: 8),
+          showCloseIcon: true,
+          closeIconColor: Colors.white,
+        ),
+      );
+    }
+  }
+
+  void _showPublicIpfsLinkDialog(String gatewayUrl, String fileName) {
+    showDialog(
+      context: context,
+      builder: (ctx) => AlertDialog(
+        title: Row(
+          children: const [
+            Icon(LucideIcons.checkCircle, color: Colors.green, size: 24),
+            SizedBox(width: 8),
+            Text('Shared Publicly'),
+          ],
+        ),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Text('$fileName is now publicly accessible via IPFS.'),
+            const SizedBox(height: 8),
+            const Text(
+              'Anyone with this link can access the file:',
+              style: TextStyle(fontSize: 12, color: Colors.grey),
+            ),
+            const SizedBox(height: 12),
+            Container(
+              width: double.infinity,
+              padding: const EdgeInsets.all(12),
+              decoration: BoxDecoration(
+                color: Theme.of(ctx).colorScheme.surfaceContainerHighest,
+                borderRadius: BorderRadius.circular(8),
+              ),
+              child: SelectableText(
+                gatewayUrl,
+                style: const TextStyle(fontFamily: 'monospace', fontSize: 11),
+              ),
+            ),
+          ],
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(ctx),
+            child: const Text('Close'),
+          ),
+          OutlinedButton.icon(
+            icon: const Icon(LucideIcons.externalLink, size: 16),
+            label: const Text('Open'),
+            onPressed: () {
+              launchUrl(Uri.parse(gatewayUrl), mode: LaunchMode.externalApplication);
+            },
+          ),
+          FilledButton.icon(
+            icon: const Icon(LucideIcons.copy, size: 16),
+            label: const Text('Copy URL'),
+            onPressed: () {
+              Clipboard.setData(ClipboardData(text: gatewayUrl));
+              Navigator.pop(ctx);
+              ScaffoldMessenger.of(context).showSnackBar(
+                const SnackBar(content: Text('IPFS URL copied to clipboard')),
+              );
+            },
+          ),
+        ],
+      ),
+    );
+  }
+
   void _showShareDisabledInfo(bool isLoggedIn) {
     if (!mounted) return;
 
diff --git a/lib/features/settings/screens/settings_screen.dart b/lib/features/settings/screens/settings_screen.dart
@@ -40,6 +40,7 @@ class _SettingsScreenState extends ConsumerState<SettingsScreen> {
   final _billingServerController = TextEditingController();
   final _aiEndpointController = TextEditingController();
   final _ipfsGatewayController = TextEditingController();
+  final _ipfsEndpointController = TextEditingController();
   final _jwtTokenController = TextEditingController();
 
   bool _isEditingApi = false;
@@ -65,13 +66,15 @@ class _SettingsScreenState extends ConsumerState<SettingsScreen> {
   static const String _defaultBillingServer = 'https://cloud.fx.land';
   static const String _defaultAiEndpoint = 'https://ai.cloud.fx.land';
   static const String _defaultIpfsGateway = 'https://ipfs.cloud.fx.land/gateway/';
+  static const String _defaultIpfsEndpoint = 'https://ipfs.cloud.fx.land';
 
   Future<void> _loadSettings() async {
     final apiGateway = await SecureStorageService.instance.read(SecureStorageKeys.apiGatewayUrl);
     final ipfsServer = await SecureStorageService.instance.read(SecureStorageKeys.ipfsServerUrl);
     final billingServer = await SecureStorageService.instance.read(SecureStorageKeys.billingServerUrl);
     final aiEndpoint = await SecureStorageService.instance.read(SecureStorageKeys.aiEndpointUrl);
     final ipfsGateway = await SecureStorageService.instance.read(SecureStorageKeys.ipfsGatewayUrl);
+    final ipfsEndpoint = await SecureStorageService.instance.read(SecureStorageKeys.ipfsEndpointUrl);
     final jwtToken = await SecureStorageService.instance.read(SecureStorageKeys.jwtToken);
 
     setState(() {
@@ -80,6 +83,7 @@ class _SettingsScreenState extends ConsumerState<SettingsScreen> {
       _billingServerController.text = billingServer ?? _defaultBillingServer;
       _aiEndpointController.text = aiEndpoint ?? _defaultAiEndpoint;
       _ipfsGatewayController.text = ipfsGateway ?? _defaultIpfsGateway;
+      _ipfsEndpointController.text = ipfsEndpoint ?? _defaultIpfsEndpoint;
       _jwtTokenController.text = jwtToken ?? '';
     });
   }
@@ -92,6 +96,7 @@ class _SettingsScreenState extends ConsumerState<SettingsScreen> {
     _billingServerController.dispose();
     _aiEndpointController.dispose();
     _ipfsGatewayController.dispose();
+    _ipfsEndpointController.dispose();
     _jwtTokenController.dispose();
     super.dispose();
   }
@@ -222,6 +227,15 @@ class _SettingsScreenState extends ConsumerState<SettingsScreen> {
                         : _ipfsGatewayController.text,
                   ),
                 ),
+                ListTile(
+                  leading: const Icon(LucideIcons.hardDrive),
+                  title: const Text('IPFS Endpoint'),
+                  subtitle: Text(
+                    _ipfsEndpointController.text.isEmpty
+                        ? 'Not configured'
+                        : _ipfsEndpointController.text,
+                  ),
+                ),
                 ListTile(
                   leading: const Icon(LucideIcons.key),
                   title: const Text('API Key'),
@@ -282,6 +296,15 @@ class _SettingsScreenState extends ConsumerState<SettingsScreen> {
                         ),
                       ),
                       const SizedBox(height: 12),
+                      TextField(
+                        controller: _ipfsEndpointController,
+                        decoration: const InputDecoration(
+                          labelText: 'IPFS Endpoint URL',
+                          hintText: 'https://ipfs.cloud.fx.land',
+                          prefixIcon: Icon(LucideIcons.hardDrive),
+                        ),
+                      ),
+                      const SizedBox(height: 12),
                       TextField(
                         controller: _jwtTokenController,
                         decoration: InputDecoration(
@@ -713,6 +736,10 @@ class _SettingsScreenState extends ConsumerState<SettingsScreen> {
         SecureStorageKeys.ipfsGatewayUrl,
         _ipfsGatewayController.text,
       );
+      await SecureStorageService.instance.write(
+        SecureStorageKeys.ipfsEndpointUrl,
+        _ipfsEndpointController.text,
+      );
       await SecureStorageService.instance.write(
         SecureStorageKeys.jwtToken,
         _jwtTokenController.text,
diff --git a/lib/shared/utils/error_messages.dart b/lib/shared/utils/error_messages.dart
@@ -362,6 +362,11 @@ class ErrorMessages {
     return getUserFriendlyMessage(error, context: 'share');
   }
 
+  /// Get error message for public IPFS share operations
+  static String forPublicShare(dynamic error) {
+    return getUserFriendlyMessage(error, context: 'share publicly');
+  }
+
   /// Get error message for delete operations
   static String forDelete(dynamic error) {
     return getUserFriendlyMessage(error, context: 'delete');
