Add context reqruied later for authentication

app/src/main.rs

@@ -4,7 +4,6 @@ use sqlx::SqlitePool;
 
 type PermissionService =
     service_impl::PermissionServiceImpl<dao_impl::PermissionDaoImpl, service_impl::UserServiceDev>;
-type HelloService = service_impl::HelloServiceImpl<dao_impl::HelloDaoImpl, PermissionService>;
 type ClockService = service_impl::clock::ClockServiceImpl;
 type UuidService = service_impl::uuid_service::UuidServiceImpl;
 type SlotService = service_impl::slot::SlotServiceImpl<
@@ -16,18 +15,13 @@ type SlotService = service_impl::slot::SlotServiceImpl<
 
 #[derive(Clone)]
 pub struct RestStateImpl {
-    hello_service: Arc<HelloService>,
     permission_service: Arc<PermissionService>,
     slot_service: Arc<SlotService>,
 }
 impl rest::RestStateDef for RestStateImpl {
-    type HelloService = HelloService;
     type PermissionService = PermissionService;
     type SlotService = SlotService;
 
-    fn hello_service(&self) -> Arc<Self::HelloService> {
-        self.hello_service.clone()
-    }
     fn permission_service(&self) -> Arc<Self::PermissionService> {
         self.permission_service.clone()
     }
@@ -37,7 +31,6 @@ impl rest::RestStateDef for RestStateImpl {
 }
 impl RestStateImpl {
     pub fn new(pool: Arc<sqlx::Pool<sqlx::Sqlite>>) -> Self {
-        let hello_dao = dao_impl::HelloDaoImpl::new(pool.clone());
         let permission_dao = dao_impl::PermissionDaoImpl::new(pool.clone());
         let slot_dao = dao_impl::slot::SlotDaoImpl::new(pool);
 
@@ -52,10 +45,6 @@ impl RestStateImpl {
             permission_dao.into(),
             user_service.into(),
         ));
-        let hello_service = Arc::new(service_impl::HelloServiceImpl::new(
-            hello_dao.into(),
-            permission_service.clone(),
-        ));
         let clock_service = Arc::new(service_impl::clock::ClockServiceImpl);
         let uuid_service = Arc::new(service_impl::uuid_service::UuidServiceImpl);
         let slot_service = Arc::new(service_impl::slot::SlotServiceImpl::new(
@@ -65,7 +54,6 @@ impl RestStateImpl {
             uuid_service,
         ));
         Self {
-            hello_service,
             permission_service,
             slot_service,
         }

rest/src/hello.rs

@@ -1,14 +0,0 @@
-use axum::{extract::State, response::Response};
-
-use crate::{error_handler, RestStateDef, RoString};
-use service::HelloService;
-
-pub async fn hello<RestState: RestStateDef>(State(rest_state): State<RestState>) -> Response {
-    error_handler(
-        (async {
-            let string = rest_state.hello_service().hello().await?;
-            Ok(RoString::from(string).into())
-        })
-        .await,
-    )
-}

rest/src/lib.rs

@@ -1,13 +1,15 @@
 use std::{convert::Infallible, sync::Arc};
 
-mod hello;
 mod permission;
 mod slot;
 
-use axum::{body::Body, response::Response, routing::get, Router};
+use axum::{body::Body, response::Response, Router};
 use thiserror::Error;
 use uuid::Uuid;
 
+// TODO: In prod, it must be a different type than in dev mode.
+type Context = ();
+
 pub struct RoString(Arc<str>, bool);
 impl http_body::Body for RoString {
     type Data = bytes::Bytes;
@@ -125,18 +127,15 @@ fn error_handler(result: Result<Response, RestError>) -> Response {
 }
 
 pub trait RestStateDef: Clone + Send + Sync + 'static {
-    type HelloService: service::HelloService + Send + Sync + 'static;
+    type PermissionService: service::PermissionService<Context = Context> + Send + Sync + 'static;
-    type PermissionService: service::PermissionService + Send + Sync + 'static;
+    type SlotService: service::slot::SlotService<Context = Context> + Send + Sync + 'static;
-    type SlotService: service::slot::SlotService + Send + Sync + 'static;
 
-    fn hello_service(&self) -> Arc<Self::HelloService>;
     fn permission_service(&self) -> Arc<Self::PermissionService>;
     fn slot_service(&self) -> Arc<Self::SlotService>;
 }
 
 pub async fn start_server<RestState: RestStateDef>(rest_state: RestState) {
     let app = Router::new()
-        .route("/", get(hello::hello::<RestState>))
         .nest("/permission", permission::generate_route())
         .nest("/slot", slot::generate_route())
         .with_state(rest_state);

rest/src/permission.rs

@@ -87,7 +87,7 @@ pub async fn add_user<RestState: RestStateDef>(
         (async {
             rest_state
                 .permission_service()
-                .create_user(user.name.as_str())
+                .create_user(user.name.as_str(), ())
                 .await?;
             Ok(Response::builder()
                 .status(201)
@@ -105,7 +105,10 @@ pub async fn remove_user<RestState: RestStateDef>(
     println!("Removing user: {:?}", user);
     error_handler(
         (async {
-            rest_state.permission_service().delete_user(&user).await?;
+            rest_state
+                .permission_service()
+                .delete_user(&user, ())
+                .await?;
             Ok(Response::builder()
                 .status(200)
                 .body(Body::from(""))
@@ -123,7 +126,7 @@ pub async fn add_role<RestState: RestStateDef>(
         (async {
             rest_state
                 .permission_service()
-                .create_role(role.name.as_str())
+                .create_role(role.name.as_str(), ())
                 .await?;
             Ok(Response::builder()
                 .status(200)
@@ -142,7 +145,7 @@ pub async fn delete_role<RestState: RestStateDef>(
         (async {
             rest_state
                 .permission_service()
-                .delete_role(role.as_str())
+                .delete_role(role.as_str(), ())
                 .await?;
             Ok(Response::builder()
                 .status(200)
@@ -161,7 +164,7 @@ pub async fn add_user_role<RestState: RestStateDef>(
         (async {
             rest_state
                 .permission_service()
-                .add_user_role(user_role.user.as_str(), user_role.role.as_str())
+                .add_user_role(user_role.user.as_str(), user_role.role.as_str(), ())
                 .await?;
             Ok(Response::builder()
                 .status(201)
@@ -180,7 +183,7 @@ pub async fn remove_user_role<RestState: RestStateDef>(
         (async {
             rest_state
                 .permission_service()
-                .delete_user_role(user_role.user.as_str(), user_role.role.as_str())
+                .delete_user_role(user_role.user.as_str(), user_role.role.as_str(), ())
                 .await?;
             Ok(Response::builder()
                 .status(200)
@@ -202,6 +205,7 @@ pub async fn add_role_privilege<RestState: RestStateDef>(
                 .add_role_privilege(
                     role_privilege.role.as_str(),
                     role_privilege.privilege.as_str(),
+                    (),
                 )
                 .await?;
             Ok(Response::builder()
@@ -224,6 +228,7 @@ pub async fn remove_role_privilege<RestState: RestStateDef>(
                 .delete_role_privilege(
                     role_privilege.role.as_str(),
                     role_privilege.privilege.as_str(),
+                    (),
                 )
                 .await?;
             Ok(Response::builder()
@@ -240,7 +245,7 @@ pub async fn get_all_users<RestState: RestStateDef>(rest_state: State<RestState>
         (async {
             let users: Arc<[UserTO]> = rest_state
                 .permission_service()
-                .get_all_users()
+                .get_all_users(())
                 .await?
                 .iter()
                 .map(UserTO::from)
@@ -259,7 +264,7 @@ pub async fn get_all_roles<RestState: RestStateDef>(rest_state: State<RestState>
         (async {
             let roles: Arc<[RoleTO]> = rest_state
                 .permission_service()
-                .get_all_roles()
+                .get_all_roles(())
                 .await?
                 .iter()
                 .map(RoleTO::from)
@@ -278,7 +283,7 @@ pub async fn get_all_privileges<RestState: RestStateDef>(rest_state: State<RestS
         (async {
             let privileges: Arc<[PrivilegeTO]> = rest_state
                 .permission_service()
-                .get_all_privileges()
+                .get_all_privileges(())
                 .await?
                 .iter()
                 .map(PrivilegeTO::from)

rest/src/slot.rs

@@ -107,7 +107,7 @@ pub async fn get_all_slots<RestState: RestStateDef>(rest_state: State<RestState>
         (async {
             let slots: Arc<[SlotTO]> = rest_state
                 .slot_service()
-                .get_slots()
+                .get_slots(())
                 .await?
                 .iter()
                 .map(SlotTO::from)
@@ -127,7 +127,7 @@ pub async fn get_slot<RestState: RestStateDef>(
 ) -> Response {
     error_handler(
         (async {
-            let slot = SlotTO::from(&rest_state.slot_service().get_slot(&slot_id).await?.into());
+            let slot = SlotTO::from(&rest_state.slot_service().get_slot(&slot_id, ()).await?);
             Ok(Response::builder()
                 .status(200)
                 .body(Body::new(serde_json::to_string(&slot).unwrap()))
@@ -146,7 +146,7 @@ pub async fn create_slot<RestState: RestStateDef>(
             let slot = SlotTO::from(
                 &rest_state
                     .slot_service()
-                    .create_slot(&(&slot).into())
+                    .create_slot(&(&slot).into(), ())
                     .await?,
             );
             Ok(Response::builder()
@@ -170,7 +170,7 @@ pub async fn update_slot<RestState: RestStateDef>(
             }
             rest_state
                 .slot_service()
-                .update_slot(&(&slot).into())
+                .update_slot(&(&slot).into(), ())
                 .await?;
             Ok(Response::builder()
                 .status(200)

service/src/lib.rs

@@ -1,6 +1,4 @@
-use async_trait::async_trait;
+use std::sync::Arc;
-use mockall::automock;
-use std::{future::Future, sync::Arc};
 use thiserror::Error;
 use time::Date;
 use time::Time;
@@ -9,6 +7,7 @@ use uuid::Uuid;
 pub mod clock;
 pub mod permission;
 pub mod slot;
+pub mod user_service;
 pub mod uuid_service;
 
 pub use permission::MockPermissionService;
@@ -57,14 +56,3 @@ pub enum ServiceError {
     #[error("Date order wrong. {0} must is not smaller or equal to {1}")]
     DateOrderWrong(Date, Date),
 }
-
-#[automock]
-pub trait HelloService {
-    fn hello(&self) -> impl Future<Output = Result<Arc<str>, ServiceError>> + Send;
-}
-
-#[automock]
-#[async_trait]
-pub trait UserService {
-    async fn current_user(&self) -> Result<Arc<str>, ServiceError>;
-}

service/src/permission.rs

@@ -41,25 +41,62 @@ impl From<&dao::PrivilegeEntity> for Privilege {
     }
 }
 
-#[automock]
+#[automock(type Context=();)]
 #[async_trait]
 pub trait PermissionService {
-    async fn check_permission(&self, privilege: &str) -> Result<(), ServiceError>;
+    type Context: Clone + Send + Sync + 'static;
 
-    async fn create_user(&self, user: &str) -> Result<(), ServiceError>;
+    async fn check_permission(
-    async fn delete_user(&self, user: &str) -> Result<(), ServiceError>;
+        &self,
-    async fn get_all_users(&self) -> Result<Arc<[User]>, ServiceError>;
+        privilege: &str,
+        context: Self::Context,
+    ) -> Result<(), ServiceError>;
 
-    async fn create_role(&self, role: &str) -> Result<(), ServiceError>;
+    async fn create_user(&self, user: &str, context: Self::Context) -> Result<(), ServiceError>;
-    async fn delete_role(&self, role: &str) -> Result<(), ServiceError>;
+    async fn delete_user(&self, user: &str, context: Self::Context) -> Result<(), ServiceError>;
-    async fn get_all_roles(&self) -> Result<Arc<[Role]>, ServiceError>;
+    async fn get_all_users(&self, context: Self::Context) -> Result<Arc<[User]>, ServiceError>;
 
-    async fn create_privilege(&self, privilege: &str) -> Result<(), ServiceError>;
+    async fn create_role(&self, role: &str, context: Self::Context) -> Result<(), ServiceError>;
-    async fn delete_privilege(&self, privilege: &str) -> Result<(), ServiceError>;
+    async fn delete_role(&self, role: &str, context: Self::Context) -> Result<(), ServiceError>;
-    async fn get_all_privileges(&self) -> Result<Arc<[Privilege]>, ServiceError>;
+    async fn get_all_roles(&self, context: Self::Context) -> Result<Arc<[Role]>, ServiceError>;
 
-    async fn add_user_role(&self, user: &str, role: &str) -> Result<(), ServiceError>;
+    async fn create_privilege(
-    async fn add_role_privilege(&self, role: &str, privilege: &str) -> Result<(), ServiceError>;
+        &self,
-    async fn delete_role_privilege(&self, role: &str, privilege: &str) -> Result<(), ServiceError>;
+        privilege: &str,
-    async fn delete_user_role(&self, user: &str, role: &str) -> Result<(), ServiceError>;
+        context: Self::Context,
+    ) -> Result<(), ServiceError>;
+    async fn delete_privilege(
+        &self,
+        privilege: &str,
+        context: Self::Context,
+    ) -> Result<(), ServiceError>;
+    async fn get_all_privileges(
+        &self,
+        context: Self::Context,
+    ) -> Result<Arc<[Privilege]>, ServiceError>;
+
+    async fn add_user_role(
+        &self,
+        user: &str,
+        role: &str,
+        context: Self::Context,
+    ) -> Result<(), ServiceError>;
+    async fn add_role_privilege(
+        &self,
+        role: &str,
+        privilege: &str,
+        context: Self::Context,
+    ) -> Result<(), ServiceError>;
+    async fn delete_role_privilege(
+        &self,
+        role: &str,
+        privilege: &str,
+        context: Self::Context,
+    ) -> Result<(), ServiceError>;
+    async fn delete_user_role(
+        &self,
+        user: &str,
+        role: &str,
+        context: Self::Context,
+    ) -> Result<(), ServiceError>;
 }

service/src/slot.rs

@@ -82,12 +82,14 @@ impl From<&Slot> for dao::slot::SlotEntity {
     }
 }
 
-#[automock]
+#[automock(type Context=();)]
 #[async_trait]
 pub trait SlotService {
-    async fn get_slots(&self) -> Result<Arc<[Slot]>, ServiceError>;
+    type Context: Clone + Send + Sync + 'static;
-    async fn get_slot(&self, id: &Uuid) -> Result<Slot, ServiceError>;
+
-    async fn create_slot(&self, slot: &Slot) -> Result<Slot, ServiceError>;
+    async fn get_slots(&self, context: Self::Context) -> Result<Arc<[Slot]>, ServiceError>;
-    async fn delete_slot(&self, id: &Uuid) -> Result<(), ServiceError>;
+    async fn get_slot(&self, id: &Uuid, context: Self::Context) -> Result<Slot, ServiceError>;
-    async fn update_slot(&self, slot: &Slot) -> Result<(), 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>;
 }

service/src/user_service.rs

@@ -0,0 +1,14 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use mockall::automock;
+
+use crate::ServiceError;
+
+#[automock(type Context=();)]
+#[async_trait]
+pub trait UserService {
+    type Context: Clone + Send + Sync + 'static;
+
+    async fn current_user(&self, context: Self::Context) -> Result<Arc<str>, ServiceError>;
+}

service_impl/src/lib.rs

@@ -10,44 +10,16 @@ pub mod uuid_service;
 
 pub use permission::PermissionServiceImpl;
 
-pub struct HelloServiceImpl<HelloDao, PermissionService>
-where
-    HelloDao: dao::HelloDao + Sync + Send,
-    PermissionService: service::PermissionService + Sync + Send,
-{
-    hello_dao: Arc<HelloDao>,
-    permission_service: Arc<PermissionService>,
-}
-impl<HelloDao, PermissionService> HelloServiceImpl<HelloDao, PermissionService>
-where
-    HelloDao: dao::HelloDao + Sync + Send,
-    PermissionService: service::PermissionService + Sync + Send,
-{
-    pub fn new(hello_dao: Arc<HelloDao>, permission_service: Arc<PermissionService>) -> Self {
-        Self {
-            hello_dao,
-            permission_service,
-        }
-    }
-}
-
-impl<HelloDao, PermissionService> service::HelloService
-    for HelloServiceImpl<HelloDao, PermissionService>
-where
-    HelloDao: dao::HelloDao + Sync + Send,
-    PermissionService: service::PermissionService + Sync + Send,
-{
-    async fn hello(&self) -> Result<Arc<str>, service::ServiceError> {
-        self.permission_service.check_permission("hello").await?;
-        Ok(self.hello_dao.get_hello().await?)
-    }
-}
-
 pub struct UserServiceDev;
 
 #[async_trait]
-impl service::UserService for UserServiceDev {
+impl service::user_service::UserService for UserServiceDev {
-    async fn current_user(&self) -> Result<Arc<str>, service::ServiceError> {
+    type Context = ();
+
+    async fn current_user(
+        &self,
+        _context: Self::Context,
+    ) -> Result<Arc<str>, service::ServiceError> {
         Ok("DEVUSER".into())
     }
 }

service_impl/src/permission.rs

@@ -5,7 +5,7 @@ use async_trait::async_trait;
 pub struct PermissionServiceImpl<PermissionDao, UserService>
 where
     PermissionDao: dao::PermissionDao + Send + Sync,
-    UserService: service::UserService + Send + Sync,
+    UserService: service::user_service::UserService + Send + Sync,
 {
     permission_dao: Arc<PermissionDao>,
     user_service: Arc<UserService>,
@@ -13,7 +13,7 @@ where
 impl<PermissionDao, UserService> PermissionServiceImpl<PermissionDao, UserService>
 where
     PermissionDao: dao::PermissionDao + Send + Sync,
-    UserService: service::UserService + Send + Sync,
+    UserService: service::user_service::UserService + Send + Sync,
 {
     pub fn new(permission_dao: Arc<PermissionDao>, user_service: Arc<UserService>) -> Self {
         Self {
@@ -30,10 +30,16 @@ impl<PermissionDao, UserService> service::PermissionService
     for PermissionServiceImpl<PermissionDao, UserService>
 where
     PermissionDao: dao::PermissionDao + Send + Sync,
-    UserService: service::UserService + Send + Sync,
+    UserService: service::user_service::UserService + Send + Sync,
 {
-    async fn check_permission(&self, privilege: &str) -> Result<(), service::ServiceError> {
+    type Context = UserService::Context;
-        let current_user = self.user_service.current_user().await?;
+
+    async fn check_permission(
+        &self,
+        privilege: &str,
+        context: Self::Context,
+    ) -> Result<(), service::ServiceError> {
+        let current_user = self.user_service.current_user(context).await?;
         if self
             .permission_dao
             .has_privilege(current_user.as_ref(), privilege)
@@ -45,8 +51,12 @@ where
         }
     }
 
-    async fn create_user(&self, user: &str) -> Result<(), service::ServiceError> {
+    async fn create_user(
-        self.check_permission("admin").await?;
+        &self,
+        user: &str,
+        context: Self::Context,
+    ) -> Result<(), service::ServiceError> {
+        self.check_permission("admin", context).await?;
         self.permission_dao
             .create_user(
                 &dao::UserEntity { name: user.into() },
@@ -55,14 +65,21 @@ where
             .await?;
         Ok(())
     }
-    async fn delete_user(&self, user: &str) -> Result<(), service::ServiceError> {
+    async fn delete_user(
-        self.check_permission("admin").await?;
+        &self,
+        user: &str,
+        context: Self::Context,
+    ) -> Result<(), service::ServiceError> {
+        self.check_permission("admin", context).await?;
         self.permission_dao.delete_user(user).await?;
         Ok(())
     }
 
-    async fn get_all_users(&self) -> Result<Arc<[service::User]>, service::ServiceError> {
+    async fn get_all_users(
-        self.check_permission("admin").await?;
+        &self,
+        context: Self::Context,
+    ) -> Result<Arc<[service::User]>, service::ServiceError> {
+        self.check_permission("admin", context).await?;
         Ok(self
             .permission_dao
             .all_users()
@@ -72,8 +89,12 @@ where
             .collect())
     }
 
-    async fn create_role(&self, role: &str) -> Result<(), service::ServiceError> {
+    async fn create_role(
-        self.check_permission("admin").await?;
+        &self,
+        role: &str,
+        context: Self::Context,
+    ) -> Result<(), service::ServiceError> {
+        self.check_permission("admin", context).await?;
         self.permission_dao
             .create_role(
                 &dao::RoleEntity { name: role.into() },
@@ -82,13 +103,20 @@ where
             .await?;
         Ok(())
     }
-    async fn delete_role(&self, role: &str) -> Result<(), service::ServiceError> {
+    async fn delete_role(
-        self.check_permission("admin").await?;
+        &self,
+        role: &str,
+        context: Self::Context,
+    ) -> Result<(), service::ServiceError> {
+        self.check_permission("admin", context).await?;
         self.permission_dao.delete_role(role).await?;
         Ok(())
     }
-    async fn get_all_roles(&self) -> Result<Arc<[service::Role]>, service::ServiceError> {
+    async fn get_all_roles(
-        self.check_permission("admin").await?;
+        &self,
+        context: Self::Context,
+    ) -> Result<Arc<[service::Role]>, service::ServiceError> {
+        self.check_permission("admin", context).await?;
         Ok(self
             .permission_dao
             .all_roles()
@@ -98,8 +126,12 @@ where
             .collect())
     }
 
-    async fn create_privilege(&self, privilege: &str) -> Result<(), service::ServiceError> {
+    async fn create_privilege(
-        self.check_permission("admin").await?;
+        &self,
+        privilege: &str,
+        context: Self::Context,
+    ) -> Result<(), service::ServiceError> {
+        self.check_permission("admin", context).await?;
         self.permission_dao
             .create_privilege(
                 &dao::PrivilegeEntity {
@@ -111,13 +143,20 @@ where
         Ok(())
     }
 
-    async fn delete_privilege(&self, privilege: &str) -> Result<(), service::ServiceError> {
+    async fn delete_privilege(
-        self.check_permission("admin").await?;
+        &self,
+        privilege: &str,
+        context: Self::Context,
+    ) -> Result<(), service::ServiceError> {
+        self.check_permission("admin", context).await?;
         self.permission_dao.delete_privilege(privilege).await?;
         Ok(())
     }
-    async fn get_all_privileges(&self) -> Result<Arc<[service::Privilege]>, service::ServiceError> {
+    async fn get_all_privileges(
-        self.check_permission("admin").await?;
+        &self,
+        context: Self::Context,
+    ) -> Result<Arc<[service::Privilege]>, service::ServiceError> {
+        self.check_permission("admin", context).await?;
         Ok(self
             .permission_dao
             .all_privileges()
@@ -127,8 +166,13 @@ where
             .collect())
     }
 
-    async fn add_user_role(&self, user: &str, role: &str) -> Result<(), service::ServiceError> {
+    async fn add_user_role(
-        self.check_permission("admin").await?;
+        &self,
+        user: &str,
+        role: &str,
+        context: Self::Context,
+    ) -> Result<(), service::ServiceError> {
+        self.check_permission("admin", context).await?;
         self.permission_dao
             .add_user_role(user, role, PERMISSION_SERVICE_PROCESS)
             .await?;
@@ -138,8 +182,9 @@ where
         &self,
         role: &str,
         privilege: &str,
+        context: Self::Context,
     ) -> Result<(), service::ServiceError> {
-        self.check_permission("admin").await?;
+        self.check_permission("admin", context).await?;
         self.permission_dao
             .add_role_privilege(role, privilege, PERMISSION_SERVICE_PROCESS)
             .await?;
@@ -149,15 +194,21 @@ where
         &self,
         role: &str,
         privilege: &str,
+        context: Self::Context,
     ) -> Result<(), service::ServiceError> {
-        self.check_permission("admin").await?;
+        self.check_permission("admin", context).await?;
         self.permission_dao
             .delete_role_privilege(role, privilege)
             .await?;
         Ok(())
     }
-    async fn delete_user_role(&self, user: &str, role: &str) -> Result<(), service::ServiceError> {
+    async fn delete_user_role(
-        self.check_permission("admin").await?;
+        &self,
+        user: &str,
+        role: &str,
+        context: Self::Context,
+    ) -> Result<(), service::ServiceError> {
+        self.check_permission("admin", context).await?;
         self.permission_dao.delete_user_role(user, role).await?;
         Ok(())
     }

service_impl/src/slot.rs

@@ -58,10 +58,13 @@ where
     ClockService: service::clock::ClockService + Send + Sync,
     UuidService: service::uuid_service::UuidService + Send + Sync,
 {
-    async fn get_slots(&self) -> Result<Arc<[Slot]>, ServiceError> {
+    type Context = PermissionService::Context;
+
+    async fn get_slots(&self, context: Self::Context) -> Result<Arc<[Slot]>, ServiceError> {
         let (hr_permission, sales_permission) = join!(
-            self.permission_service.check_permission("hr"),
+            self.permission_service
-            self.permission_service.check_permission("sales"),
+                .check_permission("hr", context.clone()),
+            self.permission_service.check_permission("sales", context),
         );
         hr_permission.or(sales_permission)?;
 
@@ -73,10 +76,11 @@ where
             .map(Slot::from)
             .collect())
     }
-    async fn get_slot(&self, id: &Uuid) -> Result<Slot, ServiceError> {
+    async fn get_slot(&self, id: &Uuid, context: Self::Context) -> Result<Slot, ServiceError> {
         let (hr_permission, sales_permission) = join!(
-            self.permission_service.check_permission("hr"),
+            self.permission_service
-            self.permission_service.check_permission("sales"),
+                .check_permission("hr", context.clone()),
+            self.permission_service.check_permission("sales", context),
         );
         hr_permission.or(sales_permission)?;
 
@@ -87,8 +91,10 @@ where
             .ok_or_else(move || ServiceError::EntityNotFound(*id))?;
         Ok(slot)
     }
-    async fn create_slot(&self, slot: &Slot) -> Result<Slot, ServiceError> {
+    async fn create_slot(&self, slot: &Slot, context: Self::Context) -> Result<Slot, ServiceError> {
-        self.permission_service.check_permission("hr").await?;
+        self.permission_service
+            .check_permission("hr", context.clone())
+            .await?;
 
         if slot.id != Uuid::nil() {
             return Err(ServiceError::IdSetOnCreate);
@@ -107,7 +113,7 @@ where
         }
 
         if self
-            .get_slots()
+            .get_slots(context)
             .await?
             .iter()
             .any(|s| test_overlapping_slots(slot, s))
@@ -126,8 +132,10 @@ where
         Ok(slot)
     }
 
-    async fn delete_slot(&self, id: &Uuid) -> Result<(), ServiceError> {
+    async fn delete_slot(&self, id: &Uuid, context: Self::Context) -> Result<(), ServiceError> {
-        self.permission_service.check_permission("hr").await?;
+        self.permission_service
+            .check_permission("hr", context)
+            .await?;
         let mut slot = self
             .slot_dao
             .get_slot(id)
@@ -139,8 +147,10 @@ where
             .await?;
         Ok(())
     }
-    async fn update_slot(&self, slot: &Slot) -> Result<(), ServiceError> {
+    async fn update_slot(&self, slot: &Slot, context: Self::Context) -> Result<(), ServiceError> {
-        self.permission_service.check_permission("hr").await?;
+        self.permission_service
+            .check_permission("hr", context)
+            .await?;
         let persisted_slot = self
             .slot_dao
             .get_slot(&slot.id)

service_impl/src/test/permission_test.rs

@@ -7,17 +7,20 @@ use tokio;
 fn generate_dependencies_mocks_permission(
     grant: bool,
     privilege: &'static str,
-) -> (dao::MockPermissionDao, service::MockUserService) {
+) -> (
+    dao::MockPermissionDao,
+    service::user_service::MockUserService,
+) {
     let mut permission_dao = dao::MockPermissionDao::new();
     permission_dao
         .expect_has_privilege()
         .with(eq("DEVUSER"), eq(privilege))
         .returning(move |_, _| Ok(grant));
 
-    let mut user_service = service::MockUserService::new();
+    let mut user_service = service::user_service::MockUserService::new();
     user_service
         .expect_current_user()
-        .returning(|| Ok("DEVUSER".into()));
+        .returning(|_| Ok("DEVUSER".into()));
     (permission_dao, user_service)
 }
 
@@ -27,7 +30,7 @@ async fn test_check_permission() {
 
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
-    let result = permission_service.check_permission("hello").await;
+    let result = permission_service.check_permission("hello", ()).await;
     result.expect("Expected successful authorization");
 }
 
@@ -37,17 +40,17 @@ async fn test_check_permission_denied() {
 
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
-    let result = permission_service.check_permission("hello").await;
+    let result = permission_service.check_permission("hello", ()).await;
     test_forbidden(&result);
 }
 
 #[tokio::test]
 async fn test_user_service_dev() {
-    use service::UserService;
+    use service::user_service::UserService;
     let user_service = UserServiceDev;
     assert_eq!(
         "DEVUSER",
-        user_service.current_user().await.unwrap().as_ref()
+        user_service.current_user(()).await.unwrap().as_ref()
     );
 }
 
@@ -68,7 +71,7 @@ async fn test_create_user() {
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
     permission_service
-        .create_user("testuser")
+        .create_user("testuser", ())
         .await
         .expect("Extected successful user creation");
 }
@@ -78,7 +81,7 @@ async fn test_create_user_without_permission() {
     let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin");
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
-    test_forbidden(&permission_service.create_user("testuser").await);
+    test_forbidden(&permission_service.create_user("testuser", ()).await);
 }
 
 #[tokio::test]
@@ -94,7 +97,7 @@ async fn test_delete_user() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
 
     permission_service
-        .delete_user("testuser")
+        .delete_user("testuser", ())
         .await
         .expect("Expected successful delete");
 }
@@ -103,7 +106,7 @@ async fn test_delete_user_without_permission() {
     let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin");
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
-    test_forbidden(&permission_service.delete_user("testuser").await);
+    test_forbidden(&permission_service.delete_user("testuser", ()).await);
 }
 
 #[tokio::test]
@@ -123,7 +126,7 @@ async fn test_create_role() {
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
     permission_service
-        .create_role("testrole")
+        .create_role("testrole", ())
         .await
         .expect("Extected successful role creation");
 }
@@ -133,7 +136,7 @@ async fn test_create_role_without_permission() {
     let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin");
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
-    test_forbidden(&permission_service.create_role("testrole").await);
+    test_forbidden(&permission_service.create_role("testrole", ()).await);
 }
 
 #[tokio::test]
@@ -149,7 +152,7 @@ async fn test_delete_role() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
 
     permission_service
-        .delete_role("testrole")
+        .delete_role("testrole", ())
         .await
         .expect("Expected successful delete");
 }
@@ -159,7 +162,7 @@ async fn test_delete_role_without_permission() {
     let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin");
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
-    test_forbidden(&permission_service.delete_role("testrole").await);
+    test_forbidden(&permission_service.delete_role("testrole", ()).await);
 }
 
 #[tokio::test]
@@ -180,7 +183,7 @@ async fn test_create_privilege() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
 
     permission_service
-        .create_privilege("testprivilege")
+        .create_privilege("testprivilege", ())
         .await
         .expect("Extected successful privilege creation");
 }
@@ -189,7 +192,11 @@ async fn test_create_privilege_without_permission() {
     let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin");
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
-    test_forbidden(&permission_service.create_privilege("testprivilege").await);
+    test_forbidden(
+        &permission_service
+            .create_privilege("testprivilege", ())
+            .await,
+    );
 }
 
 #[tokio::test]
@@ -205,7 +212,7 @@ async fn test_delete_privilege() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
 
     permission_service
-        .delete_privilege("testprivilege")
+        .delete_privilege("testprivilege", ())
         .await
         .expect("Expected successful delete");
 }
@@ -215,7 +222,11 @@ async fn test_delete_privilege_without_permission() {
     let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin");
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
-    test_forbidden(&permission_service.delete_privilege("testprivilege").await);
+    test_forbidden(
+        &permission_service
+            .delete_privilege("testprivilege", ())
+            .await,
+    );
 }
 
 #[tokio::test]
@@ -231,7 +242,7 @@ async fn test_add_user_role() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
 
     permission_service
-        .add_user_role("testuser", "testrole")
+        .add_user_role("testuser", "testrole", ())
         .await
         .expect("Extected successful user role creation");
 }
@@ -243,7 +254,7 @@ async fn test_add_user_role_without_permission() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
     test_forbidden(
         &permission_service
-            .add_user_role("testuser", "testrole")
+            .add_user_role("testuser", "testrole", ())
             .await,
     );
 }
@@ -265,7 +276,7 @@ async fn test_add_role_privilege() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
 
     permission_service
-        .add_role_privilege("testrole", "testprivilege")
+        .add_role_privilege("testrole", "testprivilege", ())
         .await
         .expect("Extected successful role privilege creation");
 }
@@ -277,7 +288,7 @@ async fn test_add_role_privilege_without_permission() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
     test_forbidden(
         &permission_service
-            .add_role_privilege("testrole", "testprivilege")
+            .add_role_privilege("testrole", "testprivilege", ())
             .await,
     );
 }
@@ -295,7 +306,7 @@ async fn test_delete_role_privilege() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
 
     permission_service
-        .delete_role_privilege("testrole", "testprivilege")
+        .delete_role_privilege("testrole", "testprivilege", ())
         .await
         .expect("Extected successful role privilege deletion");
 }
@@ -307,7 +318,7 @@ async fn test_delete_role_privilege_without_permission() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
     test_forbidden(
         &permission_service
-            .delete_role_privilege("testrole", "testprivilege")
+            .delete_role_privilege("testrole", "testprivilege", ())
             .await,
     );
 }
@@ -325,7 +336,7 @@ async fn test_delete_user_role() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
 
     permission_service
-        .delete_user_role("testuser", "testrole")
+        .delete_user_role("testuser", "testrole", ())
         .await
         .expect("Extected successful user role deletion");
 }
@@ -337,7 +348,7 @@ async fn test_delete_user_role_without_permission() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
     test_forbidden(
         &permission_service
-            .delete_user_role("testuser", "testrole")
+            .delete_user_role("testuser", "testrole", ())
             .await,
     );
 }
@@ -360,7 +371,7 @@ async fn test_all_roles() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
 
     let all_roles = permission_service
-        .get_all_roles()
+        .get_all_roles(())
         .await
         .expect("Expected roles successfully");
     assert_eq!(all_roles.len(), 2);
@@ -373,7 +384,7 @@ async fn test_all_roles_without_permission() {
     let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin");
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
-    test_forbidden(&permission_service.get_all_roles().await);
+    test_forbidden(&permission_service.get_all_roles(()).await);
 }
 
 #[tokio::test]
@@ -394,7 +405,7 @@ async fn test_all_users() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
 
     let all_users = permission_service
-        .get_all_users()
+        .get_all_users(())
         .await
         .expect("Expected users successfully");
 
@@ -408,7 +419,7 @@ async fn test_all_users_without_permission() {
     let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin");
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
-    test_forbidden(&permission_service.get_all_users().await);
+    test_forbidden(&permission_service.get_all_users(()).await);
 }
 
 #[tokio::test]
@@ -432,7 +443,7 @@ async fn test_all_privileges() {
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
 
     let all_privileges = permission_service
-        .get_all_privileges()
+        .get_all_privileges(())
         .await
         .expect("Expected privileges successfully");
 
@@ -446,5 +457,5 @@ async fn test_all_privileges_without_permission() {
     let (permission_dao, user_service) = generate_dependencies_mocks_permission(false, "admin");
     let permission_service =
         PermissionServiceImpl::new(Arc::new(permission_dao), Arc::new(user_service));
-    test_forbidden(&permission_service.get_all_privileges().await);
+    test_forbidden(&permission_service.get_all_privileges(()).await);
 }

service_impl/src/test/slot.rs

@@ -72,8 +72,8 @@ pub fn build_dependencies(permission: bool, role: &'static str) -> SlotServiceDe
     let mut permission_service = MockPermissionService::new();
     permission_service
         .expect_check_permission()
-        .with(eq(role))
+        .with(eq(role), eq(()))
-        .returning(move |_| {
+        .returning(move |_, _| {
             if permission {
                 Ok(())
             } else {
@@ -82,7 +82,7 @@ pub fn build_dependencies(permission: bool, role: &'static str) -> SlotServiceDe
         });
     permission_service
         .expect_check_permission()
-        .returning(move |_| Err(service::ServiceError::Forbidden));
+        .returning(move |_, _| Err(service::ServiceError::Forbidden));
     let mut clock_service = MockClockService::new();
     clock_service
         .expect_time_now()
@@ -122,7 +122,7 @@ async fn test_get_slots() {
 
     let slot_service = dependencies.build_service();
 
-    let result = slot_service.get_slots().await;
+    let result = slot_service.get_slots(()).await;
     assert!(result.is_ok());
     let result = result.unwrap();
 
@@ -146,7 +146,7 @@ async fn test_get_slots_sales_role() {
         .expect_get_slots()
         .returning(|| Ok(Arc::new([])));
     let slot_service = dependencies.build_service();
-    let result = slot_service.get_slots().await;
+    let result = slot_service.get_slots(()).await;
     assert!(result.is_ok());
 }
 
@@ -158,7 +158,7 @@ async fn test_get_slots_no_permission() {
         .expect_get_slots()
         .returning(|| Ok(Arc::new([])));
     let slot_service = dependencies.build_service();
-    let result = slot_service.get_slots().await;
+    let result = slot_service.get_slots(()).await;
     test_forbidden(&result);
 }
 
@@ -172,7 +172,7 @@ async fn test_get_slot() {
         .times(1)
         .returning(|_| Ok(Some(generate_default_slot_entity())));
     let slot_service = dependencies.build_service();
-    let result = slot_service.get_slot(&default_id()).await;
+    let result = slot_service.get_slot(&default_id(), ()).await;
     assert!(result.is_ok());
     let result = result.unwrap();
     assert_eq!(result, generate_default_slot());
@@ -188,7 +188,7 @@ async fn test_get_slot_sales_role() {
         .times(1)
         .returning(|_| Ok(Some(generate_default_slot_entity())));
     let slot_service = dependencies.build_service();
-    let result = slot_service.get_slot(&default_id()).await;
+    let result = slot_service.get_slot(&default_id(), ()).await;
     assert!(result.is_ok());
 }
 
@@ -202,7 +202,7 @@ async fn test_get_slot_not_found() {
         .times(1)
         .returning(|_| Ok(None));
     let slot_service = dependencies.build_service();
-    let result = slot_service.get_slot(&default_id()).await;
+    let result = slot_service.get_slot(&default_id(), ()).await;
     test_not_found(&result, &default_id());
 }
 
@@ -210,7 +210,7 @@ async fn test_get_slot_not_found() {
 async fn test_get_slot_no_permission() {
     let dependencies = build_dependencies(false, "hr");
     let slot_service = dependencies.build_service();
-    let result = slot_service.get_slot(&default_id()).await;
+    let result = slot_service.get_slot(&default_id(), ()).await;
     test_forbidden(&result);
 }
 
@@ -240,11 +240,14 @@ async fn test_create_slot() {
 
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            id: Uuid::nil(),
+            &Slot {
-            version: Uuid::nil(),
+                id: Uuid::nil(),
-            ..generate_default_slot()
+                version: Uuid::nil(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     assert!(result.is_ok());
     assert_eq!(result.unwrap(), generate_default_slot());
@@ -254,7 +257,7 @@ async fn test_create_slot() {
 async fn test_create_slot_no_permission() {
     let dependencies = build_dependencies(false, "hr");
     let slot_service = dependencies.build_service();
-    let result = slot_service.create_slot(&generate_default_slot()).await;
+    let result = slot_service.create_slot(&generate_default_slot(), ()).await;
     test_forbidden(&result);
 }
 
@@ -273,10 +276,13 @@ async fn test_create_slot_non_zero_id() {
         .returning(|_| default_version());
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            version: Uuid::nil(),
+            &Slot {
-            ..generate_default_slot()
+                version: Uuid::nil(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_zero_id_error(&result);
 }
@@ -296,10 +302,13 @@ async fn test_create_slot_non_zero_version() {
         .returning(|_| default_version());
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            id: Uuid::nil(),
+            &Slot {
-            ..generate_default_slot()
+                id: Uuid::nil(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_zero_version_error(&result);
 }
@@ -343,85 +352,106 @@ async fn test_create_slot_intersects() {
 
     // Test successful case, directly between two existing slots.
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            id: Uuid::nil(),
+            &Slot {
-            version: Uuid::nil(),
+                id: Uuid::nil(),
-            from: Time::from_hms(11, 0, 0).unwrap(),
+                version: Uuid::nil(),
-            to: Time::from_hms(12, 0, 0).unwrap(),
+                from: Time::from_hms(11, 0, 0).unwrap(),
-            ..generate_default_slot()
+                to: Time::from_hms(12, 0, 0).unwrap(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     assert!(result.is_ok());
 
     // Test case where it is exactly on an existing slot.
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            id: Uuid::nil(),
+            &Slot {
-            version: Uuid::nil(),
+                id: Uuid::nil(),
-            from: Time::from_hms(10, 0, 0).unwrap(),
+                version: Uuid::nil(),
-            to: Time::from_hms(11, 0, 0).unwrap(),
+                from: Time::from_hms(10, 0, 0).unwrap(),
-            ..generate_default_slot()
+                to: Time::from_hms(11, 0, 0).unwrap(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_overlapping_time_range_error(&result);
 
     // Test case where from is inside an existing slot.
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            id: Uuid::nil(),
+            &Slot {
-            version: Uuid::nil(),
+                id: Uuid::nil(),
-            from: Time::from_hms(10, 30, 0).unwrap(),
+                version: Uuid::nil(),
-            to: Time::from_hms(11, 30, 0).unwrap(),
+                from: Time::from_hms(10, 30, 0).unwrap(),
-            ..generate_default_slot()
+                to: Time::from_hms(11, 30, 0).unwrap(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_overlapping_time_range_error(&result);
 
     // Test case where to is inside an existing slot.
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            id: Uuid::nil(),
+            &Slot {
-            version: Uuid::nil(),
+                id: Uuid::nil(),
-            from: Time::from_hms(11, 30, 0).unwrap(),
+                version: Uuid::nil(),
-            to: Time::from_hms(12, 30, 0).unwrap(),
+                from: Time::from_hms(11, 30, 0).unwrap(),
-            ..generate_default_slot()
+                to: Time::from_hms(12, 30, 0).unwrap(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_overlapping_time_range_error(&result);
 
     // Test case where is completely inside an existing slot.
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            id: Uuid::nil(),
+            &Slot {
-            version: Uuid::nil(),
+                id: Uuid::nil(),
-            from: Time::from_hms(10, 15, 0).unwrap(),
+                version: Uuid::nil(),
-            to: Time::from_hms(10, 45, 0).unwrap(),
+                from: Time::from_hms(10, 15, 0).unwrap(),
-            ..generate_default_slot()
+                to: Time::from_hms(10, 45, 0).unwrap(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_overlapping_time_range_error(&result);
 
     // Test case where is completely outside of an existing slot.
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            id: Uuid::nil(),
+            &Slot {
-            version: Uuid::nil(),
+                id: Uuid::nil(),
-            from: Time::from_hms(9, 0, 0).unwrap(),
+                version: Uuid::nil(),
-            to: Time::from_hms(11, 0, 0).unwrap(),
+                from: Time::from_hms(9, 0, 0).unwrap(),
-            ..generate_default_slot()
+                to: Time::from_hms(11, 0, 0).unwrap(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_overlapping_time_range_error(&result);
 
     // Test case where is would intersect on monday but not on tuesday.
     // Test case where is completely outside of an existing slot.
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            id: Uuid::nil(),
+            &Slot {
-            version: Uuid::nil(),
+                id: Uuid::nil(),
-            day_of_week: DayOfWeek::Tuesday.into(),
+                version: Uuid::nil(),
-            ..generate_default_slot()
+                day_of_week: DayOfWeek::Tuesday.into(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     assert!(result.is_ok());
 }
@@ -440,13 +470,16 @@ async fn test_create_slot_time_order() {
 
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            id: Uuid::nil(),
+            &Slot {
-            version: Uuid::nil(),
+                id: Uuid::nil(),
-            from: Time::from_hms(12, 00, 0).unwrap(),
+                version: Uuid::nil(),
-            to: Time::from_hms(11, 00, 00).unwrap(),
+                from: Time::from_hms(12, 00, 0).unwrap(),
-            ..generate_default_slot()
+                to: Time::from_hms(11, 00, 00).unwrap(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_time_order_wrong(&result);
 }
@@ -465,13 +498,16 @@ async fn test_create_slot_date_order() {
 
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .create_slot(&Slot {
+        .create_slot(
-            id: Uuid::nil(),
+            &Slot {
-            version: Uuid::nil(),
+                id: Uuid::nil(),
-            valid_from: Date::from_calendar_date(2022, Month::January, 2).unwrap(),
+                version: Uuid::nil(),
-            valid_to: Some(Date::from_calendar_date(2022, Month::January, 1).unwrap()),
+                valid_from: Date::from_calendar_date(2022, Month::January, 2).unwrap(),
-            ..generate_default_slot()
+                valid_to: Some(Date::from_calendar_date(2022, Month::January, 1).unwrap()),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_date_order_wrong(&result);
 }
@@ -502,7 +538,7 @@ async fn test_delete_slot() {
         .returning(|_, _| Ok(()));
 
     let slot_service = dependencies.build_service();
-    let result = slot_service.delete_slot(&default_id()).await;
+    let result = slot_service.delete_slot(&default_id(), ()).await;
     assert!(result.is_ok());
 }
 
@@ -510,7 +546,7 @@ async fn test_delete_slot() {
 async fn test_delete_slot_no_permission() {
     let dependencies = build_dependencies(false, "hr");
     let slot_service = dependencies.build_service();
-    let result = slot_service.delete_slot(&default_id()).await;
+    let result = slot_service.delete_slot(&default_id(), ()).await;
     test_forbidden(&result);
 }
 
@@ -524,7 +560,7 @@ async fn test_delete_slot_not_found() {
         .times(1)
         .returning(|_| Ok(None));
     let slot_service = dependencies.build_service();
-    let result = slot_service.delete_slot(&default_id()).await;
+    let result = slot_service.delete_slot(&default_id(), ()).await;
     test_not_found(&result, &default_id());
 }
 
@@ -532,7 +568,7 @@ async fn test_delete_slot_not_found() {
 async fn test_update_slot_no_permission() {
     let dependencies = build_dependencies(false, "hr");
     let slot_service = dependencies.build_service();
-    let result = slot_service.update_slot(&generate_default_slot()).await;
+    let result = slot_service.update_slot(&generate_default_slot(), ()).await;
     test_forbidden(&result);
 }
 
@@ -546,7 +582,7 @@ async fn test_update_slot_not_found() {
         .times(1)
         .returning(|_| Ok(None));
     let slot_service = dependencies.build_service();
-    let result = slot_service.update_slot(&generate_default_slot()).await;
+    let result = slot_service.update_slot(&generate_default_slot(), ()).await;
     test_not_found(&result, &default_id());
 }
 
@@ -560,10 +596,13 @@ async fn test_update_slot_version_mismatch() {
         .returning(|_| Ok(Some(generate_default_slot_entity())));
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .update_slot(&service::slot::Slot {
+        .update_slot(
-            version: uuid!("86DE856C-D176-4F1F-A4FE-0D9844C02C04"),
+            &service::slot::Slot {
-            ..generate_default_slot()
+                version: uuid!("86DE856C-D176-4F1F-A4FE-0D9844C02C04"),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_conflicts(
         &result,
@@ -605,12 +644,15 @@ async fn test_update_slot_valid_to() {
 
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .update_slot(&service::slot::Slot {
+        .update_slot(
-            valid_to: Some(
+            &service::slot::Slot {
-                time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(),
+                valid_to: Some(
-            ),
+                    time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(),
-            ..generate_default_slot()
+                ),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     dbg!(&result);
     assert!(result.is_ok());
@@ -627,12 +669,15 @@ async fn test_update_slot_valid_to_before_valid_from() {
 
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .update_slot(&service::slot::Slot {
+        .update_slot(
-            valid_to: Some(
+            &service::slot::Slot {
-                time::Date::from_calendar_date(2021, 1.try_into().unwrap(), 10).unwrap(),
+                valid_to: Some(
-            ),
+                    time::Date::from_calendar_date(2021, 1.try_into().unwrap(), 10).unwrap(),
-            ..generate_default_slot()
+                ),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_date_order_wrong(&result);
 }
@@ -669,13 +714,16 @@ async fn test_update_slot_deleted() {
 
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .update_slot(&Slot {
+        .update_slot(
-            deleted: Some(time::PrimitiveDateTime::new(
+            &Slot {
-                Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(),
+                deleted: Some(time::PrimitiveDateTime::new(
-                Time::from_hms(0, 0, 0).unwrap(),
+                    Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(),
-            )),
+                    Time::from_hms(0, 0, 0).unwrap(),
-            ..generate_default_slot()
+                )),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     assert!(result.is_ok());
 }
@@ -690,10 +738,13 @@ async fn test_update_slot_day_of_week_forbidden() {
         .returning(|_| Ok(Some(generate_default_slot_entity())));
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .update_slot(&service::slot::Slot {
+        .update_slot(
-            day_of_week: service::slot::DayOfWeek::Friday,
+            &service::slot::Slot {
-            ..generate_default_slot()
+                day_of_week: service::slot::DayOfWeek::Friday,
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_validation_error(
         &result,
@@ -719,10 +770,15 @@ async fn test_update_to_forbidden_when_not_none() {
         });
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .update_slot(&service::slot::Slot {
+        .update_slot(
-            valid_to: Some(time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 4).unwrap()),
+            &service::slot::Slot {
-            ..generate_default_slot()
+                valid_to: Some(
-        })
+                    time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 4).unwrap(),
+                ),
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_validation_error(
         &result,
@@ -741,10 +797,13 @@ async fn test_update_from_forbidden() {
         .returning(|_| Ok(Some(generate_default_slot_entity())));
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .update_slot(&service::slot::Slot {
+        .update_slot(
-            from: time::Time::from_hms(14, 0, 0).unwrap(),
+            &service::slot::Slot {
-            ..generate_default_slot()
+                from: time::Time::from_hms(14, 0, 0).unwrap(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_validation_error(
         &result,
@@ -763,10 +822,13 @@ async fn test_update_to_forbidden() {
         .returning(|_| Ok(Some(generate_default_slot_entity())));
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .update_slot(&service::slot::Slot {
+        .update_slot(
-            to: time::Time::from_hms(14, 0, 0).unwrap(),
+            &service::slot::Slot {
-            ..generate_default_slot()
+                to: time::Time::from_hms(14, 0, 0).unwrap(),
-        })
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_validation_error(
         &result,
@@ -785,10 +847,14 @@ async fn test_update_valid_from_forbidden() {
         .returning(|_| Ok(Some(generate_default_slot_entity())));
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .update_slot(&service::slot::Slot {
+        .update_slot(
-            valid_from: time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(),
+            &service::slot::Slot {
-            ..generate_default_slot()
+                valid_from: time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10)
-        })
+                    .unwrap(),
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_validation_error(
         &result,
@@ -807,11 +873,15 @@ async fn test_update_valid_multiple_forbidden_changes() {
         .returning(|_| Ok(Some(generate_default_slot_entity())));
     let slot_service = dependencies.build_service();
     let result = slot_service
-        .update_slot(&service::slot::Slot {
+        .update_slot(
-            valid_from: time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10).unwrap(),
+            &service::slot::Slot {
-            from: time::Time::from_hms(14, 0, 0).unwrap(),
+                valid_from: time::Date::from_calendar_date(2022, 1.try_into().unwrap(), 10)
-            ..generate_default_slot()
+                    .unwrap(),
-        })
+                from: time::Time::from_hms(14, 0, 0).unwrap(),
+                ..generate_default_slot()
+            },
+            (),
+        )
         .await;
     test_validation_error(
         &result,