diff --git a/src/ordering/adapters/input/web/category.rs b/src/ordering/adapters/input/web/category.rs new file mode 100644 index 0000000..0c38bdf --- /dev/null +++ b/src/ordering/adapters/input/web/category.rs @@ -0,0 +1,115 @@ +// SPDX-FileCopyrightText: 2024 Aravinth Manivannan +// +// SPDX-License-Identifier: AGPL-3.0-or-later + +use actix_identity::Identity; +use actix_web::{get, http::header::ContentType, post, web, HttpRequest, HttpResponse, Responder}; +use derive_builder::Builder; +use serde::{Deserialize, Serialize}; +use url::Url; +use uuid::Uuid; + +use super::errors::*; +use super::types; +//use crate::utils::uuid::WebGetUUIDInterfaceObj; + +pub fn services(cfg: &mut web::ServiceConfig) { + cfg.service(add_category_ui_handler); + cfg.service(add_category_form_submission_handler); + + cfg.service(update_category_ui_handler); + cfg.service(update_category_form_submission_handler); +} + +// add_category handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/menu/category/add")] +#[tracing::instrument(name = "add_category UI handler", skip())] +async fn add_category_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::add_category::*; + + let page = AddCategoryPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct AddCategoryPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/menu/category/add")] +#[tracing::instrument( + name = "add_category form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn add_category_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +// update_category handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/menu/{category_uuid}/update")] +#[tracing::instrument(name = "update_category UI handler", skip())] +async fn update_category_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::update_category::*; + + let page = UpdateCategoryPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct UpdateCategoryPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/menu/{category_uuid}/update")] +#[tracing::instrument( + name = "update_category form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn update_category_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + #[actix_rt::test] + async fn ordering_web_add_category_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.add_category).await; + } + + #[actix_rt::test] + async fn ordering_web_update_category_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.update_category(UUID)).await; + } +} diff --git a/src/ordering/adapters/input/web/customization.rs b/src/ordering/adapters/input/web/customization.rs new file mode 100644 index 0000000..9c2331c --- /dev/null +++ b/src/ordering/adapters/input/web/customization.rs @@ -0,0 +1,118 @@ +// SPDX-FileCopyrightText: 2024 Aravinth Manivannan +// +// SPDX-License-Identifier: AGPL-3.0-or-later + +use actix_identity::Identity; +use actix_web::{get, http::header::ContentType, post, web, HttpRequest, HttpResponse, Responder}; +use derive_builder::Builder; +use serde::{Deserialize, Serialize}; +use url::Url; +use uuid::Uuid; + +use super::errors::*; +use super::types; +//use crate::utils::uuid::WebGetUUIDInterfaceObj; + +pub fn services(cfg: &mut web::ServiceConfig) { + cfg.service(add_customization_ui_handler); + cfg.service(add_customization_form_submission_handler); + + cfg.service(update_customization_ui_handler); + cfg.service(update_customization_form_submission_handler); +} + +// add_customization handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/menu/{category_uuid}/{product_uuid}/customization/add")] +#[tracing::instrument(name = "add_customization UI handler", skip())] +async fn add_customization_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::add_customization::*; + + let page = AddCustomizationPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct AddCustomizationPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/menu/{category_uuid}/{product_uuid}/customization/add")] +#[tracing::instrument( + name = "add_customization form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn add_customization_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +// update_customization handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/menu/{category_uuid}/{product_uuid}/{customization_uuid}/update")] +#[tracing::instrument(name = "update_customization UI handler", skip())] +async fn update_customization_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::update_customization::*; + + let page = UpdateCustomizationPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct UpdateCustomizationPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/menu/{category_uuid}/{product_uuid}/{customization_uuid}/update")] +#[tracing::instrument( + name = "update_customization form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn update_customization_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + #[actix_rt::test] + async fn ordering_web_add_customization_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.add_customization(UUID, UUID)) + .await; + } + + #[actix_rt::test] + async fn ordering_web_update_customization_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner( + &routes.update_customization(UUID, UUID, UUID), + ) + .await; + } +} diff --git a/src/ordering/adapters/input/web/kot.rs b/src/ordering/adapters/input/web/kot.rs new file mode 100644 index 0000000..64c9b80 --- /dev/null +++ b/src/ordering/adapters/input/web/kot.rs @@ -0,0 +1,161 @@ +// SPDX-FileCopyrightText: 2024 Aravinth Manivannan +// +// SPDX-License-Identifier: AGPL-3.0-or-later + +use actix_identity::Identity; +use actix_web::{get, http::header::ContentType, post, web, HttpRequest, HttpResponse, Responder}; +use derive_builder::Builder; +use serde::{Deserialize, Serialize}; +use url::Url; +use uuid::Uuid; + +use super::errors::*; +use super::types; +//use crate::utils::uuid::WebGetUUIDInterfaceObj; + +pub fn services(cfg: &mut web::ServiceConfig) { + cfg.service(add_kot_ui_handler); + cfg.service(add_kot_form_submission_handler); + + cfg.service(update_kot_ui_handler); + cfg.service(update_kot_form_submission_handler); + + cfg.service(delete_kot_ui_handler); + cfg.service(delete_kot_form_submission_handler); +} + +// add_kot handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/floor/{order_uuid}/kot/add")] +#[tracing::instrument(name = "add_kot UI handler", skip())] +async fn add_kot_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::add_kot::*; + + let page = AddKotPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct AddKotPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/floor/{order_uuid}/kot/add")] +#[tracing::instrument( + name = "add_kot form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn add_kot_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +// update_kot handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/floor/{order_uuid}/{kot_uuid}/update")] +#[tracing::instrument(name = "update_kot UI handler", skip())] +async fn update_kot_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::update_kot::*; + + let page = UpdateKotPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct UpdateKotPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/floor/{order_uuid}/{kot_uuid}/update")] +#[tracing::instrument( + name = "update_kot form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn update_kot_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +// delete_kot handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/floor/{order_uuid}/{kot_uuid}/delete")] +#[tracing::instrument(name = "delete_kot UI handler", skip())] +async fn delete_kot_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::delete_kot::*; + + let page = DeleteKotPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct DeleteKotPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/floor/{order_uuid}/{kot_uuid}/delete")] +#[tracing::instrument( + name = "delete_kot form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn delete_kot_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + #[actix_rt::test] + async fn ordering_web_add_kot_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.add_kot(UUID)).await; + } + + #[actix_rt::test] + async fn ordering_web_update_kot_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.update_kot(UUID, UUID)).await; + } + + #[actix_rt::test] + async fn ordering_web_delete_kot_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.delete_kot(UUID, UUID)).await; + } +} diff --git a/src/ordering/adapters/input/web/line_item.rs b/src/ordering/adapters/input/web/line_item.rs new file mode 100644 index 0000000..e90d561 --- /dev/null +++ b/src/ordering/adapters/input/web/line_item.rs @@ -0,0 +1,168 @@ +// SPDX-FileCopyrightText: 2024 Aravinth Manivannan +// +// SPDX-License-Identifier: AGPL-3.0-or-later + +use actix_identity::Identity; +use actix_web::{get, http::header::ContentType, post, web, HttpRequest, HttpResponse, Responder}; +use derive_builder::Builder; +use serde::{Deserialize, Serialize}; +use url::Url; +use uuid::Uuid; + +use super::errors::*; +use super::types; +//use crate::utils::uuid::WebGetUUIDInterfaceObj; + +pub fn services(cfg: &mut web::ServiceConfig) { + cfg.service(add_line_item_ui_handler); + cfg.service(add_line_item_form_submission_handler); + + cfg.service(update_line_item_ui_handler); + cfg.service(update_line_item_form_submission_handler); + + cfg.service(delete_line_item_ui_handler); + cfg.service(delete_line_item_form_submission_handler); +} + +// add_line_item handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/floor/{order_uuid}/{kot_uuid}/line_item/add")] +#[tracing::instrument(name = "add_line_item UI handler", skip())] +async fn add_line_item_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::add_line_item::*; + + let page = AddLineItemPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct AddLineItemPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/floor/{order_uuid}/{kot_uuid}/line_item/add")] +#[tracing::instrument( + name = "add_line_item form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn add_line_item_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +// update_line_item handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/floor/{order_uuid}/{kot_uuid}/{line_item_uuid}/update")] +#[tracing::instrument(name = "update_line_item UI handler", skip())] +async fn update_line_item_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::update_line_item::*; + + let page = UpdateLineItemPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct UpdateLineItemPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/floor/{order_uuid}/{kot_uuid}/{line_item_uuid}/update")] +#[tracing::instrument( + name = "update_line_item form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn update_line_item_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +// delete_line_item handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/floor/{order_uuid}/{kot_uuid}/{line_item_uuid}/delete")] +#[tracing::instrument(name = "delete_line_item UI handler", skip())] +async fn delete_line_item_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::delete_line_item::*; + + let page = DeleteLineItemPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct DeleteLineItemPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/floor/{order_uuid}/{kot_uuid}/{line_item_uuid}/delete")] +#[tracing::instrument( + name = "delete_line_item form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn delete_line_item_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + #[actix_rt::test] + async fn ordering_web_add_line_item_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.add_line_item(UUID, UUID)) + .await; + } + + #[actix_rt::test] + async fn ordering_web_update_line_item_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner( + &routes.update_line_item(UUID, UUID, UUID), + ) + .await; + } + + #[actix_rt::test] + async fn ordering_web_delete_line_item_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner( + &routes.delete_line_item(UUID, UUID, UUID), + ) + .await; + } +} diff --git a/src/ordering/adapters/input/web/mod.rs b/src/ordering/adapters/input/web/mod.rs index 9bf19d3..adc4186 100644 --- a/src/ordering/adapters/input/web/mod.rs +++ b/src/ordering/adapters/input/web/mod.rs @@ -11,6 +11,14 @@ use crate::ordering::adapters::types; mod errors; mod routes; +mod category; +mod customization; +mod product; + +mod kot; +mod line_item; +mod order; + pub use errors::WebJsonRepsonse; pub use routes::RoutesRepository; @@ -20,6 +28,13 @@ pub fn load_ctx() -> impl FnOnce(&mut web::ServiceConfig) { let f = move |cfg: &mut web::ServiceConfig| { cfg.app_data(routes); + cfg.configure(customization::services); + cfg.configure(product::services); + cfg.configure(category::services); + + cfg.configure(line_item::services); + cfg.configure(kot::services); + cfg.configure(order::services); }; Box::new(f) diff --git a/src/ordering/adapters/input/web/order.rs b/src/ordering/adapters/input/web/order.rs new file mode 100644 index 0000000..4049ed8 --- /dev/null +++ b/src/ordering/adapters/input/web/order.rs @@ -0,0 +1,161 @@ +// SPDX-FileCopyrightText: 2024 Aravinth Manivannan +// +// SPDX-License-Identifier: AGPL-3.0-or-later + +use actix_identity::Identity; +use actix_web::{get, http::header::ContentType, post, web, HttpRequest, HttpResponse, Responder}; +use derive_builder::Builder; +use serde::{Deserialize, Serialize}; +use url::Url; +use uuid::Uuid; + +use super::errors::*; +use super::types; +//use crate::utils::uuid::WebGetUUIDInterfaceObj; + +pub fn services(cfg: &mut web::ServiceConfig) { + cfg.service(add_order_ui_handler); + cfg.service(add_order_form_submission_handler); + + cfg.service(update_order_ui_handler); + cfg.service(update_order_form_submission_handler); + + cfg.service(delete_order_ui_handler); + cfg.service(delete_order_form_submission_handler); +} + +// add_order handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/floor/order/add")] +#[tracing::instrument(name = "add_order UI handler", skip())] +async fn add_order_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::add_order::*; + + let page = AddOrderPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct AddOrderPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/floor/order/add")] +#[tracing::instrument( + name = "add_order form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn add_order_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +// update_order handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/floor/{order_uuid}/update")] +#[tracing::instrument(name = "update_order UI handler", skip())] +async fn update_order_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::update_order::*; + + let page = UpdateOrderPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct UpdateOrderPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/floor/{order_uuid}/update")] +#[tracing::instrument( + name = "update_order form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn update_order_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +// delete_order handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/floor/{order_uuid}/delete")] +#[tracing::instrument(name = "delete_order UI handler", skip())] +async fn delete_order_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::delete_order::*; + + let page = DeleteOrderPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct DeleteOrderPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/floor/{order_uuid}/delete")] +#[tracing::instrument( + name = "delete_order form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn delete_order_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + #[actix_rt::test] + async fn ordering_web_add_order_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.add_order).await; + } + + #[actix_rt::test] + async fn ordering_web_update_order_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.update_order(UUID)).await; + } + + #[actix_rt::test] + async fn ordering_web_delete_order_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.delete_order(UUID)).await; + } +} diff --git a/src/ordering/adapters/input/web/product.rs b/src/ordering/adapters/input/web/product.rs new file mode 100644 index 0000000..ab3bb98 --- /dev/null +++ b/src/ordering/adapters/input/web/product.rs @@ -0,0 +1,114 @@ +// SPDX-FileCopyrightText: 2024 Aravinth Manivannan +// +// SPDX-License-Identifier: AGPL-3.0-or-later + +use actix_identity::Identity; +use actix_web::{get, http::header::ContentType, post, web, HttpRequest, HttpResponse, Responder}; +use derive_builder::Builder; +use serde::{Deserialize, Serialize}; +use url::Url; +use uuid::Uuid; + +use super::errors::*; +use super::types; +//use crate::utils::uuid::WebGetUUIDInterfaceObj; + +pub fn services(cfg: &mut web::ServiceConfig) { + cfg.service(add_product_ui_handler); + cfg.service(add_product_form_submission_handler); + + cfg.service(update_product_ui_handler); + cfg.service(update_product_form_submission_handler); +} +// add_product handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/menu/{category_uuid}/product/add")] +#[tracing::instrument(name = "add_product UI handler", skip())] +async fn add_product_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::add_product::*; + + let page = AddProductPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct AddProductPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/menu/{category_uuid}/product/add")] +#[tracing::instrument( + name = "add_product form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn add_product_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} + +// update_product handlers + +#[allow(clippy::too_many_arguments)] +#[get("/ordering/menu/{category_uuid}/{product_uuid}/update")] +#[tracing::instrument(name = "update_product UI handler", skip())] +async fn update_product_ui_handler() -> WebJsonRepsonse { + use web_ui::ordering::update_product::*; + + let page = UpdateProductPage::page(); + + Ok(HttpResponse::Ok() + .insert_header(ContentType::html()) + .body(page)) +} + +#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] +struct UpdateProductPayload { + password: String, +} + +#[allow(clippy::too_many_arguments)] +#[post("/ordering/menu/{category_uuid}/{product_uuid}/update")] +#[tracing::instrument( + name = "update_product form submission handler" + skip(id, req, payload, ordering_cqrs_exec) + )] +async fn update_product_form_submission_handler( + ordering_cqrs_exec: types::WebOrderingCqrsExec, + req: HttpRequest, + id: Identity, + payload: web::Form, +) -> WebJsonRepsonse { + let store = ""; + + Ok(HttpResponse::Ok().json(store)) +} +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + #[actix_rt::test] + async fn ordering_web_add_product_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.add_product(UUID)).await; + } + + #[actix_rt::test] + async fn ordering_web_update_product_ui_works() { + let routes = crate::ordering::adapters::input::web::RoutesRepository::default(); + crate::tests::actix_web_test_utils::page_test_runner(&routes.update_product(UUID, UUID)) + .await; + } +} diff --git a/src/ordering/adapters/input/web/routes.rs b/src/ordering/adapters/input/web/routes.rs index 2c2d1bd..efb4ec3 100644 --- a/src/ordering/adapters/input/web/routes.rs +++ b/src/ordering/adapters/input/web/routes.rs @@ -6,12 +6,280 @@ use url::Url; use uuid::Uuid; #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] -pub struct RoutesRepository {} +pub struct RoutesRepository { + add_line_item: String, + update_line_item: String, + delete_line_item: String, + + pub add_order: String, + update_order: String, + delete_order: String, + + add_kot: String, + update_kot: String, + delete_kot: String, + + pub add_category: String, + update_category: String, + + add_product: String, + update_product: String, + + add_customization: String, + update_customization: String, +} impl Default for RoutesRepository { fn default() -> Self { - Self {} + Self { + add_order: "/ordering/floor/order/add".into(), + update_order: "/ordering/floor/{order_uuid}/update".into(), + delete_order: "/ordering/floor/{order_uuid}/delete".into(), + + add_kot: "/ordering/floor/{order_uuid}/kot/add".into(), + update_kot: "/ordering/floor/{order_uuid}/{kot_uuid}/update".into(), + delete_kot: "/ordering/floor/{order_uuid}/{kot_uuid}/delete".into(), + + add_line_item: "/ordering/floor/{order_uuid}/{kot_uuid}/line_item/add".into(), + update_line_item: "/ordering/floor/{order_uuid}/{kot_uuid}/{line_item_uuid}/update" + .into(), + delete_line_item: "/ordering/floor/{order_uuid}/{kot_uuid}/{line_item_uuid}/delete" + .into(), + + add_category: "/ordering/menu/category/add".into(), + update_category: "/ordering/menu/{category_uuid}/update".into(), + + add_product: "/ordering/menu/{category_uuid}/product/add".into(), + update_product: "/ordering/menu/{category_uuid}/{product_uuid}/update".into(), + + add_customization: "/ordering/menu/{category_uuid}/{product_uuid}/customization/add" + .into(), + update_customization: + "/ordering/menu/{category_uuid}/{product_uuid}/{customization_uuid}/update".into(), + } } } -impl RoutesRepository {} +impl RoutesRepository { + pub fn update_order(&self, order_uuid: Uuid) -> String { + self.update_order + .replace("{order_uuid}", &order_uuid.to_string()) + } + + pub fn delete_order(&self, order_uuid: Uuid) -> String { + self.delete_order + .replace("{order_uuid}", &order_uuid.to_string()) + } + + pub fn add_kot(&self, order_uuid: Uuid) -> String { + self.add_kot + .replace("{order_uuid}", &order_uuid.to_string()) + } + + pub fn update_kot(&self, order_uuid: Uuid, kot_uuid: Uuid) -> String { + self.update_kot + .replace("{order_uuid}", &order_uuid.to_string()) + .replace("{kot_uuid}", &kot_uuid.to_string()) + } + + pub fn delete_kot(&self, order_uuid: Uuid, kot_uuid: Uuid) -> String { + self.delete_kot + .replace("{order_uuid}", &order_uuid.to_string()) + .replace("{kot_uuid}", &kot_uuid.to_string()) + } + + pub fn add_line_item(&self, order_uuid: Uuid, kot_uuid: Uuid) -> String { + self.add_line_item + .replace("{order_uuid}", &order_uuid.to_string()) + .replace("{kot_uuid}", &kot_uuid.to_string()) + } + + pub fn update_line_item( + &self, + order_uuid: Uuid, + kot_uuid: Uuid, + line_item_uuid: Uuid, + ) -> String { + self.update_line_item + .replace("{order_uuid}", &order_uuid.to_string()) + .replace("{kot_uuid}", &kot_uuid.to_string()) + .replace("{line_item_uuid}", &line_item_uuid.to_string()) + } + + pub fn delete_line_item( + &self, + order_uuid: Uuid, + kot_uuid: Uuid, + line_item_uuid: Uuid, + ) -> String { + self.delete_line_item + .replace("{order_uuid}", &order_uuid.to_string()) + .replace("{kot_uuid}", &kot_uuid.to_string()) + .replace("{line_item_uuid}", &line_item_uuid.to_string()) + } + + pub fn update_category(&self, category_uuid: Uuid) -> String { + self.update_category + .replace("{category_uuid}", &category_uuid.to_string()) + } + + pub fn add_product(&self, category_uuid: Uuid) -> String { + self.add_product + .replace("{category_uuid}", &category_uuid.to_string()) + } + pub fn update_product(&self, category_uuid: Uuid, product_uuid: Uuid) -> String { + self.update_product + .replace("{category_uuid}", &category_uuid.to_string()) + .replace("{product_uuid}", &product_uuid.to_string()) + } + + pub fn add_customization(&self, category_uuid: Uuid, product_uuid: Uuid) -> String { + self.add_customization + .replace("{category_uuid}", &category_uuid.to_string()) + .replace("{product_uuid}", &product_uuid.to_string()) + } + + pub fn update_customization( + &self, + category_uuid: Uuid, + product_uuid: Uuid, + customization_uuid: Uuid, + ) -> String { + self.update_customization + .replace("{category_uuid}", &category_uuid.to_string()) + .replace("{product_uuid}", &product_uuid.to_string()) + .replace("{customization_uuid}", &customization_uuid.to_string()) + } +} + +#[cfg(test)] +mod tests { + use crate::utils::uuid::tests::UUID; + + use super::*; + + #[test] + fn ordering_web_route_update_order() { + let r = RoutesRepository::default(); + assert_eq!( + r.update_order(UUID), + format!("/ordering/floor/{UUID}/update") + ); + } + + #[test] + fn ordering_web_route_delete_order() { + let r = RoutesRepository::default(); + assert_eq!( + r.delete_order(UUID), + format!("/ordering/floor/{UUID}/delete") + ); + } + + #[test] + fn ordering_web_route_add_kot() { + let r = RoutesRepository::default(); + assert_eq!(r.add_kot(UUID), format!("/ordering/floor/{UUID}/kot/add")); + } + + #[test] + fn ordering_web_route_update_kot() { + let r = RoutesRepository::default(); + let kot_uuid = Uuid::new_v4(); + assert_eq!( + r.update_kot(UUID, kot_uuid), + format!("/ordering/floor/{UUID}/{kot_uuid}/update") + ); + } + + #[test] + fn ordering_web_route_delete_kot() { + let r = RoutesRepository::default(); + let kot_uuid = Uuid::new_v4(); + assert_eq!( + r.delete_kot(UUID, kot_uuid), + format!("/ordering/floor/{UUID}/{kot_uuid}/delete") + ); + } + + #[test] + fn ordering_web_route_add_line_item() { + let r = RoutesRepository::default(); + let kot_uuid = Uuid::new_v4(); + assert_eq!( + r.add_line_item(UUID, kot_uuid), + format!("/ordering/floor/{UUID}/{kot_uuid}/line_item/add") + ); + } + + #[test] + fn ordering_web_route_update_line_item() { + let r = RoutesRepository::default(); + let kot_uuid = Uuid::new_v4(); + let line_item_uuid = Uuid::new_v4(); + assert_eq!( + r.update_line_item(UUID, kot_uuid, line_item_uuid), + format!("/ordering/floor/{UUID}/{kot_uuid}/{line_item_uuid}/update") + ); + } + + #[test] + fn ordering_web_route_delete_line_item() { + let r = RoutesRepository::default(); + let kot_uuid = Uuid::new_v4(); + let line_item_uuid = Uuid::new_v4(); + assert_eq!( + r.delete_line_item(UUID, kot_uuid, line_item_uuid), + format!("/ordering/floor/{UUID}/{kot_uuid}/{line_item_uuid}/delete") + ); + } + + #[test] + fn ordering_web_route_update_category() { + let r = RoutesRepository::default(); + assert_eq!( + r.update_category(UUID), + format!("/ordering/menu/{UUID}/update") + ); + } + + #[test] + fn ordering_web_route_add_product() { + let r = RoutesRepository::default(); + assert_eq!( + r.add_product(UUID), + format!("/ordering/menu/{UUID}/product/add") + ); + } + + #[test] + fn ordering_web_route_update_product() { + let r = RoutesRepository::default(); + let product_id = Uuid::new_v4(); + assert_eq!( + r.update_product(UUID, product_id), + format!("/ordering/menu/{UUID}/{product_id}/update") + ); + } + + #[test] + fn ordering_web_route_add_customization() { + let r = RoutesRepository::default(); + let product_id = Uuid::new_v4(); + assert_eq!( + r.add_customization(UUID, product_id), + format!("/ordering/menu/{UUID}/{product_id}/customization/add") + ); + } + + #[test] + fn ordering_web_route_update_customization() { + let r = RoutesRepository::default(); + let product_id = Uuid::new_v4(); + let customization_id = Uuid::new_v4(); + assert_eq!( + r.update_customization(UUID, product_id, customization_id), + format!("/ordering/menu/{UUID}/{product_id}/{customization_id}/update") + ); + } +}