Shifty/shifty-backend
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add id check for booking

Browse source 
It now checks if sales_person_id and slot_id actually exists.
This commit is contained in:
Simon Goller 2024-05-09 08:11:38 +02:00
parent 418a2944f7
commit bc8a534353
10 changed files with 201 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

5
app/src/main.rs
View file

@ -23,6 +23,8 @@ type BookingService = service_impl::booking::BookingServiceImpl<
PermissionService,
ClockService,
UuidService,
SalesPersonService,
SlotService,
>;
#[derive(Clone)]
@ -31,7 +33,6 @@ pub struct RestStateImpl {
slot_service: Arc<SlotService>,
sales_person_service: Arc<SalesPersonService>,
booking_service: Arc<BookingService>,
}
impl rest::RestStateDef for RestStateImpl {
type PermissionService = PermissionService;
@ -90,6 +91,8 @@ impl RestStateImpl {
permission_service.clone(),
clock_service,
uuid_service,
sales_person_service.clone(),
slot_service.clone(),
));
Self {
permission_service,

24
rest/src/booking.rs
View file

@ -10,7 +10,7 @@ use time::PrimitiveDateTime;
use uuid::Uuid;
use crate::{error_handler, RestStateDef};
use service::booking::{BookingService, Booking};
use service::booking::{Booking, BookingService};
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct BookingTO {
@ -65,9 +65,7 @@ pub fn generate_route<RestState: RestStateDef>() -> Router<RestState> {
.route("/:id", delete(delete_booking::<RestState>))
}
pub async fn get_all_bookings<RestState: RestStateDef>(
rest_state: State<RestState>,
) -> Response {
pub async fn get_all_bookings<RestState: RestStateDef>(rest_state: State<RestState>) -> Response {
error_handler(
(async {
let bookings: Arc<[BookingTO]> = rest_state
@ -95,7 +93,9 @@ pub async fn get_booking<RestState: RestStateDef>(
let booking = rest_state.booking_service().get(booking_id, ()).await?;
Ok(Response::builder()
.status(200)
.body(Body::new(serde_json::to_string(&BookingTO::from(&booking)).unwrap()))
.body(Body::new(
serde_json::to_string(&BookingTO::from(&booking)).unwrap(),
))
.unwrap())
})
.await,
@ -108,10 +108,15 @@ pub async fn create_booking<RestState: RestStateDef>(
) -> Response {
error_handler(
(async {
let booking = rest_state.booking_service().create(&Booking::from(&booking), ()).await?;
let booking = rest_state
.booking_service()
.create(&Booking::from(&booking), ())
.await?;
Ok(Response::builder()
.status(200)
.body(Body::new(serde_json::to_string(&BookingTO::from(&booking)).unwrap()))
.body(Body::new(
serde_json::to_string(&BookingTO::from(&booking)).unwrap(),
))
.unwrap())
})
.await,
@ -125,10 +130,7 @@ pub async fn delete_booking<RestState: RestStateDef>(
error_handler(
(async {
rest_state.booking_service().delete(booking_id, ()).await?;
Ok(Response::builder()
.status(200)
.body(Body::empty())
.unwrap())
Ok(Response::builder().status(200).body(Body::empty()).unwrap())
})
.await,
)

2
service/src/lib.rs
View file

@ -22,6 +22,8 @@ pub use permission::User;
pub enum ValidationFailureItem {
ModificationNotAllowed(Arc<str>),
InvalidValue(Arc<str>),
IdDoesNotExist(Arc<str>, Uuid),
Duplicate,
}
#[derive(Debug, Error)]

1
service/src/sales_person.rs
View file

@ -44,6 +44,7 @@ pub trait SalesPersonService {
async fn get_all(&self, context: Self::Context) -> Result<Arc<[SalesPerson]>, ServiceError>;
async fn get(&self, id: Uuid, context: Self::Context) -> Result<SalesPerson, ServiceError>;
async fn exists(&self, id: Uuid, context: Self::Context) -> Result<bool, ServiceError>;
async fn create(
&self,
item: &SalesPerson,

1
service/src/slot.rs
View file

@ -89,6 +89,7 @@ pub trait SlotService {
async fn get_slots(&self, context: Self::Context) -> Result<Arc<[Slot]>, ServiceError>;
async fn get_slot(&self, id: &Uuid, context: Self::Context) -> Result<Slot, ServiceError>;
async fn exists(&self, id: Uuid, context: Self::Context) -> Result<bool, ServiceError>;
async fn create_slot(&self, slot: &Slot, context: Self::Context) -> Result<Slot, ServiceError>;
async fn delete_slot(&self, id: &Uuid, context: Self::Context) -> Result<(), ServiceError>;
async fn update_slot(&self, slot: &Slot, context: Self::Context) -> Result<(), ServiceError>;

71
service_impl/src/booking.rs
View file

@ -8,49 +8,84 @@ use uuid::Uuid;
const BOOKING_SERVICE_PROCESS: &str = "booking-service";
pub struct BookingServiceImpl<BookingDao, PermissionService, ClockService, UuidService>
where
pub struct BookingServiceImpl<
BookingDao,
PermissionService,
ClockService,
UuidService,
SalesPersonService,
SlotService,
> where
BookingDao: dao::booking::BookingDao + Send + Sync,
PermissionService: service::permission::PermissionService + Send + Sync,
UuidService: service::uuid_service::UuidService + Send + Sync,
ClockService: service::clock::ClockService + Send + Sync,
SalesPersonService: service::sales_person::SalesPersonService + Send + Sync,
SlotService: service::slot::SlotService + Send + Sync,
{
pub booking_dao: Arc<BookingDao>,
pub permission_service: Arc<PermissionService>,
pub clock_service: Arc<ClockService>,
pub uuid_service: Arc<UuidService>,
pub sales_person_service: Arc<SalesPersonService>,
pub slot_service: Arc<SlotService>,
}
impl<BookingDao, PermissionService, ClockService, UuidService>
BookingServiceImpl<BookingDao, PermissionService, ClockService, UuidService>
impl<BookingDao, PermissionService, ClockService, UuidService, SalesPersonService, SlotService>
BookingServiceImpl<
BookingDao,
PermissionService,
ClockService,
UuidService,
SalesPersonService,
SlotService,
>
where
BookingDao: dao::booking::BookingDao + Send + Sync,
PermissionService: service::permission::PermissionService + Send + Sync,
UuidService: service::uuid_service::UuidService + Send + Sync,
ClockService: service::clock::ClockService + Send + Sync,
SalesPersonService: service::sales_person::SalesPersonService + Send + Sync,
SlotService: service::slot::SlotService + Send + Sync,
{
pub fn new(
booking_dao: Arc<BookingDao>,
permission_service: Arc<PermissionService>,
clock_service: Arc<ClockService>,
uuid_service: Arc<UuidService>,
sales_person_service: Arc<SalesPersonService>,
slot_service: Arc<SlotService>,
) -> Self {
Self {
booking_dao,
permission_service,
clock_service,
uuid_service,
sales_person_service,
slot_service,
}
}
}
#[async_trait]
impl<BookingDao, PermissionService, ClockService, UuidService> BookingService
for BookingServiceImpl<BookingDao, PermissionService, ClockService, UuidService>
impl<BookingDao, PermissionService, ClockService, UuidService, SalesPersonService, SlotService>
BookingService
for BookingServiceImpl<
BookingDao,
PermissionService,
ClockService,
UuidService,
SalesPersonService,
SlotService,
>
where
BookingDao: dao::booking::BookingDao + Send + Sync,
PermissionService: service::permission::PermissionService + Send + Sync,
UuidService: service::uuid_service::UuidService + Send + Sync,
ClockService: service::clock::ClockService + Send + Sync,
SalesPersonService: service::sales_person::SalesPersonService<Context = PermissionService::Context>
+ Send
+ Sync,
SlotService: service::slot::SlotService<Context = PermissionService::Context> + Send + Sync,
{
type Context = PermissionService::Context;
@ -85,7 +120,7 @@ where
context: Self::Context,
) -> Result<Booking, ServiceError> {
self.permission_service
.check_permission("hr", context)
.check_permission("hr", context.clone())
.await?;
if booking.id != Uuid::nil() {
@ -113,6 +148,28 @@ where
if booking.calendar_week > 53 {
validation.push(ValidationFailureItem::InvalidValue("calendar_week".into()));
}
if self
.sales_person_service
.exists(booking.sales_person_id, context.clone())
.await?
== false
{
validation.push(ValidationFailureItem::IdDoesNotExist(
"sales_person_id".into(),
booking.sales_person_id,
));
}
if self
.slot_service
.exists(booking.slot_id, context.clone())
.await?
== false
{
validation.push(ValidationFailureItem::IdDoesNotExist(
"slot_id".into(),
booking.slot_id,
));
}
if !validation.is_empty() {
return Err(ServiceError::ValidationError(validation.into()));

8
service_impl/src/sales_person.rs
View file

@ -86,6 +86,14 @@ where
.ok_or(ServiceError::EntityNotFound(id))
}
async fn exists(&self, id: Uuid, _context: Self::Context) -> Result<bool, ServiceError> {
Ok(self
.sales_person_dao
.find_by_id(id)
.await
.map(|x| x.is_some())?)
}
async fn create(
&self,
sales_person: &SalesPerson,

5
service_impl/src/slot.rs
View file

@ -91,6 +91,11 @@ where
.ok_or_else(move || ServiceError::EntityNotFound(*id))?;
Ok(slot)
}
async fn exists(&self, id: Uuid, _context: Self::Context) -> Result<bool, ServiceError> {
Ok(self.slot_dao.get_slot(&id).await.map(|s| s.is_some())?)
}
async fn create_slot(&self, slot: &Slot, context: Self::Context) -> Result<Slot, ServiceError> {
self.permission_service
.check_permission("hr", context.clone())

83
service_impl/src/test/booking.rs
View file

@ -2,8 +2,9 @@ use crate::test::error_test::*;
use dao::booking::{BookingEntity, MockBookingDao};
use mockall::predicate::eq;
use service::{
booking::Booking, clock::MockClockService, uuid_service::MockUuidService,
MockPermissionService, ValidationFailureItem,
booking::Booking, clock::MockClockService, sales_person::MockSalesPersonService,
slot::MockSlotService, uuid_service::MockUuidService, MockPermissionService,
ValidationFailureItem,
};
use time::{Date, Month, PrimitiveDateTime, Time};
use uuid::{uuid, Uuid};
@ -67,17 +68,27 @@ pub struct BookingServiceDependencies {
pub permission_service: MockPermissionService,
pub clock_service: MockClockService,
pub uuid_service: MockUuidService,
pub sales_person_service: MockSalesPersonService,
pub slot_service: MockSlotService,
}
impl BookingServiceDependencies {
pub fn build_service(
self,
) -> BookingServiceImpl<MockBookingDao, MockPermissionService, MockClockService, MockUuidService>
{
) -> BookingServiceImpl<
MockBookingDao,
MockPermissionService,
MockClockService,
MockUuidService,
MockSalesPersonService,
MockSlotService,
> {
BookingServiceImpl::new(
self.booking_dao.into(),
self.permission_service.into(),
self.clock_service.into(),
self.uuid_service.into(),
self.sales_person_service.into(),
self.slot_service.into(),
)
}
}
@ -113,11 +124,20 @@ pub fn build_dependencies(permission: bool, role: &'static str) -> BookingServic
});
let uuid_service = MockUuidService::new();
let mut sales_person_service = MockSalesPersonService::new();
sales_person_service
.expect_exists()
.returning(|_, _| Ok(true));
let mut slot_service = MockSlotService::new();
slot_service.expect_exists().returning(|_, _| Ok(true));
BookingServiceDependencies {
booking_dao,
permission_service,
clock_service,
uuid_service,
sales_person_service,
slot_service,
}
}
@ -303,6 +323,61 @@ async fn test_create_with_created_fail() {
);
}
#[tokio::test]
async fn test_create_sales_person_does_not_exist() {
let mut deps = build_dependencies(true, "hr");
deps.sales_person_service.checkpoint();
deps.sales_person_service
.expect_exists()
.with(eq(default_sales_person_id()), eq(()))
.returning(|_, _| Ok(false));
let service = deps.build_service();
let result = service
.create(
&Booking {
id: Uuid::nil(),
version: Uuid::nil(),
created: None,
..default_booking()
},
(),
)
.await;
dbg!(&result);
test_validation_error(
&result,
&ValidationFailureItem::IdDoesNotExist("sales_person_id".into(), default_sales_person_id()),
1,
);
}
#[tokio::test]
async fn test_create_slot_does_not_exist() {
let mut deps = build_dependencies(true, "hr");
deps.slot_service.checkpoint();
deps.slot_service
.expect_exists()
.with(eq(default_slot_id()), eq(()))
.returning(|_, _| Ok(false));
let service = deps.build_service();
let result = service
.create(
&Booking {
id: Uuid::nil(),
version: Uuid::nil(),
created: None,
..default_booking()
},
(),
)
.await;
test_validation_error(
&result,
&ValidationFailureItem::IdDoesNotExist("slot_id".into(), default_slot_id()),
1,
);
}
#[tokio::test]
async fn test_delete_no_permission() {
let deps = build_dependencies(false, "hr");

23
service_impl/src/test/sales_person.rs
View file

@ -517,3 +517,26 @@ async fn test_delete_not_found() {
let result = sales_person_service.delete(default_id(), ()).await;
test_not_found(&result, &default_id());
}
#[tokio::test]
async fn test_exists() {
let mut dependencies = build_dependencies(true, "hr");
dependencies
.sales_person_dao
.expect_find_by_id()
.with(eq(default_id()))
.returning(|_| Ok(Some(default_sales_person_entity())));
let sales_person_service = dependencies.build_service();
let result = sales_person_service.exists(default_id(), ()).await.unwrap();
assert!(result);
let mut dependencies = build_dependencies(true, "hr");
dependencies.sales_person_dao.checkpoint();
dependencies
.sales_person_dao
.expect_find_by_id()
.with(eq(default_id()))
.returning(|_| Ok(None));
let result = sales_person_service.exists(default_id(), ()).await.unwrap();
assert_eq!(false, !result);
}