Bookmark & Bookmark Categories Endpoints

Added endpoints for bookmarks and bookmark categories.
This commit is contained in:
Joe Bellus 2022-02-04 15:28:53 -05:00
parent 734b704fa2
commit 80d14a9688
9 changed files with 573 additions and 7 deletions

View File

@ -11,13 +11,14 @@ CREATE TABLE application (
CREATE TABLE application_category ( CREATE TABLE application_category (
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
category_name TEXT NOT NULL, category_name TEXT NOT NULL,
glyph TEXT,
active BOOLEAN NOT NULL DEFAULT 1 active BOOLEAN NOT NULL DEFAULT 1
); );
CREATE TABLE bookmark ( CREATE TABLE bookmark (
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
category_name TEXT NOT NULL, bookmark_name TEXT NOT NULL,
url TEXT NOT NULL,
active BOOLEAN NOT NULL DEFAULT 1, active BOOLEAN NOT NULL DEFAULT 1,
glyph TEXT, bookmark_category_id INTEGER
); );
CREATE TABLE bookmark_category ( CREATE TABLE bookmark_category (
id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,

View File

@ -20,6 +20,7 @@ pub async fn new_application_category(
) -> Result<HttpResponse> { ) -> Result<HttpResponse> {
let model = application_category::ActiveModel { let model = application_category::ActiveModel {
id: NotSet, id: NotSet,
glyph: Set(data.0.glyph),
category_name: Set(data.0.category_name), category_name: Set(data.0.category_name),
active: Set(data.0.active), active: Set(data.0.active),
}; };
@ -58,6 +59,7 @@ pub async fn update_application_category(
let data = data.into_inner(); let data = data.into_inner();
let ret = application_category::ActiveModel { let ret = application_category::ActiveModel {
id: Set(id), id: Set(id),
glyph: Set(data.glyph),
active: Set(data.active), active: Set(data.active),
category_name: Set(data.category_name), category_name: Set(data.category_name),
}; };
@ -177,6 +179,7 @@ mod tests {
let model = application_category::Model { let model = application_category::Model {
id: 0, id: 0,
category_name: "Some name".into(), category_name: "Some name".into(),
glyph: None,
active: true, active: true,
}; };

View File

@ -0,0 +1,308 @@
use tracing::instrument;
use crate::api::api_prelude::*;
use crate::error::{Error, Result};
#[instrument]
#[get("")]
pub async fn list_bookmark_categories(state: web::Data<AppState>) -> Result<HttpResponse> {
let cats: Vec<bookmark_category::Model> =
BookmarkCategory::find().all(&state.db).await.unwrap();
let count = cats.len();
Ok(HttpResponse::Ok().json(ListObjects::new(cats, count)))
}
#[instrument]
#[post("")]
pub async fn new_bookmark_category(
state: web::Data<AppState>,
data: web::Json<bookmark_category::Model>,
) -> Result<HttpResponse> {
let model = bookmark_category::ActiveModel {
id: NotSet,
category_name: Set(data.0.category_name),
glyph: Set(data.0.glyph),
active: Set(data.0.active),
};
let rec = model.insert(&state.db).await?;
Ok(HttpResponse::Ok().json(rec))
}
#[instrument]
#[get("{id}")]
pub async fn get_bookmark_category(
state: web::Data<AppState>,
id: web::Path<i32>,
) -> Result<HttpResponse> {
let id = id.into_inner();
let res: Option<bookmark_category::Model> =
BookmarkCategory::find_by_id(id).one(&state.db).await?;
match res {
Some(rec) => Ok(HttpResponse::Ok().json(rec)),
None => Err(Error::not_found()),
}
}
#[instrument]
#[put("{id}")]
pub async fn update_bookmark_category(
state: web::Data<AppState>,
data: web::Json<bookmark_category::Model>,
id: web::Path<i32>,
) -> Result<HttpResponse> {
let id = id.into_inner();
let res: Option<bookmark_category::Model> =
BookmarkCategory::find_by_id(id).one(&state.db).await?;
match res {
Some(_rec) => {
let data = data.into_inner();
let ret = bookmark_category::ActiveModel {
id: Set(id),
active: Set(data.active),
glyph: Set(data.glyph),
category_name: Set(data.category_name),
};
let model = ret.update(&state.db).await?;
Ok(HttpResponse::Ok().json(model))
}
None => Err(Error::not_found()),
}
}
#[instrument]
#[delete("{id}")]
pub async fn delete_bookmark_category(
state: web::Data<AppState>,
id: web::Path<i32>,
) -> Result<HttpResponse> {
BookmarkCategory::delete_many()
.filter(bookmark_category::Column::Id.eq(id.into_inner()))
.exec(&state.db)
.await?;
Ok(HttpResponse::Ok().body(""))
}
#[instrument]
#[get("{id}/bookmarks")]
pub async fn bookmark_category_bookmarks(
state: web::Data<AppState>,
id: web::Path<i32>,
) -> Result<HttpResponse> {
let recs: Vec<bookmark::Model> = Bookmark::find()
.filter(bookmark::Column::BookmarkCategoryId.eq(id.into_inner()))
.all(&state.db)
.await
.unwrap();
let count = recs.len();
Ok(HttpResponse::Ok().json(ListObjects::new(recs, count)))
}
/// Routes for the bookmark endpoints. This binds up a scope with all endpoints for bookmarks, to make it easier to add them to the server.
pub fn routes() -> Scope {
web::scope("/bookmark_categories")
.service(bookmark_category_bookmarks)
.service(list_bookmark_categories)
.service(update_bookmark_category)
.service(delete_bookmark_category)
.service(new_bookmark_category)
.service(get_bookmark_category)
}
#[cfg(test)]
mod tests {
use crate::api::test_prelude::*;
use actix_web::http::Method;
#[actix_rt::test]
async fn test_list_bookmark_categories() -> Result<()> {
let state = setup_state().await?;
bookmark_category::ActiveModel {
category_name: Set("Bookmark 1".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
bookmark_category::ActiveModel {
category_name: Set("Bookmark 2".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
let req = actix_web::test::TestRequest::with_uri("/bookmark_categories")
.method(Method::GET)
.to_request();
let resp = call_endpoint!(req, state);
assert_eq!(resp.status(), 200);
let data = get_response!(resp, ListObjects<crate::entity::bookmark_category::Model>);
assert_eq!(2_usize, data.items.len());
Ok(())
}
#[actix_rt::test]
async fn test_get_bookmark_categories() -> Result<()> {
let state = setup_state().await?;
let model = bookmark_category::ActiveModel {
category_name: Set("Bookmark 1".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
let req =
actix_web::test::TestRequest::with_uri(&format!("/bookmark_categories/{}", model.id))
.method(Method::GET)
.to_request();
let resp = call_endpoint!(req, state);
let status = resp.status();
let mut data = get_response!(resp, crate::entity::bookmark_category::Model);
data.id = model.id;
assert_eq!(model, data);
assert_eq!(status, 200);
Ok(())
}
#[actix_rt::test]
async fn test_new_bookmark_category() -> Result<()> {
let model = bookmark_category::Model {
id: 0,
category_name: "Some name".into(),
glyph: None,
active: true,
};
let state = setup_state().await?;
let req = actix_web::test::TestRequest::with_uri("/bookmark_categories")
.method(Method::POST)
.set_json(model.clone())
.to_request();
let resp = call_endpoint!(req, state);
assert_eq!(resp.status(), 200);
let data = get_response!(resp, crate::entity::bookmark_category::Model);
assert_eq!(model, data);
assert_eq!(bookmark_category::Entity::find().count(&state.db).await?, 1);
Ok(())
}
#[actix_rt::test]
async fn test_update_bookmark_category() -> Result<()> {
let state = setup_state().await?;
bookmark_category::ActiveModel {
category_name: Set("Some name".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
let mut model = bookmark_category::ActiveModel {
category_name: Set("Some name".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
model.category_name = "Another name".into();
let req =
actix_web::test::TestRequest::with_uri(&format!("/bookmark_categories/{}", model.id))
.method(Method::PUT)
.set_json(model.clone())
.to_request();
let resp = call_endpoint!(req, state);
assert_eq!(resp.status(), 200);
let mut data = get_response!(resp, crate::entity::bookmark_category::Model);
data.id = model.id;
assert_eq!(model, data, "Check API");
let db_model = bookmark_category::Entity::find_by_id(model.id)
.one(&state.db)
.await?
.unwrap();
assert_eq!(db_model, model, "Check DB");
Ok(())
}
#[actix_rt::test]
async fn test_delete_bookmark_category() -> Result<()> {
let state = setup_state().await?;
let model = bookmark_category::ActiveModel {
category_name: Set("Some name".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
let req =
actix_web::test::TestRequest::with_uri(&format!("/bookmark_categories/{}", model.id))
.method(Method::DELETE)
.to_request();
let resp = call_endpoint!(req, state);
assert_eq!(resp.status(), 200);
assert_eq!(bookmark_category::Entity::find().count(&state.db).await?, 0);
Ok(())
}
#[actix_rt::test]
async fn test_bookmark_categories_bookmarks() -> Result<()> {
let state = setup_state().await?;
let category = bookmark_category::ActiveModel {
category_name: Set("Bookmark 1".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
bookmark::ActiveModel {
bookmark_name: Set("Bookmark 1".into()),
url: Set("http://somewhere/".into()),
active: Set(true),
bookmark_category_id: Set(Some(category.id)),
..Default::default()
}
.insert(&state.db)
.await?;
bookmark::ActiveModel {
bookmark_name: Set("Bookmark 2".into()),
url: Set("http://somewhere/".into()),
bookmark_category_id: Set(Some(category.id)),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
bookmark::ActiveModel {
bookmark_name: Set("Bookmark 2".into()),
url: Set("http://somewhere/".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
let req = actix_web::test::TestRequest::with_uri(&format!(
"/bookmark_categories/{}/bookmarks",
category.id
))
.method(Method::GET)
.to_request();
let resp = call_endpoint!(req, state);
assert_eq!(resp.status(), 200);
let data = get_response!(resp, ListObjects<crate::entity::bookmark::Model>);
assert_eq!(2_usize, data.items.len());
Ok(())
}
}

241
src/api/bookmarks.rs Normal file
View File

@ -0,0 +1,241 @@
use tracing::instrument;
use crate::api::api_prelude::*;
use crate::error::{Error, Result};
#[instrument]
#[get("")]
pub async fn list_bookmarks(state: web::Data<AppState>) -> Result<HttpResponse> {
let apps: Vec<bookmark::Model> = Bookmark::find().all(&state.db).await.unwrap();
let count = apps.len();
Ok(HttpResponse::Ok().json(ListObjects::new(apps, count)))
}
#[instrument]
#[post("")]
pub async fn new_bookmark(
state: web::Data<AppState>,
data: web::Json<bookmark::Model>,
) -> Result<HttpResponse> {
let model = bookmark::ActiveModel {
id: NotSet,
bookmark_name: Set(data.0.bookmark_name),
url: Set(data.0.url),
active: Set(data.0.active),
bookmark_category_id: Set(data.0.bookmark_category_id),
};
let app = model.insert(&state.db).await?;
Ok(HttpResponse::Ok().json(app))
}
#[instrument]
#[get("{id}")]
pub async fn get_bookmarks(state: web::Data<AppState>, id: web::Path<i32>) -> Result<HttpResponse> {
let id = id.into_inner();
let res: Option<bookmark::Model> = Bookmark::find_by_id(id).one(&state.db).await?;
match res {
Some(app) => Ok(HttpResponse::Ok().json(app)),
None => Err(Error::not_found()),
}
}
#[instrument]
#[put("{id}")]
pub async fn update_bookmarks(
state: web::Data<AppState>,
data: web::Json<bookmark::Model>,
id: web::Path<i32>,
) -> Result<HttpResponse> {
let id = id.into_inner();
let res: Option<bookmark::Model> = Bookmark::find_by_id(id).one(&state.db).await?;
match res {
Some(_app) => {
let data = data.into_inner();
let ret = bookmark::ActiveModel {
id: Set(id),
active: Set(data.active),
bookmark_name: Set(data.bookmark_name),
url: Set(data.url),
bookmark_category_id: Set(data.bookmark_category_id),
};
let model = ret.update(&state.db).await?;
Ok(HttpResponse::Ok().json(model))
}
None => Err(Error::not_found()),
}
}
#[instrument]
#[delete("{id}")]
pub async fn delete_bookmark(
state: web::Data<AppState>,
id: web::Path<i32>,
) -> Result<HttpResponse> {
Bookmark::delete_many()
.filter(bookmark::Column::Id.eq(id.into_inner()))
.exec(&state.db)
.await?;
Ok(HttpResponse::Ok().body(""))
}
/// Routes for the bookmark endpoints. This binds up a scope with all endpoints for bookmarks, to make it easier to add them to the server.
pub fn routes() -> Scope {
web::scope("/bookmarks")
.service(list_bookmarks)
.service(update_bookmarks)
.service(delete_bookmark)
.service(new_bookmark)
.service(get_bookmarks)
}
#[cfg(test)]
mod tests {
use crate::api::test_prelude::*;
use actix_web::http::Method;
#[actix_rt::test]
async fn test_list_bookmarks() -> Result<()> {
let state = setup_state().await?;
bookmark::ActiveModel {
bookmark_name: Set("Bookmark 1".into()),
url: Set("http://somewhere/".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
bookmark::ActiveModel {
bookmark_name: Set("Bookmark 2".into()),
url: Set("http://somewhere/".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
let req = actix_web::test::TestRequest::with_uri("/bookmarks")
.method(Method::GET)
.to_request();
let resp = call_endpoint!(req, state);
assert_eq!(resp.status(), 200);
let data = get_response!(resp, ListObjects<crate::entity::bookmark::Model>);
assert_eq!(2_usize, data.items.len());
Ok(())
}
#[actix_rt::test]
async fn test_get_bookmarks() -> Result<()> {
let state = setup_state().await?;
let model = bookmark::ActiveModel {
bookmark_name: Set("Bookmark 1".into()),
url: Set("http://somewhere/".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
let req = actix_web::test::TestRequest::with_uri(&format!("/bookmarks/{}", model.id))
.method(Method::GET)
.to_request();
let resp = call_endpoint!(req, state);
let status = resp.status();
let mut data = get_response!(resp, crate::entity::bookmark::Model);
data.id = model.id;
assert_eq!(model, data);
assert_eq!(status, 200);
Ok(())
}
#[actix_rt::test]
async fn test_new_bookmark() -> Result<()> {
let model = bookmark::Model {
id: 0,
bookmark_name: "Bookmark 1".into(),
url: "http://example.com".into(),
active: true,
bookmark_category_id: None,
};
let state = setup_state().await?;
let req = actix_web::test::TestRequest::with_uri("/bookmarks")
.method(Method::POST)
.set_json(model.clone())
.to_request();
let resp = call_endpoint!(req, state);
assert_eq!(resp.status(), 200);
let data = get_response!(resp, crate::entity::bookmark::Model);
assert_eq!(model, data);
assert_eq!(bookmark::Entity::find().count(&state.db).await?, 1);
Ok(())
}
#[actix_rt::test]
async fn test_update_bookmark() -> Result<()> {
let state = setup_state().await?;
bookmark::ActiveModel {
bookmark_name: Set("Bookmark 1".into()),
url: Set("http://somewhere/".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
let mut model = bookmark::ActiveModel {
bookmark_name: Set("Bookmark 2".into()),
url: Set("http://somewhere/".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
model.url = "http://updated.com".into();
let req = actix_web::test::TestRequest::with_uri(&format!("/bookmarks/{}", model.id))
.method(Method::PUT)
.set_json(model.clone())
.to_request();
let resp = call_endpoint!(req, state);
assert_eq!(resp.status(), 200);
let mut data = get_response!(resp, crate::entity::bookmark::Model);
data.id = model.id;
assert_eq!(model, data, "Check API");
let db_model = bookmark::Entity::find_by_id(model.id)
.one(&state.db)
.await?
.unwrap();
assert_eq!(db_model, model, "Check DB");
Ok(())
}
#[actix_rt::test]
async fn test_delete_bookmark() -> Result<()> {
let state = setup_state().await?;
let model = bookmark::ActiveModel {
bookmark_name: Set("Bookmark 1".into()),
url: Set("http://somewhere/".into()),
active: Set(true),
..Default::default()
}
.insert(&state.db)
.await?;
let req = actix_web::test::TestRequest::with_uri(&format!("/bookmarks/{}", model.id))
.method(Method::DELETE)
.to_request();
let resp = call_endpoint!(req, state);
assert_eq!(resp.status(), 200);
assert_eq!(bookmark::Entity::find().count(&state.db).await?, 0);
Ok(())
}
}

View File

@ -21,7 +21,9 @@ macro_rules! call_endpoint {
.wrap(tracing_actix_web::TracingLogger::default()) .wrap(tracing_actix_web::TracingLogger::default())
.app_data($state.clone()) .app_data($state.clone())
.service(crate::api::applications::routes()) .service(crate::api::applications::routes())
.service(crate::api::application_category::routes()); .service(crate::api::application_categories::routes())
.service(crate::api::bookmarks::routes())
.service(crate::api::bookmark_categories::routes());
let app = actix_web::test::init_service(a).await; let app = actix_web::test::init_service(a).await;
let resp = actix_web::test::call_service(&app, $req).await; let resp = actix_web::test::call_service(&app, $req).await;
resp resp
@ -36,8 +38,10 @@ macro_rules! get_response {
}}; }};
} }
pub mod application_category; pub mod application_categories;
pub mod applications; pub mod applications;
pub mod bookmark_categories;
pub mod bookmarks;
mod api_prelude { mod api_prelude {
pub use super::ListObjects; pub use super::ListObjects;
@ -78,7 +82,11 @@ mod test_prelude {
let stmt: TableCreateStatement = let stmt: TableCreateStatement =
schema.create_table_from_entity(application_category::Entity); schema.create_table_from_entity(application_category::Entity);
db.execute(db.get_database_backend().build(&stmt)).await?; db.execute(db.get_database_backend().build(&stmt)).await?;
let stmt: TableCreateStatement = schema.create_table_from_entity(bookmark::Entity);
db.execute(db.get_database_backend().build(&stmt)).await?;
let stmt: TableCreateStatement = schema.create_table_from_entity(bookmark_category::Entity);
db.execute(db.get_database_backend().build(&stmt)).await?;
Ok(actix_web::web::Data::new(AppState { db })) Ok(actix_web::web::Data::new(AppState { db }))
} }
} }

View File

@ -12,6 +12,7 @@ pub struct Model {
pub id: i32, pub id: i32,
pub category_name: String, pub category_name: String,
pub active: bool, pub active: bool,
pub glyph: Option<String>,
} }
#[derive(Copy, Clone, Debug, EnumIter)] #[derive(Copy, Clone, Debug, EnumIter)]

View File

@ -7,10 +7,11 @@ use serde::{Deserialize, Serialize};
#[sea_orm(table_name = "bookmark")] #[sea_orm(table_name = "bookmark")]
pub struct Model { pub struct Model {
#[sea_orm(primary_key)] #[sea_orm(primary_key)]
#[serde(skip_deserializing)]
pub id: i32, pub id: i32,
pub category_name: String, pub bookmark_name: String,
pub url: String,
pub active: bool, pub active: bool,
pub glyph: Option<String>,
pub bookmark_category_id: Option<i32>, pub bookmark_category_id: Option<i32>,
} }

View File

@ -7,6 +7,7 @@ use serde::{Deserialize, Serialize};
#[sea_orm(table_name = "bookmark_category")] #[sea_orm(table_name = "bookmark_category")]
pub struct Model { pub struct Model {
#[sea_orm(primary_key)] #[sea_orm(primary_key)]
#[serde(skip_deserializing)]
pub id: i32, pub id: i32,
pub category_name: String, pub category_name: String,
pub active: bool, pub active: bool,

View File

@ -31,7 +31,9 @@ async fn main() {
App::new() App::new()
.app_data(state.clone()) .app_data(state.clone())
.service(api::applications::routes()) .service(api::applications::routes())
.service(api::application_category::routes()) .service(api::application_categories::routes())
.service(api::bookmarks::routes())
.service(api::bookmark_categories::routes())
}) })
.bind("127.0.0.1:8080") .bind("127.0.0.1:8080")
.unwrap() .unwrap()