FEAT: Move note now works.

This commit is contained in:
Elf M. Sternberg 2020-10-12 20:43:49 -07:00
parent 380d3f4a7c
commit 1c0f3abd6c
3 changed files with 491 additions and 308 deletions

View File

@ -38,25 +38,70 @@ mod tests {
#[tokio::test(threaded_scheduler)] #[tokio::test(threaded_scheduler)]
async fn fetching_unfound_page_by_title_works() { async fn fetching_unfound_page_by_title_works() {
let title = "Nonexistent Page"; let title = "Nonexistent Page";
let _now = chrono::Utc::now(); let now = chrono::Utc::now();
let storagepool = fresh_inmemory_database().await; let storagepool = fresh_inmemory_database().await;
let newpageresult = storagepool.get_page_by_title(&title).await; let newpageresult = storagepool.get_page_by_title(&title).await;
assert!(newpageresult.is_ok(), "{:?}", newpageresult); assert!(newpageresult.is_ok(), "{:?}", newpageresult);
let (newpage, _newnotes) = newpageresult.unwrap(); let (newpage, newnotes) = newpageresult.unwrap();
assert_eq!(newpage.title, title, "{:?}", newpage.title); assert_eq!(newpage.title, title, "{:?}", newpage.title);
assert_eq!(newpage.slug, "nonexistent-page"); assert_eq!(newpage.slug, "nonexistent-page");
assert_eq!(newnotes.len(), 1);
assert_eq!(newnotes[0].notetype, "root");
assert_eq!(newpage.note_id, newnotes[0].id);
assert!((newpage.creation_date - now).num_minutes() < 1);
assert!((newpage.updated_date - now).num_minutes() < 1);
assert!((newpage.lastview_date - now).num_minutes() < 1);
assert!(newpage.deleted_date.is_none());
} }
// // TODO: This should be 1, not 0 fn make_new_note(content: &str) -> row_structs::NewNote {
// assert_eq!(newnotes.len(), 0); row_structs::NewNoteBuilder::default()
// // assert_eq!(newnotes[0].notetype, "root"); .content(content.to_string())
// // assert_eq!(newpage.note_id, newnotes[0].id); .build()
// .unwrap()
// assert!((newpage.creation_date - now).num_minutes() < 1.0); }
// assert!((newpage.updated_date - now).num_minutes() < 1.0);
// assert!((newpage.lastview_date - now).num_minutes() < 1.0); #[tokio::test(threaded_scheduler)]
// assert!(newpage.deleted_date.is_none()); async fn can_nest_notes() {
// } let title = "Nonexistent Page";
let storagepool = fresh_inmemory_database().await;
let newpageresult = storagepool.get_page_by_title(&title).await;
let (_newpage, newnotes) = newpageresult.unwrap();
let root = &newnotes[0];
let note1 = make_new_note("1");
let note1_uuid = storagepool.insert_nested_note(&note1, &root.uuid, 0).await;
assert!(note1_uuid.is_ok(), "{:?}", note1_uuid);
let note1_uuid = note1_uuid.unwrap();
let note2 = make_new_note("2");
let note2_uuid = storagepool.insert_nested_note(&note2, &root.uuid, 0).await;
assert!(note2_uuid.is_ok(), "{:?}", note2_uuid);
let note2_uuid = note2_uuid.unwrap();
let note3 = make_new_note("3");
let note3_uuid = storagepool.insert_nested_note(&note3, &note1_uuid, 0).await;
assert!(note3_uuid.is_ok(), "{:?}", note3_uuid);
let note3_uuid = note3_uuid.unwrap();
let note4 = make_new_note("4");
let note4_uuid = storagepool.insert_nested_note(&note4, &note2_uuid, 0).await;
assert!(note4_uuid.is_ok(), "{:?}", note4_uuid);
let note4_uuid = note4_uuid.unwrap();
let newpageresult = storagepool.get_page_by_title(&title).await;
let (newpage, newnotes) = newpageresult.unwrap();
assert_eq!(newpage.title, title, "{:?}", newpage.title);
assert_eq!(newpage.slug, "nonexistent-page");
assert_eq!(newnotes.len(), 5);
assert_eq!(newnotes[0].notetype, "root");
assert_eq!(newpage.note_id, newnotes[0].id);
}
} }

View File

@ -47,6 +47,7 @@ pub struct NewPage {
#[derive(Clone, Serialize, Deserialize, Debug, Builder)] #[derive(Clone, Serialize, Deserialize, Debug, Builder)]
pub struct NewNote { pub struct NewNote {
#[builder(default = r#""".to_string()"#)]
pub uuid: String, pub uuid: String,
pub content: String, pub content: String,
#[builder(default = r#""note".to_string()"#)] #[builder(default = r#""note".to_string()"#)]
@ -76,6 +77,14 @@ pub(crate) struct JustId {
pub id: i64, pub id: i64,
} }
#[derive(Clone, Serialize, Deserialize, Debug, FromRow)]
pub(crate) struct NoteRelationship {
pub parent_id: i64,
pub note_id: i64,
pub position: i64,
pub nature: String,
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;

View File

@ -1,15 +1,17 @@
use crate::errors::NoteStoreError; use crate::errors::NoteStoreError;
use crate::row_structs::{ use crate::row_structs::{
JustId, JustSlugs, NewNote, NewNoteBuilder, NewPage, NewPageBuilder, RawNote, RawPage, JustId, JustSlugs, NewNote, NewNoteBuilder, NewPage,
NewPageBuilder, NoteRelationship, RawNote, RawPage,
}; };
use friendly_id; use friendly_id;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use std::collections::HashMap;
use regex::Regex; use regex::Regex;
use slug::slugify; use slug::slugify;
use sqlx; use sqlx;
use sqlx::{ use sqlx::{
sqlite::{Sqlite, SqlitePool}, sqlite::{Sqlite, SqlitePool, SqliteRow},
Executor, Done, Executor, Row
}; };
use std::sync::Arc; use std::sync::Arc;
@ -30,9 +32,7 @@ impl NoteStore {
// to its original empty form. Do not use unless you // to its original empty form. Do not use unless you
// really, really want that to happen. // really, really want that to happen.
pub async fn reset_database(&self) -> NoteResult<()> { pub async fn reset_database(&self) -> NoteResult<()> {
reset_database(&*self.0) reset_database(&*self.0).await.map_err(NoteStoreError::DBError)
.await
.map_err(NoteStoreError::DBError)
} }
/// Fetch page by slug /// Fetch page by slug
@ -46,12 +46,10 @@ impl NoteStore {
// let select_note_collection_for_root = include_str!("sql/select_note_collection_for_root.sql"); // let select_note_collection_for_root = include_str!("sql/select_note_collection_for_root.sql");
let mut tx = self.0.begin().await?; let mut tx = self.0.begin().await?;
let page = select_page_by_slug(&mut tx, slug).await?; let page = select_page_by_slug(&mut tx, slug).await?;
// let notes = sqlx::query_as(select_note_collection_for_root) let note_id = page.note_id;
// .bind(page.note_id) let notes = select_note_collection_from_root(&mut tx, note_id).await?;
// .fetch(&tx)
// .await?;
tx.commit().await?; tx.commit().await?;
Ok((page, vec![])) Ok((page, notes))
} }
/// Fetch page by title /// Fetch page by title
@ -65,10 +63,7 @@ impl NoteStore {
let (page, notes) = match select_page_by_title(&mut tx, title).await { let (page, notes) = match select_page_by_title(&mut tx, title).await {
Ok(page) => { Ok(page) => {
let note_id = page.note_id; let note_id = page.note_id;
( (page, select_note_collection_from_root(&mut tx, note_id).await?)
page,
select_note_collection_from_root(&mut tx, note_id).await?,
)
} }
Err(sqlx::Error::RowNotFound) => { Err(sqlx::Error::RowNotFound) => {
let page = { let page = {
@ -80,10 +75,7 @@ impl NoteStore {
select_page_by_title(&mut tx, &title).await? select_page_by_title(&mut tx, &title).await?
}; };
let note_id = page.note_id; let note_id = page.note_id;
( (page, select_note_collection_from_root(&mut tx, note_id).await?)
page,
select_note_collection_from_root(&mut tx, note_id).await?,
)
} }
Err(e) => return Err(NoteStoreError::DBError(e)), Err(e) => return Err(NoteStoreError::DBError(e)),
}; };
@ -91,11 +83,13 @@ impl NoteStore {
Ok((page, notes)) Ok((page, notes))
} }
// TODO: Make sure the position is sane.
/// Insert a note as the child of an existing note, at a set position.
pub async fn insert_nested_note( pub async fn insert_nested_note(
&self, &self,
note: NewNote, note: &NewNote,
parent_note_uuid: &str, parent_note_uuid: &str,
position: i32, position: i64,
) -> NoteResult<String> { ) -> NoteResult<String> {
let mut new_note = note.clone(); let mut new_note = note.clone();
new_note.uuid = friendly_id::create(); new_note.uuid = friendly_id::create();
@ -107,8 +101,71 @@ impl NoteStore {
tx.commit().await?; tx.commit().await?;
Ok(new_note.uuid) Ok(new_note.uuid)
} }
}
// TODO: Make sure the new position is sane.
/// Move a note from one location to another.
pub async fn move_note(
&self,
note_uuid: &str,
old_parent_uuid: &str,
new_parent_uuid: &str,
new_position: i64,
) -> NoteResult<()> {
let sample = vec![note_uuid, old_parent_uuid, new_parent_uuid];
let mut tx = self.0.begin().await?;
let found_id_vec = bulk_select_ids_for_note_uuids(&mut tx, &sample)
.await?;
let found_ids: HashMap<String, i64> = found_id_vec
.into_iter()
.collect();
if found_ids.len() != 3 {
return Err(NoteStoreError::NotFound);
}
let old_parent_id = *found_ids.get(old_parent_uuid).unwrap();
let new_parent_id = *found_ids.get(new_parent_uuid).unwrap();
let note_id = *found_ids.get(note_uuid).unwrap();
let old_note_position = get_note_note_relationship(&mut tx, old_parent_id, note_id)
.await?
.position;
let _ = delete_note_note_relationship(&mut tx, old_parent_id, note_id).await?;
let _ = close_hole_for_deleted_note(&mut tx, old_parent_id, old_note_position).await?;
let _ = make_room_for_new_note(&mut tx, new_parent_id, new_position).await?;
let _ = insert_note_note_relationship(&mut tx, new_parent_id, note_id, new_position).await?;
tx.commit().await?;
Ok(())
}
/// Embed or reference a note from a different location.
pub async fn reference_or_embed_note(
&self,
note_uuid: &str,
new_parent_uuid: &str,
new_position: i64,
new_nature: &str) -> NoteResult<()> {
todo!()
}
/// Delete a note
pub async fn delete_note(
&self,
note_uuid: &str,
note_parent_uuid: &str) -> NoteResult<()> {
todo!()
}
/// Update a note's content
pub async fn update_note_content(
&self,
note_uuid: &str,
content: &str) -> NoteResult<()> {
todo!()
}
}
// ___ _ _ // ___ _ _
// | _ \_ _(_)_ ____ _| |_ ___ // | _ \_ _(_)_ ____ _| |_ ___
// | _/ '_| \ V / _` | _/ -_) // | _/ '_| \ V / _` | _/ -_)
@ -125,10 +182,7 @@ where
E: Executor<'a, Database = Sqlite>, E: Executor<'a, Database = Sqlite>,
{ {
let initialize_sql = include_str!("sql/initialize_database.sql"); let initialize_sql = include_str!("sql/initialize_database.sql");
sqlx::query(initialize_sql) sqlx::query(initialize_sql).execute(executor).await.map(|_| ())
.execute(executor)
.await
.map(|_| ())
} }
async fn select_page_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<RawPage> async fn select_page_by_slug<'a, E>(executor: E, slug: &str) -> SqlResult<RawPage>
@ -171,7 +225,7 @@ where
Ok(id.id) Ok(id.id)
} }
async fn make_room_for_new_note<'a, E>(executor: E, parent_id: i64, position: i32) -> SqlResult<()> async fn make_room_for_new_note<'a, E>(executor: E, parent_id: i64, position: i64) -> SqlResult<()>
where where
E: Executor<'a, Database = Sqlite>, E: Executor<'a, Database = Sqlite>,
{ {
@ -189,12 +243,7 @@ where
.map(|_| ()) .map(|_| ())
} }
async fn insert_note_note_relationship<'a, E>( async fn insert_note_note_relationship<'a, E>(executor: E, parent_id: i64, note_id: i64, position: i64) -> SqlResult<()>
executor: E,
parent_id: i64,
note_id: i64,
position: i32,
) -> SqlResult<()>
where where
E: Executor<'a, Database = Sqlite>, E: Executor<'a, Database = Sqlite>,
{ {
@ -217,8 +266,7 @@ async fn select_note_collection_from_root<'a, E>(executor: E, root: i64) -> SqlR
where where
E: Executor<'a, Database = Sqlite>, E: Executor<'a, Database = Sqlite>,
{ {
let select_note_collection_from_root_sql = let select_note_collection_from_root_sql = include_str!("sql/select_note_collection_from_root.sql");
include_str!("sql/select_note_collection_from_root.sql");
Ok(sqlx::query_as(&select_note_collection_from_root_sql) Ok(sqlx::query_as(&select_note_collection_from_root_sql)
.bind(&root) .bind(&root)
.fetch_all(executor) .fetch_all(executor)
@ -322,6 +370,87 @@ where
.last_insert_rowid()) .last_insert_rowid())
} }
async fn bulk_select_ids_for_note_uuids<'a, E>(executor: E, ids: &Vec<&str>) -> SqlResult<Vec<(String, i64)>>
where
E: Executor<'a, Database = Sqlite>,
{
let bulk_select_ids_for_note_uuids_sql =
"SELECT uuid, id FROM notes WHERE uuid IN (".to_string() +
&["?",].repeat(ids.len()).join(",") +
&");".to_string();
let mut request = sqlx::query(&bulk_select_ids_for_note_uuids_sql);
for id in ids.iter() {
request = request.bind(id);
}
Ok(request
.try_map(|row: SqliteRow| {
let l = row.try_get::<String, _>(0)?;
let r = row.try_get::<i64, _>(1)?;
Ok((l, r)) })
.fetch_all(executor)
.await?
.into_iter()
.collect())
}
async fn get_note_note_relationship<'a, E>(executor: E, parent_id: i64, note_id: i64) -> SqlResult<NoteRelationship>
where
E: Executor<'a, Database = Sqlite>,
{
let get_note_note_relationship_sql = concat!(
"SELECT parent_id, note_id, position, nature ",
"FROM note_relationships ",
"WHERE parent_id = ? and note_id = ? ",
"LIMIT 1"
);
sqlx::query_as(get_note_note_relationship_sql)
.bind(&parent_id)
.bind(&note_id)
.fetch_one(executor)
.await
}
async fn delete_note_note_relationship<'a, E>(executor: E, parent_id: i64, note_id: i64) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
{
let delete_note_note_relationship_sql = concat!(
"DELETE FROM note_relationships ",
"WHERE parent_id = ? and note_id = ? "
);
let count = sqlx::query(delete_note_note_relationship_sql)
.bind(&parent_id)
.bind(&note_id)
.execute(executor)
.await?
.rows_affected();
match count {
1 => Ok(()),
_ => Err(sqlx::Error::RowNotFound),
}
}
async fn close_hole_for_deleted_note<'a, E>(executor: E, parent_id: i64, position: i64) -> SqlResult<()>
where
E: Executor<'a, Database = Sqlite>,
{
let close_hole_for_deleted_note_sql = concat!(
"UPDATE note_relationships ",
"SET position = position - 1 ",
"WHERE position > ? and parent_id = ?;"
);
sqlx::query(close_hole_for_deleted_note_sql)
.bind(&position)
.bind(&parent_id)
.execute(executor)
.await
.map(|_| ())
}
fn create_unique_root_note() -> NewNote { fn create_unique_root_note() -> NewNote {
NewNoteBuilder::default() NewNoteBuilder::default()
.uuid(friendly_id::create()) .uuid(friendly_id::create())