libre-solutions/vanikam
5
0
Fork 0
Code Issues 2 Pull requests 3 Projects Releases Packages Wiki Activity

Merge pull request 'fix&feat: ordering: Aggregate creator provides ID' (#114) from ordering-fix-aggregate-id into master
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
Details

Browse source 
Reviewed-on: #114
This commit is contained in:
Aravinth Manivannan 2024-09-24 19:10:15 +05:30
commit 23a87480b7
49 changed files with 1780 additions and 812 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
.sqlx/query-d896f6ffb486efad5ed10a9c824656d863de0c9140054de66eef32491ace9ddb.json → .sqlx/query-289e6d9fe105ae9e91d947c22d0a5979786aac15b0c78359b3f634b74c4686d4.json
View file

@ -1,6 +1,6 @@
{ {
"db_name": "PostgreSQL", "db_name": "PostgreSQL",
"query": "UPDATE\n cqrs_ordering_category_query\n SET\n version = $1,\n name = $2,\n description = $3,\n category_id = $4,\n store_id = $5,\n deleted = $6;", "query": "UPDATE\n cqrs_ordering_category_query\n SET\n version = $1,\n name = $2,\n description = $3,\n store_id = $4,\n deleted = $5;",
"describe": { "describe": {
"columns": [], "columns": [],
"parameters": { "parameters": {
@ -9,11 +9,10 @@
"Text", "Text",
"Text", "Text",
"Uuid", "Uuid",
"Uuid",
"Bool" "Bool"
] ]
}, },
"nullable": [] "nullable": []
}, },
"hash": "d896f6ffb486efad5ed10a9c824656d863de0c9140054de66eef32491ace9ddb" "hash": "289e6d9fe105ae9e91d947c22d0a5979786aac15b0c78359b3f634b74c4686d4"
} }

10
.sqlx/query-dbe1e41f04a81b2a504b9179911201ec52340d09d45041addd54eb349af82488.json → .sqlx/query-4f8a2294b40e4285fa6d4c7bcf648be7320f99002b9a9279981053a5062b0ed8.json
View file

@ -1,6 +1,6 @@
{ {
"db_name": "PostgreSQL", "db_name": "PostgreSQL",
"query": "SELECT \n customer_name,\n order_id,\n created_time,\n deleted\n FROM\n cqrs_ordering_order_query\n WHERE\n order_id = $1;", "query": "SELECT \n customer_name,\n order_id,\n created_time,\n store_id,\n deleted\n FROM\n cqrs_ordering_order_query\n WHERE\n order_id = $1;",
"describe": { "describe": {
"columns": [ "columns": [
{ {
@ -20,6 +20,11 @@
}, },
{ {
"ordinal": 3, "ordinal": 3,
"name": "store_id",
"type_info": "Uuid"
},
{
"ordinal": 4,
"name": "deleted", "name": "deleted",
"type_info": "Bool" "type_info": "Bool"
} }
@ -30,11 +35,12 @@
] ]
}, },
"nullable": [ "nullable": [
true,
false, false,
false, false,
false, false,
false false
] ]
}, },
"hash": "dbe1e41f04a81b2a504b9179911201ec52340d09d45041addd54eb349af82488" "hash": "4f8a2294b40e4285fa6d4c7bcf648be7320f99002b9a9279981053a5062b0ed8"
} }

5
.sqlx/query-a342003149f2991ef0280d008f18e664c96299edfd9a11d08487e4db10a10e8b.json → .sqlx/query-7e2e91418e136fc5091b27c5f61158cca61e4853bee64e5afc44679e685cd744.json
View file

@ -1,6 +1,6 @@
{ {
"db_name": "PostgreSQL", "db_name": "PostgreSQL",
"query": "INSERT INTO cqrs_ordering_order_query (\n version,\n customer_name,\n order_id,\n created_time,\n deleted\n\n ) VALUES (\n $1, $2, $3, $4, $5\n );", "query": "INSERT INTO cqrs_ordering_order_query (\n version,\n customer_name,\n order_id,\n created_time,\n store_id,\n deleted\n\n ) VALUES (\n $1, $2, $3, $4, $5, $6\n );",
"describe": { "describe": {
"columns": [], "columns": [],
"parameters": { "parameters": {
@ -9,10 +9,11 @@
"Text", "Text",
"Uuid", "Uuid",
"Timestamptz", "Timestamptz",
"Uuid",
"Bool" "Bool"
] ]
}, },
"nullable": [] "nullable": []
}, },
"hash": "a342003149f2991ef0280d008f18e664c96299edfd9a11d08487e4db10a10e8b" "hash": "7e2e91418e136fc5091b27c5f61158cca61e4853bee64e5afc44679e685cd744"
} }

6
.sqlx/query-bc7d17aab113d0519c53e5f612116a6e72bb0007a298cdba17f45f4b8bed5f56.json → .sqlx/query-876ca2c177175439a1604a2d5aeec785e41473116ceda238a8089bcb33588e3d.json
View file

@ -1,18 +1,18 @@
{ {
"db_name": "PostgreSQL", "db_name": "PostgreSQL",
"query": "UPDATE\n cqrs_ordering_order_query\n SET\n version = $1,\n customer_name = $2,\n order_id = $3,\n created_time = $4,\n deleted = $5;", "query": "UPDATE\n cqrs_ordering_order_query\n SET\n version = $1,\n customer_name = $2,\n created_time = $3,\n store_id= $4,\n deleted = $5;",
"describe": { "describe": {
"columns": [], "columns": [],
"parameters": { "parameters": {
"Left": [ "Left": [
"Int8", "Int8",
"Text", "Text",
"Uuid",
"Timestamptz", "Timestamptz",
"Uuid",
"Bool" "Bool"
] ]
}, },
"nullable": [] "nullable": []
}, },
"hash": "bc7d17aab113d0519c53e5f612116a6e72bb0007a298cdba17f45f4b8bed5f56" "hash": "876ca2c177175439a1604a2d5aeec785e41473116ceda238a8089bcb33588e3d"
} }

5
.sqlx/query-d0580ff6dc77150cb00186302f20460dc3be59be1f8f5588bdc3d0f4489eb613.json → .sqlx/query-8a7958c4f8419e1fd95b2d0c75a3bab76f5962f37e58c7dee4e5f9341dca8c0e.json
View file

@ -1,6 +1,6 @@
{ {
"db_name": "PostgreSQL", "db_name": "PostgreSQL",
"query": "UPDATE\n cqrs_ordering_store_query\n SET\n version = $1,\n name = $2,\n address = $3,\n store_id = $4,\n owner = $5,\n deleted = $6;", "query": "UPDATE\n cqrs_ordering_store_query\n SET\n version = $1,\n name = $2,\n address = $3,\n owner = $4,\n deleted = $5;",
"describe": { "describe": {
"columns": [], "columns": [],
"parameters": { "parameters": {
@ -9,11 +9,10 @@
"Text", "Text",
"Text", "Text",
"Uuid", "Uuid",
"Uuid",
"Bool" "Bool"
] ]
}, },
"nullable": [] "nullable": []
}, },
"hash": "d0580ff6dc77150cb00186302f20460dc3be59be1f8f5588bdc3d0f4489eb613" "hash": "8a7958c4f8419e1fd95b2d0c75a3bab76f5962f37e58c7dee4e5f9341dca8c0e"
} }

5
.sqlx/query-4b7100e5c7442066dbb4ea7c9733e038af635766f0be61a86ca7084b34a2109d.json → .sqlx/query-97c136fd927b9a153a6093da6594e5fc2837b3943b8bbcbade97920a99019c86.json
View file

@ -1,18 +1,17 @@
{ {
"db_name": "PostgreSQL", "db_name": "PostgreSQL",
"query": "UPDATE\n cqrs_ordering_kot_query\n SET\n version = $1,\n order_id = $2,\n kot_id = $3,\n created_time = $4,\n deleted = $5;", "query": "UPDATE\n cqrs_ordering_kot_query\n SET\n version = $1,\n order_id = $2,\n created_time = $3,\n deleted = $4;",
"describe": { "describe": {
"columns": [], "columns": [],
"parameters": { "parameters": {
"Left": [ "Left": [
"Int8", "Int8",
"Uuid", "Uuid",
"Uuid",
"Timestamptz", "Timestamptz",
"Bool" "Bool"
] ]
}, },
"nullable": [] "nullable": []
}, },
"hash": "4b7100e5c7442066dbb4ea7c9733e038af635766f0be61a86ca7084b34a2109d" "hash": "97c136fd927b9a153a6093da6594e5fc2837b3943b8bbcbade97920a99019c86"
} }

5
.sqlx/query-c3a3348990d0fea3225fd2be2ef883ca1649e21fd28c1a35a0ffffce6035fd75.json → .sqlx/query-a3fa1c6271b85d23d70116363f19144190120c13752364bc3b78a92a08bd9157.json
View file

@ -1,6 +1,6 @@
{ {
"db_name": "PostgreSQL", "db_name": "PostgreSQL",
"query": "UPDATE\n cqrs_ordering_product_query\n SET\n version = $1,\n name = $2,\n description = $3,\n image = $4,\n product_id = $5,\n category_id = $6,\n price_major = $7,\n price_minor = $8,\n price_currency = $9,\n sku_able = $10,\n quantity_minor_unit = $11,\n quantity_minor_number = $12,\n quantity_major_unit = $13,\n quantity_major_number = $14,\n deleted = $15;", "query": "UPDATE\n cqrs_ordering_product_query\n SET\n version = $1,\n name = $2,\n description = $3,\n image = $4,\n category_id = $5,\n price_major = $6,\n price_minor = $7,\n price_currency = $8,\n sku_able = $9,\n quantity_minor_unit = $10,\n quantity_minor_number = $11,\n quantity_major_unit = $12,\n quantity_major_number = $13,\n deleted = $14;",
"describe": { "describe": {
"columns": [], "columns": [],
"parameters": { "parameters": {
@ -10,7 +10,6 @@
"Text", "Text",
"Text", "Text",
"Uuid", "Uuid",
"Uuid",
"Int4", "Int4",
"Int4", "Int4",
"Text", "Text",
@ -24,5 +23,5 @@
}, },
"nullable": [] "nullable": []
}, },
"hash": "c3a3348990d0fea3225fd2be2ef883ca1649e21fd28c1a35a0ffffce6035fd75" "hash": "a3fa1c6271b85d23d70116363f19144190120c13752364bc3b78a92a08bd9157"
} }

5
.sqlx/query-d9c625876e7d398cb48c6278e69b2eb6ad8515e68d5520013634415109309e6e.json → .sqlx/query-a5a58d14ddbfa78cca3729392faecfab30cc8b01fed9b73b9cc0813750230314.json
View file

@ -1,6 +1,6 @@
{ {
"db_name": "PostgreSQL", "db_name": "PostgreSQL",
"query": "UPDATE\n cqrs_ordering_product_customizations_query\n SET\n version = $1,\n name = $2,\n customization_id = $3,\n product_id = $4,\n deleted = $5;", "query": "UPDATE\n cqrs_ordering_product_customizations_query\n SET\n version = $1,\n name = $2,\n product_id = $3,\n deleted = $4;",
"describe": { "describe": {
"columns": [], "columns": [],
"parameters": { "parameters": {
@ -8,11 +8,10 @@
"Int8", "Int8",
"Text", "Text",
"Uuid", "Uuid",
"Uuid",
"Bool" "Bool"
] ]
}, },
"nullable": [] "nullable": []
}, },
"hash": "d9c625876e7d398cb48c6278e69b2eb6ad8515e68d5520013634415109309e6e" "hash": "a5a58d14ddbfa78cca3729392faecfab30cc8b01fed9b73b9cc0813750230314"
} }

24
.sqlx/query-c348d55dd91acb0d4697c433f61866b288fec93971bf9ab41faec21680e50f71.json
View file

@ -1,24 +0,0 @@
{
"db_name": "PostgreSQL",
"query": "UPDATE\n cqrs_ordering_line_item_query\n SET\n version = $1,\n product_name = $2,\n product_id = $3,\n line_item_id = $4,\n quantity_minor_unit = $5,\n quantity_minor_number = $6,\n quantity_major_unit = $7,\n quantity_major_number = $8,\n created_time = $9,\n kot_id = $10,\n deleted = $11;",
"describe": {
"columns": [],
"parameters": {
"Left": [
"Int8",
"Text",
"Uuid",
"Uuid",
"Text",
"Int4",
"Text",
"Int4",
"Timestamptz",
"Uuid",
"Bool"
]
},
"nullable": []
},
"hash": "c348d55dd91acb0d4697c433f61866b288fec93971bf9ab41faec21680e50f71"
}

23
.sqlx/query-e61db066fe7e66879f8ce8ccd3da94d89c30f8f5d633004ba16a6e971e041a14.json Normal file
View file

@ -0,0 +1,23 @@
{
"db_name": "PostgreSQL",
"query": "UPDATE\n cqrs_ordering_line_item_query\n SET\n version = $1,\n product_name = $2,\n product_id = $3,\n quantity_minor_unit = $4,\n quantity_minor_number = $5,\n quantity_major_unit = $6,\n quantity_major_number = $7,\n created_time = $8,\n kot_id = $9,\n deleted = $10;",
"describe": {
"columns": [],
"parameters": {
"Left": [
"Int8",
"Text",
"Uuid",
"Text",
"Int4",
"Text",
"Int4",
"Timestamptz",
"Uuid",
"Bool"
]
},
"nullable": []
},
"hash": "e61db066fe7e66879f8ce8ccd3da94d89c30f8f5d633004ba16a6e971e041a14"
}

3
migrations/20240723132531_cqrs_ordering_order_query.sql
View file

@ -8,8 +8,9 @@ CREATE TABLE IF NOT EXISTS cqrs_ordering_order_query
created_time timestamp with time zone DEFAULT (CURRENT_TIMESTAMP) NOT NULL, created_time timestamp with time zone DEFAULT (CURRENT_TIMESTAMP) NOT NULL,
order_id UUID NOT NULL UNIQUE, order_id UUID NOT NULL UNIQUE,
store_id UUID NOT NULL,
customer_name TEXT NOT NULL, customer_name TEXT,
deleted BOOLEAN NOT NULL DEFAULT FALSE, deleted BOOLEAN NOT NULL DEFAULT FALSE,

83
src/billing/domain/add_store_command.rs
View file

@ -1,86 +1,3 @@
//// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
////
//// SPDX-License-Identifier: AGPL-3.0-or-later
//
//use derive_getters::Getters;
//use derive_more::{Display, Error};
//use serde::{Deserialize, Serialize};
//use uuid::Uuid;
//
//#[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
//pub enum AddStoreCommandError {
// NameIsEmpty,
//}
//
//#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
//pub struct AddStoreCommand {
// name: String,
// address: Option<String>,
// owner: Uuid,
//}
//
//impl AddStoreCommand {
// pub fn new(
// name: String,
// address: Option<String>,
// owner: Uuid,
// ) -> Result<Self, AddStoreCommandError> {
// let address: Option<String> = if let Some(address) = address {
// let address = address.trim();
// if address.is_empty() {
// None
// } else {
// Some(address.to_owned())
// }
// } else {
// None
// };
//
// let name = name.trim().to_owned();
// if name.is_empty() {
// return Err(AddStoreCommandError::NameIsEmpty);
// }
//
// Ok(Self {
// name,
// address,
// owner,
// })
// }
//}
//
//#[cfg(test)]
//mod tests {
// use crate::utils::uuid::tests::UUID;
//
// use super::*;
//
// #[test]
// fn test_cmd() {
// let name = "foo";
// let address = "bar";
// let owner = UUID;
//
// // address = None
// let cmd = AddStoreCommand::new(name.into(), None, owner).unwrap();
// assert_eq!(cmd.name(), name);
// assert_eq!(cmd.address(), &None);
// assert_eq!(cmd.owner(), &owner);
//
// // address = Some
// let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
// assert_eq!(cmd.name(), name);
// assert_eq!(cmd.address(), &Some(address.to_owned()));
// assert_eq!(cmd.owner(), &owner);
//
// // AddStoreCommandError::NameIsEmpty
// assert_eq!(
// AddStoreCommand::new("".into(), Some(address.into()), owner),
// Err(AddStoreCommandError::NameIsEmpty)
// )
// }
//}
// SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net> // SPDX-FileCopyrightText: 2024 Aravinth Manivannan <realaravinth@batsense.net>
// //
// SPDX-License-Identifier: AGPL-3.0-or-later // SPDX-License-Identifier: AGPL-3.0-or-later

2
src/ordering/adapters/output/db/category_name_exists_for_store.rs
View file

@ -49,7 +49,7 @@ pub mod tests {
VALUES ($1, $2, $3, $4, $5, $6);", VALUES ($1, $2, $3, $4, $5, $6);",
1, 1,
c.name(), c.name(),
c.description().as_ref().unwrap(), c.description().as_ref().map(|s| s.as_str()),
c.category_id(), c.category_id(),
c.store_id(), c.store_id(),
c.deleted().clone(), c.deleted().clone(),

164
src/ordering/adapters/output/db/category_view.rs
View file

@ -10,7 +10,7 @@ use uuid::Uuid;
use super::errors::*; use super::errors::*;
use super::OrderingDBPostgresAdapter; use super::OrderingDBPostgresAdapter;
use crate::ordering::domain::category_aggregate::Category; use crate::ordering::domain::category_aggregate::*;
use crate::ordering::domain::events::OrderingEvent; use crate::ordering::domain::events::OrderingEvent;
use crate::utils::parse_aggregate_id::parse_aggregate_id; use crate::utils::parse_aggregate_id::parse_aggregate_id;
@ -27,6 +27,19 @@ pub struct CategoryView {
deleted: bool, deleted: bool,
} }
impl From<CategoryView> for Category {
fn from(v: CategoryView) -> Self {
CategoryBuilder::default()
.name(v.name)
.description(v.description)
.category_id(v.category_id)
.store_id(v.store_id)
.deleted(v.deleted)
.build()
.unwrap()
}
}
// This updates the view with events as they are committed. // This updates the view with events as they are committed.
// The logic should be minimal here, e.g., don't calculate the account balance, // The logic should be minimal here, e.g., don't calculate the account balance,
// design the events to carry the balance information instead. // design the events to carry the balance information instead.
@ -157,13 +170,11 @@ impl ViewRepository<CategoryView, Category> for OrderingDBPostgresAdapter {
version = $1, version = $1,
name = $2, name = $2,
description = $3, description = $3,
category_id = $4, store_id = $4,
store_id = $5, deleted = $5;",
deleted = $6;",
version, version,
view.name, view.name,
view.description, view.description,
view.category_id,
view.store_id, view.store_id,
view.deleted view.deleted
) )
@ -210,3 +221,146 @@ impl Query<Category> for OrderingDBPostgresAdapter {
self.update_view(view, view_context).await.unwrap(); self.update_view(view, view_context).await.unwrap();
} }
} }
#[cfg(test)]
mod tests {
use super::*;
use postgres_es::PostgresCqrs;
use crate::{
db::migrate::*,
ordering::{
application::services::{
add_category_service::*, update_category_service::*, MockOrderingServicesInterface,
},
domain::{
add_category_command::*, category_aggregate::*, commands::*, events::*,
store_aggregate::*, update_category_command::*,
},
},
tests::bdd::*,
utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
};
use std::sync::Arc;
#[actix_rt::test]
async fn pg_query_ordering_category_view() {
let settings = crate::settings::tests::get_settings().await;
//let settings = crate::settings::Settings::new().unwrap();
settings.create_db().await;
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
db.migrate().await;
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
let store = Store::default();
crate::ordering::adapters::output::db::store_id_exists::tests::create_dummy_store_record(
&store, &db,
)
.await;
let queries: Vec<Box<dyn Query<Category>>> = vec![Box::new(db.clone())];
let mut mock_services = MockOrderingServicesInterface::new();
let db2 = Arc::new(db.clone());
mock_services
.expect_add_category()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
AddCategoryServiceBuilder::default()
.db_store_id_exists(db2.clone())
.db_category_name_exists_for_store(db2.clone())
.db_category_id_exists(db2.clone())
.build()
.unwrap(),
)
});
let db2 = Arc::new(db.clone());
mock_services
.expect_update_category()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
UpdateCategoryServiceBuilder::default()
.db_store_id_exists(db2.clone())
.db_category_name_exists_for_store(db2.clone())
.db_category_id_exists(db2.clone())
.build()
.unwrap(),
)
});
let (cqrs, category_query): (
Arc<PostgresCqrs<Category>>,
Arc<dyn ViewRepository<CategoryView, Category>>,
) = (
Arc::new(postgres_es::postgres_cqrs(
db.pool.clone(),
queries,
Arc::new(mock_services),
)),
Arc::new(db.clone()),
);
let rand = crate::utils::random_string::GenerateRandomString {};
let cmd = AddCategoryCommandBuilder::default()
.name(rand.get_random(10))
.description(None)
.store_id(*store.store_id())
.adding_by(UUID)
.category_id(UUID)
.build()
.unwrap();
cqrs.execute(
&cmd.category_id().to_string(),
OrderingCommand::AddCategory(cmd.clone()),
)
.await
.unwrap();
let category = category_query
.load(&(*cmd.category_id()).to_string())
.await
.unwrap()
.unwrap();
let category: Category = category.into();
assert_eq!(category.name(), cmd.name());
assert_eq!(category.description(), cmd.description());
assert_eq!(category.category_id(), cmd.category_id());
assert_eq!(category.store_id(), cmd.store_id());
assert!(!store.deleted());
let update_category_cmd = UpdateCategoryCommand::new(
rand.get_random(10),
Some(rand.get_random(10)),
category,
UUID,
)
.unwrap();
cqrs.execute(
&cmd.category_id().to_string(),
OrderingCommand::UpdateCategory(update_category_cmd.clone()),
)
.await
.unwrap();
let category = category_query
.load(&(*cmd.category_id()).to_string())
.await
.unwrap()
.unwrap();
let category: Category = category.into();
assert_eq!(category.name(), update_category_cmd.name());
assert_eq!(category.description(), update_category_cmd.description());
assert_eq!(category.category_id(), cmd.category_id());
assert_eq!(category.store_id(), cmd.store_id());
assert!(!category.deleted());
settings.drop_db().await;
}
}

153
src/ordering/adapters/output/db/customization_view.rs
View file

@ -17,11 +17,6 @@ use crate::utils::parse_aggregate_id::parse_aggregate_id;
pub const NEW_CUSTOMIZATION_NON_UUID: &str = "ordering_new_customization_non_uuid-asdfa"; pub const NEW_CUSTOMIZATION_NON_UUID: &str = "ordering_new_customization_non_uuid-asdfa";
//#[derive(Debug, Default, Serialize, Deserialize)]
//struct Customizations {
// customizations: Vec<CustomizationView>,
//}
#[derive(Debug, Default, Serialize, Deserialize)] #[derive(Debug, Default, Serialize, Deserialize)]
struct CustomizationView { struct CustomizationView {
name: String, name: String,
@ -187,12 +182,10 @@ impl ViewRepository<CustomizationView, Customization> for OrderingDBPostgresAdap
SET SET
version = $1, version = $1,
name = $2, name = $2,
customization_id = $3, product_id = $3,
product_id = $4, deleted = $4;",
deleted = $5;",
version, version,
view.name, view.name,
view.customization_id,
view.product_id, view.product_id,
view.deleted, view.deleted,
) )
@ -225,3 +218,145 @@ impl Query<Customization> for OrderingDBPostgresAdapter {
self.update_view(view, view_context).await.unwrap(); self.update_view(view, view_context).await.unwrap();
} }
} }
#[cfg(test)]
mod tests {
use super::*;
use postgres_es::PostgresCqrs;
use crate::{
db::migrate::*,
ordering::{
adapters::output::db::product_id_exists::tests::create_dummy_product_record,
application::services::{
add_customization_service::*, update_customization_service::*,
MockOrderingServicesInterface,
},
domain::{
add_customization_command::*,
commands::OrderingCommand,
product_aggregate::Product,
update_customization_command::{tests::get_update_customization_command, *},
},
},
tests::bdd::*,
utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
};
use std::sync::Arc;
#[actix_rt::test]
async fn pg_query_ordering_customization_view() {
let settings = crate::settings::tests::get_settings().await;
//let settings = crate::settings::Settings::new().unwrap();
settings.create_db().await;
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
db.migrate().await;
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
let product = Product::default();
create_dummy_product_record(&product, &db).await;
// let simple_query = super::store_view::SimpleLoggingQuery {};
let queries: Vec<Box<dyn Query<Customization>>> = vec![Box::new(db.clone())];
let mut mock_services = MockOrderingServicesInterface::new();
let db2 = db.clone();
mock_services
.expect_add_customization()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
AddCustomizationServiceBuilder::default()
.db_product_id_exists(Arc::new(db2.clone()))
.db_customization_id_exists(Arc::new(db2.clone()))
.db_customization_name_exists_for_product(Arc::new(db2.clone()))
.build()
.unwrap(),
)
});
let db2 = Arc::new(db.clone());
mock_services
.expect_update_customization()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
UpdateCustomizationServiceBuilder::default()
.db_product_id_exists(db2.clone())
.db_customization_name_exists_for_product(db2.clone())
.db_customization_id_exists(db2.clone())
.build()
.unwrap(),
)
});
let (cqrs, custmoization_query): (
Arc<PostgresCqrs<Customization>>,
Arc<dyn ViewRepository<CustomizationView, Customization>>,
) = (
Arc::new(postgres_es::postgres_cqrs(
db.pool.clone(),
queries,
Arc::new(mock_services),
)),
Arc::new(db.clone()),
);
let rand = crate::utils::random_string::GenerateRandomString {};
let cmd = AddCustomizationCommandBuilder::default()
.name(rand.get_random(10))
.product_id(product.product_id().clone())
.customization_id(UUID.clone())
.build()
.unwrap();
cqrs.execute(
&cmd.customization_id().to_string(),
OrderingCommand::AddCustomization(cmd.clone()),
)
.await
.unwrap();
let customization = custmoization_query
.load(&(*cmd.customization_id()).to_string())
.await
.unwrap()
.unwrap();
let customization: Customization = customization.into();
assert_eq!(customization.name(), cmd.name());
assert_eq!(customization.customization_id(), cmd.customization_id());
assert_eq!(customization.product_id(), cmd.product_id());
assert!(!customization.deleted());
let update_customization_command = UnvalidatedUpdateCustomizationCommandBuilder::default()
.name(rand.get_random(10))
.old_customization(customization.clone())
.adding_by(UUID.clone())
.build()
.unwrap()
.validate()
.unwrap();
cqrs.execute(
&cmd.customization_id().to_string(),
OrderingCommand::UpdateCustomization(update_customization_command.clone()),
)
.await
.unwrap();
let c = custmoization_query
.load(&(*cmd.customization_id()).to_string())
.await
.unwrap()
.unwrap();
let c: Customization = c.into();
assert_eq!(c.name(), update_customization_command.name());
assert_eq!(
update_customization_command.old_customization(),
&customization
);
assert!(!c.deleted());
settings.drop_db().await;
}
}

2
src/ordering/adapters/output/db/kot_id_exists.rs
View file

@ -36,7 +36,7 @@ pub mod tests {
// use crate::ordering::domain::add_product_command::tests::get_customizations; // use crate::ordering::domain::add_product_command::tests::get_customizations;
use crate::ordering::domain::kot_aggregate::*; use crate::ordering::domain::kot_aggregate::*;
async fn create_dummy_kot(kot: &Kot, db: &OrderingDBPostgresAdapter) { pub async fn create_dummy_kot(kot: &Kot, db: &OrderingDBPostgresAdapter) {
sqlx::query!( sqlx::query!(
"INSERT INTO cqrs_ordering_kot_query ( "INSERT INTO cqrs_ordering_kot_query (
version, version,

185
src/ordering/adapters/output/db/kot_view.rs
View file

@ -197,12 +197,10 @@ impl ViewRepository<KotView, Kot> for OrderingDBPostgresAdapter {
SET SET
version = $1, version = $1,
order_id = $2, order_id = $2,
kot_id = $3, created_time = $3,
created_time = $4, deleted = $4;",
deleted = $5;",
version, version,
view.order_id, view.order_id,
view.kot_id,
view.created_time, view.created_time,
view.deleted, view.deleted,
) )
@ -230,3 +228,182 @@ impl Query<Kot> for OrderingDBPostgresAdapter {
self.update_view(view, view_context).await.unwrap(); self.update_view(view, view_context).await.unwrap();
} }
} }
#[cfg(test)]
mod tests {
use super::*;
use postgres_es::PostgresCqrs;
use time::macros::datetime;
use crate::{
db::migrate::*,
ordering::{
application::services::{
add_kot_service::AddKotServiceBuilder, delete_kot_service::DeleteKotServiceBuilder,
update_kot_service::*, MockOrderingServicesInterface,
},
domain::{
add_kot_command::*, commands::OrderingCommand,
delete_kot_command::DeleteKotCommandBuilder, order_aggregate::Order,
update_kot_command::*,
},
},
tests::bdd::*,
utils::{
random_string::GenerateRandomStringInterface,
uuid::{tests::UUID, *},
},
};
use std::sync::Arc;
#[actix_rt::test]
async fn pg_query_ordering_kot_view() {
let settings = crate::settings::tests::get_settings().await;
//let settings = crate::settings::Settings::new().unwrap();
settings.create_db().await;
let uuid = GenerateUUID {};
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
db.migrate().await;
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
let order = Order::default();
crate::ordering::adapters::output::db::order_id_exists::tests::create_dummy_order(
&order, &db,
)
.await;
let queries: Vec<Box<dyn Query<Kot>>> = vec![Box::new(db.clone())];
let mut mock_services = MockOrderingServicesInterface::new();
let db2 = db.clone();
mock_services
.expect_add_kot()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
AddKotServiceBuilder::default()
.db_kot_id_exists(Arc::new(db2.clone()))
.db_order_id_exists(Arc::new(db2.clone()))
.build()
.unwrap(),
)
});
let db2 = db.clone();
mock_services
.expect_update_kot()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
UpdateKotServiceBuilder::default()
.db_kot_id_exists(Arc::new(db2.clone()))
.db_order_id_exists(Arc::new(db2.clone()))
.build()
.unwrap(),
)
});
let db2 = db.clone();
mock_services
.expect_delete_kot()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
DeleteKotServiceBuilder::default()
.db_kot_id_exists(Arc::new(db2.clone()))
.build()
.unwrap(),
)
});
let (cqrs, kot_query): (
Arc<PostgresCqrs<Kot>>,
Arc<dyn ViewRepository<KotView, Kot>>,
) = (
Arc::new(postgres_es::postgres_cqrs(
db.pool.clone(),
queries,
Arc::new(mock_services),
)),
Arc::new(db.clone()),
);
let cmd = AddKotCommandBuilder::default()
.adding_by(UUID)
.created_time(datetime!(1970-01-01 0:00 UTC))
.order_id(*order.order_id())
.kot_id(uuid.get_uuid())
.build()
.unwrap();
cqrs.execute(
&cmd.kot_id().to_string(),
OrderingCommand::AddKot(cmd.clone()),
)
.await
.unwrap();
let kot = kot_query
.load(&(*cmd.kot_id()).to_string())
.await
.unwrap()
.unwrap();
let kot: Kot = kot.into();
assert_eq!(kot.order_id(), cmd.order_id());
assert_eq!(kot.kot_id(), cmd.kot_id());
assert!(!kot.deleted());
// update
let update_kot_cmd = UpdateKotCommandBuilder::default()
.adding_by(UUID)
.created_time(datetime!(1970-01-01 1:00 UTC))
.order_id(*order.order_id())
.old_kot(kot.clone())
.build()
.unwrap();
cqrs.execute(
&cmd.kot_id().to_string(),
OrderingCommand::UpdateKot(update_kot_cmd.clone()),
)
.await
.unwrap();
let kot = kot_query
.load(&(*cmd.kot_id()).to_string())
.await
.unwrap()
.unwrap();
let kot: Kot = kot.into();
assert_eq!(kot.order_id(), update_kot_cmd.order_id());
assert_eq!(kot.kot_id(), update_kot_cmd.old_kot().kot_id());
assert!(!kot.deleted());
// delete
let delete_kot_command = DeleteKotCommandBuilder::default()
.kot(kot.clone())
.adding_by(UUID)
.build()
.unwrap();
cqrs.execute(
&cmd.kot_id().to_string(),
OrderingCommand::DeleteKot(delete_kot_command.clone()),
)
.await
.unwrap();
let kot = kot_query
.load(&(*cmd.kot_id()).to_string())
.await
.unwrap()
.unwrap();
let kot: Kot = kot.into();
assert_eq!(kot.order_id(), delete_kot_command.kot().order_id());
assert_eq!(kot.kot_id(), delete_kot_command.kot().kot_id());
assert!(kot.deleted());
settings.drop_db().await;
}
}

224
src/ordering/adapters/output/db/line_item_view.rs
View file

@ -271,18 +271,16 @@ impl ViewRepository<LineItemView, LineItem> for OrderingDBPostgresAdapter {
version = $1, version = $1,
product_name = $2, product_name = $2,
product_id = $3, product_id = $3,
line_item_id = $4, quantity_minor_unit = $4,
quantity_minor_unit = $5, quantity_minor_number = $5,
quantity_minor_number = $6, quantity_major_unit = $6,
quantity_major_unit = $7, quantity_major_number = $7,
quantity_major_number = $8, created_time = $8,
created_time = $9, kot_id = $9,
kot_id = $10, deleted = $10;",
deleted = $11;",
version, version,
view.product_name, view.product_name,
view.product_id, view.product_id,
view.line_item_id,
view.quantity_minor_unit, view.quantity_minor_unit,
view.quantity_minor_number, view.quantity_minor_number,
view.quantity_major_unit, view.quantity_major_unit,
@ -320,3 +318,211 @@ impl Query<LineItem> for OrderingDBPostgresAdapter {
self.update_view(view, view_context).await.unwrap(); self.update_view(view, view_context).await.unwrap();
} }
} }
#[cfg(test)]
mod tests {
use super::*;
use postgres_es::PostgresCqrs;
use crate::{
db::migrate::*,
ordering::{
application::services::{
add_line_item_service::AddLineItemServiceBuilder, delete_line_item_service::*,
update_line_item_service::*, MockOrderingServicesInterface,
},
domain::{
add_line_item_command::*, commands::OrderingCommand,
delete_line_item_command::DeleteLineItemCommandBuilder, kot_aggregate::Kot,
update_line_item_command::*,
},
},
tests::bdd::*,
types::quantity::*,
utils::{
random_string::GenerateRandomStringInterface,
uuid::{tests::UUID, *},
},
};
use std::sync::Arc;
#[actix_rt::test]
async fn pg_query_ordering_line_item_view() {
let settings = crate::settings::tests::get_settings().await;
//let settings = crate::settings::Settings::new().unwrap();
settings.create_db().await;
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
db.migrate().await;
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
let queries: Vec<Box<dyn Query<LineItem>>> = vec![Box::new(db.clone())];
let mut mock_services = MockOrderingServicesInterface::new();
let kot = Kot::default();
crate::ordering::adapters::output::db::kot_id_exists::tests::create_dummy_kot(&kot, &db)
.await;
let db2 = db.clone();
mock_services
.expect_add_line_item()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
AddLineItemServiceBuilder::default()
.db_line_item_id_exists(Arc::new(db2.clone()))
.db_kot_id_exists(Arc::new(db2.clone()))
.build()
.unwrap(),
)
});
let db2 = db.clone();
mock_services
.expect_update_line_item()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
UpdateLineItemServiceBuilder::default()
.db_line_item_id_exists(Arc::new(db2.clone()))
.db_kot_id_exists(Arc::new(db2.clone()))
.build()
.unwrap(),
)
});
let db2 = db.clone();
mock_services
.expect_delete_line_item()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
DeleteLineItemServiceBuilder::default()
.db_line_item_id_exists(Arc::new(db2.clone()))
.build()
.unwrap(),
)
});
let (cqrs, line_item_query): (
Arc<PostgresCqrs<LineItem>>,
Arc<dyn ViewRepository<LineItemView, LineItem>>,
) = (
Arc::new(postgres_es::postgres_cqrs(
db.pool.clone(),
queries,
Arc::new(mock_services),
)),
Arc::new(db.clone()),
);
let rand = crate::utils::random_string::GenerateRandomString {};
let uuid = GenerateUUID {};
let line_item_id = uuid.get_uuid();
let cmd = AddLineItemCommandBuilder::default()
.product_name(rand.get_random(10))
.adding_by(UUID)
.quantity(Quantity::get_quantity())
.product_id(UUID)
.kot_id(*kot.kot_id())
.line_item_id(line_item_id)
.build()
.unwrap();
cqrs.execute(
&cmd.line_item_id().to_string(),
OrderingCommand::AddLineItem(cmd.clone()),
)
.await
.unwrap();
let line_item = line_item_query
.load(&(*cmd.line_item_id()).to_string())
.await
.unwrap()
.unwrap();
let line_item: LineItem = line_item.into();
assert_eq!(line_item.line_item_id(), cmd.line_item_id());
assert_eq!(line_item.product_name(), cmd.product_name());
assert_eq!(line_item.product_id(), cmd.product_id());
assert_eq!(line_item.quantity(), cmd.quantity());
assert!(!line_item.deleted());
let update_line_item_cmd = UnvalidatedUpdateLineItemCommandBuilder::default()
.product_name(rand.get_random(10))
.adding_by(UUID)
.quantity(Quantity::get_quantity())
.product_id(UUID)
.kot_id(*kot.kot_id())
.old_line_item(line_item.clone())
.build()
.unwrap()
.validate()
.unwrap();
cqrs.execute(
&cmd.line_item_id().to_string(),
OrderingCommand::UpdateLineItem(update_line_item_cmd.clone()),
)
.await
.unwrap();
let line_item = line_item_query
.load(&(*cmd.line_item_id()).to_string())
.await
.unwrap()
.unwrap();
let line_item: LineItem = line_item.into();
assert_eq!(
line_item.line_item_id(),
update_line_item_cmd.old_line_item().line_item_id()
);
assert_eq!(
line_item.product_name(),
update_line_item_cmd.product_name()
);
assert_eq!(line_item.product_id(), update_line_item_cmd.product_id());
assert_eq!(line_item.quantity(), update_line_item_cmd.quantity());
assert!(!line_item.deleted());
// delete
let delete_line_item_cmd = DeleteLineItemCommandBuilder::default()
.line_item(line_item.clone())
.adding_by(UUID)
.build()
.unwrap();
cqrs.execute(
&cmd.line_item_id().to_string(),
OrderingCommand::DeleteLineItem(delete_line_item_cmd.clone()),
)
.await
.unwrap();
let deleted_line_item = line_item_query
.load(&(*cmd.line_item_id()).to_string())
.await
.unwrap()
.unwrap();
let deleted_line_item: LineItem = deleted_line_item.into();
assert_eq!(
deleted_line_item.line_item_id(),
delete_line_item_cmd.line_item().line_item_id()
);
assert_eq!(
deleted_line_item.product_name(),
delete_line_item_cmd.line_item().product_name()
);
assert_eq!(
deleted_line_item.product_id(),
delete_line_item_cmd.line_item().product_id()
);
assert_eq!(
deleted_line_item.quantity(),
delete_line_item_cmd.line_item().quantity()
);
assert!(deleted_line_item.deleted());
settings.drop_db().await;
}
}

8
src/ordering/adapters/output/db/order_id_exists.rs
View file

@ -36,20 +36,22 @@ pub mod tests {
// use crate::ordering::domain::add_order_command::tests::get_customizations; // use crate::ordering::domain::add_order_command::tests::get_customizations;
use crate::ordering::domain::order_aggregate::*; use crate::ordering::domain::order_aggregate::*;
async fn create_dummy_order(order: &Order, db: &OrderingDBPostgresAdapter) { pub async fn create_dummy_order(order: &Order, db: &OrderingDBPostgresAdapter) {
sqlx::query!( sqlx::query!(
"INSERT INTO cqrs_ordering_order_query ( "INSERT INTO cqrs_ordering_order_query (
version, version,
order_id, order_id,
store_id,
customer_name, customer_name,
created_time, created_time,
deleted deleted
) VALUES ( ) VALUES (
$1, $2, $3, $4, $5 $1, $2, $3, $4, $5, $6
);", );",
1, 1,
order.order_id(), order.order_id(),
order.customer_name(), order.store_id(),
order.customer_name().as_ref().map(|s| s.as_str()),
order.created_time(), order.created_time(),
order.deleted().clone(), order.deleted().clone(),
) )

207
src/ordering/adapters/output/db/order_view.rs
View file

@ -23,8 +23,9 @@ pub const NEW_ORDER_NON_UUID: &str = "new_order_non_uuid-asdfa";
// be designed to reflect the response dto that will be returned to a user. // be designed to reflect the response dto that will be returned to a user.
#[derive(Debug, Serialize, Deserialize)] #[derive(Debug, Serialize, Deserialize)]
pub struct OrderView { pub struct OrderView {
customer_name: String, customer_name: Option<String>,
order_id: Uuid, order_id: Uuid,
store_id: Uuid,
created_time: OffsetDateTime, created_time: OffsetDateTime,
deleted: bool, deleted: bool,
@ -36,6 +37,7 @@ impl Default for OrderView {
customer_name: Default::default(), customer_name: Default::default(),
order_id: Default::default(), order_id: Default::default(),
created_time: OffsetDateTime::now_utc(), created_time: OffsetDateTime::now_utc(),
store_id: Default::default(),
deleted: false, deleted: false,
} }
} }
@ -46,6 +48,7 @@ impl From<OrderView> for Order {
OrderBuilder::default() OrderBuilder::default()
.customer_name(v.customer_name) .customer_name(v.customer_name)
.order_id(v.order_id) .order_id(v.order_id)
.store_id(v.store_id)
.created_time(v.created_time) .created_time(v.created_time)
.deleted(v.deleted) .deleted(v.deleted)
.build() .build()
@ -60,16 +63,18 @@ impl View<Order> for OrderView {
fn update(&mut self, event: &EventEnvelope<Order>) { fn update(&mut self, event: &EventEnvelope<Order>) {
match &event.payload { match &event.payload {
OrderingEvent::OrderAdded(val) => { OrderingEvent::OrderAdded(val) => {
self.customer_name = val.order().customer_name().into(); self.customer_name = val.order().customer_name().clone();
self.order_id = *val.order().order_id(); self.order_id = *val.order().order_id();
self.created_time = val.order().created_time().clone(); self.created_time = val.order().created_time().clone();
self.store_id = *val.order().store_id();
self.deleted = false; self.deleted = false;
} }
OrderingEvent::OrderUpdated(e) => { OrderingEvent::OrderUpdated(e) => {
let new = e.new_order(); let new = e.new_order();
self.customer_name = new.customer_name().into(); self.customer_name = new.customer_name().clone();
self.order_id = *new.order_id(); self.order_id = *new.order_id();
self.store_id = *new.store_id();
self.created_time = new.created_time().clone(); self.created_time = new.created_time().clone();
} }
OrderingEvent::OrderDeleted(_) => self.deleted = true, OrderingEvent::OrderDeleted(_) => self.deleted = true,
@ -93,6 +98,7 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
customer_name, customer_name,
order_id, order_id,
created_time, created_time,
store_id,
deleted deleted
FROM FROM
cqrs_ordering_order_query cqrs_ordering_order_query
@ -122,6 +128,7 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
customer_name, customer_name,
order_id, order_id,
created_time, created_time,
store_id,
deleted deleted
FROM FROM
cqrs_ordering_order_query cqrs_ordering_order_query
@ -170,15 +177,17 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
customer_name, customer_name,
order_id, order_id,
created_time, created_time,
store_id,
deleted deleted
) VALUES ( ) VALUES (
$1, $2, $3, $4, $5 $1, $2, $3, $4, $5, $6
);", );",
version, version,
view.customer_name, view.customer_name,
view.order_id, view.order_id,
view.created_time, view.created_time,
view.store_id,
view.deleted, view.deleted,
) )
.execute(&self.pool) .execute(&self.pool)
@ -194,13 +203,13 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
SET SET
version = $1, version = $1,
customer_name = $2, customer_name = $2,
order_id = $3, created_time = $3,
created_time = $4, store_id= $4,
deleted = $5;", deleted = $5;",
version, version,
view.customer_name, view.customer_name,
view.order_id,
view.created_time, view.created_time,
view.store_id,
view.deleted, view.deleted,
) )
.execute(&self.pool) .execute(&self.pool)
@ -227,3 +236,187 @@ impl Query<Order> for OrderingDBPostgresAdapter {
self.update_view(view, view_context).await.unwrap(); self.update_view(view, view_context).await.unwrap();
} }
} }
#[cfg(test)]
mod tests {
use super::*;
use postgres_es::PostgresCqrs;
use time::macros::datetime;
use crate::{
db::migrate::*,
ordering::{
application::services::{
add_order_service::*, delete_order_service::DeleteOrderServiceBuilder,
update_order_service::*, MockOrderingServicesInterface,
},
domain::{
add_order_command::*, commands::*, delete_order_command::DeleteOrderCommandBuilder,
events::*, order_aggregate::*, store_aggregate::*, update_order_command::*,
},
},
tests::bdd::*,
utils::{
random_string::GenerateRandomStringInterface,
uuid::{tests::UUID, *},
},
};
use std::sync::Arc;
#[actix_rt::test]
async fn pg_query_ordering_order_view() {
let settings = crate::settings::tests::get_settings().await;
//let settings = crate::settings::Settings::new().unwrap();
settings.create_db().await;
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
db.migrate().await;
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
let store = Store::default();
crate::ordering::adapters::output::db::store_id_exists::tests::create_dummy_store_record(
&store, &db,
)
.await;
let queries: Vec<Box<dyn Query<Order>>> = vec![Box::new(db.clone())];
let mut mock_services = MockOrderingServicesInterface::new();
let db2 = Arc::new(db.clone());
mock_services
.expect_add_order()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
AddOrderServiceBuilder::default()
.db_order_id_exists(db2.clone())
.db_store_id_exists(db2.clone())
.build()
.unwrap(),
)
});
let db2 = Arc::new(db.clone());
mock_services
.expect_update_order()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
UpdateOrderServiceBuilder::default()
.db_order_id_exists(db2.clone())
.build()
.unwrap(),
)
});
let db2 = Arc::new(db.clone());
mock_services
.expect_delete_order()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
DeleteOrderServiceBuilder::default()
.db_order_id_exists(db2.clone())
.build()
.unwrap(),
)
});
let (cqrs, order_query): (
Arc<PostgresCqrs<Order>>,
Arc<dyn ViewRepository<OrderView, Order>>,
) = (
Arc::new(postgres_es::postgres_cqrs(
db.pool.clone(),
queries,
Arc::new(mock_services),
)),
Arc::new(db.clone()),
);
let rand = crate::utils::random_string::GenerateRandomString {};
let uuid = GenerateUUID {};
let cmd = AddOrderCommandBuilder::default()
.customer_name(None)
.adding_by(UUID)
.created_time(datetime!(1970-01-01 0:00 UTC))
.store_id(*store.store_id())
.order_id(uuid.get_uuid())
.build()
.unwrap();
cqrs.execute(
&cmd.order_id().to_string(),
OrderingCommand::AddOrder(cmd.clone()),
)
.await
.unwrap();
let order = order_query
.load(&(*cmd.order_id()).to_string())
.await
.unwrap()
.unwrap();
let order: Order = order.into();
assert_eq!(order.customer_name(), cmd.customer_name());
assert_eq!(order.store_id(), cmd.store_id());
assert_eq!(order.order_id(), cmd.order_id());
assert!(!order.deleted());
// update
let update_order_cmd = UpdateOrderCommandBuilder::default()
.customer_name(Some(rand.get_random(10)))
.adding_by(UUID)
.created_time(datetime!(1970-01-01 0:00 UTC))
.old_order(order.clone())
.build()
.unwrap();
cqrs.execute(
&cmd.order_id().to_string(),
OrderingCommand::UpdateOrder(update_order_cmd.clone()),
)
.await
.unwrap();
let order = order_query
.load(&(*cmd.order_id()).to_string())
.await
.unwrap()
.unwrap();
let order: Order = order.into();
assert_eq!(order.customer_name(), update_order_cmd.customer_name());
assert_eq!(order.store_id(), update_order_cmd.old_order().store_id());
assert_eq!(order.order_id(), update_order_cmd.old_order().order_id());
assert!(!order.deleted());
let delete_order_cmd = DeleteOrderCommandBuilder::default()
.adding_by(UUID)
.order(order.clone())
.build()
.unwrap();
cqrs.execute(
&cmd.order_id().to_string(),
OrderingCommand::DeleteOrder(delete_order_cmd.clone()),
)
.await
.unwrap();
let order = order_query
.load(&(*cmd.order_id()).to_string())
.await
.unwrap()
.unwrap();
let order: Order = order.into();
assert_eq!(
order.customer_name(),
delete_order_cmd.order().customer_name()
);
assert_eq!(order.store_id(), delete_order_cmd.order().store_id());
assert_eq!(order.order_id(), delete_order_cmd.order().order_id());
assert!(order.deleted());
settings.drop_db().await;
}
}

4
src/ordering/adapters/output/db/product_id_exists.rs
View file

@ -95,8 +95,8 @@ pub mod tests {
);", );",
1, 1,
p.name(), p.name(),
p.description().as_ref().unwrap(), p.description().as_ref().map(|s| s.as_str()),
p.image().as_ref().unwrap(), p.image().as_ref().map(|s| s.as_str()),
p.product_id(), p.product_id(),
p.category_id(), p.category_id(),
p.price().major().clone() as i32, p.price().major().clone() as i32,

173
src/ordering/adapters/output/db/product_view.rs
View file

@ -293,22 +293,20 @@ impl ViewRepository<ProductView, Product> for OrderingDBPostgresAdapter {
name = $2, name = $2,
description = $3, description = $3,
image = $4, image = $4,
product_id = $5, category_id = $5,
category_id = $6, price_major = $6,
price_major = $7, price_minor = $7,
price_minor = $8, price_currency = $8,
price_currency = $9, sku_able = $9,
sku_able = $10, quantity_minor_unit = $10,
quantity_minor_unit = $11, quantity_minor_number = $11,
quantity_minor_number = $12, quantity_major_unit = $12,
quantity_major_unit = $13, quantity_major_number = $13,
quantity_major_number = $14, deleted = $14;",
deleted = $15;",
version, version,
view.name, view.name,
view.description, view.description,
view.image, view.image,
view.product_id,
view.category_id, view.category_id,
view.price_major, view.price_major,
view.price_minor, view.price_minor,
@ -349,3 +347,154 @@ impl Query<Product> for OrderingDBPostgresAdapter {
self.update_view(view, view_context).await.unwrap(); self.update_view(view, view_context).await.unwrap();
} }
} }
#[cfg(test)]
mod tests {
use super::*;
use postgres_es::PostgresCqrs;
use crate::{
db::migrate::*,
ordering::{
application::{
port::output::full_text_search::add_product_to_store::*,
services::{
add_product_service::*, update_product_service::*,
MockOrderingServicesInterface,
},
},
domain::{
add_product_command::tests::get_command, category_aggregate::*, commands::*,
product_aggregate::*, store_aggregate::*,
update_product_command::tests::get_command_with_product,
},
},
tests::bdd::*,
utils::uuid::tests::UUID,
};
use std::sync::Arc;
#[actix_rt::test]
async fn pg_query_ordering_product_view() {
let settings = crate::settings::tests::get_settings().await;
//let settings = crate::settings::Settings::new().unwrap();
settings.create_db().await;
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
db.migrate().await;
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
let store = Store::default();
crate::ordering::adapters::output::db::store_id_exists::tests::create_dummy_store_record(
&store, &db,
)
.await;
let category = CategoryBuilder::default()
.name("fooooo_cat".into())
.description(None)
.store_id(*store.store_id())
.category_id(UUID)
.build()
.unwrap();
crate::ordering::adapters::output::db::category_name_exists_for_store::tests::create_dummy_category_record(&category, &db).await;
let queries: Vec<Box<dyn Query<Product>>> = vec![Box::new(db.clone())];
let mut mock_services = MockOrderingServicesInterface::new();
let db2 = Arc::new(db.clone());
mock_services
.expect_add_product()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
AddProductServiceBuilder::default()
.db_product_name_exists_for_category(db2.clone())
.db_product_id_exists(db2.clone())
.db_get_category(db2.clone())
.db_category_id_exists(db2.clone())
.fts_add_product(mock_add_product_to_store_fts_port(IGNORE_CALL_COUNT))
.build()
.unwrap(),
)
});
let db2 = Arc::new(db.clone());
mock_services
.expect_update_product()
.times(IS_CALLED_ONLY_ONCE.unwrap())
.returning(move || {
Arc::new(
UpdateProductServiceBuilder::default()
.db_category_id_exists(db2.clone())
.db_product_name_exists_for_category(db2.clone())
.db_product_id_exists(db2.clone())
.build()
.unwrap(),
)
});
let (cqrs, product_query): (
Arc<PostgresCqrs<Product>>,
Arc<dyn ViewRepository<ProductView, Product>>,
) = (
Arc::new(postgres_es::postgres_cqrs(
db.pool.clone(),
queries,
Arc::new(mock_services),
)),
Arc::new(db.clone()),
);
let cmd = get_command();
cqrs.execute(
&cmd.product_id().to_string(),
OrderingCommand::AddProduct(cmd.clone()),
)
.await
.unwrap();
let product = product_query
.load(&(*cmd.product_id()).to_string())
.await
.unwrap()
.unwrap();
let product: Product = product.into();
assert_eq!(product.name(), cmd.name());
assert_eq!(product.description(), cmd.description());
assert_eq!(product.image(), cmd.image());
assert_eq!(product.product_id(), cmd.product_id());
assert_eq!(product.quantity(), cmd.quantity());
assert_eq!(product.sku_able(), cmd.sku_able());
assert_eq!(product.price(), cmd.price());
assert!(!product.deleted());
let update_product_cmd = get_command_with_product(product.clone());
cqrs.execute(
&cmd.product_id().to_string(),
OrderingCommand::UpdateProduct(update_product_cmd.clone()),
)
.await
.unwrap();
let product = product_query
.load(&(*cmd.product_id()).to_string())
.await
.unwrap()
.unwrap();
let product: Product = product.into();
assert_eq!(product.name(), update_product_cmd.name());
assert_eq!(product.description(), update_product_cmd.description());
assert_eq!(product.image(), update_product_cmd.image());
assert_eq!(
product.product_id(),
update_product_cmd.old_product().product_id()
);
assert_eq!(product.quantity(), update_product_cmd.quantity());
assert_eq!(product.sku_able(), update_product_cmd.sku_able());
assert_eq!(product.price(), update_product_cmd.price());
assert!(!product.deleted());
settings.drop_db().await;
}
}

2
src/ordering/adapters/output/db/store_id_exists.rs
View file

@ -45,7 +45,7 @@ pub mod tests {
VALUES ($1, $2, $3, $4, $5 ,$6);", VALUES ($1, $2, $3, $4, $5 ,$6);",
1, 1,
s.name(), s.name(),
s.address().as_ref().unwrap(), s.address().as_ref().map(|s| s.as_str()),
s.store_id(), s.store_id(),
s.owner(), s.owner(),
false false

259
src/ordering/adapters/output/db/store_view.rs
View file

@ -11,7 +11,7 @@ use uuid::Uuid;
use super::errors::*; use super::errors::*;
use super::OrderingDBPostgresAdapter; use super::OrderingDBPostgresAdapter;
use crate::ordering::domain::events::OrderingEvent; use crate::ordering::domain::events::OrderingEvent;
use crate::ordering::domain::store_aggregate::Store; use crate::ordering::domain::store_aggregate::*;
use crate::utils::parse_aggregate_id::parse_aggregate_id; use crate::utils::parse_aggregate_id::parse_aggregate_id;
pub const NEW_STORE_NON_UUID: &str = "ordering_new_store_non_uuid-asdfa"; pub const NEW_STORE_NON_UUID: &str = "ordering_new_store_non_uuid-asdfa";
@ -27,6 +27,19 @@ pub struct StoreView {
deleted: bool, deleted: bool,
} }
impl From<StoreView> for Store {
fn from(value: StoreView) -> Self {
StoreBuilder::default()
.name(value.name)
.address(value.address)
.store_id(value.store_id)
.owner(value.owner)
.deleted(value.deleted)
.build()
.unwrap()
}
}
// This updates the view with events as they are committed. // This updates the view with events as they are committed.
// The logic should be minimal here, e.g., don't calculate the account balance, // The logic should be minimal here, e.g., don't calculate the account balance,
// design the events to carry the balance information instead. // design the events to carry the balance information instead.
@ -156,13 +169,11 @@ impl ViewRepository<StoreView, Store> for OrderingDBPostgresAdapter {
version = $1, version = $1,
name = $2, name = $2,
address = $3, address = $3,
store_id = $4, owner = $4,
owner = $5, deleted = $5;",
deleted = $6;",
version, version,
view.name, view.name,
view.address, view.address,
view.store_id,
view.owner, view.owner,
view.deleted, view.deleted,
) )
@ -205,108 +216,138 @@ impl Query<Store> for OrderingDBPostgresAdapter {
} }
} }
// Our second query, this one will be handled with Postgres `GenericQuery` #[cfg(test)]
// which will serialize and persist our view after it is updated. It also mod tests {
// provides a `load` method to deserialize the view on request. use super::*;
//pub type StoreQuery = GenericQuery<OrderingDBPostgresAdapter, StoreView, Store>;
//pub type StoreQuery = Query<dyn OrderingDBPostgresAdapter, StoreView, Store>;
//#[cfg(test)] use postgres_es::PostgresCqrs;
//mod tests {
// use super::*; use crate::{
// db::migrate::*,
// use postgres_es::PostgresCqrs; ordering::{
// application::services::{
// use crate::{ add_store_service::AddStoreServiceBuilder, update_store_service::*,
// db::migrate::*, MockOrderingServicesInterface,
// ordering::{ },
// application::services::{ domain::add_store_command::*,
// add_category_service::tests::mock_add_category_service, add_customization_service::tests::mock_add_customization_service, add_line_item_service::tests::mock_add_line_item_service, add_product_service::tests::mock_add_product_service, add_store_service::AddStoreServiceBuilder, update_category_service::tests::mock_update_category_service, update_customization_service::tests::mock_update_customization_service, update_product_service::tests::mock_update_product_service, update_store_service::tests::mock_update_store_service, OrderingServicesBuilder domain::commands::OrderingCommand,
// }, domain::update_store_command::*,
// domain::{ },
// add_category_command::AddCategoryCommand, add_customization_command, tests::bdd::*,
// add_product_command::tests::get_command, add_store_command::AddStoreCommand, utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
// commands::OrderingCommand, };
// update_category_command::tests::get_update_category_command, use std::sync::Arc;
// update_customization_command::tests::get_update_customization_command,
// update_product_command, update_store_command::tests::get_update_store_cmd, #[actix_rt::test]
// }, async fn pg_query_ordering_store_view() {
// }, let settings = crate::settings::tests::get_settings().await;
// tests::bdd::IS_NEVER_CALLED, //let settings = crate::settings::Settings::new().unwrap();
// utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID}, settings.create_db().await;
// };
// use std::sync::Arc; let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
// db.migrate().await;
// #[actix_rt::test] let db = OrderingDBPostgresAdapter::new(db.pool.clone());
// async fn pg_query() {
// let settings = crate::settings::tests::get_settings().await; let simple_query = SimpleLoggingQuery {};
// //let settings = crate::settings::Settings::new().unwrap();
// settings.create_db().await; let queries: Vec<Box<dyn Query<Store>>> =
// vec![Box::new(simple_query), Box::new(db.clone())];
// let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
// db.migrate().await; let mut mock_services = MockOrderingServicesInterface::new();
// let db = OrderingDBPostgresAdapter::new(db.pool.clone());
// let db2 = db.clone();
// let simple_query = SimpleLoggingQuery {}; mock_services
// .expect_add_store()
// let queries: Vec<Box<dyn Query<Store>>> = .times(IS_CALLED_ONLY_ONCE.unwrap())
// vec![Box::new(simple_query), Box::new(db.clone())]; .returning(move || {
// Arc::new(
// let services = OrderingServicesBuilder::default() AddStoreServiceBuilder::default()
// .add_store(Arc::new( .db_store_id_exists(Arc::new(db2.clone()))
// AddStoreServiceBuilder::default() .db_store_name_exists(Arc::new(db2.clone()))
// .db_store_id_exists(Arc::new(db.clone())) .build()
// .db_store_name_exists(Arc::new(db.clone())) .unwrap(),
// .get_uuid(Arc::new(crate::utils::uuid::GenerateUUID {})) )
// .build() });
// .unwrap(),
// )) let db2 = db.clone();
// .add_category(mock_add_category_service( mock_services
// IS_NEVER_CALLED, .expect_update_store()
// AddCategoryCommand::new("foo".into(), None, UUID, UUID).unwrap(), .times(IS_CALLED_ONLY_ONCE.unwrap())
// )) .returning(move || {
// .add_product(mock_add_product_service(IS_NEVER_CALLED, get_command())) Arc::new(
// .add_customization(mock_add_customization_service( UpdateStoreServiceBuilder::default()
// IS_NEVER_CALLED, .db_store_id_exists(Arc::new(db2.clone()))
// add_customization_command::tests::get_command(), .db_store_name_exists(Arc::new(db2.clone()))
// )) .build()
// .update_product(mock_update_product_service( .unwrap(),
// IS_NEVER_CALLED, )
// update_product_command::tests::get_command(), });
// ))
// .update_customization(mock_update_customization_service( let (cqrs, store_query): (
// IS_NEVER_CALLED, Arc<PostgresCqrs<Store>>,
// get_update_customization_command(), Arc<dyn ViewRepository<StoreView, Store>>,
// )) ) = (
// .update_category(mock_update_category_service( Arc::new(postgres_es::postgres_cqrs(
// IS_NEVER_CALLED, db.pool.clone(),
// get_update_category_command(), queries,
// )) Arc::new(mock_services),
// .update_store(mock_update_store_service( )),
// IS_NEVER_CALLED, Arc::new(db.clone()),
// get_update_store_cmd(), );
// ))
// .build() let rand = crate::utils::random_string::GenerateRandomString {};
// .unwrap(); let cmd = AddStoreCommandBuilder::default()
// .name(rand.get_random(10))
// let (cqrs, _store_query): ( .address(None)
// Arc<PostgresCqrs<Store>>, .owner(UUID)
// Arc<dyn ViewRepository<StoreView, Store>>, .store_id(UUID)
// ) = ( .build()
// Arc::new(postgres_es::postgres_cqrs( .unwrap();
// db.pool.clone(), cqrs.execute(
// queries, &cmd.store_id().to_string(),
// Arc::new(services), OrderingCommand::AddStore(cmd.clone()),
// )), )
// Arc::new(db.clone()), .await
// ); .unwrap();
//
// let rand = crate::utils::random_string::GenerateRandomString {}; let store = store_query
// let cmd = AddStoreCommand::new(rand.get_random(10), None, UUID).unwrap(); .load(&(*cmd.store_id()).to_string())
// cqrs.execute("", OrderingCommand::AddStore(cmd.clone())) .await
// .await .unwrap()
// .unwrap(); .unwrap();
// let store: Store = store.into();
// settings.drop_db().await; assert_eq!(store.name(), cmd.name());
// } assert_eq!(store.address(), cmd.address());
//} assert_eq!(store.owner(), cmd.owner());
assert_eq!(store.store_id(), cmd.store_id());
assert!(!store.deleted());
let update_store_cmd = UpdateStoreCommand::new(
rand.get_random(10),
Some(rand.get_random(10)),
UUID,
store,
UUID,
)
.unwrap();
cqrs.execute(
&cmd.store_id().to_string(),
OrderingCommand::UpdateStore(update_store_cmd.clone()),
)
.await
.unwrap();
let store = store_query
.load(&(*cmd.store_id()).to_string())
.await
.unwrap()
.unwrap();
let store: Store = store.into();
assert_eq!(store.name(), update_store_cmd.name());
assert_eq!(store.address(), update_store_cmd.address());
assert_eq!(store.owner(), update_store_cmd.owner());
assert_eq!(store.store_id(), update_store_cmd.old_store().store_id());
assert!(!store.deleted());
settings.drop_db().await;
}
}

63
src/ordering/application/services/add_category_service.rs
View file

@ -19,7 +19,6 @@ use crate::ordering::{
category_aggregate::*, category_aggregate::*,
}, },
}; };
use crate::utils::uuid::*;
#[automock] #[automock]
#[async_trait::async_trait] #[async_trait::async_trait]
@ -34,7 +33,6 @@ pub struct AddCategoryService {
db_store_id_exists: StoreIDExistsDBPortObj, db_store_id_exists: StoreIDExistsDBPortObj,
db_category_name_exists_for_store: CategoryNameExistsForStoreDBPortObj, db_category_name_exists_for_store: CategoryNameExistsForStoreDBPortObj,
db_category_id_exists: CategoryIDExistsDBPortObj, db_category_id_exists: CategoryIDExistsDBPortObj,
get_uuid: GetUUIDInterfaceObj,
} }
#[async_trait::async_trait] #[async_trait::async_trait]
@ -48,27 +46,19 @@ impl AddCategoryUseCase for AddCategoryService {
return Err(OrderingError::StoreIDNotFound); return Err(OrderingError::StoreIDNotFound);
} }
let mut category_id = self.get_uuid.get_uuid(); if self
.db_category_id_exists
loop { .category_id_exists(cmd.category_id())
if self .await?
.db_category_id_exists {
.category_id_exists(&category_id) return Err(OrderingError::DuplicateCategoryID);
.await?
{
category_id = self.get_uuid.get_uuid();
continue;
} else {
break;
}
} }
let category = CategoryBuilder::default() let category = CategoryBuilder::default()
.name(cmd.name().into()) .name(cmd.name().into())
.description(cmd.description().as_ref().map(|s| s.to_string())) .description(cmd.description().as_ref().map(|s| s.to_string()))
.store_id(*cmd.store_id()) .store_id(*cmd.store_id())
.category_id(category_id) .category_id(*cmd.category_id())
.build() .build()
.unwrap(); .unwrap();
@ -97,8 +87,9 @@ pub mod tests {
use uuid::Uuid; use uuid::Uuid;
use crate::utils::uuid::tests::UUID; use crate::tests::bdd::*;
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
use crate::ordering::domain::add_category_command::tests::get_add_category_cmd;
pub fn mock_add_category_service( pub fn mock_add_category_service(
times: Option<usize>, times: Option<usize>,
@ -111,7 +102,7 @@ pub mod tests {
.description(cmd.description().as_ref().map(|s| s.to_string())) .description(cmd.description().as_ref().map(|s| s.to_string()))
.added_by_user(*cmd.adding_by()) .added_by_user(*cmd.adding_by())
.store_id(*cmd.store_id()) .store_id(*cmd.store_id())
.category_id(UUID) .category_id(*cmd.category_id())
.build() .build()
.unwrap(); .unwrap();
@ -128,14 +119,7 @@ pub mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_service_category_doesnt_exist() { async fn test_service_category_doesnt_exist() {
let name = "foo"; let cmd = get_add_category_cmd();
let description = "bar";
let user_id = UUID;
let store_id = Uuid::new_v4();
// description = None
let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
.unwrap();
let s = AddCategoryServiceBuilder::default() let s = AddCategoryServiceBuilder::default()
.db_store_id_exists(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE)) .db_store_id_exists(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
@ -143,7 +127,6 @@ pub mod tests {
IS_CALLED_ONLY_ONCE, IS_CALLED_ONLY_ONCE,
)) ))
.db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
.build() .build()
.unwrap(); .unwrap();
@ -152,19 +135,12 @@ pub mod tests {
assert_eq!(res.description(), cmd.description()); assert_eq!(res.description(), cmd.description());
assert_eq!(res.added_by_user(), cmd.adding_by()); assert_eq!(res.added_by_user(), cmd.adding_by());
assert_eq!(res.store_id(), cmd.store_id()); assert_eq!(res.store_id(), cmd.store_id());
assert_eq!(res.category_id(), &UUID); assert_eq!(res.category_id(), cmd.category_id());
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_service_category_name_exists_for_store() { async fn test_service_category_name_exists_for_store() {
let name = "foo"; let cmd = get_add_category_cmd();
let description = "bar";
let user_id = UUID;
let store_id = Uuid::new_v4();
// description = None
let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
.unwrap();
let s = AddCategoryServiceBuilder::default() let s = AddCategoryServiceBuilder::default()
.db_store_id_exists(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE)) .db_store_id_exists(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
@ -172,7 +148,6 @@ pub mod tests {
IS_CALLED_ONLY_ONCE, IS_CALLED_ONLY_ONCE,
)) ))
.db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
.build() .build()
.unwrap(); .unwrap();
@ -184,14 +159,7 @@ pub mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_service_store_doesnt_exist() { async fn test_service_store_doesnt_exist() {
let name = "foo"; let cmd = get_add_category_cmd();
let description = "bar";
let user_id = UUID;
let store_id = Uuid::new_v4();
// description = None
let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
.unwrap();
let s = AddCategoryServiceBuilder::default() let s = AddCategoryServiceBuilder::default()
.db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
@ -199,7 +167,6 @@ pub mod tests {
IS_NEVER_CALLED, IS_NEVER_CALLED,
)) ))
.db_category_id_exists(mock_category_id_exists_db_port_false(IS_NEVER_CALLED)) .db_category_id_exists(mock_category_id_exists_db_port_false(IS_NEVER_CALLED))
.get_uuid(mock_get_uuid(IS_NEVER_CALLED))
.build() .build()
.unwrap(); .unwrap();

51
src/ordering/application/services/add_customization_service.rs
View file

@ -11,20 +11,12 @@ use mockall::*;
use super::errors::*; use super::errors::*;
use crate::ordering::{ use crate::ordering::{
application::port::output::db::{ application::port::output::db::{
customization_id_exists::{self, *}, customization_id_exists::*, customization_name_exists_for_product::*, product_id_exists::*,
customization_name_exists_for_product::*,
product_id_exists::{self, *},
product_name_exists_for_category::*,
}, },
domain::{ domain::{
add_customization_command::AddCustomizationCommand, add_customization_command::*, customization_added_event::*, customization_aggregate::*,
customization_added_event::{self, *},
customization_aggregate::*,
product_added_event::{self, ProductAddedEvent, ProductAddedEventBuilder},
product_aggregate::*,
}, },
}; };
use crate::utils::uuid::*;
#[automock] #[automock]
#[async_trait::async_trait] #[async_trait::async_trait]
@ -42,7 +34,6 @@ pub struct AddCustomizationService {
db_product_id_exists: ProductIDExistsDBPortObj, db_product_id_exists: ProductIDExistsDBPortObj,
db_customization_id_exists: CustomizationIDExistsDBPortObj, db_customization_id_exists: CustomizationIDExistsDBPortObj,
db_customization_name_exists_for_product: CustomizationNameExistsForProductDBPortObj, db_customization_name_exists_for_product: CustomizationNameExistsForProductDBPortObj,
get_uuid: GetUUIDInterfaceObj,
} }
#[async_trait::async_trait] #[async_trait::async_trait]
@ -59,25 +50,19 @@ impl AddCustomizationUseCase for AddCustomizationService {
return Err(OrderingError::ProductIDNotFound); return Err(OrderingError::ProductIDNotFound);
} }
let mut customization_id = self.get_uuid.get_uuid(); if self
loop { .db_customization_id_exists
if self .customization_id_exists(cmd.customization_id())
.db_customization_id_exists .await?
.customization_id_exists(&customization_id) {
.await? return Err(OrderingError::DuplicateCustomizationID);
{
customization_id = self.get_uuid.get_uuid();
continue;
} else {
break;
}
} }
let customization = CustomizationBuilder::default() let customization = CustomizationBuilder::default()
.name(cmd.name().into()) .name(cmd.name().into())
.deleted(false) .deleted(false)
.product_id(*cmd.product_id()) .product_id(*cmd.product_id())
.customization_id(customization_id) .customization_id(*cmd.customization_id())
.build() .build()
.unwrap(); .unwrap();
@ -100,12 +85,10 @@ impl AddCustomizationUseCase for AddCustomizationService {
pub mod tests { pub mod tests {
use super::*; use super::*;
use customization_added_event::tests::get_customization_added_event_from_cmd; use crate::ordering::domain::{
use uuid::Uuid; add_customization_command::tests::*, customization_added_event::tests::*,
};
use crate::ordering::domain::add_customization_command::tests::get_command; use crate::tests::bdd::*;
use crate::utils::uuid::tests::UUID;
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
pub fn mock_add_customization_service( pub fn mock_add_customization_service(
times: Option<usize>, times: Option<usize>,
@ -138,13 +121,15 @@ pub mod tests {
.db_customization_name_exists_for_product( .db_customization_name_exists_for_product(
mock_customization_name_exists_for_product_db_port_false(IS_CALLED_ONLY_ONCE), mock_customization_name_exists_for_product_db_port_false(IS_CALLED_ONLY_ONCE),
) )
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
.build() .build()
.unwrap(); .unwrap();
let res = s.add_customization(cmd.clone()).await.unwrap(); let res = s.add_customization(cmd.clone()).await.unwrap();
assert_eq!(res.customization().name(), cmd.name()); assert_eq!(res.customization().name(), cmd.name());
// assert_eq!(customization_added_events.len(), cmd.customizations().len()); assert_eq!(
res.customization().customization_id(),
cmd.customization_id()
);
} }
#[actix_rt::test] #[actix_rt::test]
@ -159,7 +144,6 @@ pub mod tests {
.db_customization_name_exists_for_product( .db_customization_name_exists_for_product(
mock_customization_name_exists_for_product_db_port_true(IS_CALLED_ONLY_ONCE), mock_customization_name_exists_for_product_db_port_true(IS_CALLED_ONLY_ONCE),
) )
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
.build() .build()
.unwrap(); .unwrap();
@ -179,7 +163,6 @@ pub mod tests {
.db_customization_name_exists_for_product( .db_customization_name_exists_for_product(
mock_customization_name_exists_for_product_db_port_false(IS_NEVER_CALLED), mock_customization_name_exists_for_product_db_port_false(IS_NEVER_CALLED),
) )
.get_uuid(mock_get_uuid(IS_NEVER_CALLED))
.build() .build()
.unwrap(); .unwrap();

20
src/ordering/application/services/add_kot_service.rs
View file

@ -7,7 +7,6 @@ use std::sync::Arc;
use derive_builder::Builder; use derive_builder::Builder;
use mockall::predicate::*; use mockall::predicate::*;
use mockall::*; use mockall::*;
use time::OffsetDateTime;
use super::errors::*; use super::errors::*;
use crate::ordering::{ use crate::ordering::{
@ -15,7 +14,6 @@ use crate::ordering::{
application::port::output::db::order_id_exists::*, application::port::output::db::order_id_exists::*,
domain::{add_kot_command::*, kot_added_event::*, kot_aggregate::*}, domain::{add_kot_command::*, kot_added_event::*, kot_aggregate::*},
}; };
use crate::utils::uuid::*;
#[automock] #[automock]
#[async_trait::async_trait] #[async_trait::async_trait]
@ -29,7 +27,6 @@ pub type AddKotServiceObj = Arc<dyn AddKotUseCase>;
pub struct AddKotService { pub struct AddKotService {
db_kot_id_exists: KotIDExistsDBPortObj, db_kot_id_exists: KotIDExistsDBPortObj,
db_order_id_exists: OrderIDExistsDBPortObj, db_order_id_exists: OrderIDExistsDBPortObj,
get_uuid: GetUUIDInterfaceObj,
} }
#[async_trait::async_trait] #[async_trait::async_trait]
@ -43,21 +40,14 @@ impl AddKotUseCase for AddKotService {
return Err(OrderingError::OrderIDNotFound); return Err(OrderingError::OrderIDNotFound);
} }
let mut kot_id = self.get_uuid.get_uuid(); if self.db_kot_id_exists.kot_id_exists(cmd.kot_id()).await? {
return Err(OrderingError::KotIDNotFound);
loop {
if self.db_kot_id_exists.kot_id_exists(&kot_id).await? {
kot_id = self.get_uuid.get_uuid();
continue;
} else {
break;
}
} }
let kot = KotBuilder::default() let kot = KotBuilder::default()
.created_time(cmd.created_time().clone()) .created_time(cmd.created_time().clone())
.order_id(*cmd.order_id()) .order_id(*cmd.order_id())
.kot_id(kot_id) .kot_id(*cmd.kot_id())
.deleted(false) .deleted(false)
.build() .build()
.unwrap(); .unwrap();
@ -75,8 +65,8 @@ pub mod tests {
use super::*; use super::*;
use crate::ordering::domain::kot_added_event::tests::get_added_kot_event_from_command; use crate::ordering::domain::kot_added_event::tests::get_added_kot_event_from_command;
use crate::tests::bdd::*;
use crate::utils::uuid::tests::UUID; use crate::utils::uuid::tests::UUID;
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
pub fn mock_add_kot_service(times: Option<usize>, cmd: AddKotCommand) -> AddKotServiceObj { pub fn mock_add_kot_service(times: Option<usize>, cmd: AddKotCommand) -> AddKotServiceObj {
let mut m = MockAddKotUseCase::new(); let mut m = MockAddKotUseCase::new();
@ -100,7 +90,6 @@ pub mod tests {
let s = AddKotServiceBuilder::default() let s = AddKotServiceBuilder::default()
.db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.db_order_id_exists(mock_order_id_exists_db_port_true(IS_CALLED_ONLY_ONCE)) .db_order_id_exists(mock_order_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
.build() .build()
.unwrap(); .unwrap();
@ -118,7 +107,6 @@ pub mod tests {
let s = AddKotServiceBuilder::default() let s = AddKotServiceBuilder::default()
.db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_NEVER_CALLED)) .db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_NEVER_CALLED))
.db_order_id_exists(mock_order_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_order_id_exists(mock_order_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.get_uuid(mock_get_uuid(IS_NEVER_CALLED))
.build() .build()
.unwrap(); .unwrap();

28
src/ordering/application/services/add_line_item_service.rs
View file

@ -15,7 +15,6 @@ use crate::ordering::{
application::port::output::db::line_item_id_exists::*, application::port::output::db::line_item_id_exists::*,
domain::{add_line_item_command::*, line_item_added_event::*, line_item_aggregate::*}, domain::{add_line_item_command::*, line_item_added_event::*, line_item_aggregate::*},
}; };
use crate::utils::uuid::*;
#[automock] #[automock]
#[async_trait::async_trait] #[async_trait::async_trait]
@ -29,7 +28,6 @@ pub type AddLineItemServiceObj = Arc<dyn AddLineItemUseCase>;
pub struct AddLineItemService { pub struct AddLineItemService {
db_line_item_id_exists: LineItemIDExistsDBPortObj, db_line_item_id_exists: LineItemIDExistsDBPortObj,
db_kot_id_exists: KotIDExistsDBPortObj, db_kot_id_exists: KotIDExistsDBPortObj,
get_uuid: GetUUIDInterfaceObj,
} }
#[async_trait::async_trait] #[async_trait::async_trait]
@ -39,19 +37,12 @@ impl AddLineItemUseCase for AddLineItemService {
return Err(OrderingError::KotIDNotFound); return Err(OrderingError::KotIDNotFound);
} }
let mut line_item_id = self.get_uuid.get_uuid(); if self
.db_line_item_id_exists
loop { .line_item_id_exists(cmd.line_item_id())
if self .await?
.db_line_item_id_exists {
.line_item_id_exists(&line_item_id) return Err(OrderingError::DuplicateLineItemID);
.await?
{
line_item_id = self.get_uuid.get_uuid();
continue;
} else {
break;
}
} }
let line_item = LineItemBuilder::default() let line_item = LineItemBuilder::default()
@ -59,7 +50,7 @@ impl AddLineItemUseCase for AddLineItemService {
.product_name(cmd.product_name().into()) .product_name(cmd.product_name().into())
.product_id(*cmd.product_id()) .product_id(*cmd.product_id())
.kot_id(*cmd.kot_id()) .kot_id(*cmd.kot_id())
.line_item_id(line_item_id) .line_item_id(*cmd.line_item_id())
.quantity(cmd.quantity().clone()) .quantity(cmd.quantity().clone())
.deleted(false) .deleted(false)
.build() .build()
@ -78,8 +69,8 @@ pub mod tests {
use super::*; use super::*;
use crate::ordering::domain::line_item_added_event::tests::get_added_line_item_event_from_command; use crate::ordering::domain::line_item_added_event::tests::get_added_line_item_event_from_command;
use crate::tests::bdd::*;
use crate::utils::uuid::tests::UUID; use crate::utils::uuid::tests::UUID;
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
pub fn mock_add_line_item_service( pub fn mock_add_line_item_service(
times: Option<usize>, times: Option<usize>,
@ -106,7 +97,6 @@ pub mod tests {
let s = AddLineItemServiceBuilder::default() let s = AddLineItemServiceBuilder::default()
.db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.db_kot_id_exists(mock_kot_id_exists_db_port_true(IS_CALLED_ONLY_ONCE)) .db_kot_id_exists(mock_kot_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
.build() .build()
.unwrap(); .unwrap();
@ -117,6 +107,7 @@ pub mod tests {
assert_eq!(res.line_item().quantity(), cmd.quantity()); assert_eq!(res.line_item().quantity(), cmd.quantity());
assert_eq!(res.line_item().quantity(), cmd.quantity()); assert_eq!(res.line_item().quantity(), cmd.quantity());
assert_eq!(res.line_item().created_time(), cmd.created_time()); assert_eq!(res.line_item().created_time(), cmd.created_time());
assert_eq!(res.line_item().line_item_id(), cmd.line_item_id());
assert!(!res.line_item().deleted()); assert!(!res.line_item().deleted());
assert_eq!(res.added_by_user(), cmd.adding_by()); assert_eq!(res.added_by_user(), cmd.adding_by());
} }
@ -128,7 +119,6 @@ pub mod tests {
let s = AddLineItemServiceBuilder::default() let s = AddLineItemServiceBuilder::default()
.db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_NEVER_CALLED)) .db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_NEVER_CALLED))
.db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.get_uuid(mock_get_uuid(IS_NEVER_CALLED))
.build() .build()
.unwrap(); .unwrap();

54
src/ordering/application/services/add_order_service.rs
View file

@ -11,10 +11,9 @@ use time::OffsetDateTime;
use super::errors::*; use super::errors::*;
use crate::ordering::{ use crate::ordering::{
application::port::output::db::order_id_exists::*, application::port::output::db::{order_id_exists::*, store_id_exists::*},
domain::{add_order_command::*, order_added_event::*, order_aggregate::*}, domain::{add_order_command::*, order_added_event::*, order_aggregate::*},
}; };
use crate::utils::uuid::*;
#[automock] #[automock]
#[async_trait::async_trait] #[async_trait::async_trait]
@ -27,27 +26,33 @@ pub type AddOrderServiceObj = Arc<dyn AddOrderUseCase>;
#[derive(Clone, Builder)] #[derive(Clone, Builder)]
pub struct AddOrderService { pub struct AddOrderService {
db_order_id_exists: OrderIDExistsDBPortObj, db_order_id_exists: OrderIDExistsDBPortObj,
get_uuid: GetUUIDInterfaceObj, db_store_id_exists: StoreIDExistsDBPortObj,
} }
#[async_trait::async_trait] #[async_trait::async_trait]
impl AddOrderUseCase for AddOrderService { impl AddOrderUseCase for AddOrderService {
async fn add_order(&self, cmd: AddOrderCommand) -> OrderingResult<OrderAddedEvent> { async fn add_order(&self, cmd: AddOrderCommand) -> OrderingResult<OrderAddedEvent> {
let mut order_id = self.get_uuid.get_uuid(); if !self
.db_store_id_exists
.store_id_exists(cmd.store_id())
.await?
{
return Err(OrderingError::StoreIDNotFound);
}
loop { if self
if self.db_order_id_exists.order_id_exists(&order_id).await? { .db_order_id_exists
order_id = self.get_uuid.get_uuid(); .order_id_exists(cmd.order_id())
continue; .await?
} else { {
break; return Err(OrderingError::DuplicateOrderID);
}
} }
let order = OrderBuilder::default() let order = OrderBuilder::default()
.created_time(OffsetDateTime::now_utc()) .created_time(OffsetDateTime::now_utc())
.customer_name(cmd.customer_name().into()) .customer_name(cmd.customer_name().clone())
.order_id(order_id) .order_id(*cmd.order_id())
.store_id(*cmd.store_id())
.deleted(false) .deleted(false)
.build() .build()
.unwrap(); .unwrap();
@ -65,8 +70,7 @@ pub mod tests {
use super::*; use super::*;
use crate::ordering::domain::order_added_event::tests::get_added_order_event_from_command; use crate::ordering::domain::order_added_event::tests::get_added_order_event_from_command;
use crate::utils::uuid::tests::UUID; use crate::tests::bdd::*;
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
pub fn mock_add_order_service( pub fn mock_add_order_service(
times: Option<usize>, times: Option<usize>,
@ -92,7 +96,7 @@ pub mod tests {
let s = AddOrderServiceBuilder::default() let s = AddOrderServiceBuilder::default()
.db_order_id_exists(mock_order_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_order_id_exists(mock_order_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE)) .db_store_id_exists(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
.build() .build()
.unwrap(); .unwrap();
@ -100,5 +104,23 @@ pub mod tests {
assert_eq!(res.order().customer_name(), cmd.customer_name()); assert_eq!(res.order().customer_name(), cmd.customer_name());
assert!(!res.order().deleted()); assert!(!res.order().deleted());
assert_eq!(res.added_by_user(), cmd.adding_by()); assert_eq!(res.added_by_user(), cmd.adding_by());
assert_eq!(res.order().store_id(), cmd.store_id());
assert_eq!(res.order().order_id(), cmd.order_id());
}
#[actix_rt::test]
async fn test_service_store_id_doesnt_exist() {
let cmd = AddOrderCommand::get_cmd();
let s = AddOrderServiceBuilder::default()
.db_order_id_exists(mock_order_id_exists_db_port_false(IS_NEVER_CALLED))
.db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.build()
.unwrap();
assert_eq!(
s.add_order(cmd.clone()).await,
Err(OrderingError::StoreIDNotFound)
);
} }
} }

33
src/ordering/application/services/add_product_service.rs
View file

@ -23,7 +23,6 @@ use crate::ordering::{
product_aggregate::*, product_aggregate::*,
}, },
}; };
use crate::utils::uuid::*;
#[automock] #[automock]
#[async_trait::async_trait] #[async_trait::async_trait]
@ -40,7 +39,6 @@ pub struct AddProductService {
db_product_id_exists: ProductIDExistsDBPortObj, db_product_id_exists: ProductIDExistsDBPortObj,
db_get_category: GetCategoryDBPortObj, db_get_category: GetCategoryDBPortObj,
fts_add_product: AddProductToStoreFTSPortObj, fts_add_product: AddProductToStoreFTSPortObj,
get_uuid: GetUUIDInterfaceObj,
} }
#[async_trait::async_trait] #[async_trait::async_trait]
@ -54,19 +52,12 @@ impl AddProductUseCase for AddProductService {
return Err(OrderingError::CategoryIDNotFound); return Err(OrderingError::CategoryIDNotFound);
} }
let mut product_id = self.get_uuid.get_uuid(); if self
.db_product_id_exists
loop { .product_id_exists(cmd.product_id())
if self .await?
.db_product_id_exists {
.product_id_exists(&product_id) return Err(OrderingError::DuplicateProductID);
.await?
{
product_id = self.get_uuid.get_uuid();
continue;
} else {
break;
}
} }
let product = ProductBuilder::default() let product = ProductBuilder::default()
@ -77,7 +68,7 @@ impl AddProductUseCase for AddProductService {
.price(cmd.price().clone()) .price(cmd.price().clone())
.category_id(*cmd.category_id()) .category_id(*cmd.category_id())
.quantity(cmd.quantity().clone()) .quantity(cmd.quantity().clone())
.product_id(product_id) .product_id(*cmd.product_id())
.build() .build()
.unwrap(); .unwrap();
@ -119,8 +110,7 @@ pub mod tests {
use super::*; use super::*;
use crate::ordering::domain::add_product_command::tests::get_command; use crate::ordering::domain::add_product_command::tests::get_command;
use crate::utils::uuid::tests::UUID; use crate::tests::bdd::*;
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
pub fn mock_add_product_service( pub fn mock_add_product_service(
times: Option<usize>, times: Option<usize>,
@ -135,7 +125,7 @@ pub mod tests {
.image(cmd.image().as_ref().map(|s| s.to_string())) .image(cmd.image().as_ref().map(|s| s.to_string()))
.sku_able(cmd.sku_able().clone()) .sku_able(cmd.sku_able().clone())
.category_id(cmd.category_id().clone()) .category_id(cmd.category_id().clone())
.product_id(UUID.clone()) .product_id(*cmd.product_id())
.price(cmd.price().clone()) .price(cmd.price().clone())
.quantity(cmd.quantity().clone()) .quantity(cmd.quantity().clone())
.added_by_user(cmd.adding_by().clone()) .added_by_user(cmd.adding_by().clone())
@ -165,7 +155,6 @@ pub mod tests {
.db_get_category(mock_get_category_db_port(IS_CALLED_ONLY_ONCE)) .db_get_category(mock_get_category_db_port(IS_CALLED_ONLY_ONCE))
.db_category_id_exists(mock_category_id_exists_db_port_true(IS_CALLED_ONLY_ONCE)) .db_category_id_exists(mock_category_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
.fts_add_product(mock_add_product_to_store_fts_port(IS_CALLED_ONLY_ONCE)) .fts_add_product(mock_add_product_to_store_fts_port(IS_CALLED_ONLY_ONCE))
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
.build() .build()
.unwrap(); .unwrap();
@ -177,7 +166,7 @@ pub mod tests {
assert_eq!(res.price(), cmd.price()); assert_eq!(res.price(), cmd.price());
assert_eq!(res.added_by_user(), cmd.adding_by()); assert_eq!(res.added_by_user(), cmd.adding_by());
assert_eq!(res.category_id(), cmd.category_id()); assert_eq!(res.category_id(), cmd.category_id());
assert_eq!(res.product_id(), &UUID); assert_eq!(res.product_id(), cmd.product_id());
assert_eq!(res.quantity(), cmd.quantity()); assert_eq!(res.quantity(), cmd.quantity());
} }
@ -190,7 +179,6 @@ pub mod tests {
mock_product_name_exists_for_category_db_port_true(IS_CALLED_ONLY_ONCE), mock_product_name_exists_for_category_db_port_true(IS_CALLED_ONLY_ONCE),
) )
.db_category_id_exists(mock_category_id_exists_db_port_true(IS_CALLED_ONLY_ONCE)) .db_category_id_exists(mock_category_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
.db_product_id_exists(mock_product_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_product_id_exists(mock_product_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.db_get_category(mock_get_category_db_port(IS_NEVER_CALLED)) .db_get_category(mock_get_category_db_port(IS_NEVER_CALLED))
.fts_add_product(mock_add_product_to_store_fts_port(IS_NEVER_CALLED)) .fts_add_product(mock_add_product_to_store_fts_port(IS_NEVER_CALLED))
@ -215,7 +203,6 @@ pub mod tests {
.db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.db_get_category(mock_get_category_db_port(IS_NEVER_CALLED)) .db_get_category(mock_get_category_db_port(IS_NEVER_CALLED))
.fts_add_product(mock_add_product_to_store_fts_port(IS_NEVER_CALLED)) .fts_add_product(mock_add_product_to_store_fts_port(IS_NEVER_CALLED))
.get_uuid(mock_get_uuid(IS_NEVER_CALLED))
.build() .build()
.unwrap(); .unwrap();

47
src/ordering/application/services/add_store_service.rs
View file

@ -12,12 +12,11 @@ use super::errors::*;
use crate::ordering::{ use crate::ordering::{
application::port::output::db::{store_id_exists::*, store_name_exists::*}, application::port::output::db::{store_id_exists::*, store_name_exists::*},
domain::{ domain::{
add_store_command::AddStoreCommand, add_store_command::*,
store_added_event::{StoreAddedEvent, StoreAddedEventBuilder}, store_added_event::{StoreAddedEvent, StoreAddedEventBuilder},
store_aggregate::*, store_aggregate::*,
}, },
}; };
use crate::utils::uuid::*;
#[automock] #[automock]
#[async_trait::async_trait] #[async_trait::async_trait]
@ -31,28 +30,24 @@ pub type AddStoreServiceObj = Arc<dyn AddStoreUseCase>;
pub struct AddStoreService { pub struct AddStoreService {
db_store_id_exists: StoreIDExistsDBPortObj, db_store_id_exists: StoreIDExistsDBPortObj,
db_store_name_exists: StoreNameExistsDBPortObj, db_store_name_exists: StoreNameExistsDBPortObj,
get_uuid: GetUUIDInterfaceObj,
} }
#[async_trait::async_trait] #[async_trait::async_trait]
impl AddStoreUseCase for AddStoreService { impl AddStoreUseCase for AddStoreService {
async fn add_store(&self, cmd: AddStoreCommand) -> OrderingResult<StoreAddedEvent> { async fn add_store(&self, cmd: AddStoreCommand) -> OrderingResult<StoreAddedEvent> {
let mut store_id = self.get_uuid.get_uuid(); if self
.db_store_id_exists
loop { .store_id_exists(cmd.store_id())
if self.db_store_id_exists.store_id_exists(&store_id).await? { .await?
store_id = self.get_uuid.get_uuid(); {
continue; return Err(OrderingError::DuplicateStoreID);
} else {
break;
}
} }
let store = StoreBuilder::default() let store = StoreBuilder::default()
.name(cmd.name().into()) .name(cmd.name().into())
.address(cmd.address().as_ref().map(|s| s.to_string())) .address(cmd.address().as_ref().map(|s| s.to_string()))
.owner(*cmd.owner()) .owner(*cmd.owner())
.store_id(store_id) .store_id(*cmd.store_id())
.build() .build()
.unwrap(); .unwrap();
@ -64,7 +59,7 @@ impl AddStoreUseCase for AddStoreService {
.name(store.name().into()) .name(store.name().into())
.address(store.address().as_ref().map(|s| s.to_string())) .address(store.address().as_ref().map(|s| s.to_string()))
.owner(*cmd.owner()) .owner(*cmd.owner())
.store_id(store_id) .store_id(*cmd.store_id())
.build() .build()
.unwrap()) .unwrap())
} }
@ -87,7 +82,7 @@ pub mod tests {
.name(cmd.name().into()) .name(cmd.name().into())
.address(cmd.address().as_ref().map(|s| s.to_string())) .address(cmd.address().as_ref().map(|s| s.to_string()))
.owner(*cmd.owner()) .owner(*cmd.owner())
.store_id(UUID) .store_id(*cmd.store_id())
.build() .build()
.unwrap(); .unwrap();
@ -108,13 +103,17 @@ pub mod tests {
let address = "bar"; let address = "bar";
let owner = UUID; let owner = UUID;
// address = None let cmd = AddStoreCommandBuilder::default()
let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap(); .name(name.into())
.address(Some(address.into()))
.owner(owner)
.store_id(UUID)
.build()
.unwrap();
let s = AddStoreServiceBuilder::default() let s = AddStoreServiceBuilder::default()
.db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.db_store_name_exists(mock_store_name_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_store_name_exists(mock_store_name_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
.build() .build()
.unwrap(); .unwrap();
@ -122,7 +121,7 @@ pub mod tests {
assert_eq!(res.name(), cmd.name()); assert_eq!(res.name(), cmd.name());
assert_eq!(res.address(), cmd.address()); assert_eq!(res.address(), cmd.address());
assert_eq!(res.owner(), cmd.owner()); assert_eq!(res.owner(), cmd.owner());
assert_eq!(res.store_id(), &UUID); assert_eq!(res.store_id(), cmd.store_id());
} }
#[actix_rt::test] #[actix_rt::test]
@ -131,13 +130,17 @@ pub mod tests {
let address = "bar"; let address = "bar";
let owner = UUID; let owner = UUID;
// address = None let cmd = AddStoreCommandBuilder::default()
let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap(); .name(name.into())
.address(Some(address.into()))
.owner(owner)
.store_id(UUID)
.build()
.unwrap();
let s = AddStoreServiceBuilder::default() let s = AddStoreServiceBuilder::default()
.db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE)) .db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
.db_store_name_exists(mock_store_name_exists_db_port_true(IS_CALLED_ONLY_ONCE)) .db_store_name_exists(mock_store_name_exists_db_port_true(IS_CALLED_ONLY_ONCE))
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
.build() .build()
.unwrap(); .unwrap();

3
src/ordering/application/services/delete_order_service.rs
View file

@ -42,8 +42,9 @@ impl DeleteOrderUseCase for DeleteOrderService {
let deleted_order = OrderBuilder::default() let deleted_order = OrderBuilder::default()
.created_time(cmd.order().created_time().clone()) .created_time(cmd.order().created_time().clone())
.customer_name(cmd.order().customer_name().into()) .customer_name(cmd.order().customer_name().clone())
.order_id(*cmd.order().order_id()) .order_id(*cmd.order().order_id())
.store_id(*cmd.order().store_id())
.deleted(true) .deleted(true)
.build() .build()
.unwrap(); .unwrap();

45
src/ordering/application/services/errors.rs
View file

@ -26,52 +26,37 @@ pub enum OrderingError {
ProductIDNotFound, ProductIDNotFound,
DuplicateCustomizationName, DuplicateCustomizationName,
CustomizationIDNotFound, CustomizationIDNotFound,
DuplicateKotID,
DuplicateOrderID,
DuplicateStoreID,
DuplicateCustomizationID,
DuplicateProductID,
DuplicateCategoryID,
DuplicateLineItemID,
} }
// //
impl From<OrderingDBError> for OrderingError { impl From<OrderingDBError> for OrderingError {
fn from(value: OrderingDBError) -> Self { fn from(value: OrderingDBError) -> Self {
match value { match value {
OrderingDBError::DuplicateLineItemID => { OrderingDBError::DuplicateLineItemID => Self::DuplicateLineItemID,
error!("DuplicateLineItemID");
Self::InternalError
}
OrderingDBError::LineItemIDNotFound => OrderingError::LineItemIDNotFound, OrderingDBError::LineItemIDNotFound => OrderingError::LineItemIDNotFound,
OrderingDBError::DuplicateOrderID => { OrderingDBError::DuplicateOrderID => Self::DuplicateOrderID,
error!("DuplicateOrderID");
Self::InternalError
}
OrderingDBError::DuplicateStoreName => Self::DuplicateStoreName, OrderingDBError::DuplicateStoreName => Self::DuplicateStoreName,
OrderingDBError::DuplicateStoreID => { OrderingDBError::DuplicateStoreID => Self::DuplicateStoreID,
error!("DuplicateStoreID");
Self::InternalError
}
OrderingDBError::StoreIDNotFound => OrderingError::StoreIDNotFound, OrderingDBError::StoreIDNotFound => OrderingError::StoreIDNotFound,
OrderingDBError::OrderIDNotFound => OrderingError::OrderIDNotFound, OrderingDBError::OrderIDNotFound => OrderingError::OrderIDNotFound,
OrderingDBError::DuplicateKotID => Self::DuplicateKotID,
OrderingDBError::DuplicateKotID => {
error!("DuplicateKotID");
Self::InternalError
}
OrderingDBError::KotIDNotFound => OrderingError::KotIDNotFound, OrderingDBError::KotIDNotFound => OrderingError::KotIDNotFound,
OrderingDBError::InternalError => Self::InternalError, OrderingDBError::InternalError => Self::InternalError,
OrderingDBError::DuplicateCategoryName => Self::DuplicateCategoryName, OrderingDBError::DuplicateCategoryName => Self::DuplicateCategoryName,
OrderingDBError::DuplicateCategoryID => { OrderingDBError::DuplicateCategoryID => Self::DuplicateCategoryID,
error!("DuplicateCategoryID");
Self::InternalError
}
OrderingDBError::CategoryIDNotFound => OrderingError::CategoryIDNotFound, OrderingDBError::CategoryIDNotFound => OrderingError::CategoryIDNotFound,
OrderingDBError::DuplicateProductName => Self::DuplicateProductName, OrderingDBError::DuplicateProductName => Self::DuplicateProductName,
OrderingDBError::DuplicateProductID => { OrderingDBError::DuplicateProductID => Self::DuplicateProductID,
error!("DuplicateProductID");
Self::InternalError
}
OrderingDBError::ProductIDNotFound => OrderingError::ProductIDNotFound, OrderingDBError::ProductIDNotFound => OrderingError::ProductIDNotFound,
OrderingDBError::DuplicateCustomizationName => Self::DuplicateCustomizationName, OrderingDBError::DuplicateCustomizationName => Self::DuplicateCustomizationName,
OrderingDBError::DuplicateCustomizationID => { OrderingDBError::DuplicateCustomizationID => Self::DuplicateCustomizationID,
error!("DuplicateCustomizationID");
Self::InternalError
}
OrderingDBError::CustomizationIDNotFound => OrderingError::CustomizationIDNotFound, OrderingDBError::CustomizationIDNotFound => OrderingError::CustomizationIDNotFound,
} }
} }

7
src/ordering/application/services/update_order_service.rs
View file

@ -7,14 +7,12 @@ use std::sync::Arc;
use derive_builder::Builder; use derive_builder::Builder;
use mockall::predicate::*; use mockall::predicate::*;
use mockall::*; use mockall::*;
use time::OffsetDateTime;
use super::errors::*; use super::errors::*;
use crate::ordering::{ use crate::ordering::{
application::port::output::db::order_id_exists::*, application::port::output::db::order_id_exists::*,
domain::{order_aggregate::*, order_updated_event::*, update_order_command::*}, domain::{order_aggregate::*, order_updated_event::*, update_order_command::*},
}; };
use crate::utils::uuid::*;
#[automock] #[automock]
#[async_trait::async_trait] #[async_trait::async_trait]
@ -42,7 +40,8 @@ impl UpdateOrderUseCase for UpdateOrderService {
let new_order = OrderBuilder::default() let new_order = OrderBuilder::default()
.created_time(cmd.created_time().clone()) .created_time(cmd.created_time().clone())
.customer_name(cmd.customer_name().into()) .customer_name(cmd.customer_name().clone())
.store_id(*cmd.old_order().store_id())
.order_id(*cmd.old_order().order_id()) .order_id(*cmd.old_order().order_id())
.deleted(false) .deleted(false)
.build() .build()
@ -62,8 +61,8 @@ pub mod tests {
use super::*; use super::*;
use crate::ordering::domain::order_updated_event::tests::get_updated_order_event_from_command; use crate::ordering::domain::order_updated_event::tests::get_updated_order_event_from_command;
use crate::tests::bdd::*;
use crate::utils::uuid::tests::UUID; use crate::utils::uuid::tests::UUID;
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
pub fn mock_update_order_service( pub fn mock_update_order_service(
times: Option<usize>, times: Option<usize>,

90
src/ordering/domain/add_category_command.rs
View file

@ -2,6 +2,7 @@
// //
// SPDX-License-Identifier: AGPL-3.0-or-later // SPDX-License-Identifier: AGPL-3.0-or-later
use derive_builder::Builder;
use derive_getters::Getters; use derive_getters::Getters;
use derive_more::{Display, Error}; use derive_more::{Display, Error};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@ -12,21 +13,22 @@ pub enum AddCategoryCommandError {
NameIsEmpty, NameIsEmpty,
} }
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)] #[derive(
Clone, Debug, Builder, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
)]
#[builder(build_fn(validate = "Self::validate"))]
pub struct AddCategoryCommand { pub struct AddCategoryCommand {
#[builder(setter(custom))]
name: String, name: String,
#[builder(setter(custom))]
description: Option<String>, description: Option<String>,
store_id: Uuid, store_id: Uuid,
category_id: Uuid,
adding_by: Uuid, adding_by: Uuid,
} }
impl AddCategoryCommand { impl AddCategoryCommandBuilder {
pub fn new( pub fn description(&mut self, description: Option<String>) -> &mut Self {
name: String,
description: Option<String>,
store_id: Uuid,
adding_by: Uuid,
) -> Result<Self, AddCategoryCommandError> {
let description: Option<String> = if let Some(description) = description { let description: Option<String> = if let Some(description) = description {
let description = description.trim(); let description = description.trim();
if description.is_empty() { if description.is_empty() {
@ -37,27 +39,46 @@ impl AddCategoryCommand {
} else { } else {
None None
}; };
self.description = Some(description);
self
}
pub fn name(&mut self, name: String) -> &mut Self {
let name = name.trim().to_owned(); let name = name.trim().to_owned();
if name.is_empty() { self.name = Some(name);
return Err(AddCategoryCommandError::NameIsEmpty); self
}
pub fn validate(&self) -> Result<(), String> {
if self.name.as_ref().unwrap().is_empty() {
return Err(AddCategoryCommandError::NameIsEmpty.to_string());
} }
Ok(Self { Ok(())
name,
store_id,
description,
adding_by,
})
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { pub mod tests {
use super::*; use super::*;
use crate::utils::uuid::tests::UUID; use crate::utils::uuid::tests::UUID;
pub fn get_add_category_cmd() -> AddCategoryCommand {
let name = "foo";
let adding_by = UUID;
let store_id = Uuid::new_v4();
AddCategoryCommandBuilder::default()
.name(name.into())
.description(None)
.store_id(store_id)
.adding_by(adding_by)
.category_id(UUID)
.build()
.unwrap()
}
#[test] #[test]
fn test_cmd() { fn test_cmd() {
let name = "foo"; let name = "foo";
@ -65,26 +86,41 @@ mod tests {
let adding_by = UUID; let adding_by = UUID;
let store_id = Uuid::new_v4(); let store_id = Uuid::new_v4();
// description = None let cmd = AddCategoryCommandBuilder::default()
let cmd = AddCategoryCommand::new(name.into(), None, store_id, adding_by).unwrap(); .name(name.into())
.description(None)
.store_id(store_id)
.adding_by(adding_by)
.category_id(UUID)
.build()
.unwrap();
assert_eq!(cmd.name(), name); assert_eq!(cmd.name(), name);
assert_eq!(cmd.description(), &None); assert_eq!(cmd.description(), &None);
assert_eq!(cmd.adding_by(), &adding_by); assert_eq!(cmd.adding_by(), &adding_by);
assert_eq!(cmd.store_id(), &store_id); assert_eq!(cmd.store_id(), &store_id);
// description = Some let cmd = AddCategoryCommandBuilder::default()
let cmd = .name(name.into())
AddCategoryCommand::new(name.into(), Some(description.into()), store_id, adding_by) .description(Some(description.into()))
.unwrap(); .store_id(store_id)
.adding_by(adding_by)
.category_id(UUID)
.build()
.unwrap();
assert_eq!(cmd.name(), name); assert_eq!(cmd.name(), name);
assert_eq!(cmd.description(), &Some(description.to_owned())); assert_eq!(cmd.description(), &Some(description.to_owned()));
assert_eq!(cmd.adding_by(), &adding_by); assert_eq!(cmd.adding_by(), &adding_by);
assert_eq!(cmd.store_id(), &store_id); assert_eq!(cmd.store_id(), &store_id);
// AddCategoryCommandError::NameIsEmpty // AddCategoryCommandError::NameIsEmpty
assert_eq!( assert!(AddCategoryCommandBuilder::default()
AddCategoryCommand::new("".into(), Some(description.into()), store_id, adding_by,), .name("".into())
Err(AddCategoryCommandError::NameIsEmpty) .description(Some(description.into()))
) .store_id(store_id)
.adding_by(adding_by)
.category_id(UUID)
.build()
.is_err())
} }
} }

55
src/ordering/domain/add_customization_command.rs
View file

@ -16,28 +16,26 @@ pub enum AddCustomizationCommandError {
#[derive( #[derive(
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder, Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
)] )]
pub struct UnvalidatedAddCustomizationCommand { #[builder(build_fn(validate = "Self::validate"))]
name: String,
product_id: Uuid,
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
pub struct AddCustomizationCommand { pub struct AddCustomizationCommand {
#[builder(setter(custom))]
name: String, name: String,
product_id: Uuid, product_id: Uuid,
customization_id: Uuid,
} }
impl UnvalidatedAddCustomizationCommand { impl AddCustomizationCommandBuilder {
pub fn validate(self) -> Result<AddCustomizationCommand, AddCustomizationCommandError> { pub fn name(&mut self, name: String) -> &mut Self {
let name = self.name.trim().to_owned(); self.name = Some(name.trim().to_owned());
if name.is_empty() { self
return Err(AddCustomizationCommandError::NameIsEmpty); }
}
Ok(AddCustomizationCommand { fn validate(&self) -> Result<(), String> {
name, let name = self.name.as_ref().unwrap().trim().to_owned();
product_id: self.product_id, if name.is_empty() {
}) return Err(AddCustomizationCommandError::NameIsEmpty.to_string());
}
Ok(())
} }
} }
@ -48,13 +46,12 @@ pub mod tests {
use crate::utils::uuid::tests::UUID; use crate::utils::uuid::tests::UUID;
pub fn get_command() -> AddCustomizationCommand { pub fn get_command() -> AddCustomizationCommand {
UnvalidatedAddCustomizationCommandBuilder::default() AddCustomizationCommandBuilder::default()
.name("foo".into()) .name("foo".into())
.product_id(UUID.clone()) .product_id(UUID.clone())
.customization_id(UUID.clone())
.build() .build()
.unwrap() .unwrap()
.validate()
.unwrap()
} }
#[test] #[test]
@ -62,12 +59,11 @@ pub mod tests {
let name = "foo"; let name = "foo";
let product_id = UUID; let product_id = UUID;
let cmd = UnvalidatedAddCustomizationCommandBuilder::default() let cmd = AddCustomizationCommandBuilder::default()
.name(name.into()) .name(name.into())
.product_id(product_id.clone()) .product_id(product_id.clone())
.customization_id(UUID.clone())
.build() .build()
.unwrap()
.validate()
.unwrap(); .unwrap();
assert_eq!(cmd.name(), name); assert_eq!(cmd.name(), name);
@ -78,14 +74,11 @@ pub mod tests {
fn test_cmd_name_is_empty() { fn test_cmd_name_is_empty() {
let product_id = UUID; let product_id = UUID;
assert_eq!( assert!(AddCustomizationCommandBuilder::default()
UnvalidatedAddCustomizationCommandBuilder::default() .name("".into())
.name("".into()) .product_id(product_id.clone())
.product_id(product_id.clone()) .customization_id(UUID.clone())
.build() .build()
.unwrap() .is_err(),);
.validate(),
Err(AddCustomizationCommandError::NameIsEmpty)
);
} }
} }

4
src/ordering/domain/add_kot_command.rs
View file

@ -17,6 +17,7 @@ pub struct AddKotCommand {
#[builder(default = "OffsetDateTime::now_utc()")] #[builder(default = "OffsetDateTime::now_utc()")]
created_time: OffsetDateTime, created_time: OffsetDateTime,
order_id: Uuid, order_id: Uuid,
kot_id: Uuid,
} }
#[cfg(test)] #[cfg(test)]
@ -36,6 +37,7 @@ mod tests {
.adding_by(adding_by) .adding_by(adding_by)
.created_time(datetime!(1970-01-01 0:00 UTC)) .created_time(datetime!(1970-01-01 0:00 UTC))
.order_id(order_id) .order_id(order_id)
.kot_id(UUID)
.build() .build()
.unwrap() .unwrap()
} }
@ -49,10 +51,12 @@ mod tests {
let cmd = AddKotCommandBuilder::default() let cmd = AddKotCommandBuilder::default()
.adding_by(adding_by) .adding_by(adding_by)
.order_id(order_id) .order_id(order_id)
.kot_id(UUID)
.build() .build()
.unwrap(); .unwrap();
assert_eq!(*cmd.order_id(), order_id); assert_eq!(*cmd.order_id(), order_id);
assert_eq!(*cmd.kot_id(), UUID);
assert_eq!(*cmd.adding_by(), adding_by); assert_eq!(*cmd.adding_by(), adding_by);
} }
} }

112
src/ordering/domain/add_line_item_command.rs
View file

@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
use time::OffsetDateTime; use time::OffsetDateTime;
use uuid::Uuid; use uuid::Uuid;
use crate::types::quantity::*; use crate::types::{currency::*, quantity::*};
use crate::utils::string::empty_string_err; use crate::utils::string::empty_string_err;
#[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)] #[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
@ -19,52 +19,41 @@ pub enum AddLineItemCommandError {
} }
#[derive( #[derive(
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder, Clone, Debug, Builder, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
)] )]
pub struct UnvalidatedAddLineItemCommand { #[builder(build_fn(validate = "Self::validate"))]
adding_by: Uuid, pub struct AddLineItemCommand {
#[builder(default = "OffsetDateTime::now_utc()")] #[builder(default = "OffsetDateTime::now_utc()")]
created_time: OffsetDateTime, created_time: OffsetDateTime,
#[builder(setter(custom))]
product_name: String, product_name: String,
product_id: Uuid, product_id: Uuid,
kot_id: Uuid, kot_id: Uuid,
quantity: Quantity, line_item_id: Uuid,
}
impl UnvalidatedAddLineItemCommand {
pub fn validate(self) -> Result<AddLineItemCommand, AddLineItemCommandError> {
let product_name = empty_string_err(
self.product_name,
AddLineItemCommandError::ProductNameIsEmpty,
)?;
if self.quantity.is_empty() {
return Err(AddLineItemCommandError::QuantityIsEmpty);
}
Ok(AddLineItemCommand {
created_time: self.created_time,
product_name,
product_id: self.product_id,
kot_id: self.kot_id,
quantity: self.quantity,
adding_by: self.adding_by,
})
}
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
pub struct AddLineItemCommand {
created_time: OffsetDateTime,
product_name: String,
product_id: Uuid,
kot_id: Uuid,
quantity: Quantity, quantity: Quantity,
adding_by: Uuid, adding_by: Uuid,
} }
impl AddLineItemCommandBuilder {
pub fn product_name(&mut self, product_name: String) -> &mut Self {
self.product_name = Some(product_name.trim().to_owned());
self
}
fn validate(&self) -> Result<(), String> {
let product_name = self.product_name.as_ref().unwrap().trim().to_owned();
if product_name.is_empty() {
return Err(AddLineItemCommandError::ProductNameIsEmpty.to_string());
}
if self.quantity.as_ref().unwrap().is_empty() {
return Err(AddLineItemCommandError::QuantityIsEmpty.to_string());
}
Ok(())
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use time::macros::datetime; use time::macros::datetime;
@ -81,17 +70,16 @@ mod tests {
let adding_by = UUID; let adding_by = UUID;
let quantity = Quantity::get_quantity(); let quantity = Quantity::get_quantity();
UnvalidatedAddLineItemCommandBuilder::default() AddLineItemCommandBuilder::default()
.product_name(product_name.into()) .product_name(product_name.into())
.adding_by(adding_by) .adding_by(adding_by)
.created_time(datetime!(1970-01-01 0:00 UTC)) .created_time(datetime!(1970-01-01 0:00 UTC))
.quantity(quantity.clone()) .quantity(quantity.clone())
.product_id(product_id) .product_id(product_id)
.kot_id(kot_id) .kot_id(kot_id)
.line_item_id(UUID)
.build() .build()
.unwrap() .unwrap()
.validate()
.unwrap()
} }
} }
@ -103,15 +91,14 @@ mod tests {
let adding_by = UUID; let adding_by = UUID;
let quantity = Quantity::get_quantity(); let quantity = Quantity::get_quantity();
let cmd = UnvalidatedAddLineItemCommandBuilder::default() let cmd = AddLineItemCommandBuilder::default()
.product_name(product_name.into()) .product_name(product_name.into())
.adding_by(adding_by) .adding_by(adding_by)
.quantity(quantity.clone()) .quantity(quantity.clone())
.product_id(product_id) .product_id(product_id)
.kot_id(kot_id) .kot_id(kot_id)
.line_item_id(UUID)
.build() .build()
.unwrap()
.validate()
.unwrap(); .unwrap();
assert_eq!(cmd.quantity(), &quantity); assert_eq!(cmd.quantity(), &quantity);
@ -128,18 +115,15 @@ mod tests {
let adding_by = UUID; let adding_by = UUID;
let quantity = Quantity::get_quantity(); let quantity = Quantity::get_quantity();
assert_eq!( assert!(AddLineItemCommandBuilder::default()
UnvalidatedAddLineItemCommandBuilder::default() .product_name(product_name.into())
.product_name(product_name.into()) .adding_by(adding_by)
.adding_by(adding_by) .quantity(quantity.clone())
.quantity(quantity.clone()) .product_id(product_id)
.product_id(product_id) .line_item_id(UUID)
.kot_id(kot_id) .kot_id(kot_id)
.build() .build()
.unwrap() .is_err());
.validate(),
Err(AddLineItemCommandError::ProductNameIsEmpty)
);
} }
#[test] #[test]
@ -151,17 +135,13 @@ mod tests {
// minor = 0; major = 0; // minor = 0; major = 0;
let quantity = Quantity::default(); let quantity = Quantity::default();
assert_eq!( assert!(AddLineItemCommandBuilder::default()
UnvalidatedAddLineItemCommandBuilder::default() .product_name(product_name.into())
.product_name(product_name.into()) .adding_by(adding_by)
.adding_by(adding_by) .quantity(quantity.clone())
.quantity(quantity.clone()) .product_id(product_id)
.product_id(product_id) .kot_id(kot_id)
.kot_id(kot_id) .build()
.build() .is_err());
.unwrap()
.validate(),
Err(AddLineItemCommandError::QuantityIsEmpty)
);
} }
} }

79
src/ordering/domain/add_order_command.rs
View file

@ -9,8 +9,6 @@ use serde::{Deserialize, Serialize};
use time::OffsetDateTime; use time::OffsetDateTime;
use uuid::Uuid; use uuid::Uuid;
use crate::utils::string::empty_string_err;
#[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)] #[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
pub enum AddOrderCommandError { pub enum AddOrderCommandError {
CustomerNameIsEmpty, CustomerNameIsEmpty,
@ -19,36 +17,33 @@ pub enum AddOrderCommandError {
#[derive( #[derive(
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder, Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
)] )]
pub struct UnvalidatedAddOrderCommand { pub struct AddOrderCommand {
adding_by: Uuid, adding_by: Uuid,
#[builder(default = "OffsetDateTime::now_utc()")] #[builder(default = "OffsetDateTime::now_utc()")]
created_time: OffsetDateTime, created_time: OffsetDateTime,
customer_name: String, #[builder(setter(custom))]
customer_name: Option<String>,
store_id: Uuid,
order_id: Uuid,
} }
impl UnvalidatedAddOrderCommand { impl AddOrderCommandBuilder {
pub fn validate(self) -> Result<AddOrderCommand, AddOrderCommandError> { pub fn customer_name(&mut self, customer_name: Option<String>) -> &mut Self {
let customer_name = empty_string_err( self.customer_name = if let Some(customer_name) = customer_name {
self.customer_name, let customer_name = customer_name.trim();
AddOrderCommandError::CustomerNameIsEmpty, if customer_name.is_empty() {
)?; Some(None)
} else {
Ok(AddOrderCommand { Some(Some(customer_name.to_string()))
created_time: self.created_time, }
customer_name, } else {
adding_by: self.adding_by, Some(None)
}) };
self
} }
} }
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
pub struct AddOrderCommand {
created_time: OffsetDateTime,
customer_name: String,
adding_by: Uuid,
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use time::macros::datetime; use time::macros::datetime;
@ -62,14 +57,14 @@ mod tests {
let customer_name = "foo"; let customer_name = "foo";
let adding_by = UUID; let adding_by = UUID;
UnvalidatedAddOrderCommandBuilder::default() AddOrderCommandBuilder::default()
.customer_name(customer_name.into()) .customer_name(Some(customer_name.into()))
.adding_by(adding_by) .adding_by(adding_by)
.created_time(datetime!(1970-01-01 0:00 UTC)) .created_time(datetime!(1970-01-01 0:00 UTC))
.store_id(UUID)
.order_id(UUID)
.build() .build()
.unwrap() .unwrap()
.validate()
.unwrap()
} }
} }
@ -78,31 +73,27 @@ mod tests {
let customer_name = "foo"; let customer_name = "foo";
let adding_by = UUID; let adding_by = UUID;
let cmd = UnvalidatedAddOrderCommandBuilder::default() let _cmd = AddOrderCommandBuilder::default()
.customer_name(customer_name.into()) .customer_name(Some(customer_name.into()))
.adding_by(adding_by) .adding_by(adding_by)
.store_id(UUID)
.order_id(UUID)
.build() .build()
.unwrap()
.validate()
.unwrap(); .unwrap();
assert_eq!(*cmd.adding_by(), adding_by);
assert_eq!(cmd.customer_name(), customer_name);
} }
#[test] #[test]
fn test_cmd_customer_name_empty() { fn test_cmd_customer_name_empty() {
let customer_name = ""; let customer_name = "";
let adding_by = UUID;
assert_eq!( let cmd = AddOrderCommandBuilder::default()
UnvalidatedAddOrderCommandBuilder::default() .customer_name(Some(customer_name.into()))
.customer_name(customer_name.into()) .adding_by(UUID)
.adding_by(adding_by) .store_id(UUID)
.build() .order_id(UUID)
.unwrap() .build()
.validate(), .unwrap();
Err(AddOrderCommandError::CustomerNameIsEmpty)
); assert!(cmd.customer_name().is_none());
} }
} }

88
src/ordering/domain/add_product_command.rs
View file

@ -17,24 +17,17 @@ pub enum AddProductCommandError {
} }
#[derive( #[derive(
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder, Clone, Builder, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
)] )]
pub struct UnvalidatedAddProductCommand { #[builder(build_fn(validate = "Self::validate"))]
name: String,
description: Option<String>,
image: Option<String>,
category_id: Uuid,
sku_able: bool,
quantity: Quantity,
price: Price,
adding_by: Uuid,
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
pub struct AddProductCommand { pub struct AddProductCommand {
#[builder(setter(custom))]
name: String, name: String,
#[builder(setter(custom))]
description: Option<String>, description: Option<String>,
#[builder(setter(custom))]
image: Option<String>, image: Option<String>,
product_id: Uuid,
category_id: Uuid, category_id: Uuid,
sku_able: bool, sku_able: bool,
price: Price, price: Price,
@ -42,9 +35,9 @@ pub struct AddProductCommand {
adding_by: Uuid, adding_by: Uuid,
} }
impl UnvalidatedAddProductCommand { impl AddProductCommandBuilder {
pub fn validate(self) -> Result<AddProductCommand, AddProductCommandError> { pub fn description(&mut self, description: Option<String>) -> &mut Self {
let description: Option<String> = if let Some(description) = self.description { let description: Option<String> = if let Some(description) = description {
let description = description.trim(); let description = description.trim();
if description.is_empty() { if description.is_empty() {
None None
@ -54,8 +47,12 @@ impl UnvalidatedAddProductCommand {
} else { } else {
None None
}; };
self.description = Some(description);
self
}
let image: Option<String> = if let Some(image) = self.image { pub fn image(&mut self, image: Option<String>) -> &mut Self {
let image: Option<String> = if let Some(image) = image {
let image = image.trim(); let image = image.trim();
if image.is_empty() { if image.is_empty() {
None None
@ -65,22 +62,22 @@ impl UnvalidatedAddProductCommand {
} else { } else {
None None
}; };
self.image = Some(image);
self
}
let name = self.name.trim().to_owned(); pub fn name(&mut self, name: String) -> &mut Self {
if name.is_empty() { let name = name.trim().to_owned();
return Err(AddProductCommandError::NameIsEmpty); self.name = Some(name);
self
}
pub fn validate(&self) -> Result<(), String> {
if self.name.as_ref().unwrap().is_empty() {
return Err(AddProductCommandError::NameIsEmpty.to_string());
} }
Ok(AddProductCommand { Ok(())
name,
description,
image,
category_id: self.category_id,
sku_able: self.sku_able,
price: self.price,
quantity: self.quantity,
adding_by: self.adding_by,
})
} }
} }
@ -93,7 +90,7 @@ pub mod tests {
pub fn get_command() -> AddProductCommand { pub fn get_command() -> AddProductCommand {
let name = "foo"; let name = "foo";
let adding_by = UUID; let adding_by = UUID;
let category_id = Uuid::new_v4(); let category_id = UUID;
let sku_able = false; let sku_able = false;
let image = Some("image".to_string()); let image = Some("image".to_string());
let description = Some("description".to_string()); let description = Some("description".to_string());
@ -123,7 +120,7 @@ pub mod tests {
.build() .build()
.unwrap(); .unwrap();
let cmd = UnvalidatedAddProductCommandBuilder::default() AddProductCommandBuilder::default()
.name(name.into()) .name(name.into())
.description(description.clone()) .description(description.clone())
.image(image.clone()) .image(image.clone())
@ -131,11 +128,10 @@ pub mod tests {
.adding_by(adding_by) .adding_by(adding_by)
.quantity(quantity) .quantity(quantity)
.sku_able(sku_able) .sku_able(sku_able)
.product_id(UUID)
.price(price.clone()) .price(price.clone())
.build() .build()
.unwrap(); .unwrap()
cmd.validate().unwrap()
} }
#[test] #[test]
@ -155,7 +151,7 @@ pub mod tests {
let quantity = Quantity::default(); let quantity = Quantity::default();
// description = None // description = None
let cmd = UnvalidatedAddProductCommandBuilder::default() let cmd = AddProductCommandBuilder::default()
.name(name.into()) .name(name.into())
.description(None) .description(None)
.image(None) .image(None)
@ -163,12 +159,11 @@ pub mod tests {
.adding_by(adding_by) .adding_by(adding_by)
.quantity(quantity.clone()) .quantity(quantity.clone())
.sku_able(sku_able) .sku_able(sku_able)
.product_id(UUID)
.price(price.clone()) .price(price.clone())
.build() .build()
.unwrap(); .unwrap();
let cmd = cmd.validate().unwrap();
assert_eq!(cmd.name(), name); assert_eq!(cmd.name(), name);
assert_eq!(cmd.description(), &None); assert_eq!(cmd.description(), &None);
assert_eq!(cmd.adding_by(), &adding_by); assert_eq!(cmd.adding_by(), &adding_by);
@ -196,21 +191,19 @@ pub mod tests {
let quantity = Quantity::default(); let quantity = Quantity::default();
let cmd = UnvalidatedAddProductCommandBuilder::default() let cmd = AddProductCommandBuilder::default()
.name(name.into()) .name(name.into())
.description(description.clone()) .description(description.clone())
.image(image.clone()) .image(image.clone())
.category_id(category_id) .category_id(category_id)
.quantity(quantity.clone())
.adding_by(adding_by) .adding_by(adding_by)
.quantity(quantity.clone())
.sku_able(sku_able) .sku_able(sku_able)
.product_id(UUID)
.price(price.clone()) .price(price.clone())
// .customizations(customizations.clone())
.build() .build()
.unwrap(); .unwrap();
let cmd = cmd.validate().unwrap();
assert_eq!(cmd.name(), name); assert_eq!(cmd.name(), name);
assert_eq!(cmd.description(), &description); assert_eq!(cmd.description(), &description);
assert_eq!(cmd.adding_by(), &adding_by); assert_eq!(cmd.adding_by(), &adding_by);
@ -238,7 +231,8 @@ pub mod tests {
let quantity = Quantity::default(); let quantity = Quantity::default();
let cmd = UnvalidatedAddProductCommandBuilder::default() // AddProductCommandError::NameIsEmpty
assert!(AddProductCommandBuilder::default()
.name("".into()) .name("".into())
.description(description.clone()) .description(description.clone())
.image(image.clone()) .image(image.clone())
@ -246,11 +240,9 @@ pub mod tests {
.adding_by(adding_by) .adding_by(adding_by)
.quantity(quantity) .quantity(quantity)
.sku_able(sku_able) .sku_able(sku_able)
.product_id(UUID)
.price(price.clone()) .price(price.clone())
.build() .build()
.unwrap(); .is_err());
// AddProductCommandError::NameIsEmpty
assert_eq!(cmd.validate(), Err(AddProductCommandError::NameIsEmpty))
} }
} }

79
src/ordering/domain/add_store_command.rs
View file

@ -2,6 +2,7 @@
// //
// SPDX-License-Identifier: AGPL-3.0-or-later // SPDX-License-Identifier: AGPL-3.0-or-later
use derive_builder::Builder;
use derive_getters::Getters; use derive_getters::Getters;
use derive_more::{Display, Error}; use derive_more::{Display, Error};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@ -12,46 +13,52 @@ pub enum AddStoreCommandError {
NameIsEmpty, NameIsEmpty,
} }
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)] #[derive(
Clone, Builder, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
)]
#[builder(build_fn(validate = "Self::validate"))]
pub struct AddStoreCommand { pub struct AddStoreCommand {
#[builder(setter(custom))]
name: String, name: String,
#[builder(setter(custom))]
address: Option<String>, address: Option<String>,
store_id: Uuid,
owner: Uuid, owner: Uuid,
} }
impl AddStoreCommand { impl AddStoreCommandBuilder {
pub fn new( pub fn address(&mut self, address: Option<String>) -> &mut Self {
name: String, self.address = if let Some(address) = address {
address: Option<String>,
owner: Uuid,
) -> Result<Self, AddStoreCommandError> {
let address: Option<String> = if let Some(address) = address {
let address = address.trim(); let address = address.trim();
if address.is_empty() { if address.is_empty() {
None Some(None)
} else { } else {
Some(address.to_owned()) Some(Some(address.to_owned()))
} }
} else { } else {
None Some(None)
}; };
self
}
let name = name.trim().to_owned(); pub fn name(&mut self, name: String) -> &mut Self {
self.name = Some(name.trim().to_owned());
self
}
fn validate(&self) -> Result<(), String> {
let name = self.name.as_ref().unwrap().trim().to_owned();
if name.is_empty() { if name.is_empty() {
return Err(AddStoreCommandError::NameIsEmpty); return Err(AddStoreCommandError::NameIsEmpty.to_string());
} }
Ok(())
Ok(Self {
name,
address,
owner,
})
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::utils::uuid::tests::UUID; use crate::tests::bdd::*;
use crate::utils::uuid::tests::*;
use super::*; use super::*;
@ -62,21 +69,41 @@ mod tests {
let owner = UUID; let owner = UUID;
// address = None // address = None
let cmd = AddStoreCommand::new(name.into(), None, owner).unwrap(); let cmd = AddStoreCommandBuilder::default()
.name(name.into())
.address(None)
.owner(owner)
.store_id(UUID)
.build()
.unwrap();
assert_eq!(cmd.name(), name); assert_eq!(cmd.name(), name);
assert_eq!(cmd.address(), &None); assert_eq!(cmd.address(), &None);
assert_eq!(cmd.owner(), &owner); assert_eq!(cmd.owner(), &owner);
assert_eq!(*cmd.store_id(), UUID);
// address = Some // address = Some
let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap(); let cmd = AddStoreCommandBuilder::default()
.name(name.into())
.address(Some(address.into()))
.owner(owner)
.store_id(UUID)
.build()
.unwrap();
assert_eq!(cmd.name(), name); assert_eq!(cmd.name(), name);
assert_eq!(cmd.address(), &Some(address.to_owned())); assert_eq!(cmd.address(), &Some(address.to_owned()));
assert_eq!(cmd.owner(), &owner); assert_eq!(cmd.owner(), &owner);
assert_eq!(*cmd.store_id(), UUID);
// AddStoreCommandError::NameIsEmpty // AddStoreCommandError::NameIsEmpty
assert_eq!(
AddStoreCommand::new("".into(), Some(address.into()), owner), assert!(AddStoreCommandBuilder::default()
Err(AddStoreCommandError::NameIsEmpty) .name("".into())
) .address(Some(address.into()))
.owner(owner)
.store_id(UUID)
.build()
.is_err())
} }
} }

14
src/ordering/domain/category_aggregate.rs
View file

@ -81,8 +81,8 @@ mod aggregate_tests {
use std::sync::Arc; use std::sync::Arc;
use cqrs_es::test::TestFramework; use cqrs_es::test::TestFramework;
use tests::get_add_category_cmd;
use update_category_service::tests::mock_update_category_service; use update_category_service::tests::mock_update_category_service;
use uuid::Uuid;
use super::*; use super::*;
use crate::ordering::{ use crate::ordering::{
@ -95,27 +95,19 @@ mod aggregate_tests {
}, },
}; };
use crate::tests::bdd::*; use crate::tests::bdd::*;
use crate::utils::uuid::tests::*;
type CategoryTestFramework = TestFramework<Category>; type CategoryTestFramework = TestFramework<Category>;
#[test] #[test]
fn test_create_category() { fn test_create_category() {
let name = "category_name"; let cmd = get_add_category_cmd();
let description = Some("category_description".to_string());
let adding_by = UUID;
let store_id = Uuid::new_v4();
let category_id = UUID;
let cmd =
AddCategoryCommand::new(name.into(), description.clone(), store_id, adding_by).unwrap();
let expected = CategoryAddedEventBuilder::default() let expected = CategoryAddedEventBuilder::default()
.name(cmd.name().into()) .name(cmd.name().into())
.description(cmd.description().as_ref().map(|s| s.to_string())) .description(cmd.description().as_ref().map(|s| s.to_string()))
.added_by_user(*cmd.adding_by()) .added_by_user(*cmd.adding_by())
.store_id(*cmd.store_id()) .store_id(*cmd.store_id())
.category_id(category_id) .category_id(*cmd.category_id())
.build() .build()
.unwrap(); .unwrap();
let expected = OrderingEvent::CategoryAdded(expected); let expected = OrderingEvent::CategoryAdded(expected);

10
src/ordering/domain/kot_added_event.rs
View file

@ -20,12 +20,18 @@ pub struct KotAddedEvent {
#[cfg(test)] #[cfg(test)]
pub mod tests { pub mod tests {
use crate::ordering::domain::add_kot_command::AddKotCommand; use crate::ordering::domain::{add_kot_command::AddKotCommand, kot_aggregate::*};
use super::*; use super::*;
pub fn get_added_kot_event_from_command(cmd: &AddKotCommand) -> KotAddedEvent { pub fn get_added_kot_event_from_command(cmd: &AddKotCommand) -> KotAddedEvent {
let kot = Kot::get_kot(); let kot = KotBuilder::default()
.created_time(cmd.created_time().clone())
.order_id(*cmd.order_id())
.kot_id(*cmd.kot_id())
.deleted(false)
.build()
.unwrap();
KotAddedEventBuilder::default() KotAddedEventBuilder::default()
.added_by_user(cmd.adding_by().clone()) .added_by_user(cmd.adding_by().clone())

12
src/ordering/domain/order_aggregate.rs
View file

@ -21,11 +21,11 @@ use crate::ordering::{
pub struct Order { pub struct Order {
#[builder(default = "OffsetDateTime::now_utc()")] #[builder(default = "OffsetDateTime::now_utc()")]
created_time: OffsetDateTime, created_time: OffsetDateTime,
// kot_ids: Vec<Kot>, store_id: Uuid,
order_id: Uuid, order_id: Uuid,
#[builder(default = "false")] #[builder(default = "false")]
deleted: bool, deleted: bool,
customer_name: String, customer_name: Option<String>,
} }
impl Default for Order { impl Default for Order {
@ -33,8 +33,9 @@ impl Default for Order {
Self { Self {
created_time: OffsetDateTime::now_utc(), created_time: OffsetDateTime::now_utc(),
order_id: Default::default(), order_id: Default::default(),
store_id: Default::default(),
deleted: false, deleted: false,
customer_name: Default::default(), customer_name: None,
} }
} }
} }
@ -51,8 +52,9 @@ mod tests {
OrderBuilder::default() OrderBuilder::default()
.created_time(cmd.created_time().clone()) .created_time(cmd.created_time().clone())
.customer_name("test_product".into()) .customer_name(Some("test_product".into()))
.order_id(UUID) .order_id(*cmd.order_id())
.store_id(*cmd.store_id())
.build() .build()
.unwrap() .unwrap()
} }

3
src/ordering/domain/order_deleted_event.rs
View file

@ -27,8 +27,9 @@ pub mod tests {
pub fn get_deleted_order_event_from_command(cmd: &DeleteOrderCommand) -> OrderDeletedEvent { pub fn get_deleted_order_event_from_command(cmd: &DeleteOrderCommand) -> OrderDeletedEvent {
let deleted_order = OrderBuilder::default() let deleted_order = OrderBuilder::default()
.created_time(cmd.order().created_time().clone()) .created_time(cmd.order().created_time().clone())
.customer_name(cmd.order().customer_name().into()) .customer_name(cmd.order().customer_name().clone())
.order_id(*cmd.order().order_id()) .order_id(*cmd.order().order_id())
.store_id(*cmd.order().store_id())
.deleted(true) .deleted(true)
.build() .build()
.unwrap(); .unwrap();

3
src/ordering/domain/order_updated_event.rs
View file

@ -28,8 +28,9 @@ pub mod tests {
pub fn get_updated_order_event_from_command(cmd: &UpdateOrderCommand) -> OrderUpdatedEvent { pub fn get_updated_order_event_from_command(cmd: &UpdateOrderCommand) -> OrderUpdatedEvent {
let new_order = OrderBuilder::default() let new_order = OrderBuilder::default()
.created_time(cmd.created_time().clone()) .created_time(cmd.created_time().clone())
.customer_name(cmd.customer_name().into()) .customer_name(cmd.customer_name().clone())
.order_id(*cmd.old_order().order_id()) .order_id(*cmd.old_order().order_id())
.store_id(*cmd.old_order().store_id())
.build() .build()
.unwrap(); .unwrap();

8
src/ordering/domain/store_aggregate.rs
View file

@ -113,7 +113,13 @@ mod tests {
.unwrap(); .unwrap();
let expected = OrderingEvent::StoreAdded(expected); let expected = OrderingEvent::StoreAdded(expected);
let cmd = AddStoreCommand::new(name.into(), address.clone(), owner).unwrap(); let cmd = AddStoreCommandBuilder::default()
.name(name.into())
.address(address.clone())
.owner(owner)
.store_id(UUID)
.build()
.unwrap();
let mut services = MockOrderingServicesInterface::new(); let mut services = MockOrderingServicesInterface::new();
services services

73
src/ordering/domain/update_order_command.rs
View file

@ -10,7 +10,6 @@ use time::OffsetDateTime;
use uuid::Uuid; use uuid::Uuid;
use super::order_aggregate::*; use super::order_aggregate::*;
use crate::utils::string::empty_string_err;
#[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)] #[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
pub enum UpdateOrderCommandError { pub enum UpdateOrderCommandError {
@ -20,39 +19,33 @@ pub enum UpdateOrderCommandError {
#[derive( #[derive(
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder, Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
)] )]
pub struct UnvalidatedUpdateOrderCommand { pub struct UpdateOrderCommand {
adding_by: Uuid, adding_by: Uuid,
#[builder(default = "OffsetDateTime::now_utc()")] #[builder(default = "OffsetDateTime::now_utc()")]
created_time: OffsetDateTime, created_time: OffsetDateTime,
customer_name: String, #[builder(setter(custom))]
customer_name: Option<String>,
old_order: Order, old_order: Order,
} }
impl UnvalidatedUpdateOrderCommand { impl UpdateOrderCommandBuilder {
pub fn validate(self) -> Result<UpdateOrderCommand, UpdateOrderCommandError> { pub fn customer_name(&mut self, customer_name: Option<String>) -> &mut Self {
let customer_name = empty_string_err( self.customer_name = if let Some(customer_name) = customer_name {
self.customer_name, let customer_name = customer_name.trim();
UpdateOrderCommandError::CustomerNameIsEmpty, if customer_name.is_empty() {
)?; Some(None)
} else {
Ok(UpdateOrderCommand { Some(Some(customer_name.to_string()))
created_time: self.created_time, }
customer_name, } else {
adding_by: self.adding_by, Some(None)
old_order: self.old_order, };
}) self
} }
} }
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
pub struct UpdateOrderCommand {
created_time: OffsetDateTime,
customer_name: String,
adding_by: Uuid,
old_order: Order,
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use time::macros::datetime; use time::macros::datetime;
@ -66,15 +59,13 @@ mod tests {
let customer_name = "foo-new-name"; let customer_name = "foo-new-name";
let adding_by = UUID; let adding_by = UUID;
UnvalidatedUpdateOrderCommandBuilder::default() UpdateOrderCommandBuilder::default()
.customer_name(customer_name.into()) .customer_name(Some(customer_name.into()))
.adding_by(adding_by) .adding_by(adding_by)
.created_time(datetime!(1970-01-01 0:00 UTC)) .created_time(datetime!(1970-01-01 0:00 UTC))
.old_order(Order::default()) .old_order(Order::default())
.build() .build()
.unwrap() .unwrap()
.validate()
.unwrap()
} }
} }
@ -84,17 +75,15 @@ mod tests {
let adding_by = UUID; let adding_by = UUID;
let old_order = Order::default(); let old_order = Order::default();
let cmd = UnvalidatedUpdateOrderCommandBuilder::default() let cmd = UpdateOrderCommandBuilder::default()
.customer_name(customer_name.into()) .customer_name(Some(customer_name.into()))
.adding_by(adding_by) .adding_by(adding_by)
.old_order(old_order.clone()) .old_order(old_order.clone())
.build() .build()
.unwrap()
.validate()
.unwrap(); .unwrap();
assert_eq!(*cmd.adding_by(), adding_by); assert_eq!(*cmd.adding_by(), adding_by);
assert_eq!(cmd.customer_name(), customer_name); assert_eq!(cmd.customer_name().as_ref().unwrap(), customer_name);
assert_eq!(cmd.old_order(), &old_order); assert_eq!(cmd.old_order(), &old_order);
} }
@ -103,15 +92,13 @@ mod tests {
let customer_name = ""; let customer_name = "";
let adding_by = UUID; let adding_by = UUID;
assert_eq!( let cmd = UpdateOrderCommandBuilder::default()
UnvalidatedUpdateOrderCommandBuilder::default() .customer_name(Some(customer_name.into()))
.customer_name(customer_name.into()) .adding_by(adding_by)
.adding_by(adding_by) .old_order(Order::default())
.old_order(Order::default()) .build()
.build() .unwrap();
.unwrap()
.validate(), assert!(cmd.customer_name().is_none());
Err(UpdateOrderCommandError::CustomerNameIsEmpty)
);
} }
} }

49
src/ordering/domain/update_product_command.rs
View file

@ -95,6 +95,55 @@ pub mod tests {
use crate::types::quantity::*; use crate::types::quantity::*;
use crate::utils::uuid::tests::UUID; use crate::utils::uuid::tests::UUID;
pub fn get_command_with_product(product: Product) -> UpdateProductCommand {
let name = "foobaaar";
let adding_by = UUID;
let category_id = UUID;
let sku_able = false;
let image = Some("imageeee".to_string());
let description = Some("descriptionnnn".to_string());
let price = PriceBuilder::default()
.minor(0)
.major(100)
.currency(Currency::INR)
.build()
.unwrap();
let quantity = QuantityBuilder::default()
.minor(
QuantityPartBuilder::default()
.number(0)
.unit(QuantityUnit::DiscreteNumber)
.build()
.unwrap(),
)
.major(
QuantityPartBuilder::default()
.number(1)
.unit(QuantityUnit::DiscreteNumber)
.build()
.unwrap(),
)
.build()
.unwrap();
let cmd = UnvalidatedUpdateProductCommandBuilder::default()
.name(name.into())
.description(description.clone())
.image(image.clone())
.category_id(category_id.clone())
.adding_by(adding_by.clone())
.quantity(quantity)
.sku_able(sku_able)
.price(price.clone())
.old_product(product)
.build()
.unwrap();
cmd.validate().unwrap()
}
pub fn get_command() -> UpdateProductCommand { pub fn get_command() -> UpdateProductCommand {
let name = "foo"; let name = "foo";
let adding_by = UUID; let adding_by = UUID;