Simplify handler content_type switching
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:
parent
e0cc81c97e
commit
377a260a2f
@ -5,12 +5,14 @@ use uuid::Uuid;
|
||||
use warp::reply::{with_header, with_status};
|
||||
use warp::{Rejection, Reply};
|
||||
|
||||
use crate::caches::{Cache, CachedResponse, CACHES};
|
||||
use crate::caches::CACHES;
|
||||
use crate::models::{InteriorRefList, ListParams};
|
||||
use crate::problem::reject_anyhow;
|
||||
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(
|
||||
id: i32,
|
||||
@ -18,29 +20,28 @@ pub async fn get(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
id: i32,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<i32, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => {
|
||||
(ContentType::Bincode, &CACHES.interior_ref_list_bin)
|
||||
}
|
||||
_ => (ContentType::Json, &CACHES.interior_ref_list),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(id, || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn get_by_shop_id(
|
||||
@ -49,30 +50,29 @@ pub async fn get_by_shop_id(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
shop_id: i32,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<i32, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => (
|
||||
ContentType::Bincode,
|
||||
&CACHES.interior_ref_list_by_shop_id_bin,
|
||||
),
|
||||
_ => (ContentType::Json, &CACHES.interior_ref_list_by_shop_id),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(shop_id, || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn list(
|
||||
@ -81,31 +81,29 @@ pub async fn list(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
list_params: ListParams,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<ListParams, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => {
|
||||
(ContentType::Bincode, &CACHES.list_interior_ref_lists_bin)
|
||||
}
|
||||
_ => (ContentType::Json, &CACHES.list_interior_ref_lists),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(list_params.clone(), || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn create(
|
||||
@ -114,11 +112,12 @@ pub async fn create(
|
||||
content_type: Option<Mime>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn create<'a, T: DataReply + 'a>(
|
||||
interior_ref_list: InteriorRefList,
|
||||
api_key: Option<Uuid>,
|
||||
env: Environment,
|
||||
) -> Result<Box<dyn Reply + 'a>, Rejection> {
|
||||
let content_type = match content_type {
|
||||
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
|
||||
ContentType::Bincode
|
||||
}
|
||||
_ => ContentType::Json,
|
||||
};
|
||||
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
|
||||
let ref_list_with_owner_id = InteriorRefList {
|
||||
owner_id: Some(owner_id),
|
||||
@ -131,8 +130,16 @@ pub async fn create(
|
||||
let url = saved_interior_ref_list
|
||||
.url(&env.api_url)
|
||||
.map_err(reject_anyhow)?;
|
||||
let reply = ETagReply::<Json>::from_serializable(&saved_interior_ref_list)
|
||||
.map_err(reject_anyhow)?;
|
||||
let reply: Box<dyn Reply> = match content_type {
|
||||
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_status(reply, StatusCode::CREATED);
|
||||
tokio::spawn(async move {
|
||||
@ -147,15 +154,7 @@ pub async fn create(
|
||||
.delete_response(saved_interior_ref_list.shop_id)
|
||||
.await;
|
||||
});
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
pub async fn update(
|
||||
@ -165,12 +164,12 @@ pub async fn update(
|
||||
content_type: Option<Mime>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn update<'a, T: DataReply + 'a>(
|
||||
id: i32,
|
||||
interior_ref_list: InteriorRefList,
|
||||
api_key: Option<Uuid>,
|
||||
env: Environment,
|
||||
) -> Result<Box<dyn Reply + 'a>, Rejection> {
|
||||
let content_type = match content_type {
|
||||
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
|
||||
ContentType::Bincode
|
||||
}
|
||||
_ => ContentType::Json,
|
||||
};
|
||||
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() {
|
||||
InteriorRefList {
|
||||
@ -191,7 +190,16 @@ pub async fn update(
|
||||
let url = updated_interior_ref_list
|
||||
.url(&env.api_url)
|
||||
.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_status(reply, StatusCode::CREATED);
|
||||
tokio::spawn(async move {
|
||||
@ -208,15 +216,7 @@ pub async fn update(
|
||||
CACHES.list_interior_ref_lists.clear().await;
|
||||
CACHES.list_interior_ref_lists_bin.clear().await;
|
||||
});
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
pub async fn update_by_shop_id(
|
||||
@ -226,12 +226,12 @@ pub async fn update_by_shop_id(
|
||||
content_type: Option<Mime>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn update<'a, T: DataReply + 'a>(
|
||||
shop_id: i32,
|
||||
interior_ref_list: InteriorRefList,
|
||||
api_key: Option<Uuid>,
|
||||
env: Environment,
|
||||
) -> Result<Box<dyn Reply + 'a>, Rejection> {
|
||||
let content_type = match content_type {
|
||||
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
|
||||
ContentType::Bincode
|
||||
}
|
||||
_ => ContentType::Json,
|
||||
};
|
||||
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
|
||||
let interior_ref_list_with_owner_id = InteriorRefList {
|
||||
owner_id: Some(owner_id),
|
||||
@ -244,7 +244,16 @@ pub async fn update_by_shop_id(
|
||||
let url = updated_interior_ref_list
|
||||
.url(&env.api_url)
|
||||
.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_status(reply, StatusCode::CREATED);
|
||||
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_bin.clear().await;
|
||||
});
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
pub async fn delete(
|
||||
|
||||
@ -5,12 +5,14 @@ use uuid::Uuid;
|
||||
use warp::reply::{with_header, with_status};
|
||||
use warp::{Rejection, Reply};
|
||||
|
||||
use crate::caches::{Cache, CachedResponse, CACHES};
|
||||
use crate::caches::CACHES;
|
||||
use crate::models::{ListParams, MerchandiseList};
|
||||
use crate::problem::reject_anyhow;
|
||||
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(
|
||||
id: i32,
|
||||
@ -18,29 +20,28 @@ pub async fn get(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
id: i32,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<i32, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => {
|
||||
(ContentType::Bincode, &CACHES.merchandise_list_bin)
|
||||
}
|
||||
_ => (ContentType::Json, &CACHES.merchandise_list),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(id, || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn get_by_shop_id(
|
||||
@ -49,30 +50,28 @@ pub async fn get_by_shop_id(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
shop_id: i32,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<i32, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => {
|
||||
(ContentType::Bincode, &CACHES.merchandise_list_bin)
|
||||
}
|
||||
_ => (ContentType::Json, &CACHES.merchandise_list),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(shop_id, || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn list(
|
||||
@ -81,30 +80,28 @@ pub async fn list(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
list_params: ListParams,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<ListParams, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => {
|
||||
(ContentType::Bincode, &CACHES.list_merchandise_lists_bin)
|
||||
}
|
||||
_ => (ContentType::Json, &CACHES.list_merchandise_lists),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(list_params.clone(), || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn create(
|
||||
@ -113,11 +110,12 @@ pub async fn create(
|
||||
content_type: Option<Mime>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn create<'a, T: DataReply + 'a>(
|
||||
merchandise_list: MerchandiseList,
|
||||
api_key: Option<Uuid>,
|
||||
env: Environment,
|
||||
) -> Result<Box<dyn Reply + 'a>, Rejection> {
|
||||
let content_type = match content_type {
|
||||
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
|
||||
ContentType::Bincode
|
||||
}
|
||||
_ => ContentType::Json,
|
||||
};
|
||||
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
|
||||
let ref_list_with_owner_id = MerchandiseList {
|
||||
owner_id: Some(owner_id),
|
||||
@ -130,7 +128,15 @@ pub async fn create(
|
||||
let url = saved_merchandise_list
|
||||
.url(&env.api_url)
|
||||
.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_status(reply, StatusCode::CREATED);
|
||||
tokio::spawn(async move {
|
||||
@ -145,15 +151,7 @@ pub async fn create(
|
||||
.delete_response(saved_merchandise_list.shop_id)
|
||||
.await;
|
||||
});
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
pub async fn update(
|
||||
@ -163,12 +161,12 @@ pub async fn update(
|
||||
content_type: Option<Mime>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn update<'a, T: DataReply + 'a>(
|
||||
id: i32,
|
||||
merchandise_list: MerchandiseList,
|
||||
api_key: Option<Uuid>,
|
||||
env: Environment,
|
||||
) -> Result<Box<dyn Reply + 'a>, Rejection> {
|
||||
let content_type = match content_type {
|
||||
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
|
||||
ContentType::Bincode
|
||||
}
|
||||
_ => ContentType::Json,
|
||||
};
|
||||
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() {
|
||||
MerchandiseList {
|
||||
@ -189,7 +187,16 @@ pub async fn update(
|
||||
let url = updated_merchandise_list
|
||||
.url(&env.api_url)
|
||||
.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_status(reply, StatusCode::CREATED);
|
||||
tokio::spawn(async move {
|
||||
@ -206,15 +213,7 @@ pub async fn update(
|
||||
CACHES.list_merchandise_lists.clear().await;
|
||||
CACHES.list_merchandise_lists_bin.clear().await;
|
||||
});
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
pub async fn update_by_shop_id(
|
||||
@ -224,12 +223,12 @@ pub async fn update_by_shop_id(
|
||||
content_type: Option<Mime>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn update<'a, T: DataReply + 'a>(
|
||||
shop_id: i32,
|
||||
merchandise_list: MerchandiseList,
|
||||
api_key: Option<Uuid>,
|
||||
env: Environment,
|
||||
) -> Result<Box<dyn Reply + 'a>, Rejection> {
|
||||
let content_type = match content_type {
|
||||
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
|
||||
ContentType::Bincode
|
||||
}
|
||||
_ => ContentType::Json,
|
||||
};
|
||||
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
|
||||
let merchandise_list_with_owner_id = MerchandiseList {
|
||||
owner_id: Some(owner_id),
|
||||
@ -242,8 +241,16 @@ pub async fn update_by_shop_id(
|
||||
let url = updated_merchandise_list
|
||||
.url(&env.api_url)
|
||||
.map_err(reject_anyhow)?;
|
||||
let reply = ETagReply::<Json>::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_status(reply, StatusCode::CREATED);
|
||||
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_bin.clear().await;
|
||||
});
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
pub async fn delete(
|
||||
|
||||
@ -64,6 +64,12 @@ pub trait DataReply: Reply + Sized {
|
||||
pub struct Json {}
|
||||
pub struct Bincode {}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub enum ContentType {
|
||||
Json,
|
||||
Bincode,
|
||||
}
|
||||
|
||||
impl Reply for ETagReply<Json> {
|
||||
fn into_response(self) -> Response {
|
||||
let mut res = Response::new(self.body.into());
|
||||
|
||||
@ -7,12 +7,14 @@ use uuid::Uuid;
|
||||
use warp::reply::{with_header, with_status};
|
||||
use warp::{Rejection, Reply};
|
||||
|
||||
use crate::caches::{Cache, CachedResponse, CACHES};
|
||||
use crate::caches::CACHES;
|
||||
use crate::models::{ListParams, Owner};
|
||||
use crate::problem::{reject_anyhow, unauthorized_no_api_key};
|
||||
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(
|
||||
id: i32,
|
||||
@ -20,29 +22,22 @@ pub async fn get(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
id: i32,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<i32, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => (ContentType::Bincode, &CACHES.owner_bin),
|
||||
_ => (ContentType::Json, &CACHES.owner),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(id, || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn list(
|
||||
@ -51,29 +46,22 @@ pub async fn list(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
list_params: ListParams,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<ListParams, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => (ContentType::Bincode, &CACHES.list_owners_bin),
|
||||
_ => (ContentType::Json, &CACHES.list_owners),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(list_params.clone(), || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn create(
|
||||
@ -84,13 +72,13 @@ pub async fn create(
|
||||
content_type: Option<Mime>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn create<'a, T: DataReply + 'a>(
|
||||
owner: Owner,
|
||||
remote_addr: Option<SocketAddr>,
|
||||
api_key: Uuid,
|
||||
real_ip: Option<IpNetwork>,
|
||||
env: Environment,
|
||||
) -> Result<Box<dyn Reply + 'a>, Rejection> {
|
||||
if let Some(api_key) = api_key {
|
||||
let content_type = match content_type {
|
||||
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
|
||||
ContentType::Bincode
|
||||
}
|
||||
_ => ContentType::Json,
|
||||
};
|
||||
let owner_with_ip_and_key = match remote_addr {
|
||||
Some(addr) => Owner {
|
||||
api_key: Some(api_key),
|
||||
@ -108,23 +96,21 @@ pub async fn create(
|
||||
.await
|
||||
.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_status(reply, StatusCode::CREATED);
|
||||
tokio::spawn(async move {
|
||||
CACHES.list_owners.clear().await;
|
||||
CACHES.list_owners_bin.clear().await;
|
||||
});
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(reply)
|
||||
} else {
|
||||
Err(reject_anyhow(unauthorized_no_api_key()))
|
||||
}
|
||||
@ -137,12 +123,12 @@ pub async fn update(
|
||||
content_type: Option<Mime>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn update<'a, T: DataReply + 'a>(
|
||||
id: i32,
|
||||
owner: Owner,
|
||||
api_key: Option<Uuid>,
|
||||
env: Environment,
|
||||
) -> Result<Box<dyn Reply + 'a>, Rejection> {
|
||||
let content_type = match content_type {
|
||||
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
|
||||
ContentType::Bincode
|
||||
}
|
||||
_ => ContentType::Json,
|
||||
};
|
||||
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
|
||||
let owner_with_id = Owner {
|
||||
id: Some(id),
|
||||
@ -153,7 +139,14 @@ pub async fn update(
|
||||
.await
|
||||
.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_status(reply, StatusCode::CREATED);
|
||||
tokio::spawn(async move {
|
||||
@ -162,15 +155,7 @@ pub async fn update(
|
||||
CACHES.list_owners.clear().await;
|
||||
CACHES.list_owners_bin.clear().await;
|
||||
});
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
pub async fn delete(
|
||||
|
||||
@ -5,12 +5,14 @@ use uuid::Uuid;
|
||||
use warp::reply::{with_header, with_status};
|
||||
use warp::{Rejection, Reply};
|
||||
|
||||
use crate::caches::{Cache, CachedResponse, CACHES};
|
||||
use crate::caches::CACHES;
|
||||
use crate::models::{InteriorRefList, ListParams, MerchandiseList, Shop};
|
||||
use crate::problem::reject_anyhow;
|
||||
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(
|
||||
id: i32,
|
||||
@ -18,29 +20,22 @@ pub async fn get(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
id: i32,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<i32, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => (ContentType::Bincode, &CACHES.shop_bin),
|
||||
_ => (ContentType::Json, &CACHES.shop),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(id, || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn list(
|
||||
@ -49,29 +44,22 @@ pub async fn list(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
list_params: ListParams,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<ListParams, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => (ContentType::Bincode, &CACHES.list_shops_bin),
|
||||
_ => (ContentType::Json, &CACHES.list_shops),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(list_params.clone(), || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn create(
|
||||
@ -80,11 +68,12 @@ pub async fn create(
|
||||
content_type: Option<Mime>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn create<'a, T: DataReply + 'a>(
|
||||
shop: Shop,
|
||||
api_key: Option<Uuid>,
|
||||
env: Environment,
|
||||
) -> Result<Box<dyn Reply + 'a>, Rejection> {
|
||||
let content_type = match content_type {
|
||||
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
|
||||
ContentType::Bincode
|
||||
}
|
||||
_ => ContentType::Json,
|
||||
};
|
||||
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
|
||||
let shop_with_owner_id = Shop {
|
||||
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 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_status(reply, StatusCode::CREATED);
|
||||
tokio::spawn(async move {
|
||||
CACHES.list_shops.clear().await;
|
||||
CACHES.list_shops_bin.clear().await;
|
||||
});
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
pub async fn update(
|
||||
@ -150,12 +138,12 @@ pub async fn update(
|
||||
content_type: Option<Mime>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn update<'a, T: DataReply + 'a>(
|
||||
id: i32,
|
||||
shop: Shop,
|
||||
api_key: Option<Uuid>,
|
||||
env: Environment,
|
||||
) -> Result<Box<dyn Reply + 'a>, Rejection> {
|
||||
let content_type = match content_type {
|
||||
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
|
||||
ContentType::Bincode
|
||||
}
|
||||
_ => ContentType::Json,
|
||||
};
|
||||
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() {
|
||||
// allows an owner to transfer ownership of shop to another owner
|
||||
@ -175,7 +163,14 @@ pub async fn update(
|
||||
.await
|
||||
.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_status(reply, StatusCode::CREATED);
|
||||
tokio::spawn(async move {
|
||||
@ -184,15 +179,7 @@ pub async fn update(
|
||||
CACHES.list_shops.clear().await;
|
||||
CACHES.list_shops_bin.clear().await;
|
||||
});
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
pub async fn delete(
|
||||
|
||||
@ -5,12 +5,14 @@ use uuid::Uuid;
|
||||
use warp::reply::{with_header, with_status};
|
||||
use warp::{Rejection, Reply};
|
||||
|
||||
use crate::caches::{Cache, CachedResponse, CACHES};
|
||||
use crate::caches::CACHES;
|
||||
use crate::models::{ListParams, MerchandiseList, Transaction};
|
||||
use crate::problem::reject_anyhow;
|
||||
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(
|
||||
id: i32,
|
||||
@ -18,29 +20,24 @@ pub async fn get(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
id: i32,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<i32, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => (ContentType::Bincode, &CACHES.transaction_bin),
|
||||
_ => (ContentType::Json, &CACHES.transaction),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(id, || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn list(
|
||||
@ -49,29 +46,26 @@ pub async fn list(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
list_params: ListParams,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<ListParams, CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => {
|
||||
(ContentType::Bincode, &CACHES.list_transactions_bin)
|
||||
}
|
||||
_ => (ContentType::Json, &CACHES.list_transactions),
|
||||
};
|
||||
let response = cache
|
||||
.get_response(list_params.clone(), || async {
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn list_by_shop_id(
|
||||
@ -81,47 +75,27 @@ pub async fn list_by_shop_id(
|
||||
accept: Option<AcceptHeader>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn get<T: DataReply>(
|
||||
shop_id: i32,
|
||||
list_params: ListParams,
|
||||
etag: Option<String>,
|
||||
env: Environment,
|
||||
cache: &'static Cache<(i32, ListParams), CachedResponse>,
|
||||
) -> Result<Box<dyn Reply>, Rejection> {
|
||||
let (content_type, cache) = match accept {
|
||||
Some(accept) if accept.accepts_bincode() => (
|
||||
ContentType::Bincode,
|
||||
&CACHES.list_transactions_by_shop_id_bin,
|
||||
),
|
||||
_ => (ContentType::Json, &CACHES.list_transactions_by_shop_id),
|
||||
};
|
||||
let response = cache
|
||||
.get_response((shop_id, list_params.clone()), || async {
|
||||
let transactions =
|
||||
Transaction::list_by_shop_id(&env.db, shop_id, &list_params).await?;
|
||||
let reply = T::from_serializable(&transactions)?;
|
||||
let transactions = Transaction::list_by_shop_id(&env.db, shop_id, &list_params).await?;
|
||||
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);
|
||||
Ok(reply)
|
||||
})
|
||||
.await?;
|
||||
Ok(Box::new(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
|
||||
}
|
||||
}
|
||||
Ok(check_etag(etag, response))
|
||||
}
|
||||
|
||||
pub async fn create(
|
||||
@ -130,11 +104,12 @@ pub async fn create(
|
||||
content_type: Option<Mime>,
|
||||
env: Environment,
|
||||
) -> Result<impl Reply, Rejection> {
|
||||
async fn create<'a, T: DataReply + 'a>(
|
||||
transaction: Transaction,
|
||||
api_key: Option<Uuid>,
|
||||
env: Environment,
|
||||
) -> Result<Box<dyn Reply + 'a>, Rejection> {
|
||||
let content_type = match content_type {
|
||||
Some(content_type) if content_type == mime::APPLICATION_OCTET_STREAM => {
|
||||
ContentType::Bincode
|
||||
}
|
||||
_ => ContentType::Json,
|
||||
};
|
||||
let owner_id = authenticate(&env, api_key).await.map_err(reject_anyhow)?;
|
||||
let transaction_with_owner_id = Transaction {
|
||||
owner_id: Some(owner_id),
|
||||
@ -170,7 +145,14 @@ pub async fn create(
|
||||
.await
|
||||
.map_err(|error| reject_anyhow(anyhow!(error)))?;
|
||||
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_status(reply, StatusCode::CREATED);
|
||||
tokio::spawn(async move {
|
||||
@ -195,15 +177,7 @@ pub async fn create(
|
||||
CACHES.list_merchandise_lists.clear().await;
|
||||
CACHES.list_merchandise_lists_bin.clear().await;
|
||||
});
|
||||
Ok(Box::new(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,
|
||||
}
|
||||
Ok(reply)
|
||||
}
|
||||
|
||||
pub async fn delete(
|
||||
|
||||
Loading…
Reference in New Issue
Block a user