thallada/BazaarRealmAPI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Simplify handler content_type switching

Browse Source 
The inner functions were a bit too cumbersome. I found a more compact way to do it in one flat function.
This commit is contained in:
Tyler Hallada 2020-11-08 20:10:32 -05:00
parent e0cc81c97e
commit 377a260a2f
6 changed files with 758 additions and 806 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

201
src/handlers/interior_ref_list.rs
View File

@ -5,12 +5,14 @@ use uuid::Uuid;
use warp::reply::{with_header, with_status}; use warp::reply::{with_header, with_status};
use warp::{Rejection, Reply}; use warp::{Rejection, Reply};
use crate::caches::{Cache, CachedResponse, CACHES}; use crate::caches::CACHES;
use crate::models::{InteriorRefList, ListParams}; use crate::models::{InteriorRefList, ListParams};
use crate::problem::reject_anyhow; use crate::problem::reject_anyhow;
use crate::Environment; use crate::Environment;
use super::{authenticate, check_etag, AcceptHeader, Bincode, DataReply, ETagReply, Json}; use super::{
authenticate, check_etag, AcceptHeader, Bincode, ContentType, DataReply, ETagReply, Json,
};
pub async fn get( pub async fn get(
id: i32, id: i32,
@ -18,29 +20,28 @@ pub async fn get(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
id: i32, Some(accept) if accept.accepts_bincode() => {
etag: Option<String>, (ContentType::Bincode, &CACHES.interior_ref_list_bin)
env: Environment, }
cache: &'static Cache<i32, CachedResponse>, _ => (ContentType::Json, &CACHES.interior_ref_list),
) -> Result<Box<dyn Reply>, Rejection> { };
let response = cache let response = cache
.get_response(id, || async { .get_response(id, || async {
let interior_ref_list = InteriorRefList::get(&env.db, id).await?; let interior_ref_list = InteriorRefList::get(&env.db, id).await?;
let reply = T::from_serializable(&interior_ref_list)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => {
Box::new(ETagReply::<Bincode>::from_serializable(&interior_ref_list)?)
}
ContentType::Json => {
Box::new(ETagReply::<Json>::from_serializable(&interior_ref_list)?)
}
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(id, etag, env, &CACHES.interior_ref_list_bin).await
}
_ => get::<ETagReply<Json>>(id, etag, env, &CACHES.interior_ref_list).await,
}
} }
pub async fn get_by_shop_id( pub async fn get_by_shop_id(
@ -49,30 +50,29 @@ pub async fn get_by_shop_id(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
shop_id: i32, Some(accept) if accept.accepts_bincode() => (
etag: Option<String>, ContentType::Bincode,
env: Environment, &CACHES.interior_ref_list_by_shop_id_bin,
cache: &'static Cache<i32, CachedResponse>, ),
) -> Result<Box<dyn Reply>, Rejection> { _ => (ContentType::Json, &CACHES.interior_ref_list_by_shop_id),
};
let response = cache let response = cache
.get_response(shop_id, || async { .get_response(shop_id, || async {
let interior_ref_list = InteriorRefList::get_by_shop_id(&env.db, shop_id).await?; let interior_ref_list = InteriorRefList::get_by_shop_id(&env.db, shop_id).await?;
let reply = T::from_serializable(&interior_ref_list)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => {
Box::new(ETagReply::<Bincode>::from_serializable(&interior_ref_list)?)
}
ContentType::Json => {
Box::new(ETagReply::<Json>::from_serializable(&interior_ref_list)?)
}
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(shop_id, etag, env, &CACHES.interior_ref_list_by_shop_id_bin)
.await
}
_ => get::<ETagReply<Json>>(shop_id, etag, env, &CACHES.interior_ref_list_by_shop_id).await,
}
} }
pub async fn list( pub async fn list(
@ -81,31 +81,29 @@ pub async fn list(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
list_params: ListParams, Some(accept) if accept.accepts_bincode() => {
etag: Option<String>, (ContentType::Bincode, &CACHES.list_interior_ref_lists_bin)
env: Environment, }
cache: &'static Cache<ListParams, CachedResponse>, _ => (ContentType::Json, &CACHES.list_interior_ref_lists),
) -> Result<Box<dyn Reply>, Rejection> { };
let response = cache let response = cache
.get_response(list_params.clone(), || async { .get_response(list_params.clone(), || async {
let interior_ref_lists = InteriorRefList::list(&env.db, &list_params).await?; let interior_ref_lists = InteriorRefList::list(&env.db, &list_params).await?;
let reply = T::from_serializable(&interior_ref_lists)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(ETagReply::<Bincode>::from_serializable(
&interior_ref_lists,
)?),
ContentType::Json => {
Box::new(ETagReply::<Json>::from_serializable(&interior_ref_lists)?)
}
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(list_params, etag, env, &CACHES.list_interior_ref_lists_bin)
.await
}
_ => get::<ETagReply<Json>>(list_params, etag, env, &CACHES.list_interior_ref_lists).await,
}
} }
pub async fn create( pub async fn create(
@ -114,11 +112,12 @@ pub async fn create(
content_type: Option<Mime>, content_type: Option<Mime>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn create<'a, T: DataReply + 'a>( let content_type = match content_type {
interior_ref_list: InteriorRefList, Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
api_key: Option<Uuid>, ContentType::Bincode
env: Environment, }
) -> Result<Box<dyn Reply + 'a>, Rejection> { _ => ContentType::Json,
};
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?; let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
let ref_list_with_owner_id = InteriorRefList { let ref_list_with_owner_id = InteriorRefList {
owner_id: Some(owner_id), owner_id: Some(owner_id),
@ -131,8 +130,16 @@ pub async fn create(
let url = saved_interior_ref_list let url = saved_interior_ref_list
.url(&env.api_url) .url(&env.api_url)
.map_err(reject_anyhow)?; .map_err(reject_anyhow)?;
let reply = ETagReply::<Json>::from_serializable(&saved_interior_ref_list) let reply: Box<dyn Reply> = match content_type {
.map_err(reject_anyhow)?; ContentType::Bincode => Box::new(
ETagReply::<Bincode>::from_serializable(&saved_interior_ref_list)
.map_err(reject_anyhow)?,
),
ContentType::Json => Box::new(
ETagReply::<Json>::from_serializable(&saved_interior_ref_list)
.map_err(reject_anyhow)?,
),
};
let reply = with_header(reply, "Location", url.as_str()); let reply = with_header(reply, "Location", url.as_str());
let reply = with_status(reply, StatusCode::CREATED); let reply = with_status(reply, StatusCode::CREATED);
tokio::spawn(async move { tokio::spawn(async move {
@ -147,15 +154,7 @@ pub async fn create(
.delete_response(saved_interior_ref_list.shop_id) .delete_response(saved_interior_ref_list.shop_id)
.await; .await;
}); });
Ok(Box::new(reply)) Ok(reply)
}
match content_type {
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
create::<ETagReply<Bincode>>(interior_ref_list, api_key, env).await
}
_ => create::<ETagReply<Json>>(interior_ref_list, api_key, env).await,
}
} }
pub async fn update( pub async fn update(
@ -165,12 +164,12 @@ pub async fn update(
content_type: Option<Mime>, content_type: Option<Mime>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn update<'a, T: DataReply + 'a>( let content_type = match content_type {
id: i32, Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
interior_ref_list: InteriorRefList, ContentType::Bincode
api_key: Option<Uuid>, }
env: Environment, _ => ContentType::Json,
) -> Result<Box<dyn Reply + 'a>, Rejection> { };
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?; let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
let interior_ref_list_with_id_and_owner_id = if interior_ref_list.owner_id.is_some() { let interior_ref_list_with_id_and_owner_id = if interior_ref_list.owner_id.is_some() {
InteriorRefList { InteriorRefList {
@ -191,7 +190,16 @@ pub async fn update(
let url = updated_interior_ref_list let url = updated_interior_ref_list
.url(&env.api_url) .url(&env.api_url)
.map_err(reject_anyhow)?; .map_err(reject_anyhow)?;
let reply = T::from_serializable(&updated_interior_ref_list).map_err(reject_anyhow)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(
ETagReply::<Bincode>::from_serializable(&updated_interior_ref_list)
.map_err(reject_anyhow)?,
),
ContentType::Json => Box::new(
ETagReply::<Json>::from_serializable(&updated_interior_ref_list)
.map_err(reject_anyhow)?,
),
};
let reply = with_header(reply, "Location", url.as_str()); let reply = with_header(reply, "Location", url.as_str());
let reply = with_status(reply, StatusCode::CREATED); let reply = with_status(reply, StatusCode::CREATED);
tokio::spawn(async move { tokio::spawn(async move {
@ -208,15 +216,7 @@ pub async fn update(
CACHES.list_interior_ref_lists.clear().await; CACHES.list_interior_ref_lists.clear().await;
CACHES.list_interior_ref_lists_bin.clear().await; CACHES.list_interior_ref_lists_bin.clear().await;
}); });
Ok(Box::new(reply)) Ok(reply)
}
match content_type {
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
update::<ETagReply<Bincode>>(id, interior_ref_list, api_key, env).await
}
_ => update::<ETagReply<Json>>(id, interior_ref_list, api_key, env).await,
}
} }
pub async fn update_by_shop_id( pub async fn update_by_shop_id(
@ -226,12 +226,12 @@ pub async fn update_by_shop_id(
content_type: Option<Mime>, content_type: Option<Mime>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn update<'a, T: DataReply + 'a>( let content_type = match content_type {
shop_id: i32, Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
interior_ref_list: InteriorRefList, ContentType::Bincode
api_key: Option<Uuid>, }
env: Environment, _ => ContentType::Json,
) -> Result<Box<dyn Reply + 'a>, Rejection> { };
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?; let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
let interior_ref_list_with_owner_id = InteriorRefList { let interior_ref_list_with_owner_id = InteriorRefList {
owner_id: Some(owner_id), owner_id: Some(owner_id),
@ -244,7 +244,16 @@ pub async fn update_by_shop_id(
let url = updated_interior_ref_list let url = updated_interior_ref_list
.url(&env.api_url) .url(&env.api_url)
.map_err(reject_anyhow)?; .map_err(reject_anyhow)?;
let reply = T::from_serializable(&updated_interior_ref_list).map_err(reject_anyhow)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(
ETagReply::<Bincode>::from_serializable(&updated_interior_ref_list)
.map_err(reject_anyhow)?,
),
ContentType::Json => Box::new(
ETagReply::<Json>::from_serializable(&updated_interior_ref_list)
.map_err(reject_anyhow)?,
),
};
let reply = with_header(reply, "Location", url.as_str()); let reply = with_header(reply, "Location", url.as_str());
let reply = with_status(reply, StatusCode::CREATED); let reply = with_status(reply, StatusCode::CREATED);
tokio::spawn(async move { tokio::spawn(async move {
@ -264,15 +273,7 @@ pub async fn update_by_shop_id(
CACHES.list_interior_ref_lists.clear().await; CACHES.list_interior_ref_lists.clear().await;
CACHES.list_interior_ref_lists_bin.clear().await; CACHES.list_interior_ref_lists_bin.clear().await;
}); });
Ok(Box::new(reply)) Ok(reply)
}
match content_type {
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
update::<ETagReply<Bincode>>(shop_id, interior_ref_list, api_key, env).await
}
_ => update::<ETagReply<Json>>(shop_id, interior_ref_list, api_key, env).await,
}
} }
pub async fn delete( pub async fn delete(

199
src/handlers/merchandise_list.rs
View File

@ -5,12 +5,14 @@ use uuid::Uuid;
use warp::reply::{with_header, with_status}; use warp::reply::{with_header, with_status};
use warp::{Rejection, Reply}; use warp::{Rejection, Reply};
use crate::caches::{Cache, CachedResponse, CACHES}; use crate::caches::CACHES;
use crate::models::{ListParams, MerchandiseList}; use crate::models::{ListParams, MerchandiseList};
use crate::problem::reject_anyhow; use crate::problem::reject_anyhow;
use crate::Environment; use crate::Environment;
use super::{authenticate, check_etag, AcceptHeader, Bincode, DataReply, ETagReply, Json}; use super::{
authenticate, check_etag, AcceptHeader, Bincode, ContentType, DataReply, ETagReply, Json,
};
pub async fn get( pub async fn get(
id: i32, id: i32,
@ -18,29 +20,28 @@ pub async fn get(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
id: i32, Some(accept) if accept.accepts_bincode() => {
etag: Option<String>, (ContentType::Bincode, &CACHES.merchandise_list_bin)
env: Environment, }
cache: &'static Cache<i32, CachedResponse>, _ => (ContentType::Json, &CACHES.merchandise_list),
) -> Result<Box<dyn Reply>, Rejection> { };
let response = cache let response = cache
.get_response(id, || async { .get_response(id, || async {
let merchandise_list = MerchandiseList::get(&env.db, id).await?; let merchandise_list = MerchandiseList::get(&env.db, id).await?;
let reply = T::from_serializable(&merchandise_list)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => {
Box::new(ETagReply::<Bincode>::from_serializable(&merchandise_list)?)
}
ContentType::Json => {
Box::new(ETagReply::<Json>::from_serializable(&merchandise_list)?)
}
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(id, etag, env, &CACHES.merchandise_list_bin).await
}
_ => get::<ETagReply<Json>>(id, etag, env, &CACHES.merchandise_list).await,
}
} }
pub async fn get_by_shop_id( pub async fn get_by_shop_id(
@ -49,30 +50,28 @@ pub async fn get_by_shop_id(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
shop_id: i32, Some(accept) if accept.accepts_bincode() => {
etag: Option<String>, (ContentType::Bincode, &CACHES.merchandise_list_bin)
env: Environment, }
cache: &'static Cache<i32, CachedResponse>, _ => (ContentType::Json, &CACHES.merchandise_list),
) -> Result<Box<dyn Reply>, Rejection> { };
let response = cache let response = cache
.get_response(shop_id, || async { .get_response(shop_id, || async {
let merchandise_list = MerchandiseList::get_by_shop_id(&env.db, shop_id).await?; let merchandise_list = MerchandiseList::get_by_shop_id(&env.db, shop_id).await?;
let reply = T::from_serializable(&merchandise_list)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => {
Box::new(ETagReply::<Bincode>::from_serializable(&merchandise_list)?)
}
ContentType::Json => {
Box::new(ETagReply::<Json>::from_serializable(&merchandise_list)?)
}
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(shop_id, etag, env, &CACHES.merchandise_list_by_shop_id_bin)
.await
}
_ => get::<ETagReply<Json>>(shop_id, etag, env, &CACHES.merchandise_list_by_shop_id).await,
}
} }
pub async fn list( pub async fn list(
@ -81,30 +80,28 @@ pub async fn list(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
list_params: ListParams, Some(accept) if accept.accepts_bincode() => {
etag: Option<String>, (ContentType::Bincode, &CACHES.list_merchandise_lists_bin)
env: Environment, }
cache: &'static Cache<ListParams, CachedResponse>, _ => (ContentType::Json, &CACHES.list_merchandise_lists),
) -> Result<Box<dyn Reply>, Rejection> { };
let response = cache let response = cache
.get_response(list_params.clone(), || async { .get_response(list_params.clone(), || async {
let merchandise_lists = MerchandiseList::list(&env.db, &list_params).await?; let merchandise_lists = MerchandiseList::list(&env.db, &list_params).await?;
let reply = T::from_serializable(&merchandise_lists)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => {
Box::new(ETagReply::<Bincode>::from_serializable(&merchandise_lists)?)
}
ContentType::Json => {
Box::new(ETagReply::<Json>::from_serializable(&merchandise_lists)?)
}
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(list_params, etag, env, &CACHES.list_merchandise_lists_bin)
.await
}
_ => get::<ETagReply<Json>>(list_params, etag, env, &CACHES.list_merchandise_lists).await,
}
} }
pub async fn create( pub async fn create(
@ -113,11 +110,12 @@ pub async fn create(
content_type: Option<Mime>, content_type: Option<Mime>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn create<'a, T: DataReply + 'a>( let content_type = match content_type {
merchandise_list: MerchandiseList, Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
api_key: Option<Uuid>, ContentType::Bincode
env: Environment, }
) -> Result<Box<dyn Reply + 'a>, Rejection> { _ => ContentType::Json,
};
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?; let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
let ref_list_with_owner_id = MerchandiseList { let ref_list_with_owner_id = MerchandiseList {
owner_id: Some(owner_id), owner_id: Some(owner_id),
@ -130,7 +128,15 @@ pub async fn create(
let url = saved_merchandise_list let url = saved_merchandise_list
.url(&env.api_url) .url(&env.api_url)
.map_err(reject_anyhow)?; .map_err(reject_anyhow)?;
let reply = T::from_serializable(&saved_merchandise_list).map_err(reject_anyhow)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(
ETagReply::<Bincode>::from_serializable(&saved_merchandise_list)
.map_err(reject_anyhow)?,
),
ContentType::Json => Box::new(
ETagReply::<Json>::from_serializable(&saved_merchandise_list).map_err(reject_anyhow)?,
),
};
let reply = with_header(reply, "Location", url.as_str()); let reply = with_header(reply, "Location", url.as_str());
let reply = with_status(reply, StatusCode::CREATED); let reply = with_status(reply, StatusCode::CREATED);
tokio::spawn(async move { tokio::spawn(async move {
@ -145,15 +151,7 @@ pub async fn create(
.delete_response(saved_merchandise_list.shop_id) .delete_response(saved_merchandise_list.shop_id)
.await; .await;
}); });
Ok(Box::new(reply)) Ok(reply)
}
match content_type {
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
create::<ETagReply<Bincode>>(merchandise_list, api_key, env).await
}
_ => create::<ETagReply<Json>>(merchandise_list, api_key, env).await,
}
} }
pub async fn update( pub async fn update(
@ -163,12 +161,12 @@ pub async fn update(
content_type: Option<Mime>, content_type: Option<Mime>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn update<'a, T: DataReply + 'a>( let content_type = match content_type {
id: i32, Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
merchandise_list: MerchandiseList, ContentType::Bincode
api_key: Option<Uuid>, }
env: Environment, _ => ContentType::Json,
) -> Result<Box<dyn Reply + 'a>, Rejection> { };
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?; let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
let merchandise_list_with_id_and_owner_id = if merchandise_list.owner_id.is_some() { let merchandise_list_with_id_and_owner_id = if merchandise_list.owner_id.is_some() {
MerchandiseList { MerchandiseList {
@ -189,7 +187,16 @@ pub async fn update(
let url = updated_merchandise_list let url = updated_merchandise_list
.url(&env.api_url) .url(&env.api_url)
.map_err(reject_anyhow)?; .map_err(reject_anyhow)?;
let reply = T::from_serializable(&updated_merchandise_list).map_err(reject_anyhow)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(
ETagReply::<Bincode>::from_serializable(&updated_merchandise_list)
.map_err(reject_anyhow)?,
),
ContentType::Json => Box::new(
ETagReply::<Json>::from_serializable(&updated_merchandise_list)
.map_err(reject_anyhow)?,
),
};
let reply = with_header(reply, "Location", url.as_str()); let reply = with_header(reply, "Location", url.as_str());
let reply = with_status(reply, StatusCode::CREATED); let reply = with_status(reply, StatusCode::CREATED);
tokio::spawn(async move { tokio::spawn(async move {
@ -206,15 +213,7 @@ pub async fn update(
CACHES.list_merchandise_lists.clear().await; CACHES.list_merchandise_lists.clear().await;
CACHES.list_merchandise_lists_bin.clear().await; CACHES.list_merchandise_lists_bin.clear().await;
}); });
Ok(Box::new(reply)) Ok(reply)
}
match content_type {
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
update::<ETagReply<Bincode>>(id, merchandise_list, api_key, env).await
}
_ => update::<ETagReply<Json>>(id, merchandise_list, api_key, env).await,
}
} }
pub async fn update_by_shop_id( pub async fn update_by_shop_id(
@ -224,12 +223,12 @@ pub async fn update_by_shop_id(
content_type: Option<Mime>, content_type: Option<Mime>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn update<'a, T: DataReply + 'a>( let content_type = match content_type {
shop_id: i32, Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
merchandise_list: MerchandiseList, ContentType::Bincode
api_key: Option<Uuid>, }
env: Environment, _ => ContentType::Json,
) -> Result<Box<dyn Reply + 'a>, Rejection> { };
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?; let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
let merchandise_list_with_owner_id = MerchandiseList { let merchandise_list_with_owner_id = MerchandiseList {
owner_id: Some(owner_id), owner_id: Some(owner_id),
@ -242,8 +241,16 @@ pub async fn update_by_shop_id(
let url = updated_merchandise_list let url = updated_merchandise_list
.url(&env.api_url) .url(&env.api_url)
.map_err(reject_anyhow)?; .map_err(reject_anyhow)?;
let reply = ETagReply::<Json>::from_serializable(&updated_merchandise_list) let reply: Box<dyn Reply> = match content_type {
.map_err(reject_anyhow)?; ContentType::Bincode => Box::new(
ETagReply::<Bincode>::from_serializable(&updated_merchandise_list)
.map_err(reject_anyhow)?,
),
ContentType::Json => Box::new(
ETagReply::<Json>::from_serializable(&updated_merchandise_list)
.map_err(reject_anyhow)?,
),
};
let reply = with_header(reply, "Location", url.as_str()); let reply = with_header(reply, "Location", url.as_str());
let reply = with_status(reply, StatusCode::CREATED); let reply = with_status(reply, StatusCode::CREATED);
tokio::spawn(async move { tokio::spawn(async move {
@ -263,15 +270,7 @@ pub async fn update_by_shop_id(
CACHES.list_merchandise_lists.clear().await; CACHES.list_merchandise_lists.clear().await;
CACHES.list_merchandise_lists_bin.clear().await; CACHES.list_merchandise_lists_bin.clear().await;
}); });
Ok(Box::new(reply)) Ok(reply)
}
match content_type {
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
update::<ETagReply<Bincode>>(shop_id, merchandise_list, api_key, env).await
}
_ => update::<ETagReply<Json>>(shop_id, merchandise_list, api_key, env).await,
}
} }
pub async fn delete( pub async fn delete(

6
src/handlers/mod.rs
View File

@ -64,6 +64,12 @@ pub trait DataReply: Reply + Sized {
pub struct Json {} pub struct Json {}
pub struct Bincode {} pub struct Bincode {}
#[derive(Debug, PartialEq, Eq)]
pub enum ContentType {
Json,
Bincode,
}
impl Reply for ETagReply<Json> { impl Reply for ETagReply<Json> {
fn into_response(self) -> Response { fn into_response(self) -> Response {
let mut res = Response::new(self.body.into()); let mut res = Response::new(self.body.into());

121
src/handlers/owner.rs
View File

@ -7,12 +7,14 @@ use uuid::Uuid;
use warp::reply::{with_header, with_status}; use warp::reply::{with_header, with_status};
use warp::{Rejection, Reply}; use warp::{Rejection, Reply};
use crate::caches::{Cache, CachedResponse, CACHES}; use crate::caches::CACHES;
use crate::models::{ListParams, Owner}; use crate::models::{ListParams, Owner};
use crate::problem::{reject_anyhow, unauthorized_no_api_key}; use crate::problem::{reject_anyhow, unauthorized_no_api_key};
use crate::Environment; use crate::Environment;
use super::{authenticate, check_etag, AcceptHeader, Bincode, DataReply, ETagReply, Json}; use super::{
authenticate, check_etag, AcceptHeader, Bincode, ContentType, DataReply, ETagReply, Json,
};
pub async fn get( pub async fn get(
id: i32, id: i32,
@ -20,29 +22,22 @@ pub async fn get(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
id: i32, Some(accept) if accept.accepts_bincode() => (ContentType::Bincode, &CACHES.owner_bin),
etag: Option<String>, _ => (ContentType::Json, &CACHES.owner),
env: Environment, };
cache: &'static Cache<i32, CachedResponse>,
) -> Result<Box<dyn Reply>, Rejection> {
let response = cache let response = cache
.get_response(id, || async { .get_response(id, || async {
let owner = Owner::get(&env.db, id).await?; let owner = Owner::get(&env.db, id).await?;
let reply = T::from_serializable(&owner)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(ETagReply::<Bincode>::from_serializable(&owner)?),
ContentType::Json => Box::new(ETagReply::<Json>::from_serializable(&owner)?),
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(id, etag, env, &CACHES.owner_bin).await
}
_ => get::<ETagReply<Json>>(id, etag, env, &CACHES.owner).await,
}
} }
pub async fn list( pub async fn list(
@ -51,29 +46,22 @@ pub async fn list(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
list_params: ListParams, Some(accept) if accept.accepts_bincode() => (ContentType::Bincode, &CACHES.list_owners_bin),
etag: Option<String>, _ => (ContentType::Json, &CACHES.list_owners),
env: Environment, };
cache: &'static Cache<ListParams, CachedResponse>,
) -> Result<Box<dyn Reply>, Rejection> {
let response = cache let response = cache
.get_response(list_params.clone(), || async { .get_response(list_params.clone(), || async {
let owners = Owner::list(&env.db, &list_params).await?; let owners = Owner::list(&env.db, &list_params).await?;
let reply = T::from_serializable(&owners)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(ETagReply::<Bincode>::from_serializable(&owners)?),
ContentType::Json => Box::new(ETagReply::<Json>::from_serializable(&owners)?),
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(list_params, etag, env, &CACHES.list_owners_bin).await
}
_ => get::<ETagReply<Json>>(list_params, etag, env, &CACHES.list_owners).await,
}
} }
pub async fn create( pub async fn create(
@ -84,13 +72,13 @@ pub async fn create(
content_type: Option<Mime>, content_type: Option<Mime>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn create<'a, T: DataReply + 'a>( if let Some(api_key) = api_key {
owner: Owner, let content_type = match content_type {
remote_addr: Option<SocketAddr>, Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
api_key: Uuid, ContentType::Bincode
real_ip: Option<IpNetwork>, }
env: Environment, _ => ContentType::Json,
) -> Result<Box<dyn Reply + 'a>, Rejection> { };
let owner_with_ip_and_key = match remote_addr { let owner_with_ip_and_key = match remote_addr {
Some(addr) => Owner { Some(addr) => Owner {
api_key: Some(api_key), api_key: Some(api_key),
@ -108,23 +96,21 @@ pub async fn create(
.await .await
.map_err(reject_anyhow)?; .map_err(reject_anyhow)?;
let url = saved_owner.url(&env.api_url).map_err(reject_anyhow)?; let url = saved_owner.url(&env.api_url).map_err(reject_anyhow)?;
let reply = T::from_serializable(&saved_owner).map_err(reject_anyhow)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(
ETagReply::<Bincode>::from_serializable(&saved_owner).map_err(reject_anyhow)?,
),
ContentType::Json => {
Box::new(ETagReply::<Json>::from_serializable(&saved_owner).map_err(reject_anyhow)?)
}
};
let reply = with_header(reply, "Location", url.as_str()); let reply = with_header(reply, "Location", url.as_str());
let reply = with_status(reply, StatusCode::CREATED); let reply = with_status(reply, StatusCode::CREATED);
tokio::spawn(async move { tokio::spawn(async move {
CACHES.list_owners.clear().await; CACHES.list_owners.clear().await;
CACHES.list_owners_bin.clear().await; CACHES.list_owners_bin.clear().await;
}); });
Ok(Box::new(reply)) Ok(reply)
}
if let Some(api_key) = api_key {
match content_type {
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
create::<ETagReply<Bincode>>(owner, remote_addr, api_key, real_ip, env).await
}
_ => create::<ETagReply<Json>>(owner, remote_addr, api_key, real_ip, env).await,
}
} else { } else {
Err(reject_anyhow(unauthorized_no_api_key())) Err(reject_anyhow(unauthorized_no_api_key()))
} }
@ -137,12 +123,12 @@ pub async fn update(
content_type: Option<Mime>, content_type: Option<Mime>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn update<'a, T: DataReply + 'a>( let content_type = match content_type {
id: i32, Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
owner: Owner, ContentType::Bincode
api_key: Option<Uuid>, }
env: Environment, _ => ContentType::Json,
) -> Result<Box<dyn Reply + 'a>, Rejection> { };
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?; let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
let owner_with_id = Owner { let owner_with_id = Owner {
id: Some(id), id: Some(id),
@ -153,7 +139,14 @@ pub async fn update(
.await .await
.map_err(reject_anyhow)?; .map_err(reject_anyhow)?;
let url = updated_owner.url(&env.api_url).map_err(reject_anyhow)?; let url = updated_owner.url(&env.api_url).map_err(reject_anyhow)?;
let reply = T::from_serializable(&updated_owner).map_err(reject_anyhow)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(
ETagReply::<Bincode>::from_serializable(&updated_owner).map_err(reject_anyhow)?,
),
ContentType::Json => {
Box::new(ETagReply::<Json>::from_serializable(&updated_owner).map_err(reject_anyhow)?)
}
};
let reply = with_header(reply, "Location", url.as_str()); let reply = with_header(reply, "Location", url.as_str());
let reply = with_status(reply, StatusCode::CREATED); let reply = with_status(reply, StatusCode::CREATED);
tokio::spawn(async move { tokio::spawn(async move {
@ -162,15 +155,7 @@ pub async fn update(
CACHES.list_owners.clear().await; CACHES.list_owners.clear().await;
CACHES.list_owners_bin.clear().await; CACHES.list_owners_bin.clear().await;
}); });
Ok(Box::new(reply)) Ok(reply)
}
match content_type {
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
update::<ETagReply<Bincode>>(id, owner, api_key, env).await
}
_ => update::<ETagReply<Json>>(id, owner, api_key, env).await,
}
} }
pub async fn delete( pub async fn delete(

117
src/handlers/shop.rs
View File

@ -5,12 +5,14 @@ use uuid::Uuid;
use warp::reply::{with_header, with_status}; use warp::reply::{with_header, with_status};
use warp::{Rejection, Reply}; use warp::{Rejection, Reply};
use crate::caches::{Cache, CachedResponse, CACHES}; use crate::caches::CACHES;
use crate::models::{InteriorRefList, ListParams, MerchandiseList, Shop}; use crate::models::{InteriorRefList, ListParams, MerchandiseList, Shop};
use crate::problem::reject_anyhow; use crate::problem::reject_anyhow;
use crate::Environment; use crate::Environment;
use super::{authenticate, check_etag, AcceptHeader, Bincode, DataReply, ETagReply, Json}; use super::{
authenticate, check_etag, AcceptHeader, Bincode, ContentType, DataReply, ETagReply, Json,
};
pub async fn get( pub async fn get(
id: i32, id: i32,
@ -18,29 +20,22 @@ pub async fn get(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
id: i32, Some(accept) if accept.accepts_bincode() => (ContentType::Bincode, &CACHES.shop_bin),
etag: Option<String>, _ => (ContentType::Json, &CACHES.shop),
env: Environment, };
cache: &'static Cache<i32, CachedResponse>,
) -> Result<Box<dyn Reply>, Rejection> {
let response = cache let response = cache
.get_response(id, || async { .get_response(id, || async {
let shop = Shop::get(&env.db, id).await?; let shop = Shop::get(&env.db, id).await?;
let reply = T::from_serializable(&shop)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(ETagReply::<Bincode>::from_serializable(&shop)?),
ContentType::Json => Box::new(ETagReply::<Json>::from_serializable(&shop)?),
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(id, etag, env, &CACHES.shop_bin).await
}
_ => get::<ETagReply<Json>>(id, etag, env, &CACHES.shop).await,
}
} }
pub async fn list( pub async fn list(
@ -49,29 +44,22 @@ pub async fn list(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
list_params: ListParams, Some(accept) if accept.accepts_bincode() => (ContentType::Bincode, &CACHES.list_shops_bin),
etag: Option<String>, _ => (ContentType::Json, &CACHES.list_shops),
env: Environment, };
cache: &'static Cache<ListParams, CachedResponse>,
) -> Result<Box<dyn Reply>, Rejection> {
let response = cache let response = cache
.get_response(list_params.clone(), || async { .get_response(list_params.clone(), || async {
let shops = Shop::list(&env.db, &list_params).await?; let shops = Shop::list(&env.db, &list_params).await?;
let reply = T::from_serializable(&shops)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(ETagReply::<Bincode>::from_serializable(&shops)?),
ContentType::Json => Box::new(ETagReply::<Json>::from_serializable(&shops)?),
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(list_params, etag, env, &CACHES.list_shops_bin).await
}
_ => get::<ETagReply<Json>>(list_params, etag, env, &CACHES.list_shops).await,
}
} }
pub async fn create( pub async fn create(
@ -80,11 +68,12 @@ pub async fn create(
content_type: Option<Mime>, content_type: Option<Mime>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn create<'a, T: DataReply + 'a>( let content_type = match content_type {
shop: Shop, Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
api_key: Option<Uuid>, ContentType::Bincode
env: Environment, }
) -> Result<Box<dyn Reply + 'a>, Rejection> { _ => ContentType::Json,
};
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?; let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
let shop_with_owner_id = Shop { let shop_with_owner_id = Shop {
owner_id: Some(owner_id), owner_id: Some(owner_id),
@ -125,22 +114,21 @@ pub async fn create(
} }
let url = saved_shop.url(&env.api_url).map_err(reject_anyhow)?; let url = saved_shop.url(&env.api_url).map_err(reject_anyhow)?;
let reply = T::from_serializable(&saved_shop).map_err(reject_anyhow)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => {
Box::new(ETagReply::<Bincode>::from_serializable(&saved_shop).map_err(reject_anyhow)?)
}
ContentType::Json => {
Box::new(ETagReply::<Json>::from_serializable(&saved_shop).map_err(reject_anyhow)?)
}
};
let reply = with_header(reply, "Location", url.as_str()); let reply = with_header(reply, "Location", url.as_str());
let reply = with_status(reply, StatusCode::CREATED); let reply = with_status(reply, StatusCode::CREATED);
tokio::spawn(async move { tokio::spawn(async move {
CACHES.list_shops.clear().await; CACHES.list_shops.clear().await;
CACHES.list_shops_bin.clear().await; CACHES.list_shops_bin.clear().await;
}); });
Ok(Box::new(reply)) Ok(reply)
}
match content_type {
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
create::<ETagReply<Bincode>>(shop, api_key, env).await
}
_ => create::<ETagReply<Json>>(shop, api_key, env).await,
}
} }
pub async fn update( pub async fn update(
@ -150,12 +138,12 @@ pub async fn update(
content_type: Option<Mime>, content_type: Option<Mime>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn update<'a, T: DataReply + 'a>( let content_type = match content_type {
id: i32, Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
shop: Shop, ContentType::Bincode
api_key: Option<Uuid>, }
env: Environment, _ => ContentType::Json,
) -> Result<Box<dyn Reply + 'a>, Rejection> { };
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?; let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
let shop_with_id_and_owner_id = if shop.owner_id.is_some() { let shop_with_id_and_owner_id = if shop.owner_id.is_some() {
// allows an owner to transfer ownership of shop to another owner // allows an owner to transfer ownership of shop to another owner
@ -175,7 +163,14 @@ pub async fn update(
.await .await
.map_err(reject_anyhow)?; .map_err(reject_anyhow)?;
let url = updated_shop.url(&env.api_url).map_err(reject_anyhow)?; let url = updated_shop.url(&env.api_url).map_err(reject_anyhow)?;
let reply = T::from_serializable(&updated_shop).map_err(reject_anyhow)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => {
Box::new(ETagReply::<Bincode>::from_serializable(&updated_shop).map_err(reject_anyhow)?)
}
ContentType::Json => {
Box::new(ETagReply::<Json>::from_serializable(&updated_shop).map_err(reject_anyhow)?)
}
};
let reply = with_header(reply, "Location", url.as_str()); let reply = with_header(reply, "Location", url.as_str());
let reply = with_status(reply, StatusCode::CREATED); let reply = with_status(reply, StatusCode::CREATED);
tokio::spawn(async move { tokio::spawn(async move {
@ -184,15 +179,7 @@ pub async fn update(
CACHES.list_shops.clear().await; CACHES.list_shops.clear().await;
CACHES.list_shops_bin.clear().await; CACHES.list_shops_bin.clear().await;
}); });
Ok(Box::new(reply)) Ok(reply)
}
match content_type {
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
update::<ETagReply<Bincode>>(id, shop, api_key, env).await
}
_ => update::<ETagReply<Json>>(id, shop, api_key, env).await,
}
} }
pub async fn delete( pub async fn delete(

142
src/handlers/transaction.rs
View File

@ -5,12 +5,14 @@ use uuid::Uuid;
use warp::reply::{with_header, with_status}; use warp::reply::{with_header, with_status};
use warp::{Rejection, Reply}; use warp::{Rejection, Reply};
use crate::caches::{Cache, CachedResponse, CACHES}; use crate::caches::CACHES;
use crate::models::{ListParams, MerchandiseList, Transaction}; use crate::models::{ListParams, MerchandiseList, Transaction};
use crate::problem::reject_anyhow; use crate::problem::reject_anyhow;
use crate::Environment; use crate::Environment;
use super::{authenticate, check_etag, AcceptHeader, Bincode, DataReply, ETagReply, Json}; use super::{
authenticate, check_etag, AcceptHeader, Bincode, ContentType, DataReply, ETagReply, Json,
};
pub async fn get( pub async fn get(
id: i32, id: i32,
@ -18,29 +20,24 @@ pub async fn get(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
id: i32, Some(accept) if accept.accepts_bincode() => (ContentType::Bincode, &CACHES.transaction_bin),
etag: Option<String>, _ => (ContentType::Json, &CACHES.transaction),
env: Environment, };
cache: &'static Cache<i32, CachedResponse>,
) -> Result<Box<dyn Reply>, Rejection> {
let response = cache let response = cache
.get_response(id, || async { .get_response(id, || async {
let transaction = Transaction::get(&env.db, id).await?; let transaction = Transaction::get(&env.db, id).await?;
let reply = T::from_serializable(&transaction)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => {
Box::new(ETagReply::<Bincode>::from_serializable(&transaction)?)
}
ContentType::Json => Box::new(ETagReply::<Json>::from_serializable(&transaction)?),
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(id, etag, env, &CACHES.transaction_bin).await
}
_ => get::<ETagReply<Json>>(id, etag, env, &CACHES.transaction).await,
}
} }
pub async fn list( pub async fn list(
@ -49,29 +46,26 @@ pub async fn list(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
list_params: ListParams, Some(accept) if accept.accepts_bincode() => {
etag: Option<String>, (ContentType::Bincode, &CACHES.list_transactions_bin)
env: Environment, }
cache: &'static Cache<ListParams, CachedResponse>, _ => (ContentType::Json, &CACHES.list_transactions),
) -> Result<Box<dyn Reply>, Rejection> { };
let response = cache let response = cache
.get_response(list_params.clone(), || async { .get_response(list_params.clone(), || async {
let transactions = Transaction::list(&env.db, &list_params).await?; let transactions = Transaction::list(&env.db, &list_params).await?;
let reply = T::from_serializable(&transactions)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => {
Box::new(ETagReply::<Bincode>::from_serializable(&transactions)?)
}
ContentType::Json => Box::new(ETagReply::<Json>::from_serializable(&transactions)?),
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(list_params, etag, env, &CACHES.list_transactions_bin).await
}
_ => get::<ETagReply<Json>>(list_params, etag, env, &CACHES.list_transactions).await,
}
} }
pub async fn list_by_shop_id( pub async fn list_by_shop_id(
@ -81,47 +75,27 @@ pub async fn list_by_shop_id(
accept: Option<AcceptHeader>, accept: Option<AcceptHeader>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn get<T: DataReply>( let (content_type, cache) = match accept {
shop_id: i32, Some(accept) if accept.accepts_bincode() => (
list_params: ListParams, ContentType::Bincode,
etag: Option<String>, &CACHES.list_transactions_by_shop_id_bin,
env: Environment, ),
cache: &'static Cache<(i32, ListParams), CachedResponse>, _ => (ContentType::Json, &CACHES.list_transactions_by_shop_id),
) -> Result<Box<dyn Reply>, Rejection> { };
let response = cache let response = cache
.get_response((shop_id, list_params.clone()), || async { .get_response((shop_id, list_params.clone()), || async {
let transactions = let transactions = Transaction::list_by_shop_id(&env.db, shop_id, &list_params).await?;
Transaction::list_by_shop_id(&env.db, shop_id, &list_params).await?; let reply: Box<dyn Reply> = match content_type {
let reply = T::from_serializable(&transactions)?; ContentType::Bincode => {
Box::new(ETagReply::<Bincode>::from_serializable(&transactions)?)
}
ContentType::Json => Box::new(ETagReply::<Json>::from_serializable(&transactions)?),
};
let reply = with_status(reply, StatusCode::OK); let reply = with_status(reply, StatusCode::OK);
Ok(reply) Ok(reply)
}) })
.await?; .await?;
Ok(Box::new(check_etag(etag, response))) Ok(check_etag(etag, response))
}
match accept {
Some(accept) if accept.accepts_bincode() => {
get::<ETagReply<Bincode>>(
shop_id,
list_params,
etag,
env,
&CACHES.list_transactions_by_shop_id_bin,
)
.await
}
_ => {
get::<ETagReply<Json>>(
shop_id,
list_params,
etag,
env,
&CACHES.list_transactions_by_shop_id,
)
.await
}
}
} }
pub async fn create( pub async fn create(
@ -130,11 +104,12 @@ pub async fn create(
content_type: Option<Mime>, content_type: Option<Mime>,
env: Environment, env: Environment,
) -> Result<impl Reply, Rejection> { ) -> Result<impl Reply, Rejection> {
async fn create<'a, T: DataReply + 'a>( let content_type = match content_type {
transaction: Transaction, Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
api_key: Option<Uuid>, ContentType::Bincode
env: Environment, }
) -> Result<Box<dyn Reply + 'a>, Rejection> { _ => ContentType::Json,
};
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?; let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
let transaction_with_owner_id = Transaction { let transaction_with_owner_id = Transaction {
owner_id: Some(owner_id), owner_id: Some(owner_id),
@ -170,7 +145,14 @@ pub async fn create(
.await .await
.map_err(|error| reject_anyhow(anyhow!(error)))?; .map_err(|error| reject_anyhow(anyhow!(error)))?;
let url = saved_transaction.url(&env.api_url).map_err(reject_anyhow)?; let url = saved_transaction.url(&env.api_url).map_err(reject_anyhow)?;
let reply = T::from_serializable(&saved_transaction).map_err(reject_anyhow)?; let reply: Box<dyn Reply> = match content_type {
ContentType::Bincode => Box::new(
ETagReply::<Bincode>::from_serializable(&saved_transaction).map_err(reject_anyhow)?,
),
ContentType::Json => Box::new(
ETagReply::<Json>::from_serializable(&saved_transaction).map_err(reject_anyhow)?,
),
};
let reply = with_header(reply, "Location", url.as_str()); let reply = with_header(reply, "Location", url.as_str());
let reply = with_status(reply, StatusCode::CREATED); let reply = with_status(reply, StatusCode::CREATED);
tokio::spawn(async move { tokio::spawn(async move {
@ -195,15 +177,7 @@ pub async fn create(
CACHES.list_merchandise_lists.clear().await; CACHES.list_merchandise_lists.clear().await;
CACHES.list_merchandise_lists_bin.clear().await; CACHES.list_merchandise_lists_bin.clear().await;
}); });
Ok(Box::new(reply)) Ok(reply)
}
match content_type {
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
create::<ETagReply<Bincode>>(transaction, api_key, env).await
}
_ => create::<ETagReply<Json>>(transaction, api_key, env).await,
}
} }
pub async fn delete( pub async fn delete(