Implement note & directory move functionality (#94)

core/src/db/directory.rs

@@ -98,8 +98,9 @@ impl Db {
     ) -> Result<()> {
         table("Directory")
             .update()
-            .filter(col("directory_id").eq(uuid(directory_id)))
-            .set("parent_id", parent_id)
+            .filter(col("id").eq(uuid(directory_id)))
+            .set("parent_id", uuid(parent_id))
+            .set("updated_at", now())
             .execute(&mut self.storage)
             .await?;
 

core/src/db/note.rs

@@ -101,14 +101,15 @@ impl Db {
         self.sync()
     }
 
-    pub async fn move_note(&mut self, note_id: NoteId, directory_id: DirectoryId) {
+    pub async fn move_note(&mut self, note_id: NoteId, directory_id: DirectoryId) -> Result<()> {
         table("Note")
             .update()
             .filter(col("id").eq(uuid(note_id)))
-            .set("directory_id", directory_id)
+            .set("directory_id", uuid(directory_id))
             .set("updated_at", now())
             .execute(&mut self.storage)
-            .await
-            .unwrap();
+            .await?;
+
+        self.sync()
     }
 }

core/src/event.rs

@@ -60,6 +60,9 @@ pub enum NotebookEvent {
     AddNote(String),
     AddDirectory(String),
 
+    MoveNote(DirectoryId),
+    MoveDirectory(DirectoryId),
+
     OpenNote,
     EditNote,
     ViewNote,
@@ -111,6 +114,7 @@ pub enum KeyEvent {
     Right,
     Up,
     Down,
+    Space,
     Enter,
     Tab,
     Tilde,

core/src/state/notebook.rs

@@ -6,7 +6,7 @@ use {
     crate::{
         data::{Directory, Note},
         state::GetInner,
-        types::DirectoryId,
+        types::{DirectoryId, Id},
         Error, Event, Glues, NotebookTransition, Result,
     },
     consume::{directory, note, tabs},
@@ -95,6 +95,15 @@ impl NotebookState {
             NoteTreeNumber(n) => {
                 format!("Steps: '{n}' selected")
             }
+            MoveMode => match &self.selected {
+                SelectedItem::Note(Note { name, .. }) => {
+                    format!("Note move mode: '{name}'")
+                }
+                SelectedItem::Directory(Directory { name, .. }) => {
+                    format!("Directory move mode: '{name}'")
+                }
+                _ => "Move mode".to_owned(),
+            },
             EditingNormalMode(VimNormalState::Idle) => {
                 let name = &self.get_selected_note()?.name;
 
@@ -242,10 +251,11 @@ impl NotebookState {
         match &self.inner_state {
             NoteSelected => {
                 let mut shortcuts = vec![
-                    "[l] Open note".to_owned(),
+                    "[l] Open".to_owned(),
                     "[h] Close parent".to_owned(),
                     "[j|k] Down | Up".to_owned(),
-                    "[1-9] Set steps".to_owned(),
+                    "[1-9] Steps".to_owned(),
+                    "[Space] Move".to_owned(),
                     "[m] More actions".to_owned(),
                 ];
 
@@ -261,9 +271,9 @@ impl NotebookState {
                     "[l] Toggle".to_owned(),
                     "[h] Close parent".to_owned(),
                     "[j|k] Down | Up".to_owned(),
-                    "[1-9] Set steps".to_owned(),
+                    "[1-9] Steps".to_owned(),
+                    "[Space] Move".to_owned(),
                     "[m] More actions".to_owned(),
-                    "[Esc] Quit".to_owned(),
                 ];
 
                 if !self.tabs.is_empty() {
@@ -281,6 +291,14 @@ impl NotebookState {
                     "[Esc] Cancel".to_owned(),
                 ]
             }
+            MoveMode => {
+                vec![
+                    "[j] Down".to_owned(),
+                    "[k] Up".to_owned(),
+                    "[Enter] Move".to_owned(),
+                    "[Esc] Cancel".to_owned(),
+                ]
+            }
             EditingNormalMode(VimNormalState::Idle) => {
                 /*
                     h j k l w e b [1-9] o O 0 $
@@ -464,6 +482,14 @@ impl NotebookState {
         }
     }
 
+    pub fn get_selected_id(&self) -> Result<&Id> {
+        match &self.selected {
+            SelectedItem::Note(ref note) => Ok(&note.id),
+            SelectedItem::Directory(ref directory) => Ok(&directory.id),
+            _ => Err(Error::Wip("selected item not found".to_owned())),
+        }
+    }
+
     pub fn get_editing(&self) -> Result<&Note> {
         let i = self
             .tab_index

core/src/state/notebook/inner_state.rs

@@ -3,6 +3,7 @@ mod directory_selected;
 mod editing_insert_mode;
 mod editing_normal_mode;
 mod editing_visual_mode;
+mod move_mode;
 mod note_more_actions;
 mod note_selected;
 mod note_tree_number;
@@ -22,6 +23,7 @@ pub enum InnerState {
     DirectorySelected,
     DirectoryMoreActions,
     NoteTreeNumber(usize),
+    MoveMode,
     EditingNormalMode(VimNormalState),
     EditingVisualMode(VimVisualState),
     EditingInsertMode,
@@ -44,6 +46,7 @@ pub async fn consume(
         NoteMoreActions => note_more_actions::consume(db, state, event).await,
         DirectoryMoreActions => directory_more_actions::consume(db, state, event).await,
         NoteTreeNumber(n) => note_tree_number::consume(db, state, *n, event).await,
+        MoveMode => move_mode::consume(db, state, event).await,
         EditingNormalMode(vim_state) => {
             editing_normal_mode::consume(db, state, *vim_state, event).await
         }

core/src/state/notebook/inner_state/directory_selected.rs

@@ -1,6 +1,7 @@
 use crate::{
     db::Db,
     state::notebook::{directory, note, tabs, InnerState, NotebookState},
+    transition::MoveModeTransition,
     Error, Event, KeyEvent, NotebookEvent, NotebookTransition, Result,
 };
 
@@ -58,6 +59,11 @@ pub async fn consume(
 
             directory::show_actions_dialog(state, directory)
         }
+        Key(KeyEvent::Space) => {
+            state.inner_state = InnerState::MoveMode;
+
+            Ok(NotebookTransition::MoveMode(MoveModeTransition::Enter))
+        }
         Notebook(SelectNote(note)) => note::select(state, note),
         Notebook(SelectDirectory(directory)) => directory::select(state, directory),
         Key(KeyEvent::Num(n)) => {

core/src/state/notebook/inner_state/move_mode.rs

@@ -0,0 +1,68 @@
+use crate::{
+    db::Db,
+    state::notebook::{directory, InnerState, NotebookState, SelectedItem},
+    transition::MoveModeTransition,
+    Error, Event, KeyEvent, NotebookEvent, NotebookTransition, Result,
+};
+
+pub async fn consume(
+    db: &mut Db,
+    state: &mut NotebookState,
+    event: Event,
+) -> Result<NotebookTransition> {
+    use Event::*;
+
+    match event {
+        Key(KeyEvent::J | KeyEvent::Down) => MoveModeTransition::SelectNext.into(),
+        Key(KeyEvent::K | KeyEvent::Up) => MoveModeTransition::SelectPrev.into(),
+        Key(KeyEvent::Esc) => {
+            match state.selected {
+                SelectedItem::Directory(_) => {
+                    state.inner_state = InnerState::DirectorySelected;
+                }
+                SelectedItem::Note(_) => {
+                    state.inner_state = InnerState::NoteSelected;
+                }
+                SelectedItem::None => {}
+            };
+
+            MoveModeTransition::Cancel.into()
+        }
+        Key(KeyEvent::Enter) => MoveModeTransition::RequestCommit.into(),
+        Notebook(NotebookEvent::MoveNote(directory_id)) => {
+            let note = state.get_selected_note()?.clone();
+
+            db.move_note(note.id.clone(), directory_id.clone()).await?;
+            directory::close(state, state.root.directory.clone())?;
+            directory::open_all(db, state, directory_id).await?;
+
+            state.selected = SelectedItem::Note(note);
+            state.inner_state = InnerState::NoteSelected;
+            MoveModeTransition::Commit.into()
+        }
+        Notebook(NotebookEvent::MoveDirectory(target_directory_id)) => {
+            let directory = state.get_selected_directory()?.clone();
+            if directory.id == target_directory_id {
+                state.inner_state = InnerState::DirectorySelected;
+                return MoveModeTransition::Cancel.into();
+            }
+
+            db.move_directory(directory.id.clone(), target_directory_id.clone())
+                .await?;
+            directory::close(state, state.root.directory.clone())?;
+            directory::open_all(db, state, target_directory_id).await?;
+
+            state.selected = SelectedItem::Directory(directory);
+            state.inner_state = InnerState::DirectorySelected;
+            MoveModeTransition::Commit.into()
+        }
+        event @ Key(_) => Ok(NotebookTransition::Inedible(event)),
+        _ => Err(Error::Wip("todo: Notebook::consume".to_owned())),
+    }
+}
+
+impl From<MoveModeTransition> for Result<NotebookTransition> {
+    fn from(transition: MoveModeTransition) -> Self {
+        Ok(NotebookTransition::MoveMode(transition))
+    }
+}

core/src/state/notebook/inner_state/note_selected.rs

@@ -1,6 +1,7 @@
 use crate::{
     db::Db,
     state::notebook::{directory, note, tabs, InnerState, NotebookState},
+    transition::MoveModeTransition,
     Error, Event, KeyEvent, NotebookEvent, NotebookTransition, Result,
 };
 
@@ -42,6 +43,11 @@ pub async fn consume(
 
             note::show_actions_dialog(state, note)
         }
+        Key(KeyEvent::Space) => {
+            state.inner_state = InnerState::MoveMode;
+
+            Ok(NotebookTransition::MoveMode(MoveModeTransition::Enter))
+        }
         Notebook(SelectNote(note)) => note::select(state, note),
         Notebook(SelectDirectory(directory)) => directory::select(state, directory),
         Key(KeyEvent::L | KeyEvent::Enter) | Notebook(OpenNote) => {

core/src/transition.rs

@@ -57,6 +57,8 @@ pub enum NotebookTransition {
     ShowNoteActionsDialog(Note),
     ShowDirectoryActionsDialog(Directory),
 
+    MoveMode(MoveModeTransition),
+
     OpenNote {
         note: Note,
         content: String,
@@ -81,6 +83,15 @@ pub enum NotebookTransition {
     ShowVimKeymap(VimKeymapKind),
 }
 
+pub enum MoveModeTransition {
+    Enter,
+    SelectNext,
+    SelectPrev,
+    RequestCommit,
+    Commit,
+    Cancel,
+}
+
 #[derive(Clone, Copy, Display)]
 pub enum VimKeymapKind {
     NormalIdle,

tui/src/action.rs

@@ -432,6 +432,7 @@ fn to_event(input: Input) -> Option<KeyEvent> {
         KeyCode::Char('~') => KeyEvent::Tilde,
         KeyCode::Char('.') => KeyEvent::Dot,
         KeyCode::Char('-') => KeyEvent::Dash,
+        KeyCode::Char(' ') => KeyEvent::Space,
         KeyCode::Left => KeyEvent::Left,
         KeyCode::Right => KeyEvent::Right,
         KeyCode::Up => KeyEvent::Up,