style: cargo fmt --all

crates/application/src/sharing/commands/generate_share_link.rs

@@ -1,10 +1,10 @@
-use std::sync::Arc;
 use domain::{
     entities::{LinkAccessLevel, ScopeType, ShareLink, ShareScope, ShareableType},
     errors::DomainError,
     ports::ShareRepository,
     value_objects::{DateTimeStamp, SystemId},
 };
+use std::sync::Arc;
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct GenerateShareLinkCommand {
@@ -25,8 +25,16 @@ impl GenerateShareLinkHandler {
         Self { share_repo }
     }
 
-    pub async fn execute(&self, cmd: GenerateShareLinkCommand) -> Result<(ShareScope, ShareLink), DomainError> {
-        let scope = ShareScope::new(ScopeType::Link, cmd.shareable_type, cmd.shareable_id, cmd.created_by);
+    pub async fn execute(
+        &self,
+        cmd: GenerateShareLinkCommand,
+    ) -> Result<(ShareScope, ShareLink), DomainError> {
+        let scope = ShareScope::new(
+            ScopeType::Link,
+            cmd.shareable_type,
+            cmd.shareable_id,
+            cmd.created_by,
+        );
         let token = uuid::Uuid::new_v4().to_string();
         let mut link = ShareLink::new(scope.scope_id, token, cmd.access_level);
         link.expires_at = cmd.expires_at;

crates/application/src/sharing/commands/mod.rs

@@ -1,7 +1,7 @@
-pub mod share_resource;
 pub mod generate_share_link;
 pub mod revoke_share;
+pub mod share_resource;
 
-pub use share_resource::{ShareResourceCommand, ShareResourceHandler};
 pub use generate_share_link::{GenerateShareLinkCommand, GenerateShareLinkHandler};
 pub use revoke_share::{RevokeShareCommand, RevokeShareHandler};
+pub use share_resource::{ShareResourceCommand, ShareResourceHandler};

crates/application/src/sharing/commands/revoke_share.rs

@@ -1,10 +1,10 @@
-use std::sync::Arc;
 use domain::{
     errors::DomainError,
     events::DomainEvent,
     ports::{EventPublisher, ShareRepository},
     value_objects::{DateTimeStamp, SystemId},
 };
+use std::sync::Arc;
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct RevokeShareCommand {
@@ -19,20 +19,29 @@ pub struct RevokeShareHandler {
 
 impl RevokeShareHandler {
     pub fn new(share_repo: Arc<dyn ShareRepository>, event_pub: Arc<dyn EventPublisher>) -> Self {
-        Self { share_repo, event_pub }
+        Self {
+            share_repo,
+            event_pub,
+        }
     }
 
     pub async fn execute(&self, cmd: RevokeShareCommand) -> Result<(), DomainError> {
-        self.share_repo.find_scope_by_id(&cmd.scope_id).await?
-            .ok_or_else(|| DomainError::NotFound(format!("Share scope {} not found", cmd.scope_id)))?;
+        self.share_repo
+            .find_scope_by_id(&cmd.scope_id)
+            .await?
+            .ok_or_else(|| {
+                DomainError::NotFound(format!("Share scope {} not found", cmd.scope_id))
+            })?;
 
         self.share_repo.delete_scope(&cmd.scope_id).await?;
 
-        self.event_pub.publish(DomainEvent::ShareRevoked {
-            scope_id: cmd.scope_id,
-            revoked_by: cmd.revoked_by,
-            timestamp: DateTimeStamp::now(),
-        }).await?;
+        self.event_pub
+            .publish(DomainEvent::ShareRevoked {
+                scope_id: cmd.scope_id,
+                revoked_by: cmd.revoked_by,
+                timestamp: DateTimeStamp::now(),
+            })
+            .await?;
 
         Ok(())
     }

crates/application/src/sharing/commands/share_resource.rs

@@ -1,4 +1,3 @@
-use std::sync::Arc;
 use domain::{
     entities::{ScopeType, ShareScope, ShareTarget, ShareableType, TargetType},
     errors::DomainError,
@@ -6,6 +5,7 @@ use domain::{
     ports::{EventPublisher, ShareRepository},
     value_objects::{DateTimeStamp, SystemId},
 };
+use std::sync::Arc;
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ShareResourceCommand {
@@ -24,27 +24,40 @@ pub struct ShareResourceHandler {
 
 impl ShareResourceHandler {
     pub fn new(share_repo: Arc<dyn ShareRepository>, event_pub: Arc<dyn EventPublisher>) -> Self {
-        Self { share_repo, event_pub }
+        Self {
+            share_repo,
+            event_pub,
+        }
     }
 
-    pub async fn execute(&self, cmd: ShareResourceCommand) -> Result<(ShareScope, ShareTarget), DomainError> {
+    pub async fn execute(
+        &self,
+        cmd: ShareResourceCommand,
+    ) -> Result<(ShareScope, ShareTarget), DomainError> {
         let scope_type = match cmd.target_type {
             TargetType::User => ScopeType::User,
             TargetType::Group => ScopeType::Group,
         };
 
-        let scope = ShareScope::new(scope_type, cmd.shareable_type, cmd.shareable_id, cmd.created_by);
+        let scope = ShareScope::new(
+            scope_type,
+            cmd.shareable_type,
+            cmd.shareable_id,
+            cmd.created_by,
+        );
         let target = ShareTarget::new(scope.scope_id, cmd.target_type, cmd.target_id, cmd.role_id);
 
         self.share_repo.save_scope(&scope).await?;
         self.share_repo.save_target(&target).await?;
 
-        self.event_pub.publish(DomainEvent::ShareCreated {
-            scope_id: scope.scope_id,
-            shareable_id: cmd.shareable_id,
-            created_by: cmd.created_by,
-            timestamp: DateTimeStamp::now(),
-        }).await?;
+        self.event_pub
+            .publish(DomainEvent::ShareCreated {
+                scope_id: scope.scope_id,
+                shareable_id: cmd.shareable_id,
+                created_by: cmd.created_by,
+                timestamp: DateTimeStamp::now(),
+            })
+            .await?;
 
         Ok((scope, target))
     }