444 lines
14 KiB
Rust
444 lines
14 KiB
Rust
use async_trait::async_trait;
|
|
|
|
use crate::{
|
|
errors::DomainError,
|
|
models::{
|
|
AnnotatedRow, DiaryEntry, DiaryFilter, EntityType, ExportFormat, ExternalPersonId,
|
|
FeedEntry, FeedSortBy, FieldMapping, FileFormat, FollowingFilter, ImportError,
|
|
ImportProfile, ImportSession, IndexableDocument, MovieProfile, MovieStats, ParsedFile,
|
|
Person, PersonCredits, PersonEnrichmentData, PersonId, RefreshSession, RemoteActorInfo,
|
|
ReviewHistory, SearchQuery, SearchResults, UserStats, UserTrends,
|
|
collections::{PageParams, Paginated},
|
|
},
|
|
ports::{
|
|
DiaryExporter, DiaryQuery, DocumentParser, ImportProfileRepository,
|
|
ImportSessionRepository, MovieProfileRepository, PersonCommand, PersonQuery,
|
|
PosterFetcherClient, RefreshSessionRepository, SearchCommand, SearchPort, StatsRepository,
|
|
UserProfileFieldsRepository,
|
|
},
|
|
value_objects::{ImportProfileId, ImportSessionId, MovieId, PosterUrl, UserId},
|
|
};
|
|
|
|
// ── PanicDiaryQuery ───────────────────────────────────────────────────────────
|
|
|
|
pub struct PanicDiaryQuery;
|
|
|
|
#[async_trait]
|
|
impl DiaryQuery for PanicDiaryQuery {
|
|
async fn query_diary(&self, _: &DiaryFilter) -> Result<Paginated<DiaryEntry>, DomainError> {
|
|
panic!("PanicDiaryQuery called")
|
|
}
|
|
async fn query_activity_feed(
|
|
&self,
|
|
_: &PageParams,
|
|
) -> Result<Paginated<FeedEntry>, DomainError> {
|
|
panic!("PanicDiaryQuery called")
|
|
}
|
|
async fn query_activity_feed_filtered(
|
|
&self,
|
|
_: &PageParams,
|
|
_: &FeedSortBy,
|
|
_: Option<&str>,
|
|
_: Option<&FollowingFilter>,
|
|
) -> Result<Paginated<FeedEntry>, DomainError> {
|
|
panic!("PanicDiaryQuery called")
|
|
}
|
|
async fn get_review_history(&self, _: &MovieId) -> Result<ReviewHistory, DomainError> {
|
|
panic!("PanicDiaryQuery called")
|
|
}
|
|
async fn get_user_history(&self, _: &UserId) -> Result<Vec<DiaryEntry>, DomainError> {
|
|
panic!("PanicDiaryQuery called")
|
|
}
|
|
fn stream_user_history(
|
|
&self,
|
|
_: UserId,
|
|
) -> futures::stream::BoxStream<'static, Result<DiaryEntry, DomainError>> {
|
|
panic!("PanicDiaryQuery called")
|
|
}
|
|
async fn get_movie_stats(&self, _: &MovieId) -> Result<MovieStats, DomainError> {
|
|
panic!("PanicDiaryQuery called")
|
|
}
|
|
async fn get_movie_social_feed(
|
|
&self,
|
|
_: &MovieId,
|
|
_: &PageParams,
|
|
) -> Result<Paginated<FeedEntry>, DomainError> {
|
|
panic!("PanicDiaryQuery called")
|
|
}
|
|
async fn count_local_posts(&self) -> Result<u64, DomainError> {
|
|
panic!("PanicDiaryQuery called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicStatsRepository;
|
|
|
|
#[async_trait]
|
|
impl StatsRepository for PanicStatsRepository {
|
|
async fn get_user_stats(&self, _: &UserId) -> Result<UserStats, DomainError> {
|
|
panic!("PanicStatsRepository called")
|
|
}
|
|
async fn get_user_trends(&self, _: &UserId) -> Result<UserTrends, DomainError> {
|
|
panic!("PanicStatsRepository called")
|
|
}
|
|
async fn count_reviews_in_year(&self, _: &UserId, _: u16) -> Result<u32, DomainError> {
|
|
panic!("PanicStatsRepository called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicImportSessionRepository;
|
|
|
|
#[async_trait]
|
|
impl ImportSessionRepository for PanicImportSessionRepository {
|
|
async fn create(&self, _: &ImportSession) -> Result<(), DomainError> {
|
|
panic!("PanicImportSessionRepository called")
|
|
}
|
|
async fn get(
|
|
&self,
|
|
_: &ImportSessionId,
|
|
_: &UserId,
|
|
) -> Result<Option<ImportSession>, DomainError> {
|
|
panic!("PanicImportSessionRepository called")
|
|
}
|
|
async fn update(&self, _: &ImportSession) -> Result<(), DomainError> {
|
|
panic!("PanicImportSessionRepository called")
|
|
}
|
|
async fn delete(&self, _: &ImportSessionId) -> Result<(), DomainError> {
|
|
panic!("PanicImportSessionRepository called")
|
|
}
|
|
async fn delete_expired(&self) -> Result<u64, DomainError> {
|
|
panic!("PanicImportSessionRepository called")
|
|
}
|
|
async fn delete_expired_for_user(&self, _: &UserId) -> Result<(), DomainError> {
|
|
panic!("PanicImportSessionRepository called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicRefreshSessionRepository;
|
|
|
|
#[async_trait]
|
|
impl RefreshSessionRepository for PanicRefreshSessionRepository {
|
|
async fn create(&self, _: &RefreshSession) -> Result<(), DomainError> {
|
|
panic!("PanicRefreshSessionRepository called")
|
|
}
|
|
async fn get_by_token(&self, _: &str) -> Result<Option<RefreshSession>, DomainError> {
|
|
panic!("PanicRefreshSessionRepository called")
|
|
}
|
|
async fn revoke(&self, _: &str) -> Result<(), DomainError> {
|
|
panic!("PanicRefreshSessionRepository called")
|
|
}
|
|
async fn revoke_all_for_user(&self, _: &UserId) -> Result<(), DomainError> {
|
|
panic!("PanicRefreshSessionRepository called")
|
|
}
|
|
async fn delete_expired(&self) -> Result<u64, DomainError> {
|
|
panic!("PanicRefreshSessionRepository called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicImportProfileRepository;
|
|
|
|
#[async_trait]
|
|
impl ImportProfileRepository for PanicImportProfileRepository {
|
|
async fn save(&self, _: &ImportProfile) -> Result<(), DomainError> {
|
|
panic!("PanicImportProfileRepository called")
|
|
}
|
|
async fn list_for_user(&self, _: &UserId) -> Result<Vec<ImportProfile>, DomainError> {
|
|
panic!("PanicImportProfileRepository called")
|
|
}
|
|
async fn get(
|
|
&self,
|
|
_: &ImportProfileId,
|
|
_: &UserId,
|
|
) -> Result<Option<ImportProfile>, DomainError> {
|
|
panic!("PanicImportProfileRepository called")
|
|
}
|
|
async fn delete(&self, _: &ImportProfileId) -> Result<(), DomainError> {
|
|
panic!("PanicImportProfileRepository called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicMovieProfileRepository;
|
|
|
|
#[async_trait]
|
|
impl MovieProfileRepository for PanicMovieProfileRepository {
|
|
async fn upsert(&self, _: &MovieProfile) -> Result<(), DomainError> {
|
|
panic!("PanicMovieProfileRepository called")
|
|
}
|
|
async fn get_by_movie_id(&self, _: &MovieId) -> Result<Option<MovieProfile>, DomainError> {
|
|
panic!("PanicMovieProfileRepository called")
|
|
}
|
|
async fn list_stale(&self) -> Result<Vec<(MovieId, String)>, DomainError> {
|
|
panic!("PanicMovieProfileRepository called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicPersonCommand;
|
|
|
|
#[async_trait]
|
|
impl PersonCommand for PanicPersonCommand {
|
|
async fn upsert_batch(&self, _: &[Person]) -> Result<(), DomainError> {
|
|
panic!("PanicPersonCommand called")
|
|
}
|
|
async fn backfill_from_credits_batch(&self, _: u32) -> Result<(u64, bool), DomainError> {
|
|
panic!("PanicPersonCommand called")
|
|
}
|
|
async fn update_enrichment(
|
|
&self,
|
|
_: &PersonId,
|
|
_: &PersonEnrichmentData,
|
|
) -> Result<(), DomainError> {
|
|
panic!("PanicPersonCommand called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicPersonQuery;
|
|
|
|
#[async_trait]
|
|
impl PersonQuery for PanicPersonQuery {
|
|
async fn get_by_id(&self, _: &PersonId) -> Result<Option<Person>, DomainError> {
|
|
panic!("PanicPersonQuery called")
|
|
}
|
|
async fn get_by_external_id(
|
|
&self,
|
|
_: &ExternalPersonId,
|
|
) -> Result<Option<Person>, DomainError> {
|
|
panic!("PanicPersonQuery called")
|
|
}
|
|
async fn get_credits(&self, _: &PersonId) -> Result<PersonCredits, DomainError> {
|
|
panic!("PanicPersonQuery called")
|
|
}
|
|
async fn list_orphaned_persons(&self) -> Result<Vec<PersonId>, DomainError> {
|
|
panic!("PanicPersonQuery called")
|
|
}
|
|
async fn list_page(&self, _: u32, _: u32) -> Result<Vec<Person>, DomainError> {
|
|
panic!("PanicPersonQuery called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicSearchPort;
|
|
|
|
#[async_trait]
|
|
impl SearchPort for PanicSearchPort {
|
|
async fn search(&self, _: &SearchQuery) -> Result<SearchResults, DomainError> {
|
|
Ok(SearchResults {
|
|
movies: Paginated {
|
|
items: vec![],
|
|
total_count: 0,
|
|
limit: 10,
|
|
offset: 0,
|
|
},
|
|
people: Paginated {
|
|
items: vec![],
|
|
total_count: 0,
|
|
limit: 10,
|
|
offset: 0,
|
|
},
|
|
})
|
|
}
|
|
}
|
|
|
|
pub struct PanicSearchCommand;
|
|
|
|
#[async_trait]
|
|
impl SearchCommand for PanicSearchCommand {
|
|
async fn index(&self, _: IndexableDocument) -> Result<(), DomainError> {
|
|
panic!("PanicSearchCommand called")
|
|
}
|
|
async fn remove(&self, _: EntityType, _: &str) -> Result<(), DomainError> {
|
|
panic!("PanicSearchCommand called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicPosterFetcher;
|
|
|
|
#[async_trait]
|
|
impl PosterFetcherClient for PanicPosterFetcher {
|
|
async fn fetch_poster_bytes(&self, _: &PosterUrl) -> Result<Vec<u8>, DomainError> {
|
|
panic!("PanicPosterFetcher called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicDiaryExporter;
|
|
|
|
impl DiaryExporter for PanicDiaryExporter {
|
|
fn stream_entries(
|
|
&self,
|
|
_stream: futures::stream::BoxStream<'static, Result<DiaryEntry, DomainError>>,
|
|
_format: ExportFormat,
|
|
) -> futures::stream::BoxStream<'static, Result<bytes::Bytes, DomainError>> {
|
|
panic!("PanicDiaryExporter called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicDocumentParser;
|
|
|
|
impl DocumentParser for PanicDocumentParser {
|
|
fn parse(&self, _: &[u8], _: FileFormat) -> Result<ParsedFile, ImportError> {
|
|
panic!("PanicDocumentParser called")
|
|
}
|
|
fn apply_mapping(&self, _: &ParsedFile, _: &[FieldMapping]) -> Vec<AnnotatedRow> {
|
|
panic!("PanicDocumentParser called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicRemoteWatchlistRepository;
|
|
|
|
#[async_trait]
|
|
impl crate::ports::RemoteWatchlistRepository for PanicRemoteWatchlistRepository {
|
|
async fn save(&self, _: crate::models::RemoteWatchlistEntry) -> Result<(), DomainError> {
|
|
panic!("PanicRemoteWatchlistRepository called")
|
|
}
|
|
async fn remove_by_ap_id(&self, _: &str, _: &str) -> Result<(), DomainError> {
|
|
panic!("PanicRemoteWatchlistRepository called")
|
|
}
|
|
async fn get_by_actor_url(
|
|
&self,
|
|
_: &str,
|
|
) -> Result<Vec<crate::models::RemoteWatchlistEntry>, DomainError> {
|
|
panic!("PanicRemoteWatchlistRepository called")
|
|
}
|
|
async fn remove_all_by_actor(&self, _: &str) -> Result<(), DomainError> {
|
|
panic!("PanicRemoteWatchlistRepository called")
|
|
}
|
|
async fn get_by_derived_uuid(
|
|
&self,
|
|
_: uuid::Uuid,
|
|
) -> Result<Vec<crate::models::RemoteWatchlistEntry>, DomainError> {
|
|
panic!("PanicRemoteWatchlistRepository called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicProfileFieldsRepo;
|
|
|
|
#[async_trait]
|
|
impl UserProfileFieldsRepository for PanicProfileFieldsRepo {
|
|
async fn get_fields(
|
|
&self,
|
|
_: &UserId,
|
|
) -> Result<Vec<crate::models::ProfileField>, DomainError> {
|
|
panic!("PanicProfileFieldsRepo called")
|
|
}
|
|
async fn set_fields(
|
|
&self,
|
|
_: &UserId,
|
|
_: Vec<crate::models::ProfileField>,
|
|
) -> Result<(), DomainError> {
|
|
panic!("PanicProfileFieldsRepo called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicFederationAdminQuery;
|
|
|
|
#[async_trait]
|
|
impl crate::ports::FederationAdminQuery for PanicFederationAdminQuery {
|
|
async fn list_all_followed_remote_actors(&self) -> Result<Vec<RemoteActorInfo>, DomainError> {
|
|
panic!("PanicFederationAdminQuery called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicFederatedProfileQuery;
|
|
|
|
#[async_trait]
|
|
impl crate::ports::FederatedProfileQuery for PanicFederatedProfileQuery {
|
|
async fn get_federated_profile(
|
|
&self,
|
|
_: uuid::Uuid,
|
|
) -> Result<Option<crate::models::FederatedProfile>, DomainError> {
|
|
panic!("PanicFederatedProfileQuery called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicWatchEventCommand;
|
|
|
|
#[async_trait]
|
|
impl crate::ports::WatchEventCommand for PanicWatchEventCommand {
|
|
async fn save(&self, _: &crate::models::WatchEvent) -> Result<(), DomainError> {
|
|
panic!("PanicWatchEventCommand called")
|
|
}
|
|
async fn update_status(
|
|
&self,
|
|
_: &crate::value_objects::WatchEventId,
|
|
_: crate::models::WatchEventStatus,
|
|
) -> Result<(), DomainError> {
|
|
panic!("PanicWatchEventCommand called")
|
|
}
|
|
async fn update_status_batch(
|
|
&self,
|
|
_: &[crate::value_objects::WatchEventId],
|
|
_: crate::models::WatchEventStatus,
|
|
) -> Result<u64, DomainError> {
|
|
panic!("PanicWatchEventCommand called")
|
|
}
|
|
async fn delete_non_pending_older_than(
|
|
&self,
|
|
_: chrono::NaiveDateTime,
|
|
) -> Result<u64, DomainError> {
|
|
panic!("PanicWatchEventCommand called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicWatchEventQuery;
|
|
|
|
#[async_trait]
|
|
impl crate::ports::WatchEventQuery for PanicWatchEventQuery {
|
|
async fn list_pending(
|
|
&self,
|
|
_: &UserId,
|
|
) -> Result<Vec<crate::models::WatchEvent>, DomainError> {
|
|
panic!("PanicWatchEventQuery called")
|
|
}
|
|
async fn get_by_id(
|
|
&self,
|
|
_: &crate::value_objects::WatchEventId,
|
|
) -> Result<Option<crate::models::WatchEvent>, DomainError> {
|
|
panic!("PanicWatchEventQuery called")
|
|
}
|
|
async fn get_by_ids(
|
|
&self,
|
|
_: &[crate::value_objects::WatchEventId],
|
|
) -> Result<Vec<crate::models::WatchEvent>, DomainError> {
|
|
panic!("PanicWatchEventQuery called")
|
|
}
|
|
async fn find_duplicate(
|
|
&self,
|
|
_: &UserId,
|
|
_: &str,
|
|
_: chrono::NaiveDateTime,
|
|
) -> Result<bool, DomainError> {
|
|
panic!("PanicWatchEventQuery called")
|
|
}
|
|
}
|
|
|
|
pub struct PanicWebhookTokenRepository;
|
|
|
|
#[async_trait]
|
|
impl crate::ports::WebhookTokenRepository for PanicWebhookTokenRepository {
|
|
async fn save(&self, _: &crate::models::WebhookToken) -> Result<(), DomainError> {
|
|
panic!("PanicWebhookTokenRepository called")
|
|
}
|
|
async fn find_by_token_hash(
|
|
&self,
|
|
_: &str,
|
|
) -> Result<Option<crate::models::WebhookToken>, DomainError> {
|
|
panic!("PanicWebhookTokenRepository called")
|
|
}
|
|
async fn list_by_user(
|
|
&self,
|
|
_: &UserId,
|
|
) -> Result<Vec<crate::models::WebhookToken>, DomainError> {
|
|
panic!("PanicWebhookTokenRepository called")
|
|
}
|
|
async fn delete(
|
|
&self,
|
|
_: &crate::value_objects::WebhookTokenId,
|
|
_: &UserId,
|
|
) -> Result<(), DomainError> {
|
|
panic!("PanicWebhookTokenRepository called")
|
|
}
|
|
async fn touch_last_used(
|
|
&self,
|
|
_: &crate::value_objects::WebhookTokenId,
|
|
) -> Result<(), DomainError> {
|
|
panic!("PanicWebhookTokenRepository called")
|
|
}
|
|
}
|