Add id check for booking

It now checks if sales_person_id and slot_id actually exists.

service_impl/src/booking.rs

@@ -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()));

service_impl/src/sales_person.rs

@@ -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,

service_impl/src/slot.rs

@@ -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())

service_impl/src/test/booking.rs

@@ -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");

service_impl/src/test/sales_person.rs

@@ -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);
+}