add: products api

crates/app/src/routes/api/v1/letters.rs

@@ -187,6 +187,13 @@ pub async fn create_request(
                 }
             }
 
+            // check if we're fulfilling a coin transfer
+            if props.transfer_id != 0 {
+                if let Err(e) = data.apply_transfer(props.transfer_id).await {
+                    return Json(e.into());
+                }
+            }
+
             // ...
             Json(ApiReturn {
                 ok: true,

crates/app/src/routes/api/v1/mod.rs

@@ -4,16 +4,17 @@ pub mod auth;
 pub mod channels;
 pub mod communities;
 pub mod domains;
-pub mod economy;
 pub mod journals;
 pub mod letters;
 pub mod notes;
 pub mod notifications;
+pub mod products;
 pub mod reactions;
 pub mod reports;
 pub mod requests;
 pub mod services;
 pub mod stacks;
+pub mod transfers;
 pub mod uploads;
 pub mod util;
 
@@ -30,6 +31,7 @@ use tetratto_core::model::{
         PollOption, PostContext,
     },
     communities_permissions::CommunityPermission,
+    economy::ProductFulfillmentMethod,
     journals::JournalPrivacyPermission,
     littleweb::{DomainData, DomainTld, ServiceFsEntry},
     oauth::AppScope,
@@ -706,8 +708,27 @@ pub fn routes() -> Router {
         .route("/letters/{id}/read", post(letters::add_read_request))
         .route("/letters/sent", get(letters::list_sent_request))
         .route("/letters/received", get(letters::list_received_request))
-        // economy
-        .route("/transfers", post(economy::create_request))
+        // transfers
+        .route("/transfers", post(transfers::create_request))
+        // products
+        .route("/products", post(products::create_request))
+        .route("/products/{id}", delete(products::delete_request))
+        .route("/products/{id}/buy", post(products::buy_request))
+        .route("/products/{id}/title", post(products::update_title_request))
+        .route(
+            "/products/{id}/description",
+            post(products::update_description_request),
+        )
+        .route(
+            "/products/{id}/on_sale",
+            post(products::update_on_sale_request),
+        )
+        .route("/products/{id}/price", post(products::update_price_request))
+        .route(
+            "/products/{id}/method",
+            post(products::update_method_request),
+        )
+        .route("/products/{id}/stock", post(products::update_stock_request))
 }
 
 pub fn lw_routes() -> Router {
@@ -1214,6 +1235,8 @@ pub struct CreateLetter {
     pub subject: String,
     pub content: String,
     pub replying_to: String,
+    #[serde(default)]
+    pub transfer_id: usize,
 }
 
 #[derive(Deserialize)]
@@ -1221,3 +1244,39 @@ pub struct CreateCoinTransfer {
     pub receiver: usize,
     pub amount: i32,
 }
+
+#[derive(Deserialize)]
+pub struct CreateProduct {
+    pub title: String,
+    pub description: String,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateProductTitle {
+    pub title: String,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateProductDescription {
+    pub description: String,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateProductOnSale {
+    pub on_sale: bool,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateProductPrice {
+    pub price: i32,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateProductMethod {
+    pub method: ProductFulfillmentMethod,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateProductStock {
+    pub stock: i32,
+}

crates/app/src/routes/api/v1/products.rs

@@ -0,0 +1,225 @@
+use crate::{get_user_from_token, State, cookie::CookieJar};
+use axum::{extract::Path, response::IntoResponse, Extension, Json};
+use tetratto_core::model::{economy::Product, oauth, ApiReturn, Error};
+use super::{
+    CreateProduct, UpdateProductDescription, UpdateProductMethod, UpdateProductOnSale,
+    UpdateProductPrice, UpdateProductStock, UpdateProductTitle,
+};
+
+pub async fn create_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Json(req): Json<CreateProduct>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data, oauth::AppScope::UserCreateProducts) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data
+        .create_product(Product::new(user.id, req.title, req.description))
+        .await
+    {
+        Ok(s) => Json(ApiReturn {
+            ok: true,
+            message: "Product created".to_string(),
+            payload: s.id.to_string(),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn delete_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data, oauth::AppScope::UserCreateProducts) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data.delete_product(id, &user).await {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Product deleted".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn update_title_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+    Json(mut req): Json<UpdateProductTitle>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data, oauth::AppScope::UserManageProducts) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    req.title = req.title.trim().to_string();
+    if req.title.len() < 2 {
+        return Json(Error::DataTooShort("title".to_string()).into());
+    } else if req.title.len() > 128 {
+        return Json(Error::DataTooLong("title".to_string()).into());
+    }
+
+    match data.update_product_title(id, &user, &req.title).await {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Product updated".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn update_description_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+    Json(mut req): Json<UpdateProductDescription>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data, oauth::AppScope::UserManageProducts) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    req.description = req.description.trim().to_string();
+    if req.description.len() < 2 {
+        return Json(Error::DataTooShort("description".to_string()).into());
+    } else if req.description.len() > 1024 {
+        return Json(Error::DataTooLong("description".to_string()).into());
+    }
+
+    match data
+        .update_product_description(id, &user, &req.description)
+        .await
+    {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Product updated".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn update_on_sale_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+    Json(req): Json<UpdateProductOnSale>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data, oauth::AppScope::UserManageProducts) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data
+        .update_product_on_sale(id, &user, if req.on_sale { 1 } else { 0 })
+        .await
+    {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Product updated".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn update_price_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+    Json(req): Json<UpdateProductPrice>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data, oauth::AppScope::UserManageProducts) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data.update_product_price(id, &user, req.price).await {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Product updated".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn update_method_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+    Json(req): Json<UpdateProductMethod>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data, oauth::AppScope::UserManageProducts) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data.update_product_method(id, &user, req.method).await {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Product updated".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn update_stock_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+    Json(req): Json<UpdateProductStock>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data, oauth::AppScope::UserManageProducts) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data.update_product_stock(id, &user, req.stock).await {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Product updated".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn buy_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let mut user = match get_user_from_token!(jar, data, oauth::AppScope::UserSendCoins) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data.purchase_product(id, &mut user).await {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Product purchased".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}

crates/app/src/routes/api/v1/transfers.rs

@@ -1,6 +1,9 @@
 use crate::{get_user_from_token, State, cookie::CookieJar};
 use axum::{response::IntoResponse, Extension, Json};
-use tetratto_core::model::{economy::CoinTransfer, oauth, ApiReturn, Error};
+use tetratto_core::model::{
+    economy::{CoinTransfer, CoinTransferMethod},
+    oauth, ApiReturn, Error,
+};
 use super::CreateCoinTransfer;
 
 pub async fn create_request(
@@ -15,13 +18,21 @@ pub async fn create_request(
     };
 
     match data
-        .create_transfer(CoinTransfer::new(user.id, req.receiver, req.amount))
+        .create_transfer(
+            &mut CoinTransfer::new(
+                user.id,
+                req.receiver,
+                req.amount,
+                CoinTransferMethod::Transfer, // this endpoint is ONLY for regular transfers; products export a buy endpoint for the other method
+            ),
+            true,
+        )
         .await
     {
         Ok(s) => Json(ApiReturn {
             ok: true,
-            message: "Stack created".to_string(),
-            payload: s.id.to_string(),
+            message: "Transfer created".to_string(),
+            payload: s.to_string(),
         }),
         Err(e) => Json(e.into()),
     }