use std::sync::Arc;
use anyhow::Result;
use async_trait::async_trait;
use chrono::Utc;
use super::FileShareProjection;
use crate::domain::entity::FileShare;
use crate::domain::events::{
FileShareCreatedEvent, FileShareUpdatedEvent, FileShareDeletedEvent,
};
#[async_trait]
pub trait FileShareEventHandler: Send + Sync {
async fn on_created(&self, event: FileShareCreatedEvent, sequence: i64) -> Result<()>;
async fn on_updated(&self, event: FileShareUpdatedEvent, sequence: i64) -> Result<()>;
async fn on_deleted(&self, event: FileShareDeletedEvent, sequence: i64) -> Result<()>;
}
#[async_trait]
pub trait FileShareProjectionRepository: Send + Sync {
async fn save(&self, projection: &FileShareProjection) -> Result<()>;
async fn find_by_id(&self, id: uuid::Uuid) -> Result<Option<FileShareProjection>>;
async fn delete(&self, id: uuid::Uuid) -> Result<()>;
async fn rebuild_all(&self) -> Result<u64>;
}
pub struct FileShareProjector<R: FileShareProjectionRepository> {
repository: Arc<R>,
}
impl<R: FileShareProjectionRepository> FileShareProjector<R> {
pub fn new(repository: Arc<R>) -> Self {
Self { repository }
}
pub async fn rebuild(&self) -> Result<u64> {
self.repository.rebuild_all().await
}
pub async fn process_stored_event(&self, event: &crate::infrastructure::event_store::StoredEvent) -> Result<bool>
where
Self: FileShareEventHandler,
{
let sequence = event.sequence;
match event.event_type.as_str() {
"FileShareCreatedEvent" => {
let created: FileShareCreatedEvent = serde_json::from_value(event.payload.clone())?;
self.on_created(created, sequence).await?;
Ok(true)
}
"FileShareUpdatedEvent" => {
let updated: FileShareUpdatedEvent = serde_json::from_value(event.payload.clone())?;
self.on_updated(updated, sequence).await?;
Ok(true)
}
"FileShareDeletedEvent" => {
let deleted: FileShareDeletedEvent = serde_json::from_value(event.payload.clone())?;
self.on_deleted(deleted, sequence).await?;
Ok(true)
}
_ => Ok(false), }
}
}
#[async_trait]
impl<R: FileShareProjectionRepository> FileShareEventHandler for FileShareProjector<R> {
async fn on_created(&self, event: FileShareCreatedEvent, sequence: i64) -> Result<()> {
let mut projection = FileShareProjection::new(
event.id,
event.file_id,
event.owner_id,
event.token,
event.share_type,
event.permission,
event.shared_with,
event.password_hash,
event.max_downloads,
event.download_count,
event.expires_at,
event.status,
event.revoked_at,
event.revoked_by,
event.message,
event.metadata
);
projection.apply_event(sequence);
self.repository.save(&projection).await
}
async fn on_updated(&self, event: FileShareUpdatedEvent, sequence: i64) -> Result<()> {
if let Some(mut projection) = self.repository.find_by_id(event.id).await? {
projection.file_id = event.file_id;
projection.owner_id = event.owner_id;
projection.token = event.token;
projection.share_type = event.share_type;
projection.permission = event.permission;
projection.shared_with = event.shared_with;
projection.password_hash = event.password_hash;
projection.max_downloads = event.max_downloads;
projection.download_count = event.download_count;
projection.expires_at = event.expires_at;
projection.status = event.status;
projection.revoked_at = event.revoked_at;
projection.revoked_by = event.revoked_by;
projection.message = event.message;
projection.metadata = event.metadata;
projection.apply_event(sequence);
self.repository.save(&projection).await?;
}
Ok(())
}
async fn on_deleted(&self, event: FileShareDeletedEvent, _sequence: i64) -> Result<()> {
self.repository.delete(event.id).await
}
}