Merge pull request #9 from owlistic-notes/import-export

Import from markdown

Author: DavideRutigliano

src/frontend/lib/providers/note_editor_provider.dart

@@ -1,6 +1,7 @@
 import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:super_editor/super_editor.dart' hide Logger;
+import 'package:super_editor_markdown/super_editor_markdown.dart';
 
 import 'package:owlistic/services/block_service.dart';
 import 'package:owlistic/services/auth_service.dart';
@@ -1526,17 +1527,6 @@ class NoteEditorProvider with ChangeNotifier implements NoteEditorViewModel {
     }
   }
 
-  @override
-  void updateBlockCache(List<Block> blocks) {
-    for (final block in blocks) {
-      // Only update if this block belongs to an active note
-      if (_noteId == block.noteId || _activeNoteIds.contains(block.noteId)) {
-        _blocks[block.id] = block;
-        _documentBuilder.registerServerBlock(block);
-      }
-    }
-  }
-
   @override
   void commitAllContent() {
     _logger.debug('Committing content for all blocks');
@@ -1676,4 +1666,91 @@ class NoteEditorProvider with ChangeNotifier implements NoteEditorViewModel {
       _logger.debug('Block type changed from ${block.type} to $detectedType');
     }
   }
+  
+  @override
+  Future<void> importMarkdownContent(String markdown) async {
+    if (_noteId == null) {
+      throw Exception('Cannot import content: no active note');
+    }
+    
+    _isLoading = true;
+    notifyListeners();
+    
+    try {
+      _logger.info('Importing markdown content to note: $_noteId');
+      
+      // Delete all existing blocks for this note
+      final existingBlocks = getBlocksForNote(_noteId!);
+      for (final block in existingBlocks) {
+        await _blockService.deleteBlock(block.id);
+      }
+      
+      // Create blocks for each node
+      final document = _documentBuilder.deserializeMarkdownContent(markdown);
+
+      // Create blocks for each node
+      int order = 0;
+      for (final node in document) {
+        try {
+          final blockContent = _documentBuilder.buildBlockContent(node);
+          
+          final blockType = blockContent['type'];
+          final payload = {
+            "metadata": blockContent['metadata'],
+            "content": blockContent['content'],
+          };
+
+          // Create block through BlockService
+          await _blockService.createBlock(
+            _noteId!,
+            payload,
+            blockType,
+            (order + 1) * 1000.0  // Use increasing order with gaps
+          );
+          
+          order++;
+        } catch (e) {
+          _logger.error('Error creating block for imported markdown: $e');
+        }
+      }
+      
+      // Refresh blocks from server
+      await fetchBlocksForNote(_noteId!, refresh: true);
+      
+      _logger.info('Markdown content imported successfully');
+    } catch (e) {
+      _logger.error('Error importing markdown content', e);
+      _errorMessage = 'Failed to import markdown: ${e.toString()}';
+    } finally {
+      _isLoading = false;
+      _updateCount++;
+      notifyListeners();
+    }
+  }
+  
+  @override
+  Future<String> exportToMarkdown() async {
+    try {
+      if (_noteId == null) {
+        throw Exception('Cannot export: no active note');
+      }
+      
+      _logger.info('Exporting note $_noteId to markdown');
+      
+      // Make sure all content is committed
+      commitAllContent();
+      
+      // Serialize the document to markdown
+      final markdown = serializeDocumentToMarkdown(
+        _documentBuilder.document,
+        syntax: MarkdownSyntax.normal
+      );
+      
+      _logger.debug('Note exported to markdown successfully');
+      return markdown;
+    } catch (e) {
+      _logger.error('Error exporting to markdown', e);
+      throw Exception('Failed to export note: ${e.toString()}');
+    }
+  }
 }

src/frontend/lib/providers/notes_provider.dart

@@ -1,5 +1,6 @@
 import 'dart:async';
 import 'package:flutter/material.dart';
+import 'package:owlistic/utils/document_builder.dart';
 import 'package:owlistic/viewmodel/notes_viewmodel.dart';
 import 'package:owlistic/models/note.dart';
 import 'package:owlistic/services/note_service.dart';
@@ -10,6 +11,7 @@ import 'package:owlistic/utils/websocket_message_parser.dart';
 import 'package:owlistic/utils/logger.dart';
 import 'package:owlistic/services/block_service.dart';
 import 'package:owlistic/services/app_state_service.dart';
+import 'package:super_editor_markdown/super_editor_markdown.dart';
 
 class NotesProvider with ChangeNotifier implements NotesViewModel {
   final Logger _logger = Logger('NotesProvider');
@@ -526,4 +528,104 @@ class NotesProvider with ChangeNotifier implements NotesViewModel {
       notifyListeners();
     }
   }
+
+  @override
+  Future<Note?> importMarkdownFile(String content, String fileName, String notebookId) async {
+    try {
+      _logger.info('Importing markdown file: $fileName to notebook: $notebookId');
+      
+      if (notebookId.isEmpty) {
+        throw Exception("Notebook ID is required to import a note");
+      }
+      
+      // Extract title from filename (remove .md extension if present)
+      String title = fileName;
+      if (title.toLowerCase().endsWith('.md')) {
+        title = title.substring(0, title.length - 3);
+      }
+      
+      // Create the note first
+      final note = await _noteService.createNote(notebookId, title);
+      _logger.debug('Created note: ${note.id} for markdown import');
+      
+      final documentBuilder = DocumentBuilder();
+
+      // Create blocks for each node
+      final document = documentBuilder.deserializeMarkdownContent(content);
+
+      // Create blocks for each node
+      int order = 0;
+      for (final node in document) {
+        try {
+          final blockContent = documentBuilder.buildBlockContent(node);
+          
+          final blockType = blockContent['type'];
+          final payload = {
+            "metadata": blockContent['metadata'],
+            "content": blockContent['content'],
+          };
+
+          // Create block through BlockService
+          await _blockService.createBlock(
+            note.id,
+            payload,
+            blockType,
+            (order + 1) * 1000.0  // Use increasing order with gaps
+          );
+          
+          order++;
+        } catch (e) {
+          _logger.error('Error creating block for imported markdown: $e');
+        }
+      }
+      
+      // Add note to local state
+      _notesMap[note.id] = note;
+      _updateCount++;
+      notifyListeners();
+      
+      return note;
+    } catch (error) {
+      _logger.error('Error importing markdown file', error);
+      _errorMessage = 'Failed to import markdown: ${error.toString()}';
+      notifyListeners();
+      return null;
+    }
+  }
+  
+  @override
+  Future<String> exportNoteToMarkdown(String noteId) async {
+    try {
+      _logger.info('Exporting note $noteId to markdown');
+      
+      // Fetch note if not already in memory
+      Note? note = _notesMap[noteId];
+      note = await fetchNoteById(noteId);
+
+      if (note == null) {
+        throw Exception("Note not found");
+      }
+      
+      // Fetch all blocks for the note to ensure we have the latest data
+      final blocks = await _blockService.fetchBlocksForNote(noteId);
+      
+      // Create a document from the blocks
+      final documentBuilder = DocumentBuilder();
+      
+      // Convert blocks to document nodes
+      documentBuilder.populateDocumentFromBlocks(blocks);
+      
+      // Serialize document to markdown
+      final markdown = serializeDocumentToMarkdown(
+        documentBuilder.document,
+        syntax: MarkdownSyntax.normal
+      );
+      
+      _logger.debug('Note exported to markdown successfully');
+      return markdown;
+    } catch (error) {
+      _logger.error('Error exporting note to markdown', error);
+      throw Exception('Failed to export note: ${error.toString()}');
+    }
+  }
 }